refine code

fix bug that listbox may throw std::runtime when the modal is enabled
fix bug that textbox attachs a wrong event angent

include/nana/detail/win32/platform_spec.hpp

@@ -17,13 +17,11 @@
 #ifndef NANA_DETAIL_PLATFORM_SPEC_HPP
 #define NANA_DETAIL_PLATFORM_SPEC_HPP
 
-#include <nana/deploy.hpp>
 #include <nana/gui/basis.hpp>
 #include <nana/paint/image.hpp>
 #include <nana/gui/detail/event_code.hpp>
 
 #include <windows.h>
-#include <map>
 #include <memory>
 #include <functional>
 
@@ -174,6 +172,12 @@ namespace detail
 
 	class platform_spec
 	{
+		platform_spec();
+		platform_spec(const platform_spec&) = delete;
+		platform_spec& operator=(const platform_spec&) = delete;
+
+		platform_spec(platform_spec&&) = delete;
+		platform_spec& operator=(platform_spec&&) = delete;
 	public:
 		typedef drawable_impl_type::font_ptr_t	font_ptr_t;
 		typedef ::nana::event_code event_code;
@@ -194,7 +198,7 @@ namespace detail
 			::nana::paint::image big_icon;
 		};
 
-		platform_spec();
+		~platform_spec();
 
 		const font_ptr_t& default_native_font() const;
 		void default_native_font(const font_ptr_t&);
@@ -207,8 +211,8 @@ namespace detail
 		void keep_window_icon(native_window_type, const paint::image&sml_icon, const paint::image& big_icon);
 		void release_window_icon(native_window_type);
 	private:
-		font_ptr_t	def_font_ptr_;
+		struct implementation;
-		std::map<native_window_type, window_icons> iconbase_;
+		implementation * const impl_;
 	};
 
 }//end namespace detail

include/nana/gui/detail/element_store.hpp

@@ -1,7 +1,7 @@
 /*
 *	The Store for the Storage Of Elements
 *	Nana C++ Library(http://www.nanapro.org)
-*	Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
+*	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
@@ -16,9 +16,7 @@
 #include <nana/gui/element.hpp>
 #include <nana/pat/cloneable.hpp>
 
-#include <map>
 #include <string>
-
 #include <nana/push_ignore_diagnostic>
 
 
@@ -28,27 +26,20 @@ namespace detail
 {
 	class element_store
 	{
-		typedef ::nana::element::element_interface element_interface;
+		using element_interface = ::nana::element::element_interface;
-		typedef pat::cloneable< ::nana::element::element_interface> cloneable_element;
+		using cloneable_element = pat::cloneable< ::nana::element::element_interface>;
 
-		struct data
+		struct data;
-		{
-			cloneable_element object;
-			::nana::element::element_interface * fast_ptr;
-
-			data();
-		};
-
-		struct store
-		{
-			std::map<std::string, data> table;
-		};
 	public:
+		element_store();
+		~element_store();
+
 		element_interface * const * bground(const std::string&);
 		void bground(const std::string&, const pat::cloneable<element_interface>&);
 		void bground(const std::string&, pat::cloneable<element_interface>&&);
 	private:
-		store bground_;
+		struct implementation;
+		std::unique_ptr<implementation> impl_;
 	};
 }//end namespace detail
 }

include/nana/gui/detail/inner_fwd_implement.hpp

@@ -133,10 +133,10 @@ namespace nana{
 		class root_register
 		{
 		public:
-			root_misc* insert(native_window_type wd, const root_misc& misc)
+			root_misc* insert(native_window_type wd, root_misc&& misc)
 			{
 				recent_ = wd;
-				auto ret = table_.insert(std::make_pair(wd, misc));
+				auto ret = table_.emplace(wd, std::move(misc));
 				misc_ptr_ = &(ret.first->second);
 				return misc_ptr_;
 			}

include/nana/gui/detail/window_manager.hpp

@@ -20,18 +20,11 @@
 
 #include <nana/push_ignore_diagnostic>
 
-#include <vector>
 #include "window_layout.hpp"
 #include "event_code.hpp"
 #include "inner_fwd.hpp"
 #include <functional>
 
-#if defined(STD_THREAD_NOT_SUPPORTED)
-	#include <nana/std_mutex.hpp>
-#else
-	#include <mutex>
-#endif
-
 namespace nana
 {
 	class widget;	//forward declaration
@@ -51,15 +44,14 @@ namespace detail
 	class window_manager
 	{
 		class revertible_mutex
-			: public std::recursive_mutex
 		{
-			struct thr_refcnt
+			revertible_mutex(const revertible_mutex&) = delete;
-			{
+			revertible_mutex& operator=(const revertible_mutex&) = delete;
-				unsigned tid;
+			revertible_mutex(revertible_mutex&&) = delete;
-				std::size_t refcnt;
+			revertible_mutex& operator=(revertible_mutex&&) = delete;
-			};
 		public:
 			revertible_mutex();
+			~revertible_mutex();
 
 			void lock();
 			bool try_lock();
@@ -68,8 +60,8 @@ namespace detail
 			void revert();
 			void forward();
 		private:
-			thr_refcnt thr_;
+			struct implementation;
-			std::vector<thr_refcnt> stack_;
+			implementation * const impl_;
 		};
 	public:
 		using native_window = native_window_type;
@@ -90,7 +82,6 @@ namespace detail
 
 		bool available(core_window_t*);
 		bool available(core_window_t *, core_window_t*);
-		bool available(native_window_type);
 
 		core_window_t* create_root(core_window_t*, bool nested, rectangle, const appearance&, widget*);
 		core_window_t* create_widget(core_window_t*, const rectangle&, bool is_lite, widget*);
@@ -157,7 +148,7 @@ namespace detail
 
 		bool calc_window_point(core_window_t*, nana::point&);
 
-		root_misc* root_runtime(native_window_type) const;
+		root_misc* root_runtime(native_window) const;
 
 		bool register_shortkey(core_window_t*, unsigned long key);
 		void unregister_shortkey(core_window_t*, bool with_children);

include/nana/gui/element.hpp

@@ -16,7 +16,6 @@
 #include <nana/paint/graphics.hpp>
 #include <nana/pat/cloneable.hpp>
 #include <vector>
-#include <map>
 
 namespace nana
 {
@@ -338,13 +337,8 @@ namespace nana
 			struct draw_image;
 			struct draw_graph;
 
-			draw_method * method_;
+			struct implementation;
-			bool	vertical_;
+			std::unique_ptr<implementation> impl_;
-			nana::rectangle valid_area_;
-			std::vector<element_state> states_;
-			std::map<element_state, element_state> join_;
-			bool	stretch_all_;
-			unsigned left_, top_, right_, bottom_;
 		}; //end class bground
 	}//end namespace element
 }//end namespace nana

include/nana/gui/place.hpp

@@ -17,7 +17,6 @@
 #define NANA_GUI_PLACE_HPP
 #include <nana/push_ignore_diagnostic>
 #include <nana/gui/basis.hpp>
-#include <utility>
 #include <memory>
 #include <functional>
 

include/nana/gui/programming_interface.hpp

@@ -347,7 +347,8 @@ namespace API
 	 * When you are finished with the caret, be sure to reset the pointer.
 	 *
 	 * @param window_handle A handle to a window whose caret is to be retrieved
-	 * @return a pointer to the caret proxy. nullptr if the window doesn't have a caret.
+	 * @return a pointer to the caret proxy.
+	 * @except throws std::runtime if the window doesn't have a caret when disable_throw is false
 	 */
 	::std::unique_ptr<caret_interface> open_caret(window window_handle, bool disable_throw = false);
 

include/nana/gui/widgets/listbox.hpp

@@ -720,7 +720,7 @@ namespace nana
 			class iresolver
 			{
 			public:
-				iresolver(const std::vector<cell>&);
+				iresolver(std::vector<cell>);
 
 				iresolver& operator>>(bool&);
 				iresolver& operator>>(short&);
@@ -740,7 +740,7 @@ namespace nana
 				iresolver& operator>>(cell&);
 				iresolver& operator>>(std::nullptr_t);
 			private:
-				const std::vector<cell>& cells_;
+				std::vector<cell> cells_;
 				std::size_t pos_{0};
 			};
 
@@ -918,7 +918,7 @@ namespace nana
 				//Undocumented method
 				essence * _m_ess() const;
 			private:
-				std::vector<cell> & _m_cells() const;
+				std::vector<cell> _m_cells() const;
 				nana::any		* _m_value(bool alloc_if_empty);
 				const nana::any	* _m_value() const;
 			private:

include/nana/gui/widgets/skeletons/text_editor.hpp

@@ -17,109 +17,26 @@
 
 #include "textbase.hpp"
 #include "text_editor_part.hpp"
-#include <nana/gui/widgets/scroll.hpp>
 #include <nana/unicode_bidi.hpp>
 
