reflexion 0.5.3 → 0.7.0

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
 

data/src/win32/tray.cpp

@@ -0,0 +1,191 @@
+#include "tray.h"
+
+
+#include <vector>
+#include <xot/windows.h>
+#include <shellapi.h>
+#include "reflex/exception.h"
+#include "../rays.h"
+#include "application.h"
+#include "menu.h"
+
+
+namespace Reflex
+{
+
+
+	enum {TRAY_ICON_ID = 1, WM_TRAY_ICON = WM_APP + 1};
+
+	static HWND tray_hwnd  = NULL;
+
+	static Menu* tray_menu = NULL;
+
+	static HICON tray_icon = NULL;
+
+	static bool tray_shown = false;
+
+
+	static void
+	popup_tray_menu ()
+	{
+		if (!tray_hwnd || !tray_menu) return;
+
+		POINT pos;
+		if (!GetCursorPos(&pos)) return;
+
+		Menu_track_popup(
+			Menu_get_hmenu(tray_menu),
+			TPM_LEFTALIGN | TPM_BOTTOMALIGN | TPM_RIGHTBUTTON, pos, tray_hwnd);
+	}
+
+	static LRESULT CALLBACK
+	tray_wndproc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
+	{
+		if (Application_has_exception())
+			return DefWindowProcW(hwnd, msg, wp, lp);
+
+		return Application_guard([&]() -> LRESULT
+		{
+			switch (msg)
+			{
+				case WM_TRAY_ICON:
+				{
+					if (lp == WM_LBUTTONUP || lp == WM_RBUTTONUP)
+						popup_tray_menu();
+					return 0;
+				}
+
+				case WM_MENUCOMMAND:
+				{
+					Menu_call_command_event((HMENU) lp, (uint) wp);
+					return 0;
+				}
+
+				case WM_INITMENUPOPUP:
+				{
+					Menu_call_open_event((HMENU) wp);
+					break;
+				}
+
+				case WM_UNINITMENUPOPUP:
+				{
+					Menu_call_close_event((HMENU) wp);
+					break;
+				}
+			}
+			return DefWindowProcW(hwnd, msg, wp, lp);
+		}, (LRESULT) 0);
+	}
+
+	static HWND
+	create_tray_window ()
+	{
+		static const wchar_t* WINDOWCLASS = L"Reflex:TrayWindowClass";
+
+		WNDCLASSEXW wc   = {sizeof(wc)};
+		wc.lpfnWndProc   = tray_wndproc;
+		wc.hInstance     = GetModuleHandle(NULL);
+		wc.lpszClassName = WINDOWCLASS;
+		if (!RegisterClassExW(&wc))
+			system_error(__FILE__, __LINE__);
+
+		HWND hwnd = CreateWindowExW(
+			WS_EX_TOOLWINDOW, WINDOWCLASS, L"", WS_POPUP,
+			0, 0, 0, 0, NULL, NULL, wc.hInstance, NULL);
+		if (!hwnd)
+			system_error(__FILE__, __LINE__);
+
+		return hwnd;
+	}
+
+	static HICON
+	create_tray_icon (const Image& image)
+	{
+		HBITMAP color = Rays::Bitmap_get_hbitmap(image.bitmap());
+		if (!color) return NULL;
+
+		BITMAP bmp = {0};
+		GetObjectW(color, sizeof(bmp), &bmp);
+
+		// the mask is required but the alpha channel decides what shows,
+		// so it stays all zero
+		int stride = ((bmp.bmWidth + 15) / 16) * 2;
+		std::vector<BYTE> zero((size_t) stride * bmp.bmHeight, 0);
+		HBITMAP mask = CreateBitmap(bmp.bmWidth, bmp.bmHeight, 1, 1, zero.data());
+
+		ICONINFO info = {0};
+		info.fIcon    = TRUE;
+		info.hbmColor = color;
+		info.hbmMask  = mask;
+
+		HICON icon = CreateIconIndirect(&info);
+		DeleteObject(mask);
+		DeleteObject(color);
+		return icon;
+	}
+
+	void
+	Tray_update_icon (Application* app)
+	{
+		Menu* menu = app ? app->background_menu() : NULL;
+		if (!menu && app && app->background())
+			menu = app->menu();
+
+		if (!menu)
+		{
+			Tray_remove_icon();
+			Application_quit_if_should();
+			return;
+		}
+
+		if (!tray_hwnd)
+			tray_hwnd = create_tray_window();
+
+		if (tray_icon)
+		{
+			DestroyIcon(tray_icon);
+			tray_icon = NULL;
+		}
+		if (menu->image())
+			tray_icon = create_tray_icon(menu->image());
+
+		String tip           = menu->label();
+		if (tip.empty()) tip = app->name();
+
+		NOTIFYICONDATAW nid  = {sizeof(nid)};
+		nid.hWnd             = tray_hwnd;
+		nid.uID              = TRAY_ICON_ID;
+		nid.uFlags           = NIF_MESSAGE | NIF_ICON | NIF_TIP;
+		nid.uCallbackMessage = WM_TRAY_ICON;
+		nid.hIcon            =
+			tray_icon ? tray_icon : LoadIconW(NULL, (LPCWSTR) IDI_APPLICATION);
+		lstrcpynW(nid.szTip, tip.to_wstr().c_str(), sizeof(nid.szTip) / sizeof(*nid.szTip));
+
+		Shell_NotifyIconW(tray_shown ? NIM_MODIFY : NIM_ADD, &nid);
+		tray_shown = true;
+		tray_menu  = menu;
+	}
+
+	void
+	Tray_remove_icon ()
+	{
+		if (tray_shown)
+		{
+			NOTIFYICONDATAW nid = {sizeof(nid)};
+			nid.hWnd            = tray_hwnd;
+			nid.uID             = TRAY_ICON_ID;
+			Shell_NotifyIconW(NIM_DELETE, &nid);
+			tray_shown = false;
+		}
+
+		if (tray_icon)
+		{
+			DestroyIcon(tray_icon);
+			tray_icon = NULL;
+		}
+
+		tray_menu = NULL;
+	}
+
+
+}// Reflex

data/src/win32/tray.h

@@ -0,0 +1,22 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WIN32_TRAY_H__
+#define __REFLEX_SRC_WIN32_TRAY_H__
+
+
+#include "application.h"
+
+
+namespace Reflex
+{
+
+
+	void Tray_update_icon (Application* app);
+
+	void Tray_remove_icon ();
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/win32/vk.cpp

@@ -0,0 +1,11 @@
+// vk.h needs VK_NAVIGATION_*, but winuser.h defines them only when
+// _WIN32_WINNT >= 0x0604, and RbConfig's CPPFLAGS sets it to 0x0600.
+// so set a higher value here before vk.h includes windows.h.
+#if _WIN32_WINNT >= 0x0604
+	#error _WIN32_WINNT is now high enough; delete this workaround
+#endif
+
+#undef  _WIN32_WINNT
+#define _WIN32_WINNT 0x0A00
+
+#include "../vk.h"