Merge remote-tracking branch 'nana_jinhao/hotfixes-1.0.2' into hotfixes-1.0.2

include/nana/gui/basis.hpp

@@ -84,6 +84,7 @@ namespace nana
 			end_of_medium = 0x19,	//Ctrl+Y
 			substitute = 0x1A,	//Ctrl+Z
 			escape = 0x1B,
+			space = 0x20,	//Space
 
 			//The following names are intuitive name of ASCII control codes
 			select_all = start_of_headline,

include/nana/gui/detail/basic_window.hpp

@@ -118,9 +118,11 @@ namespace detail
 
 		bool is_ancestor_of(const basic_window* wd) const;
 		bool visible_parents() const;
+		bool displayed() const;
 		bool belong_to_lazy() const;
+		const basic_window * child_caret() const; //Returns a child which owns a caret
 
-		bool is_draw_through() const;	///< Determines whether it is a draw-through window.
+		bool is_draw_through() const;	// Determines whether it is a draw-through window.
 	public:
 		//Override event_holder
 		bool set_events(const std::shared_ptr<general_events>&) override;

include/nana/gui/detail/drawer.hpp

@@ -23,12 +23,18 @@ namespace nana
 {
 	class widget;
 
+	namespace detail
+	{
+		class drawer;
+	}
+
 	class drawer_trigger
 		: ::nana::noncopyable, ::nana::nonmovable
 	{
+		friend class detail::drawer;
 	public:
-		typedef widget&		widget_reference;
-		typedef paint::graphics&	graph_reference;
+		using widget_reference = widget&;
+		using graph_reference = paint::graphics&;
 
 		virtual ~drawer_trigger();
 		virtual void attached(widget_reference, graph_reference);	//none-const
@@ -56,10 +62,11 @@ namespace nana
 		virtual void key_release(graph_reference, const arg_keyboard&);
 		virtual void shortkey(graph_reference, const arg_keyboard&);
 
-		void _m_reset_overrided();
-		bool _m_overrided() const;
 	private:
-		bool overrided_{false};
+		void _m_reset_overrided();
+		bool _m_overrided(event_code) const;
+	private:
+		unsigned overrided_{ 0xFFFFFFFF };
 	};
 
 	namespace detail
@@ -83,7 +90,7 @@ namespace nana
 
 			enum class method_state
 			{
-				unknown,
+				pending,
 				overrided,
 				not_overrided
 			};
@@ -128,31 +135,27 @@ namespace nana
 			template<typename Arg, typename Mfptr>
 			void _m_emit(event_code evt_code, const Arg& arg, Mfptr mfptr)
 			{
-				if (realizer_)
+				const int pos = static_cast<int>(evt_code);
+				if (realizer_ && (method_state::not_overrided != mth_state_[pos]))
 				{
-					const int pos = static_cast<int>(evt_code);
-					if (method_state::not_overrided != mth_state_[pos])
+					_m_bground_pre();
+
+					if (method_state::pending == mth_state_[pos])
 					{
-						_m_bground_pre();
+						(realizer_->*mfptr)(graphics, arg);
+						
+						//Check realizer, when the window is closed in that event handler, the drawer will be
+						//detached and realizer will be a nullptr
+						if(realizer_)
+							mth_state_[pos] = (realizer_->_m_overrided(evt_code) ? method_state::overrided : method_state::not_overrided);
+					}
+					else
+						(realizer_->*mfptr)(graphics, arg);
 
-						if (method_state::unknown == mth_state_[pos])
-						{
-							realizer_->_m_reset_overrided();
-							(realizer_->*mfptr)(graphics, arg);
-							
-							//Check realizer, when the window is closed in that event handler, the drawer will be
-							//detached and realizer will be a nullptr
-							if(realizer_)
-								mth_state_[pos] = (realizer_->_m_overrided() ? method_state::overrided : method_state::not_overrided);
-						}
-						else
-							(realizer_->*mfptr)(graphics, arg);
-
-						if (_m_lazy_decleared())
-						{
-							_m_draw_dynamic_drawing_object();
-							_m_bground_end();
-						}
+					if (_m_lazy_decleared())
+					{
+						_m_draw_dynamic_drawing_object();
+						_m_bground_end();
 					}
 				}
 			}

include/nana/gui/detail/effects_renderer.hpp

@@ -23,7 +23,7 @@ namespace nana{
 				return object;
 			}
 
-			std::size_t weight() const
+			unsigned weight() const
 			{
 				return 2;
 			}
@@ -55,22 +55,23 @@ namespace nana{
 				}
 			}
 
