From 830839ae27f71f3d20cccccf2625d435aeeac844 Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Wed, 28 Sep 2016 07:47:53 +0800
Subject: [PATCH 01/16] add place::div() to return the div text

introduce keywords 'undisplayed' and 'invisible' into div-text
---
 include/nana/gui/place.hpp |   3 +-
 source/gui/place.cpp       | 159 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 159 insertions(+), 3 deletions(-)

diff --git a/include/nana/gui/place.hpp b/include/nana/gui/place.hpp
index dbc12111..176c7bd4 100644
--- a/include/nana/gui/place.hpp
+++ b/include/nana/gui/place.hpp
@@ -112,7 +112,8 @@ namespace nana
 		void bind(window handle);
 		window window_handle() const;
         
-		void div(const char* s);              ///< Divides the attached widget into fields.
+		void div(const char* s);			///< Divides the attached widget into fields.
+		const std::string& div() const noexcept;	///< Returns div-text that depends on fields status.
 		void modify(const char* field_name, const char* div_text);	///< Modifies a specified field.
 
 		field_reference field(const char* name);///< Returns a field with the specified name.
diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 1af71f0c..739b80cf 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -56,7 +56,7 @@ namespace nana
 			{
 				div_start, div_end, splitter,
 				identifier, dock, vert, grid, number, array, reparray,
-				weight, gap, margin, arrange, variable, repeated, min_px, max_px, left, right, top, bottom,
+				weight, gap, margin, arrange, variable, repeated, min_px, max_px, left, right, top, bottom, undisplayed, invisible,
 				collapse, parameters,
 				equal,
 				eof, error
@@ -275,7 +275,7 @@ namespace nana
 							_m_throw_error("a parameter list is required after 'collapse'");
 						return token::collapse;
 					}
-					else if ("left" == idstr_ || "right" == idstr_ || "top" == idstr_ || "bottom" == idstr_)
+					else if ("left" == idstr_ || "right" == idstr_ || "top" == idstr_ || "bottom" == idstr_ || "undisplayed" == idstr_ || "invisible" == idstr_)
 					{
 						switch (idstr_.front())
 						{
@@ -283,8 +283,11 @@ namespace nana
 						case 'r': return token::right;
 						case 't': return token::top;
 						case 'b': return token::bottom;
+						case 'u': return token::undisplayed;
+						case 'i': return token::invisible;
 						}
 					}
+
 					return token::identifier;
 				}
 
@@ -442,6 +445,8 @@ namespace nana
 
 		window window_handle{nullptr};
 		event_handle event_size_handle{nullptr};
+
+		std::string div_text;
 		std::unique_ptr<division> root_division;
 		std::map<std::string, field_gather*> fields;
 		std::map<std::string, field_dock*> docks;
@@ -2147,6 +2152,9 @@ namespace nana
 		std::vector<std::unique_ptr<division>> children;
 		::nana::direction div_dir = ::nana::direction::west;
 
+		bool undisplayed = false;
+		bool invisible = false;
+
 		for (token tk = tknizer.read(); tk != token::eof; tk = tknizer.read())
 		{
 			bool exit_for = false;
@@ -2305,6 +2313,10 @@ namespace nana
 				div_dir = ::nana::direction::north; break;
 			case token::bottom:
 				div_dir = ::nana::direction::south; break;
+			case token::undisplayed:
+				undisplayed = true; break;
+			case token::invisible:
+				invisible = true; break;
 			default:	break;
 			}
 			if (exit_for)
@@ -2430,6 +2442,9 @@ namespace nana
 		div->children.swap(children);
 		div->margin = std::move(margin);
 		div->dir = div_dir;
+
+		div->display = !undisplayed;
+		div->visible = !(undisplayed || invisible);
 		return div;
 	}
 
@@ -2593,6 +2608,7 @@ namespace nana
 			impl_->connect(div.get());
 			impl_->root_division.reset();	//clear atachments div-fields
 			impl_->root_division.swap(div);
+			impl_->div_text.assign(s);
 		}
 		catch (...)
 		{
@@ -2601,6 +2617,11 @@ namespace nana
 		}
 	}
 
+	const std::string& place::div() const noexcept
+	{
+		return impl_->div_text;
+	}
+
 	void place::modify(const char* name, const char* div_text)
 	{
 		if (nullptr == div_text)
@@ -2698,6 +2719,133 @@ namespace nana
 		return *p;
 	}
 
+	bool is_idchar(int ch)
+	{
+		return ('_' == ch || isalpha(ch) || isalnum(ch));
+	}
+
+	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
+	{
+		const auto len = std::strlen(idstr);
+		auto pos = text.find(idstr, off);
+		if (text.npos == pos)
+			return text.npos;
+
+		if (pos && is_idchar(text[pos - 1]))
+			return text.npos;
+
+		if ((pos + len < text.length()) && is_idchar(text[pos + len]))
+			return text.npos;
+
+		return pos;
+	}
+
+	void update_div(std::string& div, const char* field, const char* attr, bool insertion)
+	{
+		const auto fieldname_pos = find_idstr(div, field);
+		if (div.npos == fieldname_pos)
+			return;
+
+		//Get the bounds of this field
+		std::size_t begin = 0, end = 0;
+
+		//Find the begin
+		int level = 0;
+		std::size_t pos = fieldname_pos;
+		while (true)
+		{
+			pos = div.find_last_of("<>", pos);
+			if (div.npos == pos)
+				return;
+
+			if ('<' == div[pos])
+			{
+				if (0 == level)
+				{
+					begin = pos;
+					break;
+				}
+				else
+					--level;
+			}
+			else
+				++level;
+		}
+
+		//Find the end
+		level = 0;
+		pos = fieldname_pos;
+		while (true)
+		{
+			pos = div.find_first_of("<>", pos);
+			if (div.npos == pos)
+				return;
+
+			if ('>' == div[pos])
+			{
+				if (0 == level)
+				{
+					end = pos + 1;
+					break;
+				}
+				else
+					--level;
+			}
+			else
+				++level;
+		}
+
+		auto fieldstr = div.substr(begin + 1, end - begin - 2);
+
+		//Search the attribute
+		for (pos = 0; true; ++pos)
+		{
+			pos = find_idstr(fieldstr, attr, pos);
+			if (fieldstr.npos == pos)
+				break;
+
+			//Check if the attr is belong to this field.
+			level = 0;
+			std::size_t off = pos;
+			while (true)
+			{
+				off = fieldstr.find_last_of("<>", off);
+				if (fieldstr.npos == off)
+					break;
+
+				if ('>' == fieldstr[off])
+					++level;
+				else
+					--level;
+
+				if (0 == off)
+					break;
+				--off;
+			}
+
+			if (0 == level)
+				break;
+		}
+
+		if (fieldstr.npos == pos)
+		{
+			//There is not an attribute
+			if (insertion)
+				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
+		}
+		else
+		{
+			//There is an attribute
+			if (!insertion)
+			{
+				div.erase(begin + pos + 1, std::strlen(attr));
+
+				if ((div[begin + pos] == div[begin + pos + 1]) && (' ' == div[begin + pos]))
+					div.erase(begin + pos, 1);
+			}
+		}
+	}
+
 	void place::field_visible(const char* name, bool vsb)
 	{
 		if (!name)	name = "";
@@ -2707,7 +2855,10 @@ namespace nana
 
 		auto div = impl_->search_div_name(impl_->root_division.get(), name);
 		if (div)
+		{
 			div->set_visible(vsb);
+			update_div(impl_->div_text, name, "invisible", !vsb);
+		}
 	}
 
 	bool place::field_visible(const char* name) const
@@ -2730,7 +2881,11 @@ namespace nana
 
 		auto div = impl_->search_div_name(impl_->root_division.get(), name);
 		if (div)
+		{
+			update_div(impl_->div_text, name, "invisible", false);
+			update_div(impl_->div_text, name, "undisplayed", !dsp);
 			div->set_display(dsp);
+		}
 	}
 
 	bool place::field_display(const char* name) const

From 3c2b36ead8857ad43caab68e7401adbef14e2ab2 Mon Sep 17 00:00:00 2001
From: dankan1890 <mewuidev2@gmail.com>
Date: Thu, 29 Sep 2016 13:54:12 +0200
Subject: [PATCH 02/16] place::modify() now correctly updates the
 place::div_text.

---
 include/nana/gui/place.hpp |  302 +-
 source/gui/place.cpp       | 6020 ++++++++++++++++++------------------
 2 files changed, 3166 insertions(+), 3156 deletions(-)

diff --git a/include/nana/gui/place.hpp b/include/nana/gui/place.hpp
index 176c7bd4..f6359236 100644
--- a/include/nana/gui/place.hpp
+++ b/include/nana/gui/place.hpp
@@ -1,151 +1,151 @@
-/*
- *	An Implementation of Place for Layout
- *	Nana C++ Library(http://www.nanapro.org)
- *	Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
- *
- *	Distributed under the Boost Software License, Version 1.0.
- *	(See accompanying file LICENSE_1_0.txt or copy at
- *	http://www.boost.org/LICENSE_1_0.txt)
- *
- *	@file: nana/gui/place.cpp
- *
- *	@contributions:
- *	min/max and splitter bar initial weight by Ariel Vina-Rodriguez.
- */
-
-#ifndef NANA_GUI_PLACE_HPP
-#define NANA_GUI_PLACE_HPP
-#include <nana/push_ignore_diagnostic>
-#include <nana/gui/basis.hpp>
-#include <memory>
-#include <functional>
-
-namespace nana
-{
-	class widget;
-	namespace detail
-	{
-		class place_agent
-		{
-		public:
-			virtual ~place_agent() = default;
-			virtual std::unique_ptr<nana::widget> create(nana::window) const = 0;
-		};
-	}
-
-	template<typename Widget>
-	class agent
-		: public detail::place_agent
-	{
-	public:
-		agent(std::function<void(Widget&)> initializer)
-			: init_(std::move(initializer))
-		{}
-
-		agent(const char* text)
-			: text_(text)
-		{
-			throw_not_utf8(text);
-		}
-
-		agent(std::string text, std::function<void(Widget&)> initializer = {})
-			: text_(std::move(text)), init_(std::move(initializer))
-		{
-			throw_not_utf8(text_);
-		}
-
-	private:
-		std::unique_ptr<nana::widget> create(nana::window handle) const override
-		{
-			std::unique_ptr<Widget> ptr(new Widget(handle));
-			ptr->caption(text_);
-			if (init_)
-				init_(*ptr);
-			return std::move(ptr);
-		}
-	private:
-		std::string text_;
-		std::function<void(Widget&)> init_;
-	};
-
-    ///  Layout managment - an object of class place is attached to a widget, and it automatically positions and resizes the children widgets.
-	class place
-		: ::nana::noncopyable
-	{
-		struct implement;
-
-		class field_interface
-		{
-			field_interface(const field_interface&) = delete;
-			field_interface& operator=(const field_interface&) = delete;
-			field_interface(field_interface&&) = delete;
-			field_interface& operator=(field_interface&&) = delete;
-		public:
-			field_interface() = default;
-			virtual ~field_interface() = default;
-			virtual field_interface& operator<<(const char* label) = 0;
-			virtual field_interface& operator<<(std::string label) = 0;
-			virtual field_interface& operator<<(window) = 0;
-			virtual field_interface& fasten(window) = 0;
-			
-			template<typename Widget>
-			field_interface& operator<<(const agent<Widget>& ag)
-			{
-				_m_add_agent(ag);
-				return *this;
-			}
-		private:
-			virtual void _m_add_agent(const detail::place_agent&) = 0;
-		};
-	public:
-        ///  reference to a field manipulator which refers to a field object created by place 
-		using field_reference = field_interface &;
-
-		place();
-		place(window);///< Attaches to a specified widget.
-		~place();
-
-		/** @brief Bind to a window
-		 *	@param handle	A handle to a window which the place wants to attach.
-		 *	@remark	It will throw an exception if the place has already binded to a window.
-		 */
-		void bind(window handle);
-		window window_handle() const;
-        
-		void div(const char* s);			///< Divides the attached widget into fields.
-		const std::string& div() const noexcept;	///< Returns div-text that depends on fields status.
-		void modify(const char* field_name, const char* div_text);	///< Modifies a specified field.
-
-		field_reference field(const char* name);///< Returns a field with the specified name.
-
-		void field_visible(const char* field_name, bool visible); ///<<Shows/Hides an existing field.
-		bool field_visible(const char* field_name) const;	///<Determines whether the specified field is visible.
-
-		void field_display(const char* field_name, bool display); ///<Displays/Discards an existing field.
-		bool field_display(const char* field_name) const;	///<Determines whether the specified field is displayed.
-
-		void collocate();                     ///< Layouts the widgets.
-
- 		void erase(window handle);				///< Erases a window from field.
-
-		field_reference operator[](const char* name); ///< Returns a field with the specified name. Equal to field();
-
-		/// Add a panel factory
-		template<typename Panel, typename ...Args>
-		place& dock(const std::string& dockname, const std::string& factory_name, Args&& ... args)
-		{
-			return dock(dockname, factory_name, std::bind([](window parent, Args & ... args)
-			{
-				return std::unique_ptr<widget>(new Panel(parent, std::forward<Args>(args)...));
-			}, std::placeholders::_1, args...));
-		}
-
-		place& dock(const std::string& dockname, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory);
-		widget* dock_create(const std::string& factory);
-	private:
-		implement * impl_;
-	};
-}//end namespace nana
-#include <nana/pop_ignore_diagnostic>
-
-#endif //#ifndef NANA_GUI_PLACE_HPP
+/*
+ *	An Implementation of Place for Layout
+ *	Nana C++ Library(http://www.nanapro.org)
+ *	Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
+ *
+ *	Distributed under the Boost Software License, Version 1.0.
+ *	(See accompanying file LICENSE_1_0.txt or copy at
+ *	http://www.boost.org/LICENSE_1_0.txt)
+ *
+ *	@file: nana/gui/place.cpp
+ *
+ *	@contributions:
+ *	min/max and splitter bar initial weight by Ariel Vina-Rodriguez.
+ */
+
+#ifndef NANA_GUI_PLACE_HPP
+#define NANA_GUI_PLACE_HPP
+#include <nana/push_ignore_diagnostic>
+#include <nana/gui/basis.hpp>
+#include <memory>
+#include <functional>
+
+namespace nana
+{
+	class widget;
+	namespace detail
+	{
+		class place_agent
+		{
+		public:
+			virtual ~place_agent() = default;
+			virtual std::unique_ptr<nana::widget> create(nana::window) const = 0;
+		};
+	}
+
+	template<typename Widget>
+	class agent
+		: public detail::place_agent
+	{
+	public:
+		agent(std::function<void(Widget&)> initializer)
+			: init_(std::move(initializer))
+		{}
+
+		agent(const char* text)
+			: text_(text)
+		{
+			throw_not_utf8(text);
+		}
+
+		agent(std::string text, std::function<void(Widget&)> initializer = {})
+			: text_(std::move(text)), init_(std::move(initializer))
+		{
+			throw_not_utf8(text_);
+		}
+
+	private:
+		std::unique_ptr<nana::widget> create(nana::window handle) const override
+		{
+			std::unique_ptr<Widget> ptr(new Widget(handle));
+			ptr->caption(text_);
+			if (init_)
+				init_(*ptr);
+			return std::move(ptr);
+		}
+	private:
+		std::string text_;
+		std::function<void(Widget&)> init_;
+	};
+
+    ///  Layout managment - an object of class place is attached to a widget, and it automatically positions and resizes the children widgets.
+	class place
+		: ::nana::noncopyable
+	{
+		struct implement;
+
+		class field_interface
+		{
+			field_interface(const field_interface&) = delete;
+			field_interface& operator=(const field_interface&) = delete;
+			field_interface(field_interface&&) = delete;
+			field_interface& operator=(field_interface&&) = delete;
+		public:
+			field_interface() = default;
+			virtual ~field_interface() = default;
+			virtual field_interface& operator<<(const char* label) = 0;
+			virtual field_interface& operator<<(std::string label) = 0;
+			virtual field_interface& operator<<(window) = 0;
+			virtual field_interface& fasten(window) = 0;
+			
+			template<typename Widget>
+			field_interface& operator<<(const agent<Widget>& ag)
+			{
+				_m_add_agent(ag);
+				return *this;
+			}
+		private:
+			virtual void _m_add_agent(const detail::place_agent&) = 0;
+		};
+	public:
+        ///  reference to a field manipulator which refers to a field object created by place 
+		using field_reference = field_interface &;
+
+		place();
+		place(window);///< Attaches to a specified widget.
+		~place();
+
+		/** @brief Bind to a window
+		 *	@param handle	A handle to a window which the place wants to attach.
+		 *	@remark	It will throw an exception if the place has already binded to a window.
+		 */
+		void bind(window handle);
+		window window_handle() const;
+        
+		void div(const char* s);			///< Divides the attached widget into fields.
+		const std::string& div() const noexcept;	///< Returns div-text that depends on fields status.
+		void modify(const char* field_name, const char* div_text);	///< Modifies a specified field.
+
+		field_reference field(const char* name);///< Returns a field with the specified name.
+
+		void field_visible(const char* field_name, bool visible) const; ///<<Shows/Hides an existing field.
+		bool field_visible(const char* field_name) const;	///<Determines whether the specified field is visible.
+
+		void field_display(const char* field_name, bool display) const; ///<Displays/Discards an existing field.
+		bool field_display(const char* field_name) const;	///<Determines whether the specified field is displayed.
+
+		void collocate();                     ///< Layouts the widgets.
+
+ 		void erase(window handle);				///< Erases a window from field.
+
+		field_reference operator[](const char* name); ///< Returns a field with the specified name. Equal to field();
+
+		/// Add a panel factory
+		template<typename Panel, typename ...Args>
+		place& dock(const std::string& dockname, const std::string& factory_name, Args&& ... args)
+		{
+			return dock(dockname, factory_name, std::bind([](window parent, Args & ... args)
+			{
+				return std::unique_ptr<widget>(new Panel(parent, std::forward<Args>(args)...));
+			}, std::placeholders::_1, args...));
+		}
+
+		place& dock(const std::string& dockname, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory);
+		widget* dock_create(const std::string& factory);
+	private:
+		implement * impl_;
+	};
+}//end namespace nana
+#include <nana/pop_ignore_diagnostic>
+
+#endif //#ifndef NANA_GUI_PLACE_HPP
diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 739b80cf..77f89ba2 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -1,3005 +1,3015 @@
-/*
- *	An Implementation of Place for Layout
- *	Nana C++ Library(http://www.nanapro.org)
- *	Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
- *
- *	Distributed under the Boost Software License, Version 1.0.
- *	(See accompanying file LICENSE_1_0.txt or copy at
- *	http://www.boost.org/LICENSE_1_0.txt)
- *
- *	@file: nana/gui/place.cpp
- *	@contributors: Ariel Vina-Rodriguez
- */
-
-#include <cfloat>
-#include <cmath>
-#include <map>
-#include <deque>
-#include <algorithm>
-#include <nana/push_ignore_diagnostic>
-#include <nana/deploy.hpp>
-#include <nana/gui/place.hpp>
-#include <nana/gui/programming_interface.hpp>
-#include <nana/gui/widgets/label.hpp>
-#include <nana/gui/widgets/panel.hpp>
-#include <nana/gui/dragger.hpp>
-#include <nana/gui/drawing.hpp>
-
-#include <memory>
-#include <limits>	//numeric_limits
-#include <cstdlib>	//std::abs
-#include <cstring>	//std::memset
-
-#include "place_parts.hpp"
-
-namespace nana
-{
-	namespace place_parts
-	{
-		//check the name
-		void check_field_name(const char* name)
-		{
-			if (*name && (*name != '_' && !(('a' <= *name && *name <= 'z') || ('A' <= *name && *name <= 'Z'))))
-				throw std::invalid_argument("nana.place: bad field name");
-		}
-	}//end namespace place_parts
-
-	typedef place_parts::number_t number_t;
-	typedef place_parts::repeated_array repeated_array;
-
-	namespace place_parts
-	{
-		class tokenizer
-		{
-		public:
-			enum class token
-			{
-				div_start, div_end, splitter,
-				identifier, dock, vert, grid, number, array, reparray,
-				weight, gap, margin, arrange, variable, repeated, min_px, max_px, left, right, top, bottom, undisplayed, invisible,
-				collapse, parameters,
-				equal,
-				eof, error
-			};
-
-			tokenizer(const char* p)
-				: divstr_(p), sp_(p)
-			{}
-
-			const std::string& idstr() const
-			{
-				return idstr_;
-			}
-
-			number_t number() const
-			{
-				return number_;
-			}
-
-			std::vector<number_t>& array()
-			{
-				return array_;
-			}
-
-			repeated_array&& reparray()
-			{
-				return std::move(reparray_);
-			}
-
-			std::vector<number_t>& parameters()
-			{
-				return parameters_;
-			}
-
-			std::size_t pos() const
-			{
-				return (sp_ - divstr_);
-			}
-
-			std::string pos_str() const
-			{
-				return std::to_string(pos());
-			}
-
-			token read()
-			{
-				sp_ = _m_eat_whitespace(sp_);
-
-				std::size_t readbytes = 0;
-				switch (*sp_)
-				{
-				case '\0':
-					return token::eof;
-				case '|':
-					++sp_;
-					readbytes = _m_number(sp_, false);
-					sp_ += readbytes;
-					return token::splitter;
-				case '=':
-					++sp_;
-					return token::equal;
-				case '<':
-					++sp_;
-					return token::div_start;
-				case '>':
-					++sp_;
-					return token::div_end;
-				case '[':
-					array_.clear();
-					sp_ = _m_eat_whitespace(sp_ + 1);
-					if (*sp_ == ']')
-					{
-						++sp_;
-						return token::array;
-					}
-					else
-					{
-						//When search the repeated.
-						bool repeated = false;
-
-						while (true)
-						{
-							sp_ = _m_eat_whitespace(sp_);
-							auto tk = read();
-							if (token::number != tk && token::variable != tk && token::repeated != tk)
-								_m_throw_error("invalid array element");
-
-							if (!repeated)
-							{
-								switch (tk)
-								{
-								case token::number:
-									array_.push_back(number_);
-									break;
-								case token::variable:
-									array_.push_back({});
-									break;
-								default:
-									repeated = true;
-									reparray_.repeated();
-									reparray_.assign(std::move(array_));
-								}
-							}
-
-							sp_ = _m_eat_whitespace(sp_);
-							char ch = *sp_++;
-
-							if (ch == ']')
-								return (repeated ? token::reparray : token::array);
-
-							if (ch != ',')
-								_m_throw_error("invalid array");
-						}
-					}
-					break;
-				case '(':
-					parameters_.clear();
-					sp_ = _m_eat_whitespace(sp_ + 1);
-					if (*sp_ == ')')
-					{
-						++sp_;
-						return token::parameters;
-					}
-
-					while (true)
-					{
-						if (token::number == read())
-							parameters_.push_back(number_);
-						else
-							_m_throw_error("invalid parameter.");
-
-						sp_ = _m_eat_whitespace(sp_);
-						char ch = *sp_++;
-
-						if (ch == ')')
-							return token::parameters;
-
-						if (ch != ',')
-							_m_throw_error("invalid parameter.");
-					}
-					break;
-				case '.': case '-':
-					if (*sp_ == '-')
-					{
-						readbytes = _m_number(sp_ + 1, true);
-						if (readbytes)
-							++readbytes;
-					}
-					else
-						readbytes = _m_number(sp_, false);
-
-					if (readbytes)
-					{
-						sp_ += readbytes;
-						return token::number;
-					}
-					else
-						_m_throw_error("invalid character '" + std::string(1, *sp_) + "'");
-					break;
-				default:
-					if ('0' <= *sp_ && *sp_ <= '9')
-					{
-						readbytes = _m_number(sp_, false);
-						if (readbytes)
-						{
-							sp_ += readbytes;
-							return token::number;
-						}
-					}
-					break;
-				}
-
-				if ('_' == *sp_ || isalpha(*sp_))
-				{
-					const char * idstart = sp_++;
-
-					while ('_' == *sp_ || isalpha(*sp_) || isalnum(*sp_))
-						++sp_;
-
-					idstr_.assign(idstart, sp_);
-
-					if ("weight" == idstr_ || "min" == idstr_ || "max" == idstr_)
-					{
-						auto ch = idstr_[1];
-						_m_attr_number_value();
-						switch (ch)
-						{
-						case 'e': return token::weight;
-						case 'i': return token::min_px;
-						case 'a': return token::max_px;
-						}
-					}
-					else if ("dock" == idstr_)
-						return token::dock;
-					else if ("vertical" == idstr_ || "vert" == idstr_)
-						return token::vert;
-					else if ("variable" == idstr_ || "repeated" == idstr_)
-						return ('v' == idstr_[0] ? token::variable : token::repeated);
-					else if ("arrange" == idstr_ || "gap" == idstr_)
-					{
-						auto ch = idstr_[0];
-						_m_attr_reparray();
-						return ('a' == ch ? token::arrange : token::gap);
-					}
-					else if ("grid" == idstr_ || "margin" == idstr_)
-					{
-						auto idstr = idstr_;
-						if (token::equal != read())
-							_m_throw_error("an equal sign is required after '" + idstr + "'");
-
-						return ('g' == idstr[0] ? token::grid : token::margin);
-					}
-					else if ("collapse" == idstr_)
-					{
-						if (token::parameters != read())
-							_m_throw_error("a parameter list is required after 'collapse'");
-						return token::collapse;
-					}
-					else if ("left" == idstr_ || "right" == idstr_ || "top" == idstr_ || "bottom" == idstr_ || "undisplayed" == idstr_ || "invisible" == idstr_)
-					{
-						switch (idstr_.front())
-						{
-						case 'l': return token::left;
-						case 'r': return token::right;
-						case 't': return token::top;
-						case 'b': return token::bottom;
-						case 'u': return token::undisplayed;
-						case 'i': return token::invisible;
-						}
-					}
-
-					return token::identifier;
-				}
-
-				std::string err = "an invalid character '";
-				err += *sp_;
-				err += "'";
-
-				_m_throw_error(err);
-				return token::error;	//Useless, just for syntax correction.
-			}
-		private:
-			void _m_throw_error(char err_char)
-			{
-				std::string str = "place: invalid character '";
-				str += err_char;
-				str += '\'';
-				_m_throw_error(str);
-			}
-
-			void _m_throw_error(const std::string& err)
-			{
-				throw std::runtime_error("nana::place: " + err + " at " + std::to_string(static_cast<unsigned>(sp_ - divstr_)));
-			}
-
-			void _m_attr_number_value()
-			{
-				if (token::equal != read())
-					_m_throw_error("an equal sign is required after '" + idstr_ + "'");
-
-				auto p = _m_eat_whitespace(sp_);
-
-				auto neg_ptr = p;
-				if ('-' == *p)
-					++p;
-
-				auto len = _m_number(p, neg_ptr != p);
-				if (0 == len)
-					_m_throw_error("the '" + idstr_ + "' requires a number(integer or real or percent)");
-
-				sp_ += len + (p - sp_);
-			}
-
-			void _m_attr_reparray()
-			{
-				auto idstr = idstr_;
-				if (token::equal != read())
-					_m_throw_error("an equal sign is required after '" + idstr + "'");
-
-				sp_ = _m_eat_whitespace(sp_);
-
-				reparray_.reset();
-				auto tk = read();
-				switch (tk)
-				{
-				case token::number:
-					reparray_.push(number());
-					reparray_.repeated();
-					break;
-				case token::array:
-					reparray_.assign(std::move(array_));
-					break;
-				case token::reparray:
-					break;
-				default:
-					_m_throw_error("a (repeated) array is required after '" + idstr + "'");
-				}
-			}
-
-			static const char* _m_eat_whitespace(const char* sp)
-			{
-				while (*sp && !isgraph(*sp))
-					++sp;
-				return sp;
-			}
-
-			std::size_t _m_number(const char* sp, bool negative)
-			{
-				const char* allstart = sp;
-				sp = _m_eat_whitespace(sp);
-
-				number_.assign(0);
-
-				bool gotcha = false;
-				int integer = 0;
-				double real = 0;
-				//read the integral part.
-				const char* istart = sp;
-				while ('0' <= *sp && *sp <= '9')
-				{
-					integer = integer * 10 + (*sp - '0');
-					++sp;
-				}
-				const char* iend = sp;
-
-				if ('.' == *sp)
-				{
-					double div = 1;
-					const char* rstart = ++sp;
-					while ('0' <= *sp && *sp <= '9')
-					{
-						real += (*sp - '0') / (div *= 10);
-						++sp;
-					}
-
-					if (rstart != sp)
-					{
-						real += integer;
-						number_.assign(negative ? -real : real);
-						gotcha = true;
-					}
-				}
-				else if (istart != iend)
-				{
-					number_.assign(negative ? -integer : integer);
-					gotcha = true;
-				}
-
-				if (gotcha)
-				{
-					sp = _m_eat_whitespace(sp);
-					if ('%' == *sp)
-					{
-						if (number_t::kind::integer == number_.kind_of())
-							number_.assign_percent(number_.integer());
-						return sp - allstart + 1;
-					}
-					return sp - allstart;
-				}
-				number_.reset();
-				return 0;
-			}
-		private:
-			const char* divstr_;
-			const char* sp_;
-			std::string idstr_;
-			number_t number_;
-			std::vector<number_t> array_;
-			repeated_array		reparray_;
-			std::vector<number_t> parameters_;
-		};	//end class tokenizer
-	}
-
-	//struct implement
-	struct place::implement
-	{
-		class field_gather;
-		class field_dock;
-
-		class division;
-		class div_arrange;
-		class div_grid;
-		class div_splitter;
-		class div_dock;
-		class div_dockpane;
-
-		window window_handle{nullptr};
-		event_handle event_size_handle{nullptr};
-
-		std::string div_text;
-		std::unique_ptr<division> root_division;
-		std::map<std::string, field_gather*> fields;
-		std::map<std::string, field_dock*> docks;
-		std::map<std::string, field_dock*> dock_factoris;
-
-		//A temporary pointer used to refer to a specified div object which
-		//will be deleted in modification process.
-		std::unique_ptr<division> tmp_replaced;
-
-		//The following functions are defined behind the definition of class division.
-		//because the class division here is an incomplete type.
-		~implement();
-
-		void collocate();
-
-		static division * search_div_name(division* start, const std::string&);
-		std::unique_ptr<division> scan_div(place_parts::tokenizer&);
-		void check_unique(const division*) const;
-
-		//connect the field/dock with div object
-		void connect(division* start);
-		void disconnect();
-	};	//end struct implement
-
-	class place::implement::field_gather
-		: public place::field_interface
-	{
-	public:
-		struct element_t
-		{
-			window handle;
-			event_handle evt_destroy;
-
-			element_t(window h, event_handle event_destroy)
-				:handle(h), evt_destroy(event_destroy)
-			{}
-		};
-
-		field_gather(place * p)
-			: place_ptr_(p)
-		{}
-
-		~field_gather()
-		{
-			for (auto & e : elements)
-				API::umake_event(e.evt_destroy);
-
-			for (auto & e : fastened)
-				API::umake_event(e.evt_destroy);
-		}
-
-		void visible(bool vsb)
-		{
-			for (auto & e : elements)
-				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)
-		{
-			for (auto i = elements.begin(); i != elements.end(); ++i)
-			{
-				if (i->handle == handle)
-				{
-					auto evt_destroy = i->evt_destroy;
-					elements.erase(i);
-					return evt_destroy;
-				}
-			}
-			return nullptr;
-		}
-	private:
-		//Listen to destroy of a window
-		//It will delete the element and recollocate when the window destroyed.
-		event_handle _m_make_destroy(window wd)
-		{
-			return API::events(wd).destroy.connect([this, wd](const arg_destroy&)
-			{
-				if (erase_element(elements, wd))
-				{
-					if (!API::is_destroying(API::get_parent_window(wd)))
-						place_ptr_->collocate();
-				}
-			});
-		}
-
-		field_interface& operator<<(const char* label_text) override
-		{
-			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text ? label_text : ""));
-		}
-
-		field_interface& operator<<(std::string label_text) override
-		{
-			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text));
-		}
-
-		field_interface& operator<<(window wd) override
-		{
-			if (API::empty_window(wd))
-				throw std::invalid_argument("Place: An invalid window handle.");
-
-			if (API::get_parent_window(wd) != place_ptr_->window_handle())
-				throw std::invalid_argument("Place: the window is not a child of place bind window");
-
-			auto evt = _m_make_destroy(wd);
-			elements.emplace_back(wd, evt);
-			return *this;
-		}
-
-		field_interface& fasten(window wd) override
-		{
-			if (API::empty_window(wd))
-				throw std::invalid_argument("Place: An invalid window handle.");
-
-			if (API::get_parent_window(wd) != place_ptr_->window_handle())
-				throw std::invalid_argument("Place: the window is not a child of place bind window");
-
-			//Listen to destroy of a window. The deleting a fastened window
-			//does not change the layout.
-			auto evt = API::events(wd).destroy.connect([this](const arg_destroy& arg)
-			{
-				erase_element(fastened, arg.window_handle);
-			});
-
-			fastened.emplace_back(wd, evt);
-			return *this;
-		}
-
-		void _m_add_agent(const detail::place_agent& ag) override
-		{
-			widgets_.emplace_back(ag.create(place_ptr_->window_handle()));
-			this->operator<<(widgets_.back()->handle());
-		}
-	public:
-		division* attached{ nullptr };
-		std::vector<std::unique_ptr<nana::widget>> widgets_;
-		std::vector<element_t>	elements;
-		std::vector<element_t>	fastened;
-	private:
-		place * place_ptr_;
-	};//end class field_gather
-
-	class place::implement::field_dock
-	{
-
-	public:
-		div_dockpane * attached{ nullptr };					//attached div object
-		std::unique_ptr<place_parts::dockarea> dockarea;	//the dockable widget
-		std::map<std::string, std::function<std::unique_ptr<widget>(window)>> factories;	//factories for dockpane
-	};//end class field_dock
-
-
-
-	class place::implement::division
-	{
-	public:
-		enum class kind{ arrange, vertical_arrange, grid, splitter, dock, dockpane};
-
-		division(kind k, std::string&& n)
-			: kind_of_division(k),
-			name(std::move(n))
-		{}
-
-		virtual ~division()
-		{
-			//detach the field
-			if (field)
-				field->attached = nullptr;
-		}
-
-		void set_visible(bool vsb)
-		{
-			if (field)
-				field->visible(vsb);
-
-			_m_visible_for_child(this, vsb);
-			visible = vsb;
-		}
-
-		void set_display(bool dsp)
-		{
-			set_visible(dsp);
-			display = dsp;
-
-			if (kind::splitter != kind_of_division)
-			{
-				//Don't display the previous one, if it is a splitter
-				auto div = previous();
-				if (div && (kind::splitter == div->kind_of_division))
-				{
-					if (dsp)
-					{
-						auto leaf = div->previous();
-						if (leaf && leaf->display)
-							div->set_display(true);
-					}
-					else
-						div->set_display(false);
-				}
-
-				//Don't display the next one, if it is a splitter
-				if (div_next && (kind::splitter == div_next->kind_of_division))
-				{
-					if (dsp)
-					{
-						auto leaf = div_next->div_next;
-						if (leaf && leaf->display)
-							div_next->set_display(true);
-					}
-					else
-						div_next->set_display(false);
-				}
-			}
-			else
-			{
-				//This is a splitter, it only checks when it is being displayed
-				if (dsp)
-				{
-					//Left field of splitterbar
-					auto left = this->previous();
-					if (left && !left->display)
-						left->set_display(true);
-
-					//Right field of splitterbar
-					if (div_next && !div_next->display)
-						div_next->set_display(true);
-				}
-			}
-		}
-
-		bool is_back(const division* div) const
-		{
-			for (auto i = children.crbegin(); i != children.crend(); ++i)
-			{
-				if (!(i->get()->display))
-					continue;
-
-				return (div == i->get());
-			}
-			return false;
-		}
-
-		static double limit_px(const division* div, double px, unsigned area_px)
-		{
-			if (!div->min_px.empty())
-			{
-				auto v = div->min_px.get_value(static_cast<int>(area_px));
-				if (px < v)
-					return v;
-			}
-			if (!div->max_px.empty())
-			{
-				auto v = div->max_px.get_value(static_cast<int>(area_px));
-				if (px > v)
-					return v;
-			}
-			return px;
-		}
-
-		bool is_fixed() const
-		{
-			return (weight.kind_of() == number_t::kind::integer);
-		}
-
-		bool is_percent() const
-		{
-			return (weight.kind_of() == number_t::kind::percent);
-		}
-
-		nana::rectangle margin_area() const
-		{
-			return margin.area(field_area);
-		}
-
-		division * previous() const
-		{
-			if (div_owner)
-			{
-				for (auto & child : div_owner->children)
-					if (child->div_next == this)
-						return child.get();
-			}
-			return nullptr;
-
-		}
-	public:
-		void _m_visible_for_child(division * div, bool vsb)
-		{
-			for (auto & child : div->children)
-			{
-				if (child->field && (!vsb || child->visible))
-					child->field->visible(vsb);
-
-				_m_visible_for_child(child.get(), vsb);
-			}
-		}
-		//Collocate the division and its children divisions,
-		//The window parameter is specified for the window which the place object binded.
-		virtual void collocate(window) = 0;
-	public:
-		kind kind_of_division;
-		bool display{ true };
-		bool visible{ true };
-		::nana::direction dir{::nana::direction::west};
-		std::string name;
-		std::vector<std::unique_ptr<division>> children;
-
-		::nana::rectangle field_area;
-		number_t weight;
-		number_t min_px, max_px;
-
-		place_parts::margin	margin;
-		place_parts::repeated_array gap;
-		field_gather * field{ nullptr };
-		division * div_next{ nullptr };
-		division * div_owner{ nullptr };
-	};//end class division
-
-	class place::implement::div_arrange
-		: public division
-	{
-	public:
-		div_arrange(bool vert, std::string&& name, place_parts::repeated_array&& arr)
-			: division((vert ? kind::vertical_arrange : kind::arrange), std::move(name)),
-			arrange_(std::move(arr))
-		{}
-
-		void collocate(window wd) override
-		{
-			const bool vert = (kind::arrange != kind_of_division);
-
-			auto area_margined = margin_area();
-			rectangle_rotator area(vert, area_margined);
-			auto area_px = area.w();
-
-			auto fa = _m_fixed_and_adjustable(kind_of_division, area_px);
-
-			double adjustable_px = _m_revise_adjustable(fa, area_px);
-
-			double position = area.x();
-			std::vector<division*> delay_collocates;
-			double precise_px = 0;
-			for (auto& child_ptr : children)					/// First collocate child div's !!!
-			{
-				auto child = child_ptr.get();
-				if(!child->display)	//Ignore the division if the corresponding field is not displayed.
-					continue;
-
-				rectangle_rotator child_area(vert, child->field_area);
-				child_area.x_ref() = static_cast<int>(position);
-				child_area.y_ref() = area.y();
-				child_area.h_ref() = area.h();
-
-				double child_px;				// and calculate this div.
-				if (!child->is_fixed())			// with is fixed for fixed div
-				{
-					if (child->is_percent())			// and calculated for others: if the child div is percent - simple take it full
-						child_px = area_px * child->weight.real() + precise_px;
-					else
-						child_px = adjustable_px;
-
-					child_px = limit_px(child, child_px, area_px);
-					auto npx = static_cast<unsigned>(child_px);
-					precise_px = child_px - npx;
-					child_px = npx;
-				}
-				else
-					child_px = static_cast<unsigned>(child->weight.integer());
-
-				//Use 'endpos' to calc width is to avoid deviation
-				int endpos = static_cast<int>(position + child_px);
-				if ((!child->is_fixed()) && child->max_px.empty() && is_back(child) && (endpos != area.right()))
-					endpos = area.right();
-
-				child_area.w_ref() = static_cast<unsigned>((std::max)(endpos - child_area.x(), 0));
-
-				child->field_area = child_area.result();
-				position += child_px;
-
-				if (child->kind_of_division == kind::splitter)
-					delay_collocates.emplace_back(child);
-				else
-					child->collocate(wd);	/// The child div have full position. Now we can collocate  inside it the child fields and child-div.
-			}
-
-			for (auto child : delay_collocates)
-				child->collocate(wd);
-
-			if (visible && display && field)
-			{
-				auto element_r = area;
-				std::size_t index = 0;
-				double precise_px = 0;
-
-				for (auto & el : field->elements)
-				{
-					element_r.x_ref() = static_cast<int>(position);
-					auto px = _m_calc_number(arrange_.at(index), area_px, adjustable_px, precise_px);
-
-					element_r.w_ref() = px;
-					API::move_window(el.handle, element_r.result());
-
-					if (index + 1 < field->elements.size())
-						position += (px + _m_calc_number(gap.at(index), area_px, 0, precise_px));
-
-					++index;
-				}
-
-				for (auto & fsn : field->fastened)
-					API::move_window(fsn.handle, area_margined);
-			}
-		}
-	private:
-		static unsigned _m_calc_number(const place_parts::number_t& number, unsigned area_px, double adjustable_px, double& precise_px)
-		{
-			switch (number.kind_of())
-			{
-			case number_t::kind::integer:
-				return static_cast<unsigned>(number.integer());
-			case number_t::kind::real:
-				return static_cast<unsigned>(number.real());
-			case number_t::kind::percent:
-				adjustable_px = area_px * number.real();
-			case number_t::kind::none:
-				{
-					auto fpx = adjustable_px + precise_px;
-					auto px = static_cast<unsigned>(fpx);
-					precise_px = fpx - px;
-					return px;
-				}
-				break;
-			}
-			return 0; //Useless
-		}
-
-		static std::pair<unsigned, std::size_t> _m_calc_fa(const place_parts::number_t& number, unsigned area_px, double& precise_px)
-		{
-			std::pair<unsigned, std::size_t> result;
-			switch (number.kind_of())
-			{
-			case number_t::kind::integer:
-				result.first = static_cast<unsigned>(number.integer());
-				break;
-			case number_t::kind::real:
-				result.first = static_cast<unsigned>(number.real());
-				break;
-			case number_t::kind::percent:
-				{
-					double px = number.real() * area_px + precise_px;
-					auto npx = static_cast<unsigned>(px);
-					result.first = npx;
-					precise_px = px - npx;
-				}
-				break;
-			case number_t::kind::none:
-				++result.second;
-				break;
-			}
-			return result;
-		}
-
-		//Returns the fixed pixels and the number of adjustable items.
-		std::pair<unsigned, std::size_t> _m_fixed_and_adjustable(kind match_kind, unsigned area_px) const
-		{
-			std::pair<unsigned, std::size_t> result;
-			if (field && (kind_of_division == match_kind))
-			{
-				//Calculate fixed and adjustable of elements
-				double precise_px = 0;
-				auto count = field->elements.size();
-				for (decltype(count) i = 0; i < count; ++i)
-				{
-					auto fa = _m_calc_fa(arrange_.at(i), area_px, precise_px);
-					result.first += fa.first;
-					result.second += fa.second;
-
-					if (i + 1 < count)
-					{
-						fa = _m_calc_fa(gap.at(i), area_px, precise_px);
-						result.first += fa.first;
-						//fa.second is ignored for gap, because the it has not the adjustable gap.
-					}
-				}
-			}
-
-			double children_fixed_px = 0;
-			for (auto& child : children)
-			{
-				if (!child->display)	//Ignore the division if the corresponding field is not displayed.
-					continue;
-
-				if (!child->weight.empty())
-					children_fixed_px += child->weight.get_value(area_px);
-				else
-					++result.second;
-			}
-			result.first += static_cast<unsigned>(children_fixed_px);
-			return result;
-		}
-
-		double _m_revise_adjustable(std::pair<unsigned, std::size_t>& fa, unsigned area_px)
-		{
-			if (fa.first >= area_px || 0 == fa.second)
-				return 0;
-
-			double var_px = area_px - fa.first;
-
-			struct revise_t
-			{
-				division * div;
-				double min_px;
-				double max_px;
-			};
-
-			std::size_t min_count = 0;
-			double sum_min_px = 0;
-			std::vector<revise_t> revises;
-			for (auto& child : children)
-			{
-				if ((!child->weight.empty()) || !child->display)
-					continue;
-
-				double min_px = std::numeric_limits<double>::lowest(), max_px = std::numeric_limits<double>::lowest();
-
-				if (!child->min_px.empty())
-				{
-					min_px = child->min_px.get_value(static_cast<int>(area_px));
-					sum_min_px += min_px;
-					++min_count;
-				}
-
-				if (!child->max_px.empty())
-					max_px = child->max_px.get_value(static_cast<int>(area_px));
-
-				if (min_px >= 0 && max_px >= 0 && min_px > max_px)
-				{
-					if (child->min_px.kind_of() == number_t::kind::percent)
-						min_px = std::numeric_limits<double>::lowest();
-					else if (child->max_px.kind_of() == number_t::kind::percent)
-						max_px = std::numeric_limits<double>::lowest();
-				}
-
-				if (min_px >= 0 || max_px >= 0)
-					revises.push_back({ child.get(), min_px, max_px });
-			}
-
-			if (revises.empty())
-				return var_px / fa.second;
-
-			auto find_lowest = [&revises](double level_px)
-			{
-				double v = (std::numeric_limits<double>::max)();
-
-				for (auto i = revises.begin(); i != revises.end(); ++i)
-				{
-					auto & rev = *i;
-					if (rev.min_px >= 0 && rev.min_px < v && rev.min_px > level_px)
-						v = rev.min_px;
-					else if (rev.max_px >= 0 && rev.max_px < v)
-						v = rev.max_px;
-				}
-				return v;
-			};
-
-			auto remove_full = [&revises](double value, std::size_t& full_count)
-			{
-				full_count = 0;
-				std::size_t reached_mins = 0;
-				auto i = revises.begin();
-				while(i != revises.end())
-				{
-					if (i->max_px == value)
-					{
-						++full_count;
-						i = revises.erase(i);
-					}
-					else
-					{
-						if (i->min_px == value)
-							++reached_mins;
-						++i;
-					}
-				}
-				return reached_mins;
-			};
-
-			double block_px = 0;
-			double level_px = 0;
-			auto rest_px = var_px - sum_min_px;
-			std::size_t blocks = fa.second;
-
-			while ((rest_px > 0) && blocks)
-			{
-				auto lowest = find_lowest(level_px);
-				double fill_px = 0;
-				//blocks may be equal to min_count. E.g, all child divisions have min/max attribute.
-				if (blocks > min_count)
-				{
-					fill_px = rest_px / (blocks - min_count);
-					if (fill_px + level_px <= lowest)
-					{
-						block_px += fill_px;
-						break;
-					}
-				}
-
-				block_px = lowest;
-				if (blocks > min_count)
-					rest_px -= (lowest-level_px) * (blocks - min_count);
-
-				std::size_t full_count;
-				min_count -= remove_full(lowest, full_count);
-				blocks -= full_count;
-				level_px = lowest;
-			}
-
-			return block_px;
-		}
-	private:
-		place_parts::repeated_array arrange_;
-	};
-
-	class place::implement::div_grid
-		: public division
-	{
-	public:
-		div_grid(std::string&& name, place_parts::repeated_array&& arrange, std::vector<rectangle>&& collapses)
-			: division(kind::grid, std::move(name)),
-			arrange_(std::move(arrange)),
-			collapses_(std::move(collapses))
-		{
-			dimension.first = dimension.second = 0;
-		}
-
-		void revise_collapses()
-		{
-			if (collapses_.empty())
-				return;
-
-			for (auto i = collapses_.begin(); i != collapses_.end();)
-			{
-				if (i->x >= static_cast<int>(dimension.first) || i->y >= static_cast<int>(dimension.second))
-					i = collapses_.erase(i);
-				else
-					++i;
-			}
-
-			//Remove the overlapped collapses
-			for (std::size_t i = 0; i < collapses_.size() - 1; ++i)
-			{
-				auto & col = collapses_[i];
-				for (auto u = i + 1; u != collapses_.size();)
-				{
-					auto & z = collapses_[u];
-					if (col.is_hit(z.x, z.y) || col.is_hit(z.right(), z.y) || col.is_hit(z.x, z.bottom()) || col.is_hit(z.right(), z.bottom()))
-						collapses_.erase(collapses_.begin() + u);
-					else
-						++u;
-				}
-			}
-
-			for (auto & col : collapses_)
-			{
-				if (col.right() >= static_cast<int>(dimension.first))
-					col.width = dimension.first - static_cast<unsigned>(col.x);
-
-				if (col.bottom() >= static_cast<int>(dimension.second))
-					col.height = dimension.second - static_cast<unsigned>(col.y);
-			}
-		}
-
-		void collocate(window) override
-		{
-			if (!field || !(visible && display))
-				return;
-
-			auto area = margin_area();
-
-			unsigned gap_size = 0;
-			auto gap_number = gap.at(0);
-			if (!gap_number.empty())
-				gap_size = static_cast<unsigned>(gap_number.get_value(area.width));
-
-			//When the amount pixels of gaps is out of the area bound.
-			if ((gap_size * dimension.first >= area.width) || (gap_size * dimension.second >= area.height))
-			{
-				for (auto & el : field->elements)
-					API::window_size(el.handle, size{ 0, 0 });
-				return;
-			}
-
-			if (dimension.first <= 1 && dimension.second <= 1)
-			{
-				auto n_of_wd = field->elements.size();
-				std::size_t edge;
-				switch (n_of_wd)
-				{
-				case 0:
-				case 1:
-					edge = 1;	break;
-				case 2: case 3: case 4:
-					edge = 2;	break;
-				default:
-					edge = static_cast<std::size_t>(std::sqrt(n_of_wd));
-					if ((edge * edge) < n_of_wd) ++edge;
-				}
-
-				bool exit_for = false;
-				double y = area.y;
-				double block_w = area.width / double(edge);
-				double block_h = area.height / double((n_of_wd / edge) + (n_of_wd % edge ? 1 : 0));
-				unsigned uns_block_w = static_cast<unsigned>(block_w);
-				unsigned uns_block_h = static_cast<unsigned>(block_h);
-				unsigned height = (uns_block_h > gap_size ? uns_block_h - gap_size : uns_block_h);
-
-				auto i = field->elements.cbegin(), end = field->elements.cend();
-				std::size_t arr_pos = 0;
-				for (std::size_t u = 0; u < edge; ++u)
-				{
-					double x = area.x;
-					for (std::size_t v = 0; v < edge; ++v)
-					{
-						if (i == end)
-						{
-							exit_for = true;
-							break;
-						}
-
-						unsigned value = 0;
-						auto arr = arrange_.at(arr_pos++);
-
-						if (arr.empty())
-							value = static_cast<decltype(value)>(block_w);
-						else
-							value = static_cast<decltype(value)>(arr.get_value(static_cast<int>(area.width)));
-
-						unsigned width = (value > uns_block_w ? uns_block_w : value);
-						if (width > gap_size)	width -= gap_size;
-						API::move_window(i->handle, rectangle{ static_cast<int>(x), static_cast<int>(y), width, height });
-						x += block_w;
-						++i;
-					}
-					if (exit_for) break;
-					y += block_h;
-				}
-			}
-			else
-			{
-				double block_w = int(area.width - gap_size * (dimension.first - 1)) / double(dimension.first);
-				double block_h = int(area.height - gap_size * (dimension.second - 1)) / double(dimension.second);
-
-				std::unique_ptr<char[]> table_ptr(new char[dimension.first * dimension.second]);
-
-				char *table = table_ptr.get();
-				std::memset(table, 0, dimension.first * dimension.second);
-
-				std::size_t lbp = 0;
-				bool exit_for = false;
-
-				auto i = field->elements.cbegin(), end = field->elements.cend();
-
-				double precise_h = 0;
-				for (std::size_t c = 0; c < dimension.second; ++c)
-				{
-					unsigned block_height_px = static_cast<unsigned>(block_h + precise_h);
-					precise_h = (block_h + precise_h) - block_height_px;
-
-					double precise_w = 0;
-					for (std::size_t l = 0; l < dimension.first; ++l)
-					{
-						if (table[l + lbp])
-						{
-							precise_w += block_w;
-							auto px = static_cast<int>(precise_w);
-							precise_w -= px;
-							continue;
-						}
-
-						if (i == end)
-						{
-							exit_for = true;
-							break;
-						}
-
-						std::pair<unsigned, unsigned> room{ 1, 1 };
-
-						_m_find_collapse(static_cast<int>(l), static_cast<int>(c), room);
-
-						int pos_x = area.x + static_cast<int>(l * (block_w + gap_size));
-						int pos_y = area.y + static_cast<int>(c * (block_h + gap_size));
-
-						unsigned result_h;
-						if (room.first <= 1 && room.second <= 1)
-						{
-							precise_w += block_w;
-							result_h = block_height_px;
-							table[l + lbp] = 1;
-						}
-						else
-						{
-							precise_w += block_w * room.first + (room.first - 1) * gap_size;
-							result_h = static_cast<unsigned>(block_h * room.second + precise_h + (room.second - 1) * gap_size);
-
-							for (unsigned y = 0; y < room.second; ++y)
-								for (unsigned x = 0; x < room.first; ++x)
-									table[l + x + lbp + y * dimension.first] = 1;
-						}
-
-						unsigned result_w = static_cast<unsigned>(precise_w);
-						precise_w -= result_w;
-
-						API::move_window(i->handle, rectangle{ pos_x, pos_y, result_w, result_h });
-						++i;
-					}
-
-					if (exit_for)
-					{
-						size empty_sz;
-						for (; i != end; ++i)
-							API::window_size(i->handle, empty_sz);
-						break;
-					}
-					lbp += dimension.first;
-				}
-			}
-
-			for (auto & fsn : field->fastened)
-				API::move_window(fsn.handle, area);
-		}
-	public:
-		std::pair<unsigned, unsigned> dimension;
-	private:
-		void _m_find_collapse(int x, int y, std::pair<unsigned, unsigned>& collapse) const
-		{
-			for (auto & col : collapses_)
-			{
-				if (col.x == x && col.y == y)
-				{
-					collapse.first = col.width;
-					collapse.second = col.height;
-					return;
-				}
-			}
-		}
-	private:
-		place_parts::repeated_array arrange_;
-		std::vector<rectangle> collapses_;
-	};//end class div_grid
-
-	class place::implement::div_splitter
-		: public division
-	{
-		struct div_block
-		{
-			division * div;
-			int	pixels;
-			double		scale;
-
-			div_block(division* d, int px)
-				: div(d), pixels(px)
-			{}
-		};
-
-		enum{splitter_px = 4};
-	public:
-		div_splitter(place_parts::number_t init_weight)
-			: division(kind::splitter, std::string()),
-			init_weight_(init_weight)
-		{
-			this->weight.assign(splitter_px);
-		}
-
-		void direction(bool horizontal)
-		{
-			splitter_cursor_ = (horizontal ? cursor::size_we : cursor::size_ns);
-		}
-	private:
-		void collocate(window wd) override
-		{
-			if (API::is_destroying(wd))
-				return;
-
-			if (splitter_.empty())
-			{
-				splitter_.create(wd);
-				splitter_.cursor(splitter_cursor_);
-
-				dragger_.trigger(splitter_);
-
-				auto grab_fn = [this](const arg_mouse& arg)
-				{
-					if (false == arg.left_button)
-						return;
-
-					if (event_code::mouse_down == arg.evt_code)
-					{
-						begin_point_ = splitter_.pos();
-
-						auto px_ptr = &nana::rectangle::width;
-
-						//Use field_area of leaf, not margin_area. Otherwise splitter would be at wrong position
-						auto area_left = _m_leaf_left()->field_area;
-						auto area_right = _m_leaf_right()->field_area;
-
-						if (nana::cursor::size_we != splitter_cursor_)
-						{
-							left_pos_ = area_left.y;
-							right_pos_ = area_right.bottom();
-							px_ptr = &nana::rectangle::height;
-						}
-						else
-						{
-							left_pos_ = area_left.x;
-							right_pos_ = area_right.right();
-						}
-
-						left_pixels_ = area_left.*px_ptr;
-						right_pixels_ = area_right.*px_ptr;
-						
-						grabbed_ = true;
-					}
-					else if(event_code::mouse_up == arg.evt_code)
-					{
-						grabbed_ = false;
-					}
-					else if (event_code::mouse_move == arg.evt_code)
-					{
-						if(!grabbed_)
-							return;
-							
-						const bool vert = (::nana::cursor::size_we != splitter_cursor_);
-						auto area_px = rectangle_rotator(vert, div_owner->margin_area()).w();
-						int delta = (vert ? splitter_.pos().y - begin_point_.y : splitter_.pos().x - begin_point_.x);
-
-						int total_pixels = static_cast<int>(left_pixels_ + right_pixels_);
-
-						auto left_px = static_cast<int>(left_pixels_) + delta;
-						if (left_px > total_pixels)
-							left_px = total_pixels;
-						else if (left_px < 0)
-							left_px = 0;
-
-						double imd_rate = 100.0 / area_px;
-						left_px = static_cast<int>(limit_px(_m_leaf_left(), left_px, area_px));
-						_m_leaf_left()->weight.assign_percent(imd_rate * left_px);
-
-						auto right_px = static_cast<int>(right_pixels_) - delta;
-						if (right_px > total_pixels)
-							right_px = total_pixels;
-						else if (right_px < 0)
-							right_px = 0;
-
-						right_px = static_cast<int>(limit_px(_m_leaf_right(), right_px, area_px));
-						_m_leaf_right()->weight.assign_percent(imd_rate * right_px);
-
-						pause_move_collocate_ = true;
-						div_owner->collocate(splitter_.parent());
-
-						//After the collocating, the splitter keeps the calculated weight of left division,
-						//and clear the weight of right division.
-						_m_leaf_right()->weight.reset();
-
-						pause_move_collocate_ = false;
-					}
-				};
-
-				auto & events = splitter_.events();
-				events.mouse_down.connect_unignorable(grab_fn);
-				events.mouse_up.connect_unignorable(grab_fn);
-				events.mouse_move.connect_unignorable(grab_fn);
-			}
-
-			auto limited_range = _m_update_splitter_range();
-
-			if (!init_weight_.empty())
-			{
-				const bool vert = (::nana::cursor::size_we != splitter_cursor_);
-
-				auto leaf_left = _m_leaf_left();
-				auto leaf_right = _m_leaf_right();
-				rectangle_rotator left(vert, leaf_left->field_area);
-				rectangle_rotator right(vert, leaf_right->field_area);
-				auto area_px = right.right() - left.x();
-				auto right_px = static_cast<int>(limit_px(leaf_right, init_weight_.get_value(area_px), static_cast<unsigned>(area_px)));
-
-				auto pos = area_px - right_px - splitter_px; //New position of splitter
-				if (pos < limited_range.x())
-					pos = limited_range.x();
-				else if (pos > limited_range.right())
-					pos = limited_range.right();
-
-				rectangle_rotator sp_r(vert, field_area);
-				sp_r.x_ref() = pos;
-
-				left.w_ref() = static_cast<unsigned>(pos - left.x());
-
-				auto right_pos = right.right();
-				right.x_ref() = (pos + splitter_px);
-				right.w_ref() = static_cast<unsigned>(right_pos - pos - splitter_px);
-
-				field_area = sp_r.result();
-				leaf_left->field_area = left.result();
-				leaf_right->field_area = right.result();
-				leaf_left->collocate(wd);
-				leaf_right->collocate(wd);
-
-				//Set the leafs' weight
-				rectangle_rotator area(vert, div_owner->field_area);
-
-				double imd_rate = 100.0 / static_cast<int>(area.w());
-				leaf_left->weight.assign_percent(imd_rate * static_cast<int>(left.w()));
-				leaf_right->weight.assign_percent(imd_rate * static_cast<int>(right.w()));
-
-				splitter_.move(this->field_area);
-
-				init_weight_.reset();
-			}
-
-			if (false == pause_move_collocate_)
-				splitter_.move(this->field_area);
-		}
-	private:
-		division * _m_leaf_left() const
-		{
-			return previous();
-		}
-
-		division * _m_leaf_right() const
-		{
-			return div_next;
-		}
-
-		rectangle_rotator _m_update_splitter_range()
-		{
-			const bool vert = (cursor::size_ns == splitter_cursor_);
-
-			rectangle_rotator area(vert, div_owner->margin_area());
-
-			auto leaf_left = _m_leaf_left();
-			auto leaf_right = _m_leaf_right();
-
-			rectangle_rotator left(vert, leaf_left->field_area);
-			rectangle_rotator right(vert, leaf_right->field_area);
-
-			const int left_base = left.x(), right_base = right.right();
-			int pos = left_base;
-			int endpos = right_base;
-
-			if (!leaf_left->min_px.empty())
-			{
-				auto v = leaf_left->min_px.get_value(area.w());
-				pos += static_cast<int>(v);
-			}
-			if (!leaf_left->max_px.empty())
-			{
-				auto v = leaf_left->max_px.get_value(area.w());
-				endpos = left_base + static_cast<int>(v);
-			}
-
-			if (!leaf_right->min_px.empty())
-			{
-				auto v = leaf_right->min_px.get_value(area.w());
-				auto x = right_base - static_cast<int>(v);
-				if (x < endpos)
-					endpos = x;
-			}
-			if (!leaf_right->max_px.empty())
-			{
-				auto v = leaf_right->max_px.get_value(area.w());
-				auto x = right_base - static_cast<int>(v);
-				if (x > pos)
-					pos = x;
-			}
-
-			area.x_ref() = pos;
-			area.w_ref() = unsigned(endpos - pos + splitter_px);
-
-			dragger_.target(splitter_, area.result(), (vert ? nana::arrange::vertical : nana::arrange::horizontal));
-
-			return area;
-		}
-	private:
-		nana::cursor	splitter_cursor_{nana::cursor::arrow};
-		place_parts::splitter<true>	splitter_;
-		nana::point	begin_point_;
-		int			left_pos_, right_pos_;
-		unsigned	left_pixels_, right_pixels_;
-		dragger	dragger_;
-		bool	grabbed_{ false };
-		bool	pause_move_collocate_{ false };	//A flag represents whether do move when collocating.
-		place_parts::number_t init_weight_;
-	};
-
-	class place::implement::div_dockpane
-		: public division, public place_parts::dock_notifier_interface
-	{
-	public:
-		div_dockpane(std::string && name, implement* impl, direction pane_dir)
-			:	division(kind::dockpane, std::move(name)),
-				impl_ptr_{impl}
-		{
-			dir = pane_dir;
-			this->display = false;
-		}
-
-		~div_dockpane()
-		{
-			if (dockable_field)
-			{
-				dockable_field->dockarea.reset();
-				dockable_field->attached = nullptr;
-			}
-		}
-
-		void collocate(window) override
-		{
-			if (!dockable_field)
-			{
-				if (name.empty())
-					return;
-
-				auto &dock_ptr = impl_ptr_->docks[name];
-				if (!dock_ptr)
-					dock_ptr = new field_dock;
-
-				dock_ptr->attached = this;
-				dockable_field = dock_ptr;
-			}
-
-			auto & dockarea = dockable_field->dockarea;
-			if (dockarea && !dockarea->floating())
-				dockarea->move(this->field_area);
-		}
-	private:
-		//Implement dock_notifier_interface
-		void notify_float() override
-		{
-			set_display(false);
-			impl_ptr_->collocate();
-		}
-
-		void notify_dock() override
-		{
-			indicator_.docker.reset();
-
-			set_display(true);
-			impl_ptr_->collocate();
-		}
-
-		void notify_move() override
-		{
-			if (!_m_indicator())
-			{
-				indicator_.docker.reset();
-				return;
-			}
-
-			if (!indicator_.docker)
-			{
-				auto host_size = API::window_size(impl_ptr_->window_handle);
-				indicator_.docker.reset(new form(impl_ptr_->window_handle, { static_cast<int>(host_size.width) / 2 - 16, static_cast<int>(host_size.height) / 2 - 16, 32, 32 }, form::appear::bald<>()));
-				drawing dw(indicator_.docker->handle());
-				dw.draw([](paint::graphics& graph)
-				{
-					graph.rectangle(false, colors::midnight_blue);
-					graph.rectangle({ 1, 1, 30, 30 }, true, colors::light_sky_blue);
-
-					facade<element::arrow> arrow;
-					arrow.direction(::nana::direction::south);
-					arrow.draw(graph, colors::light_sky_blue, colors::midnight_blue, { 12, 0, 16, 16 }, element_state::normal);
-
-					graph.rectangle({ 4, 16, 24, 11 }, true, colors::midnight_blue);
-					graph.rectangle({ 5, 19, 22, 7 }, true, colors::button_face);
-				});
-
-				indicator_.docker->z_order(nullptr, ::nana::z_order_action::topmost);
-				indicator_.docker->show();
-
-				indicator_.docker->events().destroy.connect([this](const arg_destroy&)
-				{
-					if (indicator_.dock_area)
-					{
-						indicator_.dock_area.reset();
-						indicator_.graph.release();
-					}
-				});
-			}
-
-			if (_m_dockable())
-			{
-				if (!indicator_.dock_area)
-				{
-					set_display(true);
-					impl_ptr_->collocate();
-
-					indicator_.graph.make(API::window_size(impl_ptr_->window_handle));
-					API::window_graphics(impl_ptr_->window_handle, indicator_.graph);
-
-					indicator_.dock_area.reset(new panel<true>(impl_ptr_->window_handle, false));
-					indicator_.dock_area->move(this->field_area);
-
-					::nana::drawing dw(indicator_.dock_area->handle());
-					dw.draw([this](paint::graphics& graph)
-					{
-						indicator_.graph.paste(this->field_area, graph, 0, 0);
-
-						const int border_px = 4;
-						rectangle r{ graph.size() };
-						int right = r.right();
-						int bottom = r.bottom();
-
-						graph.blend(r.pare_off(border_px), colors::blue, 0.3);
-
-						::nana::color clr = colors::deep_sky_blue;
-						r.y = 0;
-						r.height = border_px;
-						graph.blend(r, clr, 0.5);
-						r.y = bottom - border_px;
-						graph.blend(r, clr, 0.5);
-
-						r.x = r.y = 0;
-						r.dimension(graph.size());
-						r.width = border_px;
-						graph.blend(r, clr, 0.5);
-						r.x = right - border_px;
-						graph.blend(r, clr, 0.5);
-
-					});
-
-					API::bring_top(indicator_.dock_area->handle(), false);
-					indicator_.dock_area->show();
-				}
-			}
-			else
-			{
-				set_display(false);
-				impl_ptr_->collocate();
-				if (indicator_.dock_area)
-				{
-					indicator_.dock_area.reset();
-					indicator_.graph.release();
-				}
-			}
-
-		}
-
-		void notify_move_stopped() override
-		{
-			if (_m_dockable() && dockable_field && dockable_field->dockarea)
-				dockable_field->dockarea->dock();
-
-			indicator_.docker.reset();
-		}
-
-		void request_close() override
-		{
-			auto window_handle = dockable_field->dockarea->handle();
-
-			//a workaround for capture
-			auto ptr = dockable_field->dockarea.release();
-			API::at_safe_place(window_handle, [ptr]
-			{
-				std::unique_ptr<typename std::remove_pointer<decltype(ptr)>::type> del(ptr);
-			});
-
-			this->set_display(false);
-			impl_ptr_->collocate();
-
-			API::close_window(window_handle);
-		}
-	private:
-		bool _m_indicator() const
-		{
-			::nana::point pos;
-			API::calc_screen_point(impl_ptr_->window_handle, pos);
-
-			rectangle r{ pos, API::window_size(impl_ptr_->window_handle) };
-			return r.is_hit(API::cursor_position());
-		}
-
-		bool _m_dockable() const
-		{
-			if (!indicator_.docker)
-				return false;
-
-			::nana::point pos;
-			API::calc_screen_point(indicator_.docker->handle(), pos);
-
-			rectangle r{ pos, API::window_size(indicator_.docker->handle()) };
-			return r.is_hit(API::cursor_position());
-		}
-	public:
-		field_dock * dockable_field{ nullptr };
-
-		std::unique_ptr<widget>	splitter;
-	private:
-		implement * impl_ptr_;
-
-		//
-		struct indicator_rep
-		{
-			paint::graphics graph;
-			std::unique_ptr<panel<true>> dock_area;
-			std::unique_ptr<form> docker;
-		}indicator_;
-	};
-
-	class place::implement::div_dock
-		: public division
-	{
-		static const unsigned splitter_px = 5;
-
-		class splitter : public panel<true>
-		{
-		public:
-			splitter(window wd, ::nana::direction dir, division* dock_dv, division* pane_dv)
-				: panel<true>(wd, true), dir_(dir), dock_dv_(dock_dv), pane_dv_(pane_dv)
-			{
-				this->bgcolor(colors::alice_blue);
-				this->cursor(_m_is_vert(dir_) ? ::nana::cursor::size_ns : ::nana::cursor::size_we);
-
-
-				auto grab_fn = [this, wd](const arg_mouse& arg)
-				{
-					if (event_code::mouse_down == arg.evt_code)	//press mouse button
-					{
-						if (arg.button != ::nana::mouse::left_button)
-							return;
-
-						bool is_vert = _m_is_vert(dir_);
-
-						this->set_capture(true);
-
-						auto basepos = API::cursor_position();
-						base_pos_.x = (is_vert ? basepos.y : basepos.x);
-
-						basepos = this->pos();
-						base_pos_.y = (is_vert ? basepos.y : basepos.x);
-
-						base_px_ = (is_vert ? pane_dv_->field_area.height : pane_dv_->field_area.width);
-					}
-					else if (event_code::mouse_move == arg.evt_code)	//hover
-					{
-						if (!arg.is_left_button())
-							return;
-
-						auto now_pos = API::cursor_position();
-						int delta = (_m_is_vert(dir_) ? now_pos.y : now_pos.x) - base_pos_.x;
-						int new_pos = base_pos_.y + delta;
-						if (new_pos < range_.x)
-						{
-							new_pos = range_.x;
-							delta = new_pos - base_pos_.y;
-						}
-						else if (new_pos >= range_.y)
-						{
-							new_pos = range_.y - 1;
-							delta = new_pos - base_pos_.y;
-						}
-
-						now_pos = this->pos();
-						if (_m_is_vert(dir_))
-							now_pos.y = new_pos;
-						else
-							now_pos.x = new_pos;
-						this->move(now_pos);
-
-						auto px = base_px_;
-						switch (dir_)
-						{
-						case ::nana::direction::west:
-						case ::nana::direction::north:
-							if (delta < 0)
-								px -= static_cast<unsigned>(-delta);
-							else
-								px += static_cast<unsigned>(delta);
-							break;
-						case ::nana::direction::east:
-						case ::nana::direction::south:
-							if (delta < 0)
-								px += static_cast<unsigned>(-delta);
-							else
-								px -= static_cast<unsigned>(delta);
-							break;
-						default:
-							break;
-						}
-
-						auto dock_px = (_m_is_vert(dir_) ? dock_dv_->field_area.height : dock_dv_->field_area.width);
-
-						pane_dv_->weight.assign_percent(double(px) / double(dock_px) * 100);
-
-						dock_dv_->collocate(wd);
-					}
-					else
-						this->release_capture();
-				};
-
-				auto & evt = this->events();
-				evt.mouse_down.connect(grab_fn);
-				evt.mouse_up.connect(grab_fn);
-				evt.mouse_move.connect(grab_fn);
-			}
-
-			void range(int begin, int end)
-			{
-				range_.x = begin;
-				range_.y = end;
-			}
-		private:
-			const ::nana::direction	dir_;
-			division* const dock_dv_;
-			division* const	pane_dv_;
-			::nana::point	range_;
-			::nana::point	base_pos_;	//x = mouse pos, y = splitter pos
-			unsigned		base_px_;	//weight of div_dockpane when mouse button is been pressing;
-
-		};
-	public:
-		div_dock(std::string && name, implement* impl)
-			: division(kind::dock, std::move(name)), impl_(impl)
-		{}
-
-		division* front() const
-		{
-			for (auto & child : children)
-			{
-				if (child->display)
-					return child.get();
-			}
-
-			return nullptr;
-		}
-
-		void collocate(window wd) override
-		{
-			auto area = this->margin_area();
-
-			unsigned vert_count = 0, horz_count = 0;
-
-			bool is_first = true;
-			bool prev_attr;
-
-			for (auto & child : children)
-			{
-				if (!child->display)
-					continue;
-
-				const auto is_vert = _m_is_vert(child->dir);
-				if (is_first)
-				{
-					is_first = false;
-					(is_vert ? horz_count : vert_count) = 1;
-					prev_attr = is_vert;
-				}
-
-				if ((is_vert == prev_attr) == is_vert)
-					++vert_count;
-				else
-					++horz_count;
-
-				prev_attr = is_vert;
-			}
-			if (0 == vert_count)
-				vert_count = 1;
-			if (0 == horz_count)
-				horz_count = 1;
-
-			//room indicates the size without splitters
-			::nana::size room(area.width - splitter_px * (horz_count - 1), area.height - splitter_px * (vert_count - 1));
-
-			double left = area.x;
-			double right = area.right();
-			double top = area.y;
-			double bottom = area.bottom();
-
-			for (auto & child : children)
-			{
-				if (!child->display)
-				{
-					auto child_dv = dynamic_cast<div_dockpane*>(child.get());
-					if (child_dv)
-						child_dv->splitter.reset();
-
-					continue;
-				}
-
-				auto child_dv = dynamic_cast<div_dockpane*>(child.get());
-				const bool is_vert = _m_is_vert(child->dir);
-
-				auto room_px = (is_vert ? room.height : room.width);
-
-				double weight;
-				if (!child->weight.empty())
-				{
-					weight = child->weight.get_value(is_vert ? room.height : room.width);
-					if (weight > room_px)
-						weight = room_px;
-				}
-				else
-					weight = room_px / double(is_vert ? vert_count : horz_count);
-
-				splitter* split = nullptr;
-				if (_m_right(child_dv))
-				{
-					//Creates a splitbar if the 'right' leaf is not empty
-					if (!child_dv->splitter)
-					{
-						split = new splitter(impl_->window_handle, child->dir, this, child_dv);
-						child_dv->splitter.reset(split);
-					}
-					else
-						split = dynamic_cast<splitter*>(child_dv->splitter.get());
-				}
-				else
-					child_dv->splitter.reset();
-
-				::nana::rectangle child_r;
-				double split_range_begin = -1, split_range_end;
-				switch (child->dir)
-				{
-				default:
-				case ::nana::direction::west:
-					child_r.x = static_cast<int>(left);
-					child_r.y = static_cast<int>(top);
-					child_r.width = static_cast<unsigned>(weight);
-					child_r.height = static_cast<unsigned>(bottom - top);
-					left += weight;
-					if (split)
-					{
-						split->move(rectangle{ child_r.right(), child_r.y, splitter_px, child_r.height });
-						split_range_begin = left - weight;
-						split_range_end = right - static_cast<int>(splitter_px);
-						left += splitter_px;
-					}
-					break;
-				case ::nana::direction::east:
-					right -= weight;
-					child_r.x = static_cast<int>(right);
-					child_r.y = static_cast<int>(top);
-					child_r.width = static_cast<unsigned>(weight);
-					child_r.height = static_cast<unsigned>(bottom - top);
-					if (split)
-					{
-						split->move(rectangle{ child_r.x - static_cast<int>(splitter_px), child_r.y, splitter_px, child_r.height });
-						split_range_begin = left;
-						split_range_end = right - static_cast<int>(splitter_px)+weight;
-						right -= splitter_px;
-					}
-					break;
-				case ::nana::direction::north:
-					child_r.x = static_cast<int>(left);
-					child_r.y = static_cast<int>(top);
-					child_r.width = static_cast<unsigned>(right - left);
-					child_r.height = static_cast<unsigned>(weight);
-					top += weight;
-					if (split)
-					{
-						split->move(rectangle{ child_r.x, child_r.bottom(), child_r.width, splitter_px });
-						split_range_begin = top - weight;
-						split_range_end = bottom - static_cast<int>(splitter_px);
-						top += splitter_px;
-					}
-					break;
-				case ::nana::direction::south:
-					child_r.x = static_cast<int>(left);
-					bottom -= weight;
-					child_r.y = static_cast<int>(bottom);
-					child_r.width = static_cast<unsigned>(right - left);
-					child_r.height = static_cast<unsigned>(weight);
-					if (split)
-					{
-						bottom -= splitter_px;
-						split->move(rectangle{ child_r.x, child_r.y - static_cast<int>(splitter_px), child_r.width, splitter_px });
-						split_range_begin = top;
-						split_range_end = bottom + weight;
-					}
-					break;
-				}
-
-				if (split_range_begin > -0.5)
-					split->range(static_cast<int>(split_range_begin), static_cast<int>(split_range_end));
-
-				if (is_vert)
-				{
-					room.height -= child_r.height;
-					--vert_count;
-				}
-				else
-				{
-					room.width -= child_r.width;
-					--horz_count;
-				}
-
-				child->field_area = child_r;
-				child->collocate(wd);
-			}
-		}
-	private:
-		static bool _m_is_vert(::nana::direction dir)
-		{
-			return (dir == ::nana::direction::north || dir == ::nana::direction::south);
-		}
-
-		static div_dockpane* _m_right(division* dv)
-		{
-			dv = dv->div_next;
-			while (dv)
-			{
-				if (dv->display)
-					return dynamic_cast<div_dockpane*>(dv);
-
-				dv = dv->div_next;
-			}
-			return nullptr;
-		}
-	private:
-		implement * const impl_;
-	};
-
-	place::implement::~implement()
-	{
-		API::umake_event(event_size_handle);
-		root_division.reset();
-
-		for (auto & pair : fields)
-			delete pair.second;
-
-		for (auto & dock : docks)
-			delete dock.second;
-	}
-
-	void place::implement::collocate()
-	{
-		if (root_division && window_handle)
-		{
-			root_division->field_area.dimension(API::window_size(window_handle));
-
-			if (root_division->field_area.empty())
-				return;
-
-			root_division->collocate(window_handle);
-
-			for (auto & field : fields)
-			{
-				bool is_show = false;
-				if (field.second->attached && field.second->attached->visible && field.second->attached->display)
-				{
-					is_show = true;
-					auto div = field.second->attached->div_owner;
-					while (div)
-					{
-						if (!div->visible || !div->display)
-						{
-							is_show = false;
-							break;
-						}
-						div = div->div_owner;
-					}
-				}
-
-				for (auto & el : field.second->elements)
-					API::show_window(el.handle, is_show);
-			}
-		}
-	}
-
-	//search_div_name
-	//search a division with the specified name.
-	place::implement::division * place::implement::search_div_name(division* start, const std::string& name)
-	{
-		if (start)
-		{
-			if (start->name == name)
-				return start;
-
-			for (auto& child : start->children)
-			{
-				auto div = search_div_name(child.get(), name);
-				if (div)
-					return div;
-			}
-		}
-		return nullptr;
-	}
-
-	auto place::implement::scan_div(place_parts::tokenizer& tknizer) -> std::unique_ptr<division>
-	{
-		typedef place_parts::tokenizer::token token;
-
-		std::unique_ptr<division> div;
-		token div_type = token::eof;
-
-		//These variables stand for the new division's attributes
-		std::string name;
-		number_t weight, min_px, max_px;
-		place_parts::repeated_array arrange, gap;
-		place_parts::margin margin;
-		std::vector<number_t> array;
-		std::vector<rectangle> collapses;
-		std::vector<std::unique_ptr<division>> children;
-		::nana::direction div_dir = ::nana::direction::west;
-
-		bool undisplayed = false;
-		bool invisible = false;
-
-		for (token tk = tknizer.read(); tk != token::eof; tk = tknizer.read())
-		{
-			bool exit_for = false;
-			switch (tk)
-			{
-			case token::dock:
-				if (token::eof != div_type && token::dock != div_type)
-					throw std::invalid_argument("nana.place: conflict of div type at " + tknizer.pos_str());
-
-				div_type = token::dock;
-				break;
-			case token::splitter:
-				//Ignore the splitter when there is not a division.
-				if (!children.empty() && (division::kind::splitter != children.back()->kind_of_division))
-				{
-					auto splitter = new div_splitter(tknizer.number());
-					children.back()->div_next = splitter;
-					children.emplace_back(std::unique_ptr<division>{ splitter });
-				}
-				break;
-			case token::div_start:
-			{
-				auto div = scan_div(tknizer);
-				if (!children.empty())
-					children.back()->div_next = div.get();
-
-				children.emplace_back(std::move(div));
-			}
-				break;
-			case token::vert:
-				div_type = tk;
-				break;
-			case token::grid:
-				div_type = tk;
-				switch (tknizer.read())
-				{
-				case token::number:
-					array.push_back(tknizer.number());
-					array.push_back(tknizer.number());
-					break;
-				case token::array:
-					tknizer.array().swap(array);
-					break;
-				case token::reparray:
-					array.push_back(tknizer.reparray().at(0));
-					array.push_back(tknizer.reparray().at(1));
-					break;
-                default:
-                    break;
-				}
-				break;
-			case token::collapse:
-				{
-					if (tknizer.parameters().size() != 4)
-						throw std::invalid_argument("nana.place: collapse requires 4 parameters.");
-
-					auto get_number = [](const number_t & arg, const std::string& nth)
-					{
-						if (arg.kind_of() == number_t::kind::integer)
-							return arg.integer();
-						else if (arg.kind_of() == number_t::kind::real)
-							return static_cast<int>(arg.real());
-
-						throw std::invalid_argument("nana.place: the type of the "+ nth +" parameter for collapse should be integer.");
-					};
-
-					::nana::rectangle col;
-					auto arg = tknizer.parameters().at(0);
-					col.x = get_number(arg, "1st");
-
-					arg = tknizer.parameters().at(1);
-					col.y = get_number(arg, "2nd");
-
-					arg = tknizer.parameters().at(2);
-					col.width = static_cast<decltype(col.width)>(get_number(arg, "3rd"));
-
-					arg = tknizer.parameters().at(3);
-					col.height = static_cast<decltype(col.height)>(get_number(arg, "4th"));
-
-					//Check the collapse area.
-					//Ignore this collapse if its area is less than 2(col.width * col.height < 2)
-					if (!col.empty() && (col.width > 1 || col.height > 1) && (col.x >= 0 && col.y >= 0))
-					{
-						//Overwrite if a exist_col in collapses has same position as the col.
-						bool use_col = true;
-						for (auto & exist_col : collapses)
-						{
-							if (exist_col.x == col.x && exist_col.y == col.y)
-							{
-								exist_col = col;
-								use_col = false;
-								break;
-							}
-						}
-						if (use_col)
-							collapses.emplace_back(col);
-					}
-				}
-				break;
-			case token::weight: case token::min_px: case token::max_px:
-				{
-					auto n = tknizer.number();
-					//If n is the type of real, convert it to integer.
-					//the integer and percent are allowed for weight/min/max.
-					if (n.kind_of() == number_t::kind::real)
-						n.assign(static_cast<int>(n.real()));
-
-					switch (tk)
-					{
-					case token::weight: weight = n; break;
-					case token::min_px: min_px = n; break;
-					case token::max_px: max_px = n; break;
-					default: break;	//Useless
-					}
-				}
-				break;
-			case token::arrange:
-				arrange = tknizer.reparray();
-				break;
-			case token::gap:
-				gap = tknizer.reparray();
-				break;
-			case token::margin:
-				margin.clear();
-				switch (tknizer.read())
-				{
-				case token::number:
-					margin.set_value(tknizer.number());
-					break;
-				case token::array:
-					margin.set_array(tknizer.array());
-					break;
-				case token::reparray:
-					for (std::size_t i = 0; i < 4; ++i)
-					{
-						auto n = tknizer.reparray().at(i);
-						if (n.empty()) n.assign(0);
-						margin.push(n);
-					}
-					break;
-				default:
-					break;
-				}
-				break;
-			case token::div_end:
-				exit_for = true;
-				break;
-			case token::identifier:
-				name = tknizer.idstr();
-				break;
-			case token::left:
-				div_dir = ::nana::direction::west; break;
-			case token::right:
-				div_dir = ::nana::direction::east; break;
-			case token::top:
-				div_dir = ::nana::direction::north; break;
-			case token::bottom:
-				div_dir = ::nana::direction::south; break;
-			case token::undisplayed:
-				undisplayed = true; break;
-			case token::invisible:
-				invisible = true; break;
-			default:	break;
-			}
-			if (exit_for)
-				break;
-		}
-
-		field_gather * attached_field = nullptr;
-		if (name.size())
-		{
-			//find the field with specified name.
-			//the field may not be created.
-			auto i = fields.find(name);
-			if (fields.end() != i)
-			{
-				attached_field = i->second;
-				//the field is attached to a division, it means there is another division with same name.
-				if (attached_field->attached)
-					throw std::runtime_error("place, the name '" + name + "' is redefined.");
-			}
-		}
-
-		switch (div_type)
-		{
-		case token::eof:
-		case token::vert:
-			div.reset(new div_arrange(token::vert == div_type, std::move(name), std::move(arrange)));
-			break;
-		case token::grid:
-		{
-			std::unique_ptr<div_grid> p(new div_grid(std::move(name), std::move(arrange), std::move(collapses)));
-
-			if (array.size())
-				p->dimension.first = array[0].integer();
-
-			if (array.size() > 1)
-				p->dimension.second = array[1].integer();
-
-			if (0 == p->dimension.first)
-				p->dimension.first = 1;
-
-			if (0 == p->dimension.second)
-				p->dimension.second = 1;
-
-			p->revise_collapses();
-			div = std::move(p);
-		}
-			break;
-		case token::dock:
-			div.reset(new div_dock(std::move(name), this));
-			break;
-		default:
-			throw std::invalid_argument("nana.place: invalid division type.");
-		}
-
-		//Requirements for min/max
-		//1, min and max != negative
-		//2, max >= min
-		if (min_px.is_negative()) min_px.reset();
-		if (max_px.is_negative()) max_px.reset();
-		if ((!min_px.empty()) && (!max_px.empty()) && (min_px.get_value(100) > max_px.get_value(100)))
-		{
-			min_px.reset();
-			max_px.reset();
-		}
-
-		//The weight will be ignored if one of min and max is specified.
-		if (min_px.empty() && max_px.empty())
-		{
-			div->weight = weight;
-		}
-		else
-		{
-			div->min_px = min_px;
-			div->max_px = max_px;
-		}
-
-		div->gap = std::move(gap);
-
-		//attach the field to the division
-		div->field = attached_field;
-		if (attached_field)
-			attached_field->attached = div.get();
-
-		if (children.size())
-		{
-			if (division::kind::splitter == children.back()->kind_of_division)
-			{
-				children.pop_back();
-				if (children.size())
-					children.back()->div_next = nullptr;
-			}
-
-			for (auto& child : children)
-			{
-				child->div_owner = div.get();
-				if (division::kind::splitter == child->kind_of_division)
-					dynamic_cast<div_splitter&>(*child).direction(div_type != token::vert);
-			}
-
-			if (token::dock == div_type)
-			{
-				//adjust these children for dock division
-				std::vector<std::unique_ptr<division>> adjusted_children;
-				for (auto & child : children)
-				{
-					auto dockpn = new div_dockpane(std::move(child->name), this, child->dir);
-					dockpn->div_owner = child->div_owner;
-					dockpn->weight = child->weight;
-					adjusted_children.emplace_back(std::unique_ptr<division>{ dockpn });
-				}
-
-				division * next = nullptr;
-				for (auto i = adjusted_children.rbegin(); i != adjusted_children.rend(); ++i)
-				{
-					i->get()->div_next = next;
-					next = i->get();
-				}
-
-				children.swap(adjusted_children);
-			}
-		}
-
-		div->children.swap(children);
-		div->margin = std::move(margin);
-		div->dir = div_dir;
-
-		div->display = !undisplayed;
-		div->visible = !(undisplayed || invisible);
-		return div;
-	}
-
-	void place::implement::check_unique(const division* div) const
-	{
-		//The second field_impl is useless. Reuse the map type in order to
-		//reduce the size of the generated code, becuase std::set<std::string>
-		//will create a new template class.
-		std::map<std::string, field_gather*> unique;
-		field_gather tmp(nullptr);
-
-		std::function<void(const implement::division* div)> check_fn;
-		check_fn = [&check_fn, &unique, &tmp](const implement::division* div)
-		{
-			if (!div->name.empty())
-			{
-				auto & ptr = unique[div->name];
-				if (ptr)
-					throw std::invalid_argument("place, the name '" + div->name + "' is redefined.");
-				ptr = &tmp;
-			}
-
-			for (auto & child : div->children)
-			{
-				check_fn(child.get());
-			}
-		};
-
-		if (div)
-			check_fn(div);
-	}
-
-	//connect the field/dock with div object,
-	void place::implement::connect(division* start)
-	{
-		if (!start)
-			return;
-
-		this->disconnect();
-
-		std::map<std::string, field_dock*> docks_to_be_closed;
-		//disconnect
-		for (auto & dk : docks)
-		{
-			if (dk.second->attached)
-				docks_to_be_closed[dk.first] = dk.second;
-		}
-
-		std::function<void(division* div)> connect_fn;
-		connect_fn = [&connect_fn, this, &docks_to_be_closed](division* div)
-		{
-			if (div->name.size())
-			{
-				if (division::kind::dock == div->kind_of_division || division::kind::dockpane == div->kind_of_division)
-				{
-					auto i = docks.find(div->name);
-					if (i != docks.end())
-					{
-						docks_to_be_closed.erase(div->name);
-						auto pane = dynamic_cast<div_dockpane*>(div);
-						pane->dockable_field = i->second;
-
-						auto old_pane = pane->dockable_field->attached;
-						if (old_pane)
-						{
-							//old div_dockpane will be deleted
-							old_pane->dockable_field = nullptr;
-							div->display = old_pane->display;
-						}
-						pane->dockable_field->attached = pane;
-
-						if (pane->dockable_field->dockarea)
-							pane->dockable_field->dockarea->set_notifier(pane);
-					}
-				}
-				else
-				{
-					auto i = fields.find(div->name);
-					if (i != fields.end())
-					{
-						div->field = i->second;
-						div->field->attached = div;
-					}
-				}
-
-			}
-
-			for (auto & child : div->children)
-			{
-				connect_fn(child.get());
-			}
-		};
-
-		connect_fn(start);
-
-		for (auto& e : docks_to_be_closed)
-		{
-			e.second->dockarea.reset();
-			e.second->attached->dockable_field = nullptr;
-			e.second->attached = nullptr;
-		}
-	}
-
-	void place::implement::disconnect()
-	{
-		for (auto & fd : fields)
-		{
-			if (fd.second->attached)
-			{
-				fd.second->attached->field = nullptr;
-				fd.second->attached = nullptr;
-			}
-		}
-	}
-
-	//class place
-	place::place()
-		: impl_(new implement)
-	{}
-
-	place::place(window wd)
-		: impl_(new implement)
-	{
-		bind(wd);
-	}
-
-	place::~place()
-	{
-		delete impl_;
-	}
-
-	void place::bind(window wd)
-	{
-		if (impl_->window_handle)
-			throw std::runtime_error("place.bind: it has already binded to a window.");
-
-		impl_->window_handle = wd;
-		impl_->event_size_handle = API::events(wd).resized.connect([this](const arg_resized& arg)
-		{
-			if (impl_->root_division)
-			{
-				impl_->root_division->field_area.dimension({ arg.width, arg.height });
-				impl_->root_division->collocate(arg.window_handle);
-			}
-		});
-	}
-
-	window place::window_handle() const
-	{
-		return impl_->window_handle;
-	}
-
-	void place::div(const char* s)
-	{
-		place_parts::tokenizer tknizer(s);
-		impl_->disconnect();
-		auto div = impl_->scan_div(tknizer);
-		try
-		{
-			impl_->check_unique(div.get());	//may throw if there is a redefined name of field.
-			impl_->connect(div.get());
-			impl_->root_division.reset();	//clear atachments div-fields
-			impl_->root_division.swap(div);
-			impl_->div_text.assign(s);
-		}
-		catch (...)
-		{
-			//redefined a name of field
-			throw;
-		}
-	}
-
-	const std::string& place::div() const noexcept
-	{
-		return impl_->div_text;
-	}
-
-	void place::modify(const char* name, const char* div_text)
-	{
-		if (nullptr == div_text)
-			throw std::invalid_argument("nana.place: invalid div-text");
-
-		if (nullptr == name) name = "";
-
-		//check the name, it throws std::invalid_argument
-		//if name violate the naming convention.
-		place_parts::check_field_name(name);
-
-		auto div_ptr = impl_->search_div_name(impl_->root_division.get(), name);
-		if (!div_ptr)
-		{
-			std::string what = "nana::place: field '";
-			what += name;
-			what += "' is not found.";
-
-			throw std::invalid_argument(what);
-		}
-
-
-		std::unique_ptr<implement::division>* replaced = nullptr;
-
-		implement::division * div_owner = div_ptr->div_owner;
-		implement::division * div_next = div_ptr->div_next;
-		if (div_owner)
-		{
-			for (auto& child: div_owner->children)
-			{
-				if (child.get() == div_ptr)
-				{
-					replaced = &child;
-					break;
-				}
-			}
-		}
-		else
-			replaced = &(impl_->root_division);
-
-		replaced->swap(impl_->tmp_replaced);
-
-		try
-		{
-			place_parts::tokenizer tknizer(div_text);
-			auto modified = impl_->scan_div(tknizer);
-			auto modified_ptr = modified.get();
-			modified_ptr->name = name;
-
-			replaced->swap(modified);
-
-			impl_->check_unique(impl_->root_division.get());
-			impl_->connect(impl_->root_division.get());
-			impl_->tmp_replaced.reset();
-
-			modified_ptr->div_owner = div_owner;
-			modified_ptr->div_next = div_next;
-		}
-		catch (...)
-		{
-			replaced->swap(impl_->tmp_replaced);
-			throw;
-		}
-	}
-
-	place::field_reference place::field(const char* name)
-	{
-		if (nullptr == name)
-			name = "";
-
-		//check the name, it throws std::invalid_argument
-		//if name violate the naming convention.
-		place_parts::check_field_name(name);
-
-		//get the field with specified name, if no such field with specified name
-		//then create one.
-		auto & p = impl_->fields[name];
-		if (nullptr == p)
-			p = new implement::field_gather(this);
-
-		if ((!p->attached) && impl_->root_division)
-		{
-			//search the division with the specified name,
-			//and attached the division to the field
-			auto div = implement::search_div_name(impl_->root_division.get(), name);
-			if (div)
-			{
-				if (div->field && (div->field != p))
-					throw std::runtime_error("nana.place: unexpected error, the division attachs a unexpected field.");
-
-				div->field = p;
-				p->attached = div;
-			}
-		}
-		return *p;
-	}
-
-	bool is_idchar(int ch)
-	{
-		return ('_' == ch || isalpha(ch) || isalnum(ch));
-	}
-
-	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
-	{
-		const auto len = std::strlen(idstr);
-		auto pos = text.find(idstr, off);
-		if (text.npos == pos)
-			return text.npos;
-
-		if (pos && is_idchar(text[pos - 1]))
-			return text.npos;
-
-		if ((pos + len < text.length()) && is_idchar(text[pos + len]))
-			return text.npos;
-
-		return pos;
-	}
-
-	void update_div(std::string& div, const char* field, const char* attr, bool insertion)
-	{
-		const auto fieldname_pos = find_idstr(div, field);
-		if (div.npos == fieldname_pos)
-			return;
-
-		//Get the bounds of this field
-		std::size_t begin = 0, end = 0;
-
-		//Find the begin
-		int level = 0;
-		std::size_t pos = fieldname_pos;
-		while (true)
-		{
-			pos = div.find_last_of("<>", pos);
-			if (div.npos == pos)
-				return;
-
-			if ('<' == div[pos])
-			{
-				if (0 == level)
-				{
-					begin = pos;
-					break;
-				}
-				else
-					--level;
-			}
-			else
-				++level;
-		}
-
-		//Find the end
-		level = 0;
-		pos = fieldname_pos;
-		while (true)
-		{
-			pos = div.find_first_of("<>", pos);
-			if (div.npos == pos)
-				return;
-
-			if ('>' == div[pos])
-			{
-				if (0 == level)
-				{
-					end = pos + 1;
-					break;
-				}
-				else
-					--level;
-			}
-			else
-				++level;
-		}
-
-		auto fieldstr = div.substr(begin + 1, end - begin - 2);
-
-		//Search the attribute
-		for (pos = 0; true; ++pos)
-		{
-			pos = find_idstr(fieldstr, attr, pos);
-			if (fieldstr.npos == pos)
-				break;
-
-			//Check if the attr is belong to this field.
-			level = 0;
-			std::size_t off = pos;
-			while (true)
-			{
-				off = fieldstr.find_last_of("<>", off);
-				if (fieldstr.npos == off)
-					break;
-
-				if ('>' == fieldstr[off])
-					++level;
-				else
-					--level;
-
-				if (0 == off)
-					break;
-				--off;
-			}
-
-			if (0 == level)
-				break;
-		}
-
-		if (fieldstr.npos == pos)
-		{
-			//There is not an attribute
-			if (insertion)
-				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
-		}
-		else
-		{
-			//There is an attribute
-			if (!insertion)
-			{
-				div.erase(begin + pos + 1, std::strlen(attr));
-
-				if ((div[begin + pos] == div[begin + pos + 1]) && (' ' == div[begin + pos]))
-					div.erase(begin + pos, 1);
-			}
-		}
-	}
-
-	void place::field_visible(const char* name, bool vsb)
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		if (div)
-		{
-			div->set_visible(vsb);
-			update_div(impl_->div_text, name, "invisible", !vsb);
-		}
-	}
-
-	bool place::field_visible(const char* name) const
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		return (div && div->visible);
-	}
-
-	void place::field_display(const char* name, bool dsp)
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		if (div)
-		{
-			update_div(impl_->div_text, name, "invisible", false);
-			update_div(impl_->div_text, name, "undisplayed", !dsp);
-			div->set_display(dsp);
-		}
-	}
-
-	bool place::field_display(const char* name) const
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		return (div && div->display);
-	}
-
-	void place::collocate()
-	{
-		impl_->collocate();
-	}
-
-	void place::erase(window handle)
-	{
-		bool recollocate = false;
-		for (auto & fld : impl_->fields)
-		{
-			auto evt = fld.second->erase_element(fld.second->elements, handle);
-			if (evt)
-			{
-				API::umake_event(evt);
-				recollocate |= (nullptr != fld.second->attached);
-			}
-
-			API::umake_event(fld.second->erase_element(fld.second->fastened, handle));
-		}
-
-		if (recollocate)
-			collocate();
-	}
-
-	place::field_reference place::operator[](const char* name)
-	{
-		return field(name);
-	}
-
-	place& place::dock(const std::string& name, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory)
-	{
-		//check the name, it throws std::invalid_argument
-		//if name violate the naming convention.
-		place_parts::check_field_name(name.data());
-
-		auto & dock_ptr = impl_->docks[name];
-		if (!dock_ptr)
-			dock_ptr = new implement::field_dock;
-
-		//Register the factory if it has a name
-		if (!factory_name.empty())
-		{
-			if (impl_->dock_factoris.find(factory_name) != impl_->dock_factoris.end())
-				throw std::invalid_argument("nana::place - the specified factory name(" + factory_name + ") already exists");
-
-			impl_->dock_factoris[factory_name] = dock_ptr;
-			dock_ptr->factories[factory_name] = std::move(factory);
-		}
-
-		auto div = dynamic_cast<implement::div_dockpane*>(impl_->search_div_name(impl_->root_division.get(), name));
-		if (div)
-		{
-			dock_ptr->attached = div;
-			div->dockable_field = dock_ptr;
-		}
-
-		//Create the pane if it has not a name
-		if (factory_name.empty() && dock_ptr->attached)
-		{
-			dock_ptr->attached->set_display(true);
-			impl_->collocate();
-
-			if (!dock_ptr->dockarea)
-			{
-				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
-				dock_ptr->dockarea->create(impl_->window_handle);
-				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
-				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
-			}
-			dock_ptr->dockarea->add_pane(factory);
-		}
-
-		return *this;
-	}
-
-	widget* place::dock_create(const std::string& factory)
-	{
-		auto i = impl_->dock_factoris.find(factory);
-		if (i == impl_->dock_factoris.end())
-			throw std::invalid_argument("invalid factory name(" + factory + ") of dockpane");
-
-		auto dock_ptr = i->second;
-		if (dock_ptr->attached)
-		{
-			dock_ptr->attached->set_display(true);
-			impl_->collocate();
-
-			if (!dock_ptr->dockarea)
-			{
-				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
-				dock_ptr->dockarea->create(impl_->window_handle);
-				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
-				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
-			}
-
-			return dock_ptr->dockarea->add_pane(i->second->factories[factory]);
-		}
-
-		return nullptr;
-	}
-	//end class place
-}//end namespace nana
-
-#include <nana/pop_ignore_diagnostic>
+/*
+ *	An Implementation of Place for Layout
+ *	Nana C++ Library(http://www.nanapro.org)
+ *	Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
+ *
+ *	Distributed under the Boost Software License, Version 1.0.
+ *	(See accompanying file LICENSE_1_0.txt or copy at
+ *	http://www.boost.org/LICENSE_1_0.txt)
+ *
+ *	@file: nana/gui/place.cpp
+ *	@contributors: Ariel Vina-Rodriguez
+ */
+
+#include <cfloat>
+#include <cmath>
+#include <map>
+#include <deque>
+#include <algorithm>
+#include <nana/push_ignore_diagnostic>
+#include <nana/deploy.hpp>
+#include <nana/gui/place.hpp>
+#include <nana/gui/programming_interface.hpp>
+#include <nana/gui/widgets/label.hpp>
+#include <nana/gui/widgets/panel.hpp>
+#include <nana/gui/dragger.hpp>
+#include <nana/gui/drawing.hpp>
+
+#include <memory>
+#include <limits>	//numeric_limits
+#include <cstdlib>	//std::abs
+#include <cstring>	//std::memset
+
+#include "place_parts.hpp"
+
+namespace nana
+{
+	namespace place_parts
+	{
+		//check the name
+		void check_field_name(const char* name)
+		{
+			if (*name && (*name != '_' && !(('a' <= *name && *name <= 'z') || ('A' <= *name && *name <= 'Z'))))
+				throw std::invalid_argument("nana.place: bad field name");
+		}
+	}//end namespace place_parts
+
+	typedef place_parts::number_t number_t;
+	typedef place_parts::repeated_array repeated_array;
+
+	namespace place_parts
+	{
+		class tokenizer
+		{
+		public:
+			enum class token
+			{
+				div_start, div_end, splitter,
+				identifier, dock, vert, grid, number, array, reparray,
+				weight, gap, margin, arrange, variable, repeated, min_px, max_px, left, right, top, bottom, undisplayed, invisible,
+				collapse, parameters,
+				equal,
+				eof, error
+			};
+
+			tokenizer(const char* p)
+				: divstr_(p), sp_(p)
+			{}
+
+			const std::string& idstr() const
+			{
+				return idstr_;
+			}
+
+			number_t number() const
+			{
+				return number_;
+			}
+
+			std::vector<number_t>& array()
+			{
+				return array_;
+			}
+
+			repeated_array&& reparray()
+			{
+				return std::move(reparray_);
+			}
+
+			std::vector<number_t>& parameters()
+			{
+				return parameters_;
+			}
+
+			std::size_t pos() const
+			{
+				return (sp_ - divstr_);
+			}
+
+			std::string pos_str() const
+			{
+				return std::to_string(pos());
+			}
+
+			token read()
+			{
+				sp_ = _m_eat_whitespace(sp_);
+
+				std::size_t readbytes = 0;
+				switch (*sp_)
+				{
+				case '\0':
+					return token::eof;
+				case '|':
+					++sp_;
+					readbytes = _m_number(sp_, false);
+					sp_ += readbytes;
+					return token::splitter;
+				case '=':
+					++sp_;
+					return token::equal;
+				case '<':
+					++sp_;
+					return token::div_start;
+				case '>':
+					++sp_;
+					return token::div_end;
+				case '[':
+					array_.clear();
+					sp_ = _m_eat_whitespace(sp_ + 1);
+					if (*sp_ == ']')
+					{
+						++sp_;
+						return token::array;
+					}
+					else
+					{
+						//When search the repeated.
+						bool repeated = false;
+
+						while (true)
+						{
+							sp_ = _m_eat_whitespace(sp_);
+							auto tk = read();
+							if (token::number != tk && token::variable != tk && token::repeated != tk)
+								_m_throw_error("invalid array element");
+
+							if (!repeated)
+							{
+								switch (tk)
+								{
+								case token::number:
+									array_.push_back(number_);
+									break;
+								case token::variable:
+									array_.push_back({});
+									break;
+								default:
+									repeated = true;
+									reparray_.repeated();
+									reparray_.assign(std::move(array_));
+								}
+							}
+
+							sp_ = _m_eat_whitespace(sp_);
+							char ch = *sp_++;
+
+							if (ch == ']')
+								return (repeated ? token::reparray : token::array);
+
+							if (ch != ',')
+								_m_throw_error("invalid array");
+						}
+					}
+					break;
+				case '(':
+					parameters_.clear();
+					sp_ = _m_eat_whitespace(sp_ + 1);
+					if (*sp_ == ')')
+					{
+						++sp_;
+						return token::parameters;
+					}
+
+					while (true)
+					{
+						if (token::number == read())
+							parameters_.push_back(number_);
+						else
+							_m_throw_error("invalid parameter.");
+
+						sp_ = _m_eat_whitespace(sp_);
+						char ch = *sp_++;
+
+						if (ch == ')')
+							return token::parameters;
+
+						if (ch != ',')
+							_m_throw_error("invalid parameter.");
+					}
+					break;
+				case '.': case '-':
+					if (*sp_ == '-')
+					{
+						readbytes = _m_number(sp_ + 1, true);
+						if (readbytes)
+							++readbytes;
+					}
+					else
+						readbytes = _m_number(sp_, false);
+
+					if (readbytes)
+					{
+						sp_ += readbytes;
+						return token::number;
+					}
+					else
+						_m_throw_error("invalid character '" + std::string(1, *sp_) + "'");
+					break;
+				default:
+					if ('0' <= *sp_ && *sp_ <= '9')
+					{
+						readbytes = _m_number(sp_, false);
+						if (readbytes)
+						{
+							sp_ += readbytes;
+							return token::number;
+						}
+					}
+					break;
+				}
+
+				if ('_' == *sp_ || isalpha(*sp_))
+				{
+					const char * idstart = sp_++;
+
+					while ('_' == *sp_ || isalpha(*sp_) || isalnum(*sp_))
+						++sp_;
+
+					idstr_.assign(idstart, sp_);
+
+					if ("weight" == idstr_ || "min" == idstr_ || "max" == idstr_)
+					{
+						auto ch = idstr_[1];
+						_m_attr_number_value();
+						switch (ch)
+						{
+						case 'e': return token::weight;
+						case 'i': return token::min_px;
+						case 'a': return token::max_px;
+						}
+					}
+					else if ("dock" == idstr_)
+						return token::dock;
+					else if ("vertical" == idstr_ || "vert" == idstr_)
+						return token::vert;
+					else if ("variable" == idstr_ || "repeated" == idstr_)
+						return ('v' == idstr_[0] ? token::variable : token::repeated);
+					else if ("arrange" == idstr_ || "gap" == idstr_)
+					{
+						auto ch = idstr_[0];
+						_m_attr_reparray();
+						return ('a' == ch ? token::arrange : token::gap);
+					}
+					else if ("grid" == idstr_ || "margin" == idstr_)
+					{
+						auto idstr = idstr_;
+						if (token::equal != read())
+							_m_throw_error("an equal sign is required after '" + idstr + "'");
+
+						return ('g' == idstr[0] ? token::grid : token::margin);
+					}
+					else if ("collapse" == idstr_)
+					{
+						if (token::parameters != read())
+							_m_throw_error("a parameter list is required after 'collapse'");
+						return token::collapse;
+					}
+					else if ("left" == idstr_ || "right" == idstr_ || "top" == idstr_ || "bottom" == idstr_ || "undisplayed" == idstr_ || "invisible" == idstr_)
+					{
+						switch (idstr_.front())
+						{
+						case 'l': return token::left;
+						case 'r': return token::right;
+						case 't': return token::top;
+						case 'b': return token::bottom;
+						case 'u': return token::undisplayed;
+						case 'i': return token::invisible;
+						}
+					}
+
+					return token::identifier;
+				}
+
+				std::string err = "an invalid character '";
+				err += *sp_;
+				err += "'";
+
+				_m_throw_error(err);
+				return token::error;	//Useless, just for syntax correction.
+			}
+		private:
+			void _m_throw_error(char err_char)
+			{
+				std::string str = "place: invalid character '";
+				str += err_char;
+				str += '\'';
+				_m_throw_error(str);
+			}
+
+			void _m_throw_error(const std::string& err)
+			{
+				throw std::runtime_error("nana::place: " + err + " at " + std::to_string(static_cast<unsigned>(sp_ - divstr_)));
+			}
+
+			void _m_attr_number_value()
+			{
+				if (token::equal != read())
+					_m_throw_error("an equal sign is required after '" + idstr_ + "'");
+
+				auto p = _m_eat_whitespace(sp_);
+
+				auto neg_ptr = p;
+				if ('-' == *p)
+					++p;
+
+				auto len = _m_number(p, neg_ptr != p);
+				if (0 == len)
+					_m_throw_error("the '" + idstr_ + "' requires a number(integer or real or percent)");
+
+				sp_ += len + (p - sp_);
+			}
+
+			void _m_attr_reparray()
+			{
+				auto idstr = idstr_;
+				if (token::equal != read())
+					_m_throw_error("an equal sign is required after '" + idstr + "'");
+
+				sp_ = _m_eat_whitespace(sp_);
+
+				reparray_.reset();
+				auto tk = read();
+				switch (tk)
+				{
+				case token::number:
+					reparray_.push(number());
+					reparray_.repeated();
+					break;
+				case token::array:
+					reparray_.assign(std::move(array_));
+					break;
+				case token::reparray:
+					break;
+				default:
+					_m_throw_error("a (repeated) array is required after '" + idstr + "'");
+				}
+			}
+
+			static const char* _m_eat_whitespace(const char* sp)
+			{
+				while (*sp && !isgraph(*sp))
+					++sp;
+				return sp;
+			}
+
+			std::size_t _m_number(const char* sp, bool negative)
+			{
+				const char* allstart = sp;
+				sp = _m_eat_whitespace(sp);
+
+				number_.assign(0);
+
+				bool gotcha = false;
+				int integer = 0;
+				double real = 0;
+				//read the integral part.
+				const char* istart = sp;
+				while ('0' <= *sp && *sp <= '9')
+				{
+					integer = integer * 10 + (*sp - '0');
+					++sp;
+				}
+				const char* iend = sp;
+
+				if ('.' == *sp)
+				{
+					double div = 1;
+					const char* rstart = ++sp;
+					while ('0' <= *sp && *sp <= '9')
+					{
+						real += (*sp - '0') / (div *= 10);
+						++sp;
+					}
+
+					if (rstart != sp)
+					{
+						real += integer;
+						number_.assign(negative ? -real : real);
+						gotcha = true;
+					}
+				}
+				else if (istart != iend)
+				{
+					number_.assign(negative ? -integer : integer);
+					gotcha = true;
+				}
+
+				if (gotcha)
+				{
+					sp = _m_eat_whitespace(sp);
+					if ('%' == *sp)
+					{
+						if (number_t::kind::integer == number_.kind_of())
+							number_.assign_percent(number_.integer());
+						return sp - allstart + 1;
+					}
+					return sp - allstart;
+				}
+				number_.reset();
+				return 0;
+			}
+		private:
+			const char* divstr_;
+			const char* sp_;
+			std::string idstr_;
+			number_t number_;
+			std::vector<number_t> array_;
+			repeated_array		reparray_;
+			std::vector<number_t> parameters_;
+		};	//end class tokenizer
+	}
+
+	//struct implement
+	struct place::implement
+	{
+		class field_gather;
+		class field_dock;
+
+		class division;
+		class div_arrange;
+		class div_grid;
+		class div_splitter;
+		class div_dock;
+		class div_dockpane;
+
+		window window_handle{nullptr};
+		event_handle event_size_handle{nullptr};
+
+		std::string div_text;
+		std::unique_ptr<division> root_division;
+		std::map<std::string, field_gather*> fields;
+		std::map<std::string, field_dock*> docks;
+		std::map<std::string, field_dock*> dock_factoris;
+
+		//A temporary pointer used to refer to a specified div object which
+		//will be deleted in modification process.
+		std::unique_ptr<division> tmp_replaced;
+
+		//The following functions are defined behind the definition of class division.
+		//because the class division here is an incomplete type.
+		~implement();
+
+		void collocate();
+
+		static division * search_div_name(division* start, const std::string&);
+		std::unique_ptr<division> scan_div(place_parts::tokenizer&);
+		void check_unique(const division*) const;
+
+		//connect the field/dock with div object
+		void connect(division* start);
+		void disconnect();
+	};	//end struct implement
+
+	class place::implement::field_gather
+		: public place::field_interface
+	{
+	public:
+		struct element_t
+		{
+			window handle;
+			event_handle evt_destroy;
+
+			element_t(window h, event_handle event_destroy)
+				:handle(h), evt_destroy(event_destroy)
+			{}
+		};
+
+		field_gather(place * p)
+			: place_ptr_(p)
+		{}
+
+		~field_gather()
+		{
+			for (auto & e : elements)
+				API::umake_event(e.evt_destroy);
+
+			for (auto & e : fastened)
+				API::umake_event(e.evt_destroy);
+		}
+
+		void visible(bool vsb)
+		{
+			for (auto & e : elements)
+				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)
+		{
+			for (auto i = elements.begin(); i != elements.end(); ++i)
+			{
+				if (i->handle == handle)
+				{
+					auto evt_destroy = i->evt_destroy;
+					elements.erase(i);
+					return evt_destroy;
+				}
+			}
+			return nullptr;
+		}
+	private:
+		//Listen to destroy of a window
+		//It will delete the element and recollocate when the window destroyed.
+		event_handle _m_make_destroy(window wd)
+		{
+			return API::events(wd).destroy.connect([this, wd](const arg_destroy&)
+			{
+				if (erase_element(elements, wd))
+				{
+					if (!API::is_destroying(API::get_parent_window(wd)))
+						place_ptr_->collocate();
+				}
+			});
+		}
+
+		field_interface& operator<<(const char* label_text) override
+		{
+			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text ? label_text : ""));
+		}
+
+		field_interface& operator<<(std::string label_text) override
+		{
+			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text));
+		}
+
+		field_interface& operator<<(window wd) override
+		{
+			if (API::empty_window(wd))
+				throw std::invalid_argument("Place: An invalid window handle.");
+
+			if (API::get_parent_window(wd) != place_ptr_->window_handle())
+				throw std::invalid_argument("Place: the window is not a child of place bind window");
+
+			auto evt = _m_make_destroy(wd);
+			elements.emplace_back(wd, evt);
+			return *this;
+		}
+
+		field_interface& fasten(window wd) override
+		{
+			if (API::empty_window(wd))
+				throw std::invalid_argument("Place: An invalid window handle.");
+
+			if (API::get_parent_window(wd) != place_ptr_->window_handle())
+				throw std::invalid_argument("Place: the window is not a child of place bind window");
+
+			//Listen to destroy of a window. The deleting a fastened window
+			//does not change the layout.
+			auto evt = API::events(wd).destroy.connect([this](const arg_destroy& arg)
+			{
+				erase_element(fastened, arg.window_handle);
+			});
+
+			fastened.emplace_back(wd, evt);
+			return *this;
+		}
+
+		void _m_add_agent(const detail::place_agent& ag) override
+		{
+			widgets_.emplace_back(ag.create(place_ptr_->window_handle()));
+			this->operator<<(widgets_.back()->handle());
+		}
+	public:
+		division* attached{ nullptr };
+		std::vector<std::unique_ptr<nana::widget>> widgets_;
+		std::vector<element_t>	elements;
+		std::vector<element_t>	fastened;
+	private:
+		place * place_ptr_;
+	};//end class field_gather
+
+	class place::implement::field_dock
+	{
+
+	public:
+		div_dockpane * attached{ nullptr };					//attached div object
+		std::unique_ptr<place_parts::dockarea> dockarea;	//the dockable widget
+		std::map<std::string, std::function<std::unique_ptr<widget>(window)>> factories;	//factories for dockpane
+	};//end class field_dock
+
+
+
+	class place::implement::division
+	{
+	public:
+		enum class kind{ arrange, vertical_arrange, grid, splitter, dock, dockpane};
+
+		division(kind k, std::string&& n)
+			: kind_of_division(k),
+			name(std::move(n))
+		{}
+
+		virtual ~division()
+		{
+			//detach the field
+			if (field)
+				field->attached = nullptr;
+		}
+
+		void set_visible(bool vsb)
+		{
+			if (field)
+				field->visible(vsb);
+
+			_m_visible_for_child(this, vsb);
+			visible = vsb;
+		}
+
+		void set_display(bool dsp)
+		{
+			set_visible(dsp);
+			display = dsp;
+
+			if (kind::splitter != kind_of_division)
+			{
+				//Don't display the previous one, if it is a splitter
+				auto div = previous();
+				if (div && (kind::splitter == div->kind_of_division))
+				{
+					if (dsp)
+					{
+						auto leaf = div->previous();
+						if (leaf && leaf->display)
+							div->set_display(true);
+					}
+					else
+						div->set_display(false);
+				}
+
+				//Don't display the next one, if it is a splitter
+				if (div_next && (kind::splitter == div_next->kind_of_division))
+				{
+					if (dsp)
+					{
+						auto leaf = div_next->div_next;
+						if (leaf && leaf->display)
+							div_next->set_display(true);
+					}
+					else
+						div_next->set_display(false);
+				}
+			}
+			else
+			{
+				//This is a splitter, it only checks when it is being displayed
+				if (dsp)
+				{
+					//Left field of splitterbar
+					auto left = this->previous();
+					if (left && !left->display)
+						left->set_display(true);
+
+					//Right field of splitterbar
+					if (div_next && !div_next->display)
+						div_next->set_display(true);
+				}
+			}
+		}
+
+		bool is_back(const division* div) const
+		{
+			for (auto i = children.crbegin(); i != children.crend(); ++i)
+			{
+				if (!(i->get()->display))
+					continue;
+
+				return (div == i->get());
+			}
+			return false;
+		}
+
+		static double limit_px(const division* div, double px, unsigned area_px)
+		{
+			if (!div->min_px.empty())
+			{
+				auto v = div->min_px.get_value(static_cast<int>(area_px));
+				if (px < v)
+					return v;
+			}
+			if (!div->max_px.empty())
+			{
+				auto v = div->max_px.get_value(static_cast<int>(area_px));
+				if (px > v)
+					return v;
+			}
+			return px;
+		}
+
+		bool is_fixed() const
+		{
+			return (weight.kind_of() == number_t::kind::integer);
+		}
+
+		bool is_percent() const
+		{
+			return (weight.kind_of() == number_t::kind::percent);
+		}
+
+		nana::rectangle margin_area() const
+		{
+			return margin.area(field_area);
+		}
+
+		division * previous() const
+		{
+			if (div_owner)
+			{
+				for (auto & child : div_owner->children)
+					if (child->div_next == this)
+						return child.get();
+			}
+			return nullptr;
+
+		}
+	public:
+		void _m_visible_for_child(division * div, bool vsb)
+		{
+			for (auto & child : div->children)
+			{
+				if (child->field && (!vsb || child->visible))
+					child->field->visible(vsb);
+
+				_m_visible_for_child(child.get(), vsb);
+			}
+		}
+		//Collocate the division and its children divisions,
+		//The window parameter is specified for the window which the place object binded.
+		virtual void collocate(window) = 0;
+	public:
+		kind kind_of_division;
+		bool display{ true };
+		bool visible{ true };
+		::nana::direction dir{::nana::direction::west};
+		std::string name;
+		std::vector<std::unique_ptr<division>> children;
+
+		::nana::rectangle field_area;
+		number_t weight;
+		number_t min_px, max_px;
+
+		place_parts::margin	margin;
+		place_parts::repeated_array gap;
+		field_gather * field{ nullptr };
+		division * div_next{ nullptr };
+		division * div_owner{ nullptr };
+	};//end class division
+
+	class place::implement::div_arrange
+		: public division
+	{
+	public:
+		div_arrange(bool vert, std::string&& name, place_parts::repeated_array&& arr)
+			: division((vert ? kind::vertical_arrange : kind::arrange), std::move(name)),
+			arrange_(std::move(arr))
+		{}
+
+		void collocate(window wd) override
+		{
+			const bool vert = (kind::arrange != kind_of_division);
+
+			auto area_margined = margin_area();
+			rectangle_rotator area(vert, area_margined);
+			auto area_px = area.w();
+
+			auto fa = _m_fixed_and_adjustable(kind_of_division, area_px);
+
+			double adjustable_px = _m_revise_adjustable(fa, area_px);
+
+			double position = area.x();
+			std::vector<division*> delay_collocates;
+			double precise_px = 0;
+			for (auto& child_ptr : children)					/// First collocate child div's !!!
+			{
+				auto child = child_ptr.get();
+				if(!child->display)	//Ignore the division if the corresponding field is not displayed.
+					continue;
+
+				rectangle_rotator child_area(vert, child->field_area);
+				child_area.x_ref() = static_cast<int>(position);
+				child_area.y_ref() = area.y();
+				child_area.h_ref() = area.h();
+
+				double child_px;				// and calculate this div.
+				if (!child->is_fixed())			// with is fixed for fixed div
+				{
+					if (child->is_percent())			// and calculated for others: if the child div is percent - simple take it full
+						child_px = area_px * child->weight.real() + precise_px;
+					else
+						child_px = adjustable_px;
+
+					child_px = limit_px(child, child_px, area_px);
+					auto npx = static_cast<unsigned>(child_px);
+					precise_px = child_px - npx;
+					child_px = npx;
+				}
+				else
+					child_px = static_cast<unsigned>(child->weight.integer());
+
+				//Use 'endpos' to calc width is to avoid deviation
+				int endpos = static_cast<int>(position + child_px);
+				if ((!child->is_fixed()) && child->max_px.empty() && is_back(child) && (endpos != area.right()))
+					endpos = area.right();
+
+				child_area.w_ref() = static_cast<unsigned>((std::max)(endpos - child_area.x(), 0));
+
+				child->field_area = child_area.result();
+				position += child_px;
+
+				if (child->kind_of_division == kind::splitter)
+					delay_collocates.emplace_back(child);
+				else
+					child->collocate(wd);	/// The child div have full position. Now we can collocate  inside it the child fields and child-div.
+			}
+
+			for (auto child : delay_collocates)
+				child->collocate(wd);
+
+			if (visible && display && field)
+			{
+				auto element_r = area;
+				std::size_t index = 0;
+				double precise_px = 0;
+
+				for (auto & el : field->elements)
+				{
+					element_r.x_ref() = static_cast<int>(position);
+					auto px = _m_calc_number(arrange_.at(index), area_px, adjustable_px, precise_px);
+
+					element_r.w_ref() = px;
+					API::move_window(el.handle, element_r.result());
+
+					if (index + 1 < field->elements.size())
+						position += (px + _m_calc_number(gap.at(index), area_px, 0, precise_px));
+
+					++index;
+				}
+
+				for (auto & fsn : field->fastened)
+					API::move_window(fsn.handle, area_margined);
+			}
+		}
+	private:
+		static unsigned _m_calc_number(const place_parts::number_t& number, unsigned area_px, double adjustable_px, double& precise_px)
+		{
+			switch (number.kind_of())
+			{
+			case number_t::kind::integer:
+				return static_cast<unsigned>(number.integer());
+			case number_t::kind::real:
+				return static_cast<unsigned>(number.real());
+			case number_t::kind::percent:
+				adjustable_px = area_px * number.real();
+			case number_t::kind::none:
+				{
+					auto fpx = adjustable_px + precise_px;
+					auto px = static_cast<unsigned>(fpx);
+					precise_px = fpx - px;
+					return px;
+				}
+				break;
+			}
+			return 0; //Useless
+		}
+
+		static std::pair<unsigned, std::size_t> _m_calc_fa(const place_parts::number_t& number, unsigned area_px, double& precise_px)
+		{
+			std::pair<unsigned, std::size_t> result;
+			switch (number.kind_of())
+			{
+			case number_t::kind::integer:
+				result.first = static_cast<unsigned>(number.integer());
+				break;
+			case number_t::kind::real:
+				result.first = static_cast<unsigned>(number.real());
+				break;
+			case number_t::kind::percent:
+				{
+					double px = number.real() * area_px + precise_px;
+					auto npx = static_cast<unsigned>(px);
+					result.first = npx;
+					precise_px = px - npx;
+				}
+				break;
+			case number_t::kind::none:
+				++result.second;
+				break;
+			}
+			return result;
+		}
+
+		//Returns the fixed pixels and the number of adjustable items.
+		std::pair<unsigned, std::size_t> _m_fixed_and_adjustable(kind match_kind, unsigned area_px) const
+		{
+			std::pair<unsigned, std::size_t> result;
+			if (field && (kind_of_division == match_kind))
+			{
+				//Calculate fixed and adjustable of elements
+				double precise_px = 0;
+				auto count = field->elements.size();
+				for (decltype(count) i = 0; i < count; ++i)
+				{
+					auto fa = _m_calc_fa(arrange_.at(i), area_px, precise_px);
+					result.first += fa.first;
+					result.second += fa.second;
+
+					if (i + 1 < count)
+					{
+						fa = _m_calc_fa(gap.at(i), area_px, precise_px);
+						result.first += fa.first;
+						//fa.second is ignored for gap, because the it has not the adjustable gap.
+					}
+				}
+			}
+
+			double children_fixed_px = 0;
+			for (auto& child : children)
+			{
+				if (!child->display)	//Ignore the division if the corresponding field is not displayed.
+					continue;
+
+				if (!child->weight.empty())
+					children_fixed_px += child->weight.get_value(area_px);
+				else
+					++result.second;
+			}
+			result.first += static_cast<unsigned>(children_fixed_px);
+			return result;
+		}
+
+		double _m_revise_adjustable(std::pair<unsigned, std::size_t>& fa, unsigned area_px)
+		{
+			if (fa.first >= area_px || 0 == fa.second)
+				return 0;
+
+			double var_px = area_px - fa.first;
+
+			struct revise_t
+			{
+				division * div;
+				double min_px;
+				double max_px;
+			};
+
+			std::size_t min_count = 0;
+			double sum_min_px = 0;
+			std::vector<revise_t> revises;
+			for (auto& child : children)
+			{
+				if ((!child->weight.empty()) || !child->display)
+					continue;
+
+				double min_px = std::numeric_limits<double>::lowest(), max_px = std::numeric_limits<double>::lowest();
+
+				if (!child->min_px.empty())
+				{
+					min_px = child->min_px.get_value(static_cast<int>(area_px));
+					sum_min_px += min_px;
+					++min_count;
+				}
+
+				if (!child->max_px.empty())
+					max_px = child->max_px.get_value(static_cast<int>(area_px));
+
+				if (min_px >= 0 && max_px >= 0 && min_px > max_px)
+				{
+					if (child->min_px.kind_of() == number_t::kind::percent)
+						min_px = std::numeric_limits<double>::lowest();
+					else if (child->max_px.kind_of() == number_t::kind::percent)
+						max_px = std::numeric_limits<double>::lowest();
+				}
+
+				if (min_px >= 0 || max_px >= 0)
+					revises.push_back({ child.get(), min_px, max_px });
+			}
+
+			if (revises.empty())
+				return var_px / fa.second;
+
+			auto find_lowest = [&revises](double level_px)
+			{
+				double v = (std::numeric_limits<double>::max)();
+
+				for (auto i = revises.begin(); i != revises.end(); ++i)
+				{
+					auto & rev = *i;
+					if (rev.min_px >= 0 && rev.min_px < v && rev.min_px > level_px)
+						v = rev.min_px;
+					else if (rev.max_px >= 0 && rev.max_px < v)
+						v = rev.max_px;
+				}
+				return v;
+			};
+
+			auto remove_full = [&revises](double value, std::size_t& full_count)
+			{
+				full_count = 0;
+				std::size_t reached_mins = 0;
+				auto i = revises.begin();
+				while(i != revises.end())
+				{
+					if (i->max_px == value)
+					{
+						++full_count;
+						i = revises.erase(i);
+					}
+					else
+					{
+						if (i->min_px == value)
+							++reached_mins;
+						++i;
+					}
+				}
+				return reached_mins;
+			};
+
+			double block_px = 0;
+			double level_px = 0;
+			auto rest_px = var_px - sum_min_px;
+			std::size_t blocks = fa.second;
+
+			while ((rest_px > 0) && blocks)
+			{
+				auto lowest = find_lowest(level_px);
+				double fill_px = 0;
+				//blocks may be equal to min_count. E.g, all child divisions have min/max attribute.
+				if (blocks > min_count)
+				{
+					fill_px = rest_px / (blocks - min_count);
+					if (fill_px + level_px <= lowest)
+					{
+						block_px += fill_px;
+						break;
+					}
+				}
+
+				block_px = lowest;
+				if (blocks > min_count)
+					rest_px -= (lowest-level_px) * (blocks - min_count);
+
+				std::size_t full_count;
+				min_count -= remove_full(lowest, full_count);
+				blocks -= full_count;
+				level_px = lowest;
+			}
+
+			return block_px;
+		}
+	private:
+		place_parts::repeated_array arrange_;
+	};
+
+	class place::implement::div_grid
+		: public division
+	{
+	public:
+		div_grid(std::string&& name, place_parts::repeated_array&& arrange, std::vector<rectangle>&& collapses)
+			: division(kind::grid, std::move(name)),
+			arrange_(std::move(arrange)),
+			collapses_(std::move(collapses))
+		{
+			dimension.first = dimension.second = 0;
+		}
+
+		void revise_collapses()
+		{
+			if (collapses_.empty())
+				return;
+
+			for (auto i = collapses_.begin(); i != collapses_.end();)
+			{
+				if (i->x >= static_cast<int>(dimension.first) || i->y >= static_cast<int>(dimension.second))
+					i = collapses_.erase(i);
+				else
+					++i;
+			}
+
+			//Remove the overlapped collapses
+			for (std::size_t i = 0; i < collapses_.size() - 1; ++i)
+			{
+				auto & col = collapses_[i];
+				for (auto u = i + 1; u != collapses_.size();)
+				{
+					auto & z = collapses_[u];
+					if (col.is_hit(z.x, z.y) || col.is_hit(z.right(), z.y) || col.is_hit(z.x, z.bottom()) || col.is_hit(z.right(), z.bottom()))
+						collapses_.erase(collapses_.begin() + u);
+					else
+						++u;
+				}
+			}
+
+			for (auto & col : collapses_)
+			{
+				if (col.right() >= static_cast<int>(dimension.first))
+					col.width = dimension.first - static_cast<unsigned>(col.x);
+
+				if (col.bottom() >= static_cast<int>(dimension.second))
+					col.height = dimension.second - static_cast<unsigned>(col.y);
+			}
+		}
+
+		void collocate(window) override
+		{
+			if (!field || !(visible && display))
+				return;
+
+			auto area = margin_area();
+
+			unsigned gap_size = 0;
+			auto gap_number = gap.at(0);
+			if (!gap_number.empty())
+				gap_size = static_cast<unsigned>(gap_number.get_value(area.width));
+
+			//When the amount pixels of gaps is out of the area bound.
+			if ((gap_size * dimension.first >= area.width) || (gap_size * dimension.second >= area.height))
+			{
+				for (auto & el : field->elements)
+					API::window_size(el.handle, size{ 0, 0 });
+				return;
+			}
+
+			if (dimension.first <= 1 && dimension.second <= 1)
+			{
+				auto n_of_wd = field->elements.size();
+				std::size_t edge;
+				switch (n_of_wd)
+				{
+				case 0:
+				case 1:
+					edge = 1;	break;
+				case 2: case 3: case 4:
+					edge = 2;	break;
+				default:
+					edge = static_cast<std::size_t>(std::sqrt(n_of_wd));
+					if ((edge * edge) < n_of_wd) ++edge;
+				}
+
+				bool exit_for = false;
+				double y = area.y;
+				double block_w = area.width / double(edge);
+				double block_h = area.height / double((n_of_wd / edge) + (n_of_wd % edge ? 1 : 0));
+				unsigned uns_block_w = static_cast<unsigned>(block_w);
+				unsigned uns_block_h = static_cast<unsigned>(block_h);
+				unsigned height = (uns_block_h > gap_size ? uns_block_h - gap_size : uns_block_h);
+
+				auto i = field->elements.cbegin(), end = field->elements.cend();
+				std::size_t arr_pos = 0;
+				for (std::size_t u = 0; u < edge; ++u)
+				{
+					double x = area.x;
+					for (std::size_t v = 0; v < edge; ++v)
+					{
+						if (i == end)
+						{
+							exit_for = true;
+							break;
+						}
+
+						unsigned value = 0;
+						auto arr = arrange_.at(arr_pos++);
+
+						if (arr.empty())
+							value = static_cast<decltype(value)>(block_w);
+						else
+							value = static_cast<decltype(value)>(arr.get_value(static_cast<int>(area.width)));
+
+						unsigned width = (value > uns_block_w ? uns_block_w : value);
+						if (width > gap_size)	width -= gap_size;
+						API::move_window(i->handle, rectangle{ static_cast<int>(x), static_cast<int>(y), width, height });
+						x += block_w;
+						++i;
+					}
+					if (exit_for) break;
+					y += block_h;
+				}
+			}
+			else
+			{
+				double block_w = int(area.width - gap_size * (dimension.first - 1)) / double(dimension.first);
+				double block_h = int(area.height - gap_size * (dimension.second - 1)) / double(dimension.second);
+
+				std::unique_ptr<char[]> table_ptr(new char[dimension.first * dimension.second]);
+
+				char *table = table_ptr.get();
+				std::memset(table, 0, dimension.first * dimension.second);
+
+				std::size_t lbp = 0;
+				bool exit_for = false;
+
+				auto i = field->elements.cbegin(), end = field->elements.cend();
+
+				double precise_h = 0;
+				for (std::size_t c = 0; c < dimension.second; ++c)
+				{
+					unsigned block_height_px = static_cast<unsigned>(block_h + precise_h);
+					precise_h = (block_h + precise_h) - block_height_px;
+
+					double precise_w = 0;
+					for (std::size_t l = 0; l < dimension.first; ++l)
+					{
+						if (table[l + lbp])
+						{
+							precise_w += block_w;
+							auto px = static_cast<int>(precise_w);
+							precise_w -= px;
+							continue;
+						}
+
+						if (i == end)
+						{
+							exit_for = true;
+							break;
+						}
+
+						std::pair<unsigned, unsigned> room{ 1, 1 };
+
+						_m_find_collapse(static_cast<int>(l), static_cast<int>(c), room);
+
+						int pos_x = area.x + static_cast<int>(l * (block_w + gap_size));
+						int pos_y = area.y + static_cast<int>(c * (block_h + gap_size));
+
+						unsigned result_h;
+						if (room.first <= 1 && room.second <= 1)
+						{
+							precise_w += block_w;
+							result_h = block_height_px;
+							table[l + lbp] = 1;
+						}
+						else
+						{
+							precise_w += block_w * room.first + (room.first - 1) * gap_size;
+							result_h = static_cast<unsigned>(block_h * room.second + precise_h + (room.second - 1) * gap_size);
+
+							for (unsigned y = 0; y < room.second; ++y)
+								for (unsigned x = 0; x < room.first; ++x)
+									table[l + x + lbp + y * dimension.first] = 1;
+						}
+
+						unsigned result_w = static_cast<unsigned>(precise_w);
+						precise_w -= result_w;
+
+						API::move_window(i->handle, rectangle{ pos_x, pos_y, result_w, result_h });
+						++i;
+					}
+
+					if (exit_for)
+					{
+						size empty_sz;
+						for (; i != end; ++i)
+							API::window_size(i->handle, empty_sz);
+						break;
+					}
+					lbp += dimension.first;
+				}
+			}
+
+			for (auto & fsn : field->fastened)
+				API::move_window(fsn.handle, area);
+		}
+	public:
+		std::pair<unsigned, unsigned> dimension;
+	private:
+		void _m_find_collapse(int x, int y, std::pair<unsigned, unsigned>& collapse) const
+		{
+			for (auto & col : collapses_)
+			{
+				if (col.x == x && col.y == y)
+				{
+					collapse.first = col.width;
+					collapse.second = col.height;
+					return;
+				}
+			}
+		}
+	private:
+		place_parts::repeated_array arrange_;
+		std::vector<rectangle> collapses_;
+	};//end class div_grid
+
+	class place::implement::div_splitter
+		: public division
+	{
+		struct div_block
+		{
+			division * div;
+			int	pixels;
+			double		scale;
+
+			div_block(division* d, int px)
+				: div(d), pixels(px)
+			{}
+		};
+
+		enum{splitter_px = 4};
+	public:
+		div_splitter(place_parts::number_t init_weight)
+			: division(kind::splitter, std::string()),
+			init_weight_(init_weight)
+		{
+			this->weight.assign(splitter_px);
+		}
+
+		void direction(bool horizontal)
+		{
+			splitter_cursor_ = (horizontal ? cursor::size_we : cursor::size_ns);
+		}
+	private:
+		void collocate(window wd) override
+		{
+			if (API::is_destroying(wd))
+				return;
+
+			if (splitter_.empty())
+			{
+				splitter_.create(wd);
+				splitter_.cursor(splitter_cursor_);
+
+				dragger_.trigger(splitter_);
+
+				auto grab_fn = [this](const arg_mouse& arg)
+				{
+					if (false == arg.left_button)
+						return;
+
+					if (event_code::mouse_down == arg.evt_code)
+					{
+						begin_point_ = splitter_.pos();
+
+						auto px_ptr = &nana::rectangle::width;
+
+						//Use field_area of leaf, not margin_area. Otherwise splitter would be at wrong position
+						auto area_left = _m_leaf_left()->field_area;
+						auto area_right = _m_leaf_right()->field_area;
+
+						if (nana::cursor::size_we != splitter_cursor_)
+						{
+							left_pos_ = area_left.y;
+							right_pos_ = area_right.bottom();
+							px_ptr = &nana::rectangle::height;
+						}
+						else
+						{
+							left_pos_ = area_left.x;
+							right_pos_ = area_right.right();
+						}
+
+						left_pixels_ = area_left.*px_ptr;
+						right_pixels_ = area_right.*px_ptr;
+						
+						grabbed_ = true;
+					}
+					else if(event_code::mouse_up == arg.evt_code)
+					{
+						grabbed_ = false;
+					}
+					else if (event_code::mouse_move == arg.evt_code)
+					{
+						if(!grabbed_)
+							return;
+							
+						const bool vert = (::nana::cursor::size_we != splitter_cursor_);
+						auto area_px = rectangle_rotator(vert, div_owner->margin_area()).w();
+						int delta = (vert ? splitter_.pos().y - begin_point_.y : splitter_.pos().x - begin_point_.x);
+
+						int total_pixels = static_cast<int>(left_pixels_ + right_pixels_);
+
+						auto left_px = static_cast<int>(left_pixels_) + delta;
+						if (left_px > total_pixels)
+							left_px = total_pixels;
+						else if (left_px < 0)
+							left_px = 0;
+
+						double imd_rate = 100.0 / area_px;
+						left_px = static_cast<int>(limit_px(_m_leaf_left(), left_px, area_px));
+						_m_leaf_left()->weight.assign_percent(imd_rate * left_px);
+
+						auto right_px = static_cast<int>(right_pixels_) - delta;
+						if (right_px > total_pixels)
+							right_px = total_pixels;
+						else if (right_px < 0)
+							right_px = 0;
+
+						right_px = static_cast<int>(limit_px(_m_leaf_right(), right_px, area_px));
+						_m_leaf_right()->weight.assign_percent(imd_rate * right_px);
+
+						pause_move_collocate_ = true;
+						div_owner->collocate(splitter_.parent());
+
+						//After the collocating, the splitter keeps the calculated weight of left division,
+						//and clear the weight of right division.
+						_m_leaf_right()->weight.reset();
+
+						pause_move_collocate_ = false;
+					}
+				};
+
+				auto & events = splitter_.events();
+				events.mouse_down.connect_unignorable(grab_fn);
+				events.mouse_up.connect_unignorable(grab_fn);
+				events.mouse_move.connect_unignorable(grab_fn);
+			}
+
+			auto limited_range = _m_update_splitter_range();
+
+			if (!init_weight_.empty())
+			{
+				const bool vert = (::nana::cursor::size_we != splitter_cursor_);
+
+				auto leaf_left = _m_leaf_left();
+				auto leaf_right = _m_leaf_right();
+				rectangle_rotator left(vert, leaf_left->field_area);
+				rectangle_rotator right(vert, leaf_right->field_area);
+				auto area_px = right.right() - left.x();
+				auto right_px = static_cast<int>(limit_px(leaf_right, init_weight_.get_value(area_px), static_cast<unsigned>(area_px)));
+
+				auto pos = area_px - right_px - splitter_px; //New position of splitter
+				if (pos < limited_range.x())
+					pos = limited_range.x();
+				else if (pos > limited_range.right())
+					pos = limited_range.right();
+
+				rectangle_rotator sp_r(vert, field_area);
+				sp_r.x_ref() = pos;
+
+				left.w_ref() = static_cast<unsigned>(pos - left.x());
+
+				auto right_pos = right.right();
+				right.x_ref() = (pos + splitter_px);
+				right.w_ref() = static_cast<unsigned>(right_pos - pos - splitter_px);
+
+				field_area = sp_r.result();
+				leaf_left->field_area = left.result();
+				leaf_right->field_area = right.result();
+				leaf_left->collocate(wd);
+				leaf_right->collocate(wd);
+
+				//Set the leafs' weight
+				rectangle_rotator area(vert, div_owner->field_area);
+
+				double imd_rate = 100.0 / static_cast<int>(area.w());
+				leaf_left->weight.assign_percent(imd_rate * static_cast<int>(left.w()));
+				leaf_right->weight.assign_percent(imd_rate * static_cast<int>(right.w()));
+
+				splitter_.move(this->field_area);
+
+				init_weight_.reset();
+			}
+
+			if (false == pause_move_collocate_)
+				splitter_.move(this->field_area);
+		}
+	private:
+		division * _m_leaf_left() const
+		{
+			return previous();
+		}
+
+		division * _m_leaf_right() const
+		{
+			return div_next;
+		}
+
+		rectangle_rotator _m_update_splitter_range()
+		{
+			const bool vert = (cursor::size_ns == splitter_cursor_);
+
+			rectangle_rotator area(vert, div_owner->margin_area());
+
+			auto leaf_left = _m_leaf_left();
+			auto leaf_right = _m_leaf_right();
+
+			rectangle_rotator left(vert, leaf_left->field_area);
+			rectangle_rotator right(vert, leaf_right->field_area);
+
+			const int left_base = left.x(), right_base = right.right();
+			int pos = left_base;
+			int endpos = right_base;
+
+			if (!leaf_left->min_px.empty())
+			{
+				auto v = leaf_left->min_px.get_value(area.w());
+				pos += static_cast<int>(v);
+			}
+			if (!leaf_left->max_px.empty())
+			{
+				auto v = leaf_left->max_px.get_value(area.w());
+				endpos = left_base + static_cast<int>(v);
+			}
+
+			if (!leaf_right->min_px.empty())
+			{
+				auto v = leaf_right->min_px.get_value(area.w());
+				auto x = right_base - static_cast<int>(v);
+				if (x < endpos)
+					endpos = x;
+			}
+			if (!leaf_right->max_px.empty())
+			{
+				auto v = leaf_right->max_px.get_value(area.w());
+				auto x = right_base - static_cast<int>(v);
+				if (x > pos)
+					pos = x;
+			}
+
+			area.x_ref() = pos;
+			area.w_ref() = unsigned(endpos - pos + splitter_px);
+
+			dragger_.target(splitter_, area.result(), (vert ? nana::arrange::vertical : nana::arrange::horizontal));
+
+			return area;
+		}
+	private:
+		nana::cursor	splitter_cursor_{nana::cursor::arrow};
+		place_parts::splitter<true>	splitter_;
+		nana::point	begin_point_;
+		int			left_pos_, right_pos_;
+		unsigned	left_pixels_, right_pixels_;
+		dragger	dragger_;
+		bool	grabbed_{ false };
+		bool	pause_move_collocate_{ false };	//A flag represents whether do move when collocating.
+		place_parts::number_t init_weight_;
+	};
+
+	class place::implement::div_dockpane
+		: public division, public place_parts::dock_notifier_interface
+	{
+	public:
+		div_dockpane(std::string && name, implement* impl, direction pane_dir)
+			:	division(kind::dockpane, std::move(name)),
+				impl_ptr_{impl}
+		{
+			dir = pane_dir;
+			this->display = false;
+		}
+
+		~div_dockpane()
+		{
+			if (dockable_field)
+			{
+				dockable_field->dockarea.reset();
+				dockable_field->attached = nullptr;
+			}
+		}
+
+		void collocate(window) override
+		{
+			if (!dockable_field)
+			{
+				if (name.empty())
+					return;
+
+				auto &dock_ptr = impl_ptr_->docks[name];
+				if (!dock_ptr)
+					dock_ptr = new field_dock;
+
+				dock_ptr->attached = this;
+				dockable_field = dock_ptr;
+			}
+
+			auto & dockarea = dockable_field->dockarea;
+			if (dockarea && !dockarea->floating())
+				dockarea->move(this->field_area);
+		}
+	private:
+		//Implement dock_notifier_interface
+		void notify_float() override
+		{
+			set_display(false);
+			impl_ptr_->collocate();
+		}
+
+		void notify_dock() override
+		{
+			indicator_.docker.reset();
+
+			set_display(true);
+			impl_ptr_->collocate();
+		}
+
+		void notify_move() override
+		{
+			if (!_m_indicator())
+			{
+				indicator_.docker.reset();
+				return;
+			}
+
+			if (!indicator_.docker)
+			{
+				auto host_size = API::window_size(impl_ptr_->window_handle);
+				indicator_.docker.reset(new form(impl_ptr_->window_handle, { static_cast<int>(host_size.width) / 2 - 16, static_cast<int>(host_size.height) / 2 - 16, 32, 32 }, form::appear::bald<>()));
+				drawing dw(indicator_.docker->handle());
+				dw.draw([](paint::graphics& graph)
+				{
+					graph.rectangle(false, colors::midnight_blue);
+					graph.rectangle({ 1, 1, 30, 30 }, true, colors::light_sky_blue);
+
+					facade<element::arrow> arrow;
+					arrow.direction(::nana::direction::south);
+					arrow.draw(graph, colors::light_sky_blue, colors::midnight_blue, { 12, 0, 16, 16 }, element_state::normal);
+
+					graph.rectangle({ 4, 16, 24, 11 }, true, colors::midnight_blue);
+					graph.rectangle({ 5, 19, 22, 7 }, true, colors::button_face);
+				});
+
+				indicator_.docker->z_order(nullptr, ::nana::z_order_action::topmost);
+				indicator_.docker->show();
+
+				indicator_.docker->events().destroy.connect([this](const arg_destroy&)
+				{
+					if (indicator_.dock_area)
+					{
+						indicator_.dock_area.reset();
+						indicator_.graph.release();
+					}
+				});
+			}
+
+			if (_m_dockable())
+			{
+				if (!indicator_.dock_area)
+				{
+					set_display(true);
+					impl_ptr_->collocate();
+
+					indicator_.graph.make(API::window_size(impl_ptr_->window_handle));
+					API::window_graphics(impl_ptr_->window_handle, indicator_.graph);
+
+					indicator_.dock_area.reset(new panel<true>(impl_ptr_->window_handle, false));
+					indicator_.dock_area->move(this->field_area);
+
+					::nana::drawing dw(indicator_.dock_area->handle());
+					dw.draw([this](paint::graphics& graph)
+					{
+						indicator_.graph.paste(this->field_area, graph, 0, 0);
+
+						const int border_px = 4;
+						rectangle r{ graph.size() };
+						int right = r.right();
+						int bottom = r.bottom();
+
+						graph.blend(r.pare_off(border_px), colors::blue, 0.3);
+
+						::nana::color clr = colors::deep_sky_blue;
+						r.y = 0;
+						r.height = border_px;
+						graph.blend(r, clr, 0.5);
+						r.y = bottom - border_px;
+						graph.blend(r, clr, 0.5);
+
+						r.x = r.y = 0;
+						r.dimension(graph.size());
+						r.width = border_px;
+						graph.blend(r, clr, 0.5);
+						r.x = right - border_px;
+						graph.blend(r, clr, 0.5);
+
+					});
+
+					API::bring_top(indicator_.dock_area->handle(), false);
+					indicator_.dock_area->show();
+				}
+			}
+			else
+			{
+				set_display(false);
+				impl_ptr_->collocate();
+				if (indicator_.dock_area)
+				{
+					indicator_.dock_area.reset();
+					indicator_.graph.release();
+				}
+			}
+
+		}
+
+		void notify_move_stopped() override
+		{
+			if (_m_dockable() && dockable_field && dockable_field->dockarea)
+				dockable_field->dockarea->dock();
+
+			indicator_.docker.reset();
+		}
+
+		void request_close() override
+		{
+			auto window_handle = dockable_field->dockarea->handle();
+
+			//a workaround for capture
+			auto ptr = dockable_field->dockarea.release();
+			API::at_safe_place(window_handle, [ptr]
+			{
+				std::unique_ptr<typename std::remove_pointer<decltype(ptr)>::type> del(ptr);
+			});
+
+			this->set_display(false);
+			impl_ptr_->collocate();
+
+			API::close_window(window_handle);
+		}
+	private:
+		bool _m_indicator() const
+		{
+			::nana::point pos;
+			API::calc_screen_point(impl_ptr_->window_handle, pos);
+
+			rectangle r{ pos, API::window_size(impl_ptr_->window_handle) };
+			return r.is_hit(API::cursor_position());
+		}
+
+		bool _m_dockable() const
+		{
+			if (!indicator_.docker)
+				return false;
+
+			::nana::point pos;
+			API::calc_screen_point(indicator_.docker->handle(), pos);
+
+			rectangle r{ pos, API::window_size(indicator_.docker->handle()) };
+			return r.is_hit(API::cursor_position());
+		}
+	public:
+		field_dock * dockable_field{ nullptr };
+
+		std::unique_ptr<widget>	splitter;
+	private:
+		implement * impl_ptr_;
+
+		//
+		struct indicator_rep
+		{
+			paint::graphics graph;
+			std::unique_ptr<panel<true>> dock_area;
+			std::unique_ptr<form> docker;
+		}indicator_;
+	};
+
+	class place::implement::div_dock
+		: public division
+	{
+		static const unsigned splitter_px = 5;
+
+		class splitter : public panel<true>
+		{
+		public:
+			splitter(window wd, ::nana::direction dir, division* dock_dv, division* pane_dv)
+				: panel<true>(wd, true), dir_(dir), dock_dv_(dock_dv), pane_dv_(pane_dv)
+			{
+				this->bgcolor(colors::alice_blue);
+				this->cursor(_m_is_vert(dir_) ? ::nana::cursor::size_ns : ::nana::cursor::size_we);
+
+
+				auto grab_fn = [this, wd](const arg_mouse& arg)
+				{
+					if (event_code::mouse_down == arg.evt_code)	//press mouse button
+					{
+						if (arg.button != ::nana::mouse::left_button)
+							return;
+
+						bool is_vert = _m_is_vert(dir_);
+
+						this->set_capture(true);
+
+						auto basepos = API::cursor_position();
+						base_pos_.x = (is_vert ? basepos.y : basepos.x);
+
+						basepos = this->pos();
+						base_pos_.y = (is_vert ? basepos.y : basepos.x);
+
+						base_px_ = (is_vert ? pane_dv_->field_area.height : pane_dv_->field_area.width);
+					}
+					else if (event_code::mouse_move == arg.evt_code)	//hover
+					{
+						if (!arg.is_left_button())
+							return;
+
+						auto now_pos = API::cursor_position();
+						int delta = (_m_is_vert(dir_) ? now_pos.y : now_pos.x) - base_pos_.x;
+						int new_pos = base_pos_.y + delta;
+						if (new_pos < range_.x)
+						{
+							new_pos = range_.x;
+							delta = new_pos - base_pos_.y;
+						}
+						else if (new_pos >= range_.y)
+						{
+							new_pos = range_.y - 1;
+							delta = new_pos - base_pos_.y;
+						}
+
+						now_pos = this->pos();
+						if (_m_is_vert(dir_))
+							now_pos.y = new_pos;
+						else
+							now_pos.x = new_pos;
+						this->move(now_pos);
+
+						auto px = base_px_;
+						switch (dir_)
+						{
+						case ::nana::direction::west:
+						case ::nana::direction::north:
+							if (delta < 0)
+								px -= static_cast<unsigned>(-delta);
+							else
+								px += static_cast<unsigned>(delta);
+							break;
+						case ::nana::direction::east:
+						case ::nana::direction::south:
+							if (delta < 0)
+								px += static_cast<unsigned>(-delta);
+							else
+								px -= static_cast<unsigned>(delta);
+							break;
+						default:
+							break;
+						}
+
+						auto dock_px = (_m_is_vert(dir_) ? dock_dv_->field_area.height : dock_dv_->field_area.width);
+
+						pane_dv_->weight.assign_percent(double(px) / double(dock_px) * 100);
+
+						dock_dv_->collocate(wd);
+					}
+					else
+						this->release_capture();
+				};
+
+				auto & evt = this->events();
+				evt.mouse_down.connect(grab_fn);
+				evt.mouse_up.connect(grab_fn);
+				evt.mouse_move.connect(grab_fn);
+			}
+
+			void range(int begin, int end)
+			{
+				range_.x = begin;
+				range_.y = end;
+			}
+		private:
+			const ::nana::direction	dir_;
+			division* const dock_dv_;
+			division* const	pane_dv_;
+			::nana::point	range_;
+			::nana::point	base_pos_;	//x = mouse pos, y = splitter pos
+			unsigned		base_px_;	//weight of div_dockpane when mouse button is been pressing;
+
+		};
+	public:
+		div_dock(std::string && name, implement* impl)
+			: division(kind::dock, std::move(name)), impl_(impl)
+		{}
+
+		division* front() const
+		{
+			for (auto & child : children)
+			{
+				if (child->display)
+					return child.get();
+			}
+
+			return nullptr;
+		}
+
+		void collocate(window wd) override
+		{
+			auto area = this->margin_area();
+
+			unsigned vert_count = 0, horz_count = 0;
+
+			bool is_first = true;
+			bool prev_attr = false;
+
+			for (auto & child : children)
+			{
+				if (!child->display)
+					continue;
+
+				const auto is_vert = _m_is_vert(child->dir);
+				if (is_first)
+				{
+					is_first = false;
+					(is_vert ? horz_count : vert_count) = 1;
+					prev_attr = is_vert;
+				}
+
+				if ((is_vert == prev_attr) == is_vert)
+					++vert_count;
+				else
+					++horz_count;
+
+				prev_attr = is_vert;
+			}
+			if (0 == vert_count)
+				vert_count = 1;
+			if (0 == horz_count)
+				horz_count = 1;
+
+			//room indicates the size without splitters
+			::nana::size room(area.width - splitter_px * (horz_count - 1), area.height - splitter_px * (vert_count - 1));
+
+			double left = area.x;
+			double right = area.right();
+			double top = area.y;
+			double bottom = area.bottom();
+
+			for (auto & child : children)
+			{
+				if (!child->display)
+				{
+					auto child_dv = dynamic_cast<div_dockpane*>(child.get());
+					if (child_dv)
+						child_dv->splitter.reset();
+
+					continue;
+				}
+
+				auto child_dv = dynamic_cast<div_dockpane*>(child.get());
+				const bool is_vert = _m_is_vert(child->dir);
+
+				auto room_px = (is_vert ? room.height : room.width);
+
+				double weight;
+				if (!child->weight.empty())
+				{
+					weight = child->weight.get_value(is_vert ? room.height : room.width);
+					if (weight > room_px)
+						weight = room_px;
+				}
+				else
+					weight = room_px / double(is_vert ? vert_count : horz_count);
+
+				splitter* split = nullptr;
+				if (_m_right(child_dv))
+				{
+					//Creates a splitbar if the 'right' leaf is not empty
+					if (!child_dv->splitter)
+					{
+						split = new splitter(impl_->window_handle, child->dir, this, child_dv);
+						child_dv->splitter.reset(split);
+					}
+					else
+						split = dynamic_cast<splitter*>(child_dv->splitter.get());
+				}
+				else
+					child_dv->splitter.reset();
+
+				::nana::rectangle child_r;
+				double split_range_begin = -1, split_range_end = 0;
+				switch (child->dir)
+				{
+				default:
+				case ::nana::direction::west:
+					child_r.x = static_cast<int>(left);
+					child_r.y = static_cast<int>(top);
+					child_r.width = static_cast<unsigned>(weight);
+					child_r.height = static_cast<unsigned>(bottom - top);
+					left += weight;
+					if (split)
+					{
+						split->move(rectangle{ child_r.right(), child_r.y, splitter_px, child_r.height });
+						split_range_begin = left - weight;
+						split_range_end = right - static_cast<int>(splitter_px);
+						left += splitter_px;
+					}
+					break;
+				case ::nana::direction::east:
+					right -= weight;
+					child_r.x = static_cast<int>(right);
+					child_r.y = static_cast<int>(top);
+					child_r.width = static_cast<unsigned>(weight);
+					child_r.height = static_cast<unsigned>(bottom - top);
+					if (split)
+					{
+						split->move(rectangle{ child_r.x - static_cast<int>(splitter_px), child_r.y, splitter_px, child_r.height });
+						split_range_begin = left;
+						split_range_end = right - static_cast<int>(splitter_px)+weight;
+						right -= splitter_px;
+					}
+					break;
+				case ::nana::direction::north:
+					child_r.x = static_cast<int>(left);
+					child_r.y = static_cast<int>(top);
+					child_r.width = static_cast<unsigned>(right - left);
+					child_r.height = static_cast<unsigned>(weight);
+					top += weight;
+					if (split)
+					{
+						split->move(rectangle{ child_r.x, child_r.bottom(), child_r.width, splitter_px });
+						split_range_begin = top - weight;
+						split_range_end = bottom - static_cast<int>(splitter_px);
+						top += splitter_px;
+					}
+					break;
+				case ::nana::direction::south:
+					child_r.x = static_cast<int>(left);
+					bottom -= weight;
+					child_r.y = static_cast<int>(bottom);
+					child_r.width = static_cast<unsigned>(right - left);
+					child_r.height = static_cast<unsigned>(weight);
+					if (split)
+					{
+						bottom -= splitter_px;
+						split->move(rectangle{ child_r.x, child_r.y - static_cast<int>(splitter_px), child_r.width, splitter_px });
+						split_range_begin = top;
+						split_range_end = bottom + weight;
+					}
+					break;
+				}
+
+				if (split_range_begin > -0.5)
+					split->range(static_cast<int>(split_range_begin), static_cast<int>(split_range_end));
+
+				if (is_vert)
+				{
+					room.height -= child_r.height;
+					--vert_count;
+				}
+				else
+				{
+					room.width -= child_r.width;
+					--horz_count;
+				}
+
+				child->field_area = child_r;
+				child->collocate(wd);
+			}
+		}
+	private:
+		static bool _m_is_vert(::nana::direction dir)
+		{
+			return (dir == ::nana::direction::north || dir == ::nana::direction::south);
+		}
+
+		static div_dockpane* _m_right(division* dv)
+		{
+			dv = dv->div_next;
+			while (dv)
+			{
+				if (dv->display)
+					return dynamic_cast<div_dockpane*>(dv);
+
+				dv = dv->div_next;
+			}
+			return nullptr;
+		}
+	private:
+		implement * const impl_;
+	};
+
+	place::implement::~implement()
+	{
+		API::umake_event(event_size_handle);
+		root_division.reset();
+
+		for (auto & pair : fields)
+			delete pair.second;
+
+		for (auto & dock : docks)
+			delete dock.second;
+	}
+
+	void place::implement::collocate()
+	{
+		if (root_division && window_handle)
+		{
+			root_division->field_area.dimension(API::window_size(window_handle));
+
+			if (root_division->field_area.empty())
+				return;
+
+			root_division->collocate(window_handle);
+
+			for (auto & field : fields)
+			{
+				bool is_show = false;
+				if (field.second->attached && field.second->attached->visible && field.second->attached->display)
+				{
+					is_show = true;
+					auto div = field.second->attached->div_owner;
+					while (div)
+					{
+						if (!div->visible || !div->display)
+						{
+							is_show = false;
+							break;
+						}
+						div = div->div_owner;
+					}
+				}
+
+				for (auto & el : field.second->elements)
+					API::show_window(el.handle, is_show);
+			}
+		}
+	}
+
+	//search_div_name
+	//search a division with the specified name.
+	place::implement::division * place::implement::search_div_name(division* start, const std::string& name)
+	{
+		if (start)
+		{
+			if (start->name == name)
+				return start;
+
+			for (auto& child : start->children)
+			{
+				auto div = search_div_name(child.get(), name);
+				if (div)
+					return div;
+			}
+		}
+		return nullptr;
+	}
+
+	auto place::implement::scan_div(place_parts::tokenizer& tknizer) -> std::unique_ptr<division>
+	{
+		typedef place_parts::tokenizer::token token;
+
+		std::unique_ptr<division> div;
+		token div_type = token::eof;
+
+		//These variables stand for the new division's attributes
+		std::string name;
+		number_t weight, min_px, max_px;
+		place_parts::repeated_array arrange, gap;
+		place_parts::margin margin;
+		std::vector<number_t> array;
+		std::vector<rectangle> collapses;
+		std::vector<std::unique_ptr<division>> children;
+		::nana::direction div_dir = ::nana::direction::west;
+
+		bool undisplayed = false;
+		bool invisible = false;
+
+		for (token tk = tknizer.read(); tk != token::eof; tk = tknizer.read())
+		{
+			bool exit_for = false;
+			switch (tk)
+			{
+			case token::dock:
+				if (token::eof != div_type && token::dock != div_type)
+					throw std::invalid_argument("nana.place: conflict of div type at " + tknizer.pos_str());
+
+				div_type = token::dock;
+				break;
+			case token::splitter:
+				//Ignore the splitter when there is not a division.
+				if (!children.empty() && (division::kind::splitter != children.back()->kind_of_division))
+				{
+					auto splitter = new div_splitter(tknizer.number());
+					children.back()->div_next = splitter;
+					children.emplace_back(std::unique_ptr<division>{ splitter });
+				}
+				break;
+			case token::div_start:
+			{
+				auto div = scan_div(tknizer);
+				if (!children.empty())
+					children.back()->div_next = div.get();
+
+				children.emplace_back(std::move(div));
+			}
+				break;
+			case token::vert:
+				div_type = tk;
+				break;
+			case token::grid:
+				div_type = tk;
+				switch (tknizer.read())
+				{
+				case token::number:
+					array.push_back(tknizer.number());
+					array.push_back(tknizer.number());
+					break;
+				case token::array:
+					tknizer.array().swap(array);
+					break;
+				case token::reparray:
+					array.push_back(tknizer.reparray().at(0));
+					array.push_back(tknizer.reparray().at(1));
+					break;
+                default:
+                    break;
+				}
+				break;
+			case token::collapse:
+				{
+					if (tknizer.parameters().size() != 4)
+						throw std::invalid_argument("nana.place: collapse requires 4 parameters.");
+
+					auto get_number = [](const number_t & arg, const std::string& nth)
+					{
+						if (arg.kind_of() == number_t::kind::integer)
+							return arg.integer();
+						else if (arg.kind_of() == number_t::kind::real)
+							return static_cast<int>(arg.real());
+
+						throw std::invalid_argument("nana.place: the type of the "+ nth +" parameter for collapse should be integer.");
+					};
+
+					::nana::rectangle col;
+					auto arg = tknizer.parameters().at(0);
+					col.x = get_number(arg, "1st");
+
+					arg = tknizer.parameters().at(1);
+					col.y = get_number(arg, "2nd");
+
+					arg = tknizer.parameters().at(2);
+					col.width = static_cast<decltype(col.width)>(get_number(arg, "3rd"));
+
+					arg = tknizer.parameters().at(3);
+					col.height = static_cast<decltype(col.height)>(get_number(arg, "4th"));
+
+					//Check the collapse area.
+					//Ignore this collapse if its area is less than 2(col.width * col.height < 2)
+					if (!col.empty() && (col.width > 1 || col.height > 1) && (col.x >= 0 && col.y >= 0))
+					{
+						//Overwrite if a exist_col in collapses has same position as the col.
+						bool use_col = true;
+						for (auto & exist_col : collapses)
+						{
+							if (exist_col.x == col.x && exist_col.y == col.y)
+							{
+								exist_col = col;
+								use_col = false;
+								break;
+							}
+						}
+						if (use_col)
+							collapses.emplace_back(col);
+					}
+				}
+				break;
+			case token::weight: case token::min_px: case token::max_px:
+				{
+					auto n = tknizer.number();
+					//If n is the type of real, convert it to integer.
+					//the integer and percent are allowed for weight/min/max.
+					if (n.kind_of() == number_t::kind::real)
+						n.assign(static_cast<int>(n.real()));
+
+					switch (tk)
+					{
+					case token::weight: weight = n; break;
+					case token::min_px: min_px = n; break;
+					case token::max_px: max_px = n; break;
+					default: break;	//Useless
+					}
+				}
+				break;
+			case token::arrange:
+				arrange = tknizer.reparray();
+				break;
+			case token::gap:
+				gap = tknizer.reparray();
+				break;
+			case token::margin:
+				margin.clear();
+				switch (tknizer.read())
+				{
+				case token::number:
+					margin.set_value(tknizer.number());
+					break;
+				case token::array:
+					margin.set_array(tknizer.array());
+					break;
+				case token::reparray:
+					for (std::size_t i = 0; i < 4; ++i)
+					{
+						auto n = tknizer.reparray().at(i);
+						if (n.empty()) n.assign(0);
+						margin.push(n);
+					}
+					break;
+				default:
+					break;
+				}
+				break;
+			case token::div_end:
+				exit_for = true;
+				break;
+			case token::identifier:
+				name = tknizer.idstr();
+				break;
+			case token::left:
+				div_dir = ::nana::direction::west; break;
+			case token::right:
+				div_dir = ::nana::direction::east; break;
+			case token::top:
+				div_dir = ::nana::direction::north; break;
+			case token::bottom:
+				div_dir = ::nana::direction::south; break;
+			case token::undisplayed:
+				undisplayed = true; break;
+			case token::invisible:
+				invisible = true; break;
+			default:	break;
+			}
+			if (exit_for)
+				break;
+		}
+
+		field_gather * attached_field = nullptr;
+		if (name.size())
+		{
+			//find the field with specified name.
+			//the field may not be created.
+			auto i = fields.find(name);
+			if (fields.end() != i)
+			{
+				attached_field = i->second;
+				//the field is attached to a division, it means there is another division with same name.
+				if (attached_field->attached)
+					throw std::runtime_error("place, the name '" + name + "' is redefined.");
+			}
+		}
+
+		switch (div_type)
+		{
+		case token::eof:
+		case token::vert:
+			div.reset(new div_arrange(token::vert == div_type, std::move(name), std::move(arrange)));
+			break;
+		case token::grid:
+		{
+			std::unique_ptr<div_grid> p(new div_grid(std::move(name), std::move(arrange), std::move(collapses)));
+
+			if (array.size())
+				p->dimension.first = array[0].integer();
+
+			if (array.size() > 1)
+				p->dimension.second = array[1].integer();
+
+			if (0 == p->dimension.first)
+				p->dimension.first = 1;
+
+			if (0 == p->dimension.second)
+				p->dimension.second = 1;
+
+			p->revise_collapses();
+			div = std::move(p);
+		}
+			break;
+		case token::dock:
+			div.reset(new div_dock(std::move(name), this));
+			break;
+		default:
+			throw std::invalid_argument("nana.place: invalid division type.");
+		}
+
+		//Requirements for min/max
+		//1, min and max != negative
+		//2, max >= min
+		if (min_px.is_negative()) min_px.reset();
+		if (max_px.is_negative()) max_px.reset();
+		if ((!min_px.empty()) && (!max_px.empty()) && (min_px.get_value(100) > max_px.get_value(100)))
+		{
+			min_px.reset();
+			max_px.reset();
+		}
+
+		//The weight will be ignored if one of min and max is specified.
+		if (min_px.empty() && max_px.empty())
+		{
+			div->weight = weight;
+		}
+		else
+		{
+			div->min_px = min_px;
+			div->max_px = max_px;
+		}
+
+		div->gap = std::move(gap);
+
+		//attach the field to the division
+		div->field = attached_field;
+		if (attached_field)
+			attached_field->attached = div.get();
+
+		if (children.size())
+		{
+			if (division::kind::splitter == children.back()->kind_of_division)
+			{
+				children.pop_back();
+				if (children.size())
+					children.back()->div_next = nullptr;
+			}
+
+			for (auto& child : children)
+			{
+				child->div_owner = div.get();
+				if (division::kind::splitter == child->kind_of_division)
+					dynamic_cast<div_splitter&>(*child).direction(div_type != token::vert);
+			}
+
+			if (token::dock == div_type)
+			{
+				//adjust these children for dock division
+				std::vector<std::unique_ptr<division>> adjusted_children;
+				for (auto & child : children)
+				{
+					auto dockpn = new div_dockpane(std::move(child->name), this, child->dir);
+					dockpn->div_owner = child->div_owner;
+					dockpn->weight = child->weight;
+					adjusted_children.emplace_back(std::unique_ptr<division>{ dockpn });
+				}
+
+				division * next = nullptr;
+				for (auto i = adjusted_children.rbegin(); i != adjusted_children.rend(); ++i)
+				{
+					i->get()->div_next = next;
+					next = i->get();
+				}
+
+				children.swap(adjusted_children);
+			}
+		}
+
+		div->children.swap(children);
+		div->margin = std::move(margin);
+		div->dir = div_dir;
+
+		div->display = !undisplayed;
+		div->visible = !(undisplayed || invisible);
+		return div;
+	}
+
+	void place::implement::check_unique(const division* div) const
+	{
+		//The second field_impl is useless. Reuse the map type in order to
+		//reduce the size of the generated code, becuase std::set<std::string>
+		//will create a new template class.
+		std::map<std::string, field_gather*> unique;
+		field_gather tmp(nullptr);
+
+		std::function<void(const implement::division* div)> check_fn;
+		check_fn = [&check_fn, &unique, &tmp](const implement::division* div)
+		{
+			if (!div->name.empty())
+			{
+				auto & ptr = unique[div->name];
+				if (ptr)
+					throw std::invalid_argument("place, the name '" + div->name + "' is redefined.");
+				ptr = &tmp;
+			}
+
+			for (auto & child : div->children)
+			{
+				check_fn(child.get());
+			}
+		};
+
+		if (div)
+			check_fn(div);
+	}
+
+	//connect the field/dock with div object,
+	void place::implement::connect(division* start)
+	{
+		if (!start)
+			return;
+
+		this->disconnect();
+
+		std::map<std::string, field_dock*> docks_to_be_closed;
+		//disconnect
+		for (auto & dk : docks)
+		{
+			if (dk.second->attached)
+				docks_to_be_closed[dk.first] = dk.second;
+		}
+
+		std::function<void(division* div)> connect_fn;
+		connect_fn = [&connect_fn, this, &docks_to_be_closed](division* div)
+		{
+			if (div->name.size())
+			{
+				if (division::kind::dock == div->kind_of_division || division::kind::dockpane == div->kind_of_division)
+				{
+					auto i = docks.find(div->name);
+					if (i != docks.end())
+					{
+						docks_to_be_closed.erase(div->name);
+						auto pane = dynamic_cast<div_dockpane*>(div);
+						pane->dockable_field = i->second;
+
+						auto old_pane = pane->dockable_field->attached;
+						if (old_pane)
+						{
+							//old div_dockpane will be deleted
+							old_pane->dockable_field = nullptr;
+							div->display = old_pane->display;
+						}
+						pane->dockable_field->attached = pane;
+
+						if (pane->dockable_field->dockarea)
+							pane->dockable_field->dockarea->set_notifier(pane);
+					}
+				}
+				else
+				{
+					auto i = fields.find(div->name);
+					if (i != fields.end())
+					{
+						div->field = i->second;
+						div->field->attached = div;
+					}
+				}
+
+			}
+
+			for (auto & child : div->children)
+			{
+				connect_fn(child.get());
+			}
+		};
+
+		connect_fn(start);
+
+		for (auto& e : docks_to_be_closed)
+		{
+			e.second->dockarea.reset();
+			e.second->attached->dockable_field = nullptr;
+			e.second->attached = nullptr;
+		}
+	}
+
+	void place::implement::disconnect()
+	{
+		for (auto & fd : fields)
+		{
+			if (fd.second->attached)
+			{
+				fd.second->attached->field = nullptr;
+				fd.second->attached = nullptr;
+			}
+		}
+	}
+
+	//class place
+	place::place()
+		: impl_(new implement)
+	{}
+
+	place::place(window wd)
+		: impl_(new implement)
+	{
+		bind(wd);
+	}
+
+	place::~place()
+	{
+		delete impl_;
+	}
+
+	void place::bind(window wd)
+	{
+		if (impl_->window_handle)
+			throw std::runtime_error("place.bind: it has already binded to a window.");
+
+		impl_->window_handle = wd;
+		impl_->event_size_handle = API::events(wd).resized.connect([this](const arg_resized& arg)
+		{
+			if (impl_->root_division)
+			{
+				impl_->root_division->field_area.dimension({ arg.width, arg.height });
+				impl_->root_division->collocate(arg.window_handle);
+			}
+		});
+	}
+
+	window place::window_handle() const
+	{
+		return impl_->window_handle;
+	}
+
+	void place::div(const char* s)
+	{
+		place_parts::tokenizer tknizer(s);
+		impl_->disconnect();
+		auto div = impl_->scan_div(tknizer);
+		try
+		{
+			impl_->check_unique(div.get());	//may throw if there is a redefined name of field.
+			impl_->connect(div.get());
+			impl_->root_division.reset();	//clear atachments div-fields
+			impl_->root_division.swap(div);
+			impl_->div_text.assign(s);
+		}
+		catch (...)
+		{
+			//redefined a name of field
+			throw;
+		}
+	}
+
+	const std::string& place::div() const noexcept
+	{
+		return impl_->div_text;
+	}
+
+	enum div_type {	erase = 0, insert, replace };
+
+	void update_div(std::string& div, const char* field, const char* attr, div_type insertion);
+
+	void place::modify(const char* name, const char* div_text)
+	{
+		if (nullptr == div_text)
+			throw std::invalid_argument("nana.place: invalid div-text");
+
+		if (nullptr == name) name = "";
+
+		//check the name, it throws std::invalid_argument
+		//if name violate the naming convention.
+		place_parts::check_field_name(name);
+
+		auto div_ptr = impl_->search_div_name(impl_->root_division.get(), name);
+		if (!div_ptr)
+		{
+			std::string what = "nana::place: field '";
+			what += name;
+			what += "' is not found.";
+
+			throw std::invalid_argument(what);
+		}
+
+
+		std::unique_ptr<implement::division>* replaced = nullptr;
+
+		implement::division * div_owner = div_ptr->div_owner;
+		implement::division * div_next = div_ptr->div_next;
+		if (div_owner)
+		{
+			for (auto& child: div_owner->children)
+			{
+				if (child.get() == div_ptr)
+				{
+					replaced = &child;
+					break;
+				}
+			}
+		}
+		else
+			replaced = &(impl_->root_division);
+
+		replaced->swap(impl_->tmp_replaced);
+
+		try
+		{
+			place_parts::tokenizer tknizer(div_text);
+			auto modified = impl_->scan_div(tknizer);
+			auto modified_ptr = modified.get();
+			modified_ptr->name = name;
+
+			replaced->swap(modified);
+
+			impl_->check_unique(impl_->root_division.get());
+			impl_->connect(impl_->root_division.get());
+			impl_->tmp_replaced.reset();
+			update_div(impl_->div_text, name, div_text, div_type::replace);
+
+			modified_ptr->div_owner = div_owner;
+			modified_ptr->div_next = div_next;
+		}
+		catch (...)
+		{
+			replaced->swap(impl_->tmp_replaced);
+			throw;
+		}
+	}
+
+	place::field_reference place::field(const char* name)
+	{
+		if (nullptr == name)
+			name = "";
+
+		//check the name, it throws std::invalid_argument
+		//if name violate the naming convention.
+		place_parts::check_field_name(name);
+
+		//get the field with specified name, if no such field with specified name
+		//then create one.
+		auto & p = impl_->fields[name];
+		if (nullptr == p)
+			p = new implement::field_gather(this);
+
+		if ((!p->attached) && impl_->root_division)
+		{
+			//search the division with the specified name,
+			//and attached the division to the field
+			auto div = implement::search_div_name(impl_->root_division.get(), name);
+			if (div)
+			{
+				if (div->field && (div->field != p))
+					throw std::runtime_error("nana.place: unexpected error, the division attachs a unexpected field.");
+
+				div->field = p;
+				p->attached = div;
+			}
+		}
+		return *p;
+	}
+
+	bool is_idchar(int ch)
+	{
+		return ('_' == ch || isalpha(ch) || isalnum(ch));
+	}
+
+	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
+	{
+		const auto len = std::strlen(idstr);
+		auto pos = text.find(idstr, off);
+		if (text.npos == pos)
+			return text.npos;
+
+		if (pos && is_idchar(text[pos - 1]))
+			return text.npos;
+
+		if ((pos + len < text.length()) && is_idchar(text[pos + len]))
+			return text.npos;
+
+		return pos;
+	}
+
+	void update_div(std::string& div, const char* field, const char* attr, div_type insertion)
+	{
+		const auto fieldname_pos = find_idstr(div, field);
+		if (div.npos == fieldname_pos)
+			return;
+
+		//Get the bounds of this field
+		std::size_t begin = 0, end = 0;
+
+		//Find the begin
+		int level = 0;
+		std::size_t pos = fieldname_pos;
+		while (true)
+		{
+			pos = div.find_last_of("<>", pos);
+			if (div.npos == pos)
+				return;
+
+			if ('<' == div[pos])
+			{
+				if (0 == level)
+				{
+					begin = pos;
+					break;
+				}
+				else
+					--level;
+			}
+			else
+				++level;
+		}
+
+		//Find the end
+		level = 0;
+		pos = fieldname_pos;
+		while (true)
+		{
+			pos = div.find_first_of("<>", pos);
+			if (div.npos == pos)
+				return;
+
+			if ('>' == div[pos])
+			{
+				if (0 == level)
+				{
+					end = pos + 1;
+					break;
+				}
+				else
+					--level;
+			}
+			else
+				++level;
+		}
+
+		auto fieldstr = div.substr(begin + 1, end - begin - 2);
+
+		//Search the attribute
+		for (pos = 0; true; ++pos)
+		{
+			pos = find_idstr(fieldstr, attr, pos);
+			if (fieldstr.npos == pos)
+				break;
+
+			//Check if the attr is belong to this field.
+			level = 0;
+			std::size_t off = pos;
+			while (true)
+			{
+				off = fieldstr.find_last_of("<>", off);
+				if (fieldstr.npos == off)
+					break;
+
+				if ('>' == fieldstr[off])
+					++level;
+				else
+					--level;
+
+				if (0 == off)
+					break;
+				--off;
+			}
+
+			if (0 == level)
+				break;
+		}
+
+		if (fieldstr.npos == pos)
+		{
+			//There is not an attribute
+			if (insertion == div_type::insert)
+				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
+			else if (insertion == div_type::replace)
+			{
+				div.erase(begin + 1, fieldstr.length());
+				div.insert(begin + 1, std::string(attr) + " " + std::string(field));
+			}
+		}
+		else
+		{
+			//There is an attribute
+			if (insertion == div_type::erase)
+			{
+				div.erase(begin + pos + 1, std::strlen(attr));
+
+				if ((div[begin + pos] == div[begin + pos + 1]) && (' ' == div[begin + pos]))
+					div.erase(begin + pos, 1);
+			}
+		}
+	}
+
+	void place::field_visible(const char* name, bool vsb) const
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		if (div)
+		{
+			div->set_visible(vsb);
+			update_div(impl_->div_text, name, "invisible", !vsb ? div_type::insert : div_type::erase);
+		}
+	}
+
+	bool place::field_visible(const char* name) const
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		return (div && div->visible);
+	}
+
+	void place::field_display(const char* name, bool dsp) const
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		if (div)
+		{
+			update_div(impl_->div_text, name, "invisible", div_type::erase);
+			update_div(impl_->div_text, name, "undisplayed", !dsp ? div_type::insert : div_type::erase);
+			div->set_display(dsp);
+		}
+	}
+
+	bool place::field_display(const char* name) const
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		return (div && div->display);
+	}
+
+	void place::collocate()
+	{
+		impl_->collocate();
+	}
+
+	void place::erase(window handle)
+	{
+		bool recollocate = false;
+		for (auto & fld : impl_->fields)
+		{
+			auto evt = fld.second->erase_element(fld.second->elements, handle);
+			if (evt)
+			{
+				API::umake_event(evt);
+				recollocate |= (nullptr != fld.second->attached);
+			}
+
+			API::umake_event(fld.second->erase_element(fld.second->fastened, handle));
+		}
+
+		if (recollocate)
+			collocate();
+	}
+
+	place::field_reference place::operator[](const char* name)
+	{
+		return field(name);
+	}
+
+	place& place::dock(const std::string& name, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory)
+	{
+		//check the name, it throws std::invalid_argument
+		//if name violate the naming convention.
+		place_parts::check_field_name(name.data());
+
+		auto & dock_ptr = impl_->docks[name];
+		if (!dock_ptr)
+			dock_ptr = new implement::field_dock;
+
+		//Register the factory if it has a name
+		if (!factory_name.empty())
+		{
+			if (impl_->dock_factoris.find(factory_name) != impl_->dock_factoris.end())
+				throw std::invalid_argument("nana::place - the specified factory name(" + factory_name + ") already exists");
+
+			impl_->dock_factoris[factory_name] = dock_ptr;
+			dock_ptr->factories[factory_name] = std::move(factory);
+		}
+
+		auto div = dynamic_cast<implement::div_dockpane*>(impl_->search_div_name(impl_->root_division.get(), name));
+		if (div)
+		{
+			dock_ptr->attached = div;
+			div->dockable_field = dock_ptr;
+		}
+
+		//Create the pane if it has not a name
+		if (factory_name.empty() && dock_ptr->attached)
+		{
+			dock_ptr->attached->set_display(true);
+			impl_->collocate();
+
+			if (!dock_ptr->dockarea)
+			{
+				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
+				dock_ptr->dockarea->create(impl_->window_handle);
+				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
+				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
+			}
+			dock_ptr->dockarea->add_pane(factory);
+		}
+
+		return *this;
+	}
+
+	widget* place::dock_create(const std::string& factory)
+	{
+		auto i = impl_->dock_factoris.find(factory);
+		if (i == impl_->dock_factoris.end())
+			throw std::invalid_argument("invalid factory name(" + factory + ") of dockpane");
+
+		auto dock_ptr = i->second;
+		if (dock_ptr->attached)
+		{
+			dock_ptr->attached->set_display(true);
+			impl_->collocate();
+
+			if (!dock_ptr->dockarea)
+			{
+				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
+				dock_ptr->dockarea->create(impl_->window_handle);
+				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
+				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
+			}
+
+			return dock_ptr->dockarea->add_pane(i->second->factories[factory]);
+		}
+
+		return nullptr;
+	}
+	//end class place
+}//end namespace nana
+
+#include <nana/pop_ignore_diagnostic>

From 00e9c0a21f1b10fbfbe07d2e5eefca8f9bb6ca2b Mon Sep 17 00:00:00 2001
From: dankan1890 <mewuidev2@gmail.com>
Date: Thu, 29 Sep 2016 13:56:36 +0200
Subject: [PATCH 03/16] reverted

---
 include/nana/gui/place.hpp |  302 +-
 source/gui/place.cpp       | 6020 ++++++++++++++++++------------------
 2 files changed, 3156 insertions(+), 3166 deletions(-)

diff --git a/include/nana/gui/place.hpp b/include/nana/gui/place.hpp
index f6359236..176c7bd4 100644
--- a/include/nana/gui/place.hpp
+++ b/include/nana/gui/place.hpp
@@ -1,151 +1,151 @@
-/*
- *	An Implementation of Place for Layout
- *	Nana C++ Library(http://www.nanapro.org)
- *	Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
- *
- *	Distributed under the Boost Software License, Version 1.0.
- *	(See accompanying file LICENSE_1_0.txt or copy at
- *	http://www.boost.org/LICENSE_1_0.txt)
- *
- *	@file: nana/gui/place.cpp
- *
- *	@contributions:
- *	min/max and splitter bar initial weight by Ariel Vina-Rodriguez.
- */
-
-#ifndef NANA_GUI_PLACE_HPP
-#define NANA_GUI_PLACE_HPP
-#include <nana/push_ignore_diagnostic>
-#include <nana/gui/basis.hpp>
-#include <memory>
-#include <functional>
-
-namespace nana
-{
-	class widget;
-	namespace detail
-	{
-		class place_agent
-		{
-		public:
-			virtual ~place_agent() = default;
-			virtual std::unique_ptr<nana::widget> create(nana::window) const = 0;
-		};
-	}
-
-	template<typename Widget>
-	class agent
-		: public detail::place_agent
-	{
-	public:
-		agent(std::function<void(Widget&)> initializer)
-			: init_(std::move(initializer))
-		{}
-
-		agent(const char* text)
-			: text_(text)
-		{
-			throw_not_utf8(text);
-		}
-
-		agent(std::string text, std::function<void(Widget&)> initializer = {})
-			: text_(std::move(text)), init_(std::move(initializer))
-		{
-			throw_not_utf8(text_);
-		}
-
-	private:
-		std::unique_ptr<nana::widget> create(nana::window handle) const override
-		{
-			std::unique_ptr<Widget> ptr(new Widget(handle));
-			ptr->caption(text_);
-			if (init_)
-				init_(*ptr);
-			return std::move(ptr);
-		}
-	private:
-		std::string text_;
-		std::function<void(Widget&)> init_;
-	};
-
-    ///  Layout managment - an object of class place is attached to a widget, and it automatically positions and resizes the children widgets.
-	class place
-		: ::nana::noncopyable
-	{
-		struct implement;
-
-		class field_interface
-		{
-			field_interface(const field_interface&) = delete;
-			field_interface& operator=(const field_interface&) = delete;
-			field_interface(field_interface&&) = delete;
-			field_interface& operator=(field_interface&&) = delete;
-		public:
-			field_interface() = default;
-			virtual ~field_interface() = default;
-			virtual field_interface& operator<<(const char* label) = 0;
-			virtual field_interface& operator<<(std::string label) = 0;
-			virtual field_interface& operator<<(window) = 0;
-			virtual field_interface& fasten(window) = 0;
-			
-			template<typename Widget>
-			field_interface& operator<<(const agent<Widget>& ag)
-			{
-				_m_add_agent(ag);
-				return *this;
-			}
-		private:
-			virtual void _m_add_agent(const detail::place_agent&) = 0;
-		};
-	public:
-        ///  reference to a field manipulator which refers to a field object created by place 
-		using field_reference = field_interface &;
-
-		place();
-		place(window);///< Attaches to a specified widget.
-		~place();
-
-		/** @brief Bind to a window
-		 *	@param handle	A handle to a window which the place wants to attach.
-		 *	@remark	It will throw an exception if the place has already binded to a window.
-		 */
-		void bind(window handle);
-		window window_handle() const;
-        
-		void div(const char* s);			///< Divides the attached widget into fields.
-		const std::string& div() const noexcept;	///< Returns div-text that depends on fields status.
-		void modify(const char* field_name, const char* div_text);	///< Modifies a specified field.
-
-		field_reference field(const char* name);///< Returns a field with the specified name.
-
-		void field_visible(const char* field_name, bool visible) const; ///<<Shows/Hides an existing field.
-		bool field_visible(const char* field_name) const;	///<Determines whether the specified field is visible.
-
-		void field_display(const char* field_name, bool display) const; ///<Displays/Discards an existing field.
-		bool field_display(const char* field_name) const;	///<Determines whether the specified field is displayed.
-
-		void collocate();                     ///< Layouts the widgets.
-
- 		void erase(window handle);				///< Erases a window from field.
-
-		field_reference operator[](const char* name); ///< Returns a field with the specified name. Equal to field();
-
-		/// Add a panel factory
-		template<typename Panel, typename ...Args>
-		place& dock(const std::string& dockname, const std::string& factory_name, Args&& ... args)
-		{
-			return dock(dockname, factory_name, std::bind([](window parent, Args & ... args)
-			{
-				return std::unique_ptr<widget>(new Panel(parent, std::forward<Args>(args)...));
-			}, std::placeholders::_1, args...));
-		}
-
-		place& dock(const std::string& dockname, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory);
-		widget* dock_create(const std::string& factory);
-	private:
-		implement * impl_;
-	};
-}//end namespace nana
-#include <nana/pop_ignore_diagnostic>
-
-#endif //#ifndef NANA_GUI_PLACE_HPP
+/*
+ *	An Implementation of Place for Layout
+ *	Nana C++ Library(http://www.nanapro.org)
+ *	Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
+ *
+ *	Distributed under the Boost Software License, Version 1.0.
+ *	(See accompanying file LICENSE_1_0.txt or copy at
+ *	http://www.boost.org/LICENSE_1_0.txt)
+ *
+ *	@file: nana/gui/place.cpp
+ *
+ *	@contributions:
+ *	min/max and splitter bar initial weight by Ariel Vina-Rodriguez.
+ */
+
+#ifndef NANA_GUI_PLACE_HPP
+#define NANA_GUI_PLACE_HPP
+#include <nana/push_ignore_diagnostic>
+#include <nana/gui/basis.hpp>
+#include <memory>
+#include <functional>
+
+namespace nana
+{
+	class widget;
+	namespace detail
+	{
+		class place_agent
+		{
+		public:
+			virtual ~place_agent() = default;
+			virtual std::unique_ptr<nana::widget> create(nana::window) const = 0;
+		};
+	}
+
+	template<typename Widget>
+	class agent
+		: public detail::place_agent
+	{
+	public:
+		agent(std::function<void(Widget&)> initializer)
+			: init_(std::move(initializer))
+		{}
+
+		agent(const char* text)
+			: text_(text)
+		{
+			throw_not_utf8(text);
+		}
+
+		agent(std::string text, std::function<void(Widget&)> initializer = {})
+			: text_(std::move(text)), init_(std::move(initializer))
+		{
+			throw_not_utf8(text_);
+		}
+
+	private:
+		std::unique_ptr<nana::widget> create(nana::window handle) const override
+		{
+			std::unique_ptr<Widget> ptr(new Widget(handle));
+			ptr->caption(text_);
+			if (init_)
+				init_(*ptr);
+			return std::move(ptr);
+		}
+	private:
+		std::string text_;
+		std::function<void(Widget&)> init_;
+	};
+
+    ///  Layout managment - an object of class place is attached to a widget, and it automatically positions and resizes the children widgets.
+	class place
+		: ::nana::noncopyable
+	{
+		struct implement;
+
+		class field_interface
+		{
+			field_interface(const field_interface&) = delete;
+			field_interface& operator=(const field_interface&) = delete;
+			field_interface(field_interface&&) = delete;
+			field_interface& operator=(field_interface&&) = delete;
+		public:
+			field_interface() = default;
+			virtual ~field_interface() = default;
+			virtual field_interface& operator<<(const char* label) = 0;
+			virtual field_interface& operator<<(std::string label) = 0;
+			virtual field_interface& operator<<(window) = 0;
+			virtual field_interface& fasten(window) = 0;
+			
+			template<typename Widget>
+			field_interface& operator<<(const agent<Widget>& ag)
+			{
+				_m_add_agent(ag);
+				return *this;
+			}
+		private:
+			virtual void _m_add_agent(const detail::place_agent&) = 0;
+		};
+	public:
+        ///  reference to a field manipulator which refers to a field object created by place 
+		using field_reference = field_interface &;
+
+		place();
+		place(window);///< Attaches to a specified widget.
+		~place();
+
+		/** @brief Bind to a window
+		 *	@param handle	A handle to a window which the place wants to attach.
+		 *	@remark	It will throw an exception if the place has already binded to a window.
+		 */
+		void bind(window handle);
+		window window_handle() const;
+        
+		void div(const char* s);			///< Divides the attached widget into fields.
+		const std::string& div() const noexcept;	///< Returns div-text that depends on fields status.
+		void modify(const char* field_name, const char* div_text);	///< Modifies a specified field.
+
+		field_reference field(const char* name);///< Returns a field with the specified name.
+
+		void field_visible(const char* field_name, bool visible); ///<<Shows/Hides an existing field.
+		bool field_visible(const char* field_name) const;	///<Determines whether the specified field is visible.
+
+		void field_display(const char* field_name, bool display); ///<Displays/Discards an existing field.
+		bool field_display(const char* field_name) const;	///<Determines whether the specified field is displayed.
+
+		void collocate();                     ///< Layouts the widgets.
+
+ 		void erase(window handle);				///< Erases a window from field.
+
+		field_reference operator[](const char* name); ///< Returns a field with the specified name. Equal to field();
+
+		/// Add a panel factory
+		template<typename Panel, typename ...Args>
+		place& dock(const std::string& dockname, const std::string& factory_name, Args&& ... args)
+		{
+			return dock(dockname, factory_name, std::bind([](window parent, Args & ... args)
+			{
+				return std::unique_ptr<widget>(new Panel(parent, std::forward<Args>(args)...));
+			}, std::placeholders::_1, args...));
+		}
+
+		place& dock(const std::string& dockname, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory);
+		widget* dock_create(const std::string& factory);
+	private:
+		implement * impl_;
+	};
+}//end namespace nana
+#include <nana/pop_ignore_diagnostic>
+
+#endif //#ifndef NANA_GUI_PLACE_HPP
diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 77f89ba2..739b80cf 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -1,3015 +1,3005 @@
-/*
- *	An Implementation of Place for Layout
- *	Nana C++ Library(http://www.nanapro.org)
- *	Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
- *
- *	Distributed under the Boost Software License, Version 1.0.
- *	(See accompanying file LICENSE_1_0.txt or copy at
- *	http://www.boost.org/LICENSE_1_0.txt)
- *
- *	@file: nana/gui/place.cpp
- *	@contributors: Ariel Vina-Rodriguez
- */
-
-#include <cfloat>
-#include <cmath>
-#include <map>
-#include <deque>
-#include <algorithm>
-#include <nana/push_ignore_diagnostic>
-#include <nana/deploy.hpp>
-#include <nana/gui/place.hpp>
-#include <nana/gui/programming_interface.hpp>
-#include <nana/gui/widgets/label.hpp>
-#include <nana/gui/widgets/panel.hpp>
-#include <nana/gui/dragger.hpp>
-#include <nana/gui/drawing.hpp>
-
-#include <memory>
-#include <limits>	//numeric_limits
-#include <cstdlib>	//std::abs
-#include <cstring>	//std::memset
-
-#include "place_parts.hpp"
-
-namespace nana
-{
-	namespace place_parts
-	{
-		//check the name
-		void check_field_name(const char* name)
-		{
-			if (*name && (*name != '_' && !(('a' <= *name && *name <= 'z') || ('A' <= *name && *name <= 'Z'))))
-				throw std::invalid_argument("nana.place: bad field name");
-		}
-	}//end namespace place_parts
-
-	typedef place_parts::number_t number_t;
-	typedef place_parts::repeated_array repeated_array;
-
-	namespace place_parts
-	{
-		class tokenizer
-		{
-		public:
-			enum class token
-			{
-				div_start, div_end, splitter,
-				identifier, dock, vert, grid, number, array, reparray,
-				weight, gap, margin, arrange, variable, repeated, min_px, max_px, left, right, top, bottom, undisplayed, invisible,
-				collapse, parameters,
-				equal,
-				eof, error
-			};
-
-			tokenizer(const char* p)
-				: divstr_(p), sp_(p)
-			{}
-
-			const std::string& idstr() const
-			{
-				return idstr_;
-			}
-
-			number_t number() const
-			{
-				return number_;
-			}
-
-			std::vector<number_t>& array()
-			{
-				return array_;
-			}
-
-			repeated_array&& reparray()
-			{
-				return std::move(reparray_);
-			}
-
-			std::vector<number_t>& parameters()
-			{
-				return parameters_;
-			}
-
-			std::size_t pos() const
-			{
-				return (sp_ - divstr_);
-			}
-
-			std::string pos_str() const
-			{
-				return std::to_string(pos());
-			}
-
-			token read()
-			{
-				sp_ = _m_eat_whitespace(sp_);
-
-				std::size_t readbytes = 0;
-				switch (*sp_)
-				{
-				case '\0':
-					return token::eof;
-				case '|':
-					++sp_;
-					readbytes = _m_number(sp_, false);
-					sp_ += readbytes;
-					return token::splitter;
-				case '=':
-					++sp_;
-					return token::equal;
-				case '<':
-					++sp_;
-					return token::div_start;
-				case '>':
-					++sp_;
-					return token::div_end;
-				case '[':
-					array_.clear();
-					sp_ = _m_eat_whitespace(sp_ + 1);
-					if (*sp_ == ']')
-					{
-						++sp_;
-						return token::array;
-					}
-					else
-					{
-						//When search the repeated.
-						bool repeated = false;
-
-						while (true)
-						{
-							sp_ = _m_eat_whitespace(sp_);
-							auto tk = read();
-							if (token::number != tk && token::variable != tk && token::repeated != tk)
-								_m_throw_error("invalid array element");
-
-							if (!repeated)
-							{
-								switch (tk)
-								{
-								case token::number:
-									array_.push_back(number_);
-									break;
-								case token::variable:
-									array_.push_back({});
-									break;
-								default:
-									repeated = true;
-									reparray_.repeated();
-									reparray_.assign(std::move(array_));
-								}
-							}
-
-							sp_ = _m_eat_whitespace(sp_);
-							char ch = *sp_++;
-
-							if (ch == ']')
-								return (repeated ? token::reparray : token::array);
-
-							if (ch != ',')
-								_m_throw_error("invalid array");
-						}
-					}
-					break;
-				case '(':
-					parameters_.clear();
-					sp_ = _m_eat_whitespace(sp_ + 1);
-					if (*sp_ == ')')
-					{
-						++sp_;
-						return token::parameters;
-					}
-
-					while (true)
-					{
-						if (token::number == read())
-							parameters_.push_back(number_);
-						else
-							_m_throw_error("invalid parameter.");
-
-						sp_ = _m_eat_whitespace(sp_);
-						char ch = *sp_++;
-
-						if (ch == ')')
-							return token::parameters;
-
-						if (ch != ',')
-							_m_throw_error("invalid parameter.");
-					}
-					break;
-				case '.': case '-':
-					if (*sp_ == '-')
-					{
-						readbytes = _m_number(sp_ + 1, true);
-						if (readbytes)
-							++readbytes;
-					}
-					else
-						readbytes = _m_number(sp_, false);
-
-					if (readbytes)
-					{
-						sp_ += readbytes;
-						return token::number;
-					}
-					else
-						_m_throw_error("invalid character '" + std::string(1, *sp_) + "'");
-					break;
-				default:
-					if ('0' <= *sp_ && *sp_ <= '9')
-					{
-						readbytes = _m_number(sp_, false);
-						if (readbytes)
-						{
-							sp_ += readbytes;
-							return token::number;
-						}
-					}
-					break;
-				}
-
-				if ('_' == *sp_ || isalpha(*sp_))
-				{
-					const char * idstart = sp_++;
-
-					while ('_' == *sp_ || isalpha(*sp_) || isalnum(*sp_))
-						++sp_;
-
-					idstr_.assign(idstart, sp_);
-
-					if ("weight" == idstr_ || "min" == idstr_ || "max" == idstr_)
-					{
-						auto ch = idstr_[1];
-						_m_attr_number_value();
-						switch (ch)
-						{
-						case 'e': return token::weight;
-						case 'i': return token::min_px;
-						case 'a': return token::max_px;
-						}
-					}
-					else if ("dock" == idstr_)
-						return token::dock;
-					else if ("vertical" == idstr_ || "vert" == idstr_)
-						return token::vert;
-					else if ("variable" == idstr_ || "repeated" == idstr_)
-						return ('v' == idstr_[0] ? token::variable : token::repeated);
-					else if ("arrange" == idstr_ || "gap" == idstr_)
-					{
-						auto ch = idstr_[0];
-						_m_attr_reparray();
-						return ('a' == ch ? token::arrange : token::gap);
-					}
-					else if ("grid" == idstr_ || "margin" == idstr_)
-					{
-						auto idstr = idstr_;
-						if (token::equal != read())
-							_m_throw_error("an equal sign is required after '" + idstr + "'");
-
-						return ('g' == idstr[0] ? token::grid : token::margin);
-					}
-					else if ("collapse" == idstr_)
-					{
-						if (token::parameters != read())
-							_m_throw_error("a parameter list is required after 'collapse'");
-						return token::collapse;
-					}
-					else if ("left" == idstr_ || "right" == idstr_ || "top" == idstr_ || "bottom" == idstr_ || "undisplayed" == idstr_ || "invisible" == idstr_)
-					{
-						switch (idstr_.front())
-						{
-						case 'l': return token::left;
-						case 'r': return token::right;
-						case 't': return token::top;
-						case 'b': return token::bottom;
-						case 'u': return token::undisplayed;
-						case 'i': return token::invisible;
-						}
-					}
-
-					return token::identifier;
-				}
-
-				std::string err = "an invalid character '";
-				err += *sp_;
-				err += "'";
-
-				_m_throw_error(err);
-				return token::error;	//Useless, just for syntax correction.
-			}
-		private:
-			void _m_throw_error(char err_char)
-			{
-				std::string str = "place: invalid character '";
-				str += err_char;
-				str += '\'';
-				_m_throw_error(str);
-			}
-
-			void _m_throw_error(const std::string& err)
-			{
-				throw std::runtime_error("nana::place: " + err + " at " + std::to_string(static_cast<unsigned>(sp_ - divstr_)));
-			}
-
-			void _m_attr_number_value()
-			{
-				if (token::equal != read())
-					_m_throw_error("an equal sign is required after '" + idstr_ + "'");
-
-				auto p = _m_eat_whitespace(sp_);
-
-				auto neg_ptr = p;
-				if ('-' == *p)
-					++p;
-
-				auto len = _m_number(p, neg_ptr != p);
-				if (0 == len)
-					_m_throw_error("the '" + idstr_ + "' requires a number(integer or real or percent)");
-
-				sp_ += len + (p - sp_);
-			}
-
-			void _m_attr_reparray()
-			{
-				auto idstr = idstr_;
-				if (token::equal != read())
-					_m_throw_error("an equal sign is required after '" + idstr + "'");
-
-				sp_ = _m_eat_whitespace(sp_);
-
-				reparray_.reset();
-				auto tk = read();
-				switch (tk)
-				{
-				case token::number:
-					reparray_.push(number());
-					reparray_.repeated();
-					break;
-				case token::array:
-					reparray_.assign(std::move(array_));
-					break;
-				case token::reparray:
-					break;
-				default:
-					_m_throw_error("a (repeated) array is required after '" + idstr + "'");
-				}
-			}
-
-			static const char* _m_eat_whitespace(const char* sp)
-			{
-				while (*sp && !isgraph(*sp))
-					++sp;
-				return sp;
-			}
-
-			std::size_t _m_number(const char* sp, bool negative)
-			{
-				const char* allstart = sp;
-				sp = _m_eat_whitespace(sp);
-
-				number_.assign(0);
-
-				bool gotcha = false;
-				int integer = 0;
-				double real = 0;
-				//read the integral part.
-				const char* istart = sp;
-				while ('0' <= *sp && *sp <= '9')
-				{
-					integer = integer * 10 + (*sp - '0');
-					++sp;
-				}
-				const char* iend = sp;
-
-				if ('.' == *sp)
-				{
-					double div = 1;
-					const char* rstart = ++sp;
-					while ('0' <= *sp && *sp <= '9')
-					{
-						real += (*sp - '0') / (div *= 10);
-						++sp;
-					}
-
-					if (rstart != sp)
-					{
-						real += integer;
-						number_.assign(negative ? -real : real);
-						gotcha = true;
-					}
-				}
-				else if (istart != iend)
-				{
-					number_.assign(negative ? -integer : integer);
-					gotcha = true;
-				}
-
-				if (gotcha)
-				{
-					sp = _m_eat_whitespace(sp);
-					if ('%' == *sp)
-					{
-						if (number_t::kind::integer == number_.kind_of())
-							number_.assign_percent(number_.integer());
-						return sp - allstart + 1;
-					}
-					return sp - allstart;
-				}
-				number_.reset();
-				return 0;
-			}
-		private:
-			const char* divstr_;
-			const char* sp_;
-			std::string idstr_;
-			number_t number_;
-			std::vector<number_t> array_;
-			repeated_array		reparray_;
-			std::vector<number_t> parameters_;
-		};	//end class tokenizer
-	}
-
-	//struct implement
-	struct place::implement
-	{
-		class field_gather;
-		class field_dock;
-
-		class division;
-		class div_arrange;
-		class div_grid;
-		class div_splitter;
-		class div_dock;
-		class div_dockpane;
-
-		window window_handle{nullptr};
-		event_handle event_size_handle{nullptr};
-
-		std::string div_text;
-		std::unique_ptr<division> root_division;
-		std::map<std::string, field_gather*> fields;
-		std::map<std::string, field_dock*> docks;
-		std::map<std::string, field_dock*> dock_factoris;
-
-		//A temporary pointer used to refer to a specified div object which
-		//will be deleted in modification process.
-		std::unique_ptr<division> tmp_replaced;
-
-		//The following functions are defined behind the definition of class division.
-		//because the class division here is an incomplete type.
-		~implement();
-
-		void collocate();
-
-		static division * search_div_name(division* start, const std::string&);
-		std::unique_ptr<division> scan_div(place_parts::tokenizer&);
-		void check_unique(const division*) const;
-
-		//connect the field/dock with div object
-		void connect(division* start);
-		void disconnect();
-	};	//end struct implement
-
-	class place::implement::field_gather
-		: public place::field_interface
-	{
-	public:
-		struct element_t
-		{
-			window handle;
-			event_handle evt_destroy;
-
-			element_t(window h, event_handle event_destroy)
-				:handle(h), evt_destroy(event_destroy)
-			{}
-		};
-
-		field_gather(place * p)
-			: place_ptr_(p)
-		{}
-
-		~field_gather()
-		{
-			for (auto & e : elements)
-				API::umake_event(e.evt_destroy);
-
-			for (auto & e : fastened)
-				API::umake_event(e.evt_destroy);
-		}
-
-		void visible(bool vsb)
-		{
-			for (auto & e : elements)
-				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)
-		{
-			for (auto i = elements.begin(); i != elements.end(); ++i)
-			{
-				if (i->handle == handle)
-				{
-					auto evt_destroy = i->evt_destroy;
-					elements.erase(i);
-					return evt_destroy;
-				}
-			}
-			return nullptr;
-		}
-	private:
-		//Listen to destroy of a window
-		//It will delete the element and recollocate when the window destroyed.
-		event_handle _m_make_destroy(window wd)
-		{
-			return API::events(wd).destroy.connect([this, wd](const arg_destroy&)
-			{
-				if (erase_element(elements, wd))
-				{
-					if (!API::is_destroying(API::get_parent_window(wd)))
-						place_ptr_->collocate();
-				}
-			});
-		}
-
-		field_interface& operator<<(const char* label_text) override
-		{
-			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text ? label_text : ""));
-		}
-
-		field_interface& operator<<(std::string label_text) override
-		{
-			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text));
-		}
-
-		field_interface& operator<<(window wd) override
-		{
-			if (API::empty_window(wd))
-				throw std::invalid_argument("Place: An invalid window handle.");
-
-			if (API::get_parent_window(wd) != place_ptr_->window_handle())
-				throw std::invalid_argument("Place: the window is not a child of place bind window");
-
-			auto evt = _m_make_destroy(wd);
-			elements.emplace_back(wd, evt);
-			return *this;
-		}
-
-		field_interface& fasten(window wd) override
-		{
-			if (API::empty_window(wd))
-				throw std::invalid_argument("Place: An invalid window handle.");
-
-			if (API::get_parent_window(wd) != place_ptr_->window_handle())
-				throw std::invalid_argument("Place: the window is not a child of place bind window");
-
-			//Listen to destroy of a window. The deleting a fastened window
-			//does not change the layout.
-			auto evt = API::events(wd).destroy.connect([this](const arg_destroy& arg)
-			{
-				erase_element(fastened, arg.window_handle);
-			});
-
-			fastened.emplace_back(wd, evt);
-			return *this;
-		}
-
-		void _m_add_agent(const detail::place_agent& ag) override
-		{
-			widgets_.emplace_back(ag.create(place_ptr_->window_handle()));
-			this->operator<<(widgets_.back()->handle());
-		}
-	public:
-		division* attached{ nullptr };
-		std::vector<std::unique_ptr<nana::widget>> widgets_;
-		std::vector<element_t>	elements;
-		std::vector<element_t>	fastened;
-	private:
-		place * place_ptr_;
-	};//end class field_gather
-
-	class place::implement::field_dock
-	{
-
-	public:
-		div_dockpane * attached{ nullptr };					//attached div object
-		std::unique_ptr<place_parts::dockarea> dockarea;	//the dockable widget
-		std::map<std::string, std::function<std::unique_ptr<widget>(window)>> factories;	//factories for dockpane
-	};//end class field_dock
-
-
-
-	class place::implement::division
-	{
-	public:
-		enum class kind{ arrange, vertical_arrange, grid, splitter, dock, dockpane};
-
-		division(kind k, std::string&& n)
-			: kind_of_division(k),
-			name(std::move(n))
-		{}
-
-		virtual ~division()
-		{
-			//detach the field
-			if (field)
-				field->attached = nullptr;
-		}
-
-		void set_visible(bool vsb)
-		{
-			if (field)
-				field->visible(vsb);
-
-			_m_visible_for_child(this, vsb);
-			visible = vsb;
-		}
-
-		void set_display(bool dsp)
-		{
-			set_visible(dsp);
-			display = dsp;
-
-			if (kind::splitter != kind_of_division)
-			{
-				//Don't display the previous one, if it is a splitter
-				auto div = previous();
-				if (div && (kind::splitter == div->kind_of_division))
-				{
-					if (dsp)
-					{
-						auto leaf = div->previous();
-						if (leaf && leaf->display)
-							div->set_display(true);
-					}
-					else
-						div->set_display(false);
-				}
-
-				//Don't display the next one, if it is a splitter
-				if (div_next && (kind::splitter == div_next->kind_of_division))
-				{
-					if (dsp)
-					{
-						auto leaf = div_next->div_next;
-						if (leaf && leaf->display)
-							div_next->set_display(true);
-					}
-					else
-						div_next->set_display(false);
-				}
-			}
-			else
-			{
-				//This is a splitter, it only checks when it is being displayed
-				if (dsp)
-				{
-					//Left field of splitterbar
-					auto left = this->previous();
-					if (left && !left->display)
-						left->set_display(true);
-
-					//Right field of splitterbar
-					if (div_next && !div_next->display)
-						div_next->set_display(true);
-				}
-			}
-		}
-
-		bool is_back(const division* div) const
-		{
-			for (auto i = children.crbegin(); i != children.crend(); ++i)
-			{
-				if (!(i->get()->display))
-					continue;
-
-				return (div == i->get());
-			}
-			return false;
-		}
-
-		static double limit_px(const division* div, double px, unsigned area_px)
-		{
-			if (!div->min_px.empty())
-			{
-				auto v = div->min_px.get_value(static_cast<int>(area_px));
-				if (px < v)
-					return v;
-			}
-			if (!div->max_px.empty())
-			{
-				auto v = div->max_px.get_value(static_cast<int>(area_px));
-				if (px > v)
-					return v;
-			}
-			return px;
-		}
-
-		bool is_fixed() const
-		{
-			return (weight.kind_of() == number_t::kind::integer);
-		}
-
-		bool is_percent() const
-		{
-			return (weight.kind_of() == number_t::kind::percent);
-		}
-
-		nana::rectangle margin_area() const
-		{
-			return margin.area(field_area);
-		}
-
-		division * previous() const
-		{
-			if (div_owner)
-			{
-				for (auto & child : div_owner->children)
-					if (child->div_next == this)
-						return child.get();
-			}
-			return nullptr;
-
-		}
-	public:
-		void _m_visible_for_child(division * div, bool vsb)
-		{
-			for (auto & child : div->children)
-			{
-				if (child->field && (!vsb || child->visible))
-					child->field->visible(vsb);
-
-				_m_visible_for_child(child.get(), vsb);
-			}
-		}
-		//Collocate the division and its children divisions,
-		//The window parameter is specified for the window which the place object binded.
-		virtual void collocate(window) = 0;
-	public:
-		kind kind_of_division;
-		bool display{ true };
-		bool visible{ true };
-		::nana::direction dir{::nana::direction::west};
-		std::string name;
-		std::vector<std::unique_ptr<division>> children;
-
-		::nana::rectangle field_area;
-		number_t weight;
-		number_t min_px, max_px;
-
-		place_parts::margin	margin;
-		place_parts::repeated_array gap;
-		field_gather * field{ nullptr };
-		division * div_next{ nullptr };
-		division * div_owner{ nullptr };
-	};//end class division
-
-	class place::implement::div_arrange
-		: public division
-	{
-	public:
-		div_arrange(bool vert, std::string&& name, place_parts::repeated_array&& arr)
-			: division((vert ? kind::vertical_arrange : kind::arrange), std::move(name)),
-			arrange_(std::move(arr))
-		{}
-
-		void collocate(window wd) override
-		{
-			const bool vert = (kind::arrange != kind_of_division);
-
-			auto area_margined = margin_area();
-			rectangle_rotator area(vert, area_margined);
-			auto area_px = area.w();
-
-			auto fa = _m_fixed_and_adjustable(kind_of_division, area_px);
-
-			double adjustable_px = _m_revise_adjustable(fa, area_px);
-
-			double position = area.x();
-			std::vector<division*> delay_collocates;
-			double precise_px = 0;
-			for (auto& child_ptr : children)					/// First collocate child div's !!!
-			{
-				auto child = child_ptr.get();
-				if(!child->display)	//Ignore the division if the corresponding field is not displayed.
-					continue;
-
-				rectangle_rotator child_area(vert, child->field_area);
-				child_area.x_ref() = static_cast<int>(position);
-				child_area.y_ref() = area.y();
-				child_area.h_ref() = area.h();
-
-				double child_px;				// and calculate this div.
-				if (!child->is_fixed())			// with is fixed for fixed div
-				{
-					if (child->is_percent())			// and calculated for others: if the child div is percent - simple take it full
-						child_px = area_px * child->weight.real() + precise_px;
-					else
-						child_px = adjustable_px;
-
-					child_px = limit_px(child, child_px, area_px);
-					auto npx = static_cast<unsigned>(child_px);
-					precise_px = child_px - npx;
-					child_px = npx;
-				}
-				else
-					child_px = static_cast<unsigned>(child->weight.integer());
-
-				//Use 'endpos' to calc width is to avoid deviation
-				int endpos = static_cast<int>(position + child_px);
-				if ((!child->is_fixed()) && child->max_px.empty() && is_back(child) && (endpos != area.right()))
-					endpos = area.right();
-
-				child_area.w_ref() = static_cast<unsigned>((std::max)(endpos - child_area.x(), 0));
-
-				child->field_area = child_area.result();
-				position += child_px;
-
-				if (child->kind_of_division == kind::splitter)
-					delay_collocates.emplace_back(child);
-				else
-					child->collocate(wd);	/// The child div have full position. Now we can collocate  inside it the child fields and child-div.
-			}
-
-			for (auto child : delay_collocates)
-				child->collocate(wd);
-
-			if (visible && display && field)
-			{
-				auto element_r = area;
-				std::size_t index = 0;
-				double precise_px = 0;
-
-				for (auto & el : field->elements)
-				{
-					element_r.x_ref() = static_cast<int>(position);
-					auto px = _m_calc_number(arrange_.at(index), area_px, adjustable_px, precise_px);
-
-					element_r.w_ref() = px;
-					API::move_window(el.handle, element_r.result());
-
-					if (index + 1 < field->elements.size())
-						position += (px + _m_calc_number(gap.at(index), area_px, 0, precise_px));
-
-					++index;
-				}
-
-				for (auto & fsn : field->fastened)
-					API::move_window(fsn.handle, area_margined);
-			}
-		}
-	private:
-		static unsigned _m_calc_number(const place_parts::number_t& number, unsigned area_px, double adjustable_px, double& precise_px)
-		{
-			switch (number.kind_of())
-			{
-			case number_t::kind::integer:
-				return static_cast<unsigned>(number.integer());
-			case number_t::kind::real:
-				return static_cast<unsigned>(number.real());
-			case number_t::kind::percent:
-				adjustable_px = area_px * number.real();
-			case number_t::kind::none:
-				{
-					auto fpx = adjustable_px + precise_px;
-					auto px = static_cast<unsigned>(fpx);
-					precise_px = fpx - px;
-					return px;
-				}
-				break;
-			}
-			return 0; //Useless
-		}
-
-		static std::pair<unsigned, std::size_t> _m_calc_fa(const place_parts::number_t& number, unsigned area_px, double& precise_px)
-		{
-			std::pair<unsigned, std::size_t> result;
-			switch (number.kind_of())
-			{
-			case number_t::kind::integer:
-				result.first = static_cast<unsigned>(number.integer());
-				break;
-			case number_t::kind::real:
-				result.first = static_cast<unsigned>(number.real());
-				break;
-			case number_t::kind::percent:
-				{
-					double px = number.real() * area_px + precise_px;
-					auto npx = static_cast<unsigned>(px);
-					result.first = npx;
-					precise_px = px - npx;
-				}
-				break;
-			case number_t::kind::none:
-				++result.second;
-				break;
-			}
-			return result;
-		}
-
-		//Returns the fixed pixels and the number of adjustable items.
-		std::pair<unsigned, std::size_t> _m_fixed_and_adjustable(kind match_kind, unsigned area_px) const
-		{
-			std::pair<unsigned, std::size_t> result;
-			if (field && (kind_of_division == match_kind))
-			{
-				//Calculate fixed and adjustable of elements
-				double precise_px = 0;
-				auto count = field->elements.size();
-				for (decltype(count) i = 0; i < count; ++i)
-				{
-					auto fa = _m_calc_fa(arrange_.at(i), area_px, precise_px);
-					result.first += fa.first;
-					result.second += fa.second;
-
-					if (i + 1 < count)
-					{
-						fa = _m_calc_fa(gap.at(i), area_px, precise_px);
-						result.first += fa.first;
-						//fa.second is ignored for gap, because the it has not the adjustable gap.
-					}
-				}
-			}
-
-			double children_fixed_px = 0;
-			for (auto& child : children)
-			{
-				if (!child->display)	//Ignore the division if the corresponding field is not displayed.
-					continue;
-
-				if (!child->weight.empty())
-					children_fixed_px += child->weight.get_value(area_px);
-				else
-					++result.second;
-			}
-			result.first += static_cast<unsigned>(children_fixed_px);
-			return result;
-		}
-
-		double _m_revise_adjustable(std::pair<unsigned, std::size_t>& fa, unsigned area_px)
-		{
-			if (fa.first >= area_px || 0 == fa.second)
-				return 0;
-
-			double var_px = area_px - fa.first;
-
-			struct revise_t
-			{
-				division * div;
-				double min_px;
-				double max_px;
-			};
-
-			std::size_t min_count = 0;
-			double sum_min_px = 0;
-			std::vector<revise_t> revises;
-			for (auto& child : children)
-			{
-				if ((!child->weight.empty()) || !child->display)
-					continue;
-
-				double min_px = std::numeric_limits<double>::lowest(), max_px = std::numeric_limits<double>::lowest();
-
-				if (!child->min_px.empty())
-				{
-					min_px = child->min_px.get_value(static_cast<int>(area_px));
-					sum_min_px += min_px;
-					++min_count;
-				}
-
-				if (!child->max_px.empty())
-					max_px = child->max_px.get_value(static_cast<int>(area_px));
-
-				if (min_px >= 0 && max_px >= 0 && min_px > max_px)
-				{
-					if (child->min_px.kind_of() == number_t::kind::percent)
-						min_px = std::numeric_limits<double>::lowest();
-					else if (child->max_px.kind_of() == number_t::kind::percent)
-						max_px = std::numeric_limits<double>::lowest();
-				}
-
-				if (min_px >= 0 || max_px >= 0)
-					revises.push_back({ child.get(), min_px, max_px });
-			}
-
-			if (revises.empty())
-				return var_px / fa.second;
-
-			auto find_lowest = [&revises](double level_px)
-			{
-				double v = (std::numeric_limits<double>::max)();
-
-				for (auto i = revises.begin(); i != revises.end(); ++i)
-				{
-					auto & rev = *i;
-					if (rev.min_px >= 0 && rev.min_px < v && rev.min_px > level_px)
-						v = rev.min_px;
-					else if (rev.max_px >= 0 && rev.max_px < v)
-						v = rev.max_px;
-				}
-				return v;
-			};
-
-			auto remove_full = [&revises](double value, std::size_t& full_count)
-			{
-				full_count = 0;
-				std::size_t reached_mins = 0;
-				auto i = revises.begin();
-				while(i != revises.end())
-				{
-					if (i->max_px == value)
-					{
-						++full_count;
-						i = revises.erase(i);
-					}
-					else
-					{
-						if (i->min_px == value)
-							++reached_mins;
-						++i;
-					}
-				}
-				return reached_mins;
-			};
-
-			double block_px = 0;
-			double level_px = 0;
-			auto rest_px = var_px - sum_min_px;
-			std::size_t blocks = fa.second;
-
-			while ((rest_px > 0) && blocks)
-			{
-				auto lowest = find_lowest(level_px);
-				double fill_px = 0;
-				//blocks may be equal to min_count. E.g, all child divisions have min/max attribute.
-				if (blocks > min_count)
-				{
-					fill_px = rest_px / (blocks - min_count);
-					if (fill_px + level_px <= lowest)
-					{
-						block_px += fill_px;
-						break;
-					}
-				}
-
-				block_px = lowest;
-				if (blocks > min_count)
-					rest_px -= (lowest-level_px) * (blocks - min_count);
-
-				std::size_t full_count;
-				min_count -= remove_full(lowest, full_count);
-				blocks -= full_count;
-				level_px = lowest;
-			}
-
-			return block_px;
-		}
-	private:
-		place_parts::repeated_array arrange_;
-	};
-
-	class place::implement::div_grid
-		: public division
-	{
-	public:
-		div_grid(std::string&& name, place_parts::repeated_array&& arrange, std::vector<rectangle>&& collapses)
-			: division(kind::grid, std::move(name)),
-			arrange_(std::move(arrange)),
-			collapses_(std::move(collapses))
-		{
-			dimension.first = dimension.second = 0;
-		}
-
-		void revise_collapses()
-		{
-			if (collapses_.empty())
-				return;
-
-			for (auto i = collapses_.begin(); i != collapses_.end();)
-			{
-				if (i->x >= static_cast<int>(dimension.first) || i->y >= static_cast<int>(dimension.second))
-					i = collapses_.erase(i);
-				else
-					++i;
-			}
-
-			//Remove the overlapped collapses
-			for (std::size_t i = 0; i < collapses_.size() - 1; ++i)
-			{
-				auto & col = collapses_[i];
-				for (auto u = i + 1; u != collapses_.size();)
-				{
-					auto & z = collapses_[u];
-					if (col.is_hit(z.x, z.y) || col.is_hit(z.right(), z.y) || col.is_hit(z.x, z.bottom()) || col.is_hit(z.right(), z.bottom()))
-						collapses_.erase(collapses_.begin() + u);
-					else
-						++u;
-				}
-			}
-
-			for (auto & col : collapses_)
-			{
-				if (col.right() >= static_cast<int>(dimension.first))
-					col.width = dimension.first - static_cast<unsigned>(col.x);
-
-				if (col.bottom() >= static_cast<int>(dimension.second))
-					col.height = dimension.second - static_cast<unsigned>(col.y);
-			}
-		}
-
-		void collocate(window) override
-		{
-			if (!field || !(visible && display))
-				return;
-
-			auto area = margin_area();
-
-			unsigned gap_size = 0;
-			auto gap_number = gap.at(0);
-			if (!gap_number.empty())
-				gap_size = static_cast<unsigned>(gap_number.get_value(area.width));
-
-			//When the amount pixels of gaps is out of the area bound.
-			if ((gap_size * dimension.first >= area.width) || (gap_size * dimension.second >= area.height))
-			{
-				for (auto & el : field->elements)
-					API::window_size(el.handle, size{ 0, 0 });
-				return;
-			}
-
-			if (dimension.first <= 1 && dimension.second <= 1)
-			{
-				auto n_of_wd = field->elements.size();
-				std::size_t edge;
-				switch (n_of_wd)
-				{
-				case 0:
-				case 1:
-					edge = 1;	break;
-				case 2: case 3: case 4:
-					edge = 2;	break;
-				default:
-					edge = static_cast<std::size_t>(std::sqrt(n_of_wd));
-					if ((edge * edge) < n_of_wd) ++edge;
-				}
-
-				bool exit_for = false;
-				double y = area.y;
-				double block_w = area.width / double(edge);
-				double block_h = area.height / double((n_of_wd / edge) + (n_of_wd % edge ? 1 : 0));
-				unsigned uns_block_w = static_cast<unsigned>(block_w);
-				unsigned uns_block_h = static_cast<unsigned>(block_h);
-				unsigned height = (uns_block_h > gap_size ? uns_block_h - gap_size : uns_block_h);
-
-				auto i = field->elements.cbegin(), end = field->elements.cend();
-				std::size_t arr_pos = 0;
-				for (std::size_t u = 0; u < edge; ++u)
-				{
-					double x = area.x;
-					for (std::size_t v = 0; v < edge; ++v)
-					{
-						if (i == end)
-						{
-							exit_for = true;
-							break;
-						}
-
-						unsigned value = 0;
-						auto arr = arrange_.at(arr_pos++);
-
-						if (arr.empty())
-							value = static_cast<decltype(value)>(block_w);
-						else
-							value = static_cast<decltype(value)>(arr.get_value(static_cast<int>(area.width)));
-
-						unsigned width = (value > uns_block_w ? uns_block_w : value);
-						if (width > gap_size)	width -= gap_size;
-						API::move_window(i->handle, rectangle{ static_cast<int>(x), static_cast<int>(y), width, height });
-						x += block_w;
-						++i;
-					}
-					if (exit_for) break;
-					y += block_h;
-				}
-			}
-			else
-			{
-				double block_w = int(area.width - gap_size * (dimension.first - 1)) / double(dimension.first);
-				double block_h = int(area.height - gap_size * (dimension.second - 1)) / double(dimension.second);
-
-				std::unique_ptr<char[]> table_ptr(new char[dimension.first * dimension.second]);
-
-				char *table = table_ptr.get();
-				std::memset(table, 0, dimension.first * dimension.second);
-
-				std::size_t lbp = 0;
-				bool exit_for = false;
-
-				auto i = field->elements.cbegin(), end = field->elements.cend();
-
-				double precise_h = 0;
-				for (std::size_t c = 0; c < dimension.second; ++c)
-				{
-					unsigned block_height_px = static_cast<unsigned>(block_h + precise_h);
-					precise_h = (block_h + precise_h) - block_height_px;
-
-					double precise_w = 0;
-					for (std::size_t l = 0; l < dimension.first; ++l)
-					{
-						if (table[l + lbp])
-						{
-							precise_w += block_w;
-							auto px = static_cast<int>(precise_w);
-							precise_w -= px;
-							continue;
-						}
-
-						if (i == end)
-						{
-							exit_for = true;
-							break;
-						}
-
-						std::pair<unsigned, unsigned> room{ 1, 1 };
-
-						_m_find_collapse(static_cast<int>(l), static_cast<int>(c), room);
-
-						int pos_x = area.x + static_cast<int>(l * (block_w + gap_size));
-						int pos_y = area.y + static_cast<int>(c * (block_h + gap_size));
-
-						unsigned result_h;
-						if (room.first <= 1 && room.second <= 1)
-						{
-							precise_w += block_w;
-							result_h = block_height_px;
-							table[l + lbp] = 1;
-						}
-						else
-						{
-							precise_w += block_w * room.first + (room.first - 1) * gap_size;
-							result_h = static_cast<unsigned>(block_h * room.second + precise_h + (room.second - 1) * gap_size);
-
-							for (unsigned y = 0; y < room.second; ++y)
-								for (unsigned x = 0; x < room.first; ++x)
-									table[l + x + lbp + y * dimension.first] = 1;
-						}
-
-						unsigned result_w = static_cast<unsigned>(precise_w);
-						precise_w -= result_w;
-
-						API::move_window(i->handle, rectangle{ pos_x, pos_y, result_w, result_h });
-						++i;
-					}
-
-					if (exit_for)
-					{
-						size empty_sz;
-						for (; i != end; ++i)
-							API::window_size(i->handle, empty_sz);
-						break;
-					}
-					lbp += dimension.first;
-				}
-			}
-
-			for (auto & fsn : field->fastened)
-				API::move_window(fsn.handle, area);
-		}
-	public:
-		std::pair<unsigned, unsigned> dimension;
-	private:
-		void _m_find_collapse(int x, int y, std::pair<unsigned, unsigned>& collapse) const
-		{
-			for (auto & col : collapses_)
-			{
-				if (col.x == x && col.y == y)
-				{
-					collapse.first = col.width;
-					collapse.second = col.height;
-					return;
-				}
-			}
-		}
-	private:
-		place_parts::repeated_array arrange_;
-		std::vector<rectangle> collapses_;
-	};//end class div_grid
-
-	class place::implement::div_splitter
-		: public division
-	{
-		struct div_block
-		{
-			division * div;
-			int	pixels;
-			double		scale;
-
-			div_block(division* d, int px)
-				: div(d), pixels(px)
-			{}
-		};
-
-		enum{splitter_px = 4};
-	public:
-		div_splitter(place_parts::number_t init_weight)
-			: division(kind::splitter, std::string()),
-			init_weight_(init_weight)
-		{
-			this->weight.assign(splitter_px);
-		}
-
-		void direction(bool horizontal)
-		{
-			splitter_cursor_ = (horizontal ? cursor::size_we : cursor::size_ns);
-		}
-	private:
-		void collocate(window wd) override
-		{
-			if (API::is_destroying(wd))
-				return;
-
-			if (splitter_.empty())
-			{
-				splitter_.create(wd);
-				splitter_.cursor(splitter_cursor_);
-
-				dragger_.trigger(splitter_);
-
-				auto grab_fn = [this](const arg_mouse& arg)
-				{
-					if (false == arg.left_button)
-						return;
-
-					if (event_code::mouse_down == arg.evt_code)
-					{
-						begin_point_ = splitter_.pos();
-
-						auto px_ptr = &nana::rectangle::width;
-
-						//Use field_area of leaf, not margin_area. Otherwise splitter would be at wrong position
-						auto area_left = _m_leaf_left()->field_area;
-						auto area_right = _m_leaf_right()->field_area;
-
-						if (nana::cursor::size_we != splitter_cursor_)
-						{
-							left_pos_ = area_left.y;
-							right_pos_ = area_right.bottom();
-							px_ptr = &nana::rectangle::height;
-						}
-						else
-						{
-							left_pos_ = area_left.x;
-							right_pos_ = area_right.right();
-						}
-
-						left_pixels_ = area_left.*px_ptr;
-						right_pixels_ = area_right.*px_ptr;
-						
-						grabbed_ = true;
-					}
-					else if(event_code::mouse_up == arg.evt_code)
-					{
-						grabbed_ = false;
-					}
-					else if (event_code::mouse_move == arg.evt_code)
-					{
-						if(!grabbed_)
-							return;
-							
-						const bool vert = (::nana::cursor::size_we != splitter_cursor_);
-						auto area_px = rectangle_rotator(vert, div_owner->margin_area()).w();
-						int delta = (vert ? splitter_.pos().y - begin_point_.y : splitter_.pos().x - begin_point_.x);
-
-						int total_pixels = static_cast<int>(left_pixels_ + right_pixels_);
-
-						auto left_px = static_cast<int>(left_pixels_) + delta;
-						if (left_px > total_pixels)
-							left_px = total_pixels;
-						else if (left_px < 0)
-							left_px = 0;
-
-						double imd_rate = 100.0 / area_px;
-						left_px = static_cast<int>(limit_px(_m_leaf_left(), left_px, area_px));
-						_m_leaf_left()->weight.assign_percent(imd_rate * left_px);
-
-						auto right_px = static_cast<int>(right_pixels_) - delta;
-						if (right_px > total_pixels)
-							right_px = total_pixels;
-						else if (right_px < 0)
-							right_px = 0;
-
-						right_px = static_cast<int>(limit_px(_m_leaf_right(), right_px, area_px));
-						_m_leaf_right()->weight.assign_percent(imd_rate * right_px);
-
-						pause_move_collocate_ = true;
-						div_owner->collocate(splitter_.parent());
-
-						//After the collocating, the splitter keeps the calculated weight of left division,
-						//and clear the weight of right division.
-						_m_leaf_right()->weight.reset();
-
-						pause_move_collocate_ = false;
-					}
-				};
-
-				auto & events = splitter_.events();
-				events.mouse_down.connect_unignorable(grab_fn);
-				events.mouse_up.connect_unignorable(grab_fn);
-				events.mouse_move.connect_unignorable(grab_fn);
-			}
-
-			auto limited_range = _m_update_splitter_range();
-
-			if (!init_weight_.empty())
-			{
-				const bool vert = (::nana::cursor::size_we != splitter_cursor_);
-
-				auto leaf_left = _m_leaf_left();
-				auto leaf_right = _m_leaf_right();
-				rectangle_rotator left(vert, leaf_left->field_area);
-				rectangle_rotator right(vert, leaf_right->field_area);
-				auto area_px = right.right() - left.x();
-				auto right_px = static_cast<int>(limit_px(leaf_right, init_weight_.get_value(area_px), static_cast<unsigned>(area_px)));
-
-				auto pos = area_px - right_px - splitter_px; //New position of splitter
-				if (pos < limited_range.x())
-					pos = limited_range.x();
-				else if (pos > limited_range.right())
-					pos = limited_range.right();
-
-				rectangle_rotator sp_r(vert, field_area);
-				sp_r.x_ref() = pos;
-
-				left.w_ref() = static_cast<unsigned>(pos - left.x());
-
-				auto right_pos = right.right();
-				right.x_ref() = (pos + splitter_px);
-				right.w_ref() = static_cast<unsigned>(right_pos - pos - splitter_px);
-
-				field_area = sp_r.result();
-				leaf_left->field_area = left.result();
-				leaf_right->field_area = right.result();
-				leaf_left->collocate(wd);
-				leaf_right->collocate(wd);
-
-				//Set the leafs' weight
-				rectangle_rotator area(vert, div_owner->field_area);
-
-				double imd_rate = 100.0 / static_cast<int>(area.w());
-				leaf_left->weight.assign_percent(imd_rate * static_cast<int>(left.w()));
-				leaf_right->weight.assign_percent(imd_rate * static_cast<int>(right.w()));
-
-				splitter_.move(this->field_area);
-
-				init_weight_.reset();
-			}
-
-			if (false == pause_move_collocate_)
-				splitter_.move(this->field_area);
-		}
-	private:
-		division * _m_leaf_left() const
-		{
-			return previous();
-		}
-
-		division * _m_leaf_right() const
-		{
-			return div_next;
-		}
-
-		rectangle_rotator _m_update_splitter_range()
-		{
-			const bool vert = (cursor::size_ns == splitter_cursor_);
-
-			rectangle_rotator area(vert, div_owner->margin_area());
-
-			auto leaf_left = _m_leaf_left();
-			auto leaf_right = _m_leaf_right();
-
-			rectangle_rotator left(vert, leaf_left->field_area);
-			rectangle_rotator right(vert, leaf_right->field_area);
-
-			const int left_base = left.x(), right_base = right.right();
-			int pos = left_base;
-			int endpos = right_base;
-
-			if (!leaf_left->min_px.empty())
-			{
-				auto v = leaf_left->min_px.get_value(area.w());
-				pos += static_cast<int>(v);
-			}
-			if (!leaf_left->max_px.empty())
-			{
-				auto v = leaf_left->max_px.get_value(area.w());
-				endpos = left_base + static_cast<int>(v);
-			}
-
-			if (!leaf_right->min_px.empty())
-			{
-				auto v = leaf_right->min_px.get_value(area.w());
-				auto x = right_base - static_cast<int>(v);
-				if (x < endpos)
-					endpos = x;
-			}
-			if (!leaf_right->max_px.empty())
-			{
-				auto v = leaf_right->max_px.get_value(area.w());
-				auto x = right_base - static_cast<int>(v);
-				if (x > pos)
-					pos = x;
-			}
-
-			area.x_ref() = pos;
-			area.w_ref() = unsigned(endpos - pos + splitter_px);
-
-			dragger_.target(splitter_, area.result(), (vert ? nana::arrange::vertical : nana::arrange::horizontal));
-
-			return area;
-		}
-	private:
-		nana::cursor	splitter_cursor_{nana::cursor::arrow};
-		place_parts::splitter<true>	splitter_;
-		nana::point	begin_point_;
-		int			left_pos_, right_pos_;
-		unsigned	left_pixels_, right_pixels_;
-		dragger	dragger_;
-		bool	grabbed_{ false };
-		bool	pause_move_collocate_{ false };	//A flag represents whether do move when collocating.
-		place_parts::number_t init_weight_;
-	};
-
-	class place::implement::div_dockpane
-		: public division, public place_parts::dock_notifier_interface
-	{
-	public:
-		div_dockpane(std::string && name, implement* impl, direction pane_dir)
-			:	division(kind::dockpane, std::move(name)),
-				impl_ptr_{impl}
-		{
-			dir = pane_dir;
-			this->display = false;
-		}
-
-		~div_dockpane()
-		{
-			if (dockable_field)
-			{
-				dockable_field->dockarea.reset();
-				dockable_field->attached = nullptr;
-			}
-		}
-
-		void collocate(window) override
-		{
-			if (!dockable_field)
-			{
-				if (name.empty())
-					return;
-
-				auto &dock_ptr = impl_ptr_->docks[name];
-				if (!dock_ptr)
-					dock_ptr = new field_dock;
-
-				dock_ptr->attached = this;
-				dockable_field = dock_ptr;
-			}
-
-			auto & dockarea = dockable_field->dockarea;
-			if (dockarea && !dockarea->floating())
-				dockarea->move(this->field_area);
-		}
-	private:
-		//Implement dock_notifier_interface
-		void notify_float() override
-		{
-			set_display(false);
-			impl_ptr_->collocate();
-		}
-
-		void notify_dock() override
-		{
-			indicator_.docker.reset();
-
-			set_display(true);
-			impl_ptr_->collocate();
-		}
-
-		void notify_move() override
-		{
-			if (!_m_indicator())
-			{
-				indicator_.docker.reset();
-				return;
-			}
-
-			if (!indicator_.docker)
-			{
-				auto host_size = API::window_size(impl_ptr_->window_handle);
-				indicator_.docker.reset(new form(impl_ptr_->window_handle, { static_cast<int>(host_size.width) / 2 - 16, static_cast<int>(host_size.height) / 2 - 16, 32, 32 }, form::appear::bald<>()));
-				drawing dw(indicator_.docker->handle());
-				dw.draw([](paint::graphics& graph)
-				{
-					graph.rectangle(false, colors::midnight_blue);
-					graph.rectangle({ 1, 1, 30, 30 }, true, colors::light_sky_blue);
-
-					facade<element::arrow> arrow;
-					arrow.direction(::nana::direction::south);
-					arrow.draw(graph, colors::light_sky_blue, colors::midnight_blue, { 12, 0, 16, 16 }, element_state::normal);
-
-					graph.rectangle({ 4, 16, 24, 11 }, true, colors::midnight_blue);
-					graph.rectangle({ 5, 19, 22, 7 }, true, colors::button_face);
-				});
-
-				indicator_.docker->z_order(nullptr, ::nana::z_order_action::topmost);
-				indicator_.docker->show();
-
-				indicator_.docker->events().destroy.connect([this](const arg_destroy&)
-				{
-					if (indicator_.dock_area)
-					{
-						indicator_.dock_area.reset();
-						indicator_.graph.release();
-					}
-				});
-			}
-
-			if (_m_dockable())
-			{
-				if (!indicator_.dock_area)
-				{
-					set_display(true);
-					impl_ptr_->collocate();
-
-					indicator_.graph.make(API::window_size(impl_ptr_->window_handle));
-					API::window_graphics(impl_ptr_->window_handle, indicator_.graph);
-
-					indicator_.dock_area.reset(new panel<true>(impl_ptr_->window_handle, false));
-					indicator_.dock_area->move(this->field_area);
-
-					::nana::drawing dw(indicator_.dock_area->handle());
-					dw.draw([this](paint::graphics& graph)
-					{
-						indicator_.graph.paste(this->field_area, graph, 0, 0);
-
-						const int border_px = 4;
-						rectangle r{ graph.size() };
-						int right = r.right();
-						int bottom = r.bottom();
-
-						graph.blend(r.pare_off(border_px), colors::blue, 0.3);
-
-						::nana::color clr = colors::deep_sky_blue;
-						r.y = 0;
-						r.height = border_px;
-						graph.blend(r, clr, 0.5);
-						r.y = bottom - border_px;
-						graph.blend(r, clr, 0.5);
-
-						r.x = r.y = 0;
-						r.dimension(graph.size());
-						r.width = border_px;
-						graph.blend(r, clr, 0.5);
-						r.x = right - border_px;
-						graph.blend(r, clr, 0.5);
-
-					});
-
-					API::bring_top(indicator_.dock_area->handle(), false);
-					indicator_.dock_area->show();
-				}
-			}
-			else
-			{
-				set_display(false);
-				impl_ptr_->collocate();
-				if (indicator_.dock_area)
-				{
-					indicator_.dock_area.reset();
-					indicator_.graph.release();
-				}
-			}
-
-		}
-
-		void notify_move_stopped() override
-		{
-			if (_m_dockable() && dockable_field && dockable_field->dockarea)
-				dockable_field->dockarea->dock();
-
-			indicator_.docker.reset();
-		}
-
-		void request_close() override
-		{
-			auto window_handle = dockable_field->dockarea->handle();
-
-			//a workaround for capture
-			auto ptr = dockable_field->dockarea.release();
-			API::at_safe_place(window_handle, [ptr]
-			{
-				std::unique_ptr<typename std::remove_pointer<decltype(ptr)>::type> del(ptr);
-			});
-
-			this->set_display(false);
-			impl_ptr_->collocate();
-
-			API::close_window(window_handle);
-		}
-	private:
-		bool _m_indicator() const
-		{
-			::nana::point pos;
-			API::calc_screen_point(impl_ptr_->window_handle, pos);
-
-			rectangle r{ pos, API::window_size(impl_ptr_->window_handle) };
-			return r.is_hit(API::cursor_position());
-		}
-
-		bool _m_dockable() const
-		{
-			if (!indicator_.docker)
-				return false;
-
-			::nana::point pos;
-			API::calc_screen_point(indicator_.docker->handle(), pos);
-
-			rectangle r{ pos, API::window_size(indicator_.docker->handle()) };
-			return r.is_hit(API::cursor_position());
-		}
-	public:
-		field_dock * dockable_field{ nullptr };
-
-		std::unique_ptr<widget>	splitter;
-	private:
-		implement * impl_ptr_;
-
-		//
-		struct indicator_rep
-		{
-			paint::graphics graph;
-			std::unique_ptr<panel<true>> dock_area;
-			std::unique_ptr<form> docker;
-		}indicator_;
-	};
-
-	class place::implement::div_dock
-		: public division
-	{
-		static const unsigned splitter_px = 5;
-
-		class splitter : public panel<true>
-		{
-		public:
-			splitter(window wd, ::nana::direction dir, division* dock_dv, division* pane_dv)
-				: panel<true>(wd, true), dir_(dir), dock_dv_(dock_dv), pane_dv_(pane_dv)
-			{
-				this->bgcolor(colors::alice_blue);
-				this->cursor(_m_is_vert(dir_) ? ::nana::cursor::size_ns : ::nana::cursor::size_we);
-
-
-				auto grab_fn = [this, wd](const arg_mouse& arg)
-				{
-					if (event_code::mouse_down == arg.evt_code)	//press mouse button
-					{
-						if (arg.button != ::nana::mouse::left_button)
-							return;
-
-						bool is_vert = _m_is_vert(dir_);
-
-						this->set_capture(true);
-
-						auto basepos = API::cursor_position();
-						base_pos_.x = (is_vert ? basepos.y : basepos.x);
-
-						basepos = this->pos();
-						base_pos_.y = (is_vert ? basepos.y : basepos.x);
-
-						base_px_ = (is_vert ? pane_dv_->field_area.height : pane_dv_->field_area.width);
-					}
-					else if (event_code::mouse_move == arg.evt_code)	//hover
-					{
-						if (!arg.is_left_button())
-							return;
-
-						auto now_pos = API::cursor_position();
-						int delta = (_m_is_vert(dir_) ? now_pos.y : now_pos.x) - base_pos_.x;
-						int new_pos = base_pos_.y + delta;
-						if (new_pos < range_.x)
-						{
-							new_pos = range_.x;
-							delta = new_pos - base_pos_.y;
-						}
-						else if (new_pos >= range_.y)
-						{
-							new_pos = range_.y - 1;
-							delta = new_pos - base_pos_.y;
-						}
-
-						now_pos = this->pos();
-						if (_m_is_vert(dir_))
-							now_pos.y = new_pos;
-						else
-							now_pos.x = new_pos;
-						this->move(now_pos);
-
-						auto px = base_px_;
-						switch (dir_)
-						{
-						case ::nana::direction::west:
-						case ::nana::direction::north:
-							if (delta < 0)
-								px -= static_cast<unsigned>(-delta);
-							else
-								px += static_cast<unsigned>(delta);
-							break;
-						case ::nana::direction::east:
-						case ::nana::direction::south:
-							if (delta < 0)
-								px += static_cast<unsigned>(-delta);
-							else
-								px -= static_cast<unsigned>(delta);
-							break;
-						default:
-							break;
-						}
-
-						auto dock_px = (_m_is_vert(dir_) ? dock_dv_->field_area.height : dock_dv_->field_area.width);
-
-						pane_dv_->weight.assign_percent(double(px) / double(dock_px) * 100);
-
-						dock_dv_->collocate(wd);
-					}
-					else
-						this->release_capture();
-				};
-
-				auto & evt = this->events();
-				evt.mouse_down.connect(grab_fn);
-				evt.mouse_up.connect(grab_fn);
-				evt.mouse_move.connect(grab_fn);
-			}
-
-			void range(int begin, int end)
-			{
-				range_.x = begin;
-				range_.y = end;
-			}
-		private:
-			const ::nana::direction	dir_;
-			division* const dock_dv_;
-			division* const	pane_dv_;
-			::nana::point	range_;
-			::nana::point	base_pos_;	//x = mouse pos, y = splitter pos
-			unsigned		base_px_;	//weight of div_dockpane when mouse button is been pressing;
-
-		};
-	public:
-		div_dock(std::string && name, implement* impl)
-			: division(kind::dock, std::move(name)), impl_(impl)
-		{}
-
-		division* front() const
-		{
-			for (auto & child : children)
-			{
-				if (child->display)
-					return child.get();
-			}
-
-			return nullptr;
-		}
-
-		void collocate(window wd) override
-		{
-			auto area = this->margin_area();
-
-			unsigned vert_count = 0, horz_count = 0;
-
-			bool is_first = true;
-			bool prev_attr = false;
-
-			for (auto & child : children)
-			{
-				if (!child->display)
-					continue;
-
-				const auto is_vert = _m_is_vert(child->dir);
-				if (is_first)
-				{
-					is_first = false;
-					(is_vert ? horz_count : vert_count) = 1;
-					prev_attr = is_vert;
-				}
-
-				if ((is_vert == prev_attr) == is_vert)
-					++vert_count;
-				else
-					++horz_count;
-
-				prev_attr = is_vert;
-			}
-			if (0 == vert_count)
-				vert_count = 1;
-			if (0 == horz_count)
-				horz_count = 1;
-
-			//room indicates the size without splitters
-			::nana::size room(area.width - splitter_px * (horz_count - 1), area.height - splitter_px * (vert_count - 1));
-
-			double left = area.x;
-			double right = area.right();
-			double top = area.y;
-			double bottom = area.bottom();
-
-			for (auto & child : children)
-			{
-				if (!child->display)
-				{
-					auto child_dv = dynamic_cast<div_dockpane*>(child.get());
-					if (child_dv)
-						child_dv->splitter.reset();
-
-					continue;
-				}
-
-				auto child_dv = dynamic_cast<div_dockpane*>(child.get());
-				const bool is_vert = _m_is_vert(child->dir);
-
-				auto room_px = (is_vert ? room.height : room.width);
-
-				double weight;
-				if (!child->weight.empty())
-				{
-					weight = child->weight.get_value(is_vert ? room.height : room.width);
-					if (weight > room_px)
-						weight = room_px;
-				}
-				else
-					weight = room_px / double(is_vert ? vert_count : horz_count);
-
-				splitter* split = nullptr;
-				if (_m_right(child_dv))
-				{
-					//Creates a splitbar if the 'right' leaf is not empty
-					if (!child_dv->splitter)
-					{
-						split = new splitter(impl_->window_handle, child->dir, this, child_dv);
-						child_dv->splitter.reset(split);
-					}
-					else
-						split = dynamic_cast<splitter*>(child_dv->splitter.get());
-				}
-				else
-					child_dv->splitter.reset();
-
-				::nana::rectangle child_r;
-				double split_range_begin = -1, split_range_end = 0;
-				switch (child->dir)
-				{
-				default:
-				case ::nana::direction::west:
-					child_r.x = static_cast<int>(left);
-					child_r.y = static_cast<int>(top);
-					child_r.width = static_cast<unsigned>(weight);
-					child_r.height = static_cast<unsigned>(bottom - top);
-					left += weight;
-					if (split)
-					{
-						split->move(rectangle{ child_r.right(), child_r.y, splitter_px, child_r.height });
-						split_range_begin = left - weight;
-						split_range_end = right - static_cast<int>(splitter_px);
-						left += splitter_px;
-					}
-					break;
-				case ::nana::direction::east:
-					right -= weight;
-					child_r.x = static_cast<int>(right);
-					child_r.y = static_cast<int>(top);
-					child_r.width = static_cast<unsigned>(weight);
-					child_r.height = static_cast<unsigned>(bottom - top);
-					if (split)
-					{
-						split->move(rectangle{ child_r.x - static_cast<int>(splitter_px), child_r.y, splitter_px, child_r.height });
-						split_range_begin = left;
-						split_range_end = right - static_cast<int>(splitter_px)+weight;
-						right -= splitter_px;
-					}
-					break;
-				case ::nana::direction::north:
-					child_r.x = static_cast<int>(left);
-					child_r.y = static_cast<int>(top);
-					child_r.width = static_cast<unsigned>(right - left);
-					child_r.height = static_cast<unsigned>(weight);
-					top += weight;
-					if (split)
-					{
-						split->move(rectangle{ child_r.x, child_r.bottom(), child_r.width, splitter_px });
-						split_range_begin = top - weight;
-						split_range_end = bottom - static_cast<int>(splitter_px);
-						top += splitter_px;
-					}
-					break;
-				case ::nana::direction::south:
-					child_r.x = static_cast<int>(left);
-					bottom -= weight;
-					child_r.y = static_cast<int>(bottom);
-					child_r.width = static_cast<unsigned>(right - left);
-					child_r.height = static_cast<unsigned>(weight);
-					if (split)
-					{
-						bottom -= splitter_px;
-						split->move(rectangle{ child_r.x, child_r.y - static_cast<int>(splitter_px), child_r.width, splitter_px });
-						split_range_begin = top;
-						split_range_end = bottom + weight;
-					}
-					break;
-				}
-
-				if (split_range_begin > -0.5)
-					split->range(static_cast<int>(split_range_begin), static_cast<int>(split_range_end));
-
-				if (is_vert)
-				{
-					room.height -= child_r.height;
-					--vert_count;
-				}
-				else
-				{
-					room.width -= child_r.width;
-					--horz_count;
-				}
-
-				child->field_area = child_r;
-				child->collocate(wd);
-			}
-		}
-	private:
-		static bool _m_is_vert(::nana::direction dir)
-		{
-			return (dir == ::nana::direction::north || dir == ::nana::direction::south);
-		}
-
-		static div_dockpane* _m_right(division* dv)
-		{
-			dv = dv->div_next;
-			while (dv)
-			{
-				if (dv->display)
-					return dynamic_cast<div_dockpane*>(dv);
-
-				dv = dv->div_next;
-			}
-			return nullptr;
-		}
-	private:
-		implement * const impl_;
-	};
-
-	place::implement::~implement()
-	{
-		API::umake_event(event_size_handle);
-		root_division.reset();
-
-		for (auto & pair : fields)
-			delete pair.second;
-
-		for (auto & dock : docks)
-			delete dock.second;
-	}
-
-	void place::implement::collocate()
-	{
-		if (root_division && window_handle)
-		{
-			root_division->field_area.dimension(API::window_size(window_handle));
-
-			if (root_division->field_area.empty())
-				return;
-
-			root_division->collocate(window_handle);
-
-			for (auto & field : fields)
-			{
-				bool is_show = false;
-				if (field.second->attached && field.second->attached->visible && field.second->attached->display)
-				{
-					is_show = true;
-					auto div = field.second->attached->div_owner;
-					while (div)
-					{
-						if (!div->visible || !div->display)
-						{
-							is_show = false;
-							break;
-						}
-						div = div->div_owner;
-					}
-				}
-
-				for (auto & el : field.second->elements)
-					API::show_window(el.handle, is_show);
-			}
-		}
-	}
-
-	//search_div_name
-	//search a division with the specified name.
-	place::implement::division * place::implement::search_div_name(division* start, const std::string& name)
-	{
-		if (start)
-		{
-			if (start->name == name)
-				return start;
-
-			for (auto& child : start->children)
-			{
-				auto div = search_div_name(child.get(), name);
-				if (div)
-					return div;
-			}
-		}
-		return nullptr;
-	}
-
-	auto place::implement::scan_div(place_parts::tokenizer& tknizer) -> std::unique_ptr<division>
-	{
-		typedef place_parts::tokenizer::token token;
-
-		std::unique_ptr<division> div;
-		token div_type = token::eof;
-
-		//These variables stand for the new division's attributes
-		std::string name;
-		number_t weight, min_px, max_px;
-		place_parts::repeated_array arrange, gap;
-		place_parts::margin margin;
-		std::vector<number_t> array;
-		std::vector<rectangle> collapses;
-		std::vector<std::unique_ptr<division>> children;
-		::nana::direction div_dir = ::nana::direction::west;
-
-		bool undisplayed = false;
-		bool invisible = false;
-
-		for (token tk = tknizer.read(); tk != token::eof; tk = tknizer.read())
-		{
-			bool exit_for = false;
-			switch (tk)
-			{
-			case token::dock:
-				if (token::eof != div_type && token::dock != div_type)
-					throw std::invalid_argument("nana.place: conflict of div type at " + tknizer.pos_str());
-
-				div_type = token::dock;
-				break;
-			case token::splitter:
-				//Ignore the splitter when there is not a division.
-				if (!children.empty() && (division::kind::splitter != children.back()->kind_of_division))
-				{
-					auto splitter = new div_splitter(tknizer.number());
-					children.back()->div_next = splitter;
-					children.emplace_back(std::unique_ptr<division>{ splitter });
-				}
-				break;
-			case token::div_start:
-			{
-				auto div = scan_div(tknizer);
-				if (!children.empty())
-					children.back()->div_next = div.get();
-
-				children.emplace_back(std::move(div));
-			}
-				break;
-			case token::vert:
-				div_type = tk;
-				break;
-			case token::grid:
-				div_type = tk;
-				switch (tknizer.read())
-				{
-				case token::number:
-					array.push_back(tknizer.number());
-					array.push_back(tknizer.number());
-					break;
-				case token::array:
-					tknizer.array().swap(array);
-					break;
-				case token::reparray:
-					array.push_back(tknizer.reparray().at(0));
-					array.push_back(tknizer.reparray().at(1));
-					break;
-                default:
-                    break;
-				}
-				break;
-			case token::collapse:
-				{
-					if (tknizer.parameters().size() != 4)
-						throw std::invalid_argument("nana.place: collapse requires 4 parameters.");
-
-					auto get_number = [](const number_t & arg, const std::string& nth)
-					{
-						if (arg.kind_of() == number_t::kind::integer)
-							return arg.integer();
-						else if (arg.kind_of() == number_t::kind::real)
-							return static_cast<int>(arg.real());
-
-						throw std::invalid_argument("nana.place: the type of the "+ nth +" parameter for collapse should be integer.");
-					};
-
-					::nana::rectangle col;
-					auto arg = tknizer.parameters().at(0);
-					col.x = get_number(arg, "1st");
-
-					arg = tknizer.parameters().at(1);
-					col.y = get_number(arg, "2nd");
-
-					arg = tknizer.parameters().at(2);
-					col.width = static_cast<decltype(col.width)>(get_number(arg, "3rd"));
-
-					arg = tknizer.parameters().at(3);
-					col.height = static_cast<decltype(col.height)>(get_number(arg, "4th"));
-
-					//Check the collapse area.
-					//Ignore this collapse if its area is less than 2(col.width * col.height < 2)
-					if (!col.empty() && (col.width > 1 || col.height > 1) && (col.x >= 0 && col.y >= 0))
-					{
-						//Overwrite if a exist_col in collapses has same position as the col.
-						bool use_col = true;
-						for (auto & exist_col : collapses)
-						{
-							if (exist_col.x == col.x && exist_col.y == col.y)
-							{
-								exist_col = col;
-								use_col = false;
-								break;
-							}
-						}
-						if (use_col)
-							collapses.emplace_back(col);
-					}
-				}
-				break;
-			case token::weight: case token::min_px: case token::max_px:
-				{
-					auto n = tknizer.number();
-					//If n is the type of real, convert it to integer.
-					//the integer and percent are allowed for weight/min/max.
-					if (n.kind_of() == number_t::kind::real)
-						n.assign(static_cast<int>(n.real()));
-
-					switch (tk)
-					{
-					case token::weight: weight = n; break;
-					case token::min_px: min_px = n; break;
-					case token::max_px: max_px = n; break;
-					default: break;	//Useless
-					}
-				}
-				break;
-			case token::arrange:
-				arrange = tknizer.reparray();
-				break;
-			case token::gap:
-				gap = tknizer.reparray();
-				break;
-			case token::margin:
-				margin.clear();
-				switch (tknizer.read())
-				{
-				case token::number:
-					margin.set_value(tknizer.number());
-					break;
-				case token::array:
-					margin.set_array(tknizer.array());
-					break;
-				case token::reparray:
-					for (std::size_t i = 0; i < 4; ++i)
-					{
-						auto n = tknizer.reparray().at(i);
-						if (n.empty()) n.assign(0);
-						margin.push(n);
-					}
-					break;
-				default:
-					break;
-				}
-				break;
-			case token::div_end:
-				exit_for = true;
-				break;
-			case token::identifier:
-				name = tknizer.idstr();
-				break;
-			case token::left:
-				div_dir = ::nana::direction::west; break;
-			case token::right:
-				div_dir = ::nana::direction::east; break;
-			case token::top:
-				div_dir = ::nana::direction::north; break;
-			case token::bottom:
-				div_dir = ::nana::direction::south; break;
-			case token::undisplayed:
-				undisplayed = true; break;
-			case token::invisible:
-				invisible = true; break;
-			default:	break;
-			}
-			if (exit_for)
-				break;
-		}
-
-		field_gather * attached_field = nullptr;
-		if (name.size())
-		{
-			//find the field with specified name.
-			//the field may not be created.
-			auto i = fields.find(name);
-			if (fields.end() != i)
-			{
-				attached_field = i->second;
-				//the field is attached to a division, it means there is another division with same name.
-				if (attached_field->attached)
-					throw std::runtime_error("place, the name '" + name + "' is redefined.");
-			}
-		}
-
-		switch (div_type)
-		{
-		case token::eof:
-		case token::vert:
-			div.reset(new div_arrange(token::vert == div_type, std::move(name), std::move(arrange)));
-			break;
-		case token::grid:
-		{
-			std::unique_ptr<div_grid> p(new div_grid(std::move(name), std::move(arrange), std::move(collapses)));
-
-			if (array.size())
-				p->dimension.first = array[0].integer();
-
-			if (array.size() > 1)
-				p->dimension.second = array[1].integer();
-
-			if (0 == p->dimension.first)
-				p->dimension.first = 1;
-
-			if (0 == p->dimension.second)
-				p->dimension.second = 1;
-
-			p->revise_collapses();
-			div = std::move(p);
-		}
-			break;
-		case token::dock:
-			div.reset(new div_dock(std::move(name), this));
-			break;
-		default:
-			throw std::invalid_argument("nana.place: invalid division type.");
-		}
-
-		//Requirements for min/max
-		//1, min and max != negative
-		//2, max >= min
-		if (min_px.is_negative()) min_px.reset();
-		if (max_px.is_negative()) max_px.reset();
-		if ((!min_px.empty()) && (!max_px.empty()) && (min_px.get_value(100) > max_px.get_value(100)))
-		{
-			min_px.reset();
-			max_px.reset();
-		}
-
-		//The weight will be ignored if one of min and max is specified.
-		if (min_px.empty() && max_px.empty())
-		{
-			div->weight = weight;
-		}
-		else
-		{
-			div->min_px = min_px;
-			div->max_px = max_px;
-		}
-
-		div->gap = std::move(gap);
-
-		//attach the field to the division
-		div->field = attached_field;
-		if (attached_field)
-			attached_field->attached = div.get();
-
-		if (children.size())
-		{
-			if (division::kind::splitter == children.back()->kind_of_division)
-			{
-				children.pop_back();
-				if (children.size())
-					children.back()->div_next = nullptr;
-			}
-
-			for (auto& child : children)
-			{
-				child->div_owner = div.get();
-				if (division::kind::splitter == child->kind_of_division)
-					dynamic_cast<div_splitter&>(*child).direction(div_type != token::vert);
-			}
-
-			if (token::dock == div_type)
-			{
-				//adjust these children for dock division
-				std::vector<std::unique_ptr<division>> adjusted_children;
-				for (auto & child : children)
-				{
-					auto dockpn = new div_dockpane(std::move(child->name), this, child->dir);
-					dockpn->div_owner = child->div_owner;
-					dockpn->weight = child->weight;
-					adjusted_children.emplace_back(std::unique_ptr<division>{ dockpn });
-				}
-
-				division * next = nullptr;
-				for (auto i = adjusted_children.rbegin(); i != adjusted_children.rend(); ++i)
-				{
-					i->get()->div_next = next;
-					next = i->get();
-				}
-
-				children.swap(adjusted_children);
-			}
-		}
-
-		div->children.swap(children);
-		div->margin = std::move(margin);
-		div->dir = div_dir;
-
-		div->display = !undisplayed;
-		div->visible = !(undisplayed || invisible);
-		return div;
-	}
-
-	void place::implement::check_unique(const division* div) const
-	{
-		//The second field_impl is useless. Reuse the map type in order to
-		//reduce the size of the generated code, becuase std::set<std::string>
-		//will create a new template class.
-		std::map<std::string, field_gather*> unique;
-		field_gather tmp(nullptr);
-
-		std::function<void(const implement::division* div)> check_fn;
-		check_fn = [&check_fn, &unique, &tmp](const implement::division* div)
-		{
-			if (!div->name.empty())
-			{
-				auto & ptr = unique[div->name];
-				if (ptr)
-					throw std::invalid_argument("place, the name '" + div->name + "' is redefined.");
-				ptr = &tmp;
-			}
-
-			for (auto & child : div->children)
-			{
-				check_fn(child.get());
-			}
-		};
-
-		if (div)
-			check_fn(div);
-	}
-
-	//connect the field/dock with div object,
-	void place::implement::connect(division* start)
-	{
-		if (!start)
-			return;
-
-		this->disconnect();
-
-		std::map<std::string, field_dock*> docks_to_be_closed;
-		//disconnect
-		for (auto & dk : docks)
-		{
-			if (dk.second->attached)
-				docks_to_be_closed[dk.first] = dk.second;
-		}
-
-		std::function<void(division* div)> connect_fn;
-		connect_fn = [&connect_fn, this, &docks_to_be_closed](division* div)
-		{
-			if (div->name.size())
-			{
-				if (division::kind::dock == div->kind_of_division || division::kind::dockpane == div->kind_of_division)
-				{
-					auto i = docks.find(div->name);
-					if (i != docks.end())
-					{
-						docks_to_be_closed.erase(div->name);
-						auto pane = dynamic_cast<div_dockpane*>(div);
-						pane->dockable_field = i->second;
-
-						auto old_pane = pane->dockable_field->attached;
-						if (old_pane)
-						{
-							//old div_dockpane will be deleted
-							old_pane->dockable_field = nullptr;
-							div->display = old_pane->display;
-						}
-						pane->dockable_field->attached = pane;
-
-						if (pane->dockable_field->dockarea)
-							pane->dockable_field->dockarea->set_notifier(pane);
-					}
-				}
-				else
-				{
-					auto i = fields.find(div->name);
-					if (i != fields.end())
-					{
-						div->field = i->second;
-						div->field->attached = div;
-					}
-				}
-
-			}
-
-			for (auto & child : div->children)
-			{
-				connect_fn(child.get());
-			}
-		};
-
-		connect_fn(start);
-
-		for (auto& e : docks_to_be_closed)
-		{
-			e.second->dockarea.reset();
-			e.second->attached->dockable_field = nullptr;
-			e.second->attached = nullptr;
-		}
-	}
-
-	void place::implement::disconnect()
-	{
-		for (auto & fd : fields)
-		{
-			if (fd.second->attached)
-			{
-				fd.second->attached->field = nullptr;
-				fd.second->attached = nullptr;
-			}
-		}
-	}
-
-	//class place
-	place::place()
-		: impl_(new implement)
-	{}
-
-	place::place(window wd)
-		: impl_(new implement)
-	{
-		bind(wd);
-	}
-
-	place::~place()
-	{
-		delete impl_;
-	}
-
-	void place::bind(window wd)
-	{
-		if (impl_->window_handle)
-			throw std::runtime_error("place.bind: it has already binded to a window.");
-
-		impl_->window_handle = wd;
-		impl_->event_size_handle = API::events(wd).resized.connect([this](const arg_resized& arg)
-		{
-			if (impl_->root_division)
-			{
-				impl_->root_division->field_area.dimension({ arg.width, arg.height });
-				impl_->root_division->collocate(arg.window_handle);
-			}
-		});
-	}
-
-	window place::window_handle() const
-	{
-		return impl_->window_handle;
-	}
-
-	void place::div(const char* s)
-	{
-		place_parts::tokenizer tknizer(s);
-		impl_->disconnect();
-		auto div = impl_->scan_div(tknizer);
-		try
-		{
-			impl_->check_unique(div.get());	//may throw if there is a redefined name of field.
-			impl_->connect(div.get());
-			impl_->root_division.reset();	//clear atachments div-fields
-			impl_->root_division.swap(div);
-			impl_->div_text.assign(s);
-		}
-		catch (...)
-		{
-			//redefined a name of field
-			throw;
-		}
-	}
-
-	const std::string& place::div() const noexcept
-	{
-		return impl_->div_text;
-	}
-
-	enum div_type {	erase = 0, insert, replace };
-
-	void update_div(std::string& div, const char* field, const char* attr, div_type insertion);
-
-	void place::modify(const char* name, const char* div_text)
-	{
-		if (nullptr == div_text)
-			throw std::invalid_argument("nana.place: invalid div-text");
-
-		if (nullptr == name) name = "";
-
-		//check the name, it throws std::invalid_argument
-		//if name violate the naming convention.
-		place_parts::check_field_name(name);
-
-		auto div_ptr = impl_->search_div_name(impl_->root_division.get(), name);
-		if (!div_ptr)
-		{
-			std::string what = "nana::place: field '";
-			what += name;
-			what += "' is not found.";
-
-			throw std::invalid_argument(what);
-		}
-
-
-		std::unique_ptr<implement::division>* replaced = nullptr;
-
-		implement::division * div_owner = div_ptr->div_owner;
-		implement::division * div_next = div_ptr->div_next;
-		if (div_owner)
-		{
-			for (auto& child: div_owner->children)
-			{
-				if (child.get() == div_ptr)
-				{
-					replaced = &child;
-					break;
-				}
-			}
-		}
-		else
-			replaced = &(impl_->root_division);
-
-		replaced->swap(impl_->tmp_replaced);
-
-		try
-		{
-			place_parts::tokenizer tknizer(div_text);
-			auto modified = impl_->scan_div(tknizer);
-			auto modified_ptr = modified.get();
-			modified_ptr->name = name;
-
-			replaced->swap(modified);
-
-			impl_->check_unique(impl_->root_division.get());
-			impl_->connect(impl_->root_division.get());
-			impl_->tmp_replaced.reset();
-			update_div(impl_->div_text, name, div_text, div_type::replace);
-
-			modified_ptr->div_owner = div_owner;
-			modified_ptr->div_next = div_next;
-		}
-		catch (...)
-		{
-			replaced->swap(impl_->tmp_replaced);
-			throw;
-		}
-	}
-
-	place::field_reference place::field(const char* name)
-	{
-		if (nullptr == name)
-			name = "";
-
-		//check the name, it throws std::invalid_argument
-		//if name violate the naming convention.
-		place_parts::check_field_name(name);
-
-		//get the field with specified name, if no such field with specified name
-		//then create one.
-		auto & p = impl_->fields[name];
-		if (nullptr == p)
-			p = new implement::field_gather(this);
-
-		if ((!p->attached) && impl_->root_division)
-		{
-			//search the division with the specified name,
-			//and attached the division to the field
-			auto div = implement::search_div_name(impl_->root_division.get(), name);
-			if (div)
-			{
-				if (div->field && (div->field != p))
-					throw std::runtime_error("nana.place: unexpected error, the division attachs a unexpected field.");
-
-				div->field = p;
-				p->attached = div;
-			}
-		}
-		return *p;
-	}
-
-	bool is_idchar(int ch)
-	{
-		return ('_' == ch || isalpha(ch) || isalnum(ch));
-	}
-
-	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
-	{
-		const auto len = std::strlen(idstr);
-		auto pos = text.find(idstr, off);
-		if (text.npos == pos)
-			return text.npos;
-
-		if (pos && is_idchar(text[pos - 1]))
-			return text.npos;
-
-		if ((pos + len < text.length()) && is_idchar(text[pos + len]))
-			return text.npos;
-
-		return pos;
-	}
-
-	void update_div(std::string& div, const char* field, const char* attr, div_type insertion)
-	{
-		const auto fieldname_pos = find_idstr(div, field);
-		if (div.npos == fieldname_pos)
-			return;
-
-		//Get the bounds of this field
-		std::size_t begin = 0, end = 0;
-
-		//Find the begin
-		int level = 0;
-		std::size_t pos = fieldname_pos;
-		while (true)
-		{
-			pos = div.find_last_of("<>", pos);
-			if (div.npos == pos)
-				return;
-
-			if ('<' == div[pos])
-			{
-				if (0 == level)
-				{
-					begin = pos;
-					break;
-				}
-				else
-					--level;
-			}
-			else
-				++level;
-		}
-
-		//Find the end
-		level = 0;
-		pos = fieldname_pos;
-		while (true)
-		{
-			pos = div.find_first_of("<>", pos);
-			if (div.npos == pos)
-				return;
-
-			if ('>' == div[pos])
-			{
-				if (0 == level)
-				{
-					end = pos + 1;
-					break;
-				}
-				else
-					--level;
-			}
-			else
-				++level;
-		}
-
-		auto fieldstr = div.substr(begin + 1, end - begin - 2);
-
-		//Search the attribute
-		for (pos = 0; true; ++pos)
-		{
-			pos = find_idstr(fieldstr, attr, pos);
-			if (fieldstr.npos == pos)
-				break;
-
-			//Check if the attr is belong to this field.
-			level = 0;
-			std::size_t off = pos;
-			while (true)
-			{
-				off = fieldstr.find_last_of("<>", off);
-				if (fieldstr.npos == off)
-					break;
-
-				if ('>' == fieldstr[off])
-					++level;
-				else
-					--level;
-
-				if (0 == off)
-					break;
-				--off;
-			}
-
-			if (0 == level)
-				break;
-		}
-
-		if (fieldstr.npos == pos)
-		{
-			//There is not an attribute
-			if (insertion == div_type::insert)
-				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
-			else if (insertion == div_type::replace)
-			{
-				div.erase(begin + 1, fieldstr.length());
-				div.insert(begin + 1, std::string(attr) + " " + std::string(field));
-			}
-		}
-		else
-		{
-			//There is an attribute
-			if (insertion == div_type::erase)
-			{
-				div.erase(begin + pos + 1, std::strlen(attr));
-
-				if ((div[begin + pos] == div[begin + pos + 1]) && (' ' == div[begin + pos]))
-					div.erase(begin + pos, 1);
-			}
-		}
-	}
-
-	void place::field_visible(const char* name, bool vsb) const
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		if (div)
-		{
-			div->set_visible(vsb);
-			update_div(impl_->div_text, name, "invisible", !vsb ? div_type::insert : div_type::erase);
-		}
-	}
-
-	bool place::field_visible(const char* name) const
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		return (div && div->visible);
-	}
-
-	void place::field_display(const char* name, bool dsp) const
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		if (div)
-		{
-			update_div(impl_->div_text, name, "invisible", div_type::erase);
-			update_div(impl_->div_text, name, "undisplayed", !dsp ? div_type::insert : div_type::erase);
-			div->set_display(dsp);
-		}
-	}
-
-	bool place::field_display(const char* name) const
-	{
-		if (!name)	name = "";
-
-		//May throw std::invalid_argument
-		place_parts::check_field_name(name);
-
-		auto div = impl_->search_div_name(impl_->root_division.get(), name);
-		return (div && div->display);
-	}
-
-	void place::collocate()
-	{
-		impl_->collocate();
-	}
-
-	void place::erase(window handle)
-	{
-		bool recollocate = false;
-		for (auto & fld : impl_->fields)
-		{
-			auto evt = fld.second->erase_element(fld.second->elements, handle);
-			if (evt)
-			{
-				API::umake_event(evt);
-				recollocate |= (nullptr != fld.second->attached);
-			}
-
-			API::umake_event(fld.second->erase_element(fld.second->fastened, handle));
-		}
-
-		if (recollocate)
-			collocate();
-	}
-
-	place::field_reference place::operator[](const char* name)
-	{
-		return field(name);
-	}
-
-	place& place::dock(const std::string& name, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory)
-	{
-		//check the name, it throws std::invalid_argument
-		//if name violate the naming convention.
-		place_parts::check_field_name(name.data());
-
-		auto & dock_ptr = impl_->docks[name];
-		if (!dock_ptr)
-			dock_ptr = new implement::field_dock;
-
-		//Register the factory if it has a name
-		if (!factory_name.empty())
-		{
-			if (impl_->dock_factoris.find(factory_name) != impl_->dock_factoris.end())
-				throw std::invalid_argument("nana::place - the specified factory name(" + factory_name + ") already exists");
-
-			impl_->dock_factoris[factory_name] = dock_ptr;
-			dock_ptr->factories[factory_name] = std::move(factory);
-		}
-
-		auto div = dynamic_cast<implement::div_dockpane*>(impl_->search_div_name(impl_->root_division.get(), name));
-		if (div)
-		{
-			dock_ptr->attached = div;
-			div->dockable_field = dock_ptr;
-		}
-
-		//Create the pane if it has not a name
-		if (factory_name.empty() && dock_ptr->attached)
-		{
-			dock_ptr->attached->set_display(true);
-			impl_->collocate();
-
-			if (!dock_ptr->dockarea)
-			{
-				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
-				dock_ptr->dockarea->create(impl_->window_handle);
-				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
-				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
-			}
-			dock_ptr->dockarea->add_pane(factory);
-		}
-
-		return *this;
-	}
-
-	widget* place::dock_create(const std::string& factory)
-	{
-		auto i = impl_->dock_factoris.find(factory);
-		if (i == impl_->dock_factoris.end())
-			throw std::invalid_argument("invalid factory name(" + factory + ") of dockpane");
-
-		auto dock_ptr = i->second;
-		if (dock_ptr->attached)
-		{
-			dock_ptr->attached->set_display(true);
-			impl_->collocate();
-
-			if (!dock_ptr->dockarea)
-			{
-				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
-				dock_ptr->dockarea->create(impl_->window_handle);
-				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
-				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
-			}
-
-			return dock_ptr->dockarea->add_pane(i->second->factories[factory]);
-		}
-
-		return nullptr;
-	}
-	//end class place
-}//end namespace nana
-
-#include <nana/pop_ignore_diagnostic>
+/*
+ *	An Implementation of Place for Layout
+ *	Nana C++ Library(http://www.nanapro.org)
+ *	Copyright(C) 2003-2016 Jinhao(cnjinhao@hotmail.com)
+ *
+ *	Distributed under the Boost Software License, Version 1.0.
+ *	(See accompanying file LICENSE_1_0.txt or copy at
+ *	http://www.boost.org/LICENSE_1_0.txt)
+ *
+ *	@file: nana/gui/place.cpp
+ *	@contributors: Ariel Vina-Rodriguez
+ */
+
+#include <cfloat>
+#include <cmath>
+#include <map>
+#include <deque>
+#include <algorithm>
+#include <nana/push_ignore_diagnostic>
+#include <nana/deploy.hpp>
+#include <nana/gui/place.hpp>
+#include <nana/gui/programming_interface.hpp>
+#include <nana/gui/widgets/label.hpp>
+#include <nana/gui/widgets/panel.hpp>
+#include <nana/gui/dragger.hpp>
+#include <nana/gui/drawing.hpp>
+
+#include <memory>
+#include <limits>	//numeric_limits
+#include <cstdlib>	//std::abs
+#include <cstring>	//std::memset
+
+#include "place_parts.hpp"
+
+namespace nana
+{
+	namespace place_parts
+	{
+		//check the name
+		void check_field_name(const char* name)
+		{
+			if (*name && (*name != '_' && !(('a' <= *name && *name <= 'z') || ('A' <= *name && *name <= 'Z'))))
+				throw std::invalid_argument("nana.place: bad field name");
+		}
+	}//end namespace place_parts
+
+	typedef place_parts::number_t number_t;
+	typedef place_parts::repeated_array repeated_array;
+
+	namespace place_parts
+	{
+		class tokenizer
+		{
+		public:
+			enum class token
+			{
+				div_start, div_end, splitter,
+				identifier, dock, vert, grid, number, array, reparray,
+				weight, gap, margin, arrange, variable, repeated, min_px, max_px, left, right, top, bottom, undisplayed, invisible,
+				collapse, parameters,
+				equal,
+				eof, error
+			};
+
+			tokenizer(const char* p)
+				: divstr_(p), sp_(p)
+			{}
+
+			const std::string& idstr() const
+			{
+				return idstr_;
+			}
+
+			number_t number() const
+			{
+				return number_;
+			}
+
+			std::vector<number_t>& array()
+			{
+				return array_;
+			}
+
+			repeated_array&& reparray()
+			{
+				return std::move(reparray_);
+			}
+
+			std::vector<number_t>& parameters()
+			{
+				return parameters_;
+			}
+
+			std::size_t pos() const
+			{
+				return (sp_ - divstr_);
+			}
+
+			std::string pos_str() const
+			{
+				return std::to_string(pos());
+			}
+
+			token read()
+			{
+				sp_ = _m_eat_whitespace(sp_);
+
+				std::size_t readbytes = 0;
+				switch (*sp_)
+				{
+				case '\0':
+					return token::eof;
+				case '|':
+					++sp_;
+					readbytes = _m_number(sp_, false);
+					sp_ += readbytes;
+					return token::splitter;
+				case '=':
+					++sp_;
+					return token::equal;
+				case '<':
+					++sp_;
+					return token::div_start;
+				case '>':
+					++sp_;
+					return token::div_end;
+				case '[':
+					array_.clear();
+					sp_ = _m_eat_whitespace(sp_ + 1);
+					if (*sp_ == ']')
+					{
+						++sp_;
+						return token::array;
+					}
+					else
+					{
+						//When search the repeated.
+						bool repeated = false;
+
+						while (true)
+						{
+							sp_ = _m_eat_whitespace(sp_);
+							auto tk = read();
+							if (token::number != tk && token::variable != tk && token::repeated != tk)
+								_m_throw_error("invalid array element");
+
+							if (!repeated)
+							{
+								switch (tk)
+								{
+								case token::number:
+									array_.push_back(number_);
+									break;
+								case token::variable:
+									array_.push_back({});
+									break;
+								default:
+									repeated = true;
+									reparray_.repeated();
+									reparray_.assign(std::move(array_));
+								}
+							}
+
+							sp_ = _m_eat_whitespace(sp_);
+							char ch = *sp_++;
+
+							if (ch == ']')
+								return (repeated ? token::reparray : token::array);
+
+							if (ch != ',')
+								_m_throw_error("invalid array");
+						}
+					}
+					break;
+				case '(':
+					parameters_.clear();
+					sp_ = _m_eat_whitespace(sp_ + 1);
+					if (*sp_ == ')')
+					{
+						++sp_;
+						return token::parameters;
+					}
+
+					while (true)
+					{
+						if (token::number == read())
+							parameters_.push_back(number_);
+						else
+							_m_throw_error("invalid parameter.");
+
+						sp_ = _m_eat_whitespace(sp_);
+						char ch = *sp_++;
+
+						if (ch == ')')
+							return token::parameters;
+
+						if (ch != ',')
+							_m_throw_error("invalid parameter.");
+					}
+					break;
+				case '.': case '-':
+					if (*sp_ == '-')
+					{
+						readbytes = _m_number(sp_ + 1, true);
+						if (readbytes)
+							++readbytes;
+					}
+					else
+						readbytes = _m_number(sp_, false);
+
+					if (readbytes)
+					{
+						sp_ += readbytes;
+						return token::number;
+					}
+					else
+						_m_throw_error("invalid character '" + std::string(1, *sp_) + "'");
+					break;
+				default:
+					if ('0' <= *sp_ && *sp_ <= '9')
+					{
+						readbytes = _m_number(sp_, false);
+						if (readbytes)
+						{
+							sp_ += readbytes;
+							return token::number;
+						}
+					}
+					break;
+				}
+
+				if ('_' == *sp_ || isalpha(*sp_))
+				{
+					const char * idstart = sp_++;
+
+					while ('_' == *sp_ || isalpha(*sp_) || isalnum(*sp_))
+						++sp_;
+
+					idstr_.assign(idstart, sp_);
+
+					if ("weight" == idstr_ || "min" == idstr_ || "max" == idstr_)
+					{
+						auto ch = idstr_[1];
+						_m_attr_number_value();
+						switch (ch)
+						{
+						case 'e': return token::weight;
+						case 'i': return token::min_px;
+						case 'a': return token::max_px;
+						}
+					}
+					else if ("dock" == idstr_)
+						return token::dock;
+					else if ("vertical" == idstr_ || "vert" == idstr_)
+						return token::vert;
+					else if ("variable" == idstr_ || "repeated" == idstr_)
+						return ('v' == idstr_[0] ? token::variable : token::repeated);
+					else if ("arrange" == idstr_ || "gap" == idstr_)
+					{
+						auto ch = idstr_[0];
+						_m_attr_reparray();
+						return ('a' == ch ? token::arrange : token::gap);
+					}
+					else if ("grid" == idstr_ || "margin" == idstr_)
+					{
+						auto idstr = idstr_;
+						if (token::equal != read())
+							_m_throw_error("an equal sign is required after '" + idstr + "'");
+
+						return ('g' == idstr[0] ? token::grid : token::margin);
+					}
+					else if ("collapse" == idstr_)
+					{
+						if (token::parameters != read())
+							_m_throw_error("a parameter list is required after 'collapse'");
+						return token::collapse;
+					}
+					else if ("left" == idstr_ || "right" == idstr_ || "top" == idstr_ || "bottom" == idstr_ || "undisplayed" == idstr_ || "invisible" == idstr_)
+					{
+						switch (idstr_.front())
+						{
+						case 'l': return token::left;
+						case 'r': return token::right;
+						case 't': return token::top;
+						case 'b': return token::bottom;
+						case 'u': return token::undisplayed;
+						case 'i': return token::invisible;
+						}
+					}
+
+					return token::identifier;
+				}
+
+				std::string err = "an invalid character '";
+				err += *sp_;
+				err += "'";
+
+				_m_throw_error(err);
+				return token::error;	//Useless, just for syntax correction.
+			}
+		private:
+			void _m_throw_error(char err_char)
+			{
+				std::string str = "place: invalid character '";
+				str += err_char;
+				str += '\'';
+				_m_throw_error(str);
+			}
+
+			void _m_throw_error(const std::string& err)
+			{
+				throw std::runtime_error("nana::place: " + err + " at " + std::to_string(static_cast<unsigned>(sp_ - divstr_)));
+			}
+
+			void _m_attr_number_value()
+			{
+				if (token::equal != read())
+					_m_throw_error("an equal sign is required after '" + idstr_ + "'");
+
+				auto p = _m_eat_whitespace(sp_);
+
+				auto neg_ptr = p;
+				if ('-' == *p)
+					++p;
+
+				auto len = _m_number(p, neg_ptr != p);
+				if (0 == len)
+					_m_throw_error("the '" + idstr_ + "' requires a number(integer or real or percent)");
+
+				sp_ += len + (p - sp_);
+			}
+
+			void _m_attr_reparray()
+			{
+				auto idstr = idstr_;
+				if (token::equal != read())
+					_m_throw_error("an equal sign is required after '" + idstr + "'");
+
+				sp_ = _m_eat_whitespace(sp_);
+
+				reparray_.reset();
+				auto tk = read();
+				switch (tk)
+				{
+				case token::number:
+					reparray_.push(number());
+					reparray_.repeated();
+					break;
+				case token::array:
+					reparray_.assign(std::move(array_));
+					break;
+				case token::reparray:
+					break;
+				default:
+					_m_throw_error("a (repeated) array is required after '" + idstr + "'");
+				}
+			}
+
+			static const char* _m_eat_whitespace(const char* sp)
+			{
+				while (*sp && !isgraph(*sp))
+					++sp;
+				return sp;
+			}
+
+			std::size_t _m_number(const char* sp, bool negative)
+			{
+				const char* allstart = sp;
+				sp = _m_eat_whitespace(sp);
+
+				number_.assign(0);
+
+				bool gotcha = false;
+				int integer = 0;
+				double real = 0;
+				//read the integral part.
+				const char* istart = sp;
+				while ('0' <= *sp && *sp <= '9')
+				{
+					integer = integer * 10 + (*sp - '0');
+					++sp;
+				}
+				const char* iend = sp;
+
+				if ('.' == *sp)
+				{
+					double div = 1;
+					const char* rstart = ++sp;
+					while ('0' <= *sp && *sp <= '9')
+					{
+						real += (*sp - '0') / (div *= 10);
+						++sp;
+					}
+
+					if (rstart != sp)
+					{
+						real += integer;
+						number_.assign(negative ? -real : real);
+						gotcha = true;
+					}
+				}
+				else if (istart != iend)
+				{
+					number_.assign(negative ? -integer : integer);
+					gotcha = true;
+				}
+
+				if (gotcha)
+				{
+					sp = _m_eat_whitespace(sp);
+					if ('%' == *sp)
+					{
+						if (number_t::kind::integer == number_.kind_of())
+							number_.assign_percent(number_.integer());
+						return sp - allstart + 1;
+					}
+					return sp - allstart;
+				}
+				number_.reset();
+				return 0;
+			}
+		private:
+			const char* divstr_;
+			const char* sp_;
+			std::string idstr_;
+			number_t number_;
+			std::vector<number_t> array_;
+			repeated_array		reparray_;
+			std::vector<number_t> parameters_;
+		};	//end class tokenizer
+	}
+
+	//struct implement
+	struct place::implement
+	{
+		class field_gather;
+		class field_dock;
+
+		class division;
+		class div_arrange;
+		class div_grid;
+		class div_splitter;
+		class div_dock;
+		class div_dockpane;
+
+		window window_handle{nullptr};
+		event_handle event_size_handle{nullptr};
+
+		std::string div_text;
+		std::unique_ptr<division> root_division;
+		std::map<std::string, field_gather*> fields;
+		std::map<std::string, field_dock*> docks;
+		std::map<std::string, field_dock*> dock_factoris;
+
+		//A temporary pointer used to refer to a specified div object which
+		//will be deleted in modification process.
+		std::unique_ptr<division> tmp_replaced;
+
+		//The following functions are defined behind the definition of class division.
+		//because the class division here is an incomplete type.
+		~implement();
+
+		void collocate();
+
+		static division * search_div_name(division* start, const std::string&);
+		std::unique_ptr<division> scan_div(place_parts::tokenizer&);
+		void check_unique(const division*) const;
+
+		//connect the field/dock with div object
+		void connect(division* start);
+		void disconnect();
+	};	//end struct implement
+
+	class place::implement::field_gather
+		: public place::field_interface
+	{
+	public:
+		struct element_t
+		{
+			window handle;
+			event_handle evt_destroy;
+
+			element_t(window h, event_handle event_destroy)
+				:handle(h), evt_destroy(event_destroy)
+			{}
+		};
+
+		field_gather(place * p)
+			: place_ptr_(p)
+		{}
+
+		~field_gather()
+		{
+			for (auto & e : elements)
+				API::umake_event(e.evt_destroy);
+
+			for (auto & e : fastened)
+				API::umake_event(e.evt_destroy);
+		}
+
+		void visible(bool vsb)
+		{
+			for (auto & e : elements)
+				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)
+		{
+			for (auto i = elements.begin(); i != elements.end(); ++i)
+			{
+				if (i->handle == handle)
+				{
+					auto evt_destroy = i->evt_destroy;
+					elements.erase(i);
+					return evt_destroy;
+				}
+			}
+			return nullptr;
+		}
+	private:
+		//Listen to destroy of a window
+		//It will delete the element and recollocate when the window destroyed.
+		event_handle _m_make_destroy(window wd)
+		{
+			return API::events(wd).destroy.connect([this, wd](const arg_destroy&)
+			{
+				if (erase_element(elements, wd))
+				{
+					if (!API::is_destroying(API::get_parent_window(wd)))
+						place_ptr_->collocate();
+				}
+			});
+		}
+
+		field_interface& operator<<(const char* label_text) override
+		{
+			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text ? label_text : ""));
+		}
+
+		field_interface& operator<<(std::string label_text) override
+		{
+			return static_cast<field_interface*>(this)->operator<<(agent<label>(label_text));
+		}
+
+		field_interface& operator<<(window wd) override
+		{
+			if (API::empty_window(wd))
+				throw std::invalid_argument("Place: An invalid window handle.");
+
+			if (API::get_parent_window(wd) != place_ptr_->window_handle())
+				throw std::invalid_argument("Place: the window is not a child of place bind window");
+
+			auto evt = _m_make_destroy(wd);
+			elements.emplace_back(wd, evt);
+			return *this;
+		}
+
+		field_interface& fasten(window wd) override
+		{
+			if (API::empty_window(wd))
+				throw std::invalid_argument("Place: An invalid window handle.");
+
+			if (API::get_parent_window(wd) != place_ptr_->window_handle())
+				throw std::invalid_argument("Place: the window is not a child of place bind window");
+
+			//Listen to destroy of a window. The deleting a fastened window
+			//does not change the layout.
+			auto evt = API::events(wd).destroy.connect([this](const arg_destroy& arg)
+			{
+				erase_element(fastened, arg.window_handle);
+			});
+
+			fastened.emplace_back(wd, evt);
+			return *this;
+		}
+
+		void _m_add_agent(const detail::place_agent& ag) override
+		{
+			widgets_.emplace_back(ag.create(place_ptr_->window_handle()));
+			this->operator<<(widgets_.back()->handle());
+		}
+	public:
+		division* attached{ nullptr };
+		std::vector<std::unique_ptr<nana::widget>> widgets_;
+		std::vector<element_t>	elements;
+		std::vector<element_t>	fastened;
+	private:
+		place * place_ptr_;
+	};//end class field_gather
+
+	class place::implement::field_dock
+	{
+
+	public:
+		div_dockpane * attached{ nullptr };					//attached div object
+		std::unique_ptr<place_parts::dockarea> dockarea;	//the dockable widget
+		std::map<std::string, std::function<std::unique_ptr<widget>(window)>> factories;	//factories for dockpane
+	};//end class field_dock
+
+
+
+	class place::implement::division
+	{
+	public:
+		enum class kind{ arrange, vertical_arrange, grid, splitter, dock, dockpane};
+
+		division(kind k, std::string&& n)
+			: kind_of_division(k),
+			name(std::move(n))
+		{}
+
+		virtual ~division()
+		{
+			//detach the field
+			if (field)
+				field->attached = nullptr;
+		}
+
+		void set_visible(bool vsb)
+		{
+			if (field)
+				field->visible(vsb);
+
+			_m_visible_for_child(this, vsb);
+			visible = vsb;
+		}
+
+		void set_display(bool dsp)
+		{
+			set_visible(dsp);
+			display = dsp;
+
+			if (kind::splitter != kind_of_division)
+			{
+				//Don't display the previous one, if it is a splitter
+				auto div = previous();
+				if (div && (kind::splitter == div->kind_of_division))
+				{
+					if (dsp)
+					{
+						auto leaf = div->previous();
+						if (leaf && leaf->display)
+							div->set_display(true);
+					}
+					else
+						div->set_display(false);
+				}
+
+				//Don't display the next one, if it is a splitter
+				if (div_next && (kind::splitter == div_next->kind_of_division))
+				{
+					if (dsp)
+					{
+						auto leaf = div_next->div_next;
+						if (leaf && leaf->display)
+							div_next->set_display(true);
+					}
+					else
+						div_next->set_display(false);
+				}
+			}
+			else
+			{
+				//This is a splitter, it only checks when it is being displayed
+				if (dsp)
+				{
+					//Left field of splitterbar
+					auto left = this->previous();
+					if (left && !left->display)
+						left->set_display(true);
+
+					//Right field of splitterbar
+					if (div_next && !div_next->display)
+						div_next->set_display(true);
+				}
+			}
+		}
+
+		bool is_back(const division* div) const
+		{
+			for (auto i = children.crbegin(); i != children.crend(); ++i)
+			{
+				if (!(i->get()->display))
+					continue;
+
+				return (div == i->get());
+			}
+			return false;
+		}
+
+		static double limit_px(const division* div, double px, unsigned area_px)
+		{
+			if (!div->min_px.empty())
+			{
+				auto v = div->min_px.get_value(static_cast<int>(area_px));
+				if (px < v)
+					return v;
+			}
+			if (!div->max_px.empty())
+			{
+				auto v = div->max_px.get_value(static_cast<int>(area_px));
+				if (px > v)
+					return v;
+			}
+			return px;
+		}
+
+		bool is_fixed() const
+		{
+			return (weight.kind_of() == number_t::kind::integer);
+		}
+
+		bool is_percent() const
+		{
+			return (weight.kind_of() == number_t::kind::percent);
+		}
+
+		nana::rectangle margin_area() const
+		{
+			return margin.area(field_area);
+		}
+
+		division * previous() const
+		{
+			if (div_owner)
+			{
+				for (auto & child : div_owner->children)
+					if (child->div_next == this)
+						return child.get();
+			}
+			return nullptr;
+
+		}
+	public:
+		void _m_visible_for_child(division * div, bool vsb)
+		{
+			for (auto & child : div->children)
+			{
+				if (child->field && (!vsb || child->visible))
+					child->field->visible(vsb);
+
+				_m_visible_for_child(child.get(), vsb);
+			}
+		}
+		//Collocate the division and its children divisions,
+		//The window parameter is specified for the window which the place object binded.
+		virtual void collocate(window) = 0;
+	public:
+		kind kind_of_division;
+		bool display{ true };
+		bool visible{ true };
+		::nana::direction dir{::nana::direction::west};
+		std::string name;
+		std::vector<std::unique_ptr<division>> children;
+
+		::nana::rectangle field_area;
+		number_t weight;
+		number_t min_px, max_px;
+
+		place_parts::margin	margin;
+		place_parts::repeated_array gap;
+		field_gather * field{ nullptr };
+		division * div_next{ nullptr };
+		division * div_owner{ nullptr };
+	};//end class division
+
+	class place::implement::div_arrange
+		: public division
+	{
+	public:
+		div_arrange(bool vert, std::string&& name, place_parts::repeated_array&& arr)
+			: division((vert ? kind::vertical_arrange : kind::arrange), std::move(name)),
+			arrange_(std::move(arr))
+		{}
+
+		void collocate(window wd) override
+		{
+			const bool vert = (kind::arrange != kind_of_division);
+
+			auto area_margined = margin_area();
+			rectangle_rotator area(vert, area_margined);
+			auto area_px = area.w();
+
+			auto fa = _m_fixed_and_adjustable(kind_of_division, area_px);
+
+			double adjustable_px = _m_revise_adjustable(fa, area_px);
+
+			double position = area.x();
+			std::vector<division*> delay_collocates;
+			double precise_px = 0;
+			for (auto& child_ptr : children)					/// First collocate child div's !!!
+			{
+				auto child = child_ptr.get();
+				if(!child->display)	//Ignore the division if the corresponding field is not displayed.
+					continue;
+
+				rectangle_rotator child_area(vert, child->field_area);
+				child_area.x_ref() = static_cast<int>(position);
+				child_area.y_ref() = area.y();
+				child_area.h_ref() = area.h();
+
+				double child_px;				// and calculate this div.
+				if (!child->is_fixed())			// with is fixed for fixed div
+				{
+					if (child->is_percent())			// and calculated for others: if the child div is percent - simple take it full
+						child_px = area_px * child->weight.real() + precise_px;
+					else
+						child_px = adjustable_px;
+
+					child_px = limit_px(child, child_px, area_px);
+					auto npx = static_cast<unsigned>(child_px);
+					precise_px = child_px - npx;
+					child_px = npx;
+				}
+				else
+					child_px = static_cast<unsigned>(child->weight.integer());
+
+				//Use 'endpos' to calc width is to avoid deviation
+				int endpos = static_cast<int>(position + child_px);
+				if ((!child->is_fixed()) && child->max_px.empty() && is_back(child) && (endpos != area.right()))
+					endpos = area.right();
+
+				child_area.w_ref() = static_cast<unsigned>((std::max)(endpos - child_area.x(), 0));
+
+				child->field_area = child_area.result();
+				position += child_px;
+
+				if (child->kind_of_division == kind::splitter)
+					delay_collocates.emplace_back(child);
+				else
+					child->collocate(wd);	/// The child div have full position. Now we can collocate  inside it the child fields and child-div.
+			}
+
+			for (auto child : delay_collocates)
+				child->collocate(wd);
+
+			if (visible && display && field)
+			{
+				auto element_r = area;
+				std::size_t index = 0;
+				double precise_px = 0;
+
+				for (auto & el : field->elements)
+				{
+					element_r.x_ref() = static_cast<int>(position);
+					auto px = _m_calc_number(arrange_.at(index), area_px, adjustable_px, precise_px);
+
+					element_r.w_ref() = px;
+					API::move_window(el.handle, element_r.result());
+
+					if (index + 1 < field->elements.size())
+						position += (px + _m_calc_number(gap.at(index), area_px, 0, precise_px));
+
+					++index;
+				}
+
+				for (auto & fsn : field->fastened)
+					API::move_window(fsn.handle, area_margined);
+			}
+		}
+	private:
+		static unsigned _m_calc_number(const place_parts::number_t& number, unsigned area_px, double adjustable_px, double& precise_px)
+		{
+			switch (number.kind_of())
+			{
+			case number_t::kind::integer:
+				return static_cast<unsigned>(number.integer());
+			case number_t::kind::real:
+				return static_cast<unsigned>(number.real());
+			case number_t::kind::percent:
+				adjustable_px = area_px * number.real();
+			case number_t::kind::none:
+				{
+					auto fpx = adjustable_px + precise_px;
+					auto px = static_cast<unsigned>(fpx);
+					precise_px = fpx - px;
+					return px;
+				}
+				break;
+			}
+			return 0; //Useless
+		}
+
+		static std::pair<unsigned, std::size_t> _m_calc_fa(const place_parts::number_t& number, unsigned area_px, double& precise_px)
+		{
+			std::pair<unsigned, std::size_t> result;
+			switch (number.kind_of())
+			{
+			case number_t::kind::integer:
+				result.first = static_cast<unsigned>(number.integer());
+				break;
+			case number_t::kind::real:
+				result.first = static_cast<unsigned>(number.real());
+				break;
+			case number_t::kind::percent:
+				{
+					double px = number.real() * area_px + precise_px;
+					auto npx = static_cast<unsigned>(px);
+					result.first = npx;
+					precise_px = px - npx;
+				}
+				break;
+			case number_t::kind::none:
+				++result.second;
+				break;
+			}
+			return result;
+		}
+
+		//Returns the fixed pixels and the number of adjustable items.
+		std::pair<unsigned, std::size_t> _m_fixed_and_adjustable(kind match_kind, unsigned area_px) const
+		{
+			std::pair<unsigned, std::size_t> result;
+			if (field && (kind_of_division == match_kind))
+			{
+				//Calculate fixed and adjustable of elements
+				double precise_px = 0;
+				auto count = field->elements.size();
+				for (decltype(count) i = 0; i < count; ++i)
+				{
+					auto fa = _m_calc_fa(arrange_.at(i), area_px, precise_px);
+					result.first += fa.first;
+					result.second += fa.second;
+
+					if (i + 1 < count)
+					{
+						fa = _m_calc_fa(gap.at(i), area_px, precise_px);
+						result.first += fa.first;
+						//fa.second is ignored for gap, because the it has not the adjustable gap.
+					}
+				}
+			}
+
+			double children_fixed_px = 0;
+			for (auto& child : children)
+			{
+				if (!child->display)	//Ignore the division if the corresponding field is not displayed.
+					continue;
+
+				if (!child->weight.empty())
+					children_fixed_px += child->weight.get_value(area_px);
+				else
+					++result.second;
+			}
+			result.first += static_cast<unsigned>(children_fixed_px);
+			return result;
+		}
+
+		double _m_revise_adjustable(std::pair<unsigned, std::size_t>& fa, unsigned area_px)
+		{
+			if (fa.first >= area_px || 0 == fa.second)
+				return 0;
+
+			double var_px = area_px - fa.first;
+
+			struct revise_t
+			{
+				division * div;
+				double min_px;
+				double max_px;
+			};
+
+			std::size_t min_count = 0;
+			double sum_min_px = 0;
+			std::vector<revise_t> revises;
+			for (auto& child : children)
+			{
+				if ((!child->weight.empty()) || !child->display)
+					continue;
+
+				double min_px = std::numeric_limits<double>::lowest(), max_px = std::numeric_limits<double>::lowest();
+
+				if (!child->min_px.empty())
+				{
+					min_px = child->min_px.get_value(static_cast<int>(area_px));
+					sum_min_px += min_px;
+					++min_count;
+				}
+
+				if (!child->max_px.empty())
+					max_px = child->max_px.get_value(static_cast<int>(area_px));
+
+				if (min_px >= 0 && max_px >= 0 && min_px > max_px)
+				{
+					if (child->min_px.kind_of() == number_t::kind::percent)
+						min_px = std::numeric_limits<double>::lowest();
+					else if (child->max_px.kind_of() == number_t::kind::percent)
+						max_px = std::numeric_limits<double>::lowest();
+				}
+
+				if (min_px >= 0 || max_px >= 0)
+					revises.push_back({ child.get(), min_px, max_px });
+			}
+
+			if (revises.empty())
+				return var_px / fa.second;
+
+			auto find_lowest = [&revises](double level_px)
+			{
+				double v = (std::numeric_limits<double>::max)();
+
+				for (auto i = revises.begin(); i != revises.end(); ++i)
+				{
+					auto & rev = *i;
+					if (rev.min_px >= 0 && rev.min_px < v && rev.min_px > level_px)
+						v = rev.min_px;
+					else if (rev.max_px >= 0 && rev.max_px < v)
+						v = rev.max_px;
+				}
+				return v;
+			};
+
+			auto remove_full = [&revises](double value, std::size_t& full_count)
+			{
+				full_count = 0;
+				std::size_t reached_mins = 0;
+				auto i = revises.begin();
+				while(i != revises.end())
+				{
+					if (i->max_px == value)
+					{
+						++full_count;
+						i = revises.erase(i);
+					}
+					else
+					{
+						if (i->min_px == value)
+							++reached_mins;
+						++i;
+					}
+				}
+				return reached_mins;
+			};
+
+			double block_px = 0;
+			double level_px = 0;
+			auto rest_px = var_px - sum_min_px;
+			std::size_t blocks = fa.second;
+
+			while ((rest_px > 0) && blocks)
+			{
+				auto lowest = find_lowest(level_px);
+				double fill_px = 0;
+				//blocks may be equal to min_count. E.g, all child divisions have min/max attribute.
+				if (blocks > min_count)
+				{
+					fill_px = rest_px / (blocks - min_count);
+					if (fill_px + level_px <= lowest)
+					{
+						block_px += fill_px;
+						break;
+					}
+				}
+
+				block_px = lowest;
+				if (blocks > min_count)
+					rest_px -= (lowest-level_px) * (blocks - min_count);
+
+				std::size_t full_count;
+				min_count -= remove_full(lowest, full_count);
+				blocks -= full_count;
+				level_px = lowest;
+			}
+
+			return block_px;
+		}
+	private:
+		place_parts::repeated_array arrange_;
+	};
+
+	class place::implement::div_grid
+		: public division
+	{
+	public:
+		div_grid(std::string&& name, place_parts::repeated_array&& arrange, std::vector<rectangle>&& collapses)
+			: division(kind::grid, std::move(name)),
+			arrange_(std::move(arrange)),
+			collapses_(std::move(collapses))
+		{
+			dimension.first = dimension.second = 0;
+		}
+
+		void revise_collapses()
+		{
+			if (collapses_.empty())
+				return;
+
+			for (auto i = collapses_.begin(); i != collapses_.end();)
+			{
+				if (i->x >= static_cast<int>(dimension.first) || i->y >= static_cast<int>(dimension.second))
+					i = collapses_.erase(i);
+				else
+					++i;
+			}
+
+			//Remove the overlapped collapses
+			for (std::size_t i = 0; i < collapses_.size() - 1; ++i)
+			{
+				auto & col = collapses_[i];
+				for (auto u = i + 1; u != collapses_.size();)
+				{
+					auto & z = collapses_[u];
+					if (col.is_hit(z.x, z.y) || col.is_hit(z.right(), z.y) || col.is_hit(z.x, z.bottom()) || col.is_hit(z.right(), z.bottom()))
+						collapses_.erase(collapses_.begin() + u);
+					else
+						++u;
+				}
+			}
+
+			for (auto & col : collapses_)
+			{
+				if (col.right() >= static_cast<int>(dimension.first))
+					col.width = dimension.first - static_cast<unsigned>(col.x);
+
+				if (col.bottom() >= static_cast<int>(dimension.second))
+					col.height = dimension.second - static_cast<unsigned>(col.y);
+			}
+		}
+
+		void collocate(window) override
+		{
+			if (!field || !(visible && display))
+				return;
+
+			auto area = margin_area();
+
+			unsigned gap_size = 0;
+			auto gap_number = gap.at(0);
+			if (!gap_number.empty())
+				gap_size = static_cast<unsigned>(gap_number.get_value(area.width));
+
+			//When the amount pixels of gaps is out of the area bound.
+			if ((gap_size * dimension.first >= area.width) || (gap_size * dimension.second >= area.height))
+			{
+				for (auto & el : field->elements)
+					API::window_size(el.handle, size{ 0, 0 });
+				return;
+			}
+
+			if (dimension.first <= 1 && dimension.second <= 1)
+			{
+				auto n_of_wd = field->elements.size();
+				std::size_t edge;
+				switch (n_of_wd)
+				{
+				case 0:
+				case 1:
+					edge = 1;	break;
+				case 2: case 3: case 4:
+					edge = 2;	break;
+				default:
+					edge = static_cast<std::size_t>(std::sqrt(n_of_wd));
+					if ((edge * edge) < n_of_wd) ++edge;
+				}
+
+				bool exit_for = false;
+				double y = area.y;
+				double block_w = area.width / double(edge);
+				double block_h = area.height / double((n_of_wd / edge) + (n_of_wd % edge ? 1 : 0));
+				unsigned uns_block_w = static_cast<unsigned>(block_w);
+				unsigned uns_block_h = static_cast<unsigned>(block_h);
+				unsigned height = (uns_block_h > gap_size ? uns_block_h - gap_size : uns_block_h);
+
+				auto i = field->elements.cbegin(), end = field->elements.cend();
+				std::size_t arr_pos = 0;
+				for (std::size_t u = 0; u < edge; ++u)
+				{
+					double x = area.x;
+					for (std::size_t v = 0; v < edge; ++v)
+					{
+						if (i == end)
+						{
+							exit_for = true;
+							break;
+						}
+
+						unsigned value = 0;
+						auto arr = arrange_.at(arr_pos++);
+
+						if (arr.empty())
+							value = static_cast<decltype(value)>(block_w);
+						else
+							value = static_cast<decltype(value)>(arr.get_value(static_cast<int>(area.width)));
+
+						unsigned width = (value > uns_block_w ? uns_block_w : value);
+						if (width > gap_size)	width -= gap_size;
+						API::move_window(i->handle, rectangle{ static_cast<int>(x), static_cast<int>(y), width, height });
+						x += block_w;
+						++i;
+					}
+					if (exit_for) break;
+					y += block_h;
+				}
+			}
+			else
+			{
+				double block_w = int(area.width - gap_size * (dimension.first - 1)) / double(dimension.first);
+				double block_h = int(area.height - gap_size * (dimension.second - 1)) / double(dimension.second);
+
+				std::unique_ptr<char[]> table_ptr(new char[dimension.first * dimension.second]);
+
+				char *table = table_ptr.get();
+				std::memset(table, 0, dimension.first * dimension.second);
+
+				std::size_t lbp = 0;
+				bool exit_for = false;
+
+				auto i = field->elements.cbegin(), end = field->elements.cend();
+
+				double precise_h = 0;
+				for (std::size_t c = 0; c < dimension.second; ++c)
+				{
+					unsigned block_height_px = static_cast<unsigned>(block_h + precise_h);
+					precise_h = (block_h + precise_h) - block_height_px;
+
+					double precise_w = 0;
+					for (std::size_t l = 0; l < dimension.first; ++l)
+					{
+						if (table[l + lbp])
+						{
+							precise_w += block_w;
+							auto px = static_cast<int>(precise_w);
+							precise_w -= px;
+							continue;
+						}
+
+						if (i == end)
+						{
+							exit_for = true;
+							break;
+						}
+
+						std::pair<unsigned, unsigned> room{ 1, 1 };
+
+						_m_find_collapse(static_cast<int>(l), static_cast<int>(c), room);
+
+						int pos_x = area.x + static_cast<int>(l * (block_w + gap_size));
+						int pos_y = area.y + static_cast<int>(c * (block_h + gap_size));
+
+						unsigned result_h;
+						if (room.first <= 1 && room.second <= 1)
+						{
+							precise_w += block_w;
+							result_h = block_height_px;
+							table[l + lbp] = 1;
+						}
+						else
+						{
+							precise_w += block_w * room.first + (room.first - 1) * gap_size;
+							result_h = static_cast<unsigned>(block_h * room.second + precise_h + (room.second - 1) * gap_size);
+
+							for (unsigned y = 0; y < room.second; ++y)
+								for (unsigned x = 0; x < room.first; ++x)
+									table[l + x + lbp + y * dimension.first] = 1;
+						}
+
+						unsigned result_w = static_cast<unsigned>(precise_w);
+						precise_w -= result_w;
+
+						API::move_window(i->handle, rectangle{ pos_x, pos_y, result_w, result_h });
+						++i;
+					}
+
+					if (exit_for)
+					{
+						size empty_sz;
+						for (; i != end; ++i)
+							API::window_size(i->handle, empty_sz);
+						break;
+					}
+					lbp += dimension.first;
+				}
+			}
+
+			for (auto & fsn : field->fastened)
+				API::move_window(fsn.handle, area);
+		}
+	public:
+		std::pair<unsigned, unsigned> dimension;
+	private:
+		void _m_find_collapse(int x, int y, std::pair<unsigned, unsigned>& collapse) const
+		{
+			for (auto & col : collapses_)
+			{
+				if (col.x == x && col.y == y)
+				{
+					collapse.first = col.width;
+					collapse.second = col.height;
+					return;
+				}
+			}
+		}
+	private:
+		place_parts::repeated_array arrange_;
+		std::vector<rectangle> collapses_;
+	};//end class div_grid
+
+	class place::implement::div_splitter
+		: public division
+	{
+		struct div_block
+		{
+			division * div;
+			int	pixels;
+			double		scale;
+
+			div_block(division* d, int px)
+				: div(d), pixels(px)
+			{}
+		};
+
+		enum{splitter_px = 4};
+	public:
+		div_splitter(place_parts::number_t init_weight)
+			: division(kind::splitter, std::string()),
+			init_weight_(init_weight)
+		{
+			this->weight.assign(splitter_px);
+		}
+
+		void direction(bool horizontal)
+		{
+			splitter_cursor_ = (horizontal ? cursor::size_we : cursor::size_ns);
+		}
+	private:
+		void collocate(window wd) override
+		{
+			if (API::is_destroying(wd))
+				return;
+
+			if (splitter_.empty())
+			{
+				splitter_.create(wd);
+				splitter_.cursor(splitter_cursor_);
+
+				dragger_.trigger(splitter_);
+
+				auto grab_fn = [this](const arg_mouse& arg)
+				{
+					if (false == arg.left_button)
+						return;
+
+					if (event_code::mouse_down == arg.evt_code)
+					{
+						begin_point_ = splitter_.pos();
+
+						auto px_ptr = &nana::rectangle::width;
+
+						//Use field_area of leaf, not margin_area. Otherwise splitter would be at wrong position
+						auto area_left = _m_leaf_left()->field_area;
+						auto area_right = _m_leaf_right()->field_area;
+
+						if (nana::cursor::size_we != splitter_cursor_)
+						{
+							left_pos_ = area_left.y;
+							right_pos_ = area_right.bottom();
+							px_ptr = &nana::rectangle::height;
+						}
+						else
+						{
+							left_pos_ = area_left.x;
+							right_pos_ = area_right.right();
+						}
+
+						left_pixels_ = area_left.*px_ptr;
+						right_pixels_ = area_right.*px_ptr;
+						
+						grabbed_ = true;
+					}
+					else if(event_code::mouse_up == arg.evt_code)
+					{
+						grabbed_ = false;
+					}
+					else if (event_code::mouse_move == arg.evt_code)
+					{
+						if(!grabbed_)
+							return;
+							
+						const bool vert = (::nana::cursor::size_we != splitter_cursor_);
+						auto area_px = rectangle_rotator(vert, div_owner->margin_area()).w();
+						int delta = (vert ? splitter_.pos().y - begin_point_.y : splitter_.pos().x - begin_point_.x);
+
+						int total_pixels = static_cast<int>(left_pixels_ + right_pixels_);
+
+						auto left_px = static_cast<int>(left_pixels_) + delta;
+						if (left_px > total_pixels)
+							left_px = total_pixels;
+						else if (left_px < 0)
+							left_px = 0;
+
+						double imd_rate = 100.0 / area_px;
+						left_px = static_cast<int>(limit_px(_m_leaf_left(), left_px, area_px));
+						_m_leaf_left()->weight.assign_percent(imd_rate * left_px);
+
+						auto right_px = static_cast<int>(right_pixels_) - delta;
+						if (right_px > total_pixels)
+							right_px = total_pixels;
+						else if (right_px < 0)
+							right_px = 0;
+
+						right_px = static_cast<int>(limit_px(_m_leaf_right(), right_px, area_px));
+						_m_leaf_right()->weight.assign_percent(imd_rate * right_px);
+
+						pause_move_collocate_ = true;
+						div_owner->collocate(splitter_.parent());
+
+						//After the collocating, the splitter keeps the calculated weight of left division,
+						//and clear the weight of right division.
+						_m_leaf_right()->weight.reset();
+
+						pause_move_collocate_ = false;
+					}
+				};
+
+				auto & events = splitter_.events();
+				events.mouse_down.connect_unignorable(grab_fn);
+				events.mouse_up.connect_unignorable(grab_fn);
+				events.mouse_move.connect_unignorable(grab_fn);
+			}
+
+			auto limited_range = _m_update_splitter_range();
+
+			if (!init_weight_.empty())
+			{
+				const bool vert = (::nana::cursor::size_we != splitter_cursor_);
+
+				auto leaf_left = _m_leaf_left();
+				auto leaf_right = _m_leaf_right();
+				rectangle_rotator left(vert, leaf_left->field_area);
+				rectangle_rotator right(vert, leaf_right->field_area);
+				auto area_px = right.right() - left.x();
+				auto right_px = static_cast<int>(limit_px(leaf_right, init_weight_.get_value(area_px), static_cast<unsigned>(area_px)));
+
+				auto pos = area_px - right_px - splitter_px; //New position of splitter
+				if (pos < limited_range.x())
+					pos = limited_range.x();
+				else if (pos > limited_range.right())
+					pos = limited_range.right();
+
+				rectangle_rotator sp_r(vert, field_area);
+				sp_r.x_ref() = pos;
+
+				left.w_ref() = static_cast<unsigned>(pos - left.x());
+
+				auto right_pos = right.right();
+				right.x_ref() = (pos + splitter_px);
+				right.w_ref() = static_cast<unsigned>(right_pos - pos - splitter_px);
+
+				field_area = sp_r.result();
+				leaf_left->field_area = left.result();
+				leaf_right->field_area = right.result();
+				leaf_left->collocate(wd);
+				leaf_right->collocate(wd);
+
+				//Set the leafs' weight
+				rectangle_rotator area(vert, div_owner->field_area);
+
+				double imd_rate = 100.0 / static_cast<int>(area.w());
+				leaf_left->weight.assign_percent(imd_rate * static_cast<int>(left.w()));
+				leaf_right->weight.assign_percent(imd_rate * static_cast<int>(right.w()));
+
+				splitter_.move(this->field_area);
+
+				init_weight_.reset();
+			}
+
+			if (false == pause_move_collocate_)
+				splitter_.move(this->field_area);
+		}
+	private:
+		division * _m_leaf_left() const
+		{
+			return previous();
+		}
+
+		division * _m_leaf_right() const
+		{
+			return div_next;
+		}
+
+		rectangle_rotator _m_update_splitter_range()
+		{
+			const bool vert = (cursor::size_ns == splitter_cursor_);
+
+			rectangle_rotator area(vert, div_owner->margin_area());
+
+			auto leaf_left = _m_leaf_left();
+			auto leaf_right = _m_leaf_right();
+
+			rectangle_rotator left(vert, leaf_left->field_area);
+			rectangle_rotator right(vert, leaf_right->field_area);
+
+			const int left_base = left.x(), right_base = right.right();
+			int pos = left_base;
+			int endpos = right_base;
+
+			if (!leaf_left->min_px.empty())
+			{
+				auto v = leaf_left->min_px.get_value(area.w());
+				pos += static_cast<int>(v);
+			}
+			if (!leaf_left->max_px.empty())
+			{
+				auto v = leaf_left->max_px.get_value(area.w());
+				endpos = left_base + static_cast<int>(v);
+			}
+
+			if (!leaf_right->min_px.empty())
+			{
+				auto v = leaf_right->min_px.get_value(area.w());
+				auto x = right_base - static_cast<int>(v);
+				if (x < endpos)
+					endpos = x;
+			}
+			if (!leaf_right->max_px.empty())
+			{
+				auto v = leaf_right->max_px.get_value(area.w());
+				auto x = right_base - static_cast<int>(v);
+				if (x > pos)
+					pos = x;
+			}
+
+			area.x_ref() = pos;
+			area.w_ref() = unsigned(endpos - pos + splitter_px);
+
+			dragger_.target(splitter_, area.result(), (vert ? nana::arrange::vertical : nana::arrange::horizontal));
+
+			return area;
+		}
+	private:
+		nana::cursor	splitter_cursor_{nana::cursor::arrow};
+		place_parts::splitter<true>	splitter_;
+		nana::point	begin_point_;
+		int			left_pos_, right_pos_;
+		unsigned	left_pixels_, right_pixels_;
+		dragger	dragger_;
+		bool	grabbed_{ false };
+		bool	pause_move_collocate_{ false };	//A flag represents whether do move when collocating.
+		place_parts::number_t init_weight_;
+	};
+
+	class place::implement::div_dockpane
+		: public division, public place_parts::dock_notifier_interface
+	{
+	public:
+		div_dockpane(std::string && name, implement* impl, direction pane_dir)
+			:	division(kind::dockpane, std::move(name)),
+				impl_ptr_{impl}
+		{
+			dir = pane_dir;
+			this->display = false;
+		}
+
+		~div_dockpane()
+		{
+			if (dockable_field)
+			{
+				dockable_field->dockarea.reset();
+				dockable_field->attached = nullptr;
+			}
+		}
+
+		void collocate(window) override
+		{
+			if (!dockable_field)
+			{
+				if (name.empty())
+					return;
+
+				auto &dock_ptr = impl_ptr_->docks[name];
+				if (!dock_ptr)
+					dock_ptr = new field_dock;
+
+				dock_ptr->attached = this;
+				dockable_field = dock_ptr;
+			}
+
+			auto & dockarea = dockable_field->dockarea;
+			if (dockarea && !dockarea->floating())
+				dockarea->move(this->field_area);
+		}
+	private:
+		//Implement dock_notifier_interface
+		void notify_float() override
+		{
+			set_display(false);
+			impl_ptr_->collocate();
+		}
+
+		void notify_dock() override
+		{
+			indicator_.docker.reset();
+
+			set_display(true);
+			impl_ptr_->collocate();
+		}
+
+		void notify_move() override
+		{
+			if (!_m_indicator())
+			{
+				indicator_.docker.reset();
+				return;
+			}
+
+			if (!indicator_.docker)
+			{
+				auto host_size = API::window_size(impl_ptr_->window_handle);
+				indicator_.docker.reset(new form(impl_ptr_->window_handle, { static_cast<int>(host_size.width) / 2 - 16, static_cast<int>(host_size.height) / 2 - 16, 32, 32 }, form::appear::bald<>()));
+				drawing dw(indicator_.docker->handle());
+				dw.draw([](paint::graphics& graph)
+				{
+					graph.rectangle(false, colors::midnight_blue);
+					graph.rectangle({ 1, 1, 30, 30 }, true, colors::light_sky_blue);
+
+					facade<element::arrow> arrow;
+					arrow.direction(::nana::direction::south);
+					arrow.draw(graph, colors::light_sky_blue, colors::midnight_blue, { 12, 0, 16, 16 }, element_state::normal);
+
+					graph.rectangle({ 4, 16, 24, 11 }, true, colors::midnight_blue);
+					graph.rectangle({ 5, 19, 22, 7 }, true, colors::button_face);
+				});
+
+				indicator_.docker->z_order(nullptr, ::nana::z_order_action::topmost);
+				indicator_.docker->show();
+
+				indicator_.docker->events().destroy.connect([this](const arg_destroy&)
+				{
+					if (indicator_.dock_area)
+					{
+						indicator_.dock_area.reset();
+						indicator_.graph.release();
+					}
+				});
+			}
+
+			if (_m_dockable())
+			{
+				if (!indicator_.dock_area)
+				{
+					set_display(true);
+					impl_ptr_->collocate();
+
+					indicator_.graph.make(API::window_size(impl_ptr_->window_handle));
+					API::window_graphics(impl_ptr_->window_handle, indicator_.graph);
+
+					indicator_.dock_area.reset(new panel<true>(impl_ptr_->window_handle, false));
+					indicator_.dock_area->move(this->field_area);
+
+					::nana::drawing dw(indicator_.dock_area->handle());
+					dw.draw([this](paint::graphics& graph)
+					{
+						indicator_.graph.paste(this->field_area, graph, 0, 0);
+
+						const int border_px = 4;
+						rectangle r{ graph.size() };
+						int right = r.right();
+						int bottom = r.bottom();
+
+						graph.blend(r.pare_off(border_px), colors::blue, 0.3);
+
+						::nana::color clr = colors::deep_sky_blue;
+						r.y = 0;
+						r.height = border_px;
+						graph.blend(r, clr, 0.5);
+						r.y = bottom - border_px;
+						graph.blend(r, clr, 0.5);
+
+						r.x = r.y = 0;
+						r.dimension(graph.size());
+						r.width = border_px;
+						graph.blend(r, clr, 0.5);
+						r.x = right - border_px;
+						graph.blend(r, clr, 0.5);
+
+					});
+
+					API::bring_top(indicator_.dock_area->handle(), false);
+					indicator_.dock_area->show();
+				}
+			}
+			else
+			{
+				set_display(false);
+				impl_ptr_->collocate();
+				if (indicator_.dock_area)
+				{
+					indicator_.dock_area.reset();
+					indicator_.graph.release();
+				}
+			}
+
+		}
+
+		void notify_move_stopped() override
+		{
+			if (_m_dockable() && dockable_field && dockable_field->dockarea)
+				dockable_field->dockarea->dock();
+
+			indicator_.docker.reset();
+		}
+
+		void request_close() override
+		{
+			auto window_handle = dockable_field->dockarea->handle();
+
+			//a workaround for capture
+			auto ptr = dockable_field->dockarea.release();
+			API::at_safe_place(window_handle, [ptr]
+			{
+				std::unique_ptr<typename std::remove_pointer<decltype(ptr)>::type> del(ptr);
+			});
+
+			this->set_display(false);
+			impl_ptr_->collocate();
+
+			API::close_window(window_handle);
+		}
+	private:
+		bool _m_indicator() const
+		{
+			::nana::point pos;
+			API::calc_screen_point(impl_ptr_->window_handle, pos);
+
+			rectangle r{ pos, API::window_size(impl_ptr_->window_handle) };
+			return r.is_hit(API::cursor_position());
+		}
+
+		bool _m_dockable() const
+		{
+			if (!indicator_.docker)
+				return false;
+
+			::nana::point pos;
+			API::calc_screen_point(indicator_.docker->handle(), pos);
+
+			rectangle r{ pos, API::window_size(indicator_.docker->handle()) };
+			return r.is_hit(API::cursor_position());
+		}
+	public:
+		field_dock * dockable_field{ nullptr };
+
+		std::unique_ptr<widget>	splitter;
+	private:
+		implement * impl_ptr_;
+
+		//
+		struct indicator_rep
+		{
+			paint::graphics graph;
+			std::unique_ptr<panel<true>> dock_area;
+			std::unique_ptr<form> docker;
+		}indicator_;
+	};
+
+	class place::implement::div_dock
+		: public division
+	{
+		static const unsigned splitter_px = 5;
+
+		class splitter : public panel<true>
+		{
+		public:
+			splitter(window wd, ::nana::direction dir, division* dock_dv, division* pane_dv)
+				: panel<true>(wd, true), dir_(dir), dock_dv_(dock_dv), pane_dv_(pane_dv)
+			{
+				this->bgcolor(colors::alice_blue);
+				this->cursor(_m_is_vert(dir_) ? ::nana::cursor::size_ns : ::nana::cursor::size_we);
+
+
+				auto grab_fn = [this, wd](const arg_mouse& arg)
+				{
+					if (event_code::mouse_down == arg.evt_code)	//press mouse button
+					{
+						if (arg.button != ::nana::mouse::left_button)
+							return;
+
+						bool is_vert = _m_is_vert(dir_);
+
+						this->set_capture(true);
+
+						auto basepos = API::cursor_position();
+						base_pos_.x = (is_vert ? basepos.y : basepos.x);
+
+						basepos = this->pos();
+						base_pos_.y = (is_vert ? basepos.y : basepos.x);
+
+						base_px_ = (is_vert ? pane_dv_->field_area.height : pane_dv_->field_area.width);
+					}
+					else if (event_code::mouse_move == arg.evt_code)	//hover
+					{
+						if (!arg.is_left_button())
+							return;
+
+						auto now_pos = API::cursor_position();
+						int delta = (_m_is_vert(dir_) ? now_pos.y : now_pos.x) - base_pos_.x;
+						int new_pos = base_pos_.y + delta;
+						if (new_pos < range_.x)
+						{
+							new_pos = range_.x;
+							delta = new_pos - base_pos_.y;
+						}
+						else if (new_pos >= range_.y)
+						{
+							new_pos = range_.y - 1;
+							delta = new_pos - base_pos_.y;
+						}
+
+						now_pos = this->pos();
+						if (_m_is_vert(dir_))
+							now_pos.y = new_pos;
+						else
+							now_pos.x = new_pos;
+						this->move(now_pos);
+
+						auto px = base_px_;
+						switch (dir_)
+						{
+						case ::nana::direction::west:
+						case ::nana::direction::north:
+							if (delta < 0)
+								px -= static_cast<unsigned>(-delta);
+							else
+								px += static_cast<unsigned>(delta);
+							break;
+						case ::nana::direction::east:
+						case ::nana::direction::south:
+							if (delta < 0)
+								px += static_cast<unsigned>(-delta);
+							else
+								px -= static_cast<unsigned>(delta);
+							break;
+						default:
+							break;
+						}
+
+						auto dock_px = (_m_is_vert(dir_) ? dock_dv_->field_area.height : dock_dv_->field_area.width);
+
+						pane_dv_->weight.assign_percent(double(px) / double(dock_px) * 100);
+
+						dock_dv_->collocate(wd);
+					}
+					else
+						this->release_capture();
+				};
+
+				auto & evt = this->events();
+				evt.mouse_down.connect(grab_fn);
+				evt.mouse_up.connect(grab_fn);
+				evt.mouse_move.connect(grab_fn);
+			}
+
+			void range(int begin, int end)
+			{
+				range_.x = begin;
+				range_.y = end;
+			}
+		private:
+			const ::nana::direction	dir_;
+			division* const dock_dv_;
+			division* const	pane_dv_;
+			::nana::point	range_;
+			::nana::point	base_pos_;	//x = mouse pos, y = splitter pos
+			unsigned		base_px_;	//weight of div_dockpane when mouse button is been pressing;
+
+		};
+	public:
+		div_dock(std::string && name, implement* impl)
+			: division(kind::dock, std::move(name)), impl_(impl)
+		{}
+
+		division* front() const
+		{
+			for (auto & child : children)
+			{
+				if (child->display)
+					return child.get();
+			}
+
+			return nullptr;
+		}
+
+		void collocate(window wd) override
+		{
+			auto area = this->margin_area();
+
+			unsigned vert_count = 0, horz_count = 0;
+
+			bool is_first = true;
+			bool prev_attr;
+
+			for (auto & child : children)
+			{
+				if (!child->display)
+					continue;
+
+				const auto is_vert = _m_is_vert(child->dir);
+				if (is_first)
+				{
+					is_first = false;
+					(is_vert ? horz_count : vert_count) = 1;
+					prev_attr = is_vert;
+				}
+
+				if ((is_vert == prev_attr) == is_vert)
+					++vert_count;
+				else
+					++horz_count;
+
+				prev_attr = is_vert;
+			}
+			if (0 == vert_count)
+				vert_count = 1;
+			if (0 == horz_count)
+				horz_count = 1;
+
+			//room indicates the size without splitters
+			::nana::size room(area.width - splitter_px * (horz_count - 1), area.height - splitter_px * (vert_count - 1));
+
+			double left = area.x;
+			double right = area.right();
+			double top = area.y;
+			double bottom = area.bottom();
+
+			for (auto & child : children)
+			{
+				if (!child->display)
+				{
+					auto child_dv = dynamic_cast<div_dockpane*>(child.get());
+					if (child_dv)
+						child_dv->splitter.reset();
+
+					continue;
+				}
+
+				auto child_dv = dynamic_cast<div_dockpane*>(child.get());
+				const bool is_vert = _m_is_vert(child->dir);
+
+				auto room_px = (is_vert ? room.height : room.width);
+
+				double weight;
+				if (!child->weight.empty())
+				{
+					weight = child->weight.get_value(is_vert ? room.height : room.width);
+					if (weight > room_px)
+						weight = room_px;
+				}
+				else
+					weight = room_px / double(is_vert ? vert_count : horz_count);
+
+				splitter* split = nullptr;
+				if (_m_right(child_dv))
+				{
+					//Creates a splitbar if the 'right' leaf is not empty
+					if (!child_dv->splitter)
+					{
+						split = new splitter(impl_->window_handle, child->dir, this, child_dv);
+						child_dv->splitter.reset(split);
+					}
+					else
+						split = dynamic_cast<splitter*>(child_dv->splitter.get());
+				}
+				else
+					child_dv->splitter.reset();
+
+				::nana::rectangle child_r;
+				double split_range_begin = -1, split_range_end;
+				switch (child->dir)
+				{
+				default:
+				case ::nana::direction::west:
+					child_r.x = static_cast<int>(left);
+					child_r.y = static_cast<int>(top);
+					child_r.width = static_cast<unsigned>(weight);
+					child_r.height = static_cast<unsigned>(bottom - top);
+					left += weight;
+					if (split)
+					{
+						split->move(rectangle{ child_r.right(), child_r.y, splitter_px, child_r.height });
+						split_range_begin = left - weight;
+						split_range_end = right - static_cast<int>(splitter_px);
+						left += splitter_px;
+					}
+					break;
+				case ::nana::direction::east:
+					right -= weight;
+					child_r.x = static_cast<int>(right);
+					child_r.y = static_cast<int>(top);
+					child_r.width = static_cast<unsigned>(weight);
+					child_r.height = static_cast<unsigned>(bottom - top);
+					if (split)
+					{
+						split->move(rectangle{ child_r.x - static_cast<int>(splitter_px), child_r.y, splitter_px, child_r.height });
+						split_range_begin = left;
+						split_range_end = right - static_cast<int>(splitter_px)+weight;
+						right -= splitter_px;
+					}
+					break;
+				case ::nana::direction::north:
+					child_r.x = static_cast<int>(left);
+					child_r.y = static_cast<int>(top);
+					child_r.width = static_cast<unsigned>(right - left);
+					child_r.height = static_cast<unsigned>(weight);
+					top += weight;
+					if (split)
+					{
+						split->move(rectangle{ child_r.x, child_r.bottom(), child_r.width, splitter_px });
+						split_range_begin = top - weight;
+						split_range_end = bottom - static_cast<int>(splitter_px);
+						top += splitter_px;
+					}
+					break;
+				case ::nana::direction::south:
+					child_r.x = static_cast<int>(left);
+					bottom -= weight;
+					child_r.y = static_cast<int>(bottom);
+					child_r.width = static_cast<unsigned>(right - left);
+					child_r.height = static_cast<unsigned>(weight);
+					if (split)
+					{
+						bottom -= splitter_px;
+						split->move(rectangle{ child_r.x, child_r.y - static_cast<int>(splitter_px), child_r.width, splitter_px });
+						split_range_begin = top;
+						split_range_end = bottom + weight;
+					}
+					break;
+				}
+
+				if (split_range_begin > -0.5)
+					split->range(static_cast<int>(split_range_begin), static_cast<int>(split_range_end));
+
+				if (is_vert)
+				{
+					room.height -= child_r.height;
+					--vert_count;
+				}
+				else
+				{
+					room.width -= child_r.width;
+					--horz_count;
+				}
+
+				child->field_area = child_r;
+				child->collocate(wd);
+			}
+		}
+	private:
+		static bool _m_is_vert(::nana::direction dir)
+		{
+			return (dir == ::nana::direction::north || dir == ::nana::direction::south);
+		}
+
+		static div_dockpane* _m_right(division* dv)
+		{
+			dv = dv->div_next;
+			while (dv)
+			{
+				if (dv->display)
+					return dynamic_cast<div_dockpane*>(dv);
+
+				dv = dv->div_next;
+			}
+			return nullptr;
+		}
+	private:
+		implement * const impl_;
+	};
+
+	place::implement::~implement()
+	{
+		API::umake_event(event_size_handle);
+		root_division.reset();
+
+		for (auto & pair : fields)
+			delete pair.second;
+
+		for (auto & dock : docks)
+			delete dock.second;
+	}
+
+	void place::implement::collocate()
+	{
+		if (root_division && window_handle)
+		{
+			root_division->field_area.dimension(API::window_size(window_handle));
+
+			if (root_division->field_area.empty())
+				return;
+
+			root_division->collocate(window_handle);
+
+			for (auto & field : fields)
+			{
+				bool is_show = false;
+				if (field.second->attached && field.second->attached->visible && field.second->attached->display)
+				{
+					is_show = true;
+					auto div = field.second->attached->div_owner;
+					while (div)
+					{
+						if (!div->visible || !div->display)
+						{
+							is_show = false;
+							break;
+						}
+						div = div->div_owner;
+					}
+				}
+
+				for (auto & el : field.second->elements)
+					API::show_window(el.handle, is_show);
+			}
+		}
+	}
+
+	//search_div_name
+	//search a division with the specified name.
+	place::implement::division * place::implement::search_div_name(division* start, const std::string& name)
+	{
+		if (start)
+		{
+			if (start->name == name)
+				return start;
+
+			for (auto& child : start->children)
+			{
+				auto div = search_div_name(child.get(), name);
+				if (div)
+					return div;
+			}
+		}
+		return nullptr;
+	}
+
+	auto place::implement::scan_div(place_parts::tokenizer& tknizer) -> std::unique_ptr<division>
+	{
+		typedef place_parts::tokenizer::token token;
+
+		std::unique_ptr<division> div;
+		token div_type = token::eof;
+
+		//These variables stand for the new division's attributes
+		std::string name;
+		number_t weight, min_px, max_px;
+		place_parts::repeated_array arrange, gap;
+		place_parts::margin margin;
+		std::vector<number_t> array;
+		std::vector<rectangle> collapses;
+		std::vector<std::unique_ptr<division>> children;
+		::nana::direction div_dir = ::nana::direction::west;
+
+		bool undisplayed = false;
+		bool invisible = false;
+
+		for (token tk = tknizer.read(); tk != token::eof; tk = tknizer.read())
+		{
+			bool exit_for = false;
+			switch (tk)
+			{
+			case token::dock:
+				if (token::eof != div_type && token::dock != div_type)
+					throw std::invalid_argument("nana.place: conflict of div type at " + tknizer.pos_str());
+
+				div_type = token::dock;
+				break;
+			case token::splitter:
+				//Ignore the splitter when there is not a division.
+				if (!children.empty() && (division::kind::splitter != children.back()->kind_of_division))
+				{
+					auto splitter = new div_splitter(tknizer.number());
+					children.back()->div_next = splitter;
+					children.emplace_back(std::unique_ptr<division>{ splitter });
+				}
+				break;
+			case token::div_start:
+			{
+				auto div = scan_div(tknizer);
+				if (!children.empty())
+					children.back()->div_next = div.get();
+
+				children.emplace_back(std::move(div));
+			}
+				break;
+			case token::vert:
+				div_type = tk;
+				break;
+			case token::grid:
+				div_type = tk;
+				switch (tknizer.read())
+				{
+				case token::number:
+					array.push_back(tknizer.number());
+					array.push_back(tknizer.number());
+					break;
+				case token::array:
+					tknizer.array().swap(array);
+					break;
+				case token::reparray:
+					array.push_back(tknizer.reparray().at(0));
+					array.push_back(tknizer.reparray().at(1));
+					break;
+                default:
+                    break;
+				}
+				break;
+			case token::collapse:
+				{
+					if (tknizer.parameters().size() != 4)
+						throw std::invalid_argument("nana.place: collapse requires 4 parameters.");
+
+					auto get_number = [](const number_t & arg, const std::string& nth)
+					{
+						if (arg.kind_of() == number_t::kind::integer)
+							return arg.integer();
+						else if (arg.kind_of() == number_t::kind::real)
+							return static_cast<int>(arg.real());
+
+						throw std::invalid_argument("nana.place: the type of the "+ nth +" parameter for collapse should be integer.");
+					};
+
+					::nana::rectangle col;
+					auto arg = tknizer.parameters().at(0);
+					col.x = get_number(arg, "1st");
+
+					arg = tknizer.parameters().at(1);
+					col.y = get_number(arg, "2nd");
+
+					arg = tknizer.parameters().at(2);
+					col.width = static_cast<decltype(col.width)>(get_number(arg, "3rd"));
+
+					arg = tknizer.parameters().at(3);
+					col.height = static_cast<decltype(col.height)>(get_number(arg, "4th"));
+
+					//Check the collapse area.
+					//Ignore this collapse if its area is less than 2(col.width * col.height < 2)
+					if (!col.empty() && (col.width > 1 || col.height > 1) && (col.x >= 0 && col.y >= 0))
+					{
+						//Overwrite if a exist_col in collapses has same position as the col.
+						bool use_col = true;
+						for (auto & exist_col : collapses)
+						{
+							if (exist_col.x == col.x && exist_col.y == col.y)
+							{
+								exist_col = col;
+								use_col = false;
+								break;
+							}
+						}
+						if (use_col)
+							collapses.emplace_back(col);
+					}
+				}
+				break;
+			case token::weight: case token::min_px: case token::max_px:
+				{
+					auto n = tknizer.number();
+					//If n is the type of real, convert it to integer.
+					//the integer and percent are allowed for weight/min/max.
+					if (n.kind_of() == number_t::kind::real)
+						n.assign(static_cast<int>(n.real()));
+
+					switch (tk)
+					{
+					case token::weight: weight = n; break;
+					case token::min_px: min_px = n; break;
+					case token::max_px: max_px = n; break;
+					default: break;	//Useless
+					}
+				}
+				break;
+			case token::arrange:
+				arrange = tknizer.reparray();
+				break;
+			case token::gap:
+				gap = tknizer.reparray();
+				break;
+			case token::margin:
+				margin.clear();
+				switch (tknizer.read())
+				{
+				case token::number:
+					margin.set_value(tknizer.number());
+					break;
+				case token::array:
+					margin.set_array(tknizer.array());
+					break;
+				case token::reparray:
+					for (std::size_t i = 0; i < 4; ++i)
+					{
+						auto n = tknizer.reparray().at(i);
+						if (n.empty()) n.assign(0);
+						margin.push(n);
+					}
+					break;
+				default:
+					break;
+				}
+				break;
+			case token::div_end:
+				exit_for = true;
+				break;
+			case token::identifier:
+				name = tknizer.idstr();
+				break;
+			case token::left:
+				div_dir = ::nana::direction::west; break;
+			case token::right:
+				div_dir = ::nana::direction::east; break;
+			case token::top:
+				div_dir = ::nana::direction::north; break;
+			case token::bottom:
+				div_dir = ::nana::direction::south; break;
+			case token::undisplayed:
+				undisplayed = true; break;
+			case token::invisible:
+				invisible = true; break;
+			default:	break;
+			}
+			if (exit_for)
+				break;
+		}
+
+		field_gather * attached_field = nullptr;
+		if (name.size())
+		{
+			//find the field with specified name.
+			//the field may not be created.
+			auto i = fields.find(name);
+			if (fields.end() != i)
+			{
+				attached_field = i->second;
+				//the field is attached to a division, it means there is another division with same name.
+				if (attached_field->attached)
+					throw std::runtime_error("place, the name '" + name + "' is redefined.");
+			}
+		}
+
+		switch (div_type)
+		{
+		case token::eof:
+		case token::vert:
+			div.reset(new div_arrange(token::vert == div_type, std::move(name), std::move(arrange)));
+			break;
+		case token::grid:
+		{
+			std::unique_ptr<div_grid> p(new div_grid(std::move(name), std::move(arrange), std::move(collapses)));
+
+			if (array.size())
+				p->dimension.first = array[0].integer();
+
+			if (array.size() > 1)
+				p->dimension.second = array[1].integer();
+
+			if (0 == p->dimension.first)
+				p->dimension.first = 1;
+
+			if (0 == p->dimension.second)
+				p->dimension.second = 1;
+
+			p->revise_collapses();
+			div = std::move(p);
+		}
+			break;
+		case token::dock:
+			div.reset(new div_dock(std::move(name), this));
+			break;
+		default:
+			throw std::invalid_argument("nana.place: invalid division type.");
+		}
+
+		//Requirements for min/max
+		//1, min and max != negative
+		//2, max >= min
+		if (min_px.is_negative()) min_px.reset();
+		if (max_px.is_negative()) max_px.reset();
+		if ((!min_px.empty()) && (!max_px.empty()) && (min_px.get_value(100) > max_px.get_value(100)))
+		{
+			min_px.reset();
+			max_px.reset();
+		}
+
+		//The weight will be ignored if one of min and max is specified.
+		if (min_px.empty() && max_px.empty())
+		{
+			div->weight = weight;
+		}
+		else
+		{
+			div->min_px = min_px;
+			div->max_px = max_px;
+		}
+
+		div->gap = std::move(gap);
+
+		//attach the field to the division
+		div->field = attached_field;
+		if (attached_field)
+			attached_field->attached = div.get();
+
+		if (children.size())
+		{
+			if (division::kind::splitter == children.back()->kind_of_division)
+			{
+				children.pop_back();
+				if (children.size())
+					children.back()->div_next = nullptr;
+			}
+
+			for (auto& child : children)
+			{
+				child->div_owner = div.get();
+				if (division::kind::splitter == child->kind_of_division)
+					dynamic_cast<div_splitter&>(*child).direction(div_type != token::vert);
+			}
+
+			if (token::dock == div_type)
+			{
+				//adjust these children for dock division
+				std::vector<std::unique_ptr<division>> adjusted_children;
+				for (auto & child : children)
+				{
+					auto dockpn = new div_dockpane(std::move(child->name), this, child->dir);
+					dockpn->div_owner = child->div_owner;
+					dockpn->weight = child->weight;
+					adjusted_children.emplace_back(std::unique_ptr<division>{ dockpn });
+				}
+
+				division * next = nullptr;
+				for (auto i = adjusted_children.rbegin(); i != adjusted_children.rend(); ++i)
+				{
+					i->get()->div_next = next;
+					next = i->get();
+				}
+
+				children.swap(adjusted_children);
+			}
+		}
+
+		div->children.swap(children);
+		div->margin = std::move(margin);
+		div->dir = div_dir;
+
+		div->display = !undisplayed;
+		div->visible = !(undisplayed || invisible);
+		return div;
+	}
+
+	void place::implement::check_unique(const division* div) const
+	{
+		//The second field_impl is useless. Reuse the map type in order to
+		//reduce the size of the generated code, becuase std::set<std::string>
+		//will create a new template class.
+		std::map<std::string, field_gather*> unique;
+		field_gather tmp(nullptr);
+
+		std::function<void(const implement::division* div)> check_fn;
+		check_fn = [&check_fn, &unique, &tmp](const implement::division* div)
+		{
+			if (!div->name.empty())
+			{
+				auto & ptr = unique[div->name];
+				if (ptr)
+					throw std::invalid_argument("place, the name '" + div->name + "' is redefined.");
+				ptr = &tmp;
+			}
+
+			for (auto & child : div->children)
+			{
+				check_fn(child.get());
+			}
+		};
+
+		if (div)
+			check_fn(div);
+	}
+
+	//connect the field/dock with div object,
+	void place::implement::connect(division* start)
+	{
+		if (!start)
+			return;
+
+		this->disconnect();
+
+		std::map<std::string, field_dock*> docks_to_be_closed;
+		//disconnect
+		for (auto & dk : docks)
+		{
+			if (dk.second->attached)
+				docks_to_be_closed[dk.first] = dk.second;
+		}
+
+		std::function<void(division* div)> connect_fn;
+		connect_fn = [&connect_fn, this, &docks_to_be_closed](division* div)
+		{
+			if (div->name.size())
+			{
+				if (division::kind::dock == div->kind_of_division || division::kind::dockpane == div->kind_of_division)
+				{
+					auto i = docks.find(div->name);
+					if (i != docks.end())
+					{
+						docks_to_be_closed.erase(div->name);
+						auto pane = dynamic_cast<div_dockpane*>(div);
+						pane->dockable_field = i->second;
+
+						auto old_pane = pane->dockable_field->attached;
+						if (old_pane)
+						{
+							//old div_dockpane will be deleted
+							old_pane->dockable_field = nullptr;
+							div->display = old_pane->display;
+						}
+						pane->dockable_field->attached = pane;
+
+						if (pane->dockable_field->dockarea)
+							pane->dockable_field->dockarea->set_notifier(pane);
+					}
+				}
+				else
+				{
+					auto i = fields.find(div->name);
+					if (i != fields.end())
+					{
+						div->field = i->second;
+						div->field->attached = div;
+					}
+				}
+
+			}
+
+			for (auto & child : div->children)
+			{
+				connect_fn(child.get());
+			}
+		};
+
+		connect_fn(start);
+
+		for (auto& e : docks_to_be_closed)
+		{
+			e.second->dockarea.reset();
+			e.second->attached->dockable_field = nullptr;
+			e.second->attached = nullptr;
+		}
+	}
+
+	void place::implement::disconnect()
+	{
+		for (auto & fd : fields)
+		{
+			if (fd.second->attached)
+			{
+				fd.second->attached->field = nullptr;
+				fd.second->attached = nullptr;
+			}
+		}
+	}
+
+	//class place
+	place::place()
+		: impl_(new implement)
+	{}
+
+	place::place(window wd)
+		: impl_(new implement)
+	{
+		bind(wd);
+	}
+
+	place::~place()
+	{
+		delete impl_;
+	}
+
+	void place::bind(window wd)
+	{
+		if (impl_->window_handle)
+			throw std::runtime_error("place.bind: it has already binded to a window.");
+
+		impl_->window_handle = wd;
+		impl_->event_size_handle = API::events(wd).resized.connect([this](const arg_resized& arg)
+		{
+			if (impl_->root_division)
+			{
+				impl_->root_division->field_area.dimension({ arg.width, arg.height });
+				impl_->root_division->collocate(arg.window_handle);
+			}
+		});
+	}
+
+	window place::window_handle() const
+	{
+		return impl_->window_handle;
+	}
+
+	void place::div(const char* s)
+	{
+		place_parts::tokenizer tknizer(s);
+		impl_->disconnect();
+		auto div = impl_->scan_div(tknizer);
+		try
+		{
+			impl_->check_unique(div.get());	//may throw if there is a redefined name of field.
+			impl_->connect(div.get());
+			impl_->root_division.reset();	//clear atachments div-fields
+			impl_->root_division.swap(div);
+			impl_->div_text.assign(s);
+		}
+		catch (...)
+		{
+			//redefined a name of field
+			throw;
+		}
+	}
+
+	const std::string& place::div() const noexcept
+	{
+		return impl_->div_text;
+	}
+
+	void place::modify(const char* name, const char* div_text)
+	{
+		if (nullptr == div_text)
+			throw std::invalid_argument("nana.place: invalid div-text");
+
+		if (nullptr == name) name = "";
+
+		//check the name, it throws std::invalid_argument
+		//if name violate the naming convention.
+		place_parts::check_field_name(name);
+
+		auto div_ptr = impl_->search_div_name(impl_->root_division.get(), name);
+		if (!div_ptr)
+		{
+			std::string what = "nana::place: field '";
+			what += name;
+			what += "' is not found.";
+
+			throw std::invalid_argument(what);
+		}
+
+
+		std::unique_ptr<implement::division>* replaced = nullptr;
+
+		implement::division * div_owner = div_ptr->div_owner;
+		implement::division * div_next = div_ptr->div_next;
+		if (div_owner)
+		{
+			for (auto& child: div_owner->children)
+			{
+				if (child.get() == div_ptr)
+				{
+					replaced = &child;
+					break;
+				}
+			}
+		}
+		else
+			replaced = &(impl_->root_division);
+
+		replaced->swap(impl_->tmp_replaced);
+
+		try
+		{
+			place_parts::tokenizer tknizer(div_text);
+			auto modified = impl_->scan_div(tknizer);
+			auto modified_ptr = modified.get();
+			modified_ptr->name = name;
+
+			replaced->swap(modified);
+
+			impl_->check_unique(impl_->root_division.get());
+			impl_->connect(impl_->root_division.get());
+			impl_->tmp_replaced.reset();
+
+			modified_ptr->div_owner = div_owner;
+			modified_ptr->div_next = div_next;
+		}
+		catch (...)
+		{
+			replaced->swap(impl_->tmp_replaced);
+			throw;
+		}
+	}
+
+	place::field_reference place::field(const char* name)
+	{
+		if (nullptr == name)
+			name = "";
+
+		//check the name, it throws std::invalid_argument
+		//if name violate the naming convention.
+		place_parts::check_field_name(name);
+
+		//get the field with specified name, if no such field with specified name
+		//then create one.
+		auto & p = impl_->fields[name];
+		if (nullptr == p)
+			p = new implement::field_gather(this);
+
+		if ((!p->attached) && impl_->root_division)
+		{
+			//search the division with the specified name,
+			//and attached the division to the field
+			auto div = implement::search_div_name(impl_->root_division.get(), name);
+			if (div)
+			{
+				if (div->field && (div->field != p))
+					throw std::runtime_error("nana.place: unexpected error, the division attachs a unexpected field.");
+
+				div->field = p;
+				p->attached = div;
+			}
+		}
+		return *p;
+	}
+
+	bool is_idchar(int ch)
+	{
+		return ('_' == ch || isalpha(ch) || isalnum(ch));
+	}
+
+	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
+	{
+		const auto len = std::strlen(idstr);
+		auto pos = text.find(idstr, off);
+		if (text.npos == pos)
+			return text.npos;
+
+		if (pos && is_idchar(text[pos - 1]))
+			return text.npos;
+
+		if ((pos + len < text.length()) && is_idchar(text[pos + len]))
+			return text.npos;
+
+		return pos;
+	}
+
+	void update_div(std::string& div, const char* field, const char* attr, bool insertion)
+	{
+		const auto fieldname_pos = find_idstr(div, field);
+		if (div.npos == fieldname_pos)
+			return;
+
+		//Get the bounds of this field
+		std::size_t begin = 0, end = 0;
+
+		//Find the begin
+		int level = 0;
+		std::size_t pos = fieldname_pos;
+		while (true)
+		{
+			pos = div.find_last_of("<>", pos);
+			if (div.npos == pos)
+				return;
+
+			if ('<' == div[pos])
+			{
+				if (0 == level)
+				{
+					begin = pos;
+					break;
+				}
+				else
+					--level;
+			}
+			else
+				++level;
+		}
+
+		//Find the end
+		level = 0;
+		pos = fieldname_pos;
+		while (true)
+		{
+			pos = div.find_first_of("<>", pos);
+			if (div.npos == pos)
+				return;
+
+			if ('>' == div[pos])
+			{
+				if (0 == level)
+				{
+					end = pos + 1;
+					break;
+				}
+				else
+					--level;
+			}
+			else
+				++level;
+		}
+
+		auto fieldstr = div.substr(begin + 1, end - begin - 2);
+
+		//Search the attribute
+		for (pos = 0; true; ++pos)
+		{
+			pos = find_idstr(fieldstr, attr, pos);
+			if (fieldstr.npos == pos)
+				break;
+
+			//Check if the attr is belong to this field.
+			level = 0;
+			std::size_t off = pos;
+			while (true)
+			{
+				off = fieldstr.find_last_of("<>", off);
+				if (fieldstr.npos == off)
+					break;
+
+				if ('>' == fieldstr[off])
+					++level;
+				else
+					--level;
+
+				if (0 == off)
+					break;
+				--off;
+			}
+
+			if (0 == level)
+				break;
+		}
+
+		if (fieldstr.npos == pos)
+		{
+			//There is not an attribute
+			if (insertion)
+				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
+		}
+		else
+		{
+			//There is an attribute
+			if (!insertion)
+			{
+				div.erase(begin + pos + 1, std::strlen(attr));
+
+				if ((div[begin + pos] == div[begin + pos + 1]) && (' ' == div[begin + pos]))
+					div.erase(begin + pos, 1);
+			}
+		}
+	}
+
+	void place::field_visible(const char* name, bool vsb)
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		if (div)
+		{
+			div->set_visible(vsb);
+			update_div(impl_->div_text, name, "invisible", !vsb);
+		}
+	}
+
+	bool place::field_visible(const char* name) const
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		return (div && div->visible);
+	}
+
+	void place::field_display(const char* name, bool dsp)
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		if (div)
+		{
+			update_div(impl_->div_text, name, "invisible", false);
+			update_div(impl_->div_text, name, "undisplayed", !dsp);
+			div->set_display(dsp);
+		}
+	}
+
+	bool place::field_display(const char* name) const
+	{
+		if (!name)	name = "";
+
+		//May throw std::invalid_argument
+		place_parts::check_field_name(name);
+
+		auto div = impl_->search_div_name(impl_->root_division.get(), name);
+		return (div && div->display);
+	}
+
+	void place::collocate()
+	{
+		impl_->collocate();
+	}
+
+	void place::erase(window handle)
+	{
+		bool recollocate = false;
+		for (auto & fld : impl_->fields)
+		{
+			auto evt = fld.second->erase_element(fld.second->elements, handle);
+			if (evt)
+			{
+				API::umake_event(evt);
+				recollocate |= (nullptr != fld.second->attached);
+			}
+
+			API::umake_event(fld.second->erase_element(fld.second->fastened, handle));
+		}
+
+		if (recollocate)
+			collocate();
+	}
+
+	place::field_reference place::operator[](const char* name)
+	{
+		return field(name);
+	}
+
+	place& place::dock(const std::string& name, std::string factory_name, std::function<std::unique_ptr<widget>(window)> factory)
+	{
+		//check the name, it throws std::invalid_argument
+		//if name violate the naming convention.
+		place_parts::check_field_name(name.data());
+
+		auto & dock_ptr = impl_->docks[name];
+		if (!dock_ptr)
+			dock_ptr = new implement::field_dock;
+
+		//Register the factory if it has a name
+		if (!factory_name.empty())
+		{
+			if (impl_->dock_factoris.find(factory_name) != impl_->dock_factoris.end())
+				throw std::invalid_argument("nana::place - the specified factory name(" + factory_name + ") already exists");
+
+			impl_->dock_factoris[factory_name] = dock_ptr;
+			dock_ptr->factories[factory_name] = std::move(factory);
+		}
+
+		auto div = dynamic_cast<implement::div_dockpane*>(impl_->search_div_name(impl_->root_division.get(), name));
+		if (div)
+		{
+			dock_ptr->attached = div;
+			div->dockable_field = dock_ptr;
+		}
+
+		//Create the pane if it has not a name
+		if (factory_name.empty() && dock_ptr->attached)
+		{
+			dock_ptr->attached->set_display(true);
+			impl_->collocate();
+
+			if (!dock_ptr->dockarea)
+			{
+				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
+				dock_ptr->dockarea->create(impl_->window_handle);
+				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
+				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
+			}
+			dock_ptr->dockarea->add_pane(factory);
+		}
+
+		return *this;
+	}
+
+	widget* place::dock_create(const std::string& factory)
+	{
+		auto i = impl_->dock_factoris.find(factory);
+		if (i == impl_->dock_factoris.end())
+			throw std::invalid_argument("invalid factory name(" + factory + ") of dockpane");
+
+		auto dock_ptr = i->second;
+		if (dock_ptr->attached)
+		{
+			dock_ptr->attached->set_display(true);
+			impl_->collocate();
+
+			if (!dock_ptr->dockarea)
+			{
+				dock_ptr->dockarea.reset(new ::nana::place_parts::dockarea);
+				dock_ptr->dockarea->create(impl_->window_handle);
+				dock_ptr->dockarea->set_notifier(dock_ptr->attached);
+				dock_ptr->dockarea->move(dock_ptr->attached->field_area);
+			}
+
+			return dock_ptr->dockarea->add_pane(i->second->factories[factory]);
+		}
+
+		return nullptr;
+	}
+	//end class place
+}//end namespace nana
+
+#include <nana/pop_ignore_diagnostic>

From 818c7459e79d9516ff0f7480fa05d1d008b17423 Mon Sep 17 00:00:00 2001
From: dankan1890 <mewuidev2@gmail.com>
Date: Thu, 29 Sep 2016 14:00:45 +0200
Subject: [PATCH 04/16] place::modify() now correctly updates the text to
 place::div_text.

Note: I reverted the previous commit because it had an incorrect formatting.
---
 include/nana/gui/place.hpp |  4 ++--
 source/gui/place.cpp       | 30 ++++++++++++++++++++----------
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/include/nana/gui/place.hpp b/include/nana/gui/place.hpp
index 176c7bd4..08ddad4d 100644
--- a/include/nana/gui/place.hpp
+++ b/include/nana/gui/place.hpp
@@ -118,10 +118,10 @@ namespace nana
 
 		field_reference field(const char* name);///< Returns a field with the specified name.
 
-		void field_visible(const char* field_name, bool visible); ///<<Shows/Hides an existing field.
+		void field_visible(const char* field_name, bool visible) const; ///<<Shows/Hides an existing field.
 		bool field_visible(const char* field_name) const;	///<Determines whether the specified field is visible.
 
-		void field_display(const char* field_name, bool display); ///<Displays/Discards an existing field.
+		void field_display(const char* field_name, bool display) const; ///<Displays/Discards an existing field.
 		bool field_display(const char* field_name) const;	///<Determines whether the specified field is displayed.
 
 		void collocate();                     ///< Layouts the widgets.
diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 739b80cf..087c480b 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -1890,7 +1890,7 @@ namespace nana
 			unsigned vert_count = 0, horz_count = 0;
 
 			bool is_first = true;
-			bool prev_attr;
+			bool prev_attr = false;
 
 			for (auto & child : children)
 			{
@@ -1967,7 +1967,7 @@ namespace nana
 					child_dv->splitter.reset();
 
 				::nana::rectangle child_r;
-				double split_range_begin = -1, split_range_end;
+				double split_range_begin = -1, split_range_end = 0;
 				switch (child->dir)
 				{
 				default:
@@ -2622,6 +2622,10 @@ namespace nana
 		return impl_->div_text;
 	}
 
+	enum div_type {	erase = 0, insert, replace };
+
+	void update_div(std::string& div, const char* field, const char* attr, div_type insertion);
+
 	void place::modify(const char* name, const char* div_text)
 	{
 		if (nullptr == div_text)
@@ -2676,6 +2680,7 @@ namespace nana
 			impl_->check_unique(impl_->root_division.get());
 			impl_->connect(impl_->root_division.get());
 			impl_->tmp_replaced.reset();
+			update_div(impl_->div_text, name, div_text, div_type::replace);
 
 			modified_ptr->div_owner = div_owner;
 			modified_ptr->div_next = div_next;
@@ -2740,7 +2745,7 @@ namespace nana
 		return pos;
 	}
 
-	void update_div(std::string& div, const char* field, const char* attr, bool insertion)
+	void update_div(std::string& div, const char* field, const char* attr, div_type insertion)
 	{
 		const auto fieldname_pos = find_idstr(div, field);
 		if (div.npos == fieldname_pos)
@@ -2830,13 +2835,18 @@ namespace nana
 		if (fieldstr.npos == pos)
 		{
 			//There is not an attribute
-			if (insertion)
+			if (insertion == div_type::insert)
 				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
+			else if (insertion == div_type::replace)
+			{
+				div.erase(begin + 1, fieldstr.length());
+				div.insert(begin + 1, std::string(attr) + " " + std::string(field));
+			}
 		}
 		else
 		{
 			//There is an attribute
-			if (!insertion)
+			if (insertion == div_type::erase)
 			{
 				div.erase(begin + pos + 1, std::strlen(attr));
 
@@ -2846,7 +2856,7 @@ namespace nana
 		}
 	}
 
-	void place::field_visible(const char* name, bool vsb)
+	void place::field_visible(const char* name, bool vsb) const
 	{
 		if (!name)	name = "";
 
@@ -2857,7 +2867,7 @@ namespace nana
 		if (div)
 		{
 			div->set_visible(vsb);
-			update_div(impl_->div_text, name, "invisible", !vsb);
+			update_div(impl_->div_text, name, "invisible", !vsb ? div_type::insert : div_type::erase);
 		}
 	}
 
@@ -2872,7 +2882,7 @@ namespace nana
 		return (div && div->visible);
 	}
 
-	void place::field_display(const char* name, bool dsp)
+	void place::field_display(const char* name, bool dsp) const
 	{
 		if (!name)	name = "";
 
@@ -2882,8 +2892,8 @@ namespace nana
 		auto div = impl_->search_div_name(impl_->root_division.get(), name);
 		if (div)
 		{
-			update_div(impl_->div_text, name, "invisible", false);
-			update_div(impl_->div_text, name, "undisplayed", !dsp);
+			update_div(impl_->div_text, name, "invisible", div_type::erase);
+			update_div(impl_->div_text, name, "undisplayed", !dsp ? div_type::insert : div_type::erase);
 			div->set_display(dsp);
 		}
 	}

From e5c14570cb8ef206976ab41c8701c3864a77696b Mon Sep 17 00:00:00 2001
From: dankan1890 <mewuidev2@gmail.com>
Date: Sun, 2 Oct 2016 22:17:59 +0200
Subject: [PATCH 05/16] fix exact match in find_idstr. (note: removed isalpha,
 isalnum already performs that check)

---
 source/gui/place.cpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 087c480b..b1d73d48 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -2726,23 +2726,24 @@ namespace nana
 
 	bool is_idchar(int ch)
 	{
-		return ('_' == ch || isalpha(ch) || isalnum(ch));
+		return ('_' == ch || isalnum(ch));
 	}
 
 	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
 	{
 		const auto len = std::strlen(idstr);
-		auto pos = text.find(idstr, off);
-		if (text.npos == pos)
-			return text.npos;
+		size_t pos;
+		while ((pos = text.find(idstr, off)) != text.npos)
+		{
+			if (!is_idchar(text[pos + len]))
+			{
+				if (pos == 0 || !is_idchar(text[pos - 1]))
+					return pos;
+			}
 
-		if (pos && is_idchar(text[pos - 1]))
-			return text.npos;
-
-		if ((pos + len < text.length()) && is_idchar(text[pos + len]))
-			return text.npos;
-
-		return pos;
+			off = pos + len; // occurrence not found, advancing the offset and try again
+		}
+		return text.npos;
 	}
 
 	void update_div(std::string& div, const char* field, const char* attr, div_type insertion)

From d8ce7ea1badd51c0b9a6b23f84c576cdec57a806 Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Mon, 3 Oct 2016 05:11:00 +0800
Subject: [PATCH 06/16] fix the issue of place find_str(#156)

---
 source/gui/place.cpp | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 739b80cf..ba7c6f9d 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -2727,17 +2727,26 @@ namespace nana
 	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
 	{
 		const auto len = std::strlen(idstr);
-		auto pos = text.find(idstr, off);
-		if (text.npos == pos)
-			return text.npos;
 
-		if (pos && is_idchar(text[pos - 1]))
-			return text.npos;
+		while (true)
+		{
+			auto pos = text.find(idstr, off);
+			if (text.npos == pos)
+				return text.npos;
 
-		if ((pos + len < text.length()) && is_idchar(text[pos + len]))
-			return text.npos;
+			if (pos && is_idchar(text[pos - 1]))
+			{
+				off = pos + 1;
+				continue;
+			}
 
-		return pos;
+			if ((pos + len < text.length()) && is_idchar(text[pos + len]))
+			{
+				off = pos + 1;
+				continue;
+			}
+			return pos;
+		}
 	}
 
 	void update_div(std::string& div, const char* field, const char* attr, bool insertion)

From fb27eece339da53b08c3fbac35ed7bcd4c71dd34 Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Mon, 3 Oct 2016 05:36:13 +0800
Subject: [PATCH 07/16] change some names base on #156

---
 include/nana/gui/place.hpp |  4 ++--
 source/gui/place.cpp       | 28 +++++++++++++++-------------
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/include/nana/gui/place.hpp b/include/nana/gui/place.hpp
index 08ddad4d..176c7bd4 100644
--- a/include/nana/gui/place.hpp
+++ b/include/nana/gui/place.hpp
@@ -118,10 +118,10 @@ namespace nana
 
 		field_reference field(const char* name);///< Returns a field with the specified name.
 
-		void field_visible(const char* field_name, bool visible) const; ///<<Shows/Hides an existing field.
+		void field_visible(const char* field_name, bool visible); ///<<Shows/Hides an existing field.
 		bool field_visible(const char* field_name) const;	///<Determines whether the specified field is visible.
 
-		void field_display(const char* field_name, bool display) const; ///<Displays/Discards an existing field.
+		void field_display(const char* field_name, bool display); ///<Displays/Discards an existing field.
 		bool field_display(const char* field_name) const;	///<Determines whether the specified field is displayed.
 
 		void collocate();                     ///< Layouts the widgets.
diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index fd928500..205045f5 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -8,7 +8,8 @@
  *	http://www.boost.org/LICENSE_1_0.txt)
  *
  *	@file: nana/gui/place.cpp
- *	@contributors: Ariel Vina-Rodriguez
+ *	@contributors:	Ariel Vina-Rodriguez
+ *					dankan1890(PR#156)
  */
 
 #include <cfloat>
@@ -2622,9 +2623,10 @@ namespace nana
 		return impl_->div_text;
 	}
 
-	enum div_type {	erase = 0, insert, replace };
+	//Contributed by dankan1890(PR#156)
+	enum class update_operation { erase = 0, insert, replace };
 
-	void update_div(std::string& div, const char* field, const char* attr, div_type insertion);
+	void update_div(std::string& div, const char* field, const char* attr, update_operation operation);
 
 	void place::modify(const char* name, const char* div_text)
 	{
@@ -2680,7 +2682,7 @@ namespace nana
 			impl_->check_unique(impl_->root_division.get());
 			impl_->connect(impl_->root_division.get());
 			impl_->tmp_replaced.reset();
-			update_div(impl_->div_text, name, div_text, div_type::replace);
+			update_div(impl_->div_text, name, div_text, update_operation::replace);
 
 			modified_ptr->div_owner = div_owner;
 			modified_ptr->div_next = div_next;
@@ -2747,7 +2749,7 @@ namespace nana
 		return text.npos;
 	}
 
-	void update_div(std::string& div, const char* field, const char* attr, div_type insertion)
+	void update_div(std::string& div, const char* field, const char* attr, update_operation operation)
 	{
 		const auto fieldname_pos = find_idstr(div, field);
 		if (div.npos == fieldname_pos)
@@ -2837,9 +2839,9 @@ namespace nana
 		if (fieldstr.npos == pos)
 		{
 			//There is not an attribute
-			if (insertion == div_type::insert)
+			if (operation == update_operation::insert)
 				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
-			else if (insertion == div_type::replace)
+			else if (operation == update_operation::replace)
 			{
 				div.erase(begin + 1, fieldstr.length());
 				div.insert(begin + 1, std::string(attr) + " " + std::string(field));
@@ -2848,7 +2850,7 @@ namespace nana
 		else
 		{
 			//There is an attribute
-			if (insertion == div_type::erase)
+			if (operation == update_operation::erase)
 			{
 				div.erase(begin + pos + 1, std::strlen(attr));
 
@@ -2858,7 +2860,7 @@ namespace nana
 		}
 	}
 
-	void place::field_visible(const char* name, bool vsb) const
+	void place::field_visible(const char* name, bool vsb)
 	{
 		if (!name)	name = "";
 
@@ -2869,7 +2871,7 @@ namespace nana
 		if (div)
 		{
 			div->set_visible(vsb);
-			update_div(impl_->div_text, name, "invisible", !vsb ? div_type::insert : div_type::erase);
+			update_div(impl_->div_text, name, "invisible", !vsb ? update_operation::insert : update_operation::erase);
 		}
 	}
 
@@ -2884,7 +2886,7 @@ namespace nana
 		return (div && div->visible);
 	}
 
-	void place::field_display(const char* name, bool dsp) const
+	void place::field_display(const char* name, bool dsp)
 	{
 		if (!name)	name = "";
 
@@ -2894,8 +2896,8 @@ namespace nana
 		auto div = impl_->search_div_name(impl_->root_division.get(), name);
 		if (div)
 		{
-			update_div(impl_->div_text, name, "invisible", div_type::erase);
-			update_div(impl_->div_text, name, "undisplayed", !dsp ? div_type::insert : div_type::erase);
+			update_div(impl_->div_text, name, "invisible", update_operation::erase);
+			update_div(impl_->div_text, name, "undisplayed", !dsp ? update_operation::insert : update_operation::erase);
 			div->set_display(dsp);
 		}
 	}

From 7f45ae434291c734e98d896e32c22977b636303b Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Mon, 3 Oct 2016 09:07:37 +0800
Subject: [PATCH 08/16] add a param to listbox::item_proxy's check/select

this new parameter is used to indicate whether to scroll the view to the
item if the item is not displayed on screen.
---
 include/nana/gui/widgets/listbox.hpp | 23 ++++++++++-
 source/gui/widgets/listbox.cpp       | 62 ++++++++++++++++++++++------
 2 files changed, 70 insertions(+), 15 deletions(-)

diff --git a/include/nana/gui/widgets/listbox.hpp b/include/nana/gui/widgets/listbox.hpp
index 63ee49ca..34c0dfcd 100644
--- a/include/nana/gui/widgets/listbox.hpp
+++ b/include/nana/gui/widgets/listbox.hpp
@@ -800,12 +800,31 @@ namespace nana
 				/// posible use: last_selected_display = last_selected.to_display().item; use with caution, it get invalidated after a sort()
 				index_pair to_display() const;
 
+				/// Determines whether the item is displayed on the screen
+				bool displayed() const;
+
 				bool empty() const;
 
-				item_proxy & check(bool ck);
+				/// Checks/unchecks the item
+				/**
+				* @param chk Indicates whether to check or uncheck the item
+				* @param scroll_view Indicates whether to scroll the view to the item. It is ignored if the item is displayed.
+				* @return the reference of *this.
+				*/
+				item_proxy & check(bool chk, bool scroll_view = false);
+
+				/// Determines whether the item is checked
 				bool checked() const;
 
-				item_proxy & select(bool);
+				/// Selects/unselects the item
+				/**
+				 * @param sel Indicates whether to select or unselect the item
+				 * @param scroll_view Indicates whether to scroll the view to the item. It is ignored if the item is displayed.
+				 * @return the reference of *this.
+				 */
+				item_proxy & select(bool sel, bool scroll_view = false);
+
+				/// Determines whether he item is selected
 				bool selected() const;
 
 				item_proxy & bgcolor(const nana::color&);
diff --git a/source/gui/widgets/listbox.cpp b/source/gui/widgets/listbox.cpp
index 0dcccdd0..cd40636f 100644
--- a/source/gui/widgets/listbox.cpp
+++ b/source/gui/widgets/listbox.cpp
@@ -4506,12 +4506,28 @@ namespace nana
 					return ess_->lister.relative_pair(pos_);
 				}
 
+				bool item_proxy::displayed() const
+				{
+					if (!ess_->lister.get(pos_.cat)->expand)
+						return false;
+
+					auto pos = to_display();
+					if (ess_->scroll.offset_y_dpl > pos)
+						return false;
+
+					auto size = ess_->number_of_lister_items(false);
+
+					auto last = ess_->lister.advance(ess_->scroll.offset_y_dpl, size);
+
+					return (last > pos || last == pos);
+				}
+
 				bool item_proxy::empty() const
 				{
 					return !ess_;
 				}
 
-				item_proxy & item_proxy::check(bool ck)
+				item_proxy & item_proxy::check(bool ck, bool scroll_view)
 				{
 					internal_scope_guard lock;
 					auto & m = cat_->items.at(pos_.item);
@@ -4520,6 +4536,15 @@ namespace nana
 						m.flags.checked = ck;
 						ess_->lister.emit_checked(pos_);
 
+						if (scroll_view)
+						{
+							if (ess_->lister.get(pos_.cat)->expand)
+								ess_->lister.get(pos_.cat)->expand = false;
+
+							if (!this->displayed())
+								ess_->lister.scroll(pos_, !(ess_->scroll.offset_y_dpl > this->to_display()));
+						}
+
 						ess_->update();
 					}
 					return *this;
@@ -4531,26 +4556,37 @@ namespace nana
 				}
 
 				/// is ignored if no change (maybe set last_selected anyway??), but if change emit event, deselect others if need ans set/unset last_selected
-				item_proxy & item_proxy::select(bool s)
+				item_proxy & item_proxy::select(bool sel, bool scroll_view)
 				{
 					internal_scope_guard lock;
 
 					//pos_ never represents a category if this item_proxy is available.
 					auto & m = cat_->items.at(pos_.item);       // a ref to the real item
-					if(m.flags.selected == s) return *this;     // ignore if no change
-					m.flags.selected = s;                       // actually change selection
-
-					ess_->lister.emit_selected(this->pos_);
-
-					if (m.flags.selected)
+					if (m.flags.selected != sel)
 					{
-						ess_->lister.cancel_others_if_single_enabled(true, pos_);	//Cancel all selections except pos_ if single_selection is enabled.
-						ess_->lister.last_selected_abs = pos_;
-					}
-					else if (ess_->lister.last_selected_abs == pos_)
+						m.flags.selected = sel;                       // actually change selection
+
+						ess_->lister.emit_selected(this->pos_);
+
+						if (m.flags.selected)
+						{
+							ess_->lister.cancel_others_if_single_enabled(true, pos_);	//Cancel all selections except pos_ if single_selection is enabled.
+							ess_->lister.last_selected_abs = pos_;
+						}
+						else if (ess_->lister.last_selected_abs == pos_)
 							ess_->lister.last_selected_abs.set_both(npos);
 
-					ess_->update();
+						if (scroll_view)
+						{
+							if (ess_->lister.get(pos_.cat)->expand)
+								ess_->lister.get(pos_.cat)->expand = false;
+
+							if (!this->displayed())
+								ess_->lister.scroll(pos_, !(ess_->scroll.offset_y_dpl > this->to_display()));
+						}
+
+						ess_->update();
+					}
 					return *this;
 				}
 

From 5383d85cc0ab0cd14d9e119bda008b8335bb2bba Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Wed, 5 Oct 2016 09:41:44 +0800
Subject: [PATCH 09/16] add support of div-text update for splitter(#157)

---
 source/gui/place.cpp | 414 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 327 insertions(+), 87 deletions(-)

diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 205045f5..98c698c1 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -431,6 +431,87 @@ namespace nana
 		};	//end class tokenizer
 	}
 
+
+	inline bool is_idchar(int ch)
+	{
+		return ('_' == ch || isalnum(ch));
+	}
+
+	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
+	{
+		const auto len = std::strlen(idstr);
+
+		size_t pos;
+		while ((pos = text.find(idstr, off)) != text.npos)
+		{
+			if (!is_idchar(text[pos + len]))
+			{
+				if (pos == 0 || !is_idchar(text[pos - 1]))
+					return pos;
+			}
+
+			off = pos + len; // occurrence not found, advancing the offset and try again
+		}
+		return text.npos;
+	}
+
+	std::pair<std::size_t, std::size_t> get_field_bound(const std::string& div, const char* idstr, int depth)
+	{
+		auto start_pos = find_idstr(div, idstr);
+
+		if (depth < 0 || start_pos >= div.length())
+			return{};
+
+		const char* p = div.c_str() + start_pos;
+
+		while (depth >= 0)
+		{
+			auto pos = div.find_last_of("<>", start_pos);
+			if (div.npos == pos)
+				return{};
+
+			if (div[pos] == '>')
+			{
+				++depth;
+				start_pos = pos - 1;
+				continue;
+			}
+
+			if (0 == depth)
+			{
+				start_pos = pos;
+				break;
+			}
+
+			--depth;
+			start_pos = pos - 1;
+		}
+
+		auto off = start_pos + 1;
+
+		while (true)
+		{
+			auto pos = div.find_first_of("<>", off);
+
+			if (div.npos == pos)
+				return{};
+
+			if ('<' == div[pos])
+			{
+				++depth;
+				off = pos + 1;
+				continue;
+			}
+
+			if (0 == depth)
+				return{ start_pos, pos + 1 };
+
+			--depth;
+			off = pos + 1;
+		}
+	}
+
+
 	//struct implement
 	struct place::implement
 	{
@@ -1315,8 +1396,9 @@ namespace nana
 
 		enum{splitter_px = 4};
 	public:
-		div_splitter(place_parts::number_t init_weight)
-			: division(kind::splitter, std::string()),
+		div_splitter(place_parts::number_t init_weight, implement* impl):
+			division(kind::splitter, std::string()),
+			impl_(impl),
 			init_weight_(init_weight)
 		{
 			this->weight.assign(splitter_px);
@@ -1341,7 +1423,7 @@ namespace nana
 
 				auto grab_fn = [this](const arg_mouse& arg)
 				{
-					if (false == arg.left_button)
+					if ((false == arg.left_button) && (mouse::left_button != arg.button))
 						return;
 
 					if (event_code::mouse_down == arg.evt_code)
@@ -1374,6 +1456,7 @@ namespace nana
 					else if(event_code::mouse_up == arg.evt_code)
 					{
 						grabbed_ = false;
+						this->_m_update_div(impl_->div_text);
 					}
 					else if (event_code::mouse_move == arg.evt_code)
 					{
@@ -1472,6 +1555,231 @@ namespace nana
 				splitter_.move(this->field_area);
 		}
 	private:
+		static int _m_search_name(const division* div, std::string& name)
+		{
+			if (div->name.size())
+			{
+				name = div->name;
+				return 0;
+			}
+
+			for (auto & child : div->children)
+			{
+				if (child->name.size())
+				{
+					name = child->name;
+					return 1;
+				}
+			}
+
+			for (auto & child : div->children)
+			{
+				auto depth = _m_search_name(child.get(), name);
+				if (depth >= 0)
+					return depth + 1;
+			}
+
+			return -1;
+		}
+
+		static std::pair<std::size_t, std::size_t> _m_field_bound(const std::string& div, std::size_t start_pos)
+		{
+			int depth = 0;
+
+			if ('<' == div[start_pos])
+			{
+				auto off = start_pos + 1;
+				while (off < div.length())
+				{
+					auto pos = div.find_first_of("<>", off);
+					if (div.npos == pos)
+						break;
+
+					if ('<' == div[pos])
+					{
+						++depth;
+						off = pos + 1;
+						continue;
+					}
+					
+					if (0 == depth)
+						return{ start_pos, pos + 1};
+
+					--depth;
+					off = pos + 1;
+				}
+			}
+			else if (('>' == div[start_pos]) && (start_pos > 0))
+			{
+				auto off = start_pos - 1;
+				while (true)
+				{
+					auto pos = div.find_last_of("<>", off);
+					if (div.npos == pos)
+						break;
+
+					if ('>' == div[pos])
+					{
+						++depth;
+						if (0 == pos)
+							break;
+
+						off = pos - 1;
+					}
+
+					if (0 == depth)
+						return{ pos, start_pos + 1};
+
+					if (0 == pos)
+						break;
+
+					off = pos - 1;
+				}
+			}
+
+			return{};
+		}
+
+		static void _m_remove_attr(std::string& div, const char* attr)
+		{
+			auto attr_pos = div.find(attr);
+			if (div.npos == attr_pos)
+				return;
+
+			std::size_t off = 1;
+			while (true)
+			{
+				auto pos = div.find('<', off);
+				if (div.npos == pos)
+					break;
+
+				if (attr_pos < pos)
+					break;
+
+				int depth = 0;
+				off = pos + 1;
+				std::size_t endpos = 0;
+				while (true)
+				{
+					endpos = div.find_first_of("<>", off);
+					if (div.npos == endpos)
+						return;
+					
+					if ('<' == div[endpos])
+					{
+						++depth;
+						off = endpos + 1;
+						continue;
+					}
+
+					if (0 == depth)
+						break;
+
+					--depth;
+					off = endpos + 1;
+				}
+
+				if (attr_pos < endpos)
+				{
+					attr_pos = div.find(attr, endpos + 1);
+					if (div.npos == attr_pos)
+						return;
+				}
+
+				off = endpos + 1;
+			}
+
+			auto len = std::strlen(attr);
+
+			auto endpos = div.find_first_not_of(" ", attr_pos + len);
+			if (div.npos != endpos && div[endpos] == '=')
+			{
+				endpos = div.find_first_not_of(" 0123456789.%", endpos + 1);
+				if (div.npos == endpos)
+					throw std::runtime_error("please report an issue if throws");
+			}
+			else
+				endpos = attr_pos + len;
+
+			div.erase(attr_pos, endpos - attr_pos);
+		}
+
+		void _m_update_div(std::string& div)
+		{
+			std::string name;
+			bool left = true;
+
+			//Search a name recursively from a specified leaf field.
+			//It returns the depth from the leaf div to the div which has a name.
+			auto depth = _m_search_name(_m_leaf_left(), name);
+			if (-1 == depth)
+			{
+				left = false;
+				depth = _m_search_name(_m_leaf_right(), name);
+				if (-1 == depth)
+					return;
+			}
+
+			//Get the bound of field div-text through reverse recursion.
+			auto bound = get_field_bound(div, name.c_str(), depth);
+			if (bound.first == bound.second)
+				return;
+
+			auto fieldstr = div.substr(bound.first, bound.second - bound.first);
+			_m_remove_attr(fieldstr, "weight");
+
+			decltype(bound) other_bound;
+			if (left)
+			{
+				//Get the bound of leaf right
+				auto pos = div.find('<', bound.second + 1);
+				if (div.npos == pos)
+					throw std::runtime_error("please report an issue if it throws");
+
+				other_bound = _m_field_bound(div, pos);
+			}
+			else
+			{
+				//Get the bound of leaf left
+				auto pos = div.rfind('>', bound.first - 1);
+				if (div.npos == pos)
+					throw std::runtime_error("place report an issue if it throws");
+
+				other_bound = _m_field_bound(div, pos);
+			}
+
+			auto other_fieldstr = div.substr(other_bound.first, other_bound.second - other_bound.first);
+			_m_remove_attr(other_fieldstr, "weight");
+
+			const bool vert = (::nana::cursor::size_we != splitter_cursor_);
+
+			rectangle_rotator r_left(vert, _m_leaf_left()->field_area);
+			rectangle_rotator r_right(vert, _m_leaf_right()->field_area);
+			rectangle_rotator r_owner(vert, this->div_owner->field_area);
+
+			double percent = double((left ? r_left : r_right).w()) / double(r_owner.w());
+
+			std::string weight = "weight=" + std::to_string(percent * 100) + "% ";
+
+			fieldstr.insert(1, weight);
+
+			//Replaces the 'right' field before 'left' in order to make the bound consistent
+			if (left)
+			{
+				if (other_fieldstr.length() != (other_bound.second - other_bound.first))
+					div.replace(other_bound.first, other_bound.second - other_bound.first, other_fieldstr);
+
+				div.replace(bound.first, bound.second - bound.first, fieldstr);
+			}
+			else
+			{
+				div.replace(bound.first, bound.second - bound.first, fieldstr);
+
+				if (other_fieldstr.length() != (other_bound.second - other_bound.first))
+					div.replace(other_bound.first, other_bound.second - other_bound.first, other_fieldstr);
+			}
+		}
+
 		division * _m_leaf_left() const
 		{
 			return previous();
@@ -1532,6 +1840,7 @@ namespace nana
 			return area;
 		}
 	private:
+		implement* const impl_;
 		nana::cursor	splitter_cursor_{nana::cursor::arrow};
 		place_parts::splitter<true>	splitter_;
 		nana::point	begin_point_;
@@ -2171,7 +2480,7 @@ namespace nana
 				//Ignore the splitter when there is not a division.
 				if (!children.empty() && (division::kind::splitter != children.back()->kind_of_division))
 				{
-					auto splitter = new div_splitter(tknizer.number());
+					auto splitter = new div_splitter(tknizer.number(), this);
 					children.back()->div_next = splitter;
 					children.emplace_back(std::unique_ptr<division>{ splitter });
 				}
@@ -2726,95 +3035,26 @@ namespace nana
 		return *p;
 	}
 
-	inline bool is_idchar(int ch)
-	{
-		return ('_' == ch || isalnum(ch));
-	}
-
-	std::size_t find_idstr(const std::string& text, const char* idstr, std::size_t off = 0)
-	{
-		const auto len = std::strlen(idstr);
-
-		size_t pos;
-		while ((pos = text.find(idstr, off)) != text.npos)
-		{
-			if (!is_idchar(text[pos + len]))
-			{
-				if (pos == 0 || !is_idchar(text[pos - 1]))
-					return pos;
-			}
-
-			off = pos + len; // occurrence not found, advancing the offset and try again
-		}
-		return text.npos;
-	}
-
 	void update_div(std::string& div, const char* field, const char* attr, update_operation operation)
 	{
 		const auto fieldname_pos = find_idstr(div, field);
 		if (div.npos == fieldname_pos)
 			return;
 
-		//Get the bounds of this field
-		std::size_t begin = 0, end = 0;
-
-		//Find the begin
-		int level = 0;
-		std::size_t pos = fieldname_pos;
-		while (true)
-		{
-			pos = div.find_last_of("<>", pos);
-			if (div.npos == pos)
-				return;
-
-			if ('<' == div[pos])
-			{
-				if (0 == level)
-				{
-					begin = pos;
-					break;
-				}
-				else
-					--level;
-			}
-			else
-				++level;
-		}
-
-		//Find the end
-		level = 0;
-		pos = fieldname_pos;
-		while (true)
-		{
-			pos = div.find_first_of("<>", pos);
-			if (div.npos == pos)
-				return;
-
-			if ('>' == div[pos])
-			{
-				if (0 == level)
-				{
-					end = pos + 1;
-					break;
-				}
-				else
-					--level;
-			}
-			else
-				++level;
-		}
-
-		auto fieldstr = div.substr(begin + 1, end - begin - 2);
+		auto bound = get_field_bound(div, field, 0);
 
+		auto fieldstr = div.substr(bound.first + 1, bound.second - bound.first - 2);
 		//Search the attribute
-		for (pos = 0; true; ++pos)
+		std::size_t pos = 0;
+		int depth = 0;
+		for (; true; ++pos)
 		{
 			pos = find_idstr(fieldstr, attr, pos);
 			if (fieldstr.npos == pos)
 				break;
 
 			//Check if the attr is belong to this field.
-			level = 0;
+			depth = 0;
 			std::size_t off = pos;
 			while (true)
 			{
@@ -2823,16 +3063,16 @@ namespace nana
 					break;
 
 				if ('>' == fieldstr[off])
-					++level;
+					++depth;
 				else
-					--level;
+					--depth;
 
 				if (0 == off)
 					break;
 				--off;
 			}
 
-			if (0 == level)
+			if (0 == depth)
 				break;
 		}
 
@@ -2843,8 +3083,8 @@ namespace nana
 				div.insert(fieldname_pos + std::strlen(field), " " + std::string(attr));
 			else if (operation == update_operation::replace)
 			{
-				div.erase(begin + 1, fieldstr.length());
-				div.insert(begin + 1, std::string(attr) + " " + std::string(field));
+				div.erase(bound.first + 1, fieldstr.length());
+				div.insert(bound.first + 1, std::string(attr) + " " + std::string(field));
 			}
 		}
 		else
@@ -2852,10 +3092,10 @@ namespace nana
 			//There is an attribute
 			if (operation == update_operation::erase)
 			{
-				div.erase(begin + pos + 1, std::strlen(attr));
+				div.erase(bound.first + pos + 1, std::strlen(attr));
 
-				if ((div[begin + pos] == div[begin + pos + 1]) && (' ' == div[begin + pos]))
-					div.erase(begin + pos, 1);
+				if ((div[bound.first + pos] == div[bound.first + pos + 1]) && (' ' == div[bound.first + pos]))
+					div.erase(bound.first + pos, 1);
 			}
 		}
 	}

From 8fe39df8b4a8834f1afe9da4f213eeee441b25ec Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Thu, 6 Oct 2016 08:53:17 +0800
Subject: [PATCH 10/16] fix an issue of place number type(#157)

missing conversion from real to percent
---
 source/gui/place.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/source/gui/place.cpp b/source/gui/place.cpp
index 98c698c1..b1d26889 100644
--- a/source/gui/place.cpp
+++ b/source/gui/place.cpp
@@ -411,8 +411,18 @@ namespace nana
 					sp = _m_eat_whitespace(sp);
 					if ('%' == *sp)
 					{
-						if (number_t::kind::integer == number_.kind_of())
+						switch (number_.kind_of())
+						{
+						case number_t::kind::integer:
 							number_.assign_percent(number_.integer());
+							break;
+						case number_t::kind::real:
+							number_.assign_percent(number_.real());
+							break;
+						default:
+							break;
+						}
+
 						return sp - allstart + 1;
 					}
 					return sp - allstart;

From d7b7a4d45f5efc2f573f31e5540a0ef563e51e74 Mon Sep 17 00:00:00 2001
From: dankan1890 <mewuidev2@gmail.com>
Date: Fri, 14 Oct 2016 01:14:55 +0200
Subject: [PATCH 11/16] listbox: Added header_fgcolor and item_highlighted to
 color scheme. menu: Added change_text function.

---
 include/nana/gui/widgets/listbox.hpp | 4 +++-
 include/nana/gui/widgets/menu.hpp    | 1 +
 source/gui/widgets/listbox.cpp       | 4 ++--
 source/gui/widgets/menu.cpp          | 5 +++++
 4 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/include/nana/gui/widgets/listbox.hpp b/include/nana/gui/widgets/listbox.hpp
index 34c0dfcd..36b2ffb9 100644
--- a/include/nana/gui/widgets/listbox.hpp
+++ b/include/nana/gui/widgets/listbox.hpp
@@ -1149,9 +1149,11 @@ namespace nana
 				: public widget_geometrics
 			{
 				color_proxy header_bgcolor{static_cast<color_rgb>(0xf1f2f4)};
+				color_proxy header_fgcolor{ static_cast<color_rgb>(0x000000) };
 				color_proxy header_grabbed{ static_cast<color_rgb>(0x8BD6F6)};
 				color_proxy header_floated{ static_cast<color_rgb>(0xBABBBC)};
 				color_proxy item_selected{ static_cast<color_rgb>(0xD5EFFC) };
+				color_proxy item_highlighted{ static_cast<color_rgb>(0xD5EFFC) };
 
 				/// The max column width which is generated by fit_content is allowed. It is ignored when it is 0, or a max value is passed to fit_content.
 				unsigned max_fit_content{ 0 };
@@ -1454,7 +1456,7 @@ the nana::detail::basic_window member pointer scheme
 		export_options& def_export_options();
 	private:
 		drawerbase::listbox::essence & _m_ess() const;
-		nana::any* _m_anyobj(size_type cat, size_type index, bool allocate_if_empty) const;
+		nana::any* _m_anyobj(size_type cat, size_type index, bool allocate_if_empty) const override;
 		drawerbase::listbox::category_t* _m_assoc(std::shared_ptr<nana::detail::key_interface>, bool create_if_not_exists);
 		void _m_erase_key(nana::detail::key_interface*);
 	};
diff --git a/include/nana/gui/widgets/menu.hpp b/include/nana/gui/widgets/menu.hpp
index 02372079..c6bc81a7 100644
--- a/include/nana/gui/widgets/menu.hpp
+++ b/include/nana/gui/widgets/menu.hpp
@@ -144,6 +144,7 @@ namespace nana
 		/// Closes the menu. It does not destroy the menu; just close the window for the menu.
 		void close();
 		void image(std::size_t pos, const paint::image& icon);
+		void change_text(std::size_t pos, const std::string& text);
 		void check_style(std::size_t pos, checks);
 		void checked(std::size_t pos, bool);
 		bool checked(std::size_t pos) const;
diff --git a/source/gui/widgets/listbox.cpp b/source/gui/widgets/listbox.cpp
index cd40636f..ce211cc4 100644
--- a/source/gui/widgets/listbox.cpp
+++ b/source/gui/widgets/listbox.cpp
@@ -3393,7 +3393,7 @@ namespace nana
 					const auto border_color = essence_->scheme_ptr->header_bgcolor.get_color().blend(colors::black, 0.8);
 
 					int text_top = (r.height - essence_->scheme_ptr->text_height) / 2 + r.y;
-					auto text_color = essence_->lister.wd_ptr()->fgcolor();
+					auto text_color = essence_->scheme_ptr->header_fgcolor.get_color();
 
 					auto state = item_state::normal;
 					//check whether grabing an item, if item_spliter_ != npos, that indicates the grab item is a spliter.
@@ -3784,7 +3784,7 @@ namespace nana
 						if (item.flags.selected)
 							bgcolor = bgcolor.blend(colors::black, 0.98);           // or "selected"
 						else
-							bgcolor = bgcolor.blend(essence_->scheme_ptr->item_selected, 0.7);   /// \todo create a parametre for amount of blend
+							bgcolor = bgcolor.blend(essence_->scheme_ptr->item_highlighted, 0.7);   /// \todo create a parametre for amount of blend
 					}
 
 					unsigned show_w = (std::min)(content_r.width, width - essence_->scroll.x_offset());
diff --git a/source/gui/widgets/menu.cpp b/source/gui/widgets/menu.cpp
index 05c428ce..e3addb5c 100644
--- a/source/gui/widgets/menu.cpp
+++ b/source/gui/widgets/menu.cpp
@@ -1158,6 +1158,11 @@ namespace nana
 			impl_->mbuilder.data().items.at(index).image = img;
 		}
 
+		void menu::change_text(std::size_t index, const std::string& text)
+		{
+			impl_->mbuilder.data().items.at(index).text = text;
+		}
+
 		bool menu::link(std::size_t index, menu& menu_obj)
 		{
 			if(impl_->mbuilder.set_sub_menu(index, menu_obj.impl_->mbuilder.data()))

From 57aa0498b352c675d0496fb29ce0d0e51fbc5f95 Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Sun, 16 Oct 2016 07:07:44 +0800
Subject: [PATCH 12/16] some modifications for pr(#154)

update contributor info
---
 include/nana/gui/widgets/listbox.hpp |  9 ++-------
 include/nana/gui/widgets/menu.hpp    |  7 ++++---
 source/gui/widgets/listbox.cpp       |  4 +++-
 source/gui/widgets/menu.cpp          | 11 ++++++-----
 4 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/include/nana/gui/widgets/listbox.hpp b/include/nana/gui/widgets/listbox.hpp
index 36b2ffb9..19fe1093 100644
--- a/include/nana/gui/widgets/listbox.hpp
+++ b/include/nana/gui/widgets/listbox.hpp
@@ -8,12 +8,7 @@
  *	http://www.boost.org/LICENSE_1_0.txt)
  *
  *	@file: nana/gui/widgets/listbox.hpp
- *	@contributors:
- *		Hiroshi Seki
- *		Ariel Vina-Rodriguez
- *		leobackes(pr#86,pr#97)
- *		Benjamin Navarro(pr#81)
- *		besh81(pr#130)
+ *
  */
 
 #ifndef NANA_GUI_WIDGETS_LISTBOX_HPP
@@ -1149,7 +1144,7 @@ namespace nana
 				: public widget_geometrics
 			{
 				color_proxy header_bgcolor{static_cast<color_rgb>(0xf1f2f4)};
-				color_proxy header_fgcolor{ static_cast<color_rgb>(0x000000) };
+				color_proxy header_fgcolor{ colors::black };
 				color_proxy header_grabbed{ static_cast<color_rgb>(0x8BD6F6)};
 				color_proxy header_floated{ static_cast<color_rgb>(0xBABBBC)};
 				color_proxy item_selected{ static_cast<color_rgb>(0xD5EFFC) };
diff --git a/include/nana/gui/widgets/menu.hpp b/include/nana/gui/widgets/menu.hpp
index c6bc81a7..b010f6d4 100644
--- a/include/nana/gui/widgets/menu.hpp
+++ b/include/nana/gui/widgets/menu.hpp
@@ -1,13 +1,14 @@
 /**
  *	A Menu implementation
  *	Nana C++ Library(http://www.nanapro.org)
- *	Copyright(C) 2009-2014 Jinhao(cnjinhao@hotmail.com)
+ *	Copyright(C) 2009-2016 Jinhao(cnjinhao@hotmail.com)
  *
  *	Distributed under the Boost Software License, Version 1.0.
  *	(See accompanying file LICENSE_1_0.txt or copy at
  *	http://www.boost.org/LICENSE_1_0.txt)
  *
  *	@file: nana/gui/widgets/menu.hpp
+ *
  */
 
 #ifndef NANA_GUI_WIDGETS_MENU_HPP
@@ -138,13 +139,13 @@ namespace nana
 		~menu();
 
 			/// Appends an item to the menu.
-		item_proxy	append(const std::string& text, const event_fn_t& callback= event_fn_t());
+		item_proxy	append(std::string text_utf8, const event_fn_t& callback= event_fn_t());
 		void		append_splitter();
 		void clear();								///< Erases all of the items.
 		/// Closes the menu. It does not destroy the menu; just close the window for the menu.
 		void close();
 		void image(std::size_t pos, const paint::image& icon);
-		void change_text(std::size_t pos, const std::string& text);
+		void text(std::size_t pos, std::string text_utf8);
 		void check_style(std::size_t pos, checks);
 		void checked(std::size_t pos, bool);
 		bool checked(std::size_t pos) const;
diff --git a/source/gui/widgets/listbox.cpp b/source/gui/widgets/listbox.cpp
index ce211cc4..80fe2ed6 100644
--- a/source/gui/widgets/listbox.cpp
+++ b/source/gui/widgets/listbox.cpp
@@ -14,7 +14,8 @@
  *		leobackes(pr#86,pr#97)
  *		Benjamin Navarro(pr#81)
  *		besh81(pr#130)
- *		
+ *		dankan1890(pr#154)
+ *
  */
 
 #include <nana/gui/widgets/listbox.hpp>
@@ -3394,6 +3395,7 @@ namespace nana
 
 					int text_top = (r.height - essence_->scheme_ptr->text_height) / 2 + r.y;
 					auto text_color = essence_->scheme_ptr->header_fgcolor.get_color();
+					
 
 					auto state = item_state::normal;
 					//check whether grabing an item, if item_spliter_ != npos, that indicates the grab item is a spliter.
diff --git a/source/gui/widgets/menu.cpp b/source/gui/widgets/menu.cpp
index e3addb5c..c3814214 100644
--- a/source/gui/widgets/menu.cpp
+++ b/source/gui/widgets/menu.cpp
@@ -1,7 +1,7 @@
 /*
 *	A Menu implementation
 *	Nana C++ Library(http://www.nanapro.org)
-*	Copyright(C) 2009-2015 Jinhao(cnjinhao@hotmail.com)
+*	Copyright(C) 2009-2016 Jinhao(cnjinhao@hotmail.com)
 *
 *	Distributed under the Boost Software License, Version 1.0.
 *	(See accompanying file LICENSE_1_0.txt or copy at
@@ -10,6 +10,7 @@
 *	@file: nana/gui/widgets/menu.cpp
 *	@contributors:
 *		kmribti(pr#102)
+*		dankan1890(pr#154)
 */
 
 #include <nana/gui/widgets/menu.hpp>
@@ -1120,9 +1121,9 @@ namespace nana
 			delete impl_;
 		}
 
-		auto menu::append(const std::string& text, const menu::event_fn_t& f) -> item_proxy
+		auto menu::append(std::string text_utf8, const menu::event_fn_t& f) -> item_proxy
 		{
-			impl_->mbuilder.data().items.emplace_back(text, f);
+			impl_->mbuilder.data().items.emplace_back(std::move(text_utf8), f);
 			return item_proxy(size() - 1, impl_->mbuilder.data().items.back());
 		}
 
@@ -1158,9 +1159,9 @@ namespace nana
 			impl_->mbuilder.data().items.at(index).image = img;
 		}
 
-		void menu::change_text(std::size_t index, const std::string& text)
+		void menu::text(std::size_t index, std::string text_utf8)
 		{
-			impl_->mbuilder.data().items.at(index).text = text;
+			impl_->mbuilder.data().items.at(index).text.swap(text_utf8);
 		}
 
 		bool menu::link(std::size_t index, menu& menu_obj)

From 47b223493296c13a1ac4a0075d10ece27115dac6 Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Sun, 16 Oct 2016 07:11:40 +0800
Subject: [PATCH 13/16] fix wrong pr number.

---
 source/gui/widgets/listbox.cpp | 2 +-
 source/gui/widgets/menu.cpp    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/gui/widgets/listbox.cpp b/source/gui/widgets/listbox.cpp
index 80fe2ed6..c2cdedf1 100644
--- a/source/gui/widgets/listbox.cpp
+++ b/source/gui/widgets/listbox.cpp
@@ -14,7 +14,7 @@
  *		leobackes(pr#86,pr#97)
  *		Benjamin Navarro(pr#81)
  *		besh81(pr#130)
- *		dankan1890(pr#154)
+ *		dankan1890(pr#158)
  *
  */
 
diff --git a/source/gui/widgets/menu.cpp b/source/gui/widgets/menu.cpp
index c3814214..823de8e6 100644
--- a/source/gui/widgets/menu.cpp
+++ b/source/gui/widgets/menu.cpp
@@ -10,7 +10,7 @@
 *	@file: nana/gui/widgets/menu.cpp
 *	@contributors:
 *		kmribti(pr#102)
-*		dankan1890(pr#154)
+*		dankan1890(pr#158)
 */
 
 #include <nana/gui/widgets/menu.hpp>

From afa9cffd5107ede405d0110762fd063896a4596e Mon Sep 17 00:00:00 2001
From: dankan1890 <mewuidev2@gmail.com>
Date: Tue, 18 Oct 2016 00:32:58 +0200
Subject: [PATCH 14/16] Added multi platform support for ICOns files.

---
 source/gui/notifier.cpp              |   6 +-
 source/paint/detail/image_ico_ex.hpp | 263 +++++++++++++++++++++++++++
 source/paint/image.cpp               |   9 +-
 3 files changed, 272 insertions(+), 6 deletions(-)
 create mode 100644 source/paint/detail/image_ico_ex.hpp

diff --git a/source/gui/notifier.cpp b/source/gui/notifier.cpp
index e46541c9..ddecc68d 100644
--- a/source/gui/notifier.cpp
+++ b/source/gui/notifier.cpp
@@ -201,7 +201,7 @@ namespace nana
 #if defined(NANA_WINDOWS)
 	void notifications_window_proc(HWND wd, WPARAM wparam, LPARAM lparam)
 	{
-		arg_notifier arg;
+		arg_notifier arg = {};
 		switch (lparam)
 		{
 		case WM_LBUTTONDBLCLK:
@@ -321,6 +321,7 @@ namespace nana
 
 	void notifier::icon(const std::string& icon_file)
 	{
+#if defined(NANA_WINDOWS)
 		paint::image image_ico{ icon_file };
 		auto icon_handle = paint::image_accessor::icon(image_ico);
 		if (icon_handle)
@@ -330,14 +331,17 @@ namespace nana
 			impl_->set_icon(image_ico);
 			impl_->icon = image_ico;
 		}
+#endif
 	}
 
 	void notifier::insert_icon(const std::string& icon_file)
 	{
+#if defined(NANA_WINDOWS)
 		paint::image image_ico{ icon_file };
 		auto icon_handle = paint::image_accessor::icon(image_ico);
 		if (icon_handle)
 			impl_->icons.emplace_back(static_cast<paint::image&&>(image_ico));
+#endif
 	}
 
 	void notifier::period(unsigned ms)
diff --git a/source/paint/detail/image_ico_ex.hpp b/source/paint/detail/image_ico_ex.hpp
new file mode 100644
index 00000000..0e9dcc44
--- /dev/null
+++ b/source/paint/detail/image_ico_ex.hpp
@@ -0,0 +1,263 @@
+#ifndef NANA_PAINT_DETAIL_IMAGE_ICO_EX_HPP
+#define NANA_PAINT_DETAIL_IMAGE_ICO_EX_HPP
+
+#include "image_pixbuf.hpp"
+
+namespace nana {
+namespace paint {
+namespace detail {
+// These next two structs represent how the icon information is stored
+// in an ICO file.
+typedef struct
+{
+	uint8_t   bWidth;                // Width of the image
+	uint8_t   bHeight;               // Height of the image (times 2)
+	uint8_t   bColorCount;           // Number of colors in image (0 if >=8bpp)
+	uint8_t   bReserved;             // Reserved
+	uint16_t  wPlanes;               // Color Planes
+	uint16_t  wBitCount;             // Bits per pixel
+	uint32_t  dwBytesInRes;          // how many bytes in this resource?
+	uint32_t  dwImageOffset;         // where in the file is this image
+} ICONDIRENTRY, *LPICONDIRENTRY;
+
+typedef struct
+{
+	uint16_t  idReserved;            // Reserved
+	uint16_t  idType;                // resource type (1 for icons)
+	uint16_t  idCount;               // how many images?
+	//ICONDIRENTRY  idEntries[1];    // the entries for each image
+} ICONDIR, *LPICONDIR;
+
+// size - 40 bytes
+typedef struct
+{
+	uint32_t  biSize;
+	uint32_t  biWidth;
+	uint32_t  biHeight;   // Icon Height (added height of XOR-Bitmap and AND-Bitmap)
+	uint16_t  biPlanes;
+	uint16_t  biBitCount;
+	uint32_t  biCompression;
+	int32_t   biSizeImage;
+	uint32_t  biXPelsPerMeter;
+	uint32_t  biYPelsPerMeter;
+	uint32_t  biClrUsed;
+	uint32_t  biClrImportant;
+} s_BITMAPINFOHEADER, *s_PBITMAPINFOHEADER;
+
+// 46 bytes
+typedef struct
+{
+	s_BITMAPINFOHEADER    icHeader;       // DIB header
+	uint32_t              icColors[1];    // Color table (short 4 bytes) //RGBQUAD
+	uint8_t               icXOR[1];       // DIB bits for XOR mask
+	uint8_t               icAND[1];       // DIB bits for AND mask
+} ICONIMAGE, *LPICONIMAGE;
+
+
+class image_ico_ex
+	: public basic_image_pixbuf
+{
+	bool _m_read_ico(const void* data, std::size_t size)
+	{
+		auto width = 0;
+		auto height = 0;
+		auto buffer = (unsigned char *)data;
+		auto icoDir = reinterpret_cast<LPICONDIR>(buffer);
+		int iconsCount = icoDir->idCount;
+		if (icoDir->idReserved != 0 || icoDir->idType != 1 || iconsCount == 0 || iconsCount > 20)
+			return false;
+
+		auto cursor = buffer;
+		cursor += 6;
+		auto dirEntry = reinterpret_cast<ICONDIRENTRY*>(cursor);
+		auto maxSize = 0;
+		auto offset = 0;
+		auto maxBitCount = 0;
+		for (auto i = 0; i < iconsCount; i++, ++dirEntry)
+		{
+			int w = dirEntry->bWidth;
+			int h = dirEntry->bHeight;
+			int bitCount = dirEntry->wBitCount;
+			if (w * h > maxSize || bitCount > maxBitCount) // we choose icon with max resolution
+			{
+				width = w;
+				height = h;
+				offset = dirEntry->dwImageOffset;
+				maxSize = w * h;
+				maxBitCount = bitCount;
+			}
+		}
+
+		if (offset == 0) return false;
+
+		cursor = buffer;
+		cursor += offset;
+		auto icon = reinterpret_cast<ICONIMAGE*>(cursor);
+		auto realBitsCount = static_cast<int>(icon->icHeader.biBitCount);
+		auto hasAndMask = (realBitsCount < 32) && (height != icon->icHeader.biHeight);
+		cursor += 40;
+		pixbuf_.open(width, height);
+
+		// rgba + vertical swap
+		if (realBitsCount >= 32)
+		{
+			for (auto x = 0; x < width; ++x)
+				for (auto y = 0; y < height; ++y)
+				{
+					pixbuf_.alpha_channel(true);
+					auto shift2 = 4 * (x + (height - y - 1) * width);
+					pixel_color_t image;
+					image.element.red = cursor[shift2 + 2];
+					image.element.green = cursor[shift2 + 1];
+					image.element.blue = cursor[shift2];
+					image.element.alpha_channel = cursor[shift2 + 3];
+					pixbuf_.pixel(x, y, image);
+				}
+		}
+
+		else if (realBitsCount == 24)
+		{
+			for (auto x = 0; x < width; x++)
+				for (auto y = 0; y < height; y++)
+				{
+					pixbuf_.alpha_channel(true);
+					auto shift2 = 3 * (x + (height - y - 1) * width);
+					pixel_color_t image;
+					image.element.red = cursor[shift2 + 2];
+					image.element.green = cursor[shift2 + 1];
+					image.element.blue = cursor[shift2];
+					image.element.alpha_channel = 255;
+					pixbuf_.pixel(x, y, image);
+				}
+		}
+
+		else if (realBitsCount == 8)  /// 256 colors
+		{
+			// 256 color table
+			auto colors = reinterpret_cast<unsigned char *>(cursor);
+			cursor += 256 * 4;
+			for (auto x = 0; x < width; x++)
+				for (auto y = 0; y < height; y++)
+				{
+					pixbuf_.alpha_channel(true);
+
+					auto shift2 = (x + (height - y - 1) * width);
+					auto index = 4 * cursor[shift2];
+					pixel_color_t image;
+					image.element.red = colors[index + 2];
+					image.element.green = colors[index + 1];
+					image.element.blue = colors[index];
+					image.element.alpha_channel = 255;
+					pixbuf_.pixel(x, y, image);
+				}
+		}
+
+		else if (realBitsCount == 4)  /// 16 colors
+		{
+			// 16 color table
+			auto colors = reinterpret_cast<unsigned char *>(cursor);
+			cursor += 16 * 4;
+			for (auto x = 0; x < width; x++)
+				for (auto y = 0; y < height; y++)
+				{
+					auto shift2 = (x + (height - y - 1) * width);
+					auto index = cursor[shift2 / 2];
+					if (shift2 % 2 == 0)
+						index = (index >> 4) & 0xF;
+					else
+						index = index & 0xF;
+					index *= 4;
+					pixbuf_.alpha_channel(true);
+					pixel_color_t image;
+					image.element.red = colors[index + 2];
+					image.element.green = colors[index + 1];
+					image.element.blue = colors[index];
+					image.element.alpha_channel = 255;
+					pixbuf_.pixel(x, y, image);
+				}
+		}
+
+		else if (realBitsCount == 1)  /// 2 colors
+		{
+			// 2 color table
+			auto colors = reinterpret_cast<unsigned char *>(cursor);
+			cursor += 2 * 4;
+			auto boundary = width; //!!! 32 bit boundary (http://www.daubnet.com/en/file-format-ico)
+			while (boundary % 32 != 0) boundary++;
+			for (auto x = 0; x < width; x++)
+				for (auto y = 0; y < height; y++)
+				{
+					auto shift2 = (x + (height - y - 1) * boundary);
+					auto index = cursor[shift2 / 8];
+
+					// select 1 bit only
+					unsigned char bit = 7 - (x % 8);
+					index = (index >> bit) & 0x01;
+					index *= 4;
+					pixbuf_.alpha_channel(true);
+					pixel_color_t image;
+					image.element.red = colors[index + 2];
+					image.element.green = colors[index + 1];
+					image.element.blue = colors[index];
+					image.element.alpha_channel = 255;
+					pixbuf_.pixel(x, y, image);
+				}
+		}
+
+		// Read AND mask after base color data - 1 BIT MASK
+		if (hasAndMask)
+		{
+			auto boundary = width * realBitsCount; //!!! 32 bit boundary (http://www.daubnet.com/en/file-format-ico)
+			while (boundary % 32 != 0) boundary++;
+			cursor += boundary * height / 8;
+			boundary = width;
+			while (boundary % 32 != 0) boundary++;
+			for (auto y = 0; y < height; y++)
+				for (auto x = 0; x < width; x++)
+				{
+					unsigned char bit = 7 - (x % 8);
+					auto shift2 = (x + (height - y - 1) * boundary) / 8;
+					auto mask = (0x01 & (static_cast<unsigned char>(cursor[shift2]) >> bit));
+					auto pc = pixbuf_.pixel(x, y);
+					auto alpha = pc.element.alpha_channel;
+					alpha *= 1 - mask;
+					pc.element.alpha_channel = alpha;
+					pixbuf_.pixel(x, y, pc);
+				}
+		}
+		return true;
+	}
+public:
+
+	bool open(const std::experimental::filesystem::path& ico_file) override
+	{
+		std::ifstream file(ico_file.string(), std::ios::binary);
+		if (!file.is_open()) return false;
+
+		// allocates a buffer for the image
+		std::streampos size = 0;
+		file.seekg(0, std::ios::end);
+		size = file.tellg() - size;
+		file.seekg(0, std::ios::beg);
+		auto buffer = new char[size];
+
+		// read data from the file and set them in the buffer
+		file.read(buffer, size);
+		auto okret = _m_read_ico(buffer, size);
+
+		// delete buffer and return
+		delete[] buffer;
+		return okret;
+	}
+
+	bool open(const void* data, std::size_t bytes) override
+	{
+		return _m_read_ico(data, bytes);
+	}
+
+};
+}//end namespace detail
+}//end namespace paint
+}//end namespace nana
+
+#endif
\ No newline at end of file
diff --git a/source/paint/image.cpp b/source/paint/image.cpp
index 498dd944..65ad6ba2 100644
--- a/source/paint/image.cpp
+++ b/source/paint/image.cpp
@@ -35,6 +35,7 @@
 #include "detail/image_ico.hpp"
 
 #include "image_accessor.hpp"
+#include "detail/image_ico_ex.hpp"
 
 namespace fs = std::experimental::filesystem;
 
@@ -264,11 +265,7 @@ namespace paint
 			{
 				if (ext_ico == ext)
 				{
-#if defined(NANA_WINDOWS)
-					ptr = std::make_shared<detail::image_ico>(true);
-#else
-					return ptr;
-#endif
+					ptr = std::make_shared<detail::image_ico_ex>();
 					break;
 				}
 
@@ -367,6 +364,8 @@ namespace paint
 							ptr = std::make_shared<detail::image_ico>(true);
 						}
 #endif
+						else if (!ptr && bytes > 40 && (0x00010000 == *reinterpret_cast<const unsigned*>(data)))
+							ptr = std::make_shared<detail::image_ico_ex>();
 					}
 				}
 

From 043ebad317362756dde64ee29a4bcf10c5e58eca Mon Sep 17 00:00:00 2001
From: Jinhao <cnjinhao@hotmail.com>
Date: Mon, 31 Oct 2016 06:36:03 +0800
Subject: [PATCH 15/16] fix some compiler errors and warnings

---
 source/gui/widgets/menu.cpp          |   6 +-
 source/paint/detail/image_ico_ex.hpp | 133 +++++++++++++--------------
 2 files changed, 69 insertions(+), 70 deletions(-)

diff --git a/source/gui/widgets/menu.cpp b/source/gui/widgets/menu.cpp
index f734deaa..1decffd5 100644
--- a/source/gui/widgets/menu.cpp
+++ b/source/gui/widgets/menu.cpp
@@ -1117,9 +1117,9 @@ namespace nana
 			delete impl_;
 		}
 
-		auto menu::append(std::string text_utf8, const menu::event_fn_t& f) -> item_proxy
+		auto menu::append(std::string text_utf8, const menu::event_fn_t& callback) -> item_proxy
 		{
-			impl_->mbuilder.data().items.emplace_back(new item_type(std::move(text_utf8, callback));
+			impl_->mbuilder.data().items.emplace_back(new item_type(std::move(text_utf8), callback));
 			return item_proxy(size() - 1, *impl_->mbuilder.data().items.back());
 		}
 
@@ -1159,7 +1159,7 @@ namespace nana
 
 		void menu::text(std::size_t index, std::string text_utf8)
 		{
-			impl_->mbuilder.data().items.at(index).text.swap(text_utf8);
+			impl_->mbuilder.data().items.at(index)->text.swap(text_utf8);
 		}
 
 		bool menu::link(std::size_t index, menu& menu_obj)
diff --git a/source/paint/detail/image_ico_ex.hpp b/source/paint/detail/image_ico_ex.hpp
index 0e9dcc44..33f1d96c 100644
--- a/source/paint/detail/image_ico_ex.hpp
+++ b/source/paint/detail/image_ico_ex.hpp
@@ -1,11 +1,11 @@
-#ifndef NANA_PAINT_DETAIL_IMAGE_ICO_EX_HPP
-#define NANA_PAINT_DETAIL_IMAGE_ICO_EX_HPP
-
-#include "image_pixbuf.hpp"
-
-namespace nana {
-namespace paint {
-namespace detail {
+#ifndef NANA_PAINT_DETAIL_IMAGE_ICO_EX_HPP
+#define NANA_PAINT_DETAIL_IMAGE_ICO_EX_HPP
+
+#include "image_pixbuf.hpp"
+
+namespace nana {
+namespace paint {
+namespace detail {
 // These next two structs represent how the icon information is stored
 // in an ICO file.
 typedef struct
@@ -52,21 +52,21 @@ typedef struct
 	uint8_t               icXOR[1];       // DIB bits for XOR mask
 	uint8_t               icAND[1];       // DIB bits for AND mask
 } ICONIMAGE, *LPICONIMAGE;
-
-
-class image_ico_ex
-	: public basic_image_pixbuf
-{
-	bool _m_read_ico(const void* data, std::size_t size)
-	{
+
+
+class image_ico_ex
+	: public basic_image_pixbuf
+{
+	bool _m_read_ico(const void* data, std::size_t size)
+	{
 		auto width = 0;
 		auto height = 0;
 		auto buffer = (unsigned char *)data;
 		auto icoDir = reinterpret_cast<LPICONDIR>(buffer);
 		int iconsCount = icoDir->idCount;
-		if (icoDir->idReserved != 0 || icoDir->idType != 1 || iconsCount == 0 || iconsCount > 20)
+		if (icoDir->idReserved != 0 || icoDir->idType != 1 || iconsCount == 0 || iconsCount > 20)
 			return false;
-
+
 		auto cursor = buffer;
 		cursor += 6;
 		auto dirEntry = reinterpret_cast<ICONDIRENTRY*>(cursor);
@@ -83,11 +83,11 @@ class image_ico_ex
 				width = w;
 				height = h;
 				offset = dirEntry->dwImageOffset;
-				maxSize = w * h;
+				maxSize = w * h;
 				maxBitCount = bitCount;
 			}
 		}
-
+
 		if (offset == 0) return false;
 
 		cursor = buffer;
@@ -119,8 +119,8 @@ class image_ico_ex
 		{
 			for (auto x = 0; x < width; x++)
 				for (auto y = 0; y < height; y++)
-				{
-					pixbuf_.alpha_channel(true);
+				{
+					pixbuf_.alpha_channel(true);
 					auto shift2 = 3 * (x + (height - y - 1) * width);
 					pixel_color_t image;
 					image.element.red = cursor[shift2 + 2];
@@ -138,10 +138,10 @@ class image_ico_ex
 			cursor += 256 * 4;
 			for (auto x = 0; x < width; x++)
 				for (auto y = 0; y < height; y++)
-				{
-					pixbuf_.alpha_channel(true);
-
-					auto shift2 = (x + (height - y - 1) * width);
+				{
+					pixbuf_.alpha_channel(true);
+
+					auto shift2 = (x + (height - y - 1) * width);
 					auto index = 4 * cursor[shift2];
 					pixel_color_t image;
 					image.element.red = colors[index + 2];
@@ -159,8 +159,8 @@ class image_ico_ex
 			cursor += 16 * 4;
 			for (auto x = 0; x < width; x++)
 				for (auto y = 0; y < height; y++)
-				{
-					auto shift2 = (x + (height - y - 1) * width);
+				{
+					auto shift2 = (x + (height - y - 1) * width);
 					auto index = cursor[shift2 / 2];
 					if (shift2 % 2 == 0)
 						index = (index >> 4) & 0xF;
@@ -186,8 +186,8 @@ class image_ico_ex
 			while (boundary % 32 != 0) boundary++;
 			for (auto x = 0; x < width; x++)
 				for (auto y = 0; y < height; y++)
-				{
-					auto shift2 = (x + (height - y - 1) * boundary);
+				{
+					auto shift2 = (x + (height - y - 1) * boundary);
 					auto index = cursor[shift2 / 8];
 
 					// select 1 bit only
@@ -214,9 +214,9 @@ class image_ico_ex
 			while (boundary % 32 != 0) boundary++;
 			for (auto y = 0; y < height; y++)
 				for (auto x = 0; x < width; x++)
-				{
-					unsigned char bit = 7 - (x % 8);
-					auto shift2 = (x + (height - y - 1) * boundary) / 8;
+				{
+					unsigned char bit = 7 - (x % 8);
+					auto shift2 = (x + (height - y - 1) * boundary) / 8;
 					auto mask = (0x01 & (static_cast<unsigned char>(cursor[shift2]) >> bit));
 					auto pc = pixbuf_.pixel(x, y);
 					auto alpha = pc.element.alpha_channel;
@@ -225,39 +225,38 @@ class image_ico_ex
 					pixbuf_.pixel(x, y, pc);
 				}
 		}
-		return true;
-	}
-public:
-
-	bool open(const std::experimental::filesystem::path& ico_file) override
-	{
-		std::ifstream file(ico_file.string(), std::ios::binary);
-		if (!file.is_open()) return false;
-
-		// allocates a buffer for the image
-		std::streampos size = 0;
-		file.seekg(0, std::ios::end);
-		size = file.tellg() - size;
-		file.seekg(0, std::ios::beg);
-		auto buffer = new char[size];
-
-		// read data from the file and set them in the buffer
-		file.read(buffer, size);
-		auto okret = _m_read_ico(buffer, size);
-
-		// delete buffer and return
-		delete[] buffer;
-		return okret;
-	}
-
-	bool open(const void* data, std::size_t bytes) override
-	{
-		return _m_read_ico(data, bytes);
-	}
-
-};
-}//end namespace detail
-}//end namespace paint
-}//end namespace nana
-
+		return true;
+	}
+public:
+
+	bool open(const std::experimental::filesystem::path& ico_file) override
+	{
+		std::ifstream file(ico_file.string(), std::ios::binary);
+		if (!file.is_open()) return false;
+
+		// allocates a buffer for the image
+		file.seekg(0, std::ios::end);
+		const auto bytes = static_cast<std::size_t>(file.tellg());
+		file.seekg(0, std::ios::beg);
+		auto buffer = new char[bytes];
+
+		// read data from the file and set them in the buffer
+		file.read(buffer, bytes);
+		auto okret = _m_read_ico(buffer, bytes);
+
+		// delete buffer and return
+		delete[] buffer;
+		return okret;
+	}
+
+	bool open(const void* data, std::size_t bytes) override
+	{
+		return _m_read_ico(data, bytes);
+	}
+
+};
+}//end namespace detail
+}//end namespace paint
+}//end namespace nana
+
 #endif
\ No newline at end of file

From c2640f5524558708d22b4362c99aa7b1f53671ca Mon Sep 17 00:00:00 2001
From: Toby Case <toby.case@aero.org>
Date: Wed, 2 Nov 2016 18:09:10 -0700
Subject: [PATCH 16/16] - Include nana/deploy.hpp to declare to_utf8 - Was
 preventing compilation of nana library

---
 include/nana/internationalization.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/nana/internationalization.hpp b/include/nana/internationalization.hpp
index 250e3978..1b434169 100644
--- a/include/nana/internationalization.hpp
+++ b/include/nana/internationalization.hpp
@@ -16,6 +16,7 @@
 #include <sstream>
 #include <functional>
 #include <memory>
+#include <nana/deploy.hpp>
 
 namespace nana
 {