Merge branch 'hotfix-1.5' into develop

include/nana/gui/widgets/menu.hpp

@@ -19,6 +19,8 @@
 
 namespace nana
 {
+	class menu;
+
 	namespace drawerbase
 	{
 		namespace menu
@@ -69,7 +71,12 @@ namespace nana
 					bool checked:1;
 				}flags;
 
-				menu_type		*sub_menu{nullptr};
+				struct
+				{
+					bool			own_creation;	//Indicates the menu_ptr is created by create_sub_menu
+					menu_type*		menu_ptr;
+				}linked;
+
 				std::string	text;
 				event_fn_t	event_handler;
 				checks			style{checks::none};
@@ -117,9 +124,8 @@ namespace nana
 		typedef drawerbase::menu::checks checks;
 
 		typedef drawerbase::menu::renderer_interface renderer_interface;
-		typedef drawerbase::menu::menu_item_type item_type;
+		typedef drawerbase::menu::menu_item_type::item_proxy item_proxy;
-		typedef item_type::item_proxy item_proxy;
+		typedef drawerbase::menu::menu_item_type::event_fn_t event_fn_t;	///< A callback functor type. Prototype: `void(item_proxy&)`
-		typedef item_type::event_fn_t event_fn_t;	///< A callback functor type. Prototype: `void(item_proxy&)`
 
 		menu();										///< The default constructor. NO OTHER CONSTRUCTOR.
 		~menu();
@@ -150,7 +156,7 @@ namespace nana
 		bool enabled(std::size_t pos) const;
 		void erase(std::size_t pos);			 	 ///< Removes the item
 		bool link(std::size_t pos, menu& menu_obj);///< Link a menu to the item as a sub menu.
-		menu * link(std::size_t pos);		 	     ///< Retrieves a linked sub menu of the item.
+		menu * link(std::size_t pos) const;		 	     ///< Retrieves a linked sub menu of the item.
 		menu *create_sub_menu(std::size_t pos);
 		void popup(window owner, int x, int y);     ///< Popup the menu at the owner window. 
 		void popup_await(window owner, int x, int y);

source/gui/detail/window_register.hpp

@@ -111,6 +111,15 @@ namespace nana
 		public:
 			using window_handle_type = basic_window*;
 
+			~window_register()
+			{
+				//Deleting a basic_window if thread never called exec(), the basic_window object
+				//will always stay in trash.
+				//
+				//Empty the trash before destructs window register
+				delete_trash(0);
+			}
+
 			void insert(window_handle_type wd)
 			{
 				if (wd)

source/gui/place.cpp

@@ -632,13 +632,16 @@ namespace nana
 				API::umake_event(e.evt_destroy);
 		}
 
-		void visible(bool vsb)
+		void visible(bool vsb, bool sync_fastened = true)
 		{
 			for (auto & e : elements)
 				API::show_window(e.handle, vsb);
 
-			for (auto & e : fastened)
+			if (sync_fastened)
-				API::show_window(e.handle, vsb);
+			{
+				for (auto & e : fastened)
+					API::show_window(e.handle, vsb);
+			}
 		}
 
 		static event_handle erase_element(std::vector<element_t>& elements, window handle) noexcept
@@ -2571,7 +2574,10 @@ namespace nana
 					}
 				}
 
-				field.second->visible(is_show);
+				//Collocate doesn't sync the visiblity of fastened windows.
+				//This is a feature that allows tabbar panels to be fastened to a same field, the collocate()
+				//shouldn't break the visibility of panels that are maintained by tabbar.
+				field.second->visible(is_show, false);
 			}
 		}
 	}

source/gui/widgets/listbox.cpp

@@ -5376,6 +5376,8 @@ namespace nana
 			if (start_pos < origin.y)
 				origin.y -= ess->item_height();
 
+			ess->lister.erase(_where);
+
 			ess->calc_content_size(false);
 			ess->content_view->change_position(origin.y, false, false);
 			ess->content_view->sync(false);

