reflexion 0.5.2 → 0.6.0

data/src/win32/clipboard.cpp

@@ -0,0 +1,210 @@
+#include "reflex/clipboard.h"
+
+
+#include <string.h>
+#include <wchar.h>
+#include <xot/noncopyable.h>
+#include <xot/windows.h>
+#include "reflex/exception.h"
+
+
+namespace Reflex
+{
+
+
+	class ClipboardLock : public Xot::NonCopyable
+	{
+
+		enum
+		{
+
+			RETRY_COUNT = 3,
+
+			RETRY_INTERVAL = 30// milliseconds
+
+		};
+
+		public:
+
+			ClipboardLock ()
+			:	opened(false)
+			{
+				// OpenClipboard fails while another process has the clipboard open
+				for (int i = 0; i < RETRY_COUNT; ++i)
+				{
+					if (i > 0) Sleep(RETRY_INTERVAL);
+
+					opened = OpenClipboard(NULL) != FALSE;
+					if (opened) break;
+				}
+			}
+
+			~ClipboardLock ()
+			{
+				if (opened) CloseClipboard();
+			}
+
+			operator bool () const
+			{
+				return opened;
+			}
+
+		private:
+
+			bool opened;
+
+	};// ClipboardLock
+
+
+	class GlobalMemory : public Xot::NonCopyable
+	{
+
+		public:
+
+			GlobalMemory (HGLOBAL handle, bool owner = false)
+			:	handle(handle), owner(owner), pointer(NULL)
+			{
+			}
+
+			~GlobalMemory ()
+			{
+				unlock();
+				if (handle && owner) GlobalFree(handle);
+			}
+
+			void* lock ()
+			{
+				if (!pointer && handle) pointer = GlobalLock(handle);
+				return pointer;
+			}
+
+			void unlock ()
+			{
+				if (!pointer) return;
+				GlobalUnlock(handle);
+				pointer = NULL;
+			}
+
+			HGLOBAL release ()
+			{
+				owner = false;
+				return handle;
+			}
+
+			HGLOBAL get () const
+			{
+				return handle;
+			}
+
+			operator bool () const
+			{
+				return handle != NULL;
+			}
+
+		private:
+
+			HGLOBAL handle;
+
+			bool owner;
+
+			void* pointer;
+
+	};// GlobalMemory
+
+
+	static String
+	to_crlf (const char* text)
+	{
+		String result;
+		for (const char* p = text; *p; ++p)
+		{
+			if (*p == '\r' || *p == '\n')
+			{
+				result += "\r\n";
+				if (*p == '\r' && *(p + 1) == '\n') ++p;
+				continue;
+			}
+			result += *p;
+		}
+		return result;
+	}
+
+	static String
+	to_lf (const String& text)
+	{
+		size_t size = text.size();
+		String result;
+		result.reserve(size);
+		for (size_t i = 0; i < size; ++i)
+		{
+			char c = text[i];
+			if (c == '\r')
+			{
+				if ((i + 1) < size && text[i + 1] == '\n') continue;
+				c = '\n';
+			}
+			result += c;
+		}
+		return result;
+	}
+
+	static HGLOBAL
+	create_text_handle (const char* text)
+	{
+		std::wstring wtext = to_crlf(text).to_wstr();
+		size_t size        = (wtext.size() + 1) * sizeof(wchar_t);
+
+		GlobalMemory mem(GlobalAlloc(GMEM_MOVEABLE, size), true);
+		if (!mem)
+			system_error(__FILE__, __LINE__);
+
+		void* buffer = mem.lock();
+		if (!buffer)
+			system_error(__FILE__, __LINE__);
+
+		memcpy(buffer, wtext.c_str(), size);
+		mem.unlock();
+
+		return mem.release();
+	}
+
+	void
+	set_clipboard (const Clipboard& clipboard)
+	{
+		const char* text = clipboard.text();
+		GlobalMemory textmem(text ? create_text_handle(text) : NULL, true);
+
+		ClipboardLock lock;
+		if (!lock)
+			system_error(__FILE__, __LINE__);
+
+		if (!EmptyClipboard())
+			system_error(__FILE__, __LINE__);
+
+		if (textmem)
+		{
+			if (!SetClipboardData(CF_UNICODETEXT, textmem.get()))
+				system_error(__FILE__, __LINE__);
+			textmem.release();
+		}
+	}
+
+	Clipboard
+	get_clipboard ()
+	{
+		ClipboardLock lock;
+		if (!lock)
+			system_error(__FILE__, __LINE__);
+
+		Clipboard clipboard;
+
+		GlobalMemory textmem(GetClipboardData(CF_UNICODETEXT));
+		const wchar_t* text = (const wchar_t*) textmem.lock();
+		if (text)
+			clipboard.set_text(to_lf(String(text, wcslen(text))).c_str());
+
+		return clipboard;
+	}
+
+
+}// Reflex

data/src/win32/event.cpp

@@ -68,6 +68,7 @@ namespace Reflex
 				break;
 
 			case WM_MOUSEMOVE:
+			case WM_MOUSELEAVE:
 				type |= Reflex::Pointer::MOUSE;
 				break;
 		}
@@ -96,6 +97,9 @@ namespace Reflex
 			case WM_MOUSEMOVE:
 				return Reflex::Pointer::MOVE;
 
+			case WM_MOUSELEAVE:
+				return Reflex::Pointer::LEAVE;
+
 			default:
 				return Reflex::Pointer::ACTION_NONE;
 		}
@@ -128,11 +132,17 @@ namespace Reflex
 	}
 
 	NativePointerEvent::NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp)
+	:	NativePointerEvent(msg, wp, lp, get_mouse_action(msg))
+	{
+	}
+
+	NativePointerEvent::NativePointerEvent (
+		UINT msg, WPARAM wp, LPARAM lp, Pointer::Action action)
 	{
 		PointerEvent_add_pointer(this, Pointer(
 			0,
 			get_mouse_type(msg, wp),
-			get_mouse_action(msg),
+			action,
 			Point(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)),
 			KeyEvent_get_modifiers(),
 			get_mouse_click_count(msg),

data/src/win32/event.h

@@ -29,6 +29,8 @@ namespace Reflex
 
 			NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp);
 
+			NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp, Pointer::Action action);
+
 			NativePointerEvent (HWND hwnd, const TOUCHINPUT* touches, size_t size);
 
 	};// NativePointerEvent

data/src/win32/menu.cpp

@@ -0,0 +1,352 @@
+#include "menu.h"
+
+
+#include "reflex/exception.h"
+#include "reflex/event.h"
+#include "reflex/view.h"
+#include "window.h"
+
+
+namespace Rays
+{
+	HBITMAP Bitmap_get_hbitmap (const Bitmap& bmp);
+}
+
+
+namespace Reflex
+{
+
+
+	static UINT
+	next_menu_id ()
+	{
+		static UINT id = 100;
+		return id++;
+	}
+
+	static HMENU
+	create_hmenu (Menu* menu, bool menubar)
+	{
+		HMENU hmenu = menubar ? CreateMenu() : CreatePopupMenu();
+		if (!hmenu)
+			system_error(__FILE__, __LINE__);
+
+		MENUINFO mi   = {sizeof(mi)};
+		mi.fMask      = MIM_MENUDATA | MIM_STYLE;
+		mi.dwMenuData = (ULONG_PTR) menu;
+		mi.dwStyle    = MNS_NOTIFYBYPOS;
+		SetMenuInfo(hmenu, &mi);
+
+		return hmenu;
+	}
+
+	static void
+	destroy_hmenu (HMENU hmenu)
+	{
+		if (!hmenu || !IsMenu(hmenu)) return;
+
+		while (GetMenuItemCount(hmenu) > 0)
+			RemoveMenu(hmenu, 0, MF_BYPOSITION);
+
+		DestroyMenu(hmenu);
+	}
+
+
+	struct MenuData : public Menu::Data
+	{
+
+		UINT id        = next_menu_id();
+
+		HMENU hparent  = NULL;
+
+		HMENU hsubmenu = NULL;
+
+		bool menubar   = false;
+
+		Image image;
+
+		std::shared_ptr<HBITMAP__> hbitmap;
+
+		virtual ~MenuData ()
+		{
+			destroy_hmenu(hsubmenu);
+		}
+
+		HMENU get_hsubmenu (Menu* menu, bool menubar = false);
+
+		HBITMAP get_hbitmap (const Image& image)
+		{
+			if (image != this->image)
+			{
+				this->image = image;
+				if (image)
+					hbitmap.reset(Rays::Bitmap_get_hbitmap(image.bitmap()), DeleteObject);
+				else
+					hbitmap.reset();
+			}
+			return hbitmap.get();
+		}
+
+	};// MenuData
+
+
+	static MenuData&
+	get_data (Menu* menu)
+	{
+		if (!menu)
+			argument_error(__FILE__, __LINE__);
+
+		return (MenuData&) *menu->self;
+	}
+
+	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))
+			return NULL;
+
+		return (Menu*) mii.dwItemData;
+	}
+
+	static Menu*
+	get_submenu_owner (HMENU hsubmenu)
+	{
+		if (!hsubmenu) return NULL;
+
+		MENUINFO mi = {sizeof(mi)};
+		mi.fMask    = MIM_MENUDATA;
+		if (!GetMenuInfo(hsubmenu, &mi))
+			return NULL;
+
+		return (Menu*) mi.dwMenuData;
+	}
+
+	static void
+	insert_item (HMENU hparent, Menu* item, int index)
+	{
+		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) "";
+
+		if (!InsertMenuItem(hparent, (UINT) index, TRUE, &mii))
+			system_error(__FILE__, __LINE__);
+
+		self.hparent = hparent;
+
+		Menu_update(item);
+	}
+
+	Menu::Data*
+	Menu_create_data ()
+	{
+		return new MenuData();
+	}
+
+	static String
+	make_item_string (const Menu* menu)
+	{
+		String s        = menu->label();
+		const char* key = menu->shortcut_key();
+		if (key && *key)
+		{
+			s += '\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;
+		}
+		return s;
+	}
+
+	void
+	Menu_update (Menu* menu)
+	{
+		MenuData& self = get_data(menu);
+
+		if (!self.hparent) return;
+
+		MENUITEMINFO 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;
+
+		String label;
+		if (menu->is_separator())
+			mii.fType = MFT_SEPARATOR;
+		else
+		{
+			label = make_item_string(menu);
+
+			mii.fMask     |= MIIM_STRING;
+			mii.fType      = MFT_STRING;
+			mii.dwTypeData = (LPSTR) label.c_str();
+			mii.fState     =
+				(menu->is_enabled() ? MFS_ENABLED : MFS_GRAYED) |
+				(menu->is_checked() ? MFS_CHECKED : MFS_UNCHECKED);
+			mii.hbmpItem   = self.get_hbitmap(menu->image());
+			mii.hSubMenu   = menu->empty() ? NULL : self.hsubmenu;
+		}
+
+		SetMenuItemInfo(self.hparent, self.id, FALSE, &mii);
+	}
+
+	void
+	Menu_popup (Menu* menu, View* view, coord x, coord y)
+	{
+		MenuData& self = get_data(menu);
+
+		HMENU hmenu = self.get_hsubmenu(menu, false);
+		if (!hmenu)
+			invalid_state_error(__FILE__, __LINE__);
+
+		HWND hwnd = NULL;
+		POINT pos = {(int) x, (int) y};
+
+		if (view)
+		{
+			Window* win = view->window();
+			if (!win)
+				invalid_state_error(__FILE__, __LINE__);
+
+			hwnd = Window_get_hwnd(win);
+			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;
+			ClientToScreen(hwnd, &pos);
+		}
+		else
+			hwnd = GetActiveWindow();
+
+		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);
+	}
+
+	void
+	Menu_child_added (Menu* parent, Menu* child, int index)
+	{
+		MenuData& c = get_data(child);
+
+		if (c.hparent)
+			invalid_state_error(__FILE__, __LINE__);
+
+		insert_item(get_data(parent).get_hsubmenu(parent), child, index);
+	}
+
+	void
+	Menu_child_removed (Menu* parent, Menu* child)
+	{
+		MenuData& p = get_data(parent);
+		MenuData& c = get_data(child);
+
+		if (!p.hsubmenu)
+			invalid_state_error(__FILE__, __LINE__);
+		if (c.hparent != p.hsubmenu)
+			invalid_state_error(__FILE__, __LINE__);
+
+		RemoveMenu(p.hsubmenu, c.id, MF_BYCOMMAND);
+		c.hparent = NULL;
+	}
+
+	HMENU
+	Menu_get_hmenu (Menu* menu)
+	{
+		return menu ? get_data(menu).get_hsubmenu(menu, true) : NULL;
+	}
+
+	void
+	Menu_call_command_event (HMENU hmenu, uint index)
+	{
+		Menu* menu = get_item_owner(hmenu, index);
+		if (!menu) return;
+
+		Event e;
+		menu->on_click(&e);
+	}
+
+	void
+	Menu_call_open_event (HMENU hmenu)
+	{
+		Menu* menu = get_submenu_owner(hmenu);
+		if (!menu) return;
+
+		Event e;
+		menu->on_open_submenu(&e);
+
+		int count = GetMenuItemCount(hmenu);
+		for (int i = 0; i < count; ++i)
+		{
+			Menu* child = get_item_owner(hmenu, i);
+			if (!child) continue;
+
+			Event ce;
+			child->on_show(&ce);
+		}
+	}
+
+	void
+	Menu_call_close_event (HMENU hmenu)
+	{
+		Menu* menu = get_submenu_owner(hmenu);
+		if (!menu) return;
+
+		int count = GetMenuItemCount(hmenu);
+		for (int i = 0; i < count; ++i)
+		{
+			Menu* child = get_item_owner(hmenu, i);
+			if (!child) continue;
+
+			Event ce;
+			child->on_hide(&ce);
+		}
+
+		Event e;
+		menu->on_close_submenu(&e);
+	}
+
+
+	HMENU
+	MenuData::get_hsubmenu (Menu* menu, bool menubar)
+	{
+		if (!hsubmenu)
+		{
+			hsubmenu      = create_hmenu(menu, menubar);
+			this->menubar = menubar;
+		}
+		else if (menubar != this->menubar)
+		{
+			HMENU old     = hsubmenu;
+			hsubmenu      = create_hmenu(menu, menubar);
+			this->menubar = menubar;
+
+			int index = 0;
+			for (auto it = menu->begin(); it != menu->end(); ++it, ++index)
+				insert_item(hsubmenu, it->get(), index);
+			destroy_hmenu(old);
+		}
+		return hsubmenu;
+	}
+
+
+}// Reflex

data/src/win32/menu.h

@@ -0,0 +1,27 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WIN32_MENU_H__
+#define __REFLEX_SRC_WIN32_MENU_H__
+
+
+#include <xot/windows.h>
+#include "../menu.h"
+
+
+namespace Reflex
+{
+
+
+	HMENU Menu_get_hmenu (Menu* menu);
+
+	void Menu_call_command_event (HMENU hmenu, uint index);
+
+	void Menu_call_open_event  (HMENU hmenu);
+
+	void Menu_call_close_event (HMENU hmenu);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/win32/window.cpp

@@ -15,6 +15,7 @@
 #include "gamepad.h"
 #include "screen.h"
 #include "opengl.h"
+#include "menu.h"
 
 
 namespace Reflex
@@ -36,6 +37,8 @@ namespace Reflex
 
 		bool need_rebind = false;
 
+		bool tracking_mouse = false;
+
 		OpenGLContext context;
 
 		PressingKeyMap pressing_keys;
@@ -305,6 +308,28 @@ namespace Reflex
 	{
 		if (is_from_touch_event()) return;
 
+		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(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);
+		}
+
 		NativePointerEvent e(msg, wp, lp);
 		Window_call_pointer_event(win, &e);
 	}
@@ -384,6 +409,24 @@ namespace Reflex
 				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;
+			}
+
 			case WM_PAINT:
 			{
 				self->context.make_current();
@@ -440,6 +483,7 @@ namespace Reflex
 			case WM_RBUTTONUP:
 			case WM_MBUTTONUP:
 			case WM_MOUSEMOVE:
+			case WM_MOUSELEAVE:
 			{
 				mouse(win, msg, wp, lp);
 				break;
@@ -707,6 +751,24 @@ namespace Reflex
 		return Bounds(x, y, w, h);
 	}
 
+	HWND
+	Window_get_hwnd (const Window* window)
+	{
+		if (!window) return NULL;
+
+		return get_data(window)->hwnd;
+	}
+
+	void
+	Window_set_menu (Window* window, Menu* menu)
+	{
+		HWND hwnd = get_data(window)->hwnd;
+		if (!hwnd) return;
+
+		SetMenu(hwnd, menu ? Menu_get_hmenu(menu) : NULL);
+		DrawMenuBar(hwnd);
+	}
+
 	Screen
 	Window_get_screen (const Window& window)
 	{