reflexion 0.6.0 → 0.7.0

data/src/win32/menu.cpp

@@ -1,16 +1,15 @@
 #include "menu.h"
 
 
+#include <string>
+#include <vector>
+#include <xot/time.h>
 #include "reflex/exception.h"
 #include "reflex/event.h"
 #include "reflex/view.h"
+#include "../rays.h"
 #include "window.h"
-
-
-namespace Rays
-{
-	HBITMAP Bitmap_get_hbitmap (const Bitmap& bmp);
-}
+#include "screen.h"
 
 
 namespace Reflex
@@ -63,6 +62,8 @@ namespace Reflex
 
 		bool menubar   = false;
 
+		bool modified  = false;
+
 		Image image;
 
 		std::shared_ptr<HBITMAP__> hbitmap;
@@ -99,14 +100,27 @@ namespace Reflex
 		return (MenuData&) *menu->self;
 	}
 
+	static Menu*
+	get_root (Menu* menu)
+	{
+		while (menu->parent()) menu = menu->parent();
+		return menu;
+	}
+
+	static void
+	set_modified (Menu* menu)
+	{
+		get_data(get_root(menu)).modified = true;
+	}
+
 	static Menu*
 	get_item_owner (HMENU hparent, uint index)
 	{
 		if (!hparent) return NULL;
 
-		MENUITEMINFO mii = {sizeof(mii)};
-		mii.fMask        = MIIM_DATA;
-		if (!GetMenuItemInfo(hparent, index, TRUE, &mii))
+		MENUITEMINFOW mii = {sizeof(mii)};
+		mii.fMask         = MIIM_DATA;
+		if (!GetMenuItemInfoW(hparent, index, TRUE, &mii))
 			return NULL;
 
 		return (Menu*) mii.dwItemData;
@@ -130,14 +144,14 @@ namespace Reflex
 	{
 		MenuData& self = get_data(item);
 
-		MENUITEMINFO mii = {sizeof(mii)};
-		mii.fMask        = MIIM_ID | MIIM_DATA | MIIM_FTYPE | MIIM_STRING;
-		mii.fType        = MFT_STRING;
-		mii.wID          = self.id;
-		mii.dwItemData   = (ULONG_PTR) item;
-		mii.dwTypeData   = (LPSTR) "";
+		MENUITEMINFOW mii = {sizeof(mii)};
+		mii.fMask         = MIIM_ID | MIIM_DATA | MIIM_FTYPE | MIIM_STRING;
+		mii.fType         = MFT_STRING;
+		mii.wID           = self.id;
+		mii.dwItemData    = (ULONG_PTR) item;
+		mii.dwTypeData    = (LPWSTR) L"";
 
-		if (!InsertMenuItem(hparent, (UINT) index, TRUE, &mii))
+		if (!InsertMenuItemW(hparent, (UINT) index, TRUE, &mii))
 			system_error(__FILE__, __LINE__);
 
 		self.hparent = hparent;
@@ -151,21 +165,54 @@ namespace Reflex
 		return new MenuData();
 	}
 
+	void
+	Menu_validate_shortcut_modifiers (uint modifiers)
+	{
+		static const uint SUPPORTED =
+			MOD_SHIFT | MOD_CONTROL | MOD_ALT | MOD_OPTION;
+
+		if (modifiers & ~SUPPORTED)
+		{
+			argument_error(
+				__FILE__, __LINE__,
+				"modifiers 0x%X can not be used for a shortcut on Windows.",
+				modifiers & ~SUPPORTED);
+		}
+	}
+
+	static String
+	get_shortcut_key_name (int key)
+	{
+		if (key < 0) return "";
+
+		UINT vsc = MapVirtualKeyW((UINT) key, MAPVK_VK_TO_VSC_EX);
+		if (vsc == 0) return "";
+
+		LONG lparam = (LONG) ((vsc & 0xff) << 16);
+		if (vsc & 0xff00) lparam |= 1 << 24;// extended key
+
+		wchar_t name[64] = {0};
+		int len = GetKeyNameTextW(lparam, name, (int) (sizeof(name) / sizeof(*name)));
+		if (len <= 0) return "";
+
+		return String(name, (size_t) len);
+	}
+
 	static String
 	make_item_string (const Menu* menu)
 	{
-		String s        = menu->label();
-		const char* key = menu->shortcut_key();
-		if (key && *key)
+		String str = menu->label();
+		String key = menu->empty() ? get_shortcut_key_name(menu->shortcut_key()) : "";
+		if (!key.empty())
 		{
-			s += '\t';
+			str += '\t';
 			uint mods = menu->shortcut_modifiers();
-			if (mods &  MOD_CONTROL)           s += "Ctrl+";
-			if (mods &  MOD_SHIFT)             s += "Shift+";
-			if (mods & (MOD_ALT | MOD_OPTION)) s += "Alt+";
-			s += key;
+			if (mods &  MOD_CONTROL)           str += "Ctrl+";
+			if (mods &  MOD_SHIFT)             str += "Shift+";
+			if (mods & (MOD_ALT | MOD_OPTION)) str += "Alt+";
+			str += key;
 		}
-		return s;
+		return str;
 	}
 
 	void
@@ -175,22 +222,22 @@ namespace Reflex
 
 		if (!self.hparent) return;
 
-		MENUITEMINFO mii = {sizeof(mii)};
-		mii.fMask        =
+		MENUITEMINFOW mii = {sizeof(mii)};
+		mii.fMask         =
 			MIIM_ID | MIIM_DATA | MIIM_FTYPE | MIIM_STATE | MIIM_BITMAP | MIIM_SUBMENU;
-		mii.wID          = self.id;
-		mii.dwItemData   = (ULONG_PTR) menu;
+		mii.wID           = self.id;
+		mii.dwItemData    = (ULONG_PTR) menu;
 
-		String label;
+		std::wstring label;
 		if (menu->is_separator())
 			mii.fType = MFT_SEPARATOR;
 		else
 		{
-			label = make_item_string(menu);
+			label = make_item_string(menu).to_wstr();
 
 			mii.fMask     |= MIIM_STRING;
 			mii.fType      = MFT_STRING;
-			mii.dwTypeData = (LPSTR) label.c_str();
+			mii.dwTypeData = (LPWSTR) label.c_str();
 			mii.fState     =
 				(menu->is_enabled() ? MFS_ENABLED : MFS_GRAYED) |
 				(menu->is_checked() ? MFS_CHECKED : MFS_UNCHECKED);
@@ -198,20 +245,24 @@ namespace Reflex
 			mii.hSubMenu   = menu->empty() ? NULL : self.hsubmenu;
 		}
 
-		SetMenuItemInfo(self.hparent, self.id, FALSE, &mii);
+		SetMenuItemInfoW(self.hparent, self.id, FALSE, &mii);
+
+		set_modified(menu);
 	}
 
 	void
 	Menu_popup (Menu* menu, View* view, coord x, coord y)
 	{
+		Menu_cancel_active_pointers_for_popup(view);
+
 		MenuData& self = get_data(menu);
 
-		HMENU hmenu = self.get_hsubmenu(menu, false);
+		HMENU hmenu = self.get_hsubmenu(menu);
 		if (!hmenu)
 			invalid_state_error(__FILE__, __LINE__);
 
 		HWND hwnd = NULL;
-		POINT pos = {(int) x, (int) y};
+		POINT pos = Screen_to_native_coord(x, y);
 
 		if (view)
 		{
@@ -223,9 +274,7 @@ namespace Reflex
 			if (!hwnd)
 				invalid_state_error(__FILE__, __LINE__);
 
-			Point p = view->to_window(Point(x, y));
-			pos.x   = (int) p.x;
-			pos.y   = (int) p.y;
+			pos = Window_to_native_coord(*win, view->to_window(Point(x, y)));
 			ClientToScreen(hwnd, &pos);
 		}
 		else
@@ -233,14 +282,8 @@ namespace Reflex
 
 		if (!hwnd) return;
 
-		// TrackPopupMenu needs the owner window in the foreground, and the
-		// trailing WM_NULL is the documented workaround for the menu not closing
-		// on the first outside click.
-		SetForegroundWindow(hwnd);
-		TrackPopupMenu(
-			hmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON,
-			pos.x, pos.y, 0, hwnd, NULL);
-		PostMessage(hwnd, WM_NULL, 0, 0);
+		Menu_track_popup(
+			hmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON, pos, hwnd);
 	}
 
 	void
