reflexion 0.6.0 → 0.7.0

data/src/win32/color_picker.cpp

@@ -0,0 +1,82 @@
+#include "../color_picker.h"
+
+
+#include <xot/windows.h>
+#include <commdlg.h>
+#include "reflex/exception.h"
+#include "window.h"
+
+
+namespace Reflex
+{
+
+
+	// the custom color slots of the dialog live as long as the process
+	static COLORREF custom_colors[16] =
+	{
+		RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255),
+		RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255),
+		RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255),
+		RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255), RGB(255, 255, 255)
+	};
+
+
+	static BYTE
+	to_byte (float value)
+	{
+		if (value < 0) value = 0;
+		if (value > 1) value = 1;
+		return (BYTE) (value * 255 + 0.5f);
+	}
+
+	static COLORREF
+	to_colorref (const Color& color)
+	{
+		return RGB(to_byte(color.red), to_byte(color.green), to_byte(color.blue));
+	}
+
+	static Color
+	to_color (COLORREF colorref)
+	{
+		return Color(
+			GetRValue(colorref) / 255.f,
+			GetGValue(colorref) / 255.f,
+			GetBValue(colorref) / 255.f);
+	}
+
+	void
+	ColorPicker_show (ColorPicker* ppicker, const Color* initial)
+	{
+		if (!ppicker)
+			argument_error(__FILE__, __LINE__);
+
+		ColorPicker::Ref picker = ppicker;
+
+		Window* owner    = picker->owner();
+		CHOOSECOLORW cc  = {0};
+		cc.lStructSize   = sizeof(cc);
+		cc.hwndOwner     = owner ? Window_get_hwnd(owner) : NULL;
+		cc.lpCustColors  = custom_colors;
+		cc.Flags         = CC_FULLOPEN | CC_ANYCOLOR;
+		if (initial)
+		{
+			cc.rgbResult = to_colorref(*initial);
+			cc.Flags    |= CC_RGBINIT;
+		}
+
+		// the dialog has no alpha, so the picked color always has alpha 1
+		BOOL picked = ChooseColorW(&cc);// runs a modal loop
+		if (picked)
+		{
+			ColorEvent e(to_color(cc.rgbResult));
+			ColorPicker_call_color_event(picker, &e);
+		}
+		else if (CommDlgExtendedError() != 0)
+			system_error(__FILE__, __LINE__);
+
+		Event e;
+		ColorPicker_call_close_event(picker, &e);
+	}
+
+
+}// Reflex

data/src/win32/event.cpp

@@ -1,6 +1,8 @@
 #include "event.h"
 
 
+#include <string>
+#include <vector>
 #include <xot/time.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
@@ -42,6 +44,90 @@ namespace Reflex
 	}
 
 