+//#include <nana/paint/graphics.hpp>
+#include <nana/gui/detail/general_events.hpp>
+
+#include <functional>
+
+namespace nana
+{
+	namespace paint
+	{
+		// Forward declaration
+		class graphics;
+	}
+}
+
 namespace nana{	namespace widgets
 {
 	namespace skeletons
 	{
-		template<typename EnumCommand>
-		class undoable_command_interface
-		{
-		public:
-			virtual ~undoable_command_interface() = default;
-
-			virtual EnumCommand get() const = 0;
-			virtual bool merge(const undoable_command_interface&) = 0;
-			virtual void execute(bool redo) = 0;
-		};
-
-		template<typename EnumCommand>
-		class undoable
-		{
-		public:
-			using command = EnumCommand;
-			using container = std::deque < std::unique_ptr<undoable_command_interface<command>> >;
-
-			void clear()
-			{
-				commands_.clear();
-				pos_ = 0;
-			}
-
-			void max_steps(std::size_t maxs)
-			{
-				max_steps_ = maxs;
-				if (maxs && (commands_.size() >= maxs))
-					commands_.erase(commands_.begin(), commands_.begin() + (commands_.size() - maxs + 1));
-			}
-
-			std::size_t max_steps() const
-			{
-				return max_steps_;
-			}
-
-			void enable(bool enb)
-			{
-				enabled_ = enb;
-				if (!enb)
-					clear();
-			}
-
-			bool enabled() const
-			{
-				return enabled_;
-			}
-
-			void push(std::unique_ptr<undoable_command_interface<command>> && ptr)
-			{
-				if (!ptr || !enabled_)
-					return;
-
-				if (pos_ < commands_.size())
-					commands_.erase(commands_.begin() + pos_, commands_.end());
-				else if (max_steps_ && (commands_.size() >= max_steps_))
-					commands_.erase(commands_.begin(), commands_.begin() + (commands_.size() - max_steps_ + 1));
-
-				pos_ = commands_.size();
-				if (!commands_.empty())
-				{
-					if (commands_.back().get()->merge(*ptr))
-						return;
-				}
-
-				commands_.emplace_back(std::move(ptr));
-				++pos_;
-			}
-
-			std::size_t count(bool is_undo) const
-			{
-				return (is_undo ? pos_ : commands_.size() - pos_);
-			}
-
-			void undo()
-			{
-				if (pos_ > 0)
-				{
-					--pos_;
-					commands_[pos_].get()->execute(false);
-				}
-			}
-
-			void redo()
-			{
-				if (pos_ != commands_.size())
-					commands_[pos_++].get()->execute(true);
-			}
-
-		private:
-			container commands_;
-			bool		enabled_{ true };
-			std::size_t max_steps_{ 30 };
-			std::size_t pos_{ 0 };
-		};
-
 		class text_editor
 		{
 			struct attributes;
@@ -136,9 +53,14 @@ namespace nana{	namespace widgets
 			class undo_input_text;
 			class undo_move_text;
 
-			struct keywords;
 			class keyword_parser;
 			class helper_pencil;
+
+			text_editor(const text_editor&) = delete;
+			text_editor& operator=(const text_editor&) = delete;
+
+			text_editor(text_editor&&) = delete;
+			text_editor& operator=(text_editor&&) = delete;
 		public:
 			using char_type = wchar_t;
 			using size_type = textbase<char_type>::size_type;
@@ -148,9 +70,10 @@ namespace nana{	namespace widgets
 
 			using graph_reference = ::nana::paint::graphics&;
 
-			struct ext_renderer_tag
+			struct renderers
 			{
-				std::function<void(graph_reference, const nana::rectangle& text_area, const ::nana::color&)> background;
+				std::function<void(graph_reference, const nana::rectangle& text_area, const ::nana::color&)> background;	///< a customized background renderer
+				std::function<void(graph_reference, const ::nana::color&)> border;											///< a customized border renderer
 			};
 
 			enum class accepts
@@ -178,11 +101,10 @@ namespace nana{	namespace widgets
 
 			/// Determine whether the text_editor is line wrapped.
 			bool line_wrapped() const;
+
 			/// Set the text_editor whether it is line wrapped, it returns false if the state is not changed.
 			bool line_wrapped(bool);
 
-			void border_renderer(std::function<void(graph_reference, const ::nana::color& bgcolor)>);
-
 			bool load(const char*);
 
 			/// Sets the text area.
@@ -205,7 +127,7 @@ namespace nana{	namespace widgets
 			void undo_max_steps(std::size_t);
 			std::size_t undo_max_steps() const;
 
-			ext_renderer_tag& ext_renderer() const;
+			renderers& customized_renderers();
 
 			unsigned line_height() const;
 			unsigned screen_lines() const;
@@ -267,8 +189,8 @@ namespace nana{	namespace widgets
 			bool mouse_move(bool left_button, const point& screen_pos);
 			bool mouse_pressed(const arg_mouse& arg);
 
-			skeletons::textbase<wchar_t>& textbase();
+			skeletons::textbase<char_type>& textbase();
-			const skeletons::textbase<wchar_t>& textbase() const;
+			const skeletons::textbase<char_type>& textbase() const;
 		private:
 			void _m_pre_calc_lines(std::size_t line_off, std::size_t lines);
 
@@ -276,7 +198,9 @@ namespace nana{	namespace widgets
 			::nana::color _m_bgcolor() const;
 			bool _m_scroll_text(bool vertical);
 			void _m_scrollbar();
-			::nana::size _m_text_area() const;
+
+			::nana::rectangle _m_text_area() const;
+
 			void _m_get_scrollbar_size();
 			void _m_reset();
 			::nana::upoint _m_put(::std::wstring);
@@ -295,9 +219,6 @@ namespace nana{	namespace widgets
 
 			int _m_text_top_base() const;
 
-			/// Returns the right/bottom point of text area.
-			int _m_end_pos(bool right) const;	
-
 			void _m_draw_parse_string(const keyword_parser&, bool rtl, ::nana::point pos, const ::nana::color& fgcolor, const wchar_t*, std::size_t len) const;
 			//_m_draw_string
 			//@brief: Draw a line of string
@@ -313,47 +234,28 @@ namespace nana{	namespace widgets
 			unsigned _m_char_by_pixels(const unicode_bidi::entity&, unsigned pos);
 
 			unsigned _m_pixels_by_char(const ::std::wstring&, ::std::size_t pos) const;
-			void _handle_move_key(const arg_keyboard& arg);
+			void _m_handle_move_key(const arg_keyboard& arg);
 
+			void _m_draw_border();
 		private:
-			std::unique_ptr<editor_behavior_interface> behavior_;
+			struct implementation;
-			undoable<command>	undo_;
+			implementation * const impl_;
+
 			nana::window window_;
-			std::unique_ptr<caret_interface> caret_;
 			graph_reference graph_;
 			const text_editor_scheme*	scheme_;
 			event_interface *			event_handler_{ nullptr };
-			std::unique_ptr<keywords> keywords_;
 
-			skeletons::textbase<wchar_t> textbase_;
 			wchar_t mask_char_{0};
 
-			mutable ext_renderer_tag ext_renderer_;
-
-			std::vector<upoint> text_position_;	//position of text from last rendering.
-
-			struct indent_rep
-			{
-				bool enabled{ false };
-				std::function<std::string()> generator;
-			}indent_;
-
 			struct attributes
 			{
-				accepts acceptive{ accepts::no_restrict };
-				std::function<bool(char_type)> pred_acceptive;
-
 				::std::string tip_string;
 
 				bool line_wrapped{false};
 				bool multi_lines{true};
 				bool editable{true};
 				bool enable_background{true};
-				bool enable_counterpart{false};
-				nana::paint::graphics counterpart; //this is used to keep the background that painted by external part.
-
-				std::unique_ptr<nana::scroll<true>>		vscroll;
-				std::unique_ptr<nana::scroll<false>>	hscroll;
 			}attributes_;
 
 			struct text_area_type
@@ -365,7 +267,6 @@ namespace nana{	namespace widgets
 				unsigned	scroll_pixels;
 				unsigned	vscroll;
 				unsigned	hscroll;
-				std::function<void(nana::paint::graphics&, const ::nana::color&)> border_renderer;
 			}text_area_;
 
 			struct selection

include/nana/gui/widgets/slider.hpp

@@ -1,7 +1,7 @@
 /**
  *	A Slider Implementation
  *	Nana C++ Library(http://www.nanapro.org)
- *	Copyright(C) 2003-2015 Jinhao(cnjinhao@hotmail.com)
+ *	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
@@ -134,7 +134,7 @@ namespace nana
 	}//end namespace drawerbase
 
 
-    /// A slider widget wich the user can drag for tracking \todo add scheme ?
+    /// A slider widget wich the user can drag for tracking
 	class slider
 		: public widget_object<category::widget_tag, drawerbase::slider::trigger, drawerbase::slider::slider_events, drawerbase::slider::scheme_impl>
 	{

include/nana/gui/widgets/widget.hpp

@@ -28,14 +28,25 @@ namespace nana
 
 	/// Abstract class for defining the capacity interface.
 	class widget
-		: nana::noncopyable, nana::nonmovable
 	{
 		friend class detail::widget_notifier_interface;
 		class inner_widget_notifier;
 		typedef void(*dummy_bool_type)(widget* (*)(const widget&));
+
+		
+		//Noncopyable
+		widget(const widget&) = delete;
+		widget& operator=(const widget&) = delete;
+
+		//Nonmovable
+		widget(widget&&) = delete;
+		widget& operator=(widget&&) = delete;
+		
 	public:
 		using native_string_type = detail::native_string_type;
 
+		widget() = default;
+
 		virtual ~widget() = default;
 		virtual window handle() const = 0;			///< Returns the handle of window, returns 0 if window is not created.
 		bool empty() const;							///< Determines whether the manipulator is handling a window.
@@ -298,15 +309,8 @@ namespace nana
 		using event_type = Events;
 
 		widget_object()
+			: widget_object(nullptr, false, API::make_center(300, 150), appearance(), this)
 		{
-			handle_ = API::dev::create_window(nullptr, false, API::make_center(300, 150), appearance(), this);
-			_m_bind_and_attach();
-		}
-
-		widget_object(const rectangle& r, const appearance& apr = {})
-		{
-			handle_ = API::dev::create_window(nullptr, false, r, apr, this);
-			_m_bind_and_attach();
 		}
 
 		widget_object(window owner, bool nested, const rectangle& r = {}, const appearance& apr = {})

include/nana/internationalization.hpp

@@ -12,7 +12,6 @@
 
 #ifndef NANA_INTERNATIONALIZATION_HPP
 #define NANA_INTERNATIONALIZATION_HPP
-#include "basic_types.hpp"
 #include <vector>
 #include <sstream>
 #include <functional>
@@ -186,9 +185,7 @@ namespace nana
 		void _m_add_args(const std::string&);
 		void _m_add_args(std::string&&);
 
-		void _m_add_args(std::wstring&);
 		void _m_add_args(const std::wstring&);
-		void _m_add_args(std::wstring&&);
 	private:
 		std::string msgid_;
 		std::vector<std::unique_ptr<eval_arg>> args_;

include/nana/paint/graphics.hpp

@@ -1,7 +1,7 @@
 /*
  *	Paint Graphics Implementation
  *	Nana C++ Library(http://www.nanapro.org)
- *	Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
+ *	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
@@ -17,7 +17,6 @@
 
 #include "../basic_types.hpp"
 #include "../gui/basis.hpp"
-#include "pixel_buffer.hpp"
 
 namespace nana
 {
@@ -72,12 +71,16 @@ namespace nana
 		class graphics
 		{
 		public:
-			typedef ::nana::native_window_type native_window_type;
-
 			graphics();
 			graphics(const ::nana::size&);                 ///< size in pixel
 			graphics(const graphics&);      ///< the resource is not copyed, the two graphics objects refer to the *SAME* resource
 			graphics& operator=(const graphics&);
+
+			graphics(graphics&&);
+			graphics& operator=(graphics&&);
+
+			~graphics();
+
 			bool changed() const;           ///< Returns true if the graphics object is operated
 			bool empty() const;             ///< Returns true if the graphics object does not refer to any resource.
 			operator const void*() const;
@@ -129,7 +132,7 @@ namespace nana
 
 			void flush();
 
-			unsigned width() const;
+			unsigned width() const;		///< Returns the width of the off-screen buffer.
 			unsigned height() const;	///< Returns the height of the off-screen buffer.
 			::nana::size size() const;
 			void setsta();				///< Clears the status if the graphics object had been changed
@@ -172,12 +175,8 @@ namespace nana
 			void gradual_rectangle(const ::nana::rectangle&, const color& from, const color& to, bool vertical);
 			void round_rectangle(const ::nana::rectangle&, unsigned radius_x, unsigned radius_y, const color&, bool solid, const color& color_if_solid);
 		private:
-			std::shared_ptr< ::nana::detail::drawable_impl_type> dwptr_;
+			struct implementation;
-			font			font_shadow_;
+			std::unique_ptr<implementation> impl_;
-            drawable_type	handle_;
-			::nana::size	size_;
-			pixel_buffer	pxbuf_;
-			bool changed_;
 		};
 	}//end namespace paint
 }	//end namespace nana

source/audio/detail/audio_device.cpp

@@ -184,7 +184,7 @@ namespace nana{namespace audio
 			{
 #if defined(NANA_WINDOWS)
 				std::lock_guard<decltype(queue_lock_)> lock(queue_lock_);
-				done_queue_.push_back(m);
+				done_queue_.emplace_back(m);
 				if(m->dwFlags & WHDR_PREPARED)
 					wave_native_if.out_unprepare(handle_, m, sizeof(WAVEHDR));
 

source/audio/detail/buffer_preparation.cpp

@@ -30,7 +30,7 @@ namespace nana{	namespace audio
 					m->bufsize = ck.nAvgBytesPerSec;
 					m->buf = rawbuf + sizeof(meta);
 #endif
-					prepared_.push_back(m);
+					prepared_.emplace_back(m);
 				}
 
 				thr_ = std::move(std::thread([this](){this->_m_prepare_routine();}));
@@ -79,7 +79,7 @@ namespace nana{	namespace audio
 			{
 				std::lock_guard<decltype(token_prepared_)> lock(token_prepared_);
 				bool if_signal = prepared_.empty();
-				prepared_.push_back(m);
+				prepared_.emplace_back(m);
 				if(if_signal)
 					cond_prepared_.notify_one();
 			}
@@ -148,7 +148,7 @@ namespace nana{	namespace audio
 					m->bufsize = buffered;
 #endif
 					std::lock_guard<decltype(token_buffer_)> lock(token_buffer_);
-					buffer_.push_back(m);
+					buffer_.emplace_back(m);
 					if(wait_for_buffer_)
 					{
 						cond_buffer_.notify_one();

source/detail/platform_spec_windows.cpp

@@ -16,10 +16,10 @@
 
 #if defined(NANA_WINDOWS)
 
-#include <shellapi.h>
 #include <stdexcept>
+#include <map>
 
-
+#include <shellapi.h>
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -352,7 +352,14 @@ namespace detail
 		}
 	}
 
+	struct platform_spec::implementation
+	{
+		font_ptr_t	def_font_ptr;
+		std::map<native_window_type, window_icons> iconbase;
+	};
+
 	platform_spec::platform_spec()
+		: impl_{ new implementation}
 	{
 		//Create default font object.
 		NONCLIENTMETRICS metrics = {};
@@ -370,17 +377,22 @@ namespace detail
 #endif
 #endif
 		::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof metrics, &metrics, 0);
-		def_font_ptr_ = make_native_font(to_utf8(metrics.lfMessageFont.lfFaceName).c_str(), font_size_to_height(9), 400, false, false, false);
+		impl_->def_font_ptr = make_native_font(to_utf8(metrics.lfMessageFont.lfFaceName).c_str(), font_size_to_height(9), 400, false, false, false);
+	}
+
+	platform_spec::~platform_spec()
+	{
+		delete impl_;
 	}
 
 	const platform_spec::font_ptr_t& platform_spec::default_native_font() const
 	{
-		return def_font_ptr_;
+		return impl_->def_font_ptr;
 	}
 
 	void platform_spec::default_native_font(const font_ptr_t& fp)
 	{
-		def_font_ptr_ = fp;
+		impl_->def_font_ptr = fp;
 	}
 
 	unsigned platform_spec::font_size_to_height(unsigned size) const
@@ -409,7 +421,7 @@ namespace detail
 		if (name && *name)
 			std::wcscpy(logfont.lfFaceName, to_wstring(name).c_str());
 		else
-			std::wcscpy(logfont.lfFaceName, def_font_ptr_->name.c_str());
+			std::wcscpy(logfont.lfFaceName, impl_->def_font_ptr->name.c_str());
 
 		logfont.lfCharSet = DEFAULT_CHARSET;
 		HDC hdc = ::GetDC(0);
@@ -448,14 +460,14 @@ namespace detail
 
 	void platform_spec::keep_window_icon(native_window_type wd, const paint::image& sml_icon, const paint::image& big_icon)
 	{
-		auto & icons = iconbase_[wd];
+		auto & icons = impl_->iconbase[wd];
 		icons.sml_icon = sml_icon;
 		icons.big_icon = big_icon;
 	}
 
 	void platform_spec::release_window_icon(native_window_type wd)
 	{
-		iconbase_.erase(wd);
+		impl_->iconbase.erase(wd);
 	}
 }//end namespace detail
 }//end namespace nana

source/gui/detail/basic_window.cpp

@@ -402,7 +402,7 @@ namespace nana
 					root = agrparent->root;
 					root_graph = agrparent->root_graph;
 					index = static_cast<unsigned>(agrparent->children.size());
-					agrparent->children.push_back(this);
+					agrparent->children.emplace_back(this);
 				}
 
 				predef_cursor = cursor::arrow;

source/gui/detail/bedrock_pi.cpp

@@ -600,7 +600,7 @@ namespace nana
 					{
 						root = wd->root;
 						if (roots.cend() == std::find(roots.cbegin(), roots.cend(), root))
-							roots.push_back(root);
+							roots.emplace_back(root);
 					}
 				}
 

source/gui/detail/drawer.cpp

@@ -338,7 +338,7 @@ namespace nana
 			for (auto p : data_impl_->draws)
 			{
 				if(p->diehard())
-					then.push_back(p);
+					then.emplace_back(p);
 				else
 					delete p;
 			}
@@ -351,7 +351,7 @@ namespace nana
 			if(f)
 			{
 				auto p = new dynamic_drawing::user_draw_function(std::move(f), diehard);
-				data_impl_->draws.push_back(p);
+				data_impl_->draws.emplace_back(p);
 				return (diehard ? p : nullptr);
 			}
 			return nullptr;

source/gui/detail/element_store.cpp

@@ -1,7 +1,7 @@
 /*
 *	The Store for the Storage Of Elements
 *	Nana C++ Library(http://www.nanapro.org)
-*	Copyright(C) 2003-2014 Jinhao(cnjinhao@hotmail.com)
+*	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
@@ -11,35 +11,53 @@
 */
 #include <nana/gui/detail/element_store.hpp>
 
+#include <map>
+
 namespace nana
 {
 namespace detail
 {
 	//class element_store
-	element_store::data::data()
+
-		: fast_ptr(nullptr)
+	struct element_store::data
+	{
+		cloneable_element entity;
+		::nana::element::element_interface * fast_ptr{ nullptr };
+	};
+
+	struct element_store::implementation
+	{
+		std::map<std::string, data> table;
+	};
+
+	element_store::element_store()
+		: impl_(new implementation)
+	{}
+
+	//Empty destructor for instance of impl
+	element_store::~element_store()
 	{}
 
 	nana::element::element_interface * const * element_store::bground(const std::string& name)
 	{
-		element_interface * const * addr = &(bground_.table[name].fast_ptr);
+		element_interface * const * addr = &(impl_->table[name].fast_ptr);
 		return addr;
 	}
 
 	void element_store::bground(const std::string& name, const pat::cloneable<element_interface>& rhs)
 	{
-		auto & store = bground_.table[name];
+		auto & store = impl_->table[name];
 
-		store.object = rhs;
+		store.entity = rhs;
-		store.fast_ptr = store.object.get();
+		store.fast_ptr = store.entity.get();
 	}
 
 	void element_store::bground(const std::string& name, pat::cloneable<element_interface>&& rv)
 	{
-		auto & store = bground_.table[name];
+		auto & store = impl_->table[name];
 
-		store.object = std::move(rv);
+		store.entity = std::move(rv);
-		store.fast_ptr = store.object.get();
+		store.fast_ptr = store.entity.get();
 	}
 }//end namespace detail
 }

source/gui/detail/window_layout.cpp

@@ -221,8 +221,8 @@ namespace nana
 							continue;
 
 						core_window_t * term = ((i + 1 != layers_rend) ? *(i + 1) : wd);
-						r.x = wd->pos_root.x - pre->pos_root.x;
+						r.position(wd->pos_root - pre->pos_root);
-						r.y = wd->pos_root.y - pre->pos_root.y;
+
 						for (auto child : pre->children)
 						{
 							if (child->index >= term->index)
@@ -253,7 +253,7 @@ namespace nana
 					if (child->visible && overlap(r_of_wd, rectangle{ child->pos_owner, child->dimension }, ovlp))
 					{
 						if (category::flags::lite_widget != child->other.category)
-							glass_buffer.bitblt(nana::rectangle{ ovlp.x - wd->pos_owner.x, ovlp.y - wd->pos_owner.y, ovlp.width, ovlp.height }, child->drawer.graphics, nana::point(ovlp.x - child->pos_owner.x, ovlp.y - child->pos_owner.y));
+							glass_buffer.bitblt(nana::rectangle{ ovlp.x - wd->pos_owner.x, ovlp.y - wd->pos_owner.y, ovlp.width, ovlp.height }, child->drawer.graphics, {ovlp.position() - child->pos_owner});
 
 						ovlp.x += wd->pos_root.x;
 						ovlp.y += wd->pos_root.y;

source/gui/detail/window_manager.cpp

@@ -23,6 +23,12 @@
 #include <stdexcept>
 #include <algorithm>
 
+#if defined(STD_THREAD_NOT_SUPPORTED)
+#include <nana/std_mutex.hpp>
+#else
+#include <mutex>
+#endif
+
 namespace nana
 {
 
@@ -36,9 +42,7 @@ namespace detail
 			Key first;
 			Value second;
 
-			key_value_rep()
+			key_value_rep() = default;
-				: first{}, second{}
-			{}
 
 			key_value_rep(const Key& k)
 				: first(k), second{}
@@ -69,19 +73,9 @@ namespace detail
 			return table_.end();
 		}
 
-		iterator erase(iterator pos)
+		std::vector<key_value_rep>& table()
 		{
-			return table_.erase(pos);
+			return table_;
-		}
-
-		iterator begin()
-		{
-			return table_.begin();
-		}
-
-		iterator end()
-		{
-			return table_.end();
 		}
 	private:
 		std::vector<key_value_rep> table_;
@@ -109,27 +103,50 @@ namespace detail
 		//end struct wdm_private_impl
 
 		//class revertible_mutex
-			window_manager::revertible_mutex::revertible_mutex()
+			struct thread_refcount
 			{
-				thr_.tid = 0;
+				unsigned tid;
-				thr_.refcnt = 0;
+				std::size_t ref;
+			};
+
+			struct window_manager::revertible_mutex::implementation
+			{
+				std::recursive_mutex mutex;
+
+				thread_refcount thread;
+				std::vector<thread_refcount> invoke_stack;
+			};
+
+			window_manager::revertible_mutex::revertible_mutex()
+				: impl_(new implementation)
+			{
+				impl_->thread.tid = 0;
+				impl_->thread.ref = 0;
+			}
+
+			window_manager::revertible_mutex::~revertible_mutex()
+			{
+				delete impl_;
 			}
 
 			void window_manager::revertible_mutex::lock()
 			{
-				std::recursive_mutex::lock();
+				impl_->mutex.lock();
-				if(0 == thr_.tid)
+
-					thr_.tid = nana::system::this_thread_id();
+				if(0 == impl_->thread.tid)
-				++thr_.refcnt;
+					impl_->thread.tid = nana::system::this_thread_id();
+
+				++(impl_->thread.ref);
 			}
 
 			bool window_manager::revertible_mutex::try_lock()
 			{
-				if(std::recursive_mutex::try_lock())
+				if(impl_->mutex.try_lock())
 				{
-					if(0 == thr_.tid)
+					if (0 == impl_->thread.tid)
-						thr_.tid = nana::system::this_thread_id();
+						impl_->thread.tid = nana::system::this_thread_id();
-					++thr_.refcnt;
+
+					++(impl_->thread.ref);
 					return true;
 				}
 				return false;
@@ -137,44 +154,45 @@ namespace detail
 
 			void window_manager::revertible_mutex::unlock()
 			{
-				if(thr_.tid == nana::system::this_thread_id())
+				if(impl_->thread.tid == nana::system::this_thread_id())
-					if(0 == --thr_.refcnt)
+					if(0 == --(impl_->thread.ref))
-						thr_.tid = 0;
+						impl_->thread.tid = 0;
-				std::recursive_mutex::unlock();
+
+				impl_->mutex.unlock();
 			}
 
 			void window_manager::revertible_mutex::revert()
 			{
-				if(thr_.refcnt && (thr_.tid == nana::system::this_thread_id()))
+				if(impl_->thread.ref && (impl_->thread.tid == nana::system::this_thread_id()))
 				{
-					std::size_t cnt = thr_.refcnt;
+					std::size_t cnt = impl_->thread.ref;
 
-					stack_.push_back(thr_);
+					impl_->invoke_stack.push_back(impl_->thread);
-					thr_.tid = 0;
+					impl_->thread.tid = 0;
-					thr_.refcnt = 0;
+					impl_->thread.ref = 0;
 
 					for (std::size_t i = 0; i < cnt; ++i)
-						std::recursive_mutex::unlock();
+						impl_->mutex.unlock();
 				}
 			}
 
 			void window_manager::revertible_mutex::forward()
 			{
-				std::recursive_mutex::lock();
+				impl_->mutex.lock();
-				if(stack_.size())
+				if(impl_->invoke_stack.size())
 				{
-					auto thr = stack_.back();
+					auto thr = impl_->invoke_stack.back();
 					if(thr.tid == nana::system::this_thread_id())
 					{
-						stack_.pop_back();
+						impl_->invoke_stack.pop_back();
-						for(std::size_t i = 0; i < thr.refcnt; ++i)
+						for (std::size_t i = 0; i < thr.ref; ++i)
-							std::recursive_mutex::lock();
+							impl_->mutex.lock();
-						thr_ = thr;
+						impl_->thread = thr;
 					}
 					else
 						throw std::runtime_error("Nana.GUI: The forward is not matched.");
 				}
-				std::recursive_mutex::unlock();
+				impl_->mutex.unlock();
 			}
 		//end class revertible_mutex
 
@@ -254,23 +272,13 @@ namespace detail
 			return (impl_->wd_register.available(a) && impl_->wd_register.available(b));
 		}
 
-		bool window_manager::available(native_window_type wd)
-		{
-			if(wd)
-			{
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
-				return (impl_->misc_register.find(wd) != nullptr);
-			}
-			return false;
-		}
-
 		window_manager::core_window_t* window_manager::create_root(core_window_t* owner, bool nested, rectangle r, const appearance& app, widget* wdg)
 		{
 			native_window_type native = nullptr;
 			if (owner)
 			{
 				//Thread-Safe Required!
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 
 				if (impl_->wd_register.available(owner))
 				{
@@ -306,11 +314,10 @@ namespace detail
 				wd->title = native_interface::window_caption(result.native_handle);
 
 				//Thread-Safe Required!
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 
 				//create Root graphics Buffer and manage it
-				root_misc misc(wd, result.width, result.height);
+				auto* value = impl_->misc_register.insert(result.native_handle, root_misc(wd, result.width, result.height));
-				auto* value = impl_->misc_register.insert(result.native_handle, misc);
 
 				wd->bind_native_window(result.native_handle, result.width, result.height, result.extra_width, result.extra_height, value->root_graph);
 				impl_->wd_register.insert(wd, wd->thread_id);
@@ -331,7 +338,7 @@ namespace detail
 		window_manager::core_window_t* window_manager::create_frame(core_window_t* parent, const rectangle& r, widget* wdg)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 
 			if (impl_->wd_register.available(parent) == false)	return nullptr;
 
@@ -350,7 +357,7 @@ namespace detail
 			if(frame)
 			{
 				//Thread-Safe Required!
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 				if(category::flags::frame == frame->other.category)
 					frame->other.attribute.frame->attach.push_back(wd);
 				return true;
@@ -363,7 +370,7 @@ namespace detail
 			if(frame)
 			{
 				//Thread-Safe Required!
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 				if(category::flags::frame == frame->other.category)
 				{
 					if (impl_->wd_register.available(wd) && (category::flags::root == wd->other.category) && wd->root != frame->root)
@@ -380,7 +387,7 @@ namespace detail
 		window_manager::core_window_t* window_manager::create_widget(core_window_t* parent, const rectangle& r, bool is_lite, widget* wdg)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(parent) == false)
 				throw std::invalid_argument("invalid parent/owner handle");
 
@@ -401,7 +408,7 @@ namespace detail
 		void window_manager::close(core_window_t *wd)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd) == false)	return;
 
 			if (wd->flags.destroying)
@@ -443,7 +450,7 @@ namespace detail
 		void window_manager::destroy(core_window_t* wd)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd) == false)	return;
 
 			rectangle update_area(wd->pos_owner, wd->dimension);
@@ -467,7 +474,7 @@ namespace detail
 		void window_manager::destroy_handle(core_window_t* wd)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd) == false)	return;
 
 #ifndef WIDGET_FRAME_DEPRECATED
@@ -491,7 +498,7 @@ namespace detail
 		{
 			if(!big_icon.empty() || !small_icon.empty())
 			{
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 				if (impl_->wd_register.available(wd))
 				{
 					if(category::flags::root == wd->other.category)
@@ -505,7 +512,7 @@ namespace detail
 		bool window_manager::show(core_window_t* wd, bool visible)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (!impl_->wd_register.available(wd))
 				return false;
 
@@ -548,7 +555,7 @@ namespace detail
 			if((false == attr_.capture.ignore_children) || (nullptr == attr_.capture.window) || (attr_.capture.window->root != root))
 			{
 				//Thread-Safe Required!
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 				auto rrt = root_runtime(root);
 				point pos{ x, y };
 				if (rrt && _m_effective(rrt->window, pos))
@@ -561,7 +568,7 @@ namespace detail
 		bool window_manager::move(core_window_t* wd, int x, int y, bool passive)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd))
 			{
 				if (category::flags::root != wd->other.category)
@@ -606,7 +613,7 @@ namespace detail
 		bool window_manager::move(core_window_t* wd, const rectangle& r)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (!impl_->wd_register.available(wd))
 				return false;
 				
@@ -680,7 +687,7 @@ namespace detail
 		bool window_manager::size(core_window_t* wd, nana::size sz, bool passive, bool ask_update)
 		{	
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (!impl_->wd_register.available(wd))
 				return false;
 			
@@ -767,7 +774,7 @@ namespace detail
 			if(cache.first == wd) return cache.second;
 
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 
 			auto rrt = root_runtime(wd);
 			if(rrt)
@@ -783,7 +790,7 @@ namespace detail
 		void window_manager::map(core_window_t* wd, bool forced, const rectangle* update_area)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd) && !wd->is_draw_through())
 			{
 				auto parent = wd->parent;
@@ -805,7 +812,7 @@ namespace detail
 		bool window_manager::update(core_window_t* wd, bool redraw, bool forced, const rectangle* update_area)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd) == false) return false;
 
 			if (wd->displayed())
@@ -837,7 +844,7 @@ namespace detail
 		void window_manager::refresh_tree(core_window_t* wd)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 
 			//It's not worthy to redraw if visible is false
 			if (impl_->wd_register.available(wd) && wd->displayed())
@@ -850,7 +857,7 @@ namespace detail
 		bool window_manager::do_lazy_refresh(core_window_t* wd, bool force_copy_to_screen, bool refresh_tree)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 
 			if (false == impl_->wd_register.available(wd))
 				return false;
@@ -888,7 +895,7 @@ namespace detail
 		bool window_manager::get_graphics(core_window_t* wd, nana::paint::graphics& result)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (!impl_->wd_register.available(wd))
 				return false;
 
@@ -901,7 +908,7 @@ namespace detail
 		bool window_manager::get_visual_rectangle(core_window_t* wd, nana::rectangle& r)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			return (impl_->wd_register.available(wd) ?
 				window_layer::read_visual_rectangle(wd, r) :
 				false);
@@ -909,7 +916,7 @@ namespace detail
 
 		std::vector<window_manager::core_window_t*> window_manager::get_children(core_window_t* wd) const
 		{
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd))
 				return wd->children;
 			return{};
@@ -918,7 +925,7 @@ namespace detail
 		bool window_manager::set_parent(core_window_t* wd, core_window_t* newpa)
 		{	
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (!impl_->wd_register.available(wd))
 				return false;
 
@@ -945,7 +952,7 @@ namespace detail
 		window_manager::core_window_t* window_manager::set_focus(core_window_t* wd, bool root_has_been_focused, arg_focus::reason reason)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 
 			if (!impl_->wd_register.available(wd))
 				return nullptr;
@@ -1051,7 +1058,7 @@ namespace detail
 				if(wd != attr_.capture.window)
 				{
 					//Thread-Safe Required!
-					std::lock_guard<decltype(mutex_)> lock(mutex_);
+					std::lock_guard<mutex_type> lock(mutex_);
 
 					if (impl_->wd_register.available(wd))
 					{
@@ -1112,7 +1119,7 @@ namespace detail
 		void window_manager::enable_tabstop(core_window_t* wd)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd) && (detail::tab_type::none == wd->flags.tab))
 			{
 				wd->root_widget->other.attribute.root->tabstop.push_back(wd);
@@ -1156,7 +1163,7 @@ namespace detail
 		auto window_manager::tabstop(core_window_t* wd, bool forward) const -> core_window_t*
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (!impl_->wd_register.available(wd))
 				return nullptr;
 
@@ -1198,7 +1205,7 @@ namespace detail
 		bool window_manager::enable_effects_bground(core_window_t* wd, bool enabled)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd))
 				return window_layer::enable_effects_bground(wd, enabled);
 
@@ -1208,7 +1215,7 @@ namespace detail
 		bool window_manager::calc_window_point(core_window_t* wd, nana::point& pos)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd))
 			{
 				if(native_interface::calc_window_point(wd->root, pos))
@@ -1220,7 +1227,7 @@ namespace detail
 			return false;
 		}
 
-		root_misc* window_manager::root_runtime(native_window_type native_wd) const
+		root_misc* window_manager::root_runtime(native_window native_wd) const
 		{
 			return impl_->misc_register.find(native_wd);
 		}
@@ -1228,7 +1235,7 @@ namespace detail
 		bool window_manager::register_shortkey(core_window_t* wd, unsigned long key)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd))
 			{
 				auto object = root_runtime(wd->root);
@@ -1241,7 +1248,7 @@ namespace detail
 		void window_manager::unregister_shortkey(core_window_t* wd, bool with_children)
 		{
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd) == false) return;
 
 			auto root_rt = root_runtime(wd->root);
@@ -1261,7 +1268,7 @@ namespace detail
 			std::vector<std::pair<core_window_t*, unsigned long>> result;
 
 			//Thread-Safe Required!
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 			if (impl_->wd_register.available(wd))
 			{
 				auto root_rt = root_runtime(wd->root);
@@ -1290,7 +1297,7 @@ namespace detail
 			if(native_window)
 			{
 				//Thread-Safe Required!
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 				auto object = root_runtime(native_window);
 				if(object)
 					return reinterpret_cast<core_window_t*>(object->shortkeys.find(key));
@@ -1302,7 +1309,7 @@ namespace detail
 		{
 			if (fn)
 			{
-				std::lock_guard<decltype(mutex_)> lock(mutex_);
+				std::lock_guard<mutex_type> lock(mutex_);
 				if (!available(wd))
 					return;
 
@@ -1312,21 +1319,21 @@ namespace detail
 
 		void window_manager::call_safe_place(unsigned thread_id)
 		{
-			std::lock_guard<decltype(mutex_)> lock(mutex_);
+			std::lock_guard<mutex_type> lock(mutex_);
 
-			for (auto i = impl_->safe_place.begin(); i != impl_->safe_place.end();)
+			auto& safe_place = impl_->safe_place.table();
+			for (auto i = safe_place.begin(); i != safe_place.end();)
 			{
 				if (i->first->thread_id == thread_id)
 				{
 					for (auto & fn : i->second)
 						fn();
 
-					i = impl_->safe_place.erase(i);
+					i = safe_place.erase(i);
 				}
 				else
 					++i;
 			}
-
 		}
 
 		bool check_tree(basic_window* wd, basic_window* const cond)

source/gui/dragger.cpp

@@ -159,7 +159,7 @@ namespace nana
 				}
 			});
 
-			triggers_.push_back(tg);
+			triggers_.emplace_back(tg);
 		}
 	private:
 		static void _m_check_restrict_area(nana::point & pos, const nana::size & size, const nana::rectangle& restr_area)

source/gui/element.cpp

@@ -15,7 +15,6 @@
 #include <nana/gui/detail/element_store.hpp>
 #include <nana/paint/image.hpp>
 #include <map>
-#include <string>
 
 #if defined(STD_THREAD_NOT_SUPPORTED)
 	#include <nana/std_mutex.hpp>
@@ -599,7 +598,6 @@ namespace nana
 	{
 		using element_type		= ElementInterface;
 		using factory_interface = pat::cloneable<element::detail::factory_abstract>;
-
 	public:
 		~element_object()
 		{
@@ -1156,46 +1154,48 @@ namespace nana
 			}
 		};
 
+
+		struct bground::implementation
+		{
+			draw_method * method{ nullptr };
+
+			bool		vert{ false };
+			rectangle	valid_area;
+			std::vector<element_state> states;
+			std::map<element_state, element_state> join;
+
+			bool		stretch_all{ true };
+			unsigned	left{ 0 }, top{ 0 }, right{ 0 }, bottom{ 0 };
+		};
+
+
 		bground::bground()
-			:	method_(nullptr),
+			: impl_{ new implementation }
-				vertical_(false),
-				stretch_all_(true),
-				left_(0), top_(0), right_(0), bottom_(0)
 		{
 			reset_states();
 		}
 
 		bground::bground(const bground& rhs)
-			: method_(rhs.method_ ? rhs.method_->clone() : nullptr),
+			: impl_{ new implementation }
-			vertical_(rhs.vertical_),
-			valid_area_(rhs.valid_area_),
-			states_(rhs.states_),
-			join_(rhs.join_),
-			stretch_all_(rhs.stretch_all_),
-			left_(rhs.left_), top_(rhs.top_), right_(rhs.right_), bottom_(rhs.bottom_)
 		{
+			if (impl_->method)
+				impl_->method = impl_->method->clone();
 		}
 
 		bground::~bground()
 		{
-			delete method_;
+			delete impl_->method;
 		}
 
 		bground& bground::operator=(const bground& rhs)
 		{
 			if (this != &rhs)
 			{
-				delete method_;
+				delete impl_->method;
-				method_		= (rhs.method_ ? rhs.method_->clone() : nullptr);
+
-				vertical_	= rhs.vertical_;
+				impl_.reset(new implementation(*rhs.impl_));
-				valid_area_ = rhs.valid_area_;
+				if (impl_->method)
-				states_ = rhs.states_;
+					impl_->method = impl_->method->clone();
-				join_ = rhs.join_;
-				stretch_all_ = rhs.stretch_all_;
-				left_	= rhs.left_;
-				top_	= rhs.top_;
-				right_	= rhs.right_;
-				bottom_	= rhs.bottom_;
 			}
 			return *this;
 		}
@@ -1203,106 +1203,110 @@ namespace nana
 		//Set a picture for the background
 		bground& bground::image(const paint::image& img, bool vertical, const nana::rectangle& valid_area)
 		{
-			delete method_;
+			delete impl_->method;
-			method_ = new draw_image(img);
+			impl_->method = new draw_image(img);
-			vertical_ = vertical;
+			impl_->vert = vertical;
 
 			if (valid_area.width && valid_area.height)
-				valid_area_ = valid_area;
+				impl_->valid_area = valid_area;
 			else
-				valid_area_ = nana::rectangle(img.size());
+				impl_->valid_area = nana::rectangle(img.size());
 			return *this;
 		}
 
 		bground& bground::image(const paint::graphics& graph, bool vertical, const nana::rectangle& valid_area)
 		{
-			delete method_;
+			delete impl_->method;
-			method_ = new draw_graph(graph);
+			impl_->method = new draw_graph(graph);
-			vertical_ = vertical;
+			impl_->vert = vertical;
 
 			if (valid_area.width && valid_area.height)
-				valid_area_ = valid_area;
+				impl_->valid_area = valid_area;
 			else
-				valid_area_ = nana::rectangle(graph.size());
+				impl_->valid_area = nana::rectangle(graph.size());
 			return *this;
 		}
 
 		//Set the state sequence of the background picture.
 		void bground::states(const std::vector<element_state> & s)
 		{
-			states_ = s;
+			impl_->states = s;
 		}
 
 		void bground::states(std::vector<element_state> && s)
 		{
-			states_ = std::move(s);
+			impl_->states = std::move(s);
 		}
 
 		void bground::reset_states()
 		{
-			states_.clear();
+			auto & st = impl_->states;
-			states_.push_back(element_state::normal);
+
-			states_.push_back(element_state::hovered);
+			st.clear();
-			states_.push_back(element_state::focus_normal);
+			st.push_back(element_state::normal);
-			states_.push_back(element_state::focus_hovered);
+			st.push_back(element_state::hovered);
-			states_.push_back(element_state::pressed);
+			st.push_back(element_state::focus_normal);
-			states_.push_back(element_state::disabled);
+			st.push_back(element_state::focus_hovered);
-			join_.clear();
+			st.push_back(element_state::pressed);
+			st.push_back(element_state::disabled);
+			impl_->join.clear();
 		}
 
 		void bground::join(element_state target, element_state joiner)
 		{
-			join_[joiner] = target;
+			impl_->join[joiner] = target;
 		}
 
 		void bground::stretch_parts(unsigned left, unsigned top, unsigned right, unsigned bottom)
 		{
-			left_ = left;
+			impl_->left = left;
-			top_ = top;
+			impl_->right = right;
-			right_ = right;
+			impl_->top = top;
-			bottom_ = bottom;
+			impl_->bottom = bottom;
 
-			stretch_all_ = !(left || right || top || bottom);
+			impl_->stretch_all = !(left || right || top || bottom);
 		}
 
 		//Implement the methods of bground_interface.
 		bool bground::draw(graph_reference dst, const ::nana::color&, const ::nana::color&, const nana::rectangle& to_r, element_state state)
 		{
-			if (nullptr == method_)
+			const auto method = impl_->method;
+
+			if (nullptr == method)
 				return false;
 
-			auto mi = join_.find(state);
+			auto mi = impl_->join.find(state);
-			if (mi != join_.end())
+			if (mi != impl_->join.end())
 				state = mi->second;
 
 			std::size_t pos = 0;
-			for (; pos < states_.size(); ++pos)
+			for (; pos < impl_->states.size(); ++pos)
 			{
-				if (states_[pos] == state)
+				if (impl_->states[pos] == state)
 					break;
 			}
 
-			if (pos == states_.size())
+			if (pos == impl_->states.size())
 				return false;
 
-			nana::rectangle from_r = valid_area_;
+			nana::rectangle from_r = impl_->valid_area;
-			if (vertical_)
+			if (impl_->vert)
 			{
-				from_r.height /= static_cast<unsigned>(states_.size());
+				from_r.height /= static_cast<unsigned>(impl_->states.size());
 				from_r.y += static_cast<int>(from_r.height * pos);
 			}
 			else
 			{
-				from_r.width /= static_cast<unsigned>(states_.size());
+				from_r.width /= static_cast<unsigned>(impl_->states.size());
 				from_r.x += static_cast<int>(from_r.width * pos);
 			}
 
-			if (stretch_all_)
+			if (impl_->stretch_all)
 			{
 				if (from_r.width == to_r.width && from_r.height == to_r.height)
-					method_->paste(from_r, dst, to_r.position());
+					method->paste(from_r, dst, to_r.position());
 				else
-					method_->stretch(from_r, dst, to_r);
+					method->stretch(from_r, dst, to_r);
 
 				return true;
 			}
@@ -1311,118 +1315,123 @@ namespace nana
 			auto perf_from_r = from_r;
 			auto perf_to_r = to_r;
 
-			if (left_ + right_ < to_r.width)
+			const auto left = impl_->left;
+			const auto right = impl_->right;
+			const auto top = impl_->top;
+			const auto bottom = impl_->bottom;
+
+			if (left + right < to_r.width)
 			{
 				nana::rectangle src_r = from_r;
-				src_r.y += static_cast<int>(top_);
+				src_r.y += static_cast<int>(top);
-				src_r.height -= top_ + bottom_;
+				src_r.height -= top + bottom;
 
 				nana::rectangle dst_r = to_r;
-				dst_r.y += static_cast<int>(top_);
+				dst_r.y += static_cast<int>(top);
-				dst_r.height -= top_ + bottom_;
+				dst_r.height -= top + bottom;
 
-				if (left_)
+				if (left)
 				{
-					src_r.width = left_;
+					src_r.width = left;
-					dst_r.width = left_;
+					dst_r.width = left;
 
-					method_->stretch(src_r, dst, dst_r);
+					method->stretch(src_r, dst, dst_r);
 
-					perf_from_r.x += static_cast<int>(left_);
+					perf_from_r.x += static_cast<int>(left);
-					perf_from_r.width -= left_;
+					perf_from_r.width -= left;
-					perf_to_r.x += static_cast<int>(left_);
+					perf_to_r.x += static_cast<int>(left);
-					perf_to_r.width -= left_;
+					perf_to_r.width -= left;
 				}
 
-				if (right_)
+				if (right)
 				{
-					src_r.x += (static_cast<int>(from_r.width) - static_cast<int>(right_));
+					src_r.x += (static_cast<int>(from_r.width) - static_cast<int>(right));
-					src_r.width = right_;
+					src_r.width = right;
 
-					dst_r.x += (static_cast<int>(to_r.width) - static_cast<int>(right_));
+					dst_r.x += (static_cast<int>(to_r.width) - static_cast<int>(right));
-					dst_r.width = right_;
+					dst_r.width = right;
 
-					method_->stretch(src_r, dst, dst_r);
+					method->stretch(src_r, dst, dst_r);
 
-					perf_from_r.width -= right_;
+					perf_from_r.width -= right;
-					perf_to_r.width -= right_;
+					perf_to_r.width -= right;
 				}
 			}
 
-			if (top_ + bottom_ < to_r.height)
+			if (top + bottom < to_r.height)
 			{
 				nana::rectangle src_r = from_r;
-				src_r.x += static_cast<int>(left_);
+				src_r.x += static_cast<int>(left);
-				src_r.width -= left_ + right_;
+				src_r.width -= left + right;
 
 				nana::rectangle dst_r = to_r;
-				dst_r.x += static_cast<int>(left_);
+				dst_r.x += static_cast<int>(left);
-				dst_r.width -= left_ + right_;
+				dst_r.width -= left + right;
 
-				if (top_)
+				if (top)
 				{
-					src_r.height = top_;
+					src_r.height = top;
-					dst_r.height = top_;
+					dst_r.height = top;
 
-					method_->stretch(src_r, dst, dst_r);
+					method->stretch(src_r, dst, dst_r);
 
-					perf_from_r.y += static_cast<int>(top_);
+					perf_from_r.y += static_cast<int>(top);
-					perf_to_r.y += static_cast<int>(top_);
+					perf_to_r.y += static_cast<int>(top);
 				}
 
-				if (bottom_)
+				if (bottom)
 				{
-					src_r.y += static_cast<int>(from_r.height - bottom_);
+					src_r.y += static_cast<int>(from_r.height - bottom);
-					src_r.height = bottom_;
+					src_r.height = bottom;
 
-					dst_r.y += static_cast<int>(to_r.height - bottom_);
+					dst_r.y += static_cast<int>(to_r.height - bottom);
-					dst_r.height = bottom_;
+					dst_r.height = bottom;
 
-					method_->stretch(src_r, dst, dst_r);
+					method->stretch(src_r, dst, dst_r);
 				}
 
-				perf_from_r.height -= (top_ + bottom_);
+				perf_from_r.height -= (top + bottom);
-				perf_to_r.height -= (top_ + bottom_);
+				perf_to_r.height -= (top + bottom);
 			}
 
-			if (left_)
+			if (left)
 			{
 				nana::rectangle src_r = from_r;
-				src_r.width = left_;
+				src_r.width = left;
-				if (top_)
+				if (top)
 				{
-					src_r.height = top_;
+					src_r.height = top;
-					method_->paste(src_r, dst, to_r.position());
+					method->paste(src_r, dst, to_r.position());
 				}
-				if (bottom_)
+				if (bottom)
 				{
-					src_r.y += static_cast<int>(from_r.height) - static_cast<int>(bottom_);
+					src_r.y += static_cast<int>(from_r.height) - static_cast<int>(bottom);
-					src_r.height = bottom_;
+					src_r.height = bottom;
-					method_->paste(src_r, dst, nana::point(to_r.x, to_r.y + static_cast<int>(to_r.height - bottom_)));
+					method->paste(src_r, dst, nana::point(to_r.x, to_r.y + static_cast<int>(to_r.height - bottom)));
 				}
 			}
 
-			if (right_)
+			if (right)
 			{
-				const int to_x = to_r.x + int(to_r.width - right_);
+				const int to_x = to_r.x + int(to_r.width - right);
 
 				nana::rectangle src_r = from_r;
-				src_r.x += static_cast<int>(src_r.width) - static_cast<int>(right_);
+				src_r.x += static_cast<int>(src_r.width) - static_cast<int>(right);
-				src_r.width = right_;
+				src_r.width = right;
-				if (top_)
+				if (top)
 				{
-					src_r.height = top_;
+					src_r.height = top;
-					method_->paste(src_r, dst, nana::point(to_x, to_r.y));
+					method->paste(src_r, dst, nana::point(to_x, to_r.y));
 				}
-				if (bottom_)
+				if (bottom)
 				{
-					src_r.y += (static_cast<int>(from_r.height) - static_cast<int>(bottom_));
+					src_r.y += (static_cast<int>(from_r.height) - static_cast<int>(bottom));
-					src_r.height = bottom_;
+					src_r.height = bottom;
-					method_->paste(src_r, dst, nana::point(to_x, to_r.y + int(to_r.height - bottom_)));
+					method->paste(src_r, dst, nana::point(to_x, to_r.y + int(to_r.height - bottom)));
 				}
 			}
 
-			method_->stretch(perf_from_r, dst, perf_to_r);
+			method->stretch(perf_from_r, dst, perf_to_r);
 			return true;
 		}
 		//end class bground

source/gui/place.cpp

@@ -661,13 +661,14 @@ namespace nana
 				//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);
 
-					auto right = div_next;
+					//Right field of splitterbar
-					if (right && !right->display)
+					if (div_next && !div_next->display)
-						right->set_display(true);
+						div_next->set_display(true);
 				}
 			}
 		}

source/gui/programming_interface.cpp

@@ -104,7 +104,7 @@ namespace API
 			{
 				if (iwd->effect.edge_nimbus == effects::edge_nimbus::none)
 				{
-					cont.push_back(basic_window::edge_nimbus_action{ iwd, false});
+					cont.emplace_back(basic_window::edge_nimbus_action{ iwd, false});
 				}
 				iwd->effect.edge_nimbus = static_cast<effects::edge_nimbus>(static_cast<unsigned>(en) | static_cast<unsigned>(iwd->effect.edge_nimbus));
 			}
@@ -365,7 +365,7 @@ namespace API
 					}
 
 					if (!exists)
-						roots.push_back(root);
+						roots.emplace_back(root);
 				}
 			}
 
@@ -401,7 +401,7 @@ namespace API
 					}
 
 					if (!exists)
-						roots.push_back(root);
+						roots.emplace_back(root);
 				}
 			}
 

