5 files changed, 283 insertions, 56 deletions

diff --git a/src/app.c b/src/app.c
index b50321b2..64ddd70e 100644
--- a/src/app.c
+++ b/src/app.c
@@ -160,12 +160,12 @@ static iString *serializePrefs_App_(const iApp *d) {
     const iSidebarWidget *sidebar2 = findWidget_App("sidebar2");
     appendFormat_String(str, "window.retain arg:%d\n", d->prefs.retainWindowSize);
     if (d->prefs.retainWindowSize) {
-        const iBool isMaximized = (SDL_GetWindowFlags(d->window->win) & SDL_WINDOW_MAXIMIZED) != 0;
+        const iBool isMaximized = snap_Window(d->window) == maximized_WindowSnap;
         int w, h, x, y;
-        x = d->window->lastRect.pos.x;
-        y = d->window->lastRect.pos.y;
-        w = d->window->lastRect.size.x;
-        h = d->window->lastRect.size.y;
+        x = d->window->place.normalRect.pos.x;
+        y = d->window->place.normalRect.pos.y;
+        w = d->window->place.normalRect.size.x;
+        h = d->window->place.normalRect.size.y;
         appendFormat_String(str, "window.setrect width:%d height:%d coord:%d %d\n", w, h, x, y);
         appendFormat_String(str, "sidebar.width arg:%d\n", width_SidebarWidget(sidebar));
         appendFormat_String(str, "sidebar2.width arg:%d\n", width_SidebarWidget(sidebar2));
@@ -1113,22 +1113,17 @@ iBool handleCommand_App(const char *cmd) {
     }
     else if (equal_Command(cmd, "window.maximize")) {
         if (!argLabel_Command(cmd, "toggle")) {
-            SDL_MaximizeWindow(d->window->win);
+            setSnap_Window(d->window, maximized_WindowSnap);
         }
         else {
-            if (SDL_GetWindowFlags(d->window->win) & SDL_WINDOW_MAXIMIZED) {
-                SDL_RestoreWindow(d->window->win);
-            }
-            else {
-                SDL_MaximizeWindow(d->window->win);
-            }
+            setSnap_Window(d->window, snap_Window(d->window) == maximized_WindowSnap ? 0 : 
+                           maximized_WindowSnap);
         }
         return iTrue;
     }
     else if (equal_Command(cmd, "window.fullscreen")) {
-        const iBool wasFull =
-            (SDL_GetWindowFlags(d->window->win) & SDL_WINDOW_FULLSCREEN_DESKTOP) != 0;
-        SDL_SetWindowFullscreen(d->window->win, wasFull ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP);
+        const iBool wasFull = snap_Window(d->window) == fullscreen_WindowSnap;
+        setSnap_Window(d->window, wasFull ? 0 : fullscreen_WindowSnap);
         postCommandf_App("window.fullscreen.changed arg:%d", !wasFull);
         return iTrue;
     }
diff --git a/src/ui/window.c b/src/ui/window.c
index 6356b292..37586aab 100644
--- a/src/ui/window.c
+++ b/src/ui/window.c
@@ -93,15 +93,6 @@ static iBool handleRootCommands_(iWidget *root, const char *cmd) {
         setTextColor_LabelWidget(findWidget_App("winbar.title"), uiTextStrong_ColorId);
         return iFalse;
     }
-    else if (equal_Command(cmd, "window.fullscreen.changed")) {
-        iWidget *winBar = findWidget_App("winbar");
-        if (winBar) {
-            setFlags_Widget(winBar, hidden_WidgetFlag, arg_Command(cmd));
-            arrange_Widget(get_Window()->root);
-            postRefresh_App();
-        }
-        return iFalse;
-    }
     else if (equal_Command(cmd, "window.minimize")) {
         SDL_MinimizeWindow(get_Window()->win);
         return iTrue;
@@ -562,7 +553,7 @@ static void setupUserInterface_Window(iWindow *d) {
         setFont_LabelWidget(appButton, uiContentBold_FontId);
         setId_Widget(addChildFlags_Widget(winBar,
                                           iClob(appTitle = new_LabelWidget("", NULL)),
-                                          expand_WidgetFlag | alignLeft_WidgetFlag |
+                                          expand_WidgetFlag | /*alignLeft_WidgetFlag |*/
                                               fixedHeight_WidgetFlag | frameless_WidgetFlag |
                                               commandOnClick_WidgetFlag),
                      "winbar.title");
@@ -570,7 +561,7 @@ static void setupUserInterface_Window(iWindow *d) {
         iLabelWidget *appMin, *appMax, *appClose;
         setId_Widget(addChildFlags_Widget(
                          winBar,
-                         iClob(appMin = newLargeIcon_LabelWidget("\u2014", "window.minimize")),
+                         iClob(appMin = newLargeIcon_LabelWidget("\u2013", "window.minimize")),
                          frameless_WidgetFlag),
                      "winbar.min");
         setSize_Widget(as_Widget(appMin),
@@ -582,6 +573,7 @@ static void setupUserInterface_Window(iWindow *d) {
         addChildFlags_Widget(winBar,
                              iClob(appClose = newLargeIcon_LabelWidget("\u2a2f", "window.close")),
                              frameless_WidgetFlag);
+        setFont_LabelWidget(appClose, uiContent_FontId);
         setSize_Widget(as_Widget(appMax), as_Widget(appMin)->rect.size);
         setSize_Widget(as_Widget(appClose), as_Widget(appMin)->rect.size);
         addChild_Widget(div, iClob(winBar));
@@ -744,8 +736,8 @@ static void updateRootSize_Window_(iWindow *d, iBool notifyAlways) {
     const iInt2 oldSize = *size;
     SDL_GetRendererOutputSize(d->render, &size->x, &size->y);
     if (notifyAlways || !isEqual_I2(oldSize, *size)) {
-        const iBool isHoriz = (d->lastNotifiedSize.x != size->x);
-        const iBool isVert  = (d->lastNotifiedSize.y != size->y);
+        const iBool isHoriz = (d->place.lastNotifiedSize.x != size->x);
+        const iBool isVert  = (d->place.lastNotifiedSize.y != size->y);
         arrange_Widget(d->root);
         postCommandf_App("window.resized width:%d height:%d horiz:%d vert:%d",
                          size->x,
@@ -753,7 +745,7 @@ static void updateRootSize_Window_(iWindow *d, iBool notifyAlways) {
                          isHoriz,
                          isVert);
         postRefresh_App();
-        d->lastNotifiedSize = *size;
+        d->place.lastNotifiedSize = *size;
     }
 }
 
@@ -793,6 +785,9 @@ static void drawBlank_Window_(iWindow *d) {
 static SDL_HitTestResult hitTest_Window_(SDL_Window *win, const SDL_Point *pos, void *data) {
     iWindow *d = data;
     iAssert(d->win == win);
+    if (SDL_GetWindowFlags(d->win) & SDL_WINDOW_MOUSE_CAPTURE) {
+        return SDL_HITTEST_NORMAL;
+    }
     int w, h;
     SDL_GetWindowSize(win, &w, &h);
     /* TODO: Check if inside the caption label widget. */    
@@ -802,15 +797,16 @@ static SDL_HitTestResult hitTest_Window_(SDL_Window *win, const SDL_Point *pos,
     const iBool isBottom = pos->y >= h - gap_UI;
     const int captionHeight = lineHeight_Text(uiContent_FontId) + gap_UI * 2;
     const int rightEdge = left_Rect(bounds_Widget(findChild_Widget(d->root, "winbar.min")));
+    d->place.lastHit = SDL_HITTEST_NORMAL;
     if (isLeft) {
         return pos->y < captionHeight       ? SDL_HITTEST_RESIZE_TOPLEFT
                : pos->y > h - captionHeight ? SDL_HITTEST_RESIZE_BOTTOMLEFT
-                                            : SDL_HITTEST_RESIZE_LEFT;
+                                            : (d->place.lastHit = SDL_HITTEST_RESIZE_LEFT);
     }
     if (isRight) {
         return pos->y < captionHeight       ? SDL_HITTEST_RESIZE_TOPRIGHT
                : pos->y > h - captionHeight ? SDL_HITTEST_RESIZE_BOTTOMRIGHT
-                                            : SDL_HITTEST_RESIZE_RIGHT;
+                                            : (d->place.lastHit = SDL_HITTEST_RESIZE_RIGHT);
     }
     if (isTop) {
         return pos->x < captionHeight       ? SDL_HITTEST_RESIZE_TOPLEFT
@@ -827,6 +823,10 @@ static SDL_HitTestResult hitTest_Window_(SDL_Window *win, const SDL_Point *pos,
     }
     return SDL_HITTEST_NORMAL;
 }
+
+SDL_HitTestResult hitTest_Window(const iWindow *d, iInt2 pos) {
+    return hitTest_Window_(d->win, &(SDL_Point){ pos.x, pos.y }, iConstCast(void *, d));
+}
 #endif
 
 iBool create_Window_(iWindow *d, iRect rect, uint32_t flags) {
@@ -841,7 +841,7 @@ iBool create_Window_(iWindow *d, iRect rect, uint32_t flags) {
     }
 #if defined (LAGRANGE_CUSTOM_FRAME)
     /* Register a handler for window hit testing (drag, resize). */
-    SDL_SetWindowHitTest(d->win, hitTest_Window_, d);    
+    SDL_SetWindowHitTest(d->win, hitTest_Window_, d);
     SDL_SetWindowResizable(d->win, SDL_TRUE);
 #endif
     return iTrue;
@@ -850,12 +850,13 @@ iBool create_Window_(iWindow *d, iRect rect, uint32_t flags) {
 void init_Window(iWindow *d, iRect rect) {
     theWindow_ = d;
     iZap(d->cursors);
-    d->initialPos = rect.pos;
-    d->lastRect = rect;
-    d->lastNotifiedSize = zero_I2();
+    d->place.initialPos = rect.pos;
+    d->place.normalRect = rect;
+    d->place.lastNotifiedSize = zero_I2();
     d->pendingCursor = NULL;
     d->isDrawFrozen = iTrue;
     d->isExposed = iFalse;
+    d->isMinimized = iFalse;
     d->isMouseInside = iTrue;
     d->focusGainedAt = 0;
     uint32_t flags = 0;
@@ -936,6 +937,9 @@ void init_Window(iWindow *d, iRect rect) {
     setupUserInterface_Window(d);
     postCommand_App("bindings.changed"); /* update from bindings */
     updateRootSize_Window_(d, iFalse);
+#if defined (LAGRANGE_CUSTOM_FRAME)
+    SDL_EventState(SDL_SYSWMEVENT, SDL_TRUE);
+#endif
 }
 
 void deinit_Window(iWindow *d) {
@@ -958,17 +962,8 @@ SDL_Renderer *renderer_Window(const iWindow *d) {
     return d->render;
 }
 
-static iBool isMaximized_Window_(const iWindow *d) {
-#if !defined (iPlatformApple)
-    return (SDL_GetWindowFlags(d->win) & (SDL_WINDOW_MINIMIZED | SDL_WINDOW_MAXIMIZED)) != 0;
-#else
-    iUnused(d);
-    return iFalse; /* There is fullscreen mode but that is not handled at the moment. */
-#endif
-}
-
 iBool isFullscreen_Window(const iWindow *d) {
-    return (SDL_GetWindowFlags(d->win) & SDL_WINDOW_FULLSCREEN_DESKTOP) != 0;
+    return snap_Window(d) == fullscreen_WindowSnap;
 }
 
 static void invalidate_Window_(iWindow *d) {
@@ -976,6 +971,31 @@ static void invalidate_Window_(iWindow *d) {
     postCommand_App("theme.changed"); /* forces UI invalidation */
 }
 
+static iBool isNormalPlacement_Window_(const iWindow *d) {
+    if (snap_Window(d) || d->isDrawFrozen) return iFalse;
+    return !(SDL_GetWindowFlags(d->win) & SDL_WINDOW_MINIMIZED);
+}
+
+static iBool unsnap_Window_(iWindow *d, const iInt2 *newPos) {
+#if defined (LAGRANGE_CUSTOM_FRAME)
+    const int snap = snap_Window(d);
+    if (snap == yMaximized_WindowSnap &&
+        (!newPos || (d->place.lastHit == SDL_HITTEST_RESIZE_LEFT ||
+                     d->place.lastHit == SDL_HITTEST_RESIZE_RIGHT))) {
+        return iFalse;
+    }
+    if (snap && snap != fullscreen_WindowSnap) {
+        if (snap_Window(d) == yMaximized_WindowSnap && newPos) {
+            d->place.normalRect.pos = *newPos;
+        }
+        printf("unsnap\n"); fflush(stdout);
+        setSnap_Window(d, none_WindowSnap);
+        return iTrue;
+    }
+#endif
+    return iFalse;
+}
+
 static iBool handleWindowEvent_Window_(iWindow *d, const SDL_WindowEvent *ev) {
     switch (ev->event) {
         case SDL_WINDOWEVENT_EXPOSED:
@@ -989,33 +1009,62 @@ static iBool handleWindowEvent_Window_(iWindow *d, const SDL_WindowEvent *ev) {
                is missing contents until other events trigger a refresh. */
             postRefresh_App();
 #if defined (LAGRANGE_ENABLE_WINDOWPOS_FIX)
-            if (d->initialPos.x >= 0) {
+            if (d->place.initialPos.x >= 0) {
                 int bx, by;
                 SDL_GetWindowBordersSize(d->win, &by, &bx, NULL, NULL);
-                SDL_SetWindowPosition(d->win, d->initialPos.x + bx, d->initialPos.y + by);
-                d->initialPos = init1_I2(-1);
+                SDL_SetWindowPosition(d->win, d->place.initialPos.x + bx, d->place.initialPos.y + by);
+                d->place.initialPos = init1_I2(-1);
             }
 #endif
             return iFalse;
         case SDL_WINDOWEVENT_MOVED: {
-            if (!isMaximized_Window_(d) && !isFullscreen_Window(d) && !d->isDrawFrozen) {
-                d->lastRect.pos = init_I2(ev->data1, ev->data2);
+            if (d->isMinimized) { 
+                return iFalse;
+            }
+            const iInt2 newPos = init_I2(ev->data1, ev->data2);
+            if (isEqual_I2(newPos, init1_I2(-32000))) { /* magic! */
+                /* Maybe minimized? Seems like a Windows constant of some kind. */
+                d->isMinimized = iTrue;
+                return iFalse;
+            }
+            //printf("MOVED: %d, %d\n", ev->data1, ev->data2); fflush(stdout);
+            if (unsnap_Window_(d, &newPos)) {
+                return iTrue;
+            }
+            if (isNormalPlacement_Window_(d)) {
+                d->place.normalRect.pos = newPos;
+                //printf("normal rect set (move)\n"); fflush(stdout);
                 iInt2 border = zero_I2();
 #if !defined (iPlatformApple)
                 SDL_GetWindowBordersSize(d->win, &border.y, &border.x, NULL, NULL);
 #endif
-                d->lastRect.pos = max_I2(zero_I2(), sub_I2(d->lastRect.pos, border));
+                d->place.normalRect.pos = max_I2(zero_I2(), sub_I2(d->place.normalRect.pos, border));
             }
             return iTrue;
         }
         case SDL_WINDOWEVENT_RESIZED:
-            if (!isMaximized_Window_(d) && !isFullscreen_Window(d) && !d->isDrawFrozen) {
-                d->lastRect.size = init_I2(ev->data1, ev->data2);
+            if (d->isMinimized) { 
+                updateRootSize_Window_(d, iTrue);
+                return iTrue;
+            }
+            if (unsnap_Window_(d, NULL)) {
+                return iTrue;
+            }
+            if (isNormalPlacement_Window_(d)) {
+                d->place.normalRect.size = init_I2(ev->data1, ev->data2);
+                //printf("normal rect set (resize)\n"); fflush(stdout);
             }
             updateRootSize_Window_(d, iTrue /* we were already redrawing during the resize */);
             return iTrue;
         case SDL_WINDOWEVENT_RESTORED:
+            //updateRootSize_Window_(d, iTrue);
             invalidate_Window_(d);
+            d->isMinimized = iFalse;
+            //printf("restored %d\n", snap_Window(d)); fflush(stdout);
+            return iTrue;
+        case SDL_WINDOWEVENT_MINIMIZED:
+            d->isMinimized = iTrue;
+            //printf("minimized\n"); fflush(stdout);
             return iTrue;
         case SDL_WINDOWEVENT_LEAVE:
             unhover_Widget();
@@ -1051,6 +1100,16 @@ static void applyCursor_Window_(iWindow *d) {
 
 iBool processEvent_Window(iWindow *d, const SDL_Event *ev) {
     switch (ev->type) {
+#if defined (LAGRANGE_CUSTOM_FRAME)
+        case SDL_SYSWMEVENT: {
+            /* We observe native Win32 messages for better user interaction with the 
+               window frame. Mouse clicks especially will not generate normal SDL 
+               events if they happen on the custom hit-tested regions. These events
+               are processed only there; the UI widgets do not get involved. */
+            processNativeEvent_Win32(ev->syswm.msg, d);
+            break;
+        }       
+#endif
         case SDL_WINDOWEVENT: {
             return handleWindowEvent_Window_(d, &ev->window);
         }
@@ -1232,3 +1291,89 @@ uint32_t frameTime_Window(const iWindow *d) {
 iWindow *get_Window(void) {
     return theWindow_;
 }
+
+#if !defined (LAGRANGE_CUSTOM_FRAME)
+void setSnap_Window(iWindow *d, int snapMode) {
+    if (snapMode == maximized_WindowSnap) {
+        SDL_MaximizeWindow(d->win);
+    }
+    else if (snapMode == fullscreen_WindowSnap) {
+        SDL_SetWindowFullscreen(d->win, SDL_WINDOW_FULLSCREEN_DESKTOP);
+    }
+    else {
+        SDL_RestoreWindow(d->win);
+    }
+}
+
+int snap_Window(const iWindow *d) {
+    const int flags = SDL_GetWindowFlags(d->win);
+    if (flags & SDL_WINDOW_FULLSCREEN_DESKTOP) {
+        return fullscreen_WindowSnap;
+    }
+    else if (flags & SDL_WINDOW_MAXIMIZED) {
+        return maximized_WindowSnap;
+    }
+    return none_WindowSnap;
+}
+#endif
+
+#if defined (LAGRANGE_CUSTOM_FRAME)
+void setSnap_Window(iWindow *d, int snapMode) {
+    if (d->place.snap == snapMode) {
+        return;
+    }
+    iRect newRect = zero_Rect();   
+    SDL_Rect usable;
+    SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(d->win), &usable);
+    if (d->place.snap == fullscreen_WindowSnap) {
+        SDL_SetWindowFullscreen(d->win, 0);
+    }
+    d->place.snap = snapMode;
+    switch (snapMode & mask_WindowSnap) {
+        case none_WindowSnap:
+            newRect = d->place.normalRect;
+            break;
+        case left_WindowSnap:
+            newRect = init_Rect(usable.x, usable.y, usable.w / 2, usable.h);
+            break;
+        case right_WindowSnap:
+            newRect = init_Rect(usable.x, usable.y + usable.w / 2, usable.w / 2, usable.h);
+            break;
+        case maximized_WindowSnap:
+            newRect = init_Rect(usable.x, usable.y, usable.w, usable.h);
+            break;
+        case yMaximized_WindowSnap:
+            newRect.pos.y = 0;
+            newRect.size.y = usable.h;
+            SDL_GetWindowPosition(d->win, &newRect.pos.x, NULL);
+            SDL_GetWindowSize(d->win, &newRect.size.x, NULL);
+            break;
+        case fullscreen_WindowSnap:
+            SDL_SetWindowFullscreen(d->win, SDL_WINDOW_FULLSCREEN_DESKTOP);
+            break;
+    }
+    if (snapMode & (topBit_WindowSnap | bottomBit_WindowSnap)) {
+        newRect.size.y /= 2;
+    }
+    if (snapMode & bottomBit_WindowSnap) {
+        newRect.pos.y += newRect.size.y;
+    }
+    /* Show and hide the title bar. */
+    iWidget *winBar = findWidget_App("winbar");
+    const iBool wasVisible = isVisible_Widget(winBar);
+    setFlags_Widget(winBar, hidden_WidgetFlag, snapMode == fullscreen_WindowSnap);
+    if (newRect.size.x) {
+        SDL_SetWindowPosition(d->win, newRect.pos.x, newRect.pos.y);
+        SDL_SetWindowSize(d->win, newRect.size.x, newRect.size.y);
+        postCommand_App("window.resized");
+    }
+    if (wasVisible != isVisible_Widget(winBar)) {
+        arrange_Widget(d->root);
+        postRefresh_App();
+    }
+}
+
+int snap_Window(const iWindow *d) {
+    return d->place.snap;
+}
+#endif
diff --git a/src/ui/window.h b/src/ui/window.h
index 5bde9065..ddb03847 100644
--- a/src/ui/window.h
+++ b/src/ui/window.h
@@ -32,13 +32,35 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 iDeclareType(Window)
 iDeclareTypeConstructionArgs(Window, iRect rect)
 
+enum iWindowSnap {
+    none_WindowSnap       = 0,
+    left_WindowSnap       = 1,
+    right_WindowSnap      = 2,
+    maximized_WindowSnap  = 3,
+    yMaximized_WindowSnap = 4,
+    fullscreen_WindowSnap = 5,
+    mask_WindowSnap       = 0xff,
+    topBit_WindowSnap     = iBit(9),
+    bottomBit_WindowSnap  = iBit(10),
+};
+
+iDeclareType(WindowPlacement)
+
+/* Tracking of window placement. */
+struct Impl_WindowPlacement {
+    iInt2 initialPos;
+    iRect normalRect;       /* updated when window is moved/resized */
+    iInt2 lastNotifiedSize; /* keep track of horizontal/vertical notifications */
+    int   snap;             /* LAGRANGE_CUSTOM_FRAME */
+    int   lastHit;
+};
+
 struct Impl_Window {
     SDL_Window *  win;
-    iInt2         initialPos;
-    iRect         lastRect; /* updated when window is moved/resized */
-    iInt2         lastNotifiedSize; /* keep track of horizontal/vertical notifications */
+    iWindowPlacement place;
     iBool         isDrawFrozen; /* avoids premature draws while restoring window state */
     iBool         isExposed;
+    iBool         isMinimized;
     iBool         isMouseInside;
     uint32_t      focusGainedAt;
     SDL_Renderer *render;
@@ -60,6 +82,7 @@ void        setTitle_Window         (iWindow *, const iString *title);
 void        setUiScale_Window       (iWindow *, float uiScale);
 void        setFreezeDraw_Window    (iWindow *, iBool freezeDraw);
 void        setCursor_Window        (iWindow *, int cursor);
+void        setSnap_Window          (iWindow *, int snapMode);
 
 uint32_t    id_Window               (const iWindow *);
 iInt2       rootSize_Window         (const iWindow *);
@@ -68,6 +91,11 @@ iInt2       coord_Window            (const iWindow *, int x, int y);
 iInt2       mouseCoord_Window       (const iWindow *);
 uint32_t    frameTime_Window        (const iWindow *);
 SDL_Renderer *renderer_Window       (const iWindow *);
+int         snap_Window             (const iWindow *);
 iBool       isFullscreen_Window     (const iWindow *);
 
 iWindow *   get_Window              (void);
+
+#if defined (LAGRANGE_CUSTOM_FRAME)
+SDL_HitTestResult hitTest_Window(const iWindow *d, iInt2 pos);
+#endif
diff --git a/src/win32.c b/src/win32.c
index 5eb2a0d5..585fdaaf 100644
--- a/src/win32.c
+++ b/src/win32.c
@@ -21,10 +21,13 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

 

 #include "win32.h"

+#include "ui/window.h"

+#include "app.h"

 #include <SDL_syswm.h>

 

 #define WIN32_LEAN_AND_MEAN

 #include <Windows.h>

+#include <windowsx.h>

 #include <d2d1.h>

 

 void setDPIAware_Win32(void) {

@@ -59,3 +62,53 @@ void useExecutableIconResource_SDLWindow(SDL_Window *win) {
         }

     }

 }

+

+#if 0

+void setup_SDLWindow(SDL_Window *win) {

+    SDL_SysWMinfo wmInfo;

+    SDL_VERSION(&wmInfo.version);

+    if (SDL_GetWindowWMInfo(win, &wmInfo)) {

+        HWND hwnd = wmInfo.info.win.window;

+//        printf("configuring window\n");

+//        SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) | WS_SYSMENU);

+    }

+}

+#endif

+

+#if defined (LAGRANGE_CUSTOM_FRAME)

+void processNativeEvent_Win32(const struct SDL_SysWMmsg *msg, iWindow *window) {

+    HWND hwnd = msg->msg.win.hwnd;

+//    printf("[syswm] %x\n", msg->msg.win.msg); fflush(stdout);

+    switch (msg->msg.win.msg) {

+        case WM_NCLBUTTONDBLCLK: {

+            POINT point = { GET_X_LPARAM(msg->msg.win.lParam), GET_Y_LPARAM(msg->msg.win.lParam) };

+            ScreenToClient(hwnd, &point);

+            iInt2 pos = init_I2(point.x, point.y);

+            switch (hitTest_Window(window, pos)) {

+                case SDL_HITTEST_DRAGGABLE:

+                    postCommand_App("window.maximize toggle:1");

+                    break;

+                case SDL_HITTEST_RESIZE_TOP:

+                case SDL_HITTEST_RESIZE_BOTTOM: {

+                    setSnap_Window(window, yMaximized_WindowSnap);

+                    break;

+                }

+            }

+            //fflush(stdout);

+            break;

+        }

+#if 0

+        /* SDL does not use WS_SYSMENU on the window, so we can't display the system menu.

+           However, the only useful function in the menu would be moving-via-keyboard,

+           but that doesn't work with a custom frame. We could show a custom system menu? */

+        case WM_NCRBUTTONUP: {

+            POINT point = { GET_X_LPARAM(msg->msg.win.lParam), GET_Y_LPARAM(msg->msg.win.lParam) };

+            HMENU menu = GetSystemMenu(hwnd, FALSE);

+            printf("menu at %d,%d menu:%p\n", point.x, point.y, menu); fflush(stdout);

+            TrackPopupMenu(menu, TPM_RIGHTBUTTON, point.x, point.y, 0, hwnd, NULL);

+            break;

+        }

+#endif

+    }

+}

+#endif /* defined (LAGRANGE_CUSTOM_FRAME) */

diff --git a/src/win32.h b/src/win32.h
index b5bc0b45..b988c302 100644
--- a/src/win32.h
+++ b/src/win32.h
@@ -21,8 +21,14 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

 

 #pragma once

+

+#include <the_Foundation/defs.h>

 #include <SDL_video.h>

+#include <SDL_syswm.h>

+

+iDeclareType(Window)

 

 void  setDPIAware_Win32(void);

 float desktopDPI_Win32(void);

 void  useExecutableIconResource_SDLWindow(SDL_Window *win);

+void  processNativeEvent_Win32(const struct SDL_SysWMmsg *msg, iWindow *window);