+	static std::wstring
+	get_composition_string (HIMC himc, DWORD index)
+	{
+		LONG size = ImmGetCompositionStringW(himc, index, NULL, 0);
+		if (size <= 0) return {};
+
+		std::wstring text(size / sizeof(wchar_t), L'\0');
+		ImmGetCompositionStringW(himc, index, text.data(), size);
+		return text;
+	}
+
+	static int
+	to_char_index (const std::wstring& str, size_t utf16_index)
+	{
+		size_t length = str.size();
+		if (utf16_index > length) utf16_index = length;
+
+		int index = 0;
+		for (size_t i = 0; i < utf16_index; ++i, ++index)
+		{
+			if (!IS_HIGH_SURROGATE(str[i]) || i + 1 >= length)
+				continue;
+
+			if (IS_LOW_SURROGATE(str[i + 1])) ++i;
+		}
+		return index;
+	}
+
+	static void
+	get_selection (
+		HIMC himc, const std::wstring& text, int* offset, int* size)
+	{
+		*offset = *size = 0;
+
+		LONG attr_size = ImmGetCompositionStringW(himc, GCS_COMPATTR, NULL, 0);
+		if (attr_size > 0)
+		{
+			std::vector<char> attrs(attr_size);
+			ImmGetCompositionStringW(himc, GCS_COMPATTR, attrs.data(), attr_size);
+
+			int begin = -1, end = 0;
+			for (LONG i = 0; i < attr_size; ++i)
+			{
+				if (
+					attrs[i] != ATTR_TARGET_CONVERTED &&
+					attrs[i] != ATTR_TARGET_NOTCONVERTED)
+				{
+					continue;
+				}
+
+				if (begin < 0) begin = (int) i;
+				end = (int) i + 1;
+			}
+
+			if (begin >= 0)
+			{
+				*offset = to_char_index(text, begin);
+				*size   = to_char_index(text, end) - *offset;
+				return;
+			}
+		}
+
+		LONG pos = ImmGetCompositionStringW(himc, GCS_CURSORPOS, NULL, 0);
+		*offset  = to_char_index(text, pos >= 0 ? (size_t) pos : text.size());
+	}
+
+	static TextEvent
+	to_text_event (TextEvent::Action action, HIMC himc, DWORD index)
+	{
+		std::wstring text = get_composition_string(himc, index);
+
+		int offset = -1, size = 0;
+		if (action == TextEvent::PREEDIT)
+			get_selection(himc, text, &offset, &size);
+
+		return TextEvent(action, String(text.c_str(), text.size()), offset, size);
+	}
+
+	NativeTextEvent::NativeTextEvent (Action action, HIMC himc, DWORD index)
+	:	TextEvent(to_text_event(action, himc, index))
+	{
+	}
+
+
 	static uint
 	get_mouse_type (UINT msg, WPARAM wp)
 	{
@@ -131,19 +217,20 @@ namespace Reflex
 		}
 	}
 
-	NativePointerEvent::NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp)
-	:	NativePointerEvent(msg, wp, lp, get_mouse_action(msg))
+	NativePointerEvent::NativePointerEvent (
+		const Window& window, UINT msg, WPARAM wp, LPARAM lp)
+	:	NativePointerEvent(window, msg, wp, lp, get_mouse_action(msg))
 	{
 	}
 
 	NativePointerEvent::NativePointerEvent (
-		UINT msg, WPARAM wp, LPARAM lp, Pointer::Action action)
+		const Window& window, UINT msg, WPARAM wp, LPARAM lp, Pointer::Action action)
 	{
 		PointerEvent_add_pointer(this, Pointer(
 			0,
 			get_mouse_type(msg, wp),
 			action,
-			Point(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)),
+			Window_from_native_coord(window, GET_X_LPARAM(lp), GET_Y_LPARAM(lp)),
 			KeyEvent_get_modifiers(),
 			get_mouse_click_count(msg),
 			is_mouse_dragging(msg, wp),
@@ -168,19 +255,19 @@ namespace Reflex
 	}
 
 	static Point
-	get_touch_position (HWND hwnd, const TOUCHINPUT& touch)
+	get_touch_position (const Window& window, const TOUCHINPUT& touch)
 	{
 		coord x = (coord) touch.x / 100;
 		coord y = (coord) touch.y / 100;
 
 		POINT point = {0, 0};
-		if (ClientToScreen(hwnd, &point))
+		if (ClientToScreen(Window_get_hwnd(&window), &point))
 		{
 			x -= point.x;
 			y -= point.y;
 		}
 
-		return Point(x, y);
+		return Window_from_native_coord(window, x, y);
 	}
 
 	static double
@@ -193,7 +280,7 @@ namespace Reflex
 	}
 
 	NativePointerEvent::NativePointerEvent (
-		HWND hwnd, const TOUCHINPUT* touches, size_t size)
+		const Window& window, const TOUCHINPUT* touches, size_t size)
 	{
 		for (size_t i = 0; i < size; ++i)
 		{
@@ -204,7 +291,7 @@ namespace Reflex
 				0,
 				get_touch_type(touch),
 				action,
-				get_touch_position(hwnd, touch),
+				get_touch_position(window, touch),
 				KeyEvent_get_modifiers(),
 				action == Pointer::DOWN ? 1 : 0,
 				action == Pointer::MOVE,
@@ -217,10 +304,25 @@ namespace Reflex
 	}
 
 
-	NativeWheelEvent::NativeWheelEvent (WPARAM wp_x, WPARAM wp_y, LPARAM lp)
+	static Point
+	get_pointer_position (const Window& window, LPARAM lp)
+	{
+		POINT pos = {GET_X_LPARAM(lp), GET_Y_LPARAM(lp)};
+		ScreenToClient(Window_get_hwnd(&window), &pos);
+		return Window_from_native_coord(window, pos.x, pos.y);
+	}
+
+	static coord
+	to_wheel_pixels (WPARAM wp)
+	{
+		return (coord) GET_WHEEL_DELTA_WPARAM(wp) / WHEEL_DELTA * WHEEL_PIXELS_PER_NOTCH;
+	}
+
+	NativeWheelEvent::NativeWheelEvent (
+		const Window& window, WPARAM wp_x, WPARAM wp_y, LPARAM lp)
 	:	WheelEvent(
-			GET_X_LPARAM(lp),              GET_Y_LPARAM(lp),             0,
-			GET_WHEEL_DELTA_WPARAM(wp_x), -GET_WHEEL_DELTA_WPARAM(wp_y), 0,
+			get_pointer_position(window, lp),
+			Point(to_wheel_pixels(wp_x), -to_wheel_pixels(wp_y), 0),
 			KeyEvent_get_modifiers())
 	{
 	}

data/src/win32/event.h

@@ -5,6 +5,8 @@
 
 
 #include <xot/windows.h>
+#include <imm.h>
+
 #include "../event.h"
 
 
@@ -22,16 +24,31 @@ namespace Reflex
 	};// NativeKeyEvent
 
 