source/gui/timer.cpp

@@ -47,8 +47,7 @@ namespace nana
 
 		friend class timer_core;
 
-		timer_driver()
+		timer_driver() = default;
-		{}
 	public:
 		static timer_driver& instance()
 		{

source/gui/tooltip.cpp

@@ -60,7 +60,7 @@ namespace nana
 				typedef widget_object<category::root_tag, drawer> base_type;
 			public:
 				tip_form()
-					:	base_type(nana::rectangle(), appear::bald<appear::floating>()),
+					:	base_type(nullptr, false, rectangle(), appear::bald<appear::floating>()),
 						duration_(0)
 				{
 					API::take_active(this->handle(), false, nullptr);

source/gui/widgets/checkbox.cpp

@@ -285,8 +285,7 @@ namespace nana{ namespace drawerbase
 				}
 			});
 			
-
+			ui_container_.emplace_back(el);
-			ui_container_.push_back(el);
 		}
 
 		std::size_t radio_group::checked() const

source/gui/widgets/combox.cpp

@@ -174,7 +174,7 @@ namespace nana
 						editor_->show_caret(enb);
 						if (!enb)
 						{
-							editor_->ext_renderer().background = [this](graph_reference graph, const ::nana::rectangle&, const ::nana::color&)
+							editor_->customized_renderers().background = [this](graph_reference graph, const ::nana::rectangle&, const ::nana::color&)
 							{
 								auto clr_from = colors::button_face_shadow_start;
 								auto clr_to = colors::button_face_shadow_end;
@@ -190,7 +190,7 @@ namespace nana
 							};
 						}
 						else
