diff --git a/CMakeLists.txt b/CMakeLists.txt index dd836cd..aca620b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -64,8 +64,8 @@ set(ZWIDGET_INCLUDES ) set(ZWIDGET_WIN32_SOURCES - src/window/win32/win32window.cpp - src/window/win32/win32window.h + src/window/win32/win32displaywindow.cpp + src/window/win32/win32displaywindow.h ) set(ZWIDGET_COCOA_SOURCES diff --git a/include/zwidget/core/widget.h b/include/zwidget/core/widget.h index 34faa14..8835922 100644 --- a/include/zwidget/core/widget.h +++ b/include/zwidget/core/widget.h @@ -85,7 +85,7 @@ class Widget : DisplayWindowHost void CaptureMouse(); void ReleaseMouseCapture(); - bool GetKeyState(EInputKey key); + bool GetKeyState(InputKey key); std::string GetClipboardText(); void SetClipboardText(const std::string& text); @@ -114,16 +114,16 @@ class Widget : DisplayWindowHost protected: virtual void OnPaintFrame(Canvas* canvas) { } virtual void OnPaint(Canvas* canvas) { } - virtual bool OnMouseDown(const Point& pos, int key) { return false; } - virtual bool OnMouseDoubleclick(const Point& pos, int key) { return false; } - virtual bool OnMouseUp(const Point& pos, int key) { return false; } - virtual bool OnMouseWheel(const Point& pos, EInputKey key) { return false; } + virtual bool OnMouseDown(const Point& pos, InputKey key) { return false; } + virtual bool OnMouseDoubleclick(const Point& pos, InputKey key) { return false; } + virtual bool OnMouseUp(const Point& pos, InputKey key) { return false; } + virtual bool OnMouseWheel(const Point& pos, InputKey key) { return false; } virtual void OnMouseMove(const Point& pos) { } virtual void OnMouseLeave() { } virtual void OnRawMouseMove(int dx, int dy) { } virtual void OnKeyChar(std::string chars) { } - virtual void OnKeyDown(EInputKey key) { } - virtual void OnKeyUp(EInputKey key) { } + virtual void OnKeyDown(InputKey key) { } + virtual void OnKeyUp(InputKey key) { } virtual void OnGeometryChanged() { } virtual void OnClose() { delete this; } virtual void OnSetFocus() { } @@ -138,14 +138,14 @@ class Widget : DisplayWindowHost // DisplayWindowHost void OnWindowPaint() override; void OnWindowMouseMove(const Point& pos) override; - void OnWindowMouseDown(const Point& pos, EInputKey key) override; - void OnWindowMouseDoubleclick(const Point& pos, EInputKey key) override; - void OnWindowMouseUp(const Point& pos, EInputKey key) override; - void OnWindowMouseWheel(const Point& pos, EInputKey key) override; + void OnWindowMouseDown(const Point& pos, InputKey key) override; + void OnWindowMouseDoubleclick(const Point& pos, InputKey key) override; + void OnWindowMouseUp(const Point& pos, InputKey key) override; + void OnWindowMouseWheel(const Point& pos, InputKey key) override; void OnWindowRawMouseMove(int dx, int dy) override; void OnWindowKeyChar(std::string chars) override; - void OnWindowKeyDown(EInputKey key) override; - void OnWindowKeyUp(EInputKey key) override; + void OnWindowKeyDown(InputKey key) override; + void OnWindowKeyUp(InputKey key) override; void OnWindowGeometryChanged() override; void OnWindowClose() override; void OnWindowActivated() override; diff --git a/include/zwidget/widgets/checkboxlabel/checkboxlabel.h b/include/zwidget/widgets/checkboxlabel/checkboxlabel.h index 57025fe..21ce0b6 100644 --- a/include/zwidget/widgets/checkboxlabel/checkboxlabel.h +++ b/include/zwidget/widgets/checkboxlabel/checkboxlabel.h @@ -21,10 +21,10 @@ class CheckboxLabel : public Widget protected: void OnPaint(Canvas* canvas) override; - bool OnMouseDown(const Point& pos, int key) override; - bool OnMouseUp(const Point& pos, int key) override; + bool OnMouseDown(const Point& pos, InputKey key) override; + bool OnMouseUp(const Point& pos, InputKey key) override; void OnMouseLeave() override; - void OnKeyUp(EInputKey key) override; + void OnKeyUp(InputKey key) override; private: std::string text; diff --git a/include/zwidget/widgets/lineedit/lineedit.h b/include/zwidget/widgets/lineedit/lineedit.h index 526d9ee..02f3025 100644 --- a/include/zwidget/widgets/lineedit/lineedit.h +++ b/include/zwidget/widgets/lineedit/lineedit.h @@ -59,7 +59,7 @@ class LineEdit : public Widget void SetInputMask(const std::string& mask); void SetDecimalCharacter(const std::string& decimal_char); - std::function FuncIgnoreKeyDown; + std::function FuncIgnoreKeyDown; std::function FuncFilterKeyChar; std::function FuncBeforeEditChanged; std::function FuncAfterEditChanged; @@ -72,12 +72,12 @@ class LineEdit : public Widget void OnPaintFrame(Canvas* canvas) override; void OnPaint(Canvas* canvas) override; void OnMouseMove(const Point& pos) override; - bool OnMouseDown(const Point& pos, int key) override; - bool OnMouseDoubleclick(const Point& pos, int key) override; - bool OnMouseUp(const Point& pos, int key) override; + bool OnMouseDown(const Point& pos, InputKey key) override; + bool OnMouseDoubleclick(const Point& pos, InputKey key) override; + bool OnMouseUp(const Point& pos, InputKey key) override; void OnKeyChar(std::string chars) override; - void OnKeyDown(EInputKey key) override; - void OnKeyUp(EInputKey key) override; + void OnKeyDown(InputKey key) override; + void OnKeyUp(InputKey key) override; void OnGeometryChanged() override; void OnEnableChanged() override; void OnSetFocus() override; diff --git a/include/zwidget/widgets/listview/listview.h b/include/zwidget/widgets/listview/listview.h index 2b150ab..00d4c24 100644 --- a/include/zwidget/widgets/listview/listview.h +++ b/include/zwidget/widgets/listview/listview.h @@ -25,10 +25,10 @@ class ListView : public Widget protected: void OnPaint(Canvas* canvas) override; void OnPaintFrame(Canvas* canvas) override; - bool OnMouseDown(const Point& pos, int key) override; - bool OnMouseDoubleclick(const Point& pos, int key) override; - bool OnMouseWheel(const Point& pos, EInputKey key) override; - void OnKeyDown(EInputKey key) override; + bool OnMouseDown(const Point& pos, InputKey key) override; + bool OnMouseDoubleclick(const Point& pos, InputKey key) override; + bool OnMouseWheel(const Point& pos, InputKey key) override; + void OnKeyDown(InputKey key) override; void OnGeometryChanged() override; void OnScrollbarScroll(); diff --git a/include/zwidget/widgets/pushbutton/pushbutton.h b/include/zwidget/widgets/pushbutton/pushbutton.h index b9b6c96..36dee95 100644 --- a/include/zwidget/widgets/pushbutton/pushbutton.h +++ b/include/zwidget/widgets/pushbutton/pushbutton.h @@ -21,12 +21,12 @@ class PushButton : public Widget protected: void OnPaintFrame(Canvas* canvas) override; void OnPaint(Canvas* canvas) override; - bool OnMouseDown(const Point& pos, int key) override; - bool OnMouseUp(const Point& pos, int key) override; + bool OnMouseDown(const Point& pos, InputKey key) override; + bool OnMouseUp(const Point& pos, InputKey key) override; void OnMouseMove(const Point& pos) override; void OnMouseLeave() override; - void OnKeyDown(EInputKey key) override; - void OnKeyUp(EInputKey key) override; + void OnKeyDown(InputKey key) override; + void OnKeyUp(InputKey key) override; private: std::string text; diff --git a/include/zwidget/widgets/scrollbar/scrollbar.h b/include/zwidget/widgets/scrollbar/scrollbar.h index 5ec95c8..6e169b1 100644 --- a/include/zwidget/widgets/scrollbar/scrollbar.h +++ b/include/zwidget/widgets/scrollbar/scrollbar.h @@ -47,8 +47,8 @@ class Scrollbar : public Widget std::function FuncScrollEnd; protected: - bool OnMouseDown(const Point& pos, int key) override; - bool OnMouseUp(const Point& pos, int key) override; + bool OnMouseDown(const Point& pos, InputKey key) override; + bool OnMouseUp(const Point& pos, InputKey key) override; void OnMouseMove(const Point& pos) override; void OnMouseLeave() override; void OnPaint(Canvas* canvas) override; diff --git a/include/zwidget/widgets/tabwidget/tabwidget.h b/include/zwidget/widgets/tabwidget/tabwidget.h index bd3fc20..dec6965 100644 --- a/include/zwidget/widgets/tabwidget/tabwidget.h +++ b/include/zwidget/widgets/tabwidget/tabwidget.h @@ -94,8 +94,8 @@ class TabBarTab : public Widget protected: void OnPaintFrame(Canvas* canvas) override; void OnGeometryChanged() override; - bool OnMouseDown(const Point& pos, int key) override; - bool OnMouseUp(const Point& pos, int key) override; + bool OnMouseDown(const Point& pos, InputKey key) override; + bool OnMouseUp(const Point& pos, InputKey key) override; void OnMouseMove(const Point& pos) override; void OnMouseLeave() override; diff --git a/include/zwidget/widgets/textedit/textedit.h b/include/zwidget/widgets/textedit/textedit.h index ed80eec..3480a7f 100644 --- a/include/zwidget/widgets/textedit/textedit.h +++ b/include/zwidget/widgets/textedit/textedit.h @@ -56,12 +56,12 @@ class TextEdit : public Widget void OnPaintFrame(Canvas* canvas) override; void OnPaint(Canvas* canvas) override; void OnMouseMove(const Point& pos) override; - bool OnMouseDown(const Point& pos, int key) override; - bool OnMouseDoubleclick(const Point& pos, int key) override; - bool OnMouseUp(const Point& pos, int key) override; + bool OnMouseDown(const Point& pos, InputKey key) override; + bool OnMouseDoubleclick(const Point& pos, InputKey key) override; + bool OnMouseUp(const Point& pos, InputKey key) override; void OnKeyChar(std::string chars) override; - void OnKeyDown(EInputKey key) override; - void OnKeyUp(EInputKey key) override; + void OnKeyDown(InputKey key) override; + void OnKeyUp(InputKey key) override; void OnGeometryChanged() override; void OnEnableChanged() override; void OnSetFocus() override; diff --git a/include/zwidget/window/window.h b/include/zwidget/window/window.h index 0539f77..2c9a413 100644 --- a/include/zwidget/window/window.h +++ b/include/zwidget/window/window.h @@ -3,6 +3,7 @@ #include #include #include +#include #include "../core/rect.h" class Engine; @@ -24,91 +25,72 @@ enum class StandardCursor wait }; -enum EInputKey +enum class InputKey : uint32_t { - IK_None, IK_LeftMouse, IK_RightMouse, IK_Cancel, - IK_MiddleMouse, IK_Unknown05, IK_Unknown06, IK_Unknown07, - IK_Backspace, IK_Tab, IK_Unknown0A, IK_Unknown0B, - IK_Unknown0C, IK_Enter, IK_Unknown0E, IK_Unknown0F, - IK_Shift, IK_Ctrl, IK_Alt, IK_Pause, - IK_CapsLock, IK_Unknown15, IK_Unknown16, IK_Unknown17, - IK_Unknown18, IK_Unknown19, IK_Unknown1A, IK_Escape, - IK_Unknown1C, IK_Unknown1D, IK_Unknown1E, IK_Unknown1F, - IK_Space, IK_PageUp, IK_PageDown, IK_End, - IK_Home, IK_Left, IK_Up, IK_Right, - IK_Down, IK_Select, IK_Print, IK_Execute, - IK_PrintScrn, IK_Insert, IK_Delete, IK_Help, - IK_0, IK_1, IK_2, IK_3, - IK_4, IK_5, IK_6, IK_7, - IK_8, IK_9, IK_Unknown3A, IK_Unknown3B, - IK_Unknown3C, IK_Unknown3D, IK_Unknown3E, IK_Unknown3F, - IK_Unknown40, IK_A, IK_B, IK_C, - IK_D, IK_E, IK_F, IK_G, - IK_H, IK_I, IK_J, IK_K, - IK_L, IK_M, IK_N, IK_O, - IK_P, IK_Q, IK_R, IK_S, - IK_T, IK_U, IK_V, IK_W, - IK_X, IK_Y, IK_Z, IK_Unknown5B, - IK_Unknown5C, IK_Unknown5D, IK_Unknown5E, IK_Unknown5F, - IK_NumPad0, IK_NumPad1, IK_NumPad2, IK_NumPad3, - IK_NumPad4, IK_NumPad5, IK_NumPad6, IK_NumPad7, - IK_NumPad8, IK_NumPad9, IK_GreyStar, IK_GreyPlus, - IK_Separator, IK_GreyMinus, IK_NumPadPeriod, IK_GreySlash, - IK_F1, IK_F2, IK_F3, IK_F4, - IK_F5, IK_F6, IK_F7, IK_F8, - IK_F9, IK_F10, IK_F11, IK_F12, - IK_F13, IK_F14, IK_F15, IK_F16, - IK_F17, IK_F18, IK_F19, IK_F20, - IK_F21, IK_F22, IK_F23, IK_F24, - IK_Unknown88, IK_Unknown89, IK_Unknown8A, IK_Unknown8B, - IK_Unknown8C, IK_Unknown8D, IK_Unknown8E, IK_Unknown8F, - IK_NumLock, IK_ScrollLock, IK_Unknown92, IK_Unknown93, - IK_Unknown94, IK_Unknown95, IK_Unknown96, IK_Unknown97, - IK_Unknown98, IK_Unknown99, IK_Unknown9A, IK_Unknown9B, - IK_Unknown9C, IK_Unknown9D, IK_Unknown9E, IK_Unknown9F, - IK_LShift, IK_RShift, IK_LControl, IK_RControl, - IK_UnknownA4, IK_UnknownA5, IK_UnknownA6, IK_UnknownA7, - IK_UnknownA8, IK_UnknownA9, IK_UnknownAA, IK_UnknownAB, - IK_UnknownAC, IK_UnknownAD, IK_UnknownAE, IK_UnknownAF, - IK_UnknownB0, IK_UnknownB1, IK_UnknownB2, IK_UnknownB3, - IK_UnknownB4, IK_UnknownB5, IK_UnknownB6, IK_UnknownB7, - IK_UnknownB8, IK_UnknownB9, IK_Semicolon, IK_Equals, - IK_Comma, IK_Minus, IK_Period, IK_Slash, - IK_Tilde, IK_UnknownC1, IK_UnknownC2, IK_UnknownC3, - IK_UnknownC4, IK_UnknownC5, IK_UnknownC6, IK_UnknownC7, - IK_Joy1, IK_Joy2, IK_Joy3, IK_Joy4, - IK_Joy5, IK_Joy6, IK_Joy7, IK_Joy8, - IK_Joy9, IK_Joy10, IK_Joy11, IK_Joy12, - IK_Joy13, IK_Joy14, IK_Joy15, IK_Joy16, - IK_UnknownD8, IK_UnknownD9, IK_UnknownDA, IK_LeftBracket, - IK_Backslash, IK_RightBracket, IK_SingleQuote, IK_UnknownDF, - IK_JoyX, IK_JoyY, IK_JoyZ, IK_JoyR, - IK_MouseX, IK_MouseY, IK_MouseZ, IK_MouseW, - IK_JoyU, IK_JoyV, IK_UnknownEA, IK_UnknownEB, - IK_MouseWheelUp, IK_MouseWheelDown, IK_Unknown10E, IK_Unknown10F, - IK_JoyPovUp, IK_JoyPovDown, IK_JoyPovLeft, IK_JoyPovRight, - IK_UnknownF4, IK_UnknownF5, IK_Attn, IK_CrSel, - IK_ExSel, IK_ErEof, IK_Play, IK_Zoom, - IK_NoName, IK_PA1, IK_OEMClear -}; - -enum EInputType -{ - IST_None, - IST_Press, - IST_Hold, - IST_Release, - IST_Axis -}; - -class KeyEvent -{ -public: - EInputKey Key; - bool Ctrl = false; - bool Alt = false; - bool Shift = false; - Point MousePos = Point(0.0, 0.0); + None, LeftMouse, RightMouse, Cancel, + MiddleMouse, Unknown05, Unknown06, Unknown07, + Backspace, Tab, Unknown0A, Unknown0B, + Unknown0C, Enter, Unknown0E, Unknown0F, + Shift, Ctrl, Alt, Pause, + CapsLock, Unknown15, Unknown16, Unknown17, + Unknown18, Unknown19, Unknown1A, Escape, + Unknown1C, Unknown1D, Unknown1E, Unknown1F, + Space, PageUp, PageDown, End, + Home, Left, Up, Right, + Down, Select, Print, Execute, + PrintScrn, Insert, Delete, Help, + _0, _1, _2, _3, + _4, _5, _6, _7, + _8, _9, Unknown3A, Unknown3B, + Unknown3C, Unknown3D, Unknown3E, Unknown3F, + Unknown40, A, B, C, + D, E, F, G, + H, I, J, K, + L, M, N, O, + P, Q, R, S, + T, U, V, W, + X, Y, Z, Unknown5B, + Unknown5C, Unknown5D, Unknown5E, Unknown5F, + NumPad0, NumPad1, NumPad2, NumPad3, + NumPad4, NumPad5, NumPad6, NumPad7, + NumPad8, NumPad9, GreyStar, GreyPlus, + Separator, GreyMinus, NumPadPeriod, GreySlash, + F1, F2, F3, F4, + F5, F6, F7, F8, + F9, F10, F11, F12, + F13, F14, F15, F16, + F17, F18, F19, F20, + F21, F22, F23, F24, + Unknown88, Unknown89, Unknown8A, Unknown8B, + Unknown8C, Unknown8D, Unknown8E, Unknown8F, + NumLock, ScrollLock, Unknown92, Unknown93, + Unknown94, Unknown95, Unknown96, Unknown97, + Unknown98, Unknown99, Unknown9A, Unknown9B, + Unknown9C, Unknown9D, Unknown9E, Unknown9F, + LShift, RShift, LControl, RControl, + UnknownA4, UnknownA5, UnknownA6, UnknownA7, + UnknownA8, UnknownA9, UnknownAA, UnknownAB, + UnknownAC, UnknownAD, UnknownAE, UnknownAF, + UnknownB0, UnknownB1, UnknownB2, UnknownB3, + UnknownB4, UnknownB5, UnknownB6, UnknownB7, + UnknownB8, UnknownB9, Semicolon, Equals, + Comma, Minus, Period, Slash, + Tilde, UnknownC1, UnknownC2, UnknownC3, + UnknownC4, UnknownC5, UnknownC6, UnknownC7, + Joy1, Joy2, Joy3, Joy4, + Joy5, Joy6, Joy7, Joy8, + Joy9, Joy10, Joy11, Joy12, + Joy13, Joy14, Joy15, Joy16, + UnknownD8, UnknownD9, UnknownDA, LeftBracket, + Backslash, RightBracket, SingleQuote, UnknownDF, + JoyX, JoyY, JoyZ, JoyR, + MouseX, MouseY, MouseZ, MouseW, + JoyU, JoyV, UnknownEA, UnknownEB, + MouseWheelUp, MouseWheelDown, Unknown10E, Unknown10F, + JoyPovUp, JoyPovDown, JoyPovLeft, JoyPovRight, + UnknownF4, UnknownF5, Attn, CrSel, + ExSel, ErEof, Play, Zoom, + NoName, PA1, OEMClear }; class DisplayWindow; @@ -118,14 +100,14 @@ class DisplayWindowHost public: virtual void OnWindowPaint() = 0; virtual void OnWindowMouseMove(const Point& pos) = 0; - virtual void OnWindowMouseDown(const Point& pos, EInputKey key) = 0; - virtual void OnWindowMouseDoubleclick(const Point& pos, EInputKey key) = 0; - virtual void OnWindowMouseUp(const Point& pos, EInputKey key) = 0; - virtual void OnWindowMouseWheel(const Point& pos, EInputKey key) = 0; + virtual void OnWindowMouseDown(const Point& pos, InputKey key) = 0; + virtual void OnWindowMouseDoubleclick(const Point& pos, InputKey key) = 0; + virtual void OnWindowMouseUp(const Point& pos, InputKey key) = 0; + virtual void OnWindowMouseWheel(const Point& pos, InputKey key) = 0; virtual void OnWindowRawMouseMove(int dx, int dy) = 0; virtual void OnWindowKeyChar(std::string chars) = 0; - virtual void OnWindowKeyDown(EInputKey key) = 0; - virtual void OnWindowKeyUp(EInputKey key) = 0; + virtual void OnWindowKeyDown(InputKey key) = 0; + virtual void OnWindowKeyUp(InputKey key) = 0; virtual void OnWindowGeometryChanged() = 0; virtual void OnWindowClose() = 0; virtual void OnWindowActivated() = 0; @@ -165,7 +147,7 @@ class DisplayWindow virtual void CaptureMouse() = 0; virtual void ReleaseMouseCapture() = 0; virtual void Update() = 0; - virtual bool GetKeyState(EInputKey key) = 0; + virtual bool GetKeyState(InputKey key) = 0; virtual void SetCursor(StandardCursor cursor) = 0; diff --git a/src/core/canvas.cpp b/src/core/canvas.cpp index d9f14ce..8ed79ad 100644 --- a/src/core/canvas.cpp +++ b/src/core/canvas.cpp @@ -489,11 +489,11 @@ void BitmapCanvas::drawLineUnclipped(const Point& p0, const Point& p1, const Col { if (p0.x == p1.x) { - drawTile(whiteTexture.get(), (float)((p0.x - 0.5) * uiscale), (float)(p0.y * uiscale), (float)((p1.x + 0.5) * uiscale), (float)(p1.y * uiscale), 0.0f, 0.0f, 1.0f, 1.0f, color); + drawTile(whiteTexture.get(), (float)((p0.x - 0.5) * uiscale), (float)(p0.y * uiscale), (float)uiscale, (float)((p1.y - p0.y) * uiscale), 0.0f, 0.0f, 1.0f, 1.0f, color); } else if (p0.y == p1.y) { - drawTile(whiteTexture.get(), (float)(p0.x * uiscale), (float)((p0.y - 0.5) * uiscale), (float)(p1.x * uiscale), (float)((p1.y + 0.5) * uiscale), 0.0f, 0.0f, 1.0f, 1.0f, color); + drawTile(whiteTexture.get(), (float)(p0.x * uiscale), (float)((p0.y - 0.5) * uiscale), (float)((p1.x - p0.x) * uiscale), (float)uiscale, 0.0f, 0.0f, 1.0f, 1.0f, color); } else { diff --git a/src/core/widget.cpp b/src/core/widget.cpp index 7ddc1ca..1d2f61a 100644 --- a/src/core/widget.cpp +++ b/src/core/widget.cpp @@ -316,7 +316,7 @@ void Widget::Paint(Canvas* canvas) canvas->popClip(); } -bool Widget::GetKeyState(EInputKey key) +bool Widget::GetKeyState(InputKey key) { Widget* window = Window(); return window ? window->DispWindow->GetKeyState(key) : false; @@ -568,7 +568,7 @@ void Widget::OnWindowMouseMove(const Point& pos) } } -void Widget::OnWindowMouseDown(const Point& pos, EInputKey key) +void Widget::OnWindowMouseDown(const Point& pos, InputKey key) { if (CaptureWidget) { @@ -589,7 +589,7 @@ void Widget::OnWindowMouseDown(const Point& pos, EInputKey key) } } -void Widget::OnWindowMouseDoubleclick(const Point& pos, EInputKey key) +void Widget::OnWindowMouseDoubleclick(const Point& pos, InputKey key) { if (CaptureWidget) { @@ -610,7 +610,7 @@ void Widget::OnWindowMouseDoubleclick(const Point& pos, EInputKey key) } } -void Widget::OnWindowMouseUp(const Point& pos, EInputKey key) +void Widget::OnWindowMouseUp(const Point& pos, InputKey key) { if (CaptureWidget) { @@ -631,7 +631,7 @@ void Widget::OnWindowMouseUp(const Point& pos, EInputKey key) } } -void Widget::OnWindowMouseWheel(const Point& pos, EInputKey key) +void Widget::OnWindowMouseWheel(const Point& pos, InputKey key) { if (CaptureWidget) { @@ -670,13 +670,13 @@ void Widget::OnWindowKeyChar(std::string chars) FocusWidget->OnKeyChar(chars); } -void Widget::OnWindowKeyDown(EInputKey key) +void Widget::OnWindowKeyDown(InputKey key) { if (FocusWidget) FocusWidget->OnKeyDown(key); } -void Widget::OnWindowKeyUp(EInputKey key) +void Widget::OnWindowKeyUp(InputKey key) { if (FocusWidget) FocusWidget->OnKeyUp(key); diff --git a/src/widgets/checkboxlabel/checkboxlabel.cpp b/src/widgets/checkboxlabel/checkboxlabel.cpp index 7736101..1738624 100644 --- a/src/widgets/checkboxlabel/checkboxlabel.cpp +++ b/src/widgets/checkboxlabel/checkboxlabel.cpp @@ -55,14 +55,14 @@ void CheckboxLabel::OnPaint(Canvas* canvas) canvas->drawText(Point(14.0, GetHeight() - 5.0), Colorf::fromRgba8(255, 255, 255), text); } -bool CheckboxLabel::OnMouseDown(const Point& pos, int key) +bool CheckboxLabel::OnMouseDown(const Point& pos, InputKey key) { mouseDownActive = true; SetFocus(); return true; } -bool CheckboxLabel::OnMouseUp(const Point& pos, int key) +bool CheckboxLabel::OnMouseUp(const Point& pos, InputKey key) { if (mouseDownActive) { @@ -77,9 +77,9 @@ void CheckboxLabel::OnMouseLeave() mouseDownActive = false; } -void CheckboxLabel::OnKeyUp(EInputKey key) +void CheckboxLabel::OnKeyUp(InputKey key) { - if (key == IK_Space) + if (key == InputKey::Space) Toggle(); } diff --git a/src/widgets/lineedit/lineedit.cpp b/src/widgets/lineedit/lineedit.cpp index 70de526..8b7695b 100644 --- a/src/widgets/lineedit/lineedit.cpp +++ b/src/widgets/lineedit/lineedit.cpp @@ -301,9 +301,9 @@ void LineEdit::OnMouseMove(const Point& pos) } } -bool LineEdit::OnMouseDown(const Point& pos, int key) +bool LineEdit::OnMouseDown(const Point& pos, InputKey key) { - if (key == IK_LeftMouse) + if (key == InputKey::LeftMouse) { if (HasFocus()) { @@ -321,14 +321,14 @@ bool LineEdit::OnMouseDown(const Point& pos, int key) return true; } -bool LineEdit::OnMouseDoubleclick(const Point& pos, int key) +bool LineEdit::OnMouseDoubleclick(const Point& pos, InputKey key) { return true; } -bool LineEdit::OnMouseUp(const Point& pos, int key) +bool LineEdit::OnMouseUp(const Point& pos, InputKey key) { - if (mouse_selecting && key == IK_LeftMouse) + if (mouse_selecting && key == InputKey::LeftMouse) { if (ignore_mouse_events) // This prevents text selection from changing from what was set when focus was gained. { @@ -412,12 +412,12 @@ void LineEdit::OnKeyChar(std::string chars) } } -void LineEdit::OnKeyDown(EInputKey key) +void LineEdit::OnKeyDown(InputKey key) { if (FuncIgnoreKeyDown && FuncIgnoreKeyDown(key)) return; - if (key == IK_Enter) + if (key == InputKey::Enter) { if (FuncEnterPressed) FuncEnterPressed(); @@ -430,12 +430,12 @@ void LineEdit::OnKeyDown(EInputKey key) timer->Start(500); // don't blink cursor when moving or typing. } - if (key == IK_Enter || key == IK_Escape || key == IK_Tab) + if (key == InputKey::Enter || key == InputKey::Escape || key == InputKey::Tab) { // Do not consume these. return; } - else if (key == IK_A && GetKeyState(IK_Ctrl)) + else if (key == InputKey::A && GetKeyState(InputKey::Ctrl)) { // select all SetTextSelection(0, (int)text.size()); @@ -443,7 +443,7 @@ void LineEdit::OnKeyDown(EInputKey key) UpdateTextClipping(); Update(); } - else if (key == IK_C && GetKeyState(IK_Ctrl)) + else if (key == InputKey::C && GetKeyState(InputKey::Ctrl)) { if (!password_mode) // Do not allow copying the password to clipboard { @@ -456,54 +456,54 @@ void LineEdit::OnKeyDown(EInputKey key) // Do not consume messages on read only component (only allow CTRL-A and CTRL-C) return; } - else if (key == IK_Left) + else if (key == InputKey::Left) { - Move(-1, GetKeyState(IK_Ctrl), GetKeyState(IK_Shift)); + Move(-1, GetKeyState(InputKey::Ctrl), GetKeyState(InputKey::Shift)); } - else if (key == IK_Right) + else if (key == InputKey::Right) { - Move(1, GetKeyState(IK_Ctrl), GetKeyState(IK_Shift)); + Move(1, GetKeyState(InputKey::Ctrl), GetKeyState(InputKey::Shift)); } - else if (key == IK_Backspace) + else if (key == InputKey::Backspace) { Backspace(); UpdateTextClipping(); } - else if (key == IK_Delete) + else if (key == InputKey::Delete) { Del(); UpdateTextClipping(); } - else if (key == IK_Home) + else if (key == InputKey::Home) { SetSelectionStart(cursor_pos); cursor_pos = 0; - if (GetKeyState(IK_Shift)) + if (GetKeyState(InputKey::Shift)) SetSelectionLength(-selection_start); else SetTextSelection(0, 0); UpdateTextClipping(); Update(); } - else if (key == IK_End) + else if (key == InputKey::End) { SetSelectionStart(cursor_pos); cursor_pos = (int)text.size(); - if (GetKeyState(IK_Shift)) + if (GetKeyState(InputKey::Shift)) SetSelectionLength((int)text.size() - selection_start); else SetTextSelection(0, 0); UpdateTextClipping(); Update(); } - else if (key == IK_X && GetKeyState(IK_Ctrl)) + else if (key == InputKey::X && GetKeyState(InputKey::Ctrl)) { std::string str = GetSelection(); DeleteSelectedText(); SetClipboardText(str); UpdateTextClipping(); } - else if (key == IK_V && GetKeyState(IK_Ctrl)) + else if (key == InputKey::V && GetKeyState(InputKey::Ctrl)) { std::string str = GetClipboardText(); std::string::const_iterator end_str = std::remove(str.begin(), str.end(), '\n'); @@ -574,7 +574,7 @@ void LineEdit::OnKeyDown(EInputKey key) UpdateTextClipping(); } - else if (GetKeyState(IK_Ctrl) && key == IK_Z) + else if (GetKeyState(InputKey::Ctrl) && key == InputKey::Z) { if (!readonly) { @@ -583,7 +583,7 @@ void LineEdit::OnKeyDown(EInputKey key) SetText(tmp); } } - else if (key == IK_Shift) + else if (key == InputKey::Shift) { if (selection_start == -1) SetTextSelection(cursor_pos, 0); @@ -593,7 +593,7 @@ void LineEdit::OnKeyDown(EInputKey key) FuncAfterEditChanged(); } -void LineEdit::OnKeyUp(EInputKey key) +void LineEdit::OnKeyUp(InputKey key) { } diff --git a/src/widgets/listview/listview.cpp b/src/widgets/listview/listview.cpp index 717f958..f1c585b 100644 --- a/src/widgets/listview/listview.cpp +++ b/src/widgets/listview/listview.cpp @@ -96,11 +96,11 @@ void ListView::OnPaintFrame(Canvas* canvas) canvas->fillRect(Rect::xywh(w - 1.0, 0.0, 1.0, h - 0.0), bordercolor); } -bool ListView::OnMouseDown(const Point& pos, int key) +bool ListView::OnMouseDown(const Point& pos, InputKey key) { SetFocus(); - if (key == IK_LeftMouse) + if (key == InputKey::LeftMouse) { int index = (int)((pos.y - 5.0 + scrollbar->GetPosition()) / 20.0); if (index >= 0 && (size_t)index < items.size()) @@ -112,31 +112,31 @@ bool ListView::OnMouseDown(const Point& pos, int key) return true; } -bool ListView::OnMouseDoubleclick(const Point& pos, int key) +bool ListView::OnMouseDoubleclick(const Point& pos, InputKey key) { - if (key == IK_LeftMouse) + if (key == InputKey::LeftMouse) { Activate(); } return true; } -bool ListView::OnMouseWheel(const Point& pos, EInputKey key) +bool ListView::OnMouseWheel(const Point& pos, InputKey key) { - if (key == IK_MouseWheelUp) + if (key == InputKey::MouseWheelUp) { scrollbar->SetPosition(std::max(scrollbar->GetPosition() - 20.0, 0.0)); } - else if (key == IK_MouseWheelDown) + else if (key == InputKey::MouseWheelDown) { scrollbar->SetPosition(std::min(scrollbar->GetPosition() + 20.0, scrollbar->GetMax())); } return true; } -void ListView::OnKeyDown(EInputKey key) +void ListView::OnKeyDown(InputKey key) { - if (key == IK_Down) + if (key == InputKey::Down) { if (selectedItem + 1 < (int)items.size()) { @@ -144,7 +144,7 @@ void ListView::OnKeyDown(EInputKey key) } ScrollToItem(selectedItem); } - else if (key == IK_Up) + else if (key == InputKey::Up) { if (selectedItem > 0) { @@ -152,7 +152,7 @@ void ListView::OnKeyDown(EInputKey key) } ScrollToItem(selectedItem); } - else if (key == IK_Enter) + else if (key == InputKey::Enter) { Activate(); } diff --git a/src/widgets/pushbutton/pushbutton.cpp b/src/widgets/pushbutton/pushbutton.cpp index d838fe4..16b255d 100644 --- a/src/widgets/pushbutton/pushbutton.cpp +++ b/src/widgets/pushbutton/pushbutton.cpp @@ -57,7 +57,7 @@ void PushButton::OnMouseMove(const Point& pos) } } -bool PushButton::OnMouseDown(const Point& pos, int key) +bool PushButton::OnMouseDown(const Point& pos, InputKey key) { SetFocus(); buttonDown = true; @@ -65,7 +65,7 @@ bool PushButton::OnMouseDown(const Point& pos, int key) return true; } -bool PushButton::OnMouseUp(const Point& pos, int key) +bool PushButton::OnMouseUp(const Point& pos, InputKey key) { if (buttonDown) { @@ -84,18 +84,18 @@ void PushButton::OnMouseLeave() Update(); } -void PushButton::OnKeyDown(EInputKey key) +void PushButton::OnKeyDown(InputKey key) { - if (key == IK_Space || key == IK_Enter) + if (key == InputKey::Space || key == InputKey::Enter) { buttonDown = true; Update(); } } -void PushButton::OnKeyUp(EInputKey key) +void PushButton::OnKeyUp(InputKey key) { - if (key == IK_Space || key == IK_Enter) + if (key == InputKey::Space || key == InputKey::Enter) { buttonDown = false; hot = false; diff --git a/src/widgets/scrollbar/scrollbar.cpp b/src/widgets/scrollbar/scrollbar.cpp index 489a663..7a3810a 100644 --- a/src/widgets/scrollbar/scrollbar.cpp +++ b/src/widgets/scrollbar/scrollbar.cpp @@ -169,7 +169,7 @@ void Scrollbar::OnMouseMove(const Point& pos) Update(); } -bool Scrollbar::OnMouseDown(const Point& pos, int key) +bool Scrollbar::OnMouseDown(const Point& pos, InputKey key) { mouse_drag_start_pos = pos; @@ -257,7 +257,7 @@ bool Scrollbar::OnMouseDown(const Point& pos, int key) return true; } -bool Scrollbar::OnMouseUp(const Point& pos, int key) +bool Scrollbar::OnMouseUp(const Point& pos, InputKey key) { if (mouse_down_mode == mouse_down_thumb_drag) { diff --git a/src/widgets/tabwidget/tabwidget.cpp b/src/widgets/tabwidget/tabwidget.cpp index cbac877..0cf6f32 100644 --- a/src/widgets/tabwidget/tabwidget.cpp +++ b/src/widgets/tabwidget/tabwidget.cpp @@ -85,7 +85,7 @@ int TabWidget::GetPageIndex(Widget* pageWidget) const for (size_t i = 0; i < Pages.size(); i++) { if (Pages[i] == pageWidget) - return i; + return (int)i; } return -1; } @@ -129,7 +129,7 @@ int TabBar::AddTab(const std::shared_ptr& icon, const std::string& label) tab->SetIcon(icon); tab->SetText(label); tab->OnClick = [=]() { OnTabClicked(tab); }; - int pageIndex = Tabs.size(); + int pageIndex = (int)Tabs.size(); Tabs.push_back(tab); if (CurrentIndex == -1) SetCurrentIndex(pageIndex); @@ -182,7 +182,7 @@ int TabBar::GetTabIndex(TabBarTab* tab) for (size_t i = 0; i < Tabs.size(); i++) { if (Tabs[i] == tab) - return i; + return (int)i; } return -1; } @@ -307,14 +307,14 @@ void TabBarTab::OnMouseMove(const Point& pos) } } -bool TabBarTab::OnMouseDown(const Point& pos, int key) +bool TabBarTab::OnMouseDown(const Point& pos, InputKey key) { if (OnClick) OnClick(); return true; } -bool TabBarTab::OnMouseUp(const Point& pos, int key) +bool TabBarTab::OnMouseUp(const Point& pos, InputKey key) { return true; } diff --git a/src/widgets/textedit/textedit.cpp b/src/widgets/textedit/textedit.cpp index dca840a..19dbbe7 100644 --- a/src/widgets/textedit/textedit.cpp +++ b/src/widgets/textedit/textedit.cpp @@ -286,9 +286,9 @@ void TextEdit::OnMouseMove(const Point& pos) } } -bool TextEdit::OnMouseDown(const Point& pos, int key) +bool TextEdit::OnMouseDown(const Point& pos, InputKey key) { - if (key == IK_LeftMouse) + if (key == InputKey::LeftMouse) { CaptureMouse(); mouse_selecting = true; @@ -301,14 +301,14 @@ bool TextEdit::OnMouseDown(const Point& pos, int key) return true; } -bool TextEdit::OnMouseDoubleclick(const Point& pos, int key) +bool TextEdit::OnMouseDoubleclick(const Point& pos, InputKey key) { return true; } -bool TextEdit::OnMouseUp(const Point& pos, int key) +bool TextEdit::OnMouseUp(const Point& pos, InputKey key) { - if (mouse_selecting && key == IK_LeftMouse) + if (mouse_selecting && key == InputKey::LeftMouse) { if (ignore_mouse_events) // This prevents text selection from changing from what was set when focus was gained. { @@ -360,9 +360,9 @@ void TextEdit::OnKeyChar(std::string chars) } } -void TextEdit::OnKeyDown(EInputKey key) +void TextEdit::OnKeyDown(InputKey key) { - if (!readonly && key == IK_Enter) + if (!readonly && key == InputKey::Enter) { if (FuncEnterPressed) { @@ -383,17 +383,17 @@ void TextEdit::OnKeyDown(EInputKey key) timer->Start(500); // don't blink cursor when moving or typing. } - if (key == IK_Enter || key == IK_Escape || key == IK_Tab) + if (key == InputKey::Enter || key == InputKey::Escape || key == InputKey::Tab) { // Do not consume these. return; } - else if (key == IK_A && GetKeyState(IK_Ctrl)) + else if (key == InputKey::A && GetKeyState(InputKey::Ctrl)) { // select all SelectAll(); } - else if (key == IK_C && GetKeyState(IK_Ctrl)) + else if (key == InputKey::C && GetKeyState(InputKey::Ctrl)) { std::string str = GetSelection(); SetClipboardText(str); @@ -403,9 +403,9 @@ void TextEdit::OnKeyDown(EInputKey key) // Do not consume messages on read only component (only allow CTRL-A and CTRL-C) return; } - else if (key == IK_Up) + else if (key == InputKey::Up) { - if (GetKeyState(IK_Shift) && selection_length == 0) + if (GetKeyState(InputKey::Shift) && selection_length == 0) selection_start = cursor_pos; if (cursor_pos.y > 0) @@ -414,7 +414,7 @@ void TextEdit::OnKeyDown(EInputKey key) cursor_pos.x = std::min(lines[cursor_pos.y].text.size(), (size_t)cursor_pos.x); } - if (GetKeyState(IK_Shift)) + if (GetKeyState(InputKey::Shift)) { selection_length = ToOffset(cursor_pos) - ToOffset(selection_start); } @@ -428,9 +428,9 @@ void TextEdit::OnKeyDown(EInputKey key) Update(); undo_info.first_text_insert = true; } - else if (key == IK_Down) + else if (key == InputKey::Down) { - if (GetKeyState(IK_Shift) && selection_length == 0) + if (GetKeyState(InputKey::Shift) && selection_length == 0) selection_start = cursor_pos; if (cursor_pos.y < lines.size() - 1) @@ -439,7 +439,7 @@ void TextEdit::OnKeyDown(EInputKey key) cursor_pos.x = std::min(lines[cursor_pos.y].text.size(), (size_t)cursor_pos.x); } - if (GetKeyState(IK_Shift)) + if (GetKeyState(InputKey::Shift)) { selection_length = ToOffset(cursor_pos) - ToOffset(selection_start); } @@ -454,55 +454,55 @@ void TextEdit::OnKeyDown(EInputKey key) Update(); undo_info.first_text_insert = true; } - else if (key == IK_Left) + else if (key == InputKey::Left) { - Move(-1, GetKeyState(IK_Shift), GetKeyState(IK_Ctrl)); + Move(-1, GetKeyState(InputKey::Shift), GetKeyState(InputKey::Ctrl)); } - else if (key == IK_Right) + else if (key == InputKey::Right) { - Move(1, GetKeyState(IK_Shift), GetKeyState(IK_Ctrl)); + Move(1, GetKeyState(InputKey::Shift), GetKeyState(InputKey::Ctrl)); } - else if (key == IK_Backspace) + else if (key == InputKey::Backspace) { Backspace(); } - else if (key == IK_Delete) + else if (key == InputKey::Delete) { Del(); } - else if (key == IK_Home) + else if (key == InputKey::Home) { - if (GetKeyState(IK_Ctrl)) + if (GetKeyState(InputKey::Ctrl)) cursor_pos = ivec2(0, 0); else cursor_pos.x = 0; - if (GetKeyState(IK_Shift)) + if (GetKeyState(InputKey::Shift)) selection_length = ToOffset(cursor_pos) - ToOffset(selection_start); else ClearSelection(); Update(); MoveVerticalScroll(); } - else if (key == IK_End) + else if (key == InputKey::End) { - if (GetKeyState(IK_Ctrl)) + if (GetKeyState(InputKey::Ctrl)) cursor_pos = ivec2(lines.back().text.length(), lines.size() - 1); else cursor_pos.x = lines[cursor_pos.y].text.size(); - if (GetKeyState(IK_Shift)) + if (GetKeyState(InputKey::Shift)) selection_length = ToOffset(cursor_pos) - ToOffset(selection_start); else ClearSelection(); Update(); } - else if (key == IK_X && GetKeyState(IK_Ctrl)) + else if (key == InputKey::X && GetKeyState(InputKey::Ctrl)) { std::string str = GetSelection(); DeleteSelectedText(); SetClipboardText(str); } - else if (key == IK_V && GetKeyState(IK_Ctrl)) + else if (key == InputKey::V && GetKeyState(InputKey::Ctrl)) { std::string str = GetClipboardText(); std::string::const_iterator end_str = std::remove(str.begin(), str.end(), '\r'); @@ -524,7 +524,7 @@ void TextEdit::OnKeyDown(EInputKey key) } MoveVerticalScroll(); } - else if (GetKeyState(IK_Ctrl) && key == IK_Z) + else if (GetKeyState(InputKey::Ctrl) && key == InputKey::Z) { if (!readonly) { @@ -533,7 +533,7 @@ void TextEdit::OnKeyDown(EInputKey key) SetText(tmp); } } - else if (key == IK_Shift) + else if (key == InputKey::Shift) { if (selection_length == 0) selection_start = cursor_pos; @@ -543,7 +543,7 @@ void TextEdit::OnKeyDown(EInputKey key) FuncAfterEditChanged(); } -void TextEdit::OnKeyUp(EInputKey key) +void TextEdit::OnKeyUp(InputKey key) { } @@ -962,7 +962,7 @@ void TextEdit::LayoutLines(Canvas* canvas) } Point draw_pos; - for (size_t i = vert_scrollbar->GetPosition(); i < lines.size(); i++) + for (size_t i = (size_t)vert_scrollbar->GetPosition(); i < lines.size(); i++) { Line& line = lines[i]; if (line.invalidated) @@ -1021,7 +1021,7 @@ void TextEdit::OnPaintFrame(Canvas* canvas) void TextEdit::OnPaint(Canvas* canvas) { LayoutLines(canvas); - for (size_t i = vert_scrollbar->GetPosition(); i < lines.size(); i++) + for (size_t i = (size_t)vert_scrollbar->GetPosition(); i < lines.size(); i++) lines[i].layout.DrawLayout(canvas); } diff --git a/src/window/sdl2/sdl2displaywindow.cpp b/src/window/sdl2/sdl2displaywindow.cpp index 2cb52e2..98988cd 100644 --- a/src/window/sdl2/sdl2displaywindow.cpp +++ b/src/window/sdl2/sdl2displaywindow.cpp @@ -152,7 +152,7 @@ void SDL2DisplayWindow::Update() SDL_PushEvent(&event); } -bool SDL2DisplayWindow::GetKeyState(EInputKey key) +bool SDL2DisplayWindow::GetKeyState(InputKey key) { int numkeys = 0; const Uint8* state = SDL_GetKeyboardState(&numkeys); @@ -401,23 +401,23 @@ void SDL2DisplayWindow::OnKeyDown(const SDL_KeyboardEvent& event) WindowHost->OnWindowKeyDown(ScancodeToInputKey(event.keysym.scancode)); } -EInputKey SDL2DisplayWindow::GetMouseButtonKey(const SDL_MouseButtonEvent& event) +InputKey SDL2DisplayWindow::GetMouseButtonKey(const SDL_MouseButtonEvent& event) { switch (event.button) { - case SDL_BUTTON_LEFT: return IK_LeftMouse; - case SDL_BUTTON_MIDDLE: return IK_MiddleMouse; - case SDL_BUTTON_RIGHT: return IK_RightMouse; - // case SDL_BUTTON_X1: return IK_XButton1; - // case SDL_BUTTON_X2: return IK_XButton2; - default: return IK_None; + case SDL_BUTTON_LEFT: return InputKey::LeftMouse; + case SDL_BUTTON_MIDDLE: return InputKey::MiddleMouse; + case SDL_BUTTON_RIGHT: return InputKey::RightMouse; + // case SDL_BUTTON_X1: return InputKey::XButton1; + // case SDL_BUTTON_X2: return InputKey::XButton2; + default: return InputKey::None; } } void SDL2DisplayWindow::OnMouseButtonUp(const SDL_MouseButtonEvent& event) { - EInputKey key = GetMouseButtonKey(event); - if (key != IK_None) + InputKey key = GetMouseButtonKey(event); + if (key != InputKey::None) { WindowHost->OnWindowMouseUp(GetMousePos(event), key); } @@ -425,8 +425,8 @@ void SDL2DisplayWindow::OnMouseButtonUp(const SDL_MouseButtonEvent& event) void SDL2DisplayWindow::OnMouseButtonDown(const SDL_MouseButtonEvent& event) { - EInputKey key = GetMouseButtonKey(event); - if (key != IK_None) + InputKey key = GetMouseButtonKey(event); + if (key != InputKey::None) { WindowHost->OnWindowMouseDown(GetMousePos(event), key); } @@ -434,8 +434,8 @@ void SDL2DisplayWindow::OnMouseButtonDown(const SDL_MouseButtonEvent& event) void SDL2DisplayWindow::OnMouseWheel(const SDL_MouseWheelEvent& event) { - EInputKey key = (event.y > 0) ? IK_MouseWheelUp : (event.y < 0) ? IK_MouseWheelDown : IK_None; - if (key != IK_None) + InputKey key = (event.y > 0) ? InputKey::MouseWheelUp : (event.y < 0) ? InputKey::MouseWheelDown : InputKey::None; + if (key != InputKey::None) { WindowHost->OnWindowMouseWheel(GetMousePos(event), key); } @@ -451,226 +451,226 @@ void SDL2DisplayWindow::OnPaintEvent() WindowHost->OnWindowPaint(); } -EInputKey SDL2DisplayWindow::ScancodeToInputKey(SDL_Scancode keycode) +InputKey SDL2DisplayWindow::ScancodeToInputKey(SDL_Scancode keycode) { switch (keycode) { - case SDL_SCANCODE_BACKSPACE: return IK_Backspace; - case SDL_SCANCODE_TAB: return IK_Tab; - case SDL_SCANCODE_CLEAR: return IK_OEMClear; - case SDL_SCANCODE_RETURN: return IK_Enter; - case SDL_SCANCODE_MENU: return IK_Alt; - case SDL_SCANCODE_PAUSE: return IK_Pause; - case SDL_SCANCODE_ESCAPE: return IK_Escape; - case SDL_SCANCODE_SPACE: return IK_Space; - case SDL_SCANCODE_END: return IK_End; - case SDL_SCANCODE_HOME: return IK_Home; - case SDL_SCANCODE_LEFT: return IK_Left; - case SDL_SCANCODE_UP: return IK_Up; - case SDL_SCANCODE_RIGHT: return IK_Right; - case SDL_SCANCODE_DOWN: return IK_Down; - case SDL_SCANCODE_SELECT: return IK_Select; - case SDL_SCANCODE_PRINTSCREEN: return IK_Print; - case SDL_SCANCODE_EXECUTE: return IK_Execute; - case SDL_SCANCODE_INSERT: return IK_Insert; - case SDL_SCANCODE_DELETE: return IK_Delete; - case SDL_SCANCODE_HELP: return IK_Help; - case SDL_SCANCODE_0: return IK_0; - case SDL_SCANCODE_1: return IK_1; - case SDL_SCANCODE_2: return IK_2; - case SDL_SCANCODE_3: return IK_3; - case SDL_SCANCODE_4: return IK_4; - case SDL_SCANCODE_5: return IK_5; - case SDL_SCANCODE_6: return IK_6; - case SDL_SCANCODE_7: return IK_7; - case SDL_SCANCODE_8: return IK_8; - case SDL_SCANCODE_9: return IK_9; - case SDL_SCANCODE_A: return IK_A; - case SDL_SCANCODE_B: return IK_B; - case SDL_SCANCODE_C: return IK_C; - case SDL_SCANCODE_D: return IK_D; - case SDL_SCANCODE_E: return IK_E; - case SDL_SCANCODE_F: return IK_F; - case SDL_SCANCODE_G: return IK_G; - case SDL_SCANCODE_H: return IK_H; - case SDL_SCANCODE_I: return IK_I; - case SDL_SCANCODE_J: return IK_J; - case SDL_SCANCODE_K: return IK_K; - case SDL_SCANCODE_L: return IK_L; - case SDL_SCANCODE_M: return IK_M; - case SDL_SCANCODE_N: return IK_N; - case SDL_SCANCODE_O: return IK_O; - case SDL_SCANCODE_P: return IK_P; - case SDL_SCANCODE_Q: return IK_Q; - case SDL_SCANCODE_R: return IK_R; - case SDL_SCANCODE_S: return IK_S; - case SDL_SCANCODE_T: return IK_T; - case SDL_SCANCODE_U: return IK_U; - case SDL_SCANCODE_V: return IK_V; - case SDL_SCANCODE_W: return IK_W; - case SDL_SCANCODE_X: return IK_X; - case SDL_SCANCODE_Y: return IK_Y; - case SDL_SCANCODE_Z: return IK_Z; - case SDL_SCANCODE_KP_0: return IK_NumPad0; - case SDL_SCANCODE_KP_1: return IK_NumPad1; - case SDL_SCANCODE_KP_2: return IK_NumPad2; - case SDL_SCANCODE_KP_3: return IK_NumPad3; - case SDL_SCANCODE_KP_4: return IK_NumPad4; - case SDL_SCANCODE_KP_5: return IK_NumPad5; - case SDL_SCANCODE_KP_6: return IK_NumPad6; - case SDL_SCANCODE_KP_7: return IK_NumPad7; - case SDL_SCANCODE_KP_8: return IK_NumPad8; - case SDL_SCANCODE_KP_9: return IK_NumPad9; - // case SDL_SCANCODE_KP_ENTER: return IK_NumPadEnter; - // case SDL_SCANCODE_KP_MULTIPLY: return IK_Multiply; - // case SDL_SCANCODE_KP_PLUS: return IK_Add; - case SDL_SCANCODE_SEPARATOR: return IK_Separator; - // case SDL_SCANCODE_KP_MINUS: return IK_Subtract; - case SDL_SCANCODE_KP_PERIOD: return IK_NumPadPeriod; - // case SDL_SCANCODE_KP_DIVIDE: return IK_Divide; - case SDL_SCANCODE_F1: return IK_F1; - case SDL_SCANCODE_F2: return IK_F2; - case SDL_SCANCODE_F3: return IK_F3; - case SDL_SCANCODE_F4: return IK_F4; - case SDL_SCANCODE_F5: return IK_F5; - case SDL_SCANCODE_F6: return IK_F6; - case SDL_SCANCODE_F7: return IK_F7; - case SDL_SCANCODE_F8: return IK_F8; - case SDL_SCANCODE_F9: return IK_F9; - case SDL_SCANCODE_F10: return IK_F10; - case SDL_SCANCODE_F11: return IK_F11; - case SDL_SCANCODE_F12: return IK_F12; - case SDL_SCANCODE_F13: return IK_F13; - case SDL_SCANCODE_F14: return IK_F14; - case SDL_SCANCODE_F15: return IK_F15; - case SDL_SCANCODE_F16: return IK_F16; - case SDL_SCANCODE_F17: return IK_F17; - case SDL_SCANCODE_F18: return IK_F18; - case SDL_SCANCODE_F19: return IK_F19; - case SDL_SCANCODE_F20: return IK_F20; - case SDL_SCANCODE_F21: return IK_F21; - case SDL_SCANCODE_F22: return IK_F22; - case SDL_SCANCODE_F23: return IK_F23; - case SDL_SCANCODE_F24: return IK_F24; - case SDL_SCANCODE_NUMLOCKCLEAR: return IK_NumLock; - case SDL_SCANCODE_SCROLLLOCK: return IK_ScrollLock; - case SDL_SCANCODE_LSHIFT: return IK_LShift; - case SDL_SCANCODE_RSHIFT: return IK_RShift; - case SDL_SCANCODE_LCTRL: return IK_LControl; - case SDL_SCANCODE_RCTRL: return IK_RControl; - case SDL_SCANCODE_GRAVE: return IK_Tilde; - default: return IK_None; + case SDL_SCANCODE_BACKSPACE: return InputKey::Backspace; + case SDL_SCANCODE_TAB: return InputKey::Tab; + case SDL_SCANCODE_CLEAR: return InputKey::OEMClear; + case SDL_SCANCODE_RETURN: return InputKey::Enter; + case SDL_SCANCODE_MENU: return InputKey::Alt; + case SDL_SCANCODE_PAUSE: return InputKey::Pause; + case SDL_SCANCODE_ESCAPE: return InputKey::Escape; + case SDL_SCANCODE_SPACE: return InputKey::Space; + case SDL_SCANCODE_END: return InputKey::End; + case SDL_SCANCODE_HOME: return InputKey::Home; + case SDL_SCANCODE_LEFT: return InputKey::Left; + case SDL_SCANCODE_UP: return InputKey::Up; + case SDL_SCANCODE_RIGHT: return InputKey::Right; + case SDL_SCANCODE_DOWN: return InputKey::Down; + case SDL_SCANCODE_SELECT: return InputKey::Select; + case SDL_SCANCODE_PRINTSCREEN: return InputKey::Print; + case SDL_SCANCODE_EXECUTE: return InputKey::Execute; + case SDL_SCANCODE_INSERT: return InputKey::Insert; + case SDL_SCANCODE_DELETE: return InputKey::Delete; + case SDL_SCANCODE_HELP: return InputKey::Help; + case SDL_SCANCODE_0: return InputKey::_0; + case SDL_SCANCODE_1: return InputKey::_1; + case SDL_SCANCODE_2: return InputKey::_2; + case SDL_SCANCODE_3: return InputKey::_3; + case SDL_SCANCODE_4: return InputKey::_4; + case SDL_SCANCODE_5: return InputKey::_5; + case SDL_SCANCODE_6: return InputKey::_6; + case SDL_SCANCODE_7: return InputKey::_7; + case SDL_SCANCODE_8: return InputKey::_8; + case SDL_SCANCODE_9: return InputKey::_9; + case SDL_SCANCODE_A: return InputKey::A; + case SDL_SCANCODE_B: return InputKey::B; + case SDL_SCANCODE_C: return InputKey::C; + case SDL_SCANCODE_D: return InputKey::D; + case SDL_SCANCODE_E: return InputKey::E; + case SDL_SCANCODE_F: return InputKey::F; + case SDL_SCANCODE_G: return InputKey::G; + case SDL_SCANCODE_H: return InputKey::H; + case SDL_SCANCODE_I: return InputKey::I; + case SDL_SCANCODE_J: return InputKey::J; + case SDL_SCANCODE_K: return InputKey::K; + case SDL_SCANCODE_L: return InputKey::L; + case SDL_SCANCODE_M: return InputKey::M; + case SDL_SCANCODE_N: return InputKey::N; + case SDL_SCANCODE_O: return InputKey::O; + case SDL_SCANCODE_P: return InputKey::P; + case SDL_SCANCODE_Q: return InputKey::Q; + case SDL_SCANCODE_R: return InputKey::R; + case SDL_SCANCODE_S: return InputKey::S; + case SDL_SCANCODE_T: return InputKey::T; + case SDL_SCANCODE_U: return InputKey::U; + case SDL_SCANCODE_V: return InputKey::V; + case SDL_SCANCODE_W: return InputKey::W; + case SDL_SCANCODE_X: return InputKey::X; + case SDL_SCANCODE_Y: return InputKey::Y; + case SDL_SCANCODE_Z: return InputKey::Z; + case SDL_SCANCODE_KP_0: return InputKey::NumPad0; + case SDL_SCANCODE_KP_1: return InputKey::NumPad1; + case SDL_SCANCODE_KP_2: return InputKey::NumPad2; + case SDL_SCANCODE_KP_3: return InputKey::NumPad3; + case SDL_SCANCODE_KP_4: return InputKey::NumPad4; + case SDL_SCANCODE_KP_5: return InputKey::NumPad5; + case SDL_SCANCODE_KP_6: return InputKey::NumPad6; + case SDL_SCANCODE_KP_7: return InputKey::NumPad7; + case SDL_SCANCODE_KP_8: return InputKey::NumPad8; + case SDL_SCANCODE_KP_9: return InputKey::NumPad9; + // case SDL_SCANCODE_KP_ENTER: return InputKey::NumPadEnter; + // case SDL_SCANCODE_KP_MULTIPLY: return InputKey::Multiply; + // case SDL_SCANCODE_KP_PLUS: return InputKey::Add; + case SDL_SCANCODE_SEPARATOR: return InputKey::Separator; + // case SDL_SCANCODE_KP_MINUS: return InputKey::Subtract; + case SDL_SCANCODE_KP_PERIOD: return InputKey::NumPadPeriod; + // case SDL_SCANCODE_KP_DIVIDE: return InputKey::Divide; + case SDL_SCANCODE_F1: return InputKey::F1; + case SDL_SCANCODE_F2: return InputKey::F2; + case SDL_SCANCODE_F3: return InputKey::F3; + case SDL_SCANCODE_F4: return InputKey::F4; + case SDL_SCANCODE_F5: return InputKey::F5; + case SDL_SCANCODE_F6: return InputKey::F6; + case SDL_SCANCODE_F7: return InputKey::F7; + case SDL_SCANCODE_F8: return InputKey::F8; + case SDL_SCANCODE_F9: return InputKey::F9; + case SDL_SCANCODE_F10: return InputKey::F10; + case SDL_SCANCODE_F11: return InputKey::F11; + case SDL_SCANCODE_F12: return InputKey::F12; + case SDL_SCANCODE_F13: return InputKey::F13; + case SDL_SCANCODE_F14: return InputKey::F14; + case SDL_SCANCODE_F15: return InputKey::F15; + case SDL_SCANCODE_F16: return InputKey::F16; + case SDL_SCANCODE_F17: return InputKey::F17; + case SDL_SCANCODE_F18: return InputKey::F18; + case SDL_SCANCODE_F19: return InputKey::F19; + case SDL_SCANCODE_F20: return InputKey::F20; + case SDL_SCANCODE_F21: return InputKey::F21; + case SDL_SCANCODE_F22: return InputKey::F22; + case SDL_SCANCODE_F23: return InputKey::F23; + case SDL_SCANCODE_F24: return InputKey::F24; + case SDL_SCANCODE_NUMLOCKCLEAR: return InputKey::NumLock; + case SDL_SCANCODE_SCROLLLOCK: return InputKey::ScrollLock; + case SDL_SCANCODE_LSHIFT: return InputKey::LShift; + case SDL_SCANCODE_RSHIFT: return InputKey::RShift; + case SDL_SCANCODE_LCTRL: return InputKey::LControl; + case SDL_SCANCODE_RCTRL: return InputKey::RControl; + case SDL_SCANCODE_GRAVE: return InputKey::Tilde; + default: return InputKey::None; } } -SDL_Scancode SDL2DisplayWindow::InputKeyToScancode(EInputKey inputkey) +SDL_Scancode SDL2DisplayWindow::InputKeyToScancode(InputKey inputkey) { switch (inputkey) { - case IK_Backspace: return SDL_SCANCODE_BACKSPACE; - case IK_Tab: return SDL_SCANCODE_TAB; - case IK_OEMClear: return SDL_SCANCODE_CLEAR; - case IK_Enter: return SDL_SCANCODE_RETURN; - case IK_Alt: return SDL_SCANCODE_MENU; - case IK_Pause: return SDL_SCANCODE_PAUSE; - case IK_Escape: return SDL_SCANCODE_ESCAPE; - case IK_Space: return SDL_SCANCODE_SPACE; - case IK_End: return SDL_SCANCODE_END; - case IK_Home: return SDL_SCANCODE_HOME; - case IK_Left: return SDL_SCANCODE_LEFT; - case IK_Up: return SDL_SCANCODE_UP; - case IK_Right: return SDL_SCANCODE_RIGHT; - case IK_Down: return SDL_SCANCODE_DOWN; - case IK_Select: return SDL_SCANCODE_SELECT; - case IK_Print: return SDL_SCANCODE_PRINTSCREEN; - case IK_Execute: return SDL_SCANCODE_EXECUTE; - case IK_Insert: return SDL_SCANCODE_INSERT; - case IK_Delete: return SDL_SCANCODE_DELETE; - case IK_Help: return SDL_SCANCODE_HELP; - case IK_0: return SDL_SCANCODE_0; - case IK_1: return SDL_SCANCODE_1; - case IK_2: return SDL_SCANCODE_2; - case IK_3: return SDL_SCANCODE_3; - case IK_4: return SDL_SCANCODE_4; - case IK_5: return SDL_SCANCODE_5; - case IK_6: return SDL_SCANCODE_6; - case IK_7: return SDL_SCANCODE_7; - case IK_8: return SDL_SCANCODE_8; - case IK_9: return SDL_SCANCODE_9; - case IK_A: return SDL_SCANCODE_A; - case IK_B: return SDL_SCANCODE_B; - case IK_C: return SDL_SCANCODE_C; - case IK_D: return SDL_SCANCODE_D; - case IK_E: return SDL_SCANCODE_E; - case IK_F: return SDL_SCANCODE_F; - case IK_G: return SDL_SCANCODE_G; - case IK_H: return SDL_SCANCODE_H; - case IK_I: return SDL_SCANCODE_I; - case IK_J: return SDL_SCANCODE_J; - case IK_K: return SDL_SCANCODE_K; - case IK_L: return SDL_SCANCODE_L; - case IK_M: return SDL_SCANCODE_M; - case IK_N: return SDL_SCANCODE_N; - case IK_O: return SDL_SCANCODE_O; - case IK_P: return SDL_SCANCODE_P; - case IK_Q: return SDL_SCANCODE_Q; - case IK_R: return SDL_SCANCODE_R; - case IK_S: return SDL_SCANCODE_S; - case IK_T: return SDL_SCANCODE_T; - case IK_U: return SDL_SCANCODE_U; - case IK_V: return SDL_SCANCODE_V; - case IK_W: return SDL_SCANCODE_W; - case IK_X: return SDL_SCANCODE_X; - case IK_Y: return SDL_SCANCODE_Y; - case IK_Z: return SDL_SCANCODE_Z; - case IK_NumPad0: return SDL_SCANCODE_KP_0; - case IK_NumPad1: return SDL_SCANCODE_KP_1; - case IK_NumPad2: return SDL_SCANCODE_KP_2; - case IK_NumPad3: return SDL_SCANCODE_KP_3; - case IK_NumPad4: return SDL_SCANCODE_KP_4; - case IK_NumPad5: return SDL_SCANCODE_KP_5; - case IK_NumPad6: return SDL_SCANCODE_KP_6; - case IK_NumPad7: return SDL_SCANCODE_KP_7; - case IK_NumPad8: return SDL_SCANCODE_KP_8; - case IK_NumPad9: return SDL_SCANCODE_KP_9; - // case IK_NumPadEnter: return SDL_SCANCODE_KP_ENTER; - // case IK_Multiply return SDL_SCANCODE_KP_MULTIPLY:; - // case IK_Add: return SDL_SCANCODE_KP_PLUS; - case IK_Separator: return SDL_SCANCODE_SEPARATOR; - // case IK_Subtract: return SDL_SCANCODE_KP_MINUS; - case IK_NumPadPeriod: return SDL_SCANCODE_KP_PERIOD; - // case IK_Divide: return SDL_SCANCODE_KP_DIVIDE; - case IK_F1: return SDL_SCANCODE_F1; - case IK_F2: return SDL_SCANCODE_F2; - case IK_F3: return SDL_SCANCODE_F3; - case IK_F4: return SDL_SCANCODE_F4; - case IK_F5: return SDL_SCANCODE_F5; - case IK_F6: return SDL_SCANCODE_F6; - case IK_F7: return SDL_SCANCODE_F7; - case IK_F8: return SDL_SCANCODE_F8; - case IK_F9: return SDL_SCANCODE_F9; - case IK_F10: return SDL_SCANCODE_F10; - case IK_F11: return SDL_SCANCODE_F11; - case IK_F12: return SDL_SCANCODE_F12; - case IK_F13: return SDL_SCANCODE_F13; - case IK_F14: return SDL_SCANCODE_F14; - case IK_F15: return SDL_SCANCODE_F15; - case IK_F16: return SDL_SCANCODE_F16; - case IK_F17: return SDL_SCANCODE_F17; - case IK_F18: return SDL_SCANCODE_F18; - case IK_F19: return SDL_SCANCODE_F19; - case IK_F20: return SDL_SCANCODE_F20; - case IK_F21: return SDL_SCANCODE_F21; - case IK_F22: return SDL_SCANCODE_F22; - case IK_F23: return SDL_SCANCODE_F23; - case IK_F24: return SDL_SCANCODE_F24; - case IK_NumLock: return SDL_SCANCODE_NUMLOCKCLEAR; - case IK_ScrollLock: return SDL_SCANCODE_SCROLLLOCK; - case IK_LShift: return SDL_SCANCODE_LSHIFT; - case IK_RShift: return SDL_SCANCODE_RSHIFT; - case IK_LControl: return SDL_SCANCODE_LCTRL; - case IK_RControl: return SDL_SCANCODE_RCTRL; - case IK_Tilde: return SDL_SCANCODE_GRAVE; + case InputKey::Backspace: return SDL_SCANCODE_BACKSPACE; + case InputKey::Tab: return SDL_SCANCODE_TAB; + case InputKey::OEMClear: return SDL_SCANCODE_CLEAR; + case InputKey::Enter: return SDL_SCANCODE_RETURN; + case InputKey::Alt: return SDL_SCANCODE_MENU; + case InputKey::Pause: return SDL_SCANCODE_PAUSE; + case InputKey::Escape: return SDL_SCANCODE_ESCAPE; + case InputKey::Space: return SDL_SCANCODE_SPACE; + case InputKey::End: return SDL_SCANCODE_END; + case InputKey::Home: return SDL_SCANCODE_HOME; + case InputKey::Left: return SDL_SCANCODE_LEFT; + case InputKey::Up: return SDL_SCANCODE_UP; + case InputKey::Right: return SDL_SCANCODE_RIGHT; + case InputKey::Down: return SDL_SCANCODE_DOWN; + case InputKey::Select: return SDL_SCANCODE_SELECT; + case InputKey::Print: return SDL_SCANCODE_PRINTSCREEN; + case InputKey::Execute: return SDL_SCANCODE_EXECUTE; + case InputKey::Insert: return SDL_SCANCODE_INSERT; + case InputKey::Delete: return SDL_SCANCODE_DELETE; + case InputKey::Help: return SDL_SCANCODE_HELP; + case InputKey::_0: return SDL_SCANCODE_0; + case InputKey::_1: return SDL_SCANCODE_1; + case InputKey::_2: return SDL_SCANCODE_2; + case InputKey::_3: return SDL_SCANCODE_3; + case InputKey::_4: return SDL_SCANCODE_4; + case InputKey::_5: return SDL_SCANCODE_5; + case InputKey::_6: return SDL_SCANCODE_6; + case InputKey::_7: return SDL_SCANCODE_7; + case InputKey::_8: return SDL_SCANCODE_8; + case InputKey::_9: return SDL_SCANCODE_9; + case InputKey::A: return SDL_SCANCODE_A; + case InputKey::B: return SDL_SCANCODE_B; + case InputKey::C: return SDL_SCANCODE_C; + case InputKey::D: return SDL_SCANCODE_D; + case InputKey::E: return SDL_SCANCODE_E; + case InputKey::F: return SDL_SCANCODE_F; + case InputKey::G: return SDL_SCANCODE_G; + case InputKey::H: return SDL_SCANCODE_H; + case InputKey::I: return SDL_SCANCODE_I; + case InputKey::J: return SDL_SCANCODE_J; + case InputKey::K: return SDL_SCANCODE_K; + case InputKey::L: return SDL_SCANCODE_L; + case InputKey::M: return SDL_SCANCODE_M; + case InputKey::N: return SDL_SCANCODE_N; + case InputKey::O: return SDL_SCANCODE_O; + case InputKey::P: return SDL_SCANCODE_P; + case InputKey::Q: return SDL_SCANCODE_Q; + case InputKey::R: return SDL_SCANCODE_R; + case InputKey::S: return SDL_SCANCODE_S; + case InputKey::T: return SDL_SCANCODE_T; + case InputKey::U: return SDL_SCANCODE_U; + case InputKey::V: return SDL_SCANCODE_V; + case InputKey::W: return SDL_SCANCODE_W; + case InputKey::X: return SDL_SCANCODE_X; + case InputKey::Y: return SDL_SCANCODE_Y; + case InputKey::Z: return SDL_SCANCODE_Z; + case InputKey::NumPad0: return SDL_SCANCODE_KP_0; + case InputKey::NumPad1: return SDL_SCANCODE_KP_1; + case InputKey::NumPad2: return SDL_SCANCODE_KP_2; + case InputKey::NumPad3: return SDL_SCANCODE_KP_3; + case InputKey::NumPad4: return SDL_SCANCODE_KP_4; + case InputKey::NumPad5: return SDL_SCANCODE_KP_5; + case InputKey::NumPad6: return SDL_SCANCODE_KP_6; + case InputKey::NumPad7: return SDL_SCANCODE_KP_7; + case InputKey::NumPad8: return SDL_SCANCODE_KP_8; + case InputKey::NumPad9: return SDL_SCANCODE_KP_9; + // case InputKey::NumPadEnter: return SDL_SCANCODE_KP_ENTER; + // case InputKey::Multiply return SDL_SCANCODE_KP_MULTIPLY:; + // case InputKey::Add: return SDL_SCANCODE_KP_PLUS; + case InputKey::Separator: return SDL_SCANCODE_SEPARATOR; + // case InputKey::Subtract: return SDL_SCANCODE_KP_MINUS; + case InputKey::NumPadPeriod: return SDL_SCANCODE_KP_PERIOD; + // case InputKey::Divide: return SDL_SCANCODE_KP_DIVIDE; + case InputKey::F1: return SDL_SCANCODE_F1; + case InputKey::F2: return SDL_SCANCODE_F2; + case InputKey::F3: return SDL_SCANCODE_F3; + case InputKey::F4: return SDL_SCANCODE_F4; + case InputKey::F5: return SDL_SCANCODE_F5; + case InputKey::F6: return SDL_SCANCODE_F6; + case InputKey::F7: return SDL_SCANCODE_F7; + case InputKey::F8: return SDL_SCANCODE_F8; + case InputKey::F9: return SDL_SCANCODE_F9; + case InputKey::F10: return SDL_SCANCODE_F10; + case InputKey::F11: return SDL_SCANCODE_F11; + case InputKey::F12: return SDL_SCANCODE_F12; + case InputKey::F13: return SDL_SCANCODE_F13; + case InputKey::F14: return SDL_SCANCODE_F14; + case InputKey::F15: return SDL_SCANCODE_F15; + case InputKey::F16: return SDL_SCANCODE_F16; + case InputKey::F17: return SDL_SCANCODE_F17; + case InputKey::F18: return SDL_SCANCODE_F18; + case InputKey::F19: return SDL_SCANCODE_F19; + case InputKey::F20: return SDL_SCANCODE_F20; + case InputKey::F21: return SDL_SCANCODE_F21; + case InputKey::F22: return SDL_SCANCODE_F22; + case InputKey::F23: return SDL_SCANCODE_F23; + case InputKey::F24: return SDL_SCANCODE_F24; + case InputKey::NumLock: return SDL_SCANCODE_NUMLOCKCLEAR; + case InputKey::ScrollLock: return SDL_SCANCODE_SCROLLLOCK; + case InputKey::LShift: return SDL_SCANCODE_LSHIFT; + case InputKey::RShift: return SDL_SCANCODE_RSHIFT; + case InputKey::LControl: return SDL_SCANCODE_LCTRL; + case InputKey::RControl: return SDL_SCANCODE_RCTRL; + case InputKey::Tilde: return SDL_SCANCODE_GRAVE; default: return (SDL_Scancode)0; } } diff --git a/src/window/sdl2/sdl2displaywindow.h b/src/window/sdl2/sdl2displaywindow.h index fa0e825..cb5c372 100644 --- a/src/window/sdl2/sdl2displaywindow.h +++ b/src/window/sdl2/sdl2displaywindow.h @@ -27,7 +27,7 @@ class SDL2DisplayWindow : public DisplayWindow void CaptureMouse() override; void ReleaseMouseCapture() override; void Update() override; - bool GetKeyState(EInputKey key) override; + bool GetKeyState(InputKey key) override; void SetCursor(StandardCursor cursor) override; Rect GetWindowFrame() const override; @@ -58,10 +58,10 @@ class SDL2DisplayWindow : public DisplayWindow void OnMouseMotion(const SDL_MouseMotionEvent& event); void OnPaintEvent(); - EInputKey GetMouseButtonKey(const SDL_MouseButtonEvent& event); + InputKey GetMouseButtonKey(const SDL_MouseButtonEvent& event); - static EInputKey ScancodeToInputKey(SDL_Scancode keycode); - static SDL_Scancode InputKeyToScancode(EInputKey inputkey); + static InputKey ScancodeToInputKey(SDL_Scancode keycode); + static SDL_Scancode InputKeyToScancode(InputKey inputkey); template Point GetMousePos(const T& event) diff --git a/src/window/win32/win32window.cpp b/src/window/win32/win32displaywindow.cpp similarity index 79% rename from src/window/win32/win32window.cpp rename to src/window/win32/win32displaywindow.cpp index f279bcf..2bf0acf 100644 --- a/src/window/win32/win32window.cpp +++ b/src/window/win32/win32displaywindow.cpp @@ -1,5 +1,5 @@ -#include "win32window.h" +#include "win32displaywindow.h" #include #include #include @@ -56,7 +56,7 @@ static std::wstring to_utf16(const std::string& str) return result; } -Win32Window::Win32Window(DisplayWindowHost* windowHost) : WindowHost(windowHost) +Win32DisplayWindow::Win32DisplayWindow(DisplayWindowHost* windowHost) : WindowHost(windowHost) { Windows.push_front(this); WindowsIterator = Windows.begin(); @@ -66,7 +66,7 @@ Win32Window::Win32Window(DisplayWindowHost* windowHost) : WindowHost(windowHost) classdesc.hInstance = GetModuleHandle(0); classdesc.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS; classdesc.lpszClassName = L"ZWidgetWindow"; - classdesc.lpfnWndProc = &Win32Window::WndProc; + classdesc.lpfnWndProc = &Win32DisplayWindow::WndProc; RegisterClassEx(&classdesc); // Microsoft logic at its finest: @@ -86,7 +86,7 @@ Win32Window::Win32Window(DisplayWindowHost* windowHost) : WindowHost(windowHost) */ } -Win32Window::~Win32Window() +Win32DisplayWindow::~Win32DisplayWindow() { if (WindowHandle) { @@ -97,36 +97,36 @@ Win32Window::~Win32Window() Windows.erase(WindowsIterator); } -void Win32Window::SetWindowTitle(const std::string& text) +void Win32DisplayWindow::SetWindowTitle(const std::string& text) { SetWindowText(WindowHandle, to_utf16(text).c_str()); } -void Win32Window::SetBorderColor(uint32_t bgra8) +void Win32DisplayWindow::SetBorderColor(uint32_t bgra8) { bgra8 = bgra8 & 0x00ffffff; DwmSetWindowAttribute(WindowHandle, 34/*DWMWA_BORDER_COLOR*/, &bgra8, sizeof(uint32_t)); } -void Win32Window::SetCaptionColor(uint32_t bgra8) +void Win32DisplayWindow::SetCaptionColor(uint32_t bgra8) { bgra8 = bgra8 & 0x00ffffff; DwmSetWindowAttribute(WindowHandle, 35/*DWMWA_CAPTION_COLOR*/, &bgra8, sizeof(uint32_t)); } -void Win32Window::SetCaptionTextColor(uint32_t bgra8) +void Win32DisplayWindow::SetCaptionTextColor(uint32_t bgra8) { bgra8 = bgra8 & 0x00ffffff; DwmSetWindowAttribute(WindowHandle, 36/*DWMWA_TEXT_COLOR*/, &bgra8, sizeof(uint32_t)); } -void Win32Window::SetWindowFrame(const Rect& box) +void Win32DisplayWindow::SetWindowFrame(const Rect& box) { double dpiscale = GetDpiScale(); SetWindowPos(WindowHandle, nullptr, (int)std::round(box.x * dpiscale), (int)std::round(box.y * dpiscale), (int)std::round(box.width * dpiscale), (int)std::round(box.height * dpiscale), SWP_NOACTIVATE | SWP_NOZORDER); } -void Win32Window::SetClientFrame(const Rect& box) +void Win32DisplayWindow::SetClientFrame(const Rect& box) { double dpiscale = GetDpiScale(); @@ -143,12 +143,12 @@ void Win32Window::SetClientFrame(const Rect& box) SetWindowPos(WindowHandle, nullptr, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE | SWP_NOZORDER); } -void Win32Window::Show() +void Win32DisplayWindow::Show() { ShowWindow(WindowHandle, SW_SHOW); } -void Win32Window::ShowFullscreen() +void Win32DisplayWindow::ShowFullscreen() { HDC screenDC = GetDC(0); int width = GetDeviceCaps(screenDC, HORZRES); @@ -160,36 +160,36 @@ void Win32Window::ShowFullscreen() Fullscreen = true; } -void Win32Window::ShowMaximized() +void Win32DisplayWindow::ShowMaximized() { ShowWindow(WindowHandle, SW_SHOWMAXIMIZED); } -void Win32Window::ShowMinimized() +void Win32DisplayWindow::ShowMinimized() { ShowWindow(WindowHandle, SW_SHOWMINIMIZED); } -void Win32Window::ShowNormal() +void Win32DisplayWindow::ShowNormal() { ShowWindow(WindowHandle, SW_NORMAL); } -void Win32Window::Hide() +void Win32DisplayWindow::Hide() { ShowWindow(WindowHandle, SW_HIDE); } -void Win32Window::Activate() +void Win32DisplayWindow::Activate() { SetFocus(WindowHandle); } -void Win32Window::ShowCursor(bool enable) +void Win32DisplayWindow::ShowCursor(bool enable) { } -void Win32Window::LockCursor() +void Win32DisplayWindow::LockCursor() { if (!MouseLocked) { @@ -199,7 +199,7 @@ void Win32Window::LockCursor() } } -void Win32Window::UnlockCursor() +void Win32DisplayWindow::UnlockCursor() { if (MouseLocked) { @@ -209,27 +209,27 @@ void Win32Window::UnlockCursor() } } -void Win32Window::CaptureMouse() +void Win32DisplayWindow::CaptureMouse() { SetCapture(WindowHandle); } -void Win32Window::ReleaseMouseCapture() +void Win32DisplayWindow::ReleaseMouseCapture() { ReleaseCapture(); } -void Win32Window::Update() +void Win32DisplayWindow::Update() { InvalidateRect(WindowHandle, nullptr, FALSE); } -bool Win32Window::GetKeyState(EInputKey key) +bool Win32DisplayWindow::GetKeyState(InputKey key) { return ::GetKeyState((int)key) & 0x8000; // High bit (0x8000) means key is down, Low bit (0x0001) means key is sticky on (like Caps Lock, Num Lock, etc.) } -void Win32Window::SetCursor(StandardCursor cursor) +void Win32DisplayWindow::SetCursor(StandardCursor cursor) { if (cursor != CurrentCursor) { @@ -238,7 +238,7 @@ void Win32Window::SetCursor(StandardCursor cursor) } } -Rect Win32Window::GetWindowFrame() const +Rect Win32DisplayWindow::GetWindowFrame() const { RECT box = {}; GetWindowRect(WindowHandle, &box); @@ -246,7 +246,7 @@ Rect Win32Window::GetWindowFrame() const return Rect(box.left / dpiscale, box.top / dpiscale, box.right / dpiscale, box.bottom / dpiscale); } -Size Win32Window::GetClientSize() const +Size Win32DisplayWindow::GetClientSize() const { RECT box = {}; GetClientRect(WindowHandle, &box); @@ -254,26 +254,26 @@ Size Win32Window::GetClientSize() const return Size(box.right / dpiscale, box.bottom / dpiscale); } -int Win32Window::GetPixelWidth() const +int Win32DisplayWindow::GetPixelWidth() const { RECT box = {}; GetClientRect(WindowHandle, &box); return box.right; } -int Win32Window::GetPixelHeight() const +int Win32DisplayWindow::GetPixelHeight() const { RECT box = {}; GetClientRect(WindowHandle, &box); return box.bottom; } -double Win32Window::GetDpiScale() const +double Win32DisplayWindow::GetDpiScale() const { return GetDpiForWindow(WindowHandle) / 96.0; } -std::string Win32Window::GetClipboardText() +std::string Win32DisplayWindow::GetClipboardText() { BOOL result = OpenClipboard(WindowHandle); if (result == FALSE) @@ -299,7 +299,7 @@ std::string Win32Window::GetClipboardText() return str; } -void Win32Window::SetClipboardText(const std::string& text) +void Win32DisplayWindow::SetClipboardText(const std::string& text) { std::wstring text16 = to_utf16(text); @@ -314,7 +314,7 @@ void Win32Window::SetClipboardText(const std::string& text) throw std::runtime_error("Unable to empty clipboard"); } - unsigned int length = (text16.length() + 1) * sizeof(std::wstring::value_type); + unsigned int length = (unsigned int)((text16.length() + 1) * sizeof(std::wstring::value_type)); HANDLE handle = GlobalAlloc(GMEM_MOVEABLE, length); if (handle == 0) { @@ -344,7 +344,7 @@ void Win32Window::SetClipboardText(const std::string& text) CloseClipboard(); } -void Win32Window::PresentBitmap(int width, int height, const uint32_t* pixels) +void Win32DisplayWindow::PresentBitmap(int width, int height, const uint32_t* pixels) { BITMAPV5HEADER header = {}; header.bV5Size = sizeof(BITMAPV5HEADER); @@ -368,7 +368,7 @@ void Win32Window::PresentBitmap(int width, int height, const uint32_t* pixels) } } -LRESULT Win32Window::OnWindowMessage(UINT msg, WPARAM wparam, LPARAM lparam) +LRESULT Win32DisplayWindow::OnWindowMessage(UINT msg, WPARAM wparam, LPARAM lparam) { LPARAM result = 0; if (DwmDefWindowProc(WindowHandle, msg, wparam, lparam, &result)) @@ -437,39 +437,39 @@ LRESULT Win32Window::OnWindowMessage(UINT msg, WPARAM wparam, LPARAM lparam) } else if (msg == WM_LBUTTONDOWN) { - WindowHost->OnWindowMouseDown(GetLParamPos(lparam), IK_LeftMouse); + WindowHost->OnWindowMouseDown(GetLParamPos(lparam), InputKey::LeftMouse); } else if (msg == WM_LBUTTONDBLCLK) { - WindowHost->OnWindowMouseDoubleclick(GetLParamPos(lparam), IK_LeftMouse); + WindowHost->OnWindowMouseDoubleclick(GetLParamPos(lparam), InputKey::LeftMouse); } else if (msg == WM_LBUTTONUP) { - WindowHost->OnWindowMouseUp(GetLParamPos(lparam), IK_LeftMouse); + WindowHost->OnWindowMouseUp(GetLParamPos(lparam), InputKey::LeftMouse); } else if (msg == WM_MBUTTONDOWN) { - WindowHost->OnWindowMouseDown(GetLParamPos(lparam), IK_MiddleMouse); + WindowHost->OnWindowMouseDown(GetLParamPos(lparam), InputKey::MiddleMouse); } else if (msg == WM_MBUTTONDBLCLK) { - WindowHost->OnWindowMouseDoubleclick(GetLParamPos(lparam), IK_MiddleMouse); + WindowHost->OnWindowMouseDoubleclick(GetLParamPos(lparam), InputKey::MiddleMouse); } else if (msg == WM_MBUTTONUP) { - WindowHost->OnWindowMouseUp(GetLParamPos(lparam), IK_MiddleMouse); + WindowHost->OnWindowMouseUp(GetLParamPos(lparam), InputKey::MiddleMouse); } else if (msg == WM_RBUTTONDOWN) { - WindowHost->OnWindowMouseDown(GetLParamPos(lparam), IK_RightMouse); + WindowHost->OnWindowMouseDown(GetLParamPos(lparam), InputKey::RightMouse); } else if (msg == WM_RBUTTONDBLCLK) { - WindowHost->OnWindowMouseDoubleclick(GetLParamPos(lparam), IK_RightMouse); + WindowHost->OnWindowMouseDoubleclick(GetLParamPos(lparam), InputKey::RightMouse); } else if (msg == WM_RBUTTONUP) { - WindowHost->OnWindowMouseUp(GetLParamPos(lparam), IK_RightMouse); + WindowHost->OnWindowMouseUp(GetLParamPos(lparam), InputKey::RightMouse); } else if (msg == WM_MOUSEWHEEL) { @@ -482,7 +482,7 @@ LRESULT Win32Window::OnWindowMessage(UINT msg, WPARAM wparam, LPARAM lparam) pos.y = GET_Y_LPARAM(lparam); ScreenToClient(WindowHandle, &pos); - WindowHost->OnWindowMouseWheel(Point(pos.x / dpiscale, pos.y / dpiscale), delta < 0.0 ? IK_MouseWheelDown : IK_MouseWheelUp); + WindowHost->OnWindowMouseWheel(Point(pos.x / dpiscale, pos.y / dpiscale), delta < 0.0 ? InputKey::MouseWheelDown : InputKey::MouseWheelUp); } else if (msg == WM_CHAR) { @@ -491,11 +491,11 @@ LRESULT Win32Window::OnWindowMessage(UINT msg, WPARAM wparam, LPARAM lparam) } else if (msg == WM_KEYDOWN) { - WindowHost->OnWindowKeyDown((EInputKey)wparam); + WindowHost->OnWindowKeyDown((InputKey)wparam); } else if (msg == WM_KEYUP) { - WindowHost->OnWindowKeyUp((EInputKey)wparam); + WindowHost->OnWindowKeyUp((InputKey)wparam); } else if (msg == WM_SETFOCUS) { @@ -530,7 +530,7 @@ LRESULT Win32Window::OnWindowMessage(UINT msg, WPARAM wparam, LPARAM lparam) return DefWindowProc(WindowHandle, msg, wparam, lparam); } -void Win32Window::UpdateCursor() +void Win32DisplayWindow::UpdateCursor() { LPCWSTR cursor = IDC_ARROW; switch (CurrentCursor) @@ -554,25 +554,25 @@ void Win32Window::UpdateCursor() ::SetCursor((HCURSOR)LoadImage(0, cursor, IMAGE_CURSOR, LR_DEFAULTSIZE, LR_DEFAULTSIZE, LR_SHARED)); } -Point Win32Window::GetLParamPos(LPARAM lparam) const +Point Win32DisplayWindow::GetLParamPos(LPARAM lparam) const { double dpiscale = GetDpiScale(); return Point(GET_X_LPARAM(lparam) / dpiscale, GET_Y_LPARAM(lparam) / dpiscale); } -LRESULT Win32Window::WndProc(HWND windowhandle, UINT msg, WPARAM wparam, LPARAM lparam) +LRESULT Win32DisplayWindow::WndProc(HWND windowhandle, UINT msg, WPARAM wparam, LPARAM lparam) { if (msg == WM_CREATE) { CREATESTRUCT* createstruct = (CREATESTRUCT*)lparam; - Win32Window* viewport = (Win32Window*)createstruct->lpCreateParams; + Win32DisplayWindow* viewport = (Win32DisplayWindow*)createstruct->lpCreateParams; viewport->WindowHandle = windowhandle; SetWindowLongPtr(windowhandle, GWLP_USERDATA, (LONG_PTR)viewport); return viewport->OnWindowMessage(msg, wparam, lparam); } else { - Win32Window* viewport = (Win32Window*)GetWindowLongPtr(windowhandle, GWLP_USERDATA); + Win32DisplayWindow* viewport = (Win32DisplayWindow*)GetWindowLongPtr(windowhandle, GWLP_USERDATA); if (viewport) { LRESULT result = viewport->OnWindowMessage(msg, wparam, lparam); @@ -590,7 +590,7 @@ LRESULT Win32Window::WndProc(HWND windowhandle, UINT msg, WPARAM wparam, LPARAM } } -void Win32Window::ProcessEvents() +void Win32DisplayWindow::ProcessEvents() { while (true) { @@ -602,7 +602,7 @@ void Win32Window::ProcessEvents() } } -void Win32Window::RunLoop() +void Win32DisplayWindow::RunLoop() { while (!ExitRunLoop && !Windows.empty()) { @@ -615,12 +615,12 @@ void Win32Window::RunLoop() ExitRunLoop = false; } -void Win32Window::ExitLoop() +void Win32DisplayWindow::ExitLoop() { ExitRunLoop = true; } -Size Win32Window::GetScreenSize() +Size Win32DisplayWindow::GetScreenSize() { HDC screenDC = GetDC(0); int screenWidth = GetDeviceCaps(screenDC, HORZRES); @@ -633,14 +633,14 @@ Size Win32Window::GetScreenSize() static void CALLBACK Win32TimerCallback(HWND handle, UINT message, UINT_PTR timerID, DWORD timestamp) { - auto it = Win32Window::Timers.find(timerID); - if (it != Win32Window::Timers.end()) + auto it = Win32DisplayWindow::Timers.find(timerID); + if (it != Win32DisplayWindow::Timers.end()) { it->second(); } } -void* Win32Window::StartTimer(int timeoutMilliseconds, std::function onTimer) +void* Win32DisplayWindow::StartTimer(int timeoutMilliseconds, std::function onTimer) { UINT_PTR result = SetTimer(0, 0, timeoutMilliseconds, Win32TimerCallback); if (result == 0) @@ -649,7 +649,7 @@ void* Win32Window::StartTimer(int timeoutMilliseconds, std::function onT return (void*)result; } -void Win32Window::StopTimer(void* timerID) +void Win32DisplayWindow::StopTimer(void* timerID) { auto it = Timers.find((UINT_PTR)timerID); if (it != Timers.end()) @@ -659,7 +659,7 @@ void Win32Window::StopTimer(void* timerID) } } -std::list Win32Window::Windows; -bool Win32Window::ExitRunLoop; +std::list Win32DisplayWindow::Windows; +bool Win32DisplayWindow::ExitRunLoop; -std::unordered_map> Win32Window::Timers; +std::unordered_map> Win32DisplayWindow::Timers; diff --git a/src/window/win32/win32window.h b/src/window/win32/win32displaywindow.h similarity index 88% rename from src/window/win32/win32window.h rename to src/window/win32/win32displaywindow.h index a0f493c..fd7ae3e 100644 --- a/src/window/win32/win32window.h +++ b/src/window/win32/win32displaywindow.h @@ -11,11 +11,11 @@ #include #include -class Win32Window : public DisplayWindow +class Win32DisplayWindow : public DisplayWindow { public: - Win32Window(DisplayWindowHost* windowHost); - ~Win32Window(); + Win32DisplayWindow(DisplayWindowHost* windowHost); + ~Win32DisplayWindow(); void SetWindowTitle(const std::string& text) override; void SetWindowFrame(const Rect& box) override; @@ -33,7 +33,7 @@ class Win32Window : public DisplayWindow void CaptureMouse() override; void ReleaseMouseCapture() override; void Update() override; - bool GetKeyState(EInputKey key) override; + bool GetKeyState(InputKey key) override; void SetCursor(StandardCursor cursor) override; void UpdateCursor(); @@ -64,8 +64,8 @@ class Win32Window : public DisplayWindow static void StopTimer(void* timerID); static bool ExitRunLoop; - static std::list Windows; - std::list::iterator WindowsIterator; + static std::list Windows; + std::list::iterator WindowsIterator; static std::unordered_map> Timers; diff --git a/src/window/window.cpp b/src/window/window.cpp index 234be61..4ceb494 100644 --- a/src/window/window.cpp +++ b/src/window/window.cpp @@ -4,41 +4,41 @@ #ifdef WIN32 -#include "win32/win32window.h" +#include "win32/win32displaywindow.h" std::unique_ptr DisplayWindow::Create(DisplayWindowHost* windowHost) { - return std::make_unique(windowHost); + return std::make_unique(windowHost); } void DisplayWindow::ProcessEvents() { - Win32Window::ProcessEvents(); + Win32DisplayWindow::ProcessEvents(); } void DisplayWindow::RunLoop() { - Win32Window::RunLoop(); + Win32DisplayWindow::RunLoop(); } void DisplayWindow::ExitLoop() { - Win32Window::ExitLoop(); + Win32DisplayWindow::ExitLoop(); } Size DisplayWindow::GetScreenSize() { - return Win32Window::GetScreenSize(); + return Win32DisplayWindow::GetScreenSize(); } void* DisplayWindow::StartTimer(int timeoutMilliseconds, std::function onTimer) { - return Win32Window::StartTimer(timeoutMilliseconds, std::move(onTimer)); + return Win32DisplayWindow::StartTimer(timeoutMilliseconds, std::move(onTimer)); } void DisplayWindow::StopTimer(void* timerID) { - Win32Window::StopTimer(timerID); + Win32DisplayWindow::StopTimer(timerID); } #elif defined(__APPLE__)