@@ -267,12 +310,107 @@ namespace Reflex
 
 		RemoveMenu(p.hsubmenu, c.id, MF_BYCOMMAND);
 		c.hparent = NULL;
+
+		set_modified(parent);
+	}
+
+
+	void
+	Menu_track_popup (HMENU hmenu, UINT flags, POINT pos, HWND owner)
+	{
+		double start = Xot::time();
+
+		// TrackPopupMenu needs the owner window in the foreground
+		SetForegroundWindow(owner);
+
+		TrackPopupMenu(hmenu, flags, pos.x, pos.y, 0, owner, NULL);
+
+		// the documented workaround for the menu not closing
+		// on the first outside click
+		PostMessageW(owner, WM_NULL, 0, 0);
+
+		Window_skip_update_time_of_all(Xot::time() - start);
 	}
 
 	HMENU
-	Menu_get_hmenu (Menu* menu)
+	Menu_get_hmenu (Menu* menu, bool menubar)
+	{
+		return menu ? get_data(menu).get_hsubmenu(menu, menubar) : NULL;
+	}
+
+	bool
+	Menu_is_modified (Menu* menu)
 	{
-		return menu ? get_data(menu).get_hsubmenu(menu, true) : NULL;
+		return menu && get_data(menu).modified;
+	}
+
+	static void
+	collect_accels (std::vector<ACCEL>* accels, Menu* menu)
+	{
+		for (auto& child : *menu)
+		{
+			Menu* item = child.get();
+			if (!item) continue;
+
+			int key = item->shortcut_key();
+			if (key >= 0 && item->empty())
+			{
+				uint mods = item->shortcut_modifiers();
+
+				ACCEL accel = {0};
+				accel.key   = (WORD) key;// KeyCode == VK
+				accel.cmd   = (WORD) get_data(item).id;
+				accel.fVirt = (BYTE)              (FVIRTKEY      |
+					(mods &  MOD_CONTROL           ? FCONTROL : 0) |
+					(mods &  MOD_SHIFT             ? FSHIFT   : 0) |
+					(mods & (MOD_ALT | MOD_OPTION) ? FALT     : 0));
+				accels->emplace_back(accel);
+			}
+
+			collect_accels(accels, item);
+		}
+	}
+
+	HACCEL
+	Menu_create_accelerator_table (Menu* menu)
+	{
+		if (!menu) return NULL;
+
+		get_data(menu).modified = false;
+
+		std::vector<ACCEL> accels;
+		collect_accels(&accels, menu);
+		if (accels.empty()) return NULL;
+
+		return CreateAcceleratorTableW(accels.data(), (int) accels.size());
+	}
+
+	static Menu*
+	find_item (Menu* menu, UINT id)
+	{
+		for (auto& child : *menu)
+		{
+			Menu* item = child.get();
+			if (!item || !item->is_enabled()) continue;
+
+			if (get_data(item).id == id) return item;
+
+			Menu* found = find_item(item, id);
+			if (found) return found;
+		}
+		return NULL;
+	}
+
+	void
+	Menu_call_command_event (Menu* menu, uint id)
+	{
+		if (!menu) return;
+
+		Menu* item = find_item(menu, (UINT) id);
+		if (!item) return;
+
+		Event e;
+		Menu_call_click_event(item, &e);
 	}
 
 	void