-							editor_->ext_renderer().background = nullptr;
+							editor_->customized_renderers().background = nullptr;
 
 						editor_->enable_background(enb);
 						editor_->enable_background_counterpart(!enb);

source/gui/widgets/float_listbox.cpp

@@ -13,6 +13,8 @@
 #include <nana/gui/widgets/float_listbox.hpp>
 #include <nana/gui/widgets/scroll.hpp>
 
+#include <nana/gui/layout_utility.hpp>
+
 namespace nana
 {
 	namespace drawerbase{
@@ -66,35 +68,7 @@ namespace nana
 						unsigned vpix = (r.height - 4);
 						if(item->image())
 						{
-							nana::size imgsz = item->image().size();
+							auto imgsz = nana::fit_zoom(item->image().size(), {image_pixels_, vpix});
-							if(imgsz.width > image_pixels_)
-							{
-								unsigned new_h = image_pixels_ * imgsz.height / imgsz.width;
-								if(new_h > vpix)
-								{
-									imgsz.width = vpix * imgsz.width / imgsz.height;
-									imgsz.height = vpix;
-								}
-								else
-								{
-									imgsz.width = image_pixels_;
-									imgsz.height = new_h;
-								}
-							}
-							else if(imgsz.height > vpix)
-							{
-								unsigned new_w = vpix * imgsz.width / imgsz.height;
-								if(new_w > image_pixels_)
-								{
-									imgsz.height = image_pixels_ * imgsz.height / imgsz.width;
-									imgsz.width = image_pixels_;
-								}
-								else
-								{
-									imgsz.height = vpix;
-									imgsz.width = new_w;
-								}
-							}
 
 							nana::point to_pos(x, r.y + 2);
 							to_pos.x += (image_pixels_ - imgsz.width) / 2;

source/gui/widgets/label.cpp

@@ -206,15 +206,13 @@ namespace nana
 				{
 					if(fbp->target.size() || fbp->url.size())
 					{
-						traceable tr;
+						traceable_.emplace_back();
+						auto & tr = traceable_.back();
 						tr.r.x = x;
 						tr.r.y = y;
-						tr.r.width = sz.width;
+						tr.r.dimension(sz);
-						tr.r.height = sz.height;
 						tr.target = fbp->target;
 						tr.url = fbp->url;
-
-						traceable_.push_back(tr);
 					}
 				}
 
@@ -331,7 +329,7 @@ namespace nana
 						px.pixels = def_line_pixels;
 						px.x_base = 0;
 
-						rs.pixels.push_back(px);
+						rs.pixels.emplace_back(px);
 
 						return 0;
 					}
@@ -374,7 +372,7 @@ namespace nana
 							if(max_ascent < as)		max_ascent = as;
 							if(max_descent < ds)	max_descent = ds;
 							if(max_px < sz.height)	max_px = sz.height;
-							line_values.push_back(i);
+							line_values.emplace_back(i);
 						}
 						else
 						{
@@ -393,13 +391,13 @@ namespace nana
 								px.baseline = max_ascent;
 								px.values.swap(line_values);
 
-								rs.pixels.push_back(px);
+								rs.pixels.emplace_back(px);
 
 								w = sz.width;
 								max_px = sz.height;
 								max_ascent = as;
 								max_descent = ds;
-								line_values.push_back(i);
+								line_values.emplace_back(i);
 							}
 							else
 							{
@@ -409,9 +407,9 @@ namespace nana
 								px.pixels = sz.height;
 								px.baseline = as;
 
-								px.values.push_back(i);
+								px.values.emplace_back(i);
 
-								rs.pixels.push_back(px);
+								rs.pixels.emplace_back(px);
 								max_px = 0;
 								max_ascent = max_descent = 0;
 							}
@@ -432,7 +430,7 @@ namespace nana
 						px.pixels = max_px;
 						px.baseline = max_ascent;
 						px.values.swap(line_values);
-						rs.pixels.push_back(px);
+						rs.pixels.emplace_back(px);
 					}
 					return total_w;
 				}

