reflexion 0.5.3 → 0.7.0

data/src/win32/window.cpp

@@ -1,19 +1,28 @@
 #include "window.h"
 
 
+#include <xot/windows.h>
+#include <imm.h>
+#include <dwmapi.h>
+#include <shellapi.h>
+
 #include <assert.h>
+#include <limits.h>
+#include <math.h>
 #include <map>
 #include <memory>
 #include <xot/time.h>
-#include <xot/windows.h>
 #include <rays/rays.h>
 #include "reflex/defs.h"
 #include "reflex/exception.h"
 #include "reflex/debug.h"
+#include "../application.h"
 #include "../view.h"
 #include "event.h"
-#include "gamepad.h"
+#include "application.h"
+#include "menu.h"
 #include "screen.h"
+#include "gamepad.h"
 #include "opengl.h"
 
 
@@ -24,17 +33,26 @@ namespace Reflex
 	typedef std::map<int, String> PressingKeyMap;
 
 
-	static const char* WINDOWCLASS   = "Reflex:WindowClass";
+	static const wchar_t* WINDOWCLASS   = L"Reflex:WindowClass";
 
-	static const char* USERDATA_PROP = "Reflex:Window:HWND";
+	static const wchar_t* USERDATA_PROP = L"Reflex:Window:HWND";
 
 
 	struct WindowData : public Window::Data
 	{
 
-		HWND hwnd        = NULL;
+		HWND hwnd                 = NULL;
+
+		bool need_rebind          = false;
+
+		bool transparent          = false;
 
-		bool need_rebind = false;
+		bool tracking_mouse       = false;
+
+		// the first half of a surrogate pair, waiting for the second half
+		wchar_t pending_surrogate = 0;
+
+		HACCEL haccel             = NULL;
 
 		OpenGLContext context;
 
@@ -42,6 +60,17 @@ namespace Reflex
 
 		mutable String title_tmp;
 
+		virtual ~WindowData ()
+		{
+			set_accelerator_table(NULL);
+		}
+
+		void set_accelerator_table (HACCEL haccel)
+		{
+			if (this->haccel) DestroyAcceleratorTable(this->haccel);
+			this->haccel = haccel;
+		}
+
 		bool is_valid () const
 		{
 			return hwnd && IsWindow(hwnd);
@@ -64,12 +93,20 @@ namespace Reflex
 		return get_data(const_cast<Window*>(window));
 	}
 
+	HWND
+	Window_get_hwnd (const Window* window)
+	{
+		if (!window) return NULL;
+
+		return get_data(window)->hwnd;
+	}
+
 	static bool
 	window_has_wndproc (HWND hwnd)
 	{
 		if (!hwnd) return false;
 
-		WNDPROC proc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC);
+		WNDPROC proc = (WNDPROC) GetWindowLongPtrW(hwnd, GWLP_WNDPROC);
 		if (proc == wndproc)
 			return true;
 
@@ -77,24 +114,42 @@ namespace Reflex
 		// it can not determine the hwnd is mine or not.
 
 		enum {BUFSIZE = 256};
-		char buf[BUFSIZE + 1];
+		wchar_t buf[BUFSIZE + 1];
 		if (
-			GetClassName(hwnd, &buf[0], BUFSIZE) == 0 &&
+			GetClassNameW(hwnd, &buf[0], BUFSIZE) == 0 &&
 			GetLastError() != 0)
 		{
 			return false;
 		}
 
-		return stricmp(buf, WINDOWCLASS) == 0;
+		return _wcsicmp(buf, WINDOWCLASS) == 0;
 	}
 
 	static Window*
 	get_window_from_hwnd (HWND hwnd)
 	{
 		if (window_has_wndproc(hwnd))
-			return (Window*) GetWindowLongPtr(hwnd, GWLP_USERDATA);
+			return (Window*) GetWindowLongPtrW(hwnd, GWLP_USERDATA);
 		else
-			return (Window*) GetProp(hwnd, USERDATA_PROP);
+			return (Window*) GetPropW(hwnd, USERDATA_PROP);
+	}
+
+	bool
+	Window_translate_accelerator (MSG* msg)
+	{
+		if (!msg || !msg->hwnd) return false;
+
+		if (msg->message != WM_KEYDOWN && msg->message != WM_SYSKEYDOWN)
+			return false;
+
+		HWND hwnd   = GetAncestor(msg->hwnd, GA_ROOT);
+		Window* win = get_window_from_hwnd(hwnd);
+		if (!win) return false;
+
+		HACCEL haccel = get_data(win)->haccel;
+		if (!haccel) return false;
+
+		return TranslateAcceleratorW(hwnd, haccel, msg) != 0;
 	}
 
 	static void
@@ -108,13 +163,13 @@ namespace Reflex
 		if (window_has_wndproc(hwnd))
 		{
 			SetLastError(0);
-			SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR) win);
+			SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) win);
 			if (GetLastError() != 0)
 				system_error(__FILE__, __LINE__);
 		}
 		else
 		{
-			if (!SetProp(hwnd, USERDATA_PROP, (HANDLE) win))
+			if (!SetPropW(hwnd, USERDATA_PROP, (HANDLE) win))
 				system_error(__FILE__, __LINE__);
 		}
 
@@ -155,13 +210,13 @@ namespace Reflex
 		if (window_has_wndproc(self->hwnd))
 		{
 			SetLastError(0);
-			SetWindowLongPtr(self->hwnd, GWLP_USERDATA, 0);
+			SetWindowLongPtrW(self->hwnd, GWLP_USERDATA, 0);
 			if (GetLastError() != 0)
 				system_error(__FILE__, __LINE__);
 		}
 		else
 		{
-			if (!RemoveProp(self->hwnd, USERDATA_PROP))
+			if (!RemovePropW(self->hwnd, USERDATA_PROP))
 				system_error(__FILE__, __LINE__);
 		}
 