@@ -282,7 +420,7 @@ namespace Reflex
 		if (!menu) return;
 
 		Event e;
-		menu->on_click(&e);
+		Menu_call_click_event(menu, &e);
 	}
 
 	void
@@ -292,7 +430,7 @@ namespace Reflex
 		if (!menu) return;
 
 		Event e;
-		menu->on_open_submenu(&e);
+		Menu_call_open_submenu_event(menu, &e);
 
 		int count = GetMenuItemCount(hmenu);
 		for (int i = 0; i < count; ++i)
@@ -301,7 +439,7 @@ namespace Reflex
 			if (!child) continue;
 
 			Event ce;
-			child->on_show(&ce);
+			Menu_call_show_event(child, &ce);
 		}
 	}
 
@@ -318,11 +456,11 @@ namespace Reflex
 			if (!child) continue;
 
 			Event ce;
-			child->on_hide(&ce);
+			Menu_call_hide_event(child, &ce);
 		}
 
 		Event e;
-		menu->on_close_submenu(&e);
+		Menu_call_close_submenu_event(menu, &e);
 	}
 
 

data/src/win32/menu.h

@@ -12,7 +12,15 @@ namespace Reflex
 {
 
 
-	HMENU Menu_get_hmenu (Menu* menu);
+	void Menu_track_popup (HMENU hmenu, UINT flags, POINT pos, HWND owner);
+
+	HMENU Menu_get_hmenu (Menu* menu, bool menubar = false);
+
+	bool Menu_is_modified (Menu* menu);
+
+	HACCEL Menu_create_accelerator_table (Menu* menu);
+
+	void Menu_call_command_event (Menu* menu, uint id);
 
 	void Menu_call_command_event (HMENU hmenu, uint index);
 

data/src/win32/opengl.cpp

@@ -3,14 +3,7 @@
 
 #include <rays/rays.h>
 #include "reflex/exception.h"
-
-
-namespace Rays
-{
-
-	const PIXELFORMATDESCRIPTOR* get_pixel_format_descriptor ();
-
-}// Rays
+#include "../rays.h"
 
 
 namespace Reflex
@@ -40,7 +33,7 @@ namespace Reflex
 		if (!hdc)
 			system_error(__FILE__, __LINE__);
 
-		const auto* pfd = Rays::get_pixel_format_descriptor();
+		const auto* pfd = Rays::OpenGL_get_pixel_format_descriptor();
 		int pf          = ChoosePixelFormat(hdc, pfd);
 		if (pf == 0)
 			system_error(__FILE__, __LINE__);

data/src/win32/reflex.cpp

@@ -1,17 +1,38 @@
 #include "reflex/reflex.h"
 
 
+#include <xot/windows.h>
 #include "reflex/exception.h"
+#include "../rays.h"
 
 
 namespace Reflex
 {
 
 
+	static struct ReflexLoaded
+	{
+		ReflexLoaded ()
+		{
+			Rays::Rays_set_pre_init_fun(pre_init);
+		}
+
+		static void pre_init ()
+		{
+			// enable High DPI: before Rays makes the hidden window for its OpenGL
+			// context, as Windows takes no declaration after a window
+			SetProcessDPIAware();
+		}
+
+	} reflex_loaded;
+
+
 	namespace global
 	{
 
-		static bool initialized = false;
+		static bool initialized     = false;
+
+		static bool com_initialized = false;
 
 	}// global
 
@@ -21,8 +42,10 @@ namespace Reflex
 	{
 		if (global::initialized)
 			reflex_error(__FILE__, __LINE__, "already initialized.");
-
 		global::initialized = true;
+
+		global::com_initialized =
+			SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED));
 	}
 
 	void