+	class NativeTextEvent : public TextEvent
+	{
+
+		public:
+
+			NativeTextEvent (Action action, HIMC himc, DWORD index);
+
+	};// NativeTextEvent
+
+
+	class Window;
+
+
 	class NativePointerEvent : public PointerEvent
 	{
 
 		public:
 
-			NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp);
+			NativePointerEvent (const Window& window, UINT msg, WPARAM wp, LPARAM lp);
 
-			NativePointerEvent (UINT msg, WPARAM wp, LPARAM lp, Pointer::Action action);
+			NativePointerEvent (
+				const Window& window, UINT msg, WPARAM wp, LPARAM lp, Pointer::Action action);
 
-			NativePointerEvent (HWND hwnd, const TOUCHINPUT* touches, size_t size);
+			NativePointerEvent (
+				const Window& window, const TOUCHINPUT* touches, size_t size);
 
 	};// NativePointerEvent
 
@@ -41,7 +58,7 @@ namespace Reflex
 
 		public:
 
-			NativeWheelEvent (WPARAM wp_x, WPARAM wp_y, LPARAM lp);
+			NativeWheelEvent (const Window& window, WPARAM wp_x, WPARAM wp_y, LPARAM lp);
 
 	};// NativeWheelEvent
 

data/src/win32/file_dialog.cpp

@@ -0,0 +1,226 @@
+#include "../file_dialog.h"
+
+
+#include <wchar.h>
+#include <string>
+#include <xot/windows.h>
+#include <shobjidl.h>
+#include <xot/noncopyable.h>
+#include "reflex/exception.h"
+#include "window.h"
+
+
+namespace Reflex
+{
+
+
+	template <typename T>
+	struct ComPtr : public Xot::NonCopyable
+	{
+
+		T* ptr = NULL;
+
+		~ComPtr () {if (ptr) ptr->Release();}
+
+		T* operator -> () {return ptr;}
+
+		operator bool () const {return ptr != NULL;}
+
+	};// ComPtr
+
+
+	static std::wstring
+	to_native_path (const char* path)
+	{
+		std::wstring result = String(path).to_wstr();
+		for (auto& c : result)
+		{
+			if (c == L'/') c = L'\\';
+		}
+		return result;
+	}
+
+	static String
+	from_native_path (PCWSTR path, size_t size)
+	{
+		String result(path, size);
+		for (auto& c : result)
+		{
+			if (c == '\\') c = '/';
+		}
+		return result;
+	}
+
+	static void
+	setup_options (IFileDialog* nativedialog, FileDialog::Data::Mode mode)
+	{
+		FILEOPENDIALOGOPTIONS options = 0;
+		if (FAILED(nativedialog->GetOptions(&options)))
+			system_error(__FILE__, __LINE__);
+
+		options |= FOS_FORCEFILESYSTEM;
+		if (mode == FileDialog::Data::OPEN_DIRECTORY) options |= FOS_PICKFOLDERS;
+		if (mode == FileDialog::Data::OPEN_FILES)     options |= FOS_ALLOWMULTISELECT;
+
+		if (FAILED(nativedialog->SetOptions(options)))
+			system_error(__FILE__, __LINE__);
+	}
+
+	static void
+	setup_file_types (
+		std::wstring* joined,
+		IFileDialog* nativedialog, const FileDialog* dialog, FileDialog::Data::Mode mode)
+	{
+		if (mode == FileDialog::Data::OPEN_DIRECTORY)
+			return;
+
+		const StringList& extensions = dialog->extensions();
+		if (extensions.empty())
+			return;
+
+		for (const auto& extension : extensions)
+		{
+			if (!joined->empty()) *joined += L';';
+			*joined += ("*." + extension).to_wstr();
+		}
+
+		COMDLG_FILTERSPEC spec = {L"Files", joined->c_str()};
+		nativedialog->SetFileTypes(1, &spec);
+	}
+
+	static void
+	add_path (StringList* paths, IShellItem* item)
+	{
+		PWSTR wpath = NULL;
+		if (FAILED(item->GetDisplayName(SIGDN_FILESYSPATH, &wpath)) || !wpath)
+			return;
+
+		paths->emplace_back(from_native_path(wpath, wcslen(wpath)));
+		CoTaskMemFree(wpath);
+	}
+
+	static bool
+	is_missing_result (HRESULT hresult)
+	{
+		// closing the last window ends the modal loop of Show() with a WM_QUIT,
+		// and it answers S_OK though nothing was ever chosen. asking for the
+		// result then gives E_FAIL, which is this dialog being over, not an error
+		return hresult == E_FAIL;
+	}
+
+	static void
+	get_open_paths (StringList* paths, IFileOpenDialog* nativedialog)
+	{
+		ComPtr<IShellItemArray> items;
+		HRESULT result = nativedialog->GetResults(&items.ptr);
+		if (is_missing_result(result))
+			return;
+		if (FAILED(result) || !items)
+			system_error(__FILE__, __LINE__);
+
+		DWORD count = 0;
+		if (FAILED(items->GetCount(&count)))
+			system_error(__FILE__, __LINE__);
+
+		for (DWORD i = 0; i < count; ++i)
+		{
+			ComPtr<IShellItem> item;
+			if (FAILED(items->GetItemAt(i, &item.ptr)) || !item)
+				continue;
+
+			add_path(paths, item.ptr);
+		}
+	}
+
+	static void
+	get_save_path (StringList* paths, IFileDialog* nativedialog)
+	{
+		ComPtr<IShellItem> item;
+		HRESULT result = nativedialog->GetResult(&item.ptr);
+		if (is_missing_result(result))
+			return;
+		if (FAILED(result) || !item)
+			system_error(__FILE__, __LINE__);
+
+		add_path(paths, item.ptr);
+	}
+
+	static void
+	set_folder (IFileDialog* nativedialog, const char* dir)
+	{
+		// SetFolder overrides the folder the user last visited, so it is only
+		// called when a directory was explicitly given
+		ComPtr<IShellItem> item;
+		HRESULT result = SHCreateItemFromParsingName(
+			to_native_path(dir).c_str(), NULL, IID_IShellItem, (void**) &item.ptr);
+		if (SUCCEEDED(result) && item)
+			nativedialog->SetFolder(item.ptr);
+	}
+
+	void
+	FileDialog_show (
+		FileDialog* pdialog, FileDialog::Data::Mode mode,
+		const char* dir, const char* name)
+	{
+		if (!pdialog)
+			argument_error(__FILE__, __LINE__);
+
+		FileDialog::Ref dialog = pdialog;
+		bool save              = mode == FileDialog::Data::SAVE_FILE;
+
+		ComPtr<IFileOpenDialog> opendialog;
+		ComPtr<IFileDialog>     savedialog;
+		HRESULT result = CoCreateInstance(
+			save ? CLSID_FileSaveDialog     : CLSID_FileOpenDialog,
+			NULL,
+			CLSCTX_INPROC_SERVER,
+			save ? IID_IFileDialog          : IID_IFileOpenDialog,
+			save ? (void**) &savedialog.ptr : (void**) &opendialog.ptr);
+		if (FAILED(result))
+			system_error(__FILE__, __LINE__);
+
+		IFileDialog* nativedialog = save ? savedialog.ptr : (IFileDialog*) opendialog.ptr;
+		setup_options(nativedialog, mode);
+
+		std::wstring joined;// keeps the filter string alive until Show()
+		setup_file_types(&joined, nativedialog, dialog, mode);
+
+		const char* title = dialog->title();
+		if (*title)
+			nativedialog->SetTitle(String(title).to_wstr().c_str());
+
+		if (dir && *dir)
+			set_folder(nativedialog, dir);
+
+		if (save && name && *name)
+			nativedialog->SetFileName(String(name).to_wstr().c_str());
+
+		Window* owner = dialog->owner();
+		HWND hwnd     = owner ? Window_get_hwnd(owner) : NULL;
+		result        = nativedialog->Show(hwnd);// runs a modal loop
+
+		StringList paths;
+		if (SUCCEEDED(result))
+		{
+			if (save)
+				get_save_path(&paths, savedialog.ptr);
+			else
+				get_open_paths(&paths, opendialog.ptr);
+		}
+
+		if (!paths.empty())
+		{
+			FileEvent e(save ? FileEvent::SAVE : FileEvent::OPEN, paths);
+			FileDialog_call_file_event(dialog, &e);
+		}
+		else if (SUCCEEDED(result) || result == HRESULT_FROM_WIN32(ERROR_CANCELLED))
+		{
+			Event e;
+			FileDialog_call_cancel_event(dialog, &e);
+		}
+		else
+			system_error(__FILE__, __LINE__);
+	}
+
+
+}// Reflex

data/src/win32/gamepad.cpp

@@ -72,20 +72,27 @@ namespace Reflex
 		handle_gamepad_trigger_event(win, state.Gamepad.bRightTrigger, prev_state.Gamepad.bRightTrigger, KEY_GAMEPAD_RTRIGGER);
 	}
 
+	static bool polling = false;
+
 	void
-	Gamepad_init (Application* app)
+	Gamepad_init_native (Application* app)
 	{
+		polling = true;
 	}
 
 	void
-	Gamepad_fin (Application* app)
+	Gamepad_fin_native (Application* app)
 	{
+		polling = false;
+
 		Gamepad_remove_all(app);
 	}
 
 	void
 	Gamepad_poll ()
 	{
+		if (!polling) return;
+
 		static XINPUT_STATE prev_state;
 		static bool prev_detected = false;