@@ -170,8 +225,162 @@ namespace Reflex
 
 		win->release();
 
-		if (Window_all().empty())
-			Reflex::app()->quit();
+		Application_quit_if_should();
+	}
+
+	static bool
+	has_style (HWND hwnd, DWORD style)
+	{
+		return ((DWORD) GetWindowLongPtrW(hwnd, GWL_STYLE) & style) == style;
+	}
+
+	static bool
+	calc_size (LRESULT* result, HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
+	{
+		if (
+			!wp || IsZoomed(hwnd) ||
+			has_style(hwnd, WS_CAPTION) || !has_style(hwnd, WS_THICKFRAME))
+		{
+			return false;
+		}
+
+		// without a caption the sizing border is still drawn at the
+		// top of the window, so let the client area cover it
+		NCCALCSIZE_PARAMS* params = (NCCALCSIZE_PARAMS*) lp;
+		LONG top                  = params->rgrc[0].top;
+		*result                   = DefWindowProcW(hwnd, msg, wp, lp);
+		params->rgrc[0].top       = top;
+		return true;
+	}
+
+	static int
+	border_size ()
+	{
+		return
+			GetSystemMetrics(SM_CYSIZEFRAME) +
+			GetSystemMetrics(SM_CXPADDEDBORDER);
+	}
+
+	static bool
+	hit_test (LRESULT* result, Window* win, HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
+	{
+		// the client area covers the sizing border, or there is no border at
+		// all, so an edge answers HTCLIENT and cannot resize. this gives the
+		// edges back.
+		if (has_style(hwnd, WS_CAPTION) || IsZoomed(hwnd))
+			return false;
+
+		LRESULT hit = DefWindowProcW(hwnd, msg, wp, lp);
+
+		// the sizing border of a window that cannot resize is only there for
+		// the shadow, so its edges answer as a plain border
+		if (!win || !win->has_flag(Window::FLAG_RESIZABLE))
+		{
+			*result = HTBORDER;
+			return HTSIZEFIRST <= hit && hit <= HTSIZELAST;
+		}
+
+		if (hit != HTCLIENT)
+			return false;
+
+		RECT window;
+		if (!GetWindowRect(hwnd, &window))
+			system_error(__FILE__, __LINE__);
+
+		int size    = border_size();
+		POINT pos   = {GET_X_LPARAM(lp), GET_Y_LPARAM(lp)};
+		bool left   = pos.x <  window.left   + size;
+		bool right  = pos.x >= window.right  - size;
+		bool top    = pos.y <  window.top    + size;
+		bool bottom = pos.y >= window.bottom - size;
+
+		// a sizing border draws the other edges outside the client area
+		if (has_style(hwnd, WS_THICKFRAME) && !top)
+			return false;
+
+		int corner  = size * 2;
+		bool near_l = pos.x <  window.left   + corner;
+		bool near_r = pos.x >= window.right  - corner;
+		bool near_t = pos.y <  window.top    + corner;
+		bool near_b = pos.y >= window.bottom - corner;
+
+		if      (top    && near_l) *result =    HTTOPLEFT;
+		else if (top    && near_r) *result =    HTTOPRIGHT;
+		else if (bottom && near_l) *result = HTBOTTOMLEFT;
+		else if (bottom && near_r) *result = HTBOTTOMRIGHT;
+		else if (left   && near_t) *result =    HTTOPLEFT;
+		else if (left   && near_b) *result = HTBOTTOMLEFT;
+		else if (right  && near_t) *result =    HTTOPRIGHT;
+		else if (right  && near_b) *result = HTBOTTOMRIGHT;
+		else if (top)              *result = HTTOP;
+		else if (bottom)           *result = HTBOTTOM;
+		else if (left)             *result = HTLEFT;
+		else if (right)            *result = HTRIGHT;
+		else return false;
+
+		return true;
+	}
+
+	static void
+	keep_caption_on_screen (HWND hwnd, RECT* rect)
+	{
+		if (!has_style(hwnd, WS_CAPTION)) return;
+
+		HMONITOR hmonitor = MonitorFromRect(rect, MONITOR_DEFAULTTONEAREST);
+		if (!hmonitor) return;
+
+		MONITORINFO info = {sizeof(info)};
+		if (!GetMonitorInfoW(hmonitor, &info))
+			system_error(__FILE__, __LINE__);
+
+		LONG over = info.rcWork.top - rect->top;
+		if (over <= 0) return;
+
+		rect->top    += over;
+		rect->bottom += over;
+	}
+
+	static bool
+	window_pos_changing (
+		LRESULT* result, Window* win, HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
+	{
+		WINDOWPOS* pos = (WINDOWPOS*) lp;
+
+		if (win && win->has_flag(Window::FLAG_ALWAYS_ON_BOTTOM))
+		{
+			pos->hwndInsertAfter = HWND_BOTTOM;
+			pos->flags          &= ~SWP_NOZORDER;
+		}
+
+		if (!(pos->flags & SWP_SHOWWINDOW) && !IsWindowVisible(hwnd))
+		{
+			// a hidden window gets the size it asks for, but windows widens
+			// a captioned one here, so take the width back
+			int cx  = pos->cx;
+			*result = DefWindowProcW(hwnd, msg, wp, lp);
+			pos->cx = cx;
+			return true;
+		}
+
+		if (!(pos->flags & SWP_NOMOVE) && !IsIconic(hwnd) && !IsZoomed(hwnd))
+		{
+			// once on screen the caption has to stay where it can be grabbed
+			RECT rect = {pos->x, pos->y, pos->x + pos->cx, pos->y + pos->cy};
+			keep_caption_on_screen(hwnd, &rect);
+			pos->y = rect.top;
+		}
+
+		return false;
+	}
+
+	static void
+	update_accelerator_table (Window* win)
+	{
+		Menu* menu = win->menu();
+		if (!menu || !Menu_is_modified(menu))
+			return;
+
+		get_data(win)->set_accelerator_table(Menu_create_accelerator_table(menu));
 	}
 
 	void
@@ -179,11 +388,12 @@ namespace Reflex
 	{
 		WindowData* self = get_data(win);
 
+		update_accelerator_table(win);
 		Gamepad_poll();
 
 		Window_call_update_event(win);
 
-		if (self->redraw)
+		if (Xot::check_and_remove_flag(&self->flags, Window::Data::REDRAW))
 		{
 			#if 1
 				InvalidateRect(self->hwnd, NULL, FALSE);
@@ -191,8 +401,6 @@ namespace Reflex
 				RedrawWindow(
 					self->hwnd, NULL, NULL, RDW_ERASE |  RDW_INVALIDATE | EDW_ALLCHILDREN);
 			#endif
-
-			self->redraw = false;
 		}
 	}
 
@@ -219,32 +427,51 @@ namespace Reflex
 		Window_call_draw_event(win, &e);
 	}
 
-	static void
-	frame_changed (Window* win)
+	static String
+	get_chars (WindowData* self, UINT msg)
 	{
-		Rays::Bounds b           = win->frame();
-		Rays::Point dpos         = b.position() - win->self->prev_position;
-		Rays::Point dsize        = b.size()     - win->self->prev_size;
-		win->self->prev_position = b.position();
-		win->self->prev_size     = b.size();
-
-		if (dpos == 0 && dsize == 0) return;
-
-		Reflex::FrameEvent e(b, dpos.x, dpos.y, 0, dsize.x, dsize.y, 0);
-		if (dpos  != 0) win->on_move(&e);
-		if (dsize != 0)
+		MSG wmchar;
+		UINT filter = msg == WM_SYSKEYDOWN ? WM_SYSCHAR : WM_CHAR;
+		BOOL peeked = PeekMessageW(&wmchar, self->hwnd, filter, filter, PM_NOREMOVE);
+		if (peeked)
 		{
-			Rays::Bounds b = win->frame();
-			b.move_to(0, 0);
-
-			if (win->painter())
-				win->painter()->canvas(b, win->painter()->pixel_density());
+			// a character outside the BMP is injected as one VK_PACKET per
+			// UTF-16 code unit, so the halves of the surrogate pair arrive in
+			// two key events and the first of them has to be held back until
+			// the second one completes the character.
+			wchar_t unit            = (wchar_t) wmchar.wParam;
+			wchar_t pending         = self->pending_surrogate;
+			self->pending_surrogate = 0;
+
+			if (IS_HIGH_SURROGATE(unit))
+				self->pending_surrogate = unit;
+			else if (IS_LOW_SURROGATE(unit))
+			{
+				if (pending)
+				{
+					wchar_t pair[] = {pending, unit};
+					return String(pair, 2);
+				}
+			}
+			else
+				return String(&unit, 1);
+		}
+		return "";
+	}
 
-			if (win->root())
-				View_set_frame(win->root(), b);
+	static bool
+	accepts_text_input (Window* win)
+	{
+		const View* focus = win->focus();
+		return focus && focus->accepts_text_input();
+	}
 
-			win->on_resize(&e);
-		}
+	// macos never commits a control character, so it is not text here either
+	static bool
+	is_committable (const String& chars)
+	{
+		uchar c = chars.empty() ? 0 : (uchar) chars[0];
+		return c >= 0x20 && c != 0x7f;
 	}
 
 	static void
@@ -252,23 +479,26 @@ namespace Reflex
 	{
 		assert(*win);
 
-		WindowData* self = get_data(win);
+		if (wp == VK_PROCESSKEY) return;
 
-		MSG wmchar;
-		UINT filter = msg == WM_SYSKEYDOWN ? WM_SYSCHAR : WM_CHAR;
-		BOOL peeked = PeekMessage(&wmchar, self->hwnd, filter, filter, PM_NOREMOVE);
+		WindowData* self = get_data(win);
 
-		String chars;
-		if (peeked) chars += (char) wmchar.wParam;
+		String chars = get_chars(self, msg);
 
 		NativeKeyEvent e(msg, wp, lp, chars);
-
 		self->pressing_keys.insert_or_assign(e.code(), chars);
+
 #if 0
 		for (auto kv : self->pressing_keys)
 			doutln("0x%x : %s", kv.first, (const char*) kv.second);
 #endif
 
+		if (accepts_text_input(win) && is_committable(chars))
+		{
+			TextEvent te(TextEvent::COMMIT, chars);
+			Window_call_text_event(win, &te);
+		}
+
 		Window_call_key_event(win, &e);
 	}
 
@@ -283,11 +513,73 @@ namespace Reflex
 
 		auto it = self->pressing_keys.find(e.code());
 		if (it != self->pressing_keys.end())
+		{
 			KeyEvent_set_chars(&e, it->second);
+			self->pressing_keys.erase(it);
+		}
 
 		Window_call_key_event(win, &e);
+	}
+
+	static void
+	update_composition (Window* win, LPARAM lp)
+	{
+		assert(*win);
+
+		WindowData* self = get_data(win);
+
+		HIMC himc = ImmGetContext(self->hwnd);
+		if (!himc) return;
+
+		if (lp & GCS_RESULTSTR)
+		{
+			NativeTextEvent e(TextEvent::COMMIT, himc, GCS_RESULTSTR);
+			Window_call_text_event(win, &e, true);
+		}
+
+		if (lp & GCS_COMPSTR)
+		{
+			NativeTextEvent e(TextEvent::PREEDIT, himc, GCS_COMPSTR);
+			Window_call_text_event(win, &e);
+		}
+
+		ImmReleaseContext(self->hwnd, himc);
+	}
+
+	static void
+	clear_composition (Window* win)
+	{
+		assert(*win);
+
+		TextEvent e(TextEvent::PREEDIT, "");
+		Window_call_text_event(win, &e);
+	}
+
+	static void
+	update_ime_position (Window* win)
+	{
+		assert(*win);
+
+		const View* focus = win->focus();
+		if (!focus) return;
+
+		WindowData* self = get_data(win);
+
+		HIMC himc = ImmGetContext(self->hwnd);
+		if (!himc) return;
+
+		Bounds b = focus->text_input_bounds();
+		POINT p1 = Window_to_native_coord(*win, focus->to_window(b.position()));
+		POINT p2 = Window_to_native_coord(*win, focus->to_window(b.position() + b.size()));
 
-		if (it != self->pressing_keys.end()) self->pressing_keys.erase(it);
+		CANDIDATEFORM form = {0};
+		form.dwIndex       = 0;
+		form.dwStyle       = CFS_EXCLUDE;
+		form.ptCurrentPos  = {(LONG) p1.x, (LONG) p2.y};
+		form.rcArea        = {(LONG) p1.x, (LONG) p1.y, (LONG) p2.x, (LONG) p2.y};
+		ImmSetCandidateWindow(himc, &form);
+
+		ImmReleaseContext(self->hwnd, himc);
 	}
 
 	#ifndef MOUSEEVENTF_FROMTOUCH