@@ -30,8 +53,26 @@ namespace Reflex
 	{
 		if (!global::initialized)
 			reflex_error(__FILE__, __LINE__, "not initialized.");
-
 		global::initialized = false;
+
+		if (global::com_initialized)
+		{
+			CoUninitialize();
+			global::com_initialized = false;
+		}
+	}
+
+	void
+	alert (const char* message, const char* title)
+	{
+		if (!message)
+			argument_error(__FILE__, __LINE__);
+
+		MessageBoxW(
+			GetActiveWindow(),
+			String(message)           .to_wstr().c_str(),
+			String(title ? title : "").to_wstr().c_str(),
+			MB_OK | MB_ICONINFORMATION | MB_TASKMODAL);
 	}
 
 

data/src/win32/screen.cpp

@@ -1,6 +1,11 @@
 #include "screen.h"
 
 
+#include <math.h>
+#include <wchar.h>
+#include <algorithm>
+#include <memory>
+#include <vector>
 #include "reflex/exception.h"
 
 
@@ -22,6 +27,56 @@ namespace Reflex
 		pthis->self->handle = hmonitor;
 	}
 
+	float
+	Screen_get_pixel_density (HMONITOR hmonitor)
+	{
+		static float density = 0;
+		if (density <= 0)
+		{
+			std::shared_ptr<HDC__> dc(GetDC(NULL), [](HDC dc) {if (dc) ReleaseDC(NULL, dc);});
+			int dpi = dc ? GetDeviceCaps(dc.get(), LOGPIXELSX) : 0;
+			density = dpi > 0 ? dpi / (float) USER_DEFAULT_SCREEN_DPI : 1;
+		}
+		return density;
+	}
+
+	Bounds
+	Screen_from_native_coord (const RECT& rect)
+	{
+		float density = Screen_get_pixel_density(
+			MonitorFromRect(&rect, MONITOR_DEFAULTTONEAREST));
+		return Bounds(
+			 rect.left                / density,
+			 rect.top                 / density,
+			(rect.right  - rect.left) / density,
+			(rect.bottom - rect.top)  / density);
+	}
+
+	POINT
+	Screen_to_native_coord (coord x, coord y)
+	{
+		// NULL: the monitor is unknown from points, but every monitor has the
+		// same system density for now
+		float density = Screen_get_pixel_density(NULL);
+
+		return {
+			(LONG) lround(x * density),
+			(LONG) lround(y * density)
+		};
+	}
+
+	RECT
+	Screen_to_native_coord (coord x, coord y, coord width, coord height)
+	{
+		float density = Screen_get_pixel_density(NULL);
+		return {
+			(LONG) lround( x           * density),
+			(LONG) lround( y           * density),
+			(LONG) lround((x + width)  * density),
+			(LONG) lround((y + height) * density)
+		};
+	}
+
 
 	Screen::Screen ()
 	{
@@ -31,6 +86,73 @@ namespace Reflex
 	{
 	}
 
+	static String
+	get_monitor_name (const wchar_t* device)
+	{
+		UINT32 npaths = 0, nmodes = 0;
+		if (GetDisplayConfigBufferSizes(QDC_ONLY_ACTIVE_PATHS, &npaths, &nmodes) != ERROR_SUCCESS)
+			return "";
+
+		std::vector<DISPLAYCONFIG_PATH_INFO> paths(npaths);
+		std::vector<DISPLAYCONFIG_MODE_INFO> modes(nmodes);
+		LONG ret = QueryDisplayConfig(
+			QDC_ONLY_ACTIVE_PATHS, &npaths, paths.data(), &nmodes, modes.data(), NULL);
+		if (ret != ERROR_SUCCESS)
+			return "";
+
+		for (UINT32 i = 0; i < npaths; ++i)
+		{
+			const auto& path = paths[i];
+
+			DISPLAYCONFIG_SOURCE_DEVICE_NAME source = {};
+			source.header.type      = DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME;
+			source.header.size      = sizeof(source);
+			source.header.adapterId = path.sourceInfo.adapterId;
+			source.header.id        = path.sourceInfo.id;
+			if (
+				DisplayConfigGetDeviceInfo(&source.header) != ERROR_SUCCESS ||
+				wcscmp(source.viewGdiDeviceName, device)   != 0)
+			{
+				continue;
+			}
+
+			DISPLAYCONFIG_TARGET_DEVICE_NAME target = {};
+			target.header.type      = DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME;
+			target.header.size      = sizeof(target);
+			target.header.adapterId = path.targetInfo.adapterId;
+			target.header.id        = path.targetInfo.id;
+			if (DisplayConfigGetDeviceInfo(&target.header) != ERROR_SUCCESS)
+				continue;
+
+			const wchar_t* name = target.monitorFriendlyDeviceName;
+			if (*name)
+				return String(name, wcslen(name));
+		}
+		return "";
+	}
+
+	String
+	Screen::name () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		MONITORINFOEXW mi = {};
+		mi.cbSize         = sizeof(mi);
+		if (!GetMonitorInfoW(self->handle, &mi))
+			system_error(__FILE__, __LINE__);
+
+		String name = get_monitor_name(mi.szDevice);
+		if (name.empty())
+		{
+			const wchar_t* device = mi.szDevice;
+			if (wcsncmp(device, L"\\\\.\\", 4) == 0) device += 4;
+			name = String(device, wcslen(device));
+		}
+
+		return name;
+	}
+
 	Bounds
 	Screen::frame () const
 	{
@@ -39,11 +161,19 @@ namespace Reflex
 
 		MONITORINFO mi = {0};
 		mi.cbSize      = sizeof(mi);
-		if (!GetMonitorInfo(self->handle, &mi))
+		if (!GetMonitorInfoW(self->handle, &mi))
 			system_error(__FILE__, __LINE__);
 
-		const auto& r = mi.rcMonitor;
-		return Bounds(r.left, r.top, r.right - r.left, r.bottom - r.top);
+		return Screen_from_native_coord(mi.rcMonitor);
+	}
+
+	float
+	Screen::pixel_density () const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return Screen_get_pixel_density(self->handle);
 	}
 
 	Screen::operator bool () const
