partial Dev dpi system -> do not merge

.github/workflows/ubuntu.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Check out repository code
         uses: actions/checkout@v4
       # we are in /home/runner/work/nana/nana
-      - run: git clone --depth=1 --branch=develop https://github.com/qPCR4vir/nana-demo.git nana-demo
+      - run: git clone --depth=1 --branch=dev_dpi_system https://github.com/qPCR4vir/nana-demo.git nana-demo
         working-directory: ../
       - run: mkdir nana-demo-build
         working-directory: ../

include/nana/basic_types.hpp

@@ -21,7 +21,7 @@
 namespace nana
 {
 	/// A constant value for the invalid position.
-	const std::size_t npos = static_cast<std::size_t>(-1);
+	constexpr std::size_t npos = static_cast<std::size_t>(-1);
 
 
 	template<typename CharT>
@@ -30,17 +30,17 @@ namespace nana
 	{
 		typedef CharT char_type;
 
-		static bool eq(char_type c1, char_type c2) noexcept
+		static constexpr bool eq(char_type c1, char_type c2) noexcept
 		{
 			return std::toupper(c1) == std::toupper(c2);
 		}
 
-		static bool lt(char_type c1, char_type c2) noexcept
+		static constexpr bool lt(char_type c1, char_type c2) noexcept
 		{
 			return std::toupper(c1) < std::toupper(c2);
 		}
 
-		static int compare(const char_type* s1, const char_type* s2, std::size_t n)
+		static constexpr int compare(const char_type* s1, const char_type* s2, std::size_t n)
 		{
 			while(n--)
 			{
@@ -54,7 +54,7 @@ namespace nana
 			return 0;
 		}
 
-		static const char_type* find(const char_type* s, std::size_t n, const char_type& a)
+		static constexpr const char_type* find(const char_type* s, std::size_t n, const char_type& a)
 		{
 			auto ua = std::toupper(a);
 			const char_type * end = s + n;

include/nana/config.hpp

@@ -25,13 +25,13 @@
 
 
 #ifndef NANA_dpi_aware  // uncomment your option: true to try experimental DPI aware nana
-    #define NANA_dpi_aware false
-	//#define NANA_dpi_aware true 
+    //#define NANA_dpi_aware false
+	#define NANA_dpi_aware true 
 #endif // NANA_dpi_aware 
 inline bool config_dpi_aware = NANA_dpi_aware;
 
 /// \todo: replace by #ifdef DPI_DEBUGGING or just fully eliminate
-static constexpr bool dpi_debugging = false;  ///< set to true to print DPI relates values for debugging
+static constexpr bool dpi_debugging = true;  ///< set to true to print DPI relates values for debugging
 
 #include "c++defines.hpp"
 

include/nana/deploy.hpp

@@ -1,4 +1,4 @@
-/*
+/**
  *	The Deploy Implementation
  *	Nana C++ Library(https://nana.acemind.cn)
  *	Copyright(C) 2003-2020 Jinhao([email protected])
@@ -7,7 +7,7 @@
  *	(See accompanying file LICENSE_1_0.txt or copy at
  *	http://www.boost.org/LICENSE_1_0.txt)
  *
- *	@file: nana/deploy.hpp
+ *	@file nana/deploy.hpp
  *
  *	What follows is dependent on what defined in nana/config.hpp
  */

include/nana/gui/basis.hpp

@@ -84,22 +84,22 @@ namespace nana
 	{
 		enum class flags
 		{
-			super,
-			widget = 0x1,
-			lite_widget = 0x3,
-			root = 0x5
+			super,              // 000
+			widget      = 0x1,  // 001
+			lite_widget = 0x3,  // 011
+			root        = 0x5   // 101
 		};
 		//wait for constexpr
-		struct widget_tag{ static const flags value = flags::widget; };
+		struct widget_tag                         { static const flags value = flags::widget;       };
 		struct lite_widget_tag : public widget_tag{ static const flags value = flags::lite_widget;  };
-		struct root_tag : public widget_tag{ static const flags value = flags::root;  };
+		struct root_tag        : public widget_tag{ static const flags value = flags::root;         };
 	}// end namespace category
 
-	using window = detail::basic_window*;							///< The window handle type representing nana window objects
+	using window             = detail::basic_window*;	 	    	///< The window handle type representing nana window objects
 	using native_window_type = detail::native_window_handle_impl*;	///< The native window handle type representing system native windows. E.g, HWND in windows, Window in X11
 
-	using event_handle = detail::event_handle_impl*;				///< The event handle type representing nana window events
-	using native_drawable_type = detail::native_drawable_impl*;		///< The drawable handle type representing system native drawable objects.	E.g. HDC in windows, Drawable in X11
+	using event_handle         = detail::event_handle_impl*;	///< The event handle type representing nana window events
+	using native_drawable_type = detail::native_drawable_impl*;	///< The drawable handle type representing system native drawable objects.	E.g. HDC in windows, Drawable in X11
 
 
 	struct keyboard

include/nana/gui/detail/bedrock.hpp

@@ -14,6 +14,7 @@
 
 #ifndef NANA_GUI_DETAIL_BEDROCK_HPP
 #define NANA_GUI_DETAIL_BEDROCK_HPP
+
 #include "general_events.hpp"
 #include "color_schemes.hpp"
 #include "virtual_keyboard.hpp"
@@ -28,7 +29,7 @@ namespace nana::detail
 
 	struct window_platform_assoc;
 
-	/// @brief	fundamental core component, it provides an abstraction to the OS platform and some basic functions.
+	/// fundamental core component, it provides an abstraction to the OS platform and some basic functions.
 	class bedrock
 	{
 		bedrock();
@@ -67,7 +68,7 @@ namespace nana::detail
 
 		void set_menubar_taken(basic_window*);
 
-		//Delay Restores focus when a menu which attached to menubar is closed
+		/// Delay Restores focus when a menu which attached to menubar is closed
 		void delay_restore(int);
 		bool close_menu_if_focus_other_window(native_window_type focus);
 		void set_menu(native_window_type menu_window, bool is_keyboard_condition);
@@ -111,7 +112,7 @@ namespace nana::detail
 
 		void manage_form_loader(basic_window*, bool insert_or_remove);
 	public:
-		// if 'bForce__EmitInternal', then ONLY internal (widget's) events are processed (even through explicit filtering)
+		/// if 'bForce__EmitInternal', then ONLY internal (widget's) events are processed (even through explicit filtering)
 		bool emit(event_code, basic_window*, const event_arg&, bool ask_update, thread_context*, const bool bForce__EmitInternal = false);
 	private:
 		void _m_emit_core(event_code, basic_window*, bool draw_only, const event_arg&, const bool bForce__EmitInternal);

include/nana/gui/detail/drawer.hpp

@@ -122,7 +122,7 @@ namespace nana
 				not_overridden
 			};
 		public:
-			drawer();
+			drawer(int dpi = 96);
 			~drawer();
 
 			void bind(basic_window*);
@@ -195,7 +195,7 @@ namespace nana
 				}
 			}
 		public:
-			nana::paint::graphics graphics;
+			nana::paint::graphics graphics;  ///< The graphics object for drawing \todo: set dpi
 		private:
 			struct data_implement;
 

include/nana/gui/detail/general_events.hpp

@@ -235,7 +235,7 @@ namespace nana
 	{
 		event_code evt_code; ///< what kind of mouse event?
 		::nana::window window_handle;  ///< A handle to the event window
-		::nana::point pos;   ///< cursor position in the event window
+		::nana::point pos;   ///< cursor position in the event window, dpi user-side coordinate
 		::nana::mouse button;	///< indicates a button which triggers the event
 
 		bool left_button;	///< true if mouse left button is pressed

include/nana/gui/detail/native_window_interface.hpp

@@ -8,32 +8,59 @@
  *	http://www.boost.org/LICENSE_1_0.txt)
  *
  *	@file nana/gui/detail/native_window_interface.hpp
+ *  @contributors  Jinhao, Ariel Vina-Rodriguez
  */
 
 #ifndef NANA_GUI_DETAIL_NATIVE_WINDOW_INTERFACE_HPP
 #define NANA_GUI_DETAIL_NATIVE_WINDOW_INTERFACE_HPP
 
 #include <functional>
+#include <iostream>
 
 #include "../basis.hpp"
 #include <nana/paint/image.hpp>
 
+//#if defined(NANA_WINDOWS)
+//#include <windef.h>
+//#endif
+
 namespace nana
 {
 namespace detail
 {
+  #if defined(NANA_WINDOWS)
+    nana::point scale_to_dpi(int x, int y, int dpi);
+	nana::point scale_to_dpi(native_window_type wd, int x, int y);
+	nana::point unscale_dpi(native_window_type wd, int x, int y);
+
+    // create helper function to scale nana::rectangle to dpi
+    nana::rectangle scale_to_dpi(const nana::rectangle& r, int dpi);
+	nana::rectangle scale_to_dpi(native_window_type wd, const nana::rectangle& r);
+	nana::rectangle unscale_dpi(const nana::rectangle& r, int dpi);
+
+	// create helper function to scale ::RECT to dpi
+	//::RECT scale_to_dpi(const ::RECT& r, int dpi);
+	//::RECT scale_to_dpi(native_window_type wd, const ::RECT& r);
+	//::RECT unscale_dpi(const ::RECT& r, int dpi);
+
+	nana::size scale_to_dpi(const nana::size& sz, int dpi);
+	nana::size scale_to_dpi(native_window_type wd, const nana::size& sz);
+	nana::size unscale_dpi(const nana::size& sz, int dpi);
+	nana::size unscale_dpi(native_window_type wd, const nana::size& sz);
+#endif
 
 	struct native_interface
 	{
 		struct window_result
 		{
 			native_window_type native_handle;
 
-			unsigned width;		///< client size
-			unsigned height;	///< client size
+			size  client_size;	    ///< client size
 
 			unsigned extra_width;	///< extra border size, it is useful in Windows, ignore in X11 always 0
 			unsigned extra_height;	///< extra border size, it is useful in Windows, ignore in X11 always 0
+
+			int   owner_dpi, dpi;	///< owner_dpi is the DPI of the owner window, dpi is the DPI of the window
 		};
 
 		struct frame_extents
@@ -47,65 +74,74 @@ namespace detail
 		using native_string_type = ::nana::detail::native_string_type;
 
 		/// Invokes a function in the thread of the specified window.
-		static void affinity_execute(native_window_type, bool post, std::function<void()>&&);
+		static void affinity_execute(native_window_type native_handle, bool post, std::function<void()>&& fn);
 
-		static nana::size	primary_monitor_size(); ///< already 'DPI' scaled size
-		/// \todo: generalize dpi to v2 awareness 
-		static rectangle screen_area_from_point(const point&);
-		static window_result create_window(native_window_type, bool nested, const rectangle&, const appearance&);
-		static native_window_type create_child_window(native_window_type, const rectangle&);
+		static nana::size	primary_monitor_size();                                 ///< return 'DPI' unscaled size (user-side)
+		static rectangle screen_area_from_system_point(const point& system_point);  ///< unused ?
+
+		static window_result create_window(native_window_type owner, bool nested, const rectangle& r, const appearance& ap);
+		static native_window_type create_child_window(native_window_type owner, const rectangle& r);  ///< unused ?
 
 #if defined(NANA_X11)
 		static void set_modal(native_window_type);
 #endif
-		static void enable_dropfiles(native_window_type, bool);
-		static void enable_window(native_window_type, bool);
-		// (On Windows) The system displays the large icon in the ALT+TAB dialog box, and the small icon in the window caption.
-		static bool window_icon(native_window_type, const paint::image& big_icon, const paint::image& small_icon);
-		static void activate_owner(native_window_type);
-		static void activate_window(native_window_type);
-		static void close_window(native_window_type);
-		static void show_window(native_window_type, bool show, bool active);
-		static void restore_window(native_window_type);
-		static void zoom_window(native_window_type, bool ask_for_max);
-		static void	refresh_window(native_window_type);
-		static bool is_window(native_window_type);
-		static bool	is_window_visible(native_window_type);
-		static bool is_window_zoomed(native_window_type, bool ask_for_max);
-
-		static nana::point	window_position(native_window_type);
-		static void	move_window(native_window_type, int x, int y);
-		static bool	move_window(native_window_type, const rectangle&);
-		static void bring_top(native_window_type, bool activated);
-		static void	set_window_z_order(native_window_type, native_window_type wd_after, z_order_action action_if_no_wd_after);
-
-		static frame_extents window_frame_extents(native_window_type);
-		static bool	window_size(native_window_type, const size&);
-		static void	get_window_rect(native_window_type, rectangle&);
-		static void	window_caption(native_window_type, const native_string_type&);
-		static native_string_type	window_caption(native_window_type);
-		static void	capture_window(native_window_type, bool);
-		static nana::point	cursor_position();
-
-		static native_window_type get_window(native_window_type wd, window_relationship);
+		static void enable_dropfiles(native_window_type wd, bool enable);
+		static void enable_window   (native_window_type wd, bool enable);
+
+		/// (On Windows) The system displays the large icon in the ALT+TAB dialog box, and the small icon in the window caption.
+		static bool window_icon(native_window_type wd, const paint::image& big_icon, const paint::image& small_icon);
+		static void activate_owner (native_window_type wd);
+		static void activate_window(native_window_type wd);
+		static void close_window   (native_window_type wd);                        ///< close the window, destroy the window
+		static void show_window    (native_window_type wd, bool show, bool active);
+		static void restore_window (native_window_type wd);
+		static void zoom_window    (native_window_type wd, bool ask_for_max);
+		static void	refresh_window (native_window_type wd);
+		static bool is_window      (native_window_type wd);
+		static bool	is_window_visible(native_window_type wd);
+		static bool is_window_zoomed(native_window_type wd, bool ask_for_max);
+
+		static nana::point	window_position(native_window_type wd);                ///< return 'DPI' unscaled size (user-side)
+		static void	move_window   (native_window_type wd, int x, int y);
+		static bool	move_window   (native_window_type wd, const rectangle&);
+		static void bring_top     (native_window_type wd, bool activated);
+		static void	set_window_z_order(native_window_type wd, native_window_type wd_after, z_order_action action_if_no_wd_after);
+
+		static frame_extents window_frame_extents(native_window_type wd);
+		static bool	window_size    (native_window_type wd, const size& new_size); ///< change to new_size if possible
+		static void	get_window_rect(native_window_type wd, rectangle& r);         ///< unused ?
+		static void	window_caption (native_window_type wd, const native_string_type& title);
+		static native_string_type	window_caption(native_window_type wd);
+		static void	capture_window (native_window_type wd, bool capture);
+		static nana::point	cursor_sytem_position ();                             ///< return system point, scaled system-side
+		static nana::point	cursor_screen_position();                             ///< return unscaled point (user-side) for whole screen
+		static nana::point	cursor_window_position(native_window_type wd);        ///< return unscaled point (user-side) for wd
+
+		static native_window_type get_window   (native_window_type    wd, window_relationship);
 		static native_window_type parent_window(native_window_type child, native_window_type new_parent, bool returns_previous);
+
 		//For Caret
-		static void caret_create(native_window_type, const ::nana::size&);
-		static void caret_destroy(native_window_type);
-		static void caret_pos(native_window_type, const ::nana::point&);
-		static void caret_visible(native_window_type, bool);
+		static void caret_create  (native_window_type wd, const ::nana::size&);
+		static void caret_destroy (native_window_type wd);
+		static void caret_pos     (native_window_type wd, const ::nana::point&);
+		static void caret_visible (native_window_type wd, bool);
 
-		static void	set_focus(native_window_type);
+		static void	set_focus     (native_window_type wd);
 		static native_window_type get_focus_window();
-		static bool calc_screen_point(native_window_type, nana::point&);
-		static bool calc_window_point(native_window_type, nana::point&);
+		static bool calc_screen_point(native_window_type wd, nana::point& window_point); ///< from client, user-side
+		static bool calc_window_point(native_window_type wd, nana::point& screen_point); ///< to  client, user-side
+		static bool transform_window_system_point_into_screen_sytem_point(native_window_type wd, nana::point& system_system_point); ///< from client, system-side
+		static bool transform_screen_system_point_into_window_sytem_point(native_window_type wd, nana::point& screen_system_point); ///< to  client, system-side
+
+		static native_window_type find_window_from_system_screen_point(const nana::point& system_screen_point);   
+		/// point will be the position of cursor the returned window, but if no window under cursor, the point will be on screen point 
+		static native_window_type find_cursor_window(nana::point& point);  
 
-		static native_window_type find_window(int x, int y);
 		static nana::size check_track_size(nana::size sz, unsigned extra_width, unsigned extra_height, bool true_for_max);
 
 		static void start_dpi_awareness(bool aware = false);
-		static std::size_t window_dpi(native_window_type);  ///< if the window is not DPI aware return the system DPI 
-		static std::size_t system_dpi();					///< get the DPI of the main monitor
+		static int window_dpi(native_window_type, bool x_requested = true);  ///< if the window is not DPI aware return the system DPI (usually x_dpi = y_dpi)
+		static int system_dpi(bool x_requested = true);			    		 ///< get the DPI of the main monitor (usually x_dpi = y_dpi)
 	};
 
 

include/nana/gui/detail/window_layout.hpp

@@ -1,12 +1,12 @@
-/*
+/**
  *	Window Layout Implementation
  *	Copyright(C) 2003-2017 Jinhao([email protected])
  *
  *	Distributed under the Boost Software License, Version 1.0.
  *	(See accompanying file LICENSE_1_0.txt or copy at
  *	http://www.boost.org/LICENSE_1_0.txt)
  *
- *	@file: nana/gui/detail/window_layout.hpp
+ *	@file nana/gui/detail/window_layout.hpp
  *
  */
 
@@ -53,20 +53,18 @@ namespace detail
 
 		static void paste_children_to_graphics(basic_window*, nana::paint::graphics& graph);
 
-		//read_visual_rectangle
-		//@brief:	Reads the visual rectangle of a window, the visual rectangle's reference frame is to root widget,
-		//			the visual rectangle is a rectangular block that a window should be displayed on screen.
-		//			The result is a rectangle that is a visible area for its ancesters.
+		///read_visual_rectangle
+		///@brief:	Reads the visual rectangle of a window, the visual rectangle's reference frame is to root widget,
+		///			the visual rectangle is a rectangular block that a window should be displayed on screen.
+		///			The result is a rectangle that is a visible area for its ancesters.
 		static bool read_visual_rectangle(basic_window*, nana::rectangle& visual);
 
-		//read_overlaps
-		//	reads the overlaps that are overlapped a rectangular block
+		///	reads the overlaps that are overlapped a rectangular block
 		static bool read_overlaps(basic_window*, const nana::rectangle& vis_rect, std::vector<wd_rectangle>& blocks);
 
 		static bool enable_effects_bground(basic_window *, bool enabled);
 
-		//make_bground
-		//		update the glass buffer of a glass window.
+		///		update the glass buffer of a glass window.
 		static void make_bground(basic_window* const);
 	private: