reflexion 0.5.3 → 0.7.0

data/src/win32/application.cpp

@@ -1,19 +1,151 @@
-#include "../application.h"
+#include "application.h"
 
 
+#include <vector>
 #include <xot/windows.h>
 #include "reflex/exception.h"
 #include "window.h"
+#include "tray.h"
 
 
 namespace Reflex
 {
 
 
+	struct ApplicationData : public Application::Data
+	{
+
+		bool quit = false;
+
+	};// ApplicationData
+
+
+	static ApplicationData*
+	get_data (Application* app)
+	{
+		return (ApplicationData*) app->self.get();
+	}
+
 	Application::Data*
 	Application_create_data ()
 	{
-		return new Application::Data();
+		return new ApplicationData();
+	}
+
+	static std::wstring
+	get_app_executable_path ()
+	{
+		std::wstring path(MAX_PATH, L'\0');
+		while (true)
+		{
+			DWORD len = GetModuleFileNameW(NULL, &path[0], (DWORD) path.size());
+			if (len < path.size())
+			{
+				path.resize(len);
+				break;
+			}
+			path.resize(path.size() * 2);
+		}
+		return path;
+	}
+
+	static String
+	get_product_name (const wchar_t* path)
+	{
+		DWORD size = GetFileVersionInfoSizeW(path, NULL);
+		if (size == 0) return "";
+
+		std::vector<BYTE> info(size);
+		if (!GetFileVersionInfoW(path, 0, size, &info[0]))
+			return "";
+
+		struct Translation {WORD lang, codepage;};
+		Translation* translations = NULL;
+		UINT bytes                = 0;
+		if (
+			!VerQueryValueW(
+				&info[0], L"\\VarFileInfo\\Translation", (void**) &translations, &bytes) ||
+			bytes < sizeof(Translation))
+		{
+			return "";
+		}
+
+		LANGID deflang           = GetUserDefaultUILanguage();
+		const Translation* found = &translations[0];
+		for (size_t i = 0; i < bytes / sizeof(Translation); ++i)
+		{
+			const Translation& t = translations[i];
+			if (t.lang == deflang)
+			{
+				found = &t;
+				break;
+			}
+			if (
+				PRIMARYLANGID(t.lang) == PRIMARYLANGID(deflang) &&
+				found == &translations[0])
+			{
+				found = &t;
+			}
+		}
+
+		wchar_t key[64];
+		swprintf(
+			key, 64, L"\\StringFileInfo\\%04x%04x\\ProductName",
+			found->lang, found->codepage);
+
+		wchar_t* name = NULL;
+		if (!VerQueryValueW(&info[0], key, (void**) &name, &bytes) || bytes <= 1)
+			return "";
+
+		return String(name, wcslen(name));
+	}
+
+	String
+	Application_get_default_name ()
+	{
+		std::wstring path = get_app_executable_path();
+		if (path.empty())
+			return "";
+
+		String name = get_product_name(path.c_str());
+		if (!name.empty())
+			return name;
+
+		std::wstring file = path.substr(path.find_last_of(L"\\/") + 1);
+		size_t dot        = file.find_last_of(L'.');
+		if (dot != std::wstring::npos) file.resize(dot);
+		return String(file.c_str(), file.size());
+	}
+
+	void
+	Application_stop (Application* app)
+	{
+		get_data(app)->quit = true;
+	}
+
+	void
+	Application_set_menu (Application* app, Menu* menu)
+	{
+		Tray_update_icon(app);
+	}
+
+	void
+	Application_set_background (Application* app, bool state)
+	{
+		Tray_update_icon(app);
+	}
+
+	void
+	Application_set_background_menu (Application* app, Menu* menu)
+	{
+		Tray_update_icon(app);
+	}
+
+	void
+	Application_quit_if_should ()
+	{
+		if (Application_should_quit(app()))
+			Application_call_quit(app());
 	}
 
 
@@ -41,21 +173,34 @@ namespace Reflex
 	void
 	Application::start ()
 	{
+		ApplicationData* self = get_data(this);
+		self->quit     = false;
+		self->quitting = false;
+		self->started  = false;
+		self->running  = true;
+
+		Tray_update_icon(this);
+
 		Event e;
-		Application_call_start(this, &e);
+		Application_call_start_event(this, &e);
 
 		timeBeginPeriod(1);
 
 		double prev = get_time();
 
-		MSG msg;
-		while (true)
+		MSG msg = {0};
+		while (!self->quit)
 		{
-			if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+			if (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
 			{
-				if (msg.message == WM_QUIT) break;
+				if (msg.message == WM_QUIT)
+					break;
+
+				if (Window_translate_accelerator(&msg))
+					continue;
+
 				TranslateMessage(&msg);
-				DispatchMessage(&msg);
+				DispatchMessageW(&msg);
 			}
 			else
 			{
@@ -70,14 +215,24 @@ namespace Reflex
 					continue;
 				}
 
-				update_all_windows(this);
+				// guarded here too, since rays can throw while drawing
+				Application_guard([&]()
+				{
+					update_all_windows(this);
+				});
 				prev = now;
 			}
 		}
 
 		timeEndPeriod(1);
 
-		if (msg.wParam != 0)
+		self->running = false;
+
+		Tray_remove_icon();
+		Application_cleanup(this);
+		Application_throw_exception(this);
+
+		if (msg.message == WM_QUIT && msg.wParam != 0)
 			reflex_error(__FILE__, __LINE__, "WM_QUIT with wParam %d.", msg.wParam);
 	}
 
@@ -85,10 +240,10 @@ namespace Reflex
 	Application::quit ()
 	{
 		Event e;
-		Application_call_quit(this, &e);
+		Application_call_quit_event(this, &e);
 		if (e.is_blocked()) return;
 
-		PostQuitMessage(0);
+		Application_stop(this);
 	}
 
 	void

data/src/win32/application.h

@@ -0,0 +1,20 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_WIN32_APPLICATION_H__
+#define __REFLEX_SRC_WIN32_APPLICATION_H__
+
+
+#include "../application.h"
+
+
+namespace Reflex
+{
+
+
+	void Application_quit_if_should ();
+
+
+}// Reflex
+
+
+#endif//EOH

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/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