source/gui/widgets/menu.cpp

@@ -21,7 +21,6 @@
 #include <nana/gui/wvl.hpp>
 #include <nana/paint/text_renderer.hpp>
 #include <cctype>	//introduces tolower
-#include <map>
 #include <vector>
 
 namespace nana
@@ -37,7 +36,8 @@ namespace nana
 				using item_container = std::vector<std::unique_ptr<item_type>>;
 				using iterator = item_container::iterator;
 
-				std::vector<menu_type*>		owner;
+				::nana::menu* owner;
+				std::vector<menu_type*>	links;
 				item_container	items;
 				unsigned max_pixels;
 				unsigned item_pixels;
@@ -103,6 +103,9 @@ namespace nana
 					flags.enabled = true;
 					flags.splitter = true;
 					flags.checked = false;
+
+					linked.own_creation = false;
+					linked.menu_ptr = nullptr;
 				}
 
 				menu_item_type::menu_item_type(std::string text, const event_fn_t& fn)
@@ -111,6 +114,9 @@ namespace nana
 					flags.enabled = true;
 					flags.splitter = false;
 					flags.checked = false;
+
+					linked.own_creation = false;
+					linked.menu_ptr = nullptr;
 				}
 			//end class menu_item_type
 
@@ -209,8 +215,9 @@ namespace nana
 				using event_fn_t = item_type::event_fn_t;
 				using iterator = menu_type::item_container::iterator;
 
-				menu_builder()
+				menu_builder(::nana::menu* owner)
 				{
+					root_.owner = owner;
 					root_.max_pixels = screen::primary_monitor_size().width * 2 / 3;
 					root_.item_pixels = 24;
 					renderer_ = pat::cloneable<renderer_interface>(internal_renderer());
@@ -218,7 +225,37 @@ namespace nana
 
 				~menu_builder()
 				{
-					this->destroy();
+					//Disconnects the link.
+
+					//Clears the all links which are parent of mine
+					for (auto link : root_.links)
+					{
+						for (auto & m : link->items)
+						{
+							if (m->linked.menu_ptr == &root_)
+							{
+								m->linked.own_creation = false;
+								m->linked.menu_ptr = nullptr;
+							}
+						}
+					}
+
+					for (auto & m : root_.items)
+					{
+						if (m->linked.menu_ptr)
+						{
+							for (auto i = m->linked.menu_ptr->links.begin(); i != m->linked.menu_ptr->links.end();)
+							{
+								if ((*i) == &root_)
+									i = m->linked.menu_ptr->links.erase(i);
+								else
+									++i;
+							}
+
+							if (m->linked.own_creation)
+								delete m->linked.menu_ptr->owner;
+						}
+					}
 				}
 
 				void check_style(std::size_t index, checks s)
@@ -270,41 +307,19 @@ namespace nana
 					return root_;
 				}
 
-				bool set_sub_menu(std::size_t pos, menu_type &sub)
+				//Returns false if the linked menu is already existing
+				bool set_linkage(std::size_t pos, menu_type &linked, bool own_creation)
 				{
-					if(root_.items.size() > pos)
+					auto mi = root_.items.at(pos).get();
-					{
-						auto & item = *(root_.items[pos]);
-						if(!item.sub_menu)
-						{
-							item.sub_menu = &sub;
-							sub.owner.emplace_back(&root_);
-							return true;
-						}
-					}
-					return false;
-				}
 
-				void destroy()
+					if (mi->linked.menu_ptr)
-				{
+						return false;
-					for(auto i : root_.owner)
-						for(auto & m : i->items)
-						{
-							if(m->sub_menu == &root_)
-								m->sub_menu = nullptr;
-						}
 
-					for(auto & m : root_.items)
+					mi->linked.menu_ptr = &linked;
-					{
+					mi->linked.own_creation = own_creation;
-						if(m->sub_menu)
+					linked.links.emplace_back(&root_);
-							for(auto i = m->sub_menu->owner.begin(); i != m->sub_menu->owner.end();)
+
-							{
+					return true;
-								if((*i) == &root_)
-									i = m->sub_menu->owner.erase(i);
-								else
-									++i;
-							}
-					}
 				}
 
 				pat::cloneable<renderer_interface>& renderer()
