fix win32 key input and implement fullscreen/maximize/minsize

TODO

@@ -20,7 +20,6 @@
 [bart] bind every global lua function in static classes
 
 == Platform
-[bart] implement fullscreen, maximize and minsize for win32
 [bart] port to MacOs and iphone
 
 == UI

src/framework/core/logger.cpp

@@ -26,18 +26,18 @@
 
 Logger g_logger;
 
-void Logger::log(Fw::LogLevel level, std::string message)
+void Logger::log(Fw::LogLevel level, const std::string& message)
 {
     const static std::string logPrefixes[] = { "", "", "WARNING: ", "ERROR: ", "FATAL ERROR: " };
 
-    message.insert(0, logPrefixes[level]);
+    std::string outmsg = logPrefixes[level] + message;
-    std::cout << message << std::endl;
+    std::cout << outmsg << std::endl;
 
     std::size_t now = std::time(NULL);
-    m_logMessages.push_back(LogMessage(level, message, now));
+    m_logMessages.push_back(LogMessage(level, outmsg, now));
 
     if(m_onLog)
-        m_onLog(level, message, now);
+        m_onLog(level, outmsg, now);
 
     if(level == Fw::LogFatal) {
         g_window.displayFatalError(message);

src/framework/core/logger.h

@@ -37,7 +37,7 @@ class Logger
     typedef std::function<void(Fw::LogLevel, std::string, std::size_t)> OnLogCallback;
 
 public:
-    void log(Fw::LogLevel level, std::string message);
+    void log(Fw::LogLevel level, const std::string& message);
     void logFunc(Fw::LogLevel level, const std::string& message, std::string prettyFunction);
 
     void fireOldMessages();

src/framework/luafunctions.cpp

@@ -239,6 +239,7 @@ void Application::registerLuaFunctions()
     g_lua.bindClassStaticFunction("g_configs", "set", std::bind(&ConfigManager::set, &g_configs, _1, _2));
     g_lua.bindClassStaticFunction("g_configs", "get", std::bind(&ConfigManager::get, &g_configs, _1));
     g_lua.bindClassStaticFunction("g_configs", "exists", std::bind(&ConfigManager::exists, &g_configs, _1));
+    g_lua.bindClassStaticFunction("g_configs", "remove", std::bind(&ConfigManager::remove, &g_configs, _1));
 
 
     g_lua.registerStaticClass("g_window");

src/framework/platform/win32window.cpp

@@ -33,6 +33,8 @@ WIN32Window::WIN32Window()
     m_deviceContext = 0;
     m_glContext = 0;
     m_maximized = false;
+    m_minimumSize = Size(16,16);
+    m_size = m_minimumSize;
 
     m_keyMap[VK_ESCAPE] = Fw::KeyEscape;
     m_keyMap[VK_TAB] = Fw::KeyTab;
@@ -261,11 +263,12 @@ void WIN32Window::internalRegisterWindowClass()
 void WIN32Window::internalCreateWindow()
 {
     DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
-    DWORD dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
+    DWORD dwStyle = WS_OVERLAPPEDWINDOW;
 
     RECT windowRect = {m_pos.x, m_pos.y, m_pos.x + m_size.width(), m_pos.y + m_size.height()};
     AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);
 
+    updateUnmaximizedCoords();
     m_window = CreateWindowExA(dwExStyle,
                                g_app->getAppName().c_str(),
                                NULL,
@@ -344,21 +347,21 @@ void *WIN32Window::getExtensionProcAddress(const char *ext)
 
 void WIN32Window::move(const Point& pos)
 {
-    MoveWindow(m_window, pos.x, pos.y, m_size.width(), m_size.height(), TRUE);
+    RECT windowRect = {pos.x, pos.y, m_pos.x + m_size.width(), m_pos.y + m_size.height()};
+    AdjustWindowRectEx(&windowRect, WS_OVERLAPPEDWINDOW, FALSE, WS_EX_APPWINDOW | WS_EX_WINDOWEDGE);
+    MoveWindow(m_window, windowRect.left, windowRect.top, windowRect.right - windowRect.left, windowRect.bottom - windowRect.top, TRUE);
 }
 
 void WIN32Window::resize(const Size& size)
 {
-    MoveWindow(m_window, m_pos.x, m_pos.y, size.width(), size.height(), TRUE);
+    RECT windowRect = {m_pos.x, m_pos.y, m_pos.x + size.width(), m_pos.y + size.height()};
+    AdjustWindowRectEx(&windowRect, WS_OVERLAPPEDWINDOW, FALSE, WS_EX_APPWINDOW | WS_EX_WINDOWEDGE);
+    MoveWindow(m_window, windowRect.left, windowRect.top, windowRect.right - windowRect.left, windowRect.bottom - windowRect.top, TRUE);
 }
 
 void WIN32Window::show()
 {
-    updateUnmaximizedCoords();
+    ShowWindow(m_window, SW_SHOW);
-    if(m_maximized)
-        ShowWindow(m_window, SW_MAXIMIZE);
-    else
-        ShowWindow(m_window, SW_SHOW);
 }
 
 void WIN32Window::hide()
@@ -368,15 +371,24 @@ void WIN32Window::hide()
 
 void WIN32Window::maximize()
 {
-    //TODO
+    ShowWindow(m_window, SW_MAXIMIZE);
 }
 
 void WIN32Window::poll()
 {
-    MSG msg;
+    for(int i=0;i<2;++i) {
-    if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+        MSG msg;
-        TranslateMessage(&msg);
+        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
-        DispatchMessage(&msg);
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+
+        updateUnmaximizedCoords();
+
+        if(m_size < m_minimumSize) {
+            resize(m_size.expandedTo(m_minimumSize));
+        } else
+            break;
     }
 }
 
@@ -398,12 +410,6 @@ LRESULT WIN32Window::windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
         case WM_CHAR: {
             if(wParam >= 32 && wParam <= 255) {
                 m_inputEvent.type = Fw::KeyPressInputEvent;
-                if(HIWORD(GetKeyState(VK_CONTROL)))
-                    m_inputEvent.keyboardModifiers |= Fw::KeyboardCtrlModifier;
-                if(HIWORD(GetKeyState(VK_MENU)))
-                    m_inputEvent.keyboardModifiers |= Fw::KeyboardAltModifier;
-                if(HIWORD(GetKeyState(VK_SHIFT)))
-                    m_inputEvent.keyboardModifiers |= Fw::KeyboardShiftModifier;
                 m_inputEvent.keyCode = Fw::KeyUnknown;
                 m_inputEvent.keyText = wParam;
             }
@@ -417,12 +423,6 @@ LRESULT WIN32Window::windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
         case WM_KEYUP: {
             if(m_keyMap.find(wParam) != m_keyMap.end()) {
                 m_inputEvent.type = (uMsg == WM_KEYDOWN) ? Fw::KeyPressInputEvent : Fw::KeyReleaseInputEvent;
-                if(HIWORD(GetKeyState(VK_CONTROL)))
-                    m_inputEvent.keyboardModifiers |= Fw::KeyboardCtrlModifier;
-                if(HIWORD(GetKeyState(VK_MENU)))
-                    m_inputEvent.keyboardModifiers |= Fw::KeyboardAltModifier;
-                if(HIWORD(GetKeyState(VK_SHIFT)))
-                    m_inputEvent.keyboardModifiers |= Fw::KeyboardShiftModifier;
                 m_inputEvent.keyCode = m_keyMap[wParam];
             }
             break;
@@ -473,7 +473,6 @@ LRESULT WIN32Window::windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
         case WM_MOVE: {
             m_pos.x = LOWORD(lParam);
             m_pos.y = HIWORD(lParam);
-            updateUnmaximizedCoords();
             break;
         }
         case WM_SIZE: {
@@ -489,7 +488,7 @@ LRESULT WIN32Window::windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
             m_visible = !(wParam == SIZE_MINIMIZED);
             m_size.setWidth(LOWORD(lParam));
             m_size.setHeight(HIWORD(lParam));
-            updateUnmaximizedCoords();
+
             m_onResize(m_size);
             break;
         }
@@ -497,8 +496,16 @@ LRESULT WIN32Window::windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lPar
             return DefWindowProc(hWnd, uMsg, wParam, lParam);
     }
 
-    if(m_inputEvent.type != Fw::NoInputEvent)
+    if(m_inputEvent.type != Fw::NoInputEvent) {
+        m_inputEvent.keyboardModifiers = 0;
+        if(HIWORD(GetKeyState(VK_CONTROL)))
+            m_inputEvent.keyboardModifiers |= Fw::KeyboardCtrlModifier;
+        if(HIWORD(GetKeyState(VK_MENU)))
+            m_inputEvent.keyboardModifiers |= Fw::KeyboardAltModifier;
+        if(HIWORD(GetKeyState(VK_SHIFT)))
+            m_inputEvent.keyboardModifiers |= Fw::KeyboardShiftModifier;
         m_onInputEvent(m_inputEvent);
+    }
 
     return 0;
 }
@@ -525,12 +532,31 @@ void WIN32Window::setTitle(const std::string& title)
 
 void WIN32Window::setMinimumSize(const Size& minimumSize)
 {
-    //TODO
+    m_minimumSize = minimumSize;
+    if(m_size < m_minimumSize)
+        resize(m_size.expandedTo(m_minimumSize));
 }
 
 void WIN32Window::setFullscreen(bool fullscreen)
 {
-    //TODO
+    if(m_fullscreen == fullscreen)
+        return;
+
+    DWORD dwStyle = GetWindowLong(m_window, GWL_STYLE);
+    static WINDOWPLACEMENT wpPrev = { sizeof(wpPrev) };
+    if(fullscreen) {
+        GetWindowPlacement(m_window, &wpPrev);
+        SetWindowLong(m_window, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
+        SetWindowPos(m_window, HWND_TOP, 0, 0, getDisplayWidth(), getDisplayHeight(),
+                     SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
+    } else {
+        SetWindowLong(m_window, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
+        SetWindowPlacement(m_window, &wpPrev);
+        SetWindowPos(m_window, NULL, 0, 0, 0, 0,
+                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
+    }
+
+    m_fullscreen = fullscreen;
 }
 
 void WIN32Window::setVerticalSync(bool enable)
@@ -590,12 +616,21 @@ void WIN32Window::setIcon(const std::string& pngIcon)
 
 void WIN32Window::setClipboardText(const std::string& text)
 {
-    m_clipboardText = text;
+    if(!OpenClipboard(m_window))
-    if(OpenClipboard(NULL)) {
+        return;
-        EmptyClipboard();
+
-        SetClipboardData(CF_TEXT, (void*)&m_clipboardText[0]);
+    HGLOBAL hglb = GlobalAlloc(GMEM_MOVEABLE, (text.length() + 1) * sizeof(TCHAR));
-        CloseClipboard();
+    if(!hglb)
-    }
+        return;
+
+    LPTSTR lptstr = (LPTSTR)GlobalLock(hglb);
+    memcpy(lptstr, &text[0], text.length() * sizeof(TCHAR));
+    lptstr[text.length()] = (TCHAR)0;
+    GlobalUnlock(hglb);
+
+    EmptyClipboard();
+    SetClipboardData(CF_TEXT, hglb);
+    CloseClipboard();
 }
 
 Size WIN32Window::getDisplaySize()
@@ -606,10 +641,19 @@ Size WIN32Window::getDisplaySize()
 std::string WIN32Window::getClipboardText()
 {
     std::string text;
-    if(OpenClipboard(NULL)) {
+
-        text = (const char*)GetClipboardData(CF_TEXT);
+    if(!OpenClipboard(m_window))
-        CloseClipboard();
+        return text;
+
+    HGLOBAL hglb = GetClipboardData(CF_TEXT);
+    if(hglb) {
+        LPTSTR lptstr = (LPTSTR)GlobalLock(hglb);
+        if(lptstr) {
+            text = lptstr;
+            GlobalUnlock(hglb);
+        }
     }
+    CloseClipboard();
     return text;
 }
 

src/framework/platform/win32window.h

@@ -79,7 +79,7 @@ private:
     HDC m_deviceContext;
     HGLRC m_glContext;
     bool m_maximized;
-    std::string m_clipboardText;
+    Size m_minimumSize;
     std::map<int, Fw::Key> m_keyMap;
 };
 

src/framework/platform/x11window.cpp

@@ -36,6 +36,7 @@ X11Window::X11Window()
     m_xic = 0;
     m_screen = 0;
     m_wmDelete = 0;
+    m_size = Size(16,16);
 
 #ifndef OPENGL_ES2
     m_glxContext = 0;

src/otclient/ui/uiitem.cpp

@@ -44,7 +44,6 @@ void UIItem::render()
         if(m_font && m_item->isStackable() && m_item->getData() > 1) {
             std::string count = Fw::tostring(m_item->getData());
             m_font->renderText(count, Rect(m_rect.topLeft(), m_rect.bottomRight() - Point(3, 0)), Fw::AlignBottomRight, Color(231, 231, 231));
-            dump << m_rect;
         }
     }