@@ -300,13 +592,76 @@ namespace Reflex
 		return (GetMessageExtraInfo() & 0xffffff00) == MOUSEEVENTF_FROMTOUCH;
 	}
 
+	static void
+	capture_mouse_on_button_down (HWND hwnd, UINT msg)
+	{
+		switch (msg)
+		{
+			case WM_LBUTTONDOWN:
+			case WM_RBUTTONDOWN:
+			case WM_MBUTTONDOWN:
+			case WM_LBUTTONDBLCLK:
+			case WM_RBUTTONDBLCLK:
+			case WM_MBUTTONDBLCLK:
+				SetCapture(hwnd);
+				break;
+		}
+	}
+
+	static void
+	release_mouse_on_button_up (HWND hwnd, UINT msg, WPARAM wp)
+	{
+		switch (msg)
+		{
+			case WM_LBUTTONUP:
+			case WM_RBUTTONUP:
+			case WM_MBUTTONUP:
+				if (
+					(wp & (MK_LBUTTON | MK_RBUTTON | MK_MBUTTON)) == 0 &&
+					hwnd == GetCapture())
+				{
+					ReleaseCapture();
+				}
+				break;
+		}
+	}
+
 	static void
 	mouse (Window* win, UINT msg, WPARAM wp, LPARAM lp)
 	{
 		if (is_from_touch_event()) return;
 
-		NativePointerEvent e(msg, wp, lp);
+		WindowData* self = get_data(win);
+
+		if (msg == WM_MOUSEMOVE && !self->tracking_mouse)
+		{
+			TRACKMOUSEEVENT tme = {sizeof(tme), TME_LEAVE, self->hwnd, 0};
+			TrackMouseEvent(&tme);
+			self->tracking_mouse = true;
+
+			// Win32 has no mouse-enter message; the first move after (re)arming
+			// the leave tracking is when the mouse entered the window.
+			NativePointerEvent e(*win, msg, wp, lp, Pointer::ENTER);
+			Window_call_pointer_event(win, &e);
+		}
+		else if (msg == WM_MOUSELEAVE)
+		{
+			self->tracking_mouse = false;
+
+			POINT pt;
+			if (GetCursorPos(&pt) && ScreenToClient(self->hwnd, &pt))
+				lp = MAKELPARAM(pt.x, pt.y);
+		}
+
+		// before the press is handled: a popup menu opened by it takes the
+		// capture away and eats the release, which would never come to let
+		// go of a capture taken after
+		capture_mouse_on_button_down(self->hwnd, msg);
+
+		NativePointerEvent e(*win, msg, wp, lp);
 		Window_call_pointer_event(win, &e);
+
+		release_mouse_on_button_up(self->hwnd, msg, wp);
 	}
 
 	static void
@@ -321,18 +676,18 @@ namespace Reflex
 		{
 			wp_y = wp;
 			MSG m;
-			if (PeekMessage(&m, self->hwnd, WM_MOUSEHWHEEL, WM_MOUSEHWHEEL, PM_REMOVE))
+			if (PeekMessageW(&m, self->hwnd, WM_MOUSEHWHEEL, WM_MOUSEHWHEEL, PM_REMOVE))
 				wp_x = m.wParam;
 		}
 		else
 		{
 			wp_x = wp;
 			MSG m;
-			if (PeekMessage(&m, self->hwnd, WM_MOUSEWHEEL, WM_MOUSEWHEEL, PM_REMOVE))
+			if (PeekMessageW(&m, self->hwnd, WM_MOUSEWHEEL, WM_MOUSEWHEEL, PM_REMOVE))
 				wp_y = m.wParam;
 		}
 
-		NativeWheelEvent e(wp_x, wp_y, lp);
+		NativeWheelEvent e(*win, wp_x, wp_y, lp);
 		Window_call_wheel_event(win, &e);
 	}
 
@@ -350,7 +705,7 @@ namespace Reflex
 		if (!GetTouchInputInfo(handle, size, &touches[0], sizeof(TOUCHINPUT)))
 			return;
 
-		NativePointerEvent e(self->hwnd, &touches[0], size);
+		NativePointerEvent e(*win, &touches[0], size);
 		Window_call_pointer_event(win, &e);
 
 		CloseTouchInputHandle(handle);