source/gui/widgets/listbox.cpp

@@ -32,6 +32,7 @@
 #include <nana/system/dataexch.hpp>
 #include <cassert>
 #include <mutex>
+#include <map>
 
 namespace nana
 {
@@ -972,6 +973,7 @@ namespace nana
 
 					if (catobj.model_ptr)
 					{
+						throw_if_immutable_model(catobj.model_ptr.get());
 						auto container = catobj.model_ptr->container();
 						std::size_t item_index;
 						//
@@ -1249,28 +1251,17 @@ namespace nana
 					return n;
 				}
 
-				std::vector<cell>& get_cells(category_t * cat, std::size_t pos) const
+				std::vector<cell> get_cells(category_t * cat, std::size_t pos) const
 				{
 					if (!cat)
 						throw std::out_of_range("nana::listbox: category is null");
 
 					if (cat->model_ptr)
-						throw std::runtime_error("nana::listbox disallow to get item cells, because there are model cells");
+						return cat->model_ptr->container()->to_cells(pos);
 
 					return *(cat->items.at(pos).cells);
 				}
 
-				std::vector<cell> get_model_cells(category_t* cat, std::size_t pos) const
-				{
-					if (!cat)
-						throw std::out_of_range("nana::listbox: category is null");
-
-					if (!(cat->model_ptr))
-						throw std::runtime_error("nana::listbox: the category hasn't a model");
-
-					return cat->model_ptr->container()->to_cells(pos);
-				}
-
 				void text(category_t* cat, size_type pos, size_type col, cell&& cl, size_type columns)
 				{
 					if ((col < columns) && (pos < cat->items.size()))
@@ -2868,8 +2859,8 @@ namespace nana
 				return *this;
 			}
 
-			iresolver::iresolver(const std::vector<cell>& cl)
+			iresolver::iresolver(std::vector<cell> cl)
-				: cells_(cl)
+				: cells_(std::move(cl))
 			{}
 
 			iresolver& iresolver::operator>>(cell& cl)
@@ -4565,14 +4556,6 @@ namespace nana
 
 				std::string item_proxy::text(size_type col) const
 				{
-					if (cat_->model_ptr)
-					{
-						auto cells = cat_->model_ptr->container()->to_cells(pos_.item);
-						if (col < cells.size())
-							return cells[col].text;
-
-						return{};
-					}
 					return ess_->lister.get_cells(cat_, pos_.item).at(col).text;
 				}
 
@@ -4692,7 +4675,7 @@ namespace nana
 					return pos_;
 				}
 
-				auto item_proxy::_m_cells() const -> std::vector<cell>&
+				auto item_proxy::_m_cells() const -> std::vector<cell>
 				{
 					return ess_->lister.get_cells(cat_, pos_.item);
 				}
@@ -5027,9 +5010,24 @@ namespace nana
 
 					internal_scope_guard lock;
 
+					if (cat_->model_ptr)
+					{
+						es_lister::throw_if_immutable_model(cat_->model_ptr.get());
+
+						auto container = cat_->model_ptr->container();
+	
+						auto item_index = container->size();
+						cat_->items.emplace_back();
+						container->emplace_back();
+
+						container->assign(item_index, cells);
+					}
+					else
+					{
 						cat_->sorted.push_back(cat_->items.size());
 						cells.resize(columns());
 						cat_->items.emplace_back(std::move(cells));
+					}
 
 					assign_colors_for_last(ess_, cat_);
 				}

source/gui/widgets/menu.cpp

@@ -18,6 +18,7 @@
 #include <nana/gui/wvl.hpp>
 #include <nana/paint/text_renderer.hpp>
 #include <cctype>	//introduces tolower
