/*
* This source file is part of RmlUi, the HTML/CSS Interface Middleware
*
* For the latest information, see http://github.com/mikke89/RmlUi
*
* Copyright (c) 2008-2010 CodePoint Ltd, Shift Technology Ltd
* Copyright (c) 2019 The RmlUi Team, and contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
#include "RmlUi_Platform_Win32.h"
#include "RmlUi_Include_Windows.h"
#include
#include
#include
#include
#include
// Used to interact with the input method editor (IME). Users of MinGW should manually link to this.
#ifdef _MSC_VER
#pragma comment(lib, "imm32")
#endif
SystemInterface_Win32::SystemInterface_Win32()
{
LARGE_INTEGER time_ticks_per_second;
QueryPerformanceFrequency(&time_ticks_per_second);
QueryPerformanceCounter(&time_startup);
time_frequency = 1.0 / (double)time_ticks_per_second.QuadPart;
// Load cursors
cursor_default = LoadCursor(nullptr, IDC_ARROW);
cursor_move = LoadCursor(nullptr, IDC_SIZEALL);
cursor_pointer = LoadCursor(nullptr, IDC_HAND);
cursor_resize = LoadCursor(nullptr, IDC_SIZENWSE);
cursor_cross = LoadCursor(nullptr, IDC_CROSS);
cursor_text = LoadCursor(nullptr, IDC_IBEAM);
cursor_unavailable = LoadCursor(nullptr, IDC_NO);
}
void SystemInterface_Win32::SetWindow(HWND in_window_handle)
{
window_handle = in_window_handle;
}
double SystemInterface_Win32::GetElapsedTime()
{
LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
return double(counter.QuadPart - time_startup.QuadPart) * time_frequency;
}
void SystemInterface_Win32::SetMouseCursor(const Rml::String& cursor_name)
{
if (window_handle)
{
HCURSOR cursor_handle = nullptr;
if (cursor_name.empty() || cursor_name == "arrow")
cursor_handle = cursor_default;
else if (cursor_name == "move")
cursor_handle = cursor_move;
else if (cursor_name == "pointer")
cursor_handle = cursor_pointer;
else if (cursor_name == "resize")
cursor_handle = cursor_resize;
else if (cursor_name == "cross")
cursor_handle = cursor_cross;
else if (cursor_name == "text")
cursor_handle = cursor_text;
else if (cursor_name == "unavailable")
cursor_handle = cursor_unavailable;
if (cursor_handle)
{
SetCursor(cursor_handle);
SetClassLongPtrA(window_handle, GCLP_HCURSOR, (LONG_PTR)cursor_handle);
}
}
}
void SystemInterface_Win32::SetClipboardText(const Rml::String& text_utf8)
{
if (window_handle)
{
if (!OpenClipboard(window_handle))
return;
EmptyClipboard();
const std::wstring text = RmlWin32::ConvertToUTF16(text_utf8);
const size_t size = sizeof(wchar_t) * (text.size() + 1);
HGLOBAL clipboard_data = GlobalAlloc(GMEM_FIXED, size);
memcpy(clipboard_data, text.data(), size);
if (SetClipboardData(CF_UNICODETEXT, clipboard_data) == nullptr)
{
CloseClipboard();
GlobalFree(clipboard_data);
}
else
CloseClipboard();
}
}
void SystemInterface_Win32::GetClipboardText(Rml::String& text)
{
if (window_handle)
{
if (!OpenClipboard(window_handle))
return;
HANDLE clipboard_data = GetClipboardData(CF_UNICODETEXT);
if (clipboard_data == nullptr)
{
CloseClipboard();
return;
}
const wchar_t* clipboard_text = (const wchar_t*)GlobalLock(clipboard_data);
if (clipboard_text)
text = RmlWin32::ConvertToUTF8(clipboard_text);
GlobalUnlock(clipboard_data);
CloseClipboard();
}
}
void SystemInterface_Win32::ActivateKeyboard(Rml::Vector2f caret_position, float /*line_height*/)
{
// Adjust the position of the input method editor (IME) to the caret.
if (HIMC himc = ImmGetContext(window_handle))
{
COMPOSITIONFORM comp = {};
comp.ptCurrentPos.x = (LONG)caret_position.x;
comp.ptCurrentPos.y = (LONG)caret_position.y;
comp.dwStyle = CFS_FORCE_POSITION;
ImmSetCompositionWindow(himc, &comp);
CANDIDATEFORM cand = {};
cand.dwStyle = CFS_CANDIDATEPOS;
cand.ptCurrentPos.x = (LONG)caret_position.x;
cand.ptCurrentPos.y = (LONG)caret_position.y;
ImmSetCandidateWindow(himc, &cand);
ImmReleaseContext(window_handle, himc);
}
}
Rml::String RmlWin32::ConvertToUTF8(const std::wstring& wstr)
{
const int count = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), (int)wstr.length(), NULL, 0, NULL, NULL);
Rml::String str(count, 0);
WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &str[0], count, NULL, NULL);
return str;
}
std::wstring RmlWin32::ConvertToUTF16(const Rml::String& str)
{
const int count = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), NULL, 0);
std::wstring wstr(count, 0);
MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), &wstr[0], count);
return wstr;
}
bool RmlWin32::WindowProcedure(Rml::Context* context, HWND window_handle, UINT message, WPARAM w_param, LPARAM l_param)
{
if (!context)
return true;
static bool tracking_mouse_leave = false;
bool result = true;
switch (message)
{
case WM_LBUTTONDOWN:
result = context->ProcessMouseButtonDown(0, RmlWin32::GetKeyModifierState());
SetCapture(window_handle);
break;
case WM_LBUTTONUP:
ReleaseCapture();
result = context->ProcessMouseButtonUp(0, RmlWin32::GetKeyModifierState());
break;
case WM_RBUTTONDOWN:
result = context->ProcessMouseButtonDown(1, RmlWin32::GetKeyModifierState());
break;
case WM_RBUTTONUP:
result = context->ProcessMouseButtonUp(1, RmlWin32::GetKeyModifierState());
break;
case WM_MBUTTONDOWN:
result = context->ProcessMouseButtonDown(2, RmlWin32::GetKeyModifierState());
break;
case WM_MBUTTONUP:
result = context->ProcessMouseButtonUp(2, RmlWin32::GetKeyModifierState());
break;
case WM_MOUSEMOVE:
result = context->ProcessMouseMove(static_cast((short)LOWORD(l_param)), static_cast((short)HIWORD(l_param)),
RmlWin32::GetKeyModifierState());
if (!tracking_mouse_leave)
{
TRACKMOUSEEVENT tme = {};
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_LEAVE;
tme.hwndTrack = window_handle;
tracking_mouse_leave = TrackMouseEvent(&tme);
}
break;
case WM_MOUSEWHEEL:
result = context->ProcessMouseWheel(static_cast((short)HIWORD(w_param)) / static_cast(-WHEEL_DELTA),
RmlWin32::GetKeyModifierState());
break;
case WM_MOUSELEAVE:
result = context->ProcessMouseLeave();
tracking_mouse_leave = false;
break;
case WM_KEYDOWN:
result = context->ProcessKeyDown(RmlWin32::ConvertKey((int)w_param), RmlWin32::GetKeyModifierState());
break;
case WM_KEYUP:
result = context->ProcessKeyUp(RmlWin32::ConvertKey((int)w_param), RmlWin32::GetKeyModifierState());
break;
case WM_CHAR:
{
static wchar_t first_u16_code_unit = 0;
const wchar_t c = (wchar_t)w_param;
Rml::Character character = (Rml::Character)c;
// Windows sends two-wide characters as two messages.
if (c >= 0xD800 && c < 0xDC00)
{
// First 16-bit code unit of a two-wide character.
first_u16_code_unit = c;
}
else
{
if (c >= 0xDC00 && c < 0xE000 && first_u16_code_unit != 0)
{
// Second 16-bit code unit of a two-wide character.
Rml::String utf8 = ConvertToUTF8(std::wstring{first_u16_code_unit, c});
character = Rml::StringUtilities::ToCharacter(utf8.data());
}
else if (c == '\r')
{
// Windows sends new-lines as carriage returns, convert to endlines.
character = (Rml::Character)'\n';
}
first_u16_code_unit = 0;
// Only send through printable characters.
if (((char32_t)character >= 32 || character == (Rml::Character)'\n') && character != (Rml::Character)127)
result = context->ProcessTextInput(character);
}
}
break;
default:
break;
}
return result;
}
int RmlWin32::GetKeyModifierState()
{
int key_modifier_state = 0;
if (GetKeyState(VK_CAPITAL) & 1)
key_modifier_state |= Rml::Input::KM_CAPSLOCK;
if (GetKeyState(VK_NUMLOCK) & 1)
key_modifier_state |= Rml::Input::KM_NUMLOCK;
if (HIWORD(GetKeyState(VK_SHIFT)) & 1)
key_modifier_state |= Rml::Input::KM_SHIFT;
if (HIWORD(GetKeyState(VK_CONTROL)) & 1)
key_modifier_state |= Rml::Input::KM_CTRL;
if (HIWORD(GetKeyState(VK_MENU)) & 1)
key_modifier_state |= Rml::Input::KM_ALT;
return key_modifier_state;
}
// These are defined in winuser.h of MinGW 64 but are missing from MinGW 32
// Visual Studio has them by default
#if defined(__MINGW32__) && !defined(__MINGW64__)
#define VK_OEM_NEC_EQUAL 0x92
#define VK_OEM_FJ_JISHO 0x92
#define VK_OEM_FJ_MASSHOU 0x93
#define VK_OEM_FJ_TOUROKU 0x94
#define VK_OEM_FJ_LOYA 0x95
#define VK_OEM_FJ_ROYA 0x96
#define VK_OEM_AX 0xE1
#define VK_ICO_HELP 0xE3
#define VK_ICO_00 0xE4
#define VK_ICO_CLEAR 0xE6
#endif // !defined(__MINGW32__) || defined(__MINGW64__)
Rml::Input::KeyIdentifier RmlWin32::ConvertKey(int win32_key_code)
{
// clang-format off
switch (win32_key_code)
{
case 'A': return Rml::Input::KI_A;
case 'B': return Rml::Input::KI_B;
case 'C': return Rml::Input::KI_C;
case 'D': return Rml::Input::KI_D;
case 'E': return Rml::Input::KI_E;
case 'F': return Rml::Input::KI_F;
case 'G': return Rml::Input::KI_G;
case 'H': return Rml::Input::KI_H;
case 'I': return Rml::Input::KI_I;
case 'J': return Rml::Input::KI_J;
case 'K': return Rml::Input::KI_K;
case 'L': return Rml::Input::KI_L;
case 'M': return Rml::Input::KI_M;
case 'N': return Rml::Input::KI_N;
case 'O': return Rml::Input::KI_O;
case 'P': return Rml::Input::KI_P;
case 'Q': return Rml::Input::KI_Q;
case 'R': return Rml::Input::KI_R;
case 'S': return Rml::Input::KI_S;
case 'T': return Rml::Input::KI_T;
case 'U': return Rml::Input::KI_U;
case 'V': return Rml::Input::KI_V;
case 'W': return Rml::Input::KI_W;
case 'X': return Rml::Input::KI_X;
case 'Y': return Rml::Input::KI_Y;
case 'Z': return Rml::Input::KI_Z;
case '0': return Rml::Input::KI_0;
case '1': return Rml::Input::KI_1;
case '2': return Rml::Input::KI_2;
case '3': return Rml::Input::KI_3;
case '4': return Rml::Input::KI_4;
case '5': return Rml::Input::KI_5;
case '6': return Rml::Input::KI_6;
case '7': return Rml::Input::KI_7;
case '8': return Rml::Input::KI_8;
case '9': return Rml::Input::KI_9;
case VK_BACK: return Rml::Input::KI_BACK;
case VK_TAB: return Rml::Input::KI_TAB;
case VK_CLEAR: return Rml::Input::KI_CLEAR;
case VK_RETURN: return Rml::Input::KI_RETURN;
case VK_PAUSE: return Rml::Input::KI_PAUSE;
case VK_CAPITAL: return Rml::Input::KI_CAPITAL;
case VK_KANA: return Rml::Input::KI_KANA;
//case VK_HANGUL: return Rml::Input::KI_HANGUL; /* overlaps with VK_KANA */
case VK_JUNJA: return Rml::Input::KI_JUNJA;
case VK_FINAL: return Rml::Input::KI_FINAL;
case VK_HANJA: return Rml::Input::KI_HANJA;
//case VK_KANJI: return Rml::Input::KI_KANJI; /* overlaps with VK_HANJA */
case VK_ESCAPE: return Rml::Input::KI_ESCAPE;
case VK_CONVERT: return Rml::Input::KI_CONVERT;
case VK_NONCONVERT: return Rml::Input::KI_NONCONVERT;
case VK_ACCEPT: return Rml::Input::KI_ACCEPT;
case VK_MODECHANGE: return Rml::Input::KI_MODECHANGE;
case VK_SPACE: return Rml::Input::KI_SPACE;
case VK_PRIOR: return Rml::Input::KI_PRIOR;
case VK_NEXT: return Rml::Input::KI_NEXT;
case VK_END: return Rml::Input::KI_END;
case VK_HOME: return Rml::Input::KI_HOME;
case VK_LEFT: return Rml::Input::KI_LEFT;
case VK_UP: return Rml::Input::KI_UP;
case VK_RIGHT: return Rml::Input::KI_RIGHT;
case VK_DOWN: return Rml::Input::KI_DOWN;
case VK_SELECT: return Rml::Input::KI_SELECT;
case VK_PRINT: return Rml::Input::KI_PRINT;
case VK_EXECUTE: return Rml::Input::KI_EXECUTE;
case VK_SNAPSHOT: return Rml::Input::KI_SNAPSHOT;
case VK_INSERT: return Rml::Input::KI_INSERT;
case VK_DELETE: return Rml::Input::KI_DELETE;
case VK_HELP: return Rml::Input::KI_HELP;
case VK_LWIN: return Rml::Input::KI_LWIN;
case VK_RWIN: return Rml::Input::KI_RWIN;
case VK_APPS: return Rml::Input::KI_APPS;
case VK_SLEEP: return Rml::Input::KI_SLEEP;
case VK_NUMPAD0: return Rml::Input::KI_NUMPAD0;
case VK_NUMPAD1: return Rml::Input::KI_NUMPAD1;
case VK_NUMPAD2: return Rml::Input::KI_NUMPAD2;
case VK_NUMPAD3: return Rml::Input::KI_NUMPAD3;
case VK_NUMPAD4: return Rml::Input::KI_NUMPAD4;
case VK_NUMPAD5: return Rml::Input::KI_NUMPAD5;
case VK_NUMPAD6: return Rml::Input::KI_NUMPAD6;
case VK_NUMPAD7: return Rml::Input::KI_NUMPAD7;
case VK_NUMPAD8: return Rml::Input::KI_NUMPAD8;
case VK_NUMPAD9: return Rml::Input::KI_NUMPAD9;
case VK_MULTIPLY: return Rml::Input::KI_MULTIPLY;
case VK_ADD: return Rml::Input::KI_ADD;
case VK_SEPARATOR: return Rml::Input::KI_SEPARATOR;
case VK_SUBTRACT: return Rml::Input::KI_SUBTRACT;
case VK_DECIMAL: return Rml::Input::KI_DECIMAL;
case VK_DIVIDE: return Rml::Input::KI_DIVIDE;
case VK_F1: return Rml::Input::KI_F1;
case VK_F2: return Rml::Input::KI_F2;
case VK_F3: return Rml::Input::KI_F3;
case VK_F4: return Rml::Input::KI_F4;
case VK_F5: return Rml::Input::KI_F5;
case VK_F6: return Rml::Input::KI_F6;
case VK_F7: return Rml::Input::KI_F7;
case VK_F8: return Rml::Input::KI_F8;
case VK_F9: return Rml::Input::KI_F9;
case VK_F10: return Rml::Input::KI_F10;
case VK_F11: return Rml::Input::KI_F11;
case VK_F12: return Rml::Input::KI_F12;
case VK_F13: return Rml::Input::KI_F13;
case VK_F14: return Rml::Input::KI_F14;
case VK_F15: return Rml::Input::KI_F15;
case VK_F16: return Rml::Input::KI_F16;
case VK_F17: return Rml::Input::KI_F17;
case VK_F18: return Rml::Input::KI_F18;
case VK_F19: return Rml::Input::KI_F19;
case VK_F20: return Rml::Input::KI_F20;
case VK_F21: return Rml::Input::KI_F21;
case VK_F22: return Rml::Input::KI_F22;
case VK_F23: return Rml::Input::KI_F23;
case VK_F24: return Rml::Input::KI_F24;
case VK_NUMLOCK: return Rml::Input::KI_NUMLOCK;
case VK_SCROLL: return Rml::Input::KI_SCROLL;
case VK_OEM_NEC_EQUAL: return Rml::Input::KI_OEM_NEC_EQUAL;
//case VK_OEM_FJ_JISHO: return Rml::Input::KI_OEM_FJ_JISHO; /* overlaps with VK_OEM_NEC_EQUAL */
case VK_OEM_FJ_MASSHOU: return Rml::Input::KI_OEM_FJ_MASSHOU;
case VK_OEM_FJ_TOUROKU: return Rml::Input::KI_OEM_FJ_TOUROKU;
case VK_OEM_FJ_LOYA: return Rml::Input::KI_OEM_FJ_LOYA;
case VK_OEM_FJ_ROYA: return Rml::Input::KI_OEM_FJ_ROYA;
case VK_SHIFT: return Rml::Input::KI_LSHIFT;
case VK_CONTROL: return Rml::Input::KI_LCONTROL;
case VK_MENU: return Rml::Input::KI_LMENU;
case VK_BROWSER_BACK: return Rml::Input::KI_BROWSER_BACK;
case VK_BROWSER_FORWARD: return Rml::Input::KI_BROWSER_FORWARD;
case VK_BROWSER_REFRESH: return Rml::Input::KI_BROWSER_REFRESH;
case VK_BROWSER_STOP: return Rml::Input::KI_BROWSER_STOP;
case VK_BROWSER_SEARCH: return Rml::Input::KI_BROWSER_SEARCH;
case VK_BROWSER_FAVORITES: return Rml::Input::KI_BROWSER_FAVORITES;
case VK_BROWSER_HOME: return Rml::Input::KI_BROWSER_HOME;
case VK_VOLUME_MUTE: return Rml::Input::KI_VOLUME_MUTE;
case VK_VOLUME_DOWN: return Rml::Input::KI_VOLUME_DOWN;
case VK_VOLUME_UP: return Rml::Input::KI_VOLUME_UP;
case VK_MEDIA_NEXT_TRACK: return Rml::Input::KI_MEDIA_NEXT_TRACK;
case VK_MEDIA_PREV_TRACK: return Rml::Input::KI_MEDIA_PREV_TRACK;
case VK_MEDIA_STOP: return Rml::Input::KI_MEDIA_STOP;
case VK_MEDIA_PLAY_PAUSE: return Rml::Input::KI_MEDIA_PLAY_PAUSE;
case VK_LAUNCH_MAIL: return Rml::Input::KI_LAUNCH_MAIL;
case VK_LAUNCH_MEDIA_SELECT: return Rml::Input::KI_LAUNCH_MEDIA_SELECT;
case VK_LAUNCH_APP1: return Rml::Input::KI_LAUNCH_APP1;
case VK_LAUNCH_APP2: return Rml::Input::KI_LAUNCH_APP2;
case VK_OEM_1: return Rml::Input::KI_OEM_1;
case VK_OEM_PLUS: return Rml::Input::KI_OEM_PLUS;
case VK_OEM_COMMA: return Rml::Input::KI_OEM_COMMA;
case VK_OEM_MINUS: return Rml::Input::KI_OEM_MINUS;
case VK_OEM_PERIOD: return Rml::Input::KI_OEM_PERIOD;
case VK_OEM_2: return Rml::Input::KI_OEM_2;
case VK_OEM_3: return Rml::Input::KI_OEM_3;
case VK_OEM_4: return Rml::Input::KI_OEM_4;
case VK_OEM_5: return Rml::Input::KI_OEM_5;
case VK_OEM_6: return Rml::Input::KI_OEM_6;
case VK_OEM_7: return Rml::Input::KI_OEM_7;
case VK_OEM_8: return Rml::Input::KI_OEM_8;
case VK_OEM_AX: return Rml::Input::KI_OEM_AX;
case VK_OEM_102: return Rml::Input::KI_OEM_102;
case VK_ICO_HELP: return Rml::Input::KI_ICO_HELP;
case VK_ICO_00: return Rml::Input::KI_ICO_00;
case VK_PROCESSKEY: return Rml::Input::KI_PROCESSKEY;
case VK_ICO_CLEAR: return Rml::Input::KI_ICO_CLEAR;
case VK_ATTN: return Rml::Input::KI_ATTN;
case VK_CRSEL: return Rml::Input::KI_CRSEL;
case VK_EXSEL: return Rml::Input::KI_EXSEL;
case VK_EREOF: return Rml::Input::KI_EREOF;
case VK_PLAY: return Rml::Input::KI_PLAY;
case VK_ZOOM: return Rml::Input::KI_ZOOM;
case VK_PA1: return Rml::Input::KI_PA1;
case VK_OEM_CLEAR: return Rml::Input::KI_OEM_CLEAR;
}
// clang-format on
return Rml::Input::KI_UNKNOWN;
}