@@ -360,12 +715,36 @@ namespace Reflex
 	window_proc (Window* win, HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
 	{
 		if (!win || !*win || hwnd != get_data(win)->hwnd)
-			return DefWindowProc(hwnd, msg, wp, lp);
+			return DefWindowProcW(hwnd, msg, wp, lp);
 
 		WindowData* self = get_data(win);
 
 		switch (msg)
 		{
+			case WM_NCCALCSIZE:
+			{
+				LRESULT result = 0;
+				if (calc_size(&result, hwnd, msg, wp, lp))
+					return result;
+				break;
+			}
+
+			case WM_NCHITTEST:
+			{
+				LRESULT result = 0;
+				if (hit_test(&result, win, hwnd, msg, wp, lp))
+					return result;
+				break;
+			}
+
+			case WM_WINDOWPOSCHANGING:
+			{
+				LRESULT result = 0;
+				if (window_pos_changing(&result, win, hwnd, msg, wp, lp))
+					return result;
+				break;
+			}
+
 			case WM_ACTIVATE:
 			{
 				if (LOWORD(wp) == WA_INACTIVE)
@@ -380,10 +759,40 @@ namespace Reflex
 
 			case WM_CLOSE:
 			{
-				win->close();
+				Window_call_close(win);
 				return 0;
 			}
 
+			case WM_COMMAND:
+			{
+				if (HIWORD(wp) == 1)
+				{
+					// menu items are reported by WM_MENUCOMMAND (MNS_NOTIFYBYPOS),
+					// so only accelerators (HIWORD == 1) arrive here
+					Menu_call_command_event(win->menu(), LOWORD(wp));
+					return 0;
+				}
+				break;
+			}
+
+			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;
+			}
+
 			case WM_PAINT:
 			{
 				self->context.make_current();
@@ -406,13 +815,13 @@ namespace Reflex
 
 			case WM_MOVE:
 			{
-				frame_changed(win);
+				Window_call_frame_event(win);
 				break;
 			}
 
 			case WM_SIZE:
 			{
-				frame_changed(win);
+				Window_call_frame_event(win);
 				break;
 			}
 
@@ -430,6 +839,31 @@ namespace Reflex
 				break;
 			}
 
+			case WM_IME_STARTCOMPOSITION:
+			{
+				if (!accepts_text_input(win)) break;
+
+				update_ime_position(win);
+				return 0;
+			}
+
+			case WM_IME_ENDCOMPOSITION:
+			{
+				if (!accepts_text_input(win)) break;
+
+				clear_composition(win);
+				return 0;
+			}
+
+			case WM_IME_COMPOSITION:
+			{
+				if (!accepts_text_input(win)) break;
+
+				update_composition(win, lp);
+				update_ime_position(win);
+				return 0;
+			}
+
 			case WM_LBUTTONDOWN:
 			case WM_RBUTTONDOWN:
 			case WM_MBUTTONDOWN:
@@ -440,6 +874,7 @@ namespace Reflex
 			case WM_RBUTTONUP:
 			case WM_MBUTTONUP:
 			case WM_MOUSEMOVE:
+			case WM_MOUSELEAVE:
 			{
 				mouse(win, msg, wp, lp);
 				break;
@@ -452,6 +887,12 @@ namespace Reflex
 				break;
 			}
 
+			case WM_CAPTURECHANGED:
+			{
+				Window_cancel_active_pointers(win);
+				break;
+			}
+
 			case WM_TOUCH:
 			{
 				touch(win, msg, wp, lp);
@@ -468,29 +909,51 @@ namespace Reflex
 			}
 		}
 
-		return DefWindowProc(hwnd, msg, wp, lp);
+		return DefWindowProcW(hwnd, msg, wp, lp);
 	}
 
 	static LRESULT CALLBACK
 	wndproc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
 	{
-		Window* win = NULL;
-		if (msg == WM_NCCREATE)
+		if (Application_has_exception())
+			return DefWindowProcW(hwnd, msg, wp, lp);
+
+		return Application_guard([&]() -> LRESULT
 		{
-			CREATESTRUCT* cs = (CREATESTRUCT*) lp;
-			win = (Window*) cs->lpCreateParams;
-			setup_window(win, hwnd);
-		}
+			Window* win = NULL;
+			if (msg == WM_NCCREATE)
+			{
+				CREATESTRUCTW* cs = (CREATESTRUCTW*) lp;
+				win = (Window*) cs->lpCreateParams;
+				setup_window(win, hwnd);
+			}
 
-		if (!win) win = get_window_from_hwnd(hwnd);
-		if  (win) rebind(win);
+			if (!win) win = get_window_from_hwnd(hwnd);
+			if  (win) rebind(win);
 
-		LRESULT ret = window_proc(win, hwnd, msg, wp, lp);
+			LRESULT ret = window_proc(win, hwnd, msg, wp, lp);
 
-		if (msg == WM_NCDESTROY)
-			cleanup_window(win);
+			if (msg == WM_NCDESTROY)
+				cleanup_window(win);
 
-		return ret;
+			return ret;
+		}, (LRESULT) 0);
+	}
+
+	static void
+	load_app_icons (HICON* large, HICON* small)
+	{
+		// the icons Explorer shows for the host executable, if it has any;
+		// NULL leaves the window with the default icon
+		*large = *small = NULL;
+
+		wchar_t path[32768];
+		if (GetModuleFileNameW(NULL, path, sizeof(path) / sizeof(path[0])) == 0)
+			return;
+
+		UINT n = ExtractIconExW(path, 0, large, small, 1);
+		if (n == 0 || n == UINT_MAX)
+			*large = *small = NULL;
 	}
 
 	static void
@@ -499,22 +962,21 @@ namespace Reflex
 		static bool registered = false;
 		if (registered) return;
 
-		WNDCLASSEX wc;
+		WNDCLASSEXW wc;
 		memset(&wc, 0, sizeof(wc));
-
 		wc.cbSize        = sizeof(wc);
 		wc.lpszClassName = WINDOWCLASS;
 		wc.lpfnWndProc   = (WNDPROC) wndproc;
 		wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_DBLCLKS;
-		wc.hInstance     = GetModuleHandle(NULL);
-		//wc.hIcon         = LoadIcon(wc.hInstance, IDI_APP_LARGE);
-		//wc.hIconSm       = LoadIcon(wc.hInstance, IDI_APP_SMALL);
-		wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+		wc.hInstance     = GetModuleHandleW(NULL);
+		wc.hCursor       = LoadCursorW(NULL, (LPCWSTR) IDC_ARROW);
 		wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
 		wc.lpszMenuName  = NULL;
 		wc.cbWndExtra    = sizeof(Window*);
 