@@ -438,7 +453,7 @@ namespace nana
 							}
 						}
 
-						if (item_ptr->sub_menu)
+						if (item_ptr->linked.menu_ptr)
 							renderer->sub_arrow(graph, nana::point(graph_->width() - 20, item_r.y), item_h_px, attr);
 
 						item_r.y += item_r.height + 1;
@@ -522,7 +537,7 @@ namespace nana
 						std::size_t index = _m_get_index_by_pos(pos.x, pos.y);
 						if (index != state_.active)
 						{
-							if ((index == npos) && items.at(state_.active)->sub_menu && state_.sub_window)
+							if ((index == npos) && items.at(state_.active)->linked.menu_ptr && state_.sub_window)
 								return false;
 
 							state_.active = (index != npos && items.at(index)->flags.splitter) ? npos : index;
@@ -550,7 +565,7 @@ namespace nana
 						return nullptr;
 
 					auto & items = menu_->items;
-					auto sub = items.at(state_.active)->sub_menu;
+					auto sub = items.at(state_.active)->linked.menu_ptr;
 					if (sub)
 					{
 						pos.x = static_cast<int>(graph_->width()) - 2;
@@ -593,7 +608,7 @@ namespace nana
 
 						if (!item_ptr->flags.splitter)
 						{
-							if (item_ptr->sub_menu)
+							if (item_ptr->linked.menu_ptr)
 							{
 								state_.active = index;
 								state_.active_timestamp = nana::system::timestamp();
@@ -901,7 +916,7 @@ namespace nana
 					
 					menu_item_type & item = *(menu->items.at(active));
 
-					if ((!item.flags.enabled) || item.flags.splitter || item.sub_menu)
+					if ((!item.flags.enabled) || item.flags.splitter || item.linked.menu_ptr)
 						return;
 
 					if (checks::highlight == item.style)
@@ -1109,25 +1124,27 @@ namespace nana
 			drawerbase::menu::menu_builder	mbuilder;
 			drawerbase::menu::menu_window *	window_ptr;
 			std::function<void()> destroy_answer;
-			std::map<std::size_t, info> sub_container;
+
+			implement(menu* self):
+				mbuilder{self}
+			{
+			}
 		};
 
 		menu::menu()
-			:impl_(new implement)
+			:impl_(new implement(this))
 		{
 			impl_->window_ptr = nullptr;
 		}
 
 		menu::~menu()
 		{
-			for(auto i = impl_->sub_container.rbegin(); i != impl_->sub_container.rend(); ++i)
+			this->close();
-			{
-				if(i->second.kill)
-					delete i->second.handle;
-			}
 			delete impl_;
 		}
 
+		using item_type = drawerbase::menu::menu_item_type;
+
 		auto menu::append(std::string text_utf8, const menu::event_fn_t& handler) -> item_proxy
 		{
 			std::unique_ptr<item_type> item{ new item_type{ std::move(text_utf8), handler } };
@@ -1139,7 +1156,7 @@ namespace nana
 		{
 			impl_->mbuilder.data().items.emplace_back(new item_type);
 		}
-
+		
 		auto menu::insert(std::size_t pos, std::string text_utf8, const event_fn_t& handler) -> item_proxy
 		{
 			auto & items = impl_->mbuilder.data().items;
@@ -1195,37 +1212,25 @@ namespace nana
 
 		bool menu::link(std::size_t index, menu& menu_obj)
 		{
-			if(impl_->mbuilder.set_sub_menu(index, menu_obj.impl_->mbuilder.data()))
+			return impl_->mbuilder.set_linkage(index, menu_obj.impl_->mbuilder.data(), false);
-			{
-				auto& minfo = impl_->sub_container[index];
-				minfo.handle = &menu_obj;
-				minfo.kill = false;
-				return true;
-			}
-			return false;
 		}
 
-		menu* menu::link(std::size_t index)
+		menu* menu::link(std::size_t index) const
 		{
-			auto i = impl_->sub_container.find(index);
+			auto mi = impl_->mbuilder.data().items.at(index).get();
-			if(i == impl_->sub_container.end())
+
-				return nullptr;
+			if (mi && mi->linked.menu_ptr)
-			return i->second.handle;
+				return mi->linked.menu_ptr->owner;
+
+			return nullptr;
 		}
 
 		menu *menu::create_sub_menu(std::size_t index)
 		{
-			menu * sub = new menu;
+			std::unique_ptr<menu> guard{new menu};
-
+			if (impl_->mbuilder.set_linkage(index, guard->impl_->mbuilder.data(), true))
-			if (this->link(index, *sub))
+				return guard.release();
-			{
+			
-				auto& minfo = impl_->sub_container[index];
-				minfo.handle = sub;
-				minfo.kill = true;
-				return sub;
-			}
-
-			delete sub;
 			return nullptr;
 		}
 

source/gui/widgets/skeletons/content_view.cpp

@@ -92,14 +92,15 @@ namespace nana {
 
 					auto mouse_evt = [this](const arg_mouse& arg)
 					{
-						if (event_code::mouse_move == arg.evt_code)
+						if (event_code::mouse_down == arg.evt_code)
 						{
 							if (!arg.is_left_button())
 								return;
 
-							if ((!this->drag_started) && this->view.view_area().is_hit(arg.pos))
+							this->drag_started = this->view.view_area().is_hit(arg.pos);
-								this->drag_started = true;
+						}
-
+						else if (event_code::mouse_move == arg.evt_code)
+						{
 							if (this->drag_started && this->drive(arg.pos))
 							{
 								tmr.interval(16);
@@ -113,6 +114,7 @@ namespace nana {
 						}
 					};
 
+					API::events(handle).mouse_down.connect_unignorable(mouse_evt);
 					API::events(handle).mouse_move.connect_unignorable(mouse_evt);
 					API::events(handle).mouse_up.connect_unignorable(mouse_evt);
 
@@ -164,11 +166,9 @@ namespace nana {
 					speed_horz = (std::min)(5, (std::max)(speed_horz, -5));
 					speed_vert = (std::min)(5, (std::max)(speed_vert, -5));
 
-					view.move_origin({
+					return view.move_origin({
 						speed_horz, speed_vert
 					});
-
-					return true;
 				}
 
 				void size_changed(bool try_update)
@@ -435,10 +435,12 @@ namespace nana {
 				}
 			}
 
-			void content_view::move_origin(const point& skew)
+			bool content_view::move_origin(const point& skew)
 			{
 				auto imd_area = this->view_area();
 
+				auto pre_origin = impl_->origin;
+
 				impl_->origin.x += skew.x;
 				if (impl_->origin.x + imd_area.width > impl_->content_size.width)
 					impl_->origin.x = static_cast<int>(impl_->content_size.width) - static_cast<int>(imd_area.width);
@@ -451,6 +453,8 @@ namespace nana {
 					impl_->origin.y = static_cast<int>(impl_->content_size.height) - static_cast<int>(imd_area.height);
 
 				if (impl_->origin.y < 0)	impl_->origin.y = 0;
+
+				return (pre_origin != impl_->origin);
 			}
 
 			void content_view::sync(bool try_update)

source/gui/widgets/skeletons/content_view.hpp

@@ -70,7 +70,8 @@ namespace skeletons
 
 		void change_position(int pos, bool aligned, bool horz);
 
-		void move_origin(const point& skew);
+		/// Returns true if the origin is moved
+		bool move_origin(const point& skew);
 
 		void sync(bool try_update);