+#include <map>
 
 namespace nana
 {

source/gui/widgets/slider.cpp

@@ -1,5 +1,6 @@
 
 #include <nana/gui/widgets/slider.hpp>
+#include <nana/paint/pixel_buffer.hpp>
 #include <cstring>	//memcpy
 
 namespace nana
@@ -645,7 +646,6 @@ namespace nana
 					{
 						adorn.bound.x = static_cast<int>(attr_.adorn_pos + attr_.slider.border_weight + bar.area.y);
 						adorn.bound.y = static_cast<int>(graph.height()) - static_cast<int>(attr_.slider.border_weight + bar.area.y);
-						//adorn.bound.x = 
 					}
 					else
 					{

source/gui/widgets/textbox.cpp

@@ -65,7 +65,6 @@ namespace drawerbase {
 		{
 			auto wd = wdg.handle();
 			widget_ = &wdg;
-			evt_agent_.reset(new event_agent(static_cast<::nana::textbox&>(wdg), editor_->text_position()));
 
 			auto scheme = API::dev::get_scheme(wdg);
 
@@ -73,6 +72,8 @@ namespace drawerbase {
 			editor_->textbase().set_event_agent(evt_agent_.get());
 			editor_->set_event(evt_agent_.get());
 
+			evt_agent_.reset(new event_agent(static_cast<::nana::textbox&>(wdg), editor_->text_position()));
+
 			_m_text_area(graph.width(), graph.height());
 
 			API::tabstop(wd);

source/gui/widgets/treebox.cpp

@@ -15,6 +15,7 @@
 #include <nana/gui/layout_utility.hpp>
 #include <nana/system/platform.hpp>
 #include <stdexcept>
+#include <map>
 
 namespace nana
 {

source/internationalization.cpp

@@ -13,7 +13,7 @@
 #include <nana/push_ignore_diagnostic>
 
 #include <nana/internationalization.hpp>
-#include <nana/gui/widgets/widget.hpp>
+#include <nana/gui/programming_interface.hpp>
 #include <unordered_map>
 #include <fstream>
 
@@ -486,32 +486,22 @@ namespace nana
 
 	void i18n_eval::_m_add_args(std::string& str)
 	{
-		args_.emplace_back(new arg_string(nana::charset(str)));
+		args_.emplace_back(new arg_string(str));
 	}
 
 	void i18n_eval::_m_add_args(const std::string& str)
 	{
-		args_.emplace_back(new arg_string(nana::charset(str)));
+		args_.emplace_back(new arg_string(str));
 	}
 
 	void i18n_eval::_m_add_args(std::string&& str)
 	{
-		args_.emplace_back(new arg_string(nana::charset(std::move(str))));
+		args_.emplace_back(new arg_string(std::move(str)));
-	}
-
-	void i18n_eval::_m_add_args(std::wstring& str)
-	{
-		args_.emplace_back(new arg_string(nana::charset(str)));
 	}
 
 	void i18n_eval::_m_add_args(const std::wstring& str)
 	{
-		args_.emplace_back(new arg_string(nana::charset(str)));
+		args_.emplace_back(new arg_string(to_utf8(str)));
-	}
-
-	void i18n_eval::_m_add_args(std::wstring&& str)
-	{
-		args_.emplace_back(new arg_string(nana::charset(std::move(str))));
 	}
 	//end class i18n_eval
 }

source/paint/graphics.cpp

@@ -194,76 +194,106 @@ namespace paint
 	//end class font
 
 	//class graphics
+		struct graphics::implementation
+		{
+			std::shared_ptr<::nana::detail::drawable_impl_type> platform_drawable;
+			font			font_shadow;
+			drawable_type	handle{ nullptr };
+			::nana::size	size;
+			pixel_buffer	pxbuf;
+			bool changed{ false };
+		};
+
 		graphics::graphics()
-			:handle_(nullptr), changed_(false)
+			: impl_(new implementation)
 		{}
 
 		graphics::graphics(const nana::size& sz)
-			:handle_(nullptr), changed_(true)
+			: impl_(new implementation)
 		{
 			make(sz);
 		}
 
 		graphics::graphics(const graphics& rhs)
-			:dwptr_(rhs.dwptr_), handle_(rhs.handle_), size_(rhs.size_), changed_(true)
+			: impl_(new implementation(*rhs.impl_))
 		{}
 
 		graphics& graphics::operator=(const graphics& rhs)
 		{
 			if(this != &rhs)
 			{
-				size_ = rhs.size_;
+				*impl_ = *rhs.impl_;
-				dwptr_ = rhs.dwptr_;
+				impl_->changed = true;
-				handle_ = rhs.handle_;
-				if(changed_ == false) changed_ = true;
 			}
 			return *this;
 		}
 
-		bool graphics::changed() const
+
+		graphics::graphics(graphics&& other)
+			: impl_(std::move(other.impl_))
 		{
-			return this->changed_;
 		}
 
-		bool graphics::empty() const { return (handle_ == nullptr); }
+		graphics& graphics::operator=(graphics&& other)
+		{
+			if (this != &other)
+				impl_ = std::move(other.impl_);
+
+			return *this;
+		}
+
+		graphics::~graphics()
+		{
+			//For instance of unique_ptr pimpl
+		}
+
+		bool graphics::changed() const
+		{
+			return impl_->changed;
+		}
+
+		bool graphics::empty() const
+		{
+			return (!impl_->handle);
+		}
 
 		graphics::operator const void *() const
 		{
-			return handle_;
+			return impl_->handle;
 		}
 
 		drawable_type graphics::handle() const
 		{
-			return handle_;
+			return impl_->handle;
 		}
 
 		const void* graphics::pixmap() const
 		{
 			//The reinterpret_cast is used for same platform. Under Windows, the type
 			//of pixmap can be conversed into void* directly, but under X11, the type is not a pointer.
-			return (handle_? reinterpret_cast<void*>(handle_->pixmap) : nullptr);
+			return (impl_->handle ? reinterpret_cast<void*>(impl_->handle->pixmap) : nullptr);
 		}
 
 		const void* graphics::context() const
 		{
-			return (handle_? handle_->context : nullptr);
+			return (impl_->handle ? impl_->handle->context : nullptr);
 		}
 
 		void graphics::make(const ::nana::size& sz)
 		{
-			if(handle_ == nullptr || size_ != sz)
+			if(impl_->handle == nullptr || impl_->size != sz)
 			{
 				//The object will be delete while dwptr_ is performing a release.
 				drawable_type dw = new nana::detail::drawable_impl_type;
 				//Reuse the old font
-				if(dwptr_)
+				if(impl_->platform_drawable)
 				{
-					drawable_type reuse = dwptr_.get();
+					drawable_type reuse = impl_->platform_drawable.get();
 					dw->font = reuse->font;
 					dw->string.tab_length = reuse->string.tab_length;
 				}
 				else
-					dw->font = font_shadow_.impl_->font_ptr;
+					dw->font = impl_->font_shadow.impl_->font_ptr;
 
 #if defined(NANA_WINDOWS)
 				HDC hdc = ::GetDC(0);
@@ -319,21 +349,22 @@ namespace paint
 #else
 					dw->update_text_color();
 #endif
-					dwptr_.reset(dw, detail::drawable_deleter{});
+					impl_->platform_drawable.reset(dw, detail::drawable_deleter{});
-					handle_ = dw;
+					impl_->handle = dw;
-					size_ = sz;
+					impl_->size = sz;
 
-					handle_->string.tab_pixels = detail::raw_text_extent_size(handle_, L"\t", 1).width;
+					impl_->handle->string.tab_pixels = detail::raw_text_extent_size(impl_->handle, L"\t", 1).width;
-					handle_->string.whitespace_pixels = detail::raw_text_extent_size(handle_, L" ", 1).width;
+					impl_->handle->string.whitespace_pixels = detail::raw_text_extent_size(impl_->handle, L" ", 1).width;
 				}
 			}
 
-			if(changed_ == false) changed_ = true;
+			if(impl_->changed == false)
+				impl_->changed = true;
 		}
 
 		void graphics::resize(const ::nana::size& sz)
 		{
-			graphics duplicate(*this);
+			graphics duplicate(std::move(*this));
 			make(sz);
 			bitblt(0, 0, duplicate);
 		}
@@ -342,16 +373,18 @@ namespace paint
 		{
 			//Keep the font as a shadow, even if the graphics is empty. Setting the font is futile when the size
 			//of a widget is zero.
-			font_shadow_ = f;
+			impl_->font_shadow = f;
-			if(handle_ && (false == f.empty()))
+			if(impl_->handle && (false == f.empty()))
 			{
-				handle_->font = f.impl_->font_ptr;
+				impl_->handle->font = f.impl_->font_ptr;
 #if defined(NANA_WINDOWS)
-				::SelectObject(handle_->context, reinterpret_cast<HFONT>(f.impl_->font_ptr->handle));
+				::SelectObject(impl_->handle->context, reinterpret_cast<HFONT>(f.impl_->font_ptr->handle));
 #endif
-				handle_->string.tab_pixels = detail::raw_text_extent_size(handle_, L"\t", 1).width;
+				impl_->handle->string.tab_pixels = detail::raw_text_extent_size(impl_->handle, L"\t", 1).width;
-				handle_->string.whitespace_pixels = detail::raw_text_extent_size(handle_, L" ", 1).width;
+				impl_->handle->string.whitespace_pixels = detail::raw_text_extent_size(impl_->handle, L" ", 1).width;
-				if(changed_ == false) changed_ = true;
+				
+				if (impl_->changed == false)
+					impl_->changed = true;
 			}
 		}
 
@@ -359,7 +392,7 @@ namespace paint
 		{
 			//The font may be set when the graphics is still empty.
 			//it should return the shadow font when the graphics is empty.
-			return (handle_ ? font(handle_) : font_shadow_);
+			return (impl_->handle ? font(impl_->handle) : impl_->font_shadow);
 		}
 
 		::nana::size graphics::text_extent_size(const ::std::string& text) const
@@ -385,26 +418,26 @@ namespace paint
 
 		nana::size	graphics::text_extent_size(const wchar_t* str, std::size_t len)	const
 		{
-			return detail::text_extent_size(handle_, str, len);
+			return detail::text_extent_size(impl_->handle, str, len);
 		}
 
 		nana::size	graphics::text_extent_size(const std::wstring& str, std::size_t len)	const
 		{
-			return detail::text_extent_size(handle_, str.c_str(), len);
+			return detail::text_extent_size(impl_->handle, str.c_str(), len);
 		}
 
 		nana::size graphics::glyph_extent_size(const wchar_t * str, std::size_t len, std::size_t begin, std::size_t end) const
 		{
 			if(len < end) end = len;
-			if (nullptr == handle_ || nullptr == str || 0 == len || begin >= end) return{};
+			if (nullptr == impl_->handle || nullptr == str || 0 == len || begin >= end) return{};
 
 			nana::size sz;
 #if defined(NANA_WINDOWS)
 			int * dx = new int[len];
 			SIZE extents;
-			::GetTextExtentExPoint(handle_->context, str, static_cast<int>(len), 0, 0, dx, &extents);
+			::GetTextExtentExPoint(impl_->handle->context, str, static_cast<int>(len), 0, 0, dx, &extents);
 			sz.width = dx[end - 1] - (begin ? dx[begin - 1] : 0);
-			unsigned tab_pixels = handle_->string.tab_length * handle_->string.whitespace_pixels;
+			unsigned tab_pixels = impl_->handle->string.tab_length * impl_->handle->string.whitespace_pixels;
 			const wchar_t * pend = str + end;
 			for(const wchar_t * p = str + begin; p != pend; ++p)
 			{
@@ -426,14 +459,14 @@ namespace paint
 
 		bool graphics::glyph_pixels(const wchar_t * str, std::size_t len, unsigned* pxbuf) const
 		{
-			if(nullptr == handle_ || nullptr == handle_->context || nullptr == str || nullptr == pxbuf) return false;
+			if(nullptr == impl_->handle || nullptr == impl_->handle->context || nullptr == str || nullptr == pxbuf) return false;
 			if(len == 0) return true;
 
-			unsigned tab_pixels = handle_->string.tab_length * handle_->string.whitespace_pixels;
+			unsigned tab_pixels = impl_->handle->string.tab_length * impl_->handle->string.whitespace_pixels;
 #if defined(NANA_WINDOWS)
 			int * dx = new int[len];
 			SIZE extents;
-			::GetTextExtentExPoint(handle_->context, str, static_cast<int>(len), 0, 0, dx, &extents);
+			::GetTextExtentExPoint(impl_->handle->context, str, static_cast<int>(len), 0, 0, dx, &extents);
 
 			pxbuf[0] = (str[0] == '\t' ? tab_pixels  : dx[0]);
 
@@ -445,7 +478,7 @@ namespace paint
 #elif defined(NANA_X11) && defined(NANA_USE_XFT)
 
 			Display * disp = nana::detail::platform_spec::instance().open_display();
-			XftFont * xft = handle_->font->handle;
+			XftFont * xft = impl_->handle->font->handle;
 
 			XGlyphInfo extents;
 			for(std::size_t i = 0; i < len; ++i)
@@ -466,7 +499,7 @@ namespace paint
 		nana::size	graphics::bidi_extent_size(const std::wstring& str) const
 		{
 			nana::size sz;
-			if(handle_ && handle_->context && str.size())
+			if(impl_->handle && impl_->handle->context && str.size())
 			{
 				std::vector<unicode_bidi::entity> reordered;
 				unicode_bidi bidi;
@@ -489,25 +522,25 @@ namespace paint
 
 		bool graphics::text_metrics(unsigned & ascent, unsigned& descent, unsigned& internal_leading) const
 		{
-			if(handle_)
+			if(impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
 				::TEXTMETRIC tm;
-				::GetTextMetrics(handle_->context, &tm);
+				::GetTextMetrics(impl_->handle->context, &tm);
 				ascent = static_cast<unsigned>(tm.tmAscent);
 				descent = static_cast<unsigned>(tm.tmDescent);
 				internal_leading = static_cast<unsigned>(tm.tmInternalLeading);
 				return true;
 #elif defined(NANA_X11)
-				if(handle_->font)
+				if(impl_->handle->font)
 				{
 	#if defined(NANA_USE_XFT)
-					XftFont * fs = reinterpret_cast<XftFont*>(handle_->font->handle);
+					XftFont * fs = reinterpret_cast<XftFont*>(impl_->handle->font->handle);
 					ascent = fs->ascent;
 					descent = fs->descent;
 					internal_leading = 0;
 	#else
-					XFontSet fs = reinterpret_cast<XFontSet>(handle_->font->handle);
+					XFontSet fs = reinterpret_cast<XFontSet>(impl_->handle->font->handle);
 					XFontSetExtents * ext = ::XExtentsOfFontSet(fs);
 					XFontStruct ** fontstructs;
 					char ** font_names;
@@ -532,13 +565,13 @@ namespace paint
 
 		void graphics::line_begin(int x, int y)
 		{
-			if(!handle_)	return;
+			if(!impl_->handle)	return;
 #if defined(NANA_WINDOWS)
-			::MoveToEx(handle_->context, x, y, 0);
+			::MoveToEx(impl_->handle->context, x, y, 0);
 
 #elif defined(NANA_X11)
-			handle_->line_begin_pos.x = x;
+			impl_->handle->line_begin_pos.x = x;
-			handle_->line_begin_pos.y = y;
+			impl_->handle->line_begin_pos.y = y;
 #endif
 		}
 
@@ -552,94 +585,94 @@ namespace paint
 
 		void graphics::bitblt(const nana::rectangle& r_dst, native_window_type src)
 		{
-			if(handle_)
+			if(impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
 				HDC dc = ::GetDC(reinterpret_cast<HWND>(src));
-				::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, 0, 0, SRCCOPY);
+				::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, 0, 0, SRCCOPY);
 				::ReleaseDC(reinterpret_cast<HWND>(src), dc);
 #elif defined(NANA_X11)
 				::XCopyArea(nana::detail::platform_spec::instance().open_display(),
-						reinterpret_cast<Window>(src), handle_->pixmap, handle_->context,
+						reinterpret_cast<Window>(src), impl_->handle->pixmap, impl_->handle->context,
 						0, 0, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
 #endif
-				if(changed_ == false) changed_ = true;
+				if(impl_->changed == false) impl_->changed = true;
 			}
 		}
 
 		void graphics::bitblt(const nana::rectangle& r_dst, native_window_type src, const nana::point& p_src)
 		{
-			if(handle_)
+			if(impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
 				HDC dc = ::GetDC(reinterpret_cast<HWND>(src));
-				::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, p_src.x, p_src.y, SRCCOPY);
+				::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, dc, p_src.x, p_src.y, SRCCOPY);
 				::ReleaseDC(reinterpret_cast<HWND>(src), dc);
 #elif defined(NANA_X11)
 				::XCopyArea(nana::detail::platform_spec::instance().open_display(),
-						reinterpret_cast<Window>(src), handle_->pixmap, handle_->context,
+						reinterpret_cast<Window>(src), impl_->handle->pixmap, impl_->handle->context,
 						p_src.x, p_src.y, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
 #endif
-				if(changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
 		void graphics::bitblt(const nana::rectangle& r_dst, const graphics& src)
 		{
-			if(handle_ && src.handle_)
+			if(impl_->handle && src.impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
-				::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.handle_->context, 0, 0, SRCCOPY);
+				::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.impl_->handle->context, 0, 0, SRCCOPY);
 #elif defined(NANA_X11)
 				::XCopyArea(nana::detail::platform_spec::instance().open_display(),
-						src.handle_->pixmap, handle_->pixmap, handle_->context,
+						src.impl_->handle->pixmap, impl_->handle->pixmap, impl_->handle->context,
 						0, 0, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
 #endif
-				if(changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
 		void graphics::bitblt(const nana::rectangle& r_dst, const graphics& src, const nana::point& p_src)
 		{
-			if(handle_ && src.handle_)
+			if(impl_->handle && src.impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
-				::BitBlt(handle_->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.handle_->context, p_src.x, p_src.y, SRCCOPY);
+				::BitBlt(impl_->handle->context, r_dst.x, r_dst.y, r_dst.width, r_dst.height, src.impl_->handle->context, p_src.x, p_src.y, SRCCOPY);
 #elif defined(NANA_X11)
 				::XCopyArea(nana::detail::platform_spec::instance().open_display(),
-						src.handle_->pixmap, handle_->pixmap, handle_->context,
+						src.impl_->handle->pixmap, impl_->handle->pixmap, impl_->handle->context,
 						p_src.x, p_src.y, r_dst.width, r_dst.height, r_dst.x, r_dst.y);
 #endif
-				if(changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
 		void graphics::blend(const nana::rectangle& s_r, graphics& dst, const nana::point& d_pos, double fade_rate) const
 		{
-			if(dst.handle_ && handle_ && (dst.handle_ != handle_))
+			if(dst.impl_->handle && impl_->handle && (dst.impl_->handle != impl_->handle))
 			{
 				pixel_buffer s_pixbuf;
-				s_pixbuf.attach(handle_, ::nana::rectangle{ size() });
+				s_pixbuf.attach(impl_->handle, ::nana::rectangle{ size() });
 
-				s_pixbuf.blend(s_r, dst.handle_, d_pos, fade_rate);
+				s_pixbuf.blend(s_r, dst.impl_->handle, d_pos, fade_rate);
 
-				if(dst.changed_ == false) dst.changed_ = true;
+				if(dst.impl_->changed == false) dst.impl_->changed = true;
 			}
 		}
 
 		void graphics::blur(const nana::rectangle& r, std::size_t radius)
 		{
-			if(handle_)
+			if(impl_->handle)
 			{
-				pixel_buffer pixbuf(handle_, 0, 0);
+				pixel_buffer pixbuf(impl_->handle, 0, 0);
 				pixbuf.blur(r, radius);
-				pixbuf.paste(handle_, point{});
+				pixbuf.paste(impl_->handle, point{});
 			}
 		}
 
 		void graphics::rgb_to_wb()
 		{
-			if(handle_)
+			if(impl_->handle)
 			{
 				//Create the color table for perfermance
 				float* tablebuf = new float[0x100 * 3];
@@ -654,11 +687,11 @@ namespace paint
 					table_blue[i] = (i * 0.11f);
 				}
 
-				pixel_buffer pixbuf(handle_, 0, 0);
+				pixel_buffer pixbuf(impl_->handle, 0, 0);
 
 				auto pixels = pixbuf.raw_ptr(0);
 
-				const nana::size sz = paint::detail::drawable_size(handle_);
+				const nana::size sz = paint::detail::drawable_size(impl_->handle);
 				const int rest = sz.width % 4;
 				const int length_align4 = sz.width - rest;
 
@@ -692,26 +725,26 @@ namespace paint
 				}
 				delete [] tablebuf;
 
-				pixbuf.paste(handle_, point{});
+				pixbuf.paste(impl_->handle, point{});
-				if(changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
 		void graphics::paste(graphics& dst, int x, int y) const
 		{
-			if(handle_ && dst.handle_ && handle_ != dst.handle_)
+			if(impl_->handle && dst.impl_->handle && impl_->handle != dst.impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
-				::BitBlt(dst.handle_->context, x, y, size_.width, size_.height, handle_->context, 0, 0, SRCCOPY);
+				::BitBlt(dst.impl_->handle->context, x, y, impl_->size.width, impl_->size.height, impl_->handle->context, 0, 0, SRCCOPY);
 #elif defined(NANA_X11)
 				Display* display = nana::detail::platform_spec::instance().open_display();
 				::XCopyArea(display,
-						handle_->pixmap, dst.handle_->pixmap, handle_->context,
+					impl_->handle->pixmap, dst.impl_->handle->pixmap, impl_->handle->context,
-						0, 0, size_.width, size_.height, x, y);
+						0, 0, impl_->size.width, impl_->size.height, x, y);
 
 				::XFlush(display);
 #endif
-				dst.changed_ = true;
+				dst.impl_->changed = true;
 			}
 		}
 
@@ -722,19 +755,19 @@ namespace paint
 
 		void graphics::paste(native_window_type dst, int dx, int dy, unsigned width, unsigned height, int sx, int sy) const
 		{
-			if(handle_)
+			if(impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
 				HDC dc = ::GetDC(reinterpret_cast<HWND>(dst));
 				if(dc)
 				{
-					::BitBlt(dc, dx, dy, width, height, handle_->context, sx, sy, SRCCOPY);
+					::BitBlt(dc, dx, dy, width, height, impl_->handle->context, sx, sy, SRCCOPY);
 					::ReleaseDC(reinterpret_cast<HWND>(dst), dc);
 				}
 #elif defined(NANA_X11)
 				Display * display = nana::detail::platform_spec::instance().open_display();
 				::XCopyArea(display,
-						handle_->pixmap, reinterpret_cast<Window>(dst), handle_->context,
+					impl_->handle->pixmap, reinterpret_cast<Window>(dst), impl_->handle->context,
 						sx, sy, width, height, dx, dy);
 
 				::XMapWindow(display, reinterpret_cast<Window>(dst));
@@ -745,15 +778,15 @@ namespace paint
 
 		void graphics::paste(drawable_type dst, int x, int y) const
 		{
-			if(handle_ && dst && handle_ != dst)
+			if(impl_->handle && dst && impl_->handle != dst)
 			{
 #if defined (NANA_WINDOWS)
-				::BitBlt(dst->context, x, y, size_.width, size_.height, handle_->context, 0, 0, SRCCOPY);
+				::BitBlt(dst->context, x, y, impl_->size.width, impl_->size.height, impl_->handle->context, 0, 0, SRCCOPY);
 #elif defined(NANA_X11)
 				Display * display = nana::detail::platform_spec::instance().open_display();
 				::XCopyArea(display,
-						handle_->pixmap, dst->pixmap, handle_->context,
+					impl_->handle->pixmap, dst->pixmap, impl_->handle->context,
-						0, 0, size_.width, size_.height, x, y);
+						0, 0, impl_->size.width, impl_->size.height, x, y);
 				::XFlush(display);
 #endif
 			}
@@ -762,14 +795,14 @@ namespace paint
 
 		void graphics::paste(const nana::rectangle& r_src, graphics& dst, int x, int y) const
 		{
-			if(handle_ && dst.handle_ && handle_ != dst.handle_)
+			if(impl_->handle && dst.impl_->handle && impl_->handle != dst.impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
-				::BitBlt(dst.handle_->context, x, y, r_src.width, r_src.height, handle_->context, r_src.x, r_src.y, SRCCOPY);
+				::BitBlt(dst.impl_->handle->context, x, y, r_src.width, r_src.height, impl_->handle->context, r_src.x, r_src.y, SRCCOPY);
 #elif defined(NANA_X11)
 				Display* display = nana::detail::platform_spec::instance().open_display();
 				::XCopyArea(display,
-						handle_->pixmap, dst.handle_->pixmap, handle_->context,
+					impl_->handle->pixmap, dst.impl_->handle->pixmap, impl_->handle->context,
 						r_src.x, r_src.y, r_src.width, r_src.height, x, y);
 
 				::XFlush(display);
@@ -779,10 +812,10 @@ namespace paint
 
 		void graphics::stretch(const nana::rectangle& src_r, graphics& dst, const nana::rectangle& r) const
 		{
-			if(handle_ && dst.handle_ && (handle_ != dst.handle_))
+			if(impl_->handle && dst.impl_->handle && (impl_->handle != dst.impl_->handle))
 			{
-				pixel_buffer pixbuf(handle_, 0, 0);
+				pixel_buffer pixbuf(impl_->handle, 0, 0);
-				pixbuf.stretch(src_r, dst.handle_, r);
+				pixbuf.stretch(src_r, dst.impl_->handle, r);
 			}
 		}
 
@@ -799,58 +832,58 @@ namespace paint
 		}
 
 		unsigned graphics::width() const{
-			return size_.width;
+			return impl_->size.width;
 		}
 
 		unsigned graphics::height() const{
-			return size_.height;
+			return impl_->size.height;
 		}
 
 		nana::size graphics::size() const{
-			return this->size_;
+			return this->impl_->size;
 		}
 
 		void graphics::setsta()
 		{
-			changed_ = false;
+			impl_->changed = false;
 		}
 
 		void graphics::set_changed()
 		{
-			changed_ = true;
+			impl_->changed = true;
 		}
 
 		void graphics::release()
 		{
-			dwptr_.reset();
+			impl_->platform_drawable.reset();
-			handle_ = nullptr;
+			impl_->handle = nullptr;
-			size_.width = size_.height = 0;
+			impl_->size.width = impl_->size.height = 0;
 		}
 
 		void graphics::save_as_file(const char* file_utf8) const throw()
 		{
-			if(handle_)
+			if(impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
-				int iWidth = static_cast<int>(size_.width);
+				const int iWidth = static_cast<int>(impl_->size.width);
-				int iHeight = static_cast<int>(size_.height);
+				const int iHeight = static_cast<int>(impl_->size.height);
 				BITMAPINFO bmpInfo = {};
 				bmpInfo.bmiHeader.biSize = sizeof(bmpInfo.bmiHeader);
-				bmpInfo.bmiHeader.biWidth = static_cast<int>(size_.width);
+				bmpInfo.bmiHeader.biWidth = iWidth;
-				bmpInfo.bmiHeader.biHeight = static_cast<int>(size_.height);
+				bmpInfo.bmiHeader.biHeight = iHeight;
 				bmpInfo.bmiHeader.biPlanes = 1;
 				bmpInfo.bmiHeader.biBitCount = 24;
 
 				const size_t lineBytes = ((bmpInfo.bmiHeader.biWidth * 3) + 3) & (~3);
 				const size_t imageBytes = iHeight * lineBytes;
 
-				HDC hdcMem = ::CreateCompatibleDC(handle_->context);
+				HDC hdcMem = ::CreateCompatibleDC(impl_->handle->context);
 				BYTE *pData = nullptr;
 				HBITMAP hBmp = ::CreateDIBSection(hdcMem, &bmpInfo, DIB_RGB_COLORS, reinterpret_cast<void**>(&pData), 0, 0);
 
 				::SelectObject(hdcMem, hBmp);
 
-				BitBlt(hdcMem, 0, 0, iWidth, iHeight, handle_->context, 0, 0, SRCCOPY);
+				BitBlt(hdcMem, 0, 0, iWidth, iHeight, impl_->handle->context, 0, 0, SRCCOPY);
 
 				BITMAPFILEHEADER bmFileHeader = { 0 };
 				bmFileHeader.bfType = 0x4d42;  //bmp
@@ -874,20 +907,20 @@ namespace paint
 
 		::nana::color graphics::palette(bool for_text) const
 		{
-			if (handle_)
+			if (impl_->handle)
-				return static_cast<color_rgb>(for_text ? handle_->get_text_color() : handle_->get_color());
+				return static_cast<color_rgb>(for_text ? impl_->handle->get_text_color() : impl_->handle->get_color());
 
 			return{};
 		}
 
 		graphics& graphics::palette(bool for_text, const ::nana::color& clr)
 		{
-			if (handle_)
+			if (impl_->handle)
 			{
 				if (for_text)
-					handle_->set_text_color(clr);
+					impl_->handle->set_text_color(clr);
 				else
-					handle_->set_color(clr);
+					impl_->handle->set_color(clr);
 			}
 
 			return *this;
@@ -915,34 +948,34 @@ namespace paint
 
 		void graphics::blend(const nana::rectangle& r, const ::nana::color& clr, double fade_rate)
 		{
-			if (handle_)
+			if (impl_->handle)
 			{
-				nana::paint::detail::blend(handle_, r, clr.px_color(), fade_rate);
+				nana::paint::detail::blend(impl_->handle, r, clr.px_color(), fade_rate);
-				if (changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
 		void graphics::set_pixel(int x, int y, const ::nana::color& clr)
 		{
-			if (handle_)
+			if (impl_->handle)
 			{
-				handle_->set_color(clr);
+				impl_->handle->set_color(clr);
 				set_pixel(x, y);
 			}
 		}
 
 		void graphics::set_pixel(int x, int y)
 		{
-			if (handle_)
+			if (impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
-				::SetPixel(handle_->context, x, y, NANA_RGB(handle_->get_color()));
+				::SetPixel(impl_->handle->context, x, y, NANA_RGB(impl_->handle->get_color()));
 #elif defined(NANA_X11)
 				Display* disp = nana::detail::platform_spec::instance().open_display();
-				handle_->update_color();
+				impl_->handle->update_color();
-				::XDrawPoint(disp, handle_->pixmap, handle_->context, x, y);
+				::XDrawPoint(disp, impl_->handle->pixmap, handle_->context, x, y);
 #endif
-				if (changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
@@ -959,7 +992,7 @@ namespace paint
 
 		void graphics::string(nana::point pos, const wchar_t* str, std::size_t len)
 		{
-			if (handle_ && str && len)
+			if (impl_->handle && str && len)
 			{
 				auto const end = str + len;
 				auto i = std::find(str, end, '\t');
@@ -968,15 +1001,15 @@ namespace paint
 #endif
 				if (i != end)
 				{
-					std::size_t tab_pixels = handle_->string.tab_length * handle_->string.tab_pixels;
+					std::size_t tab_pixels = impl_->handle->string.tab_length * impl_->handle->string.tab_pixels;
 					while (true)
 					{
 						len = i - str;
 						if (len)
 						{
 							//Render a part that does not contains a tab
-							detail::draw_string(handle_, pos, str, len);
+							detail::draw_string(impl_->handle, pos, str, len);
-							pos.x += detail::raw_text_extent_size(handle_, str, len).width;
+							pos.x += detail::raw_text_extent_size(impl_->handle, str, len).width;
 						}
 
 						str = i;
@@ -994,8 +1027,8 @@ namespace paint
 					}
 				}
 				else
-					detail::draw_string(handle_, pos, str, len);
+					detail::draw_string(impl_->handle, pos, str, len);
-				if (changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
@@ -1017,21 +1050,21 @@ namespace paint
 
 		void graphics::line(const nana::point& pos1, const nana::point& pos2)
 		{
-			if (!handle_)	return;
+			if (!impl_->handle)	return;
 #if defined(NANA_WINDOWS)
-			handle_->update_pen();
+			impl_->handle->update_pen();
 			if (pos1 != pos2)
 			{
-				::MoveToEx(handle_->context, pos1.x, pos1.y, 0);
+				::MoveToEx(impl_->handle->context, pos1.x, pos1.y, 0);
-				::LineTo(handle_->context, pos2.x, pos2.y);
+				::LineTo(impl_->handle->context, pos2.x, pos2.y);
 			}
-			::SetPixel(handle_->context, pos2.x, pos2.y, NANA_RGB(handle_->pen.color));
+			::SetPixel(impl_->handle->context, pos2.x, pos2.y, NANA_RGB(impl_->handle->pen.color));
 #elif defined(NANA_X11)
 			Display* disp = nana::detail::platform_spec::instance().open_display();
-			handle_->update_color();
+			impl_->handle->update_color();
-			::XDrawLine(disp, handle_->pixmap, handle_->context, pos1.x, pos1.y, pos2.x, pos2.y);
+			::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context, pos1.x, pos1.y, pos2.x, pos2.y);
 #endif
-			if (changed_ == false) changed_ = true;
+			if (impl_->changed == false) impl_->changed = true;
 		}
 
 		void graphics::line(const point& pos_a, const point& pos_b, const color& clr)
@@ -1042,26 +1075,26 @@ namespace paint
 
 		void graphics::line_to(const point& pos, const color& clr)
 		{
-			if (!handle_) return;
+			if (!impl_->handle) return;
-			handle_->set_color(clr);
+			impl_->handle->set_color(clr);
 			line_to(pos);
 		}
 
 		void graphics::line_to(const point& pos)
 		{
-			if (!handle_)	return;
+			if (!impl_->handle)	return;
 #if defined(NANA_WINDOWS)
-			handle_->update_pen();
+			impl_->handle->update_pen();
-			::LineTo(handle_->context, pos.x, pos.y);
+			::LineTo(impl_->handle->context, pos.x, pos.y);
 #elif defined(NANA_X11)
 			Display* disp = nana::detail::platform_spec::instance().open_display();
-			handle_->update_color();
+			impl_->handle->update_color();
-			::XDrawLine(disp, handle_->pixmap, handle_->context,
+			::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context,
-				handle_->line_begin_pos.x, handle_->line_begin_pos.y,
+				impl_->handle->line_begin_pos.x, impl_->handle->line_begin_pos.y,
 				pos.x, pos.y);
-			handle_->line_begin_pos = pos;
+			impl_->handle->line_begin_pos = pos;
 #endif
-			if (changed_ == false) changed_ = true;
+			if (impl_->changed == false) impl_->changed = true;
 		}
 
 		void graphics::rectangle(bool solid)
@@ -1077,21 +1110,21 @@ namespace paint
 
 		void graphics::rectangle(const ::nana::rectangle& r, bool solid)
 		{
-			if (r.width && r.height && handle_ && r.right() > 0 && r.bottom() > 0)
+			if (r.width && r.height && impl_->handle && r.right() > 0 && r.bottom() > 0)
 			{
 #if defined(NANA_WINDOWS)
 				::RECT native_r = { r.x, r.y, r.right(), r.bottom()};
-				handle_->update_brush();
+				impl_->handle->update_brush();
-				(solid ? ::FillRect : ::FrameRect)(handle_->context, &native_r, handle_->brush.handle);
+				(solid ? ::FillRect : ::FrameRect)(impl_->handle->context, &native_r, impl_->handle->brush.handle);
 #elif defined(NANA_X11)
 				Display* disp = nana::detail::platform_spec::instance().open_display();
-				handle_->update_color();
+				impl_->handle->update_color();
 				if (solid)
-					::XFillRectangle(disp, handle_->pixmap, handle_->context, r.x, r.y, r.width, r.height);
+					::XFillRectangle(disp, impl_->handle->pixmap, impl_->handle->context, r.x, r.y, r.width, r.height);
 				else
-					::XDrawRectangle(disp, handle_->pixmap, handle_->context, r.x, r.y, r.width - 1, r.height - 1);
+					::XDrawRectangle(disp, impl_->handle->pixmap, impl_->handle->context, r.x, r.y, r.width - 1, r.height - 1);
 #endif
-				if (changed_ == false) changed_ = true;
+				if (impl_->changed == false) impl_->changed = true;
 			}
 		}
 
@@ -1138,10 +1171,10 @@ namespace paint
 		void graphics::gradual_rectangle(const ::nana::rectangle& rct, const ::nana::color& from, const ::nana::color& to, bool vertical)
 		{
 #if defined(NANA_WINDOWS)
-			if (pxbuf_.open(handle_))
+			if (impl_->pxbuf.open(impl_->handle))
 			{
-				pxbuf_.gradual_rectangle(rct, from, to, 0.0, vertical);
+				impl_->pxbuf.gradual_rectangle(rct, from, to, 0.0, vertical);
-				pxbuf_.paste(handle_, point{});
+				impl_->pxbuf.paste(impl_->handle, point{});
 			}
 #elif defined(NANA_X11)
 			if (nullptr == handle_) return;
@@ -1155,7 +1188,7 @@ namespace paint
 			unsigned last_color = (int(r) << 16) | (int(g) << 8) | int(b);
 
 			Display * disp = nana::detail::platform_spec::instance().open_display();
-			handle_->fgcolor(static_cast<color_rgb>(last_color));
+			impl_->handle->fgcolor(static_cast<color_rgb>(last_color));
 			const int endpos = deltapx + (vertical ? rct.y : rct.x);
 			if (endpos > 0)
 			{
@@ -1165,12 +1198,12 @@ namespace paint
 					auto y = rct.y;
 					for (; y < endpos; ++y)
 					{
-						::XDrawLine(disp, handle_->pixmap, handle_->context, x1, y, x2, y);
+						::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context, x1, y, x2, y);
 						unsigned new_color = (int(r += delta_r) << 16) | (int(g += delta_g) << 8) | int(b += delta_b);
 						if (new_color != last_color)
 						{
 							last_color = new_color;
-							handle_->fgcolor(static_cast<color_rgb>(last_color));
+							impl_->handle->fgcolor(static_cast<color_rgb>(last_color));
 						}
 					}
 				}
@@ -1180,39 +1213,40 @@ namespace paint
 					auto x = rct.x;
 					for (; x < endpos; ++x)
 					{
-						::XDrawLine(disp, handle_->pixmap, handle_->context, x, y1, x, y2);
+						::XDrawLine(disp, impl_->handle->pixmap, impl_->handle->context, x, y1, x, y2);
 						unsigned new_color = (int(r += delta_r) << 16) | (int(g += delta_g) << 8) | int(b += delta_b);
 						if (new_color != last_color)
 						{
 							last_color = new_color;
-							handle_->fgcolor(static_cast<color_rgb>(last_color));
+							impl_->handle->fgcolor(static_cast<color_rgb>(last_color));
 						}
 					}
 				}
 			}
 #endif
-			if (changed_ == false) changed_ = true;
+			if (impl_->changed == false) impl_->changed = true;
 		}
 
 		void graphics::round_rectangle(const ::nana::rectangle& r, unsigned radius_x, unsigned radius_y, const color& clr, bool solid, const color& solid_clr)
 		{
-			if (handle_)
+			if (impl_->handle)
 			{
 #if defined(NANA_WINDOWS)
-				handle_->set_color(clr);
+				impl_->handle->set_color(clr);
 				if (solid)
 				{
-					handle_->update_pen();
+					impl_->handle->update_pen();
-					handle_->brush.set(handle_->context, handle_->brush.Solid, solid_clr.px_color().value);
+					impl_->handle->brush.set(impl_->handle->context, impl_->handle->brush.Solid, solid_clr.px_color().value);
-					::RoundRect(handle_->context, r.x, r.y, r.right(), r.bottom(), static_cast<int>(radius_x * 2), static_cast<int>(radius_y * 2));
+					::RoundRect(impl_->handle->context, r.x, r.y, r.right(), r.bottom(), static_cast<int>(radius_x * 2), static_cast<int>(radius_y * 2));
 				}
 				else
 				{
-					handle_->update_brush();
+					impl_->handle->update_brush();
-					handle_->round_region.set(r, radius_x, radius_y);
+					impl_->handle->round_region.set(r, radius_x, radius_y);
-					::FrameRgn(handle_->context, handle_->round_region.handle, handle_->brush.handle, 1, 1);
+					::FrameRgn(impl_->handle->context, impl_->handle->round_region.handle, impl_->handle->brush.handle, 1, 1);
 				}
-				if(changed_ == false) changed_ = true;
+
+				if (impl_->changed == false) impl_->changed = true;
 #elif defined(NANA_X11)
 				if(solid && (clr == solid_clr))
 				{

source/paint/text_renderer.cpp

@@ -70,7 +70,7 @@ namespace nana
 								auto ts = detail::text_extent_size(dw, ent.begin, ent.end - ent.begin);
 								if(ts.height > pixels) pixels = ts.height;
 								lenpx += ts.width;
-								widths.push_back(ts.width);
+								widths.emplace_back(ts.width);
 							}
 
 							pos.x += (endpos - pos.x - static_cast<int>(lenpx))/2;
@@ -199,7 +199,7 @@ namespace nana
 					{
 						nana::size ts = detail::text_extent_size(dw, i.begin, i.end - i.begin);
 						if(ts.height > pixels) pixels = ts.height;
-						ts_keeper.push_back(ts);
+						ts_keeper.emplace_back(ts);
 						str_w += ts.width;
 					}
 
@@ -417,7 +417,7 @@ namespace nana
 					for(auto & i : reordered)
 					{
 						nana::size ts = detail::text_extent_size(dw, i.begin, i.end - i.begin);
-						ts_keeper.push_back(ts);
+						ts_keeper.emplace_back(ts);
 						str_w += ts.width;
 					}
 

source/system/dataexch.cpp

@@ -13,6 +13,7 @@
 #include <nana/system/dataexch.hpp>
 #include <nana/traits.hpp>
 #include <nana/paint/graphics.hpp>
+#include <nana/paint/pixel_buffer.hpp>
 #include <vector>
 #include <cassert>
 #include <cstring>

source/threads/pool.cpp

@@ -94,7 +94,7 @@ namespace threads
 					pto->suspended = false;
 					::pthread_create(&(pto->handle), 0, reinterpret_cast<void*(*)(void*)>(&impl::_m_thr_starter), pto);
 #endif
-					container_.threads.push_back(pto);
+					container_.threads.emplace_back(pto);
 				}
 			}
 
@@ -168,7 +168,7 @@ namespace threads
 				else
 				{
 					std::lock_guard<decltype(mutex_)> lock(mutex_);
-					container_.tasks.push_back(taskptr);
+					container_.tasks.emplace_back(taskptr);
 				}
 			}
 

source/unicode_bidi.cpp

@@ -536,7 +536,8 @@ namespace nana
 				}
 				else if (LRE <= *c && *c <= RLO)
 				{
-					stack.push_back(cur);
+					stack.emplace_back(cur);
+
 					if (begin_character)
 					{
 						_m_push_entity(begin_character, c, cur.level, begin_char_type);
@@ -607,12 +608,13 @@ namespace nana
 
 		void unicode_bidi::_m_push_entity(const char_type * begin, const char_type *end, unsigned level, bidi_char bidi_char_type)
 		{
-			entity e;
+			levels_.emplace_back();
+			auto & e = levels_.back();
 			e.begin = begin;
 			e.end = end;
 			e.level = level;
 			e.bidi_char_type = bidi_char_type;
-			levels_.push_back(e);
+
 		}
 		
 		std::vector<unicode_bidi::entity>::iterator unicode_bidi::_m_search_first_character()
@@ -620,6 +622,7 @@ namespace nana
 			return levels_.begin();
 		}
 
+	
 		auto unicode_bidi::_m_eor(std::vector<entity>::iterator i) ->bidi_char
 		{
 			const auto end = levels_.end();