-		if (!RegisterClassEx(&wc))
+		load_app_icons(&wc.hIcon, &wc.hIconSm);
+
+		if (!RegisterClassExW(&wc))
 			system_error(__FILE__, __LINE__);
 
 		registered = true;
@@ -527,10 +989,10 @@ namespace Reflex
 			invalid_state_error(__FILE__, __LINE__);
 
 		register_windowclass();
-		HWND hwnd = CreateWindowEx(
-			0, WINDOWCLASS, "",
+		HWND hwnd = CreateWindowExW(
+			0, WINDOWCLASS, L"",
 			WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
-			0, 0, 0, 0, NULL, NULL, GetModuleHandle(NULL), win);
+			0, 0, 0, 0, NULL, NULL, GetModuleHandleW(NULL), win);
 		if (!hwnd)
 			system_error(__FILE__, __LINE__);
 
@@ -552,9 +1014,12 @@ namespace Reflex
 	Window_default_flags ()
 	{
 		return
-			Window::FLAG_CLOSABLE  |
-			Window::FLAG_RESIZABLE |
-			Window::FLAG_MINIMIZABLE;
+			Window::FLAG_CLOSABLE            |
+			Window::FLAG_MINIMIZABLE         |
+			Window::FLAG_RESIZABLE           |
+			Window::FLAG_TITLEBAR_BUTTONS    |
+			Window::FLAG_TITLEBAR_BACKGROUND |
+			Window::FLAG_SHADOW;
 	}
 
 	void
@@ -573,9 +1038,15 @@ namespace Reflex
 
 		WindowData* self = get_data(window);
 
+		// the frame is passed so that WM_WINDOWPOSCHANGING can correct it
+		RECT rect = {0};
+		if (!GetWindowRect(self->hwnd, &rect))
+			system_error(__FILE__, __LINE__);
+
 		SetWindowPos(
-			self->hwnd, HWND_TOP, 0, 0, 0, 0,
-			SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);
+			self->hwnd, HWND_TOP,
+			rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
+			SWP_SHOWWINDOW);
 		UpdateWindow(self->hwnd);
 	}
 
@@ -610,7 +1081,7 @@ namespace Reflex
 
 		if (!*window) return;
 
-		if (!SetWindowText(get_data(window)->hwnd, title))
+		if (!SetWindowTextW(get_data(window)->hwnd, String(title).to_wstr().c_str()))
 			system_error(__FILE__, __LINE__);
 	}
 
@@ -621,75 +1092,80 @@ namespace Reflex
 
 		const WindowData* self = get_data(&window);
 
-		int size = GetWindowTextLength(self->hwnd);
+		int size = GetWindowTextLengthW(self->hwnd);
 		if (size <= 0) return "";
 
-		std::unique_ptr<char[]> buf(new char[size + 1]);
-		if (GetWindowText(self->hwnd, &buf[0], size + 1) != size)
+		std::unique_ptr<wchar_t[]> buf(new wchar_t[size + 1]);
+		if (GetWindowTextW(self->hwnd, &buf[0], size + 1) != size)
 			return "";
 
-		self->title_tmp = &buf[0];
+		self->title_tmp = String(&buf[0], size);
 		return self->title_tmp.c_str();
 	}
 
-	static void
-	get_window_bounds (
-		HWND hwnd, coord* x, coord* y, coord* width, coord* height,
-		coord* nonclient_width = NULL, coord* nonclient_height = NULL)
+	static RECT
+	get_client_rect (HWND hwnd)
 	{
-		if (!x && !y && !width && !height && !nonclient_width && !nonclient_height)
-			argument_error(__FILE__, __LINE__);
-
-		RECT window;
-		if (!GetWindowRect(hwnd, &window))
-			system_error(__FILE__, __LINE__);
-
 		RECT client;
 		if (!GetClientRect(hwnd, &client))
 			system_error(__FILE__, __LINE__);
 
-		if (x)      *x      = window.left;
-		if (y)      *y      = window.top;
-		if (width)  *width  = client.right  - client.left;
-		if (height) *height = client.bottom - client.top;
+		POINT pos = {client.left, client.top};
+		if (!ClientToScreen(hwnd, &pos))
+			system_error(__FILE__, __LINE__);
 
-		if (nonclient_width)
-		{
-			coord ww = window.right  - window.left;
-			coord cw = client.right  - client.left;
-			*nonclient_width  = ww - cw;
-		}
-		if (nonclient_height)
-		{
-			coord wh = window.bottom - window.top;
-			coord ch = client.bottom - client.top;
-			*nonclient_height = wh - ch;
-		}
+		return {
+			pos.x,
+			pos.y,
+			pos.x + (client.right  - client.left),
+			pos.y + (client.bottom - client.top)
+		};
+	}
+
+	static void
+	client_to_window_rect (HWND hwnd, RECT* rect)
+	{
+		DWORD style   = (DWORD) GetWindowLongPtrW(hwnd, GWL_STYLE);
+		DWORD exstyle = (DWORD) GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
+
+		LONG top = rect->top;
+		if (!AdjustWindowRectEx(rect, style, GetMenu(hwnd) != NULL, exstyle))
+			system_error(__FILE__, __LINE__);
+
+		// WM_NCCALCSIZE gives the top of the sizing border to the client area
+		// when there is no caption, so it takes no room here either
+		if (!has_style(hwnd, WS_CAPTION)) rect->top = top;
 	}
 
 	void
-	Window_set_frame (Window* window, coord x, coord y, coord width, coord height)
+	Window_set_frame (Window* window, coord x, coord y, coord w, coord h)
 	{
 		if (!*window) return;
 
-		WindowData* self = get_data(window);
+		HWND hwnd = get_data(window)->hwnd;
 
-		coord xx, yy, ww, hh, nonclient_w, nonclient_h;
-		get_window_bounds(
-			self->hwnd, &xx, &yy, &ww, &hh, &nonclient_w, &nonclient_h);
+		RECT now   = get_client_rect(hwnd);
+		RECT rect  = Screen_to_native_coord(x, y, w, h);
+		UINT flags = 0;
 
-		width  += nonclient_w;
-		height += nonclient_h;
+		if (rect.left == now.left && rect.top == now.top)
+			flags |= SWP_NOMOVE;
 
-		UINT flags = 0;
-		if (x     == xx && y      == yy) flags |= SWP_NOMOVE;
-		if (width == ww && height == hh) flags |= SWP_NOSIZE;
+		if (
+			rect.right  - rect.left == now.right  - now.left &&
+			rect.bottom - rect.top  == now.bottom - now.top)
+		{
+			flags |= SWP_NOSIZE;
+		}
 
 		if (flags == (SWP_NOMOVE | SWP_NOSIZE))
 			return;
 
+		client_to_window_rect(hwnd, &rect);
+
 		if (!SetWindowPos(
-			self->hwnd, NULL, (int) x, (int) y, (int) width, (int) height,
+			hwnd, NULL,
+			rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
 			flags | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOOWNERZORDER))
 		{
 			system_error(__FILE__, __LINE__);
@@ -702,9 +1178,20 @@ namespace Reflex
 		if (!window)
 			invalid_state_error(__FILE__, __LINE__);
 
-		coord x, y, w, h;
-		get_window_bounds(get_data(&window)->hwnd, &x, &y, &w, &h);
-		return Bounds(x, y, w, h);
+		return Screen_from_native_coord(get_client_rect(get_data(&window)->hwnd));
+	}
+
+	void
+	Window_set_menu (Window* window, Menu* menu)
+	{
+		WindowData* self = get_data(window);
+		HWND hwnd        = self->hwnd;
+		if (!hwnd) return;
+
+		SetMenu(hwnd, menu ? Menu_get_hmenu(menu, true) : NULL);
+		DrawMenuBar(hwnd);
+
+		self->set_accelerator_table(menu ? Menu_create_accelerator_table(menu) : NULL);
 	}
 
 	Screen
@@ -717,20 +1204,256 @@ namespace Reflex
 		return s;
 	}
 
