Windows: Custom frame behavior

A borderless SDL window gets no standard window behavior, so
this commit implements support for some of them. There is
special handling for the window frame and various snapping modes.

Not quite finished yet... It might make sense to research if
a custom window class could work with this app (with SDL); could be
less work.

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);