-			bool render(core_window_t * wd, bool forced, const rectangle* update_area = nullptr)
+			void render(core_window_t * wd, bool forced, const rectangle* update_area = nullptr)
 			{
-				bool rendered = false;
-				core_window_t * root_wd = wd->root_widget;
-				auto & nimbus = root_wd->other.attribute.root->effects_edge_nimbus;
+				bool copy_separately = true;
+				std::vector<std::pair<rectangle, core_window_t*>>	rd_set;
 
-				if(nimbus.size())
+				if (wd->root_widget->other.attribute.root->effects_edge_nimbus.size())
 				{
-					core_window_t * focused = root_wd->other.attribute.root->focus;
-					native_window_type native = root_wd->root;
-					std::size_t pixels = weight();
+					auto root_wd = wd->root_widget;
+
+					auto & nimbus = root_wd->other.attribute.root->effects_edge_nimbus;
+
+					auto focused = root_wd->other.attribute.root->focus;
+
+					const unsigned pixels = weight();
 
 					auto graph = root_wd->root_graph;
 
-					std::vector<core_window_t*> erase;
-					std::vector<std::pair<rectangle,core_window_t*>>	rd_set;
 					nana::rectangle r;
 					for(auto & action : nimbus)
 					{
@@ -80,11 +81,11 @@ namespace nana{
 							{
 								if (update_area)
 									::nana::overlap(*update_area, rectangle(r), r);
-								rendered = true;
+								copy_separately = false;
 							}
 
 							//Avoiding duplicated rendering. If the window is declared to lazy refresh, it should be rendered.
-							if ((forced && (action.window == wd)) || !action.rendered || (action.window->other.upd_state == core_window_t::update_state::refresh))
+							if ((forced && (action.window == wd)) || (focused == action.window) || !action.rendered || (action.window->other.upd_state == core_window_t::update_state::refresh))
 							{
 								rd_set.emplace_back(r, action.window);
 								action.rendered = true;
@@ -93,29 +94,36 @@ namespace nana{
 						else if(action.rendered)
 						{
 							action.rendered = false;
-							erase.push_back(action.window);
+
+							if (action.window == wd)
+								copy_separately = false;
+
+							::nana::rectangle erase_r(
+									action.window->pos_root.x - static_cast<int>(pixels),
+									action.window->pos_root.y - static_cast<int>(pixels),
+									static_cast<unsigned>(action.window->dimension.width + (pixels << 1)),
+									static_cast<unsigned>(action.window->dimension.height + (pixels << 1))
+								);
+
+							graph->paste(root_wd->root, erase_r, erase_r.x, erase_r.y);
 						}
 					}
-
-					//Erase
-					for(auto el : erase)
-					{
-						if(el == wd)
-							rendered = true;
-
-						r.x = el->pos_root.x - static_cast<int>(pixels);
-						r.y = el->pos_root.y - static_cast<int>(pixels);
-						r.width = static_cast<unsigned>(el->dimension.width + (pixels << 1));
-						r.height = static_cast<unsigned>(el->dimension.height + (pixels << 1));
-
-						graph->paste(native, r, r.x, r.y);
-					}
-
-					//Render
-					for (auto & rd : rd_set)
-						_m_render_edge_nimbus(rd.second, rd.first);
 				}
-				return rendered;
+
+				if (copy_separately)
+				{
+					rectangle vr;
+					if (window_layer::read_visual_rectangle(wd, vr))
+					{
+						if (update_area)
+							::nana::overlap(*update_area, rectangle(vr), vr);
+						wd->root_graph->paste(wd->root, vr, vr.x, vr.y);
+					}
+				}
+
+				//Render
+				for (auto & rd : rd_set)
+					_m_render_edge_nimbus(rd.second, rd.first);
 			}
 		private:
 			static bool _m_edge_nimbus(core_window_t * focused_wd, core_window_t * wd)
@@ -134,8 +142,8 @@ namespace nana{
 				nana::rectangle good_r;
 				if(overlap(r, wd->root_graph->size(), good_r))
 				{
-					if(	(good_r.x < wd->pos_root.x) || (good_r.y < wd->pos_root.y) ||
-						(good_r.x + good_r.width > visual.x + visual.width) || (good_r.y + good_r.height > visual.y + visual.height))
+					if ((good_r.x < wd->pos_root.x) || (good_r.y < wd->pos_root.y) || 
+						(good_r.right() > visual.right()) || (good_r.bottom() > visual.bottom()))
 					{
 						auto graph = wd->root_graph;
 						nana::paint::pixel_buffer pixbuf(graph->handle(), r);