+	static void
+	set_background_transparent (HWND hwnd, bool transparent)
+	{
+		std::shared_ptr<HRGN__> region;
+		if (transparent)
+		{
+			region.reset(CreateRectRgn(0, 0, -1, -1), DeleteObject);// no blur
+			if (!region)
+				system_error(__FILE__, __LINE__);
+		}
+
+		DWM_BLURBEHIND blur = {0};
+		blur.dwFlags        = DWM_BB_ENABLE | (transparent ? DWM_BB_BLURREGION : 0);
+		blur.fEnable        = transparent ? TRUE : FALSE;
+		blur.hRgnBlur       = region.get();
+		HRESULT result      = DwmEnableBlurBehindWindow(hwnd, &blur);
+		if (FAILED(result))
+		{
+			system_error(
+				__FILE__, __LINE__,
+				"DwmEnableBlurBehindWindow failed (0x%08x)", (uint) result);
+		}
+	}
+
+	static DWORD
+	make_window_style (uint flags, DWORD style)
+	{
+		using namespace Xot;
+
+		bool caption = has_flag(flags, Window::FLAG_TITLEBAR_BACKGROUND);
+
+		// the sizing border follows resizable, but a captionless window keeps
+		// it for the shadow and leaves the resizing to the hit test
+		bool sizing_border = caption
+			?	has_flag(flags, Window::FLAG_RESIZABLE)
+			:	has_flag(flags, Window::FLAG_SHADOW);
+
+		update_flag(&style, WS_SYSMENU,     has_flag(flags, Window::FLAG_TITLEBAR_BUTTONS));
+		update_flag(&style, WS_CAPTION,     caption);
+		update_flag(&style, WS_MINIMIZEBOX, has_flag(flags, Window::FLAG_MINIMIZABLE));
+		update_flag(&style, WS_MAXIMIZEBOX, has_flag(flags, Window::FLAG_RESIZABLE));
+		update_flag(&style, WS_THICKFRAME,  sizing_border);
+
+		return style;
+	}
+
+	static void
+	set_window_style (HWND hwnd, DWORD style)
+	{
+		RECT client = {0};
+		bool normal = !IsIconic(hwnd) && !IsZoomed(hwnd) && GetClientRect(hwnd, &client);
+
+		POINT pos = {0, 0};
+		if (normal && !ClientToScreen(hwnd, &pos))
+			system_error(__FILE__, __LINE__);
+
+		RECT rect = {
+			pos.x, pos.y,
+			pos.x + (client.right  - client.left),
+			pos.y + (client.bottom - client.top)
+		};
+
+		SetLastError(0);
+		SetWindowLongPtrW(hwnd, GWL_STYLE, style);
+		if (GetLastError() != 0)
+			system_error(__FILE__, __LINE__);
+
+		UINT posflags = SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOACTIVATE;
+		if (normal)
+			client_to_window_rect(hwnd, &rect);
+		else
+			posflags |= SWP_NOMOVE | SWP_NOSIZE;
+
+		if (!SetWindowPos(
+			hwnd, NULL,
+			rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
+			posflags))
+		{
+			system_error(__FILE__, __LINE__);
+		}
+	}
+
+	static void
+	set_closable (HWND hwnd, bool closable)
+	{
+		// the close button follows the state of the close menu item
+		HMENU menu = GetSystemMenu(hwnd, FALSE);
+		if (!menu) return;
+
+		EnableMenuItem(
+			menu, SC_CLOSE, MF_BYCOMMAND | (closable ? MF_ENABLED : MF_GRAYED));
+	}
+
+	static void
+	set_unlisted (HWND hwnd, bool state)
+	{
+		DWORD current = (DWORD) GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
+		DWORD exstyle = state
+			?	current |  WS_EX_TOOLWINDOW
+			:	current & ~WS_EX_TOOLWINDOW;
+		if (exstyle == current) return;
+
+		SetLastError(0);
+		SetWindowLongPtrW(hwnd, GWL_EXSTYLE, exstyle);
+		if (GetLastError() != 0)
+			system_error(__FILE__, __LINE__);
+	}
+
 	void
 	Window_set_flags (Window* window, uint flags)
 	{
+		if (
+			 Xot::has_flag(flags, Window::FLAG_TITLEBAR_BUTTONS) &&
+			!Xot::has_flag(flags, Window::FLAG_TITLEBAR_BACKGROUND))
+		{
+			argument_error(
+				__FILE__, __LINE__, "FLAG_TITLEBAR_BUTTONS needs FLAG_TITLEBAR_BACKGROUND");
+		}
+
+		if (
+			 Xot::has_flag(flags, Window::FLAG_TITLEBAR_BACKGROUND) &&
+			!Xot::has_flag(flags, Window::FLAG_SHADOW))
+		{
+			argument_error(
+				__FILE__, __LINE__, "FLAG_TITLEBAR_BACKGROUND needs FLAG_SHADOW");
+		}
+
 		if (Xot::has_flag(flags, Window::FLAG_PORTRAIT))
 			argument_error(__FILE__, __LINE__, "FLAG_PORTRAIT is not supported");
 
 		if (Xot::has_flag(flags, Window::FLAG_LANDSCAPE))
 			argument_error(__FILE__, __LINE__, "FLAG_LANDSCAPE is not supported");
+
+		if (!*window)
+			invalid_state_error(__FILE__, __LINE__);
+
+		WindowData* self = get_data(window);
+
+		bool transparent = Xot::has_flag(flags, Window::FLAG_TRANSPARENT);
+		if (transparent != self->transparent)
+		{
+			set_background_transparent(self->hwnd, transparent);
+			self->transparent = transparent;
+		}
+
+		DWORD current = (DWORD) GetWindowLongPtrW(self->hwnd, GWL_STYLE);
+		DWORD style   = make_window_style(flags, current);
+		if (style != current)
+			set_window_style(self->hwnd, style);
+
+		set_closable(self->hwnd, Xot::has_flag(flags, Window::FLAG_CLOSABLE));
+
+		set_unlisted(self->hwnd, Xot::has_flag(flags, Window::FLAG_UNLISTED));
+
+		HWND after = HWND_NOTOPMOST;
+		if      (Xot::has_flag(flags, Window::FLAG_ALWAYS_ON_TOP))
+			after    = HWND_TOPMOST;
+		else if (Xot::has_flag(flags, Window::FLAG_ALWAYS_ON_BOTTOM))
+			after    = HWND_BOTTOM;
+		if (!SetWindowPos(
+			self->hwnd, after, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE))
+		{
+			system_error(__FILE__, __LINE__);
+		}
 	}
 
 	float
 	Window_get_pixel_density (const Window& window)
 	{
-		return 1;
+		HWND hwnd = get_data(&window)->hwnd;
+		return Screen_get_pixel_density(
+			hwnd ? MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) : NULL);
+	}
+
+	Point
+	Window_from_native_coord (const Window& window, coord x, coord y)
+	{
+		float density = Window_get_pixel_density(window);
+		return Point(x / density, y / density);
+	}
+
+	POINT
+	Window_to_native_coord (const Window& window, const Point& point)
+	{
+		float density = Window_get_pixel_density(window);
+		return {
+			(LONG) lround(point.x * density),
+			(LONG) lround(point.y * density)
+		};
+	}
+
+	void
+	Window_set_pointer_through (Window* window, bool through)
+	{
+		static const DWORD THROUGH = WS_EX_TRANSPARENT | WS_EX_LAYERED;
+
+		HWND hwnd     = get_data(window)->hwnd;
+		DWORD current = (DWORD) GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
+		DWORD exstyle = through ? current | THROUGH : current & ~THROUGH;
+		if (exstyle == current) return;
+
+		SetLastError(0);
+		SetWindowLongPtrW(hwnd, GWL_EXSTYLE, exstyle);
+		if (GetLastError() != 0)
+			system_error(__FILE__, __LINE__);
+
+		if (through && !SetLayeredWindowAttributes(hwnd, 0, 255, LWA_ALPHA))
+			system_error(__FILE__, __LINE__);
+	}
+
+	static bool
+	is_covered_by_another_window (HWND hwnd, POINT pos)
+	{
+		// only a window that takes mouse events counts as covering. the hit
+		// test skips a window letting pointers through, so the hit can be one
+		// below hwnd itself; it covers hwnd when it is among the windows above
+
+		HWND hit = WindowFromPoint(pos);
+		if (hit) hit = GetAncestor(hit, GA_ROOT);
+		if (!hit || hit == hwnd)
+			return false;
+
+		for (HWND h = GetWindow(hwnd, GW_HWNDPREV); h; h = GetWindow(h, GW_HWNDPREV))
+		{
+			if (h == hit)
+				return true;
+		}
+		return false;
+	}
+
+	bool
+	Window_is_pointer_over_and_uncovered (Point* position, const Window& window)
+	{
+		POINT pos;
+		if (!GetCursorPos(&pos))
+			return false;
+
+		HWND hwnd = get_data(&window)->hwnd;
+		RECT rect;
+		if (!GetWindowRect(hwnd, &rect))
+			return false;
+		if (!PtInRect(&rect, pos))
+			return false;
+		if (is_covered_by_another_window(hwnd, pos))
+			return false;
+		if (!ScreenToClient(hwnd, &pos))
+			return false;
+
+		*position = Window_from_native_coord(window, pos.x, pos.y);
+		return true;
 	}