@@ -57,5 +187,36 @@ namespace Reflex
 		return !operator bool();
 	}
 
+	static BOOL CALLBACK
+	add_screen (HMONITOR hmonitor, HDC, LPRECT, LPARAM lp)
+	{
+		Screen s;
+		Screen_initialize(&s, hmonitor);
+		((Screen::List*) lp)->emplace_back(s);
+		return TRUE;
+	}
+
+	static bool
+	is_primary (const Screen& screen)
+	{
+		MONITORINFO mi = {0};
+		mi.cbSize      = sizeof(mi);
+		if (!GetMonitorInfoW(screen.self->handle, &mi))
+			return false;
+
+		return mi.dwFlags & MONITORINFOF_PRIMARY;
+	}
+
+	Screen::List
+	Screen::all ()
+	{
+		List list;
+		if (!EnumDisplayMonitors(NULL, NULL, add_screen, (LPARAM) &list))
+			system_error(__FILE__, __LINE__);
+
+		std::stable_partition(list.begin(), list.end(), is_primary);
+		return list;
+	}
+
 
 }// Reflex

data/src/win32/screen.h

@@ -14,6 +14,14 @@ namespace Reflex
 
 	void Screen_initialize (Screen* pthis, HMONITOR hmonitor);
 
+	float Screen_get_pixel_density (HMONITOR hmonitor);
+
+	Bounds Screen_from_native_coord (const RECT& rect);
+
+	POINT    Screen_to_native_coord (coord x, coord y);
+
+	RECT     Screen_to_native_coord (coord x, coord y, coord width, coord height);
+
 
 }// Reflex