1 files changed, 458 insertions, 274 deletions

diff --git a/src/ui/window.c b/src/ui/window.c
index f8391ed9..066ea102 100644
--- a/src/ui/window.c
+++ b/src/ui/window.c
@@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 #include "keys.h"
 #include "labelwidget.h"
 #include "documentwidget.h"
+#include "sidebarwidget.h"
 #include "paint.h"
 #include "root.h"
 #include "touch.h"
@@ -57,7 +58,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 #include "stb_image.h"
 #include "stb_image_resize.h"
 
-static iWindow *theWindow_ = NULL;
+static iWindow *    theWindow_;
+static iMainWindow *theMainWindow_;
 
 #if defined (iPlatformApple) || defined (iPlatformLinux) || defined (iPlatformOther)
 static float initialUiScale_ = 1.0f;
@@ -67,7 +69,10 @@ static float initialUiScale_ = 1.1f;
 
 static iBool isOpenGLRenderer_;
 
-iDefineTypeConstructionArgs(Window, (iRect rect), rect)
+iDefineTypeConstructionArgs(Window,
+                            (enum iWindowType type, iRect rect, uint32_t flags),
+                            type, rect, flags)
+iDefineTypeConstructionArgs(MainWindow, (iRect rect), rect)
 
 /* TODO: Define menus per platform. */
 
@@ -116,6 +121,7 @@ static const iMenuItem viewMenuItems_[] = {
 static iMenuItem bookmarksMenuItems_[] = {
     { "${menu.page.bookmark}", SDLK_d, KMOD_PRIMARY, "bookmark.add" },
     { "${menu.page.subscribe}", subscribeToPage_KeyModifier, "feeds.subscribe" },
+    { "${menu.newfolder}", 0, 0, "bookmarks.addfolder" },
     { "---", 0, 0, NULL },
     { "${menu.import.links}", 0, 0, "bookmark.links confirm:1" },
     { "---", 0, 0, NULL },
@@ -124,6 +130,8 @@ static iMenuItem bookmarksMenuItems_[] = {
     { "${macos.menu.bookmarks.bytime}", 0, 0, "open url:about:bookmarks?created" },
     { "${menu.feeds.entrylist}", 0, 0, "open url:about:feeds" },
     { "---", 0, 0, NULL },
+    { "${menu.sort.alpha}", 0, 0, "bookmarks.sort" },
+    { "---", 0, 0, NULL },
     { "${menu.bookmarks.refresh}", 0, 0, "bookmarks.reload.remote" },
     { "${menu.feeds.refresh}", SDLK_r, KMOD_PRIMARY | KMOD_SHIFT, "feeds.refresh" },
 };
@@ -169,17 +177,17 @@ int numRoots_Window(const iWindow *d) {
     return num;
 }
 
-static void windowSizeChanged_Window_(iWindow *d) {
-    const int numRoots = numRoots_Window(d);
-    const iInt2 rootSize = d->size;
+static void windowSizeChanged_MainWindow_(iMainWindow *d) {
+    const int numRoots = numRoots_Window(as_Window(d));
+    const iInt2 rootSize = d->base.size;
     const int weights[2] = {
-        d->roots[0] ? (d->splitMode & twoToOne_WindowSplit ? 2 : 1) : 0,
-        d->roots[1] ? (d->splitMode & oneToTwo_WindowSplit ? 2 : 1) : 0,
+        d->base.roots[0] ? (d->splitMode & twoToOne_WindowSplit ? 2 : 1) : 0,
+        d->base.roots[1] ? (d->splitMode & oneToTwo_WindowSplit ? 2 : 1) : 0,
     };
     const int totalWeight = weights[0] + weights[1];
     int w = 0;
-    iForIndices(i, d->roots) {
-        iRoot *root = d->roots[i];
+    iForIndices(i, d->base.roots) {
+        iRoot *root = d->base.roots[i];
         if (root) {
             iRect *rect = &root->widget->rect;
             /* Horizontal split frame. */
@@ -199,26 +207,27 @@ static void windowSizeChanged_Window_(iWindow *d) {
     }
 }
 
-static void setupUserInterface_Window(iWindow *d) {
+static void setupUserInterface_MainWindow(iMainWindow *d) {
 #if defined (iHaveNativeMenus)
     insertMacMenus_();
 #endif
     /* One root is created by default. */
-    d->roots[0] = new_Root();
-    setCurrent_Root(d->roots[0]);
-    createUserInterface_Root(d->roots[0]);
+    d->base.roots[0] = new_Root();
+    d->base.roots[0]->window = as_Window(d);
+    setCurrent_Root(d->base.roots[0]);
+    createUserInterface_Root(d->base.roots[0]);
     setCurrent_Root(NULL);
     /* One of the roots always has keyboard input focus. */
-    d->keyRoot = d->roots[0];
+    d->base.keyRoot = d->base.roots[0];
 }
 
-static void updateSize_Window_(iWindow *d, iBool notifyAlways) {
-    iInt2 *size = &d->size;
+static void updateSize_MainWindow_(iMainWindow *d, iBool notifyAlways) {
+    iInt2 *size = &d->base.size;
     const iInt2 oldSize = *size;
-    SDL_GetRendererOutputSize(d->render, &size->x, &size->y);
+    SDL_GetRendererOutputSize(d->base.render, &size->x, &size->y);
     size->y -= d->keyboardHeight;
     if (notifyAlways || !isEqual_I2(oldSize, *size)) {
-        windowSizeChanged_Window_(d);
+        windowSizeChanged_MainWindow_(d);
         if (!isEqual_I2(*size, d->place.lastNotifiedSize)) {
             const iBool isHoriz = (d->place.lastNotifiedSize.x != size->x);
             const iBool isVert  = (d->place.lastNotifiedSize.y != size->y);
@@ -234,8 +243,8 @@ static void updateSize_Window_(iWindow *d, iBool notifyAlways) {
     }
 }
 
-void drawWhileResizing_Window(iWindow *d, int w, int h) {
-    draw_Window(d);        
+void drawWhileResizing_MainWindow(iMainWindow *d, int w, int h) {
+    draw_MainWindow(d);
 }
 
 static float pixelRatio_Window_(const iWindow *d) {
@@ -308,7 +317,7 @@ static iRoot *rootAt_Window_(const iWindow *d, iInt2 coord) {
 }
 
 #if defined (LAGRANGE_ENABLE_CUSTOM_FRAME)
-static SDL_HitTestResult hitTest_Window_(SDL_Window *win, const SDL_Point *pos, void *data) {
+static SDL_HitTestResult hitTest_MainWindow_(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 | SDL_WINDOW_FULLSCREEN_DESKTOP)) {
@@ -361,19 +370,22 @@ SDL_HitTestResult hitTest_Window(const iWindow *d, iInt2 pos) {
 #endif
 
 iBool create_Window_(iWindow *d, iRect rect, uint32_t flags) {
-    flags |= SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_HIDDEN;
+    flags |= SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_HIDDEN;
+    if (d->type == main_WindowType) {
+        flags |= SDL_WINDOW_RESIZABLE;
 #if defined (LAGRANGE_ENABLE_CUSTOM_FRAME)
-    if (prefs_App()->customFrame) {
-        /* We are drawing a custom frame so hide the default one. */
-        flags |= SDL_WINDOW_BORDERLESS;
-    }
+        if (prefs_App()->customFrame) {
+            /* We are drawing a custom frame so hide the default one. */
+            flags |= SDL_WINDOW_BORDERLESS;
+        }
 #endif
+    }
     if (SDL_CreateWindowAndRenderer(
             width_Rect(rect), height_Rect(rect), flags, &d->win, &d->render)) {
         return iFalse;
     }
 #if defined (LAGRANGE_ENABLE_CUSTOM_FRAME)
-    if (prefs_App()->customFrame) {
+    if (type_Window(d) == main_WindowType && prefs_App()->customFrame) {
         /* Register a handler for window hit testing (drag, resize). */
         SDL_SetWindowHitTest(d->win, hitTest_Window_, d);
         SDL_SetWindowResizable(d->win, SDL_TRUE);
@@ -397,40 +409,27 @@ static SDL_Surface *loadImage_(const iBlock *data, int resized) {
         pixels, w, h, 8 * num, w * num, SDL_PIXELFORMAT_RGBA32);
 }
 
-void init_Window(iWindow *d, iRect rect) {
-    theWindow_ = d;
-    d->win = NULL;
-    d->size = zero_I2(); /* will be updated below */
-    iZap(d->roots);
-    d->splitMode = d->pendingSplitMode = 0;
-    d->pendingSplitUrl = new_String();
-    d->hover = NULL;
-    d->mouseGrab = NULL;
-    d->focus = NULL;
-    iZap(d->cursors);
-    d->place.initialPos = rect.pos;
-    d->place.normalRect = rect;
-    d->place.lastNotifiedSize = zero_I2();
-    d->place.snap = 0;
+void init_Window(iWindow *d, enum iWindowType type, iRect rect, uint32_t flags) {
+    d->type          = type;
+    d->win           = NULL;
+    d->size          = zero_I2(); /* will be updated below */
+    d->hover         = NULL;
+    d->lastHover     = NULL;
+    d->mouseGrab     = NULL;
+    d->focus         = NULL;
     d->pendingCursor = NULL;
-    d->isDrawFrozen = iTrue;
-    d->isExposed = iFalse;
-    d->isMinimized = iFalse;
+    d->isExposed     = iFalse;
+    d->isMinimized   = iFalse;
     d->isInvalidated = iFalse; /* set when posting event, to avoid repeated events */
-    d->isMouseInside = iTrue;    
-    d->ignoreClick = iFalse;
+    d->isMouseInside = iTrue;
+    d->ignoreClick   = iFalse;
     d->focusGainedAt = 0;
-    d->keyboardHeight = 0;
-    init_Anim(&d->rootOffset, 0.0f);
-    uint32_t flags = 0;
-#if defined (iPlatformAppleDesktop)
-    SDL_SetHint(SDL_HINT_RENDER_DRIVER, shouldDefaultToMetalRenderer_MacOS() ? "metal" : "opengl");
-#elif defined (iPlatformAppleMobile)
-    SDL_SetHint(SDL_HINT_RENDER_DRIVER, "metal");
-#else
-    flags |= SDL_WINDOW_OPENGL;
-#endif
-    SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1");
+    d->presentTime   = 0.0;
+    d->frameTime     = SDL_GetTicks();
+    d->keyRoot       = NULL;
+    d->borderShadow  = NULL;
+    iZap(d->roots);
+    iZap(d->cursors);
     /* First try SDL's default renderer that should be the best option. */
     if (forceSoftwareRender_App() || !create_Window_(d, rect, flags)) {
         /* No luck, maybe software only? This should always work as long as there is a display. */
@@ -443,36 +442,95 @@ void init_Window(iWindow *d, iRect rect) {
     if (left_Rect(rect) >= 0 || top_Rect(rect) >= 0) {
         SDL_SetWindowPosition(d->win, left_Rect(rect), top_Rect(rect));
     }
+    SDL_GetRendererOutputSize(d->render, &d->size.x, &d->size.y);
+    drawBlank_Window_(d);
+    d->pixelRatio   = pixelRatio_Window_(d); /* point/pixel conversion */
+    d->displayScale = displayScale_Window_(d);
+    d->uiScale      = initialUiScale_;
+    /* TODO: Ratios, scales, and metrics must be window-specific, not global. */
+    setScale_Metrics(d->pixelRatio * d->displayScale * d->uiScale);
+    d->text = new_Text(d->render);
+}
+
+static void deinitRoots_Window_(iWindow *d) {
+    iRecycle();
+    iForIndices(i, d->roots) {
+        if (d->roots[i]) {
+            setCurrent_Root(d->roots[i]);
+            delete_Root(d->roots[i]);
+            d->roots[i] = NULL;
+        }
+    }
+    setCurrent_Root(NULL);
+}
+
+void deinit_Window(iWindow *d) {
+    if (d->type == popup_WindowType) {
+        removePopup_App(d);
+    }
+    deinitRoots_Window_(d);
+    delete_Text(d->text);
+    SDL_DestroyRenderer(d->render);
+    SDL_DestroyWindow(d->win);
+    iForIndices(i, d->cursors) {
+        if (d->cursors[i]) {
+            SDL_FreeCursor(d->cursors[i]);
+        }
+    }
+}
+
+void init_MainWindow(iMainWindow *d, iRect rect) {
+    theWindow_ = &d->base;
+    theMainWindow_ = d;
+    uint32_t flags = 0;
+#if defined (iPlatformAppleDesktop)
+    SDL_SetHint(SDL_HINT_RENDER_DRIVER, shouldDefaultToMetalRenderer_MacOS() ? "metal" : "opengl");
+#elif defined (iPlatformAppleMobile)
+    SDL_SetHint(SDL_HINT_RENDER_DRIVER, "metal");
+#else
+    flags |= SDL_WINDOW_OPENGL;
+#endif
+    SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1");
+    init_Window(&d->base, main_WindowType, rect, flags);
+    d->isDrawFrozen           = iTrue;
+    d->splitMode              = 0;
+    d->pendingSplitMode       = 0;
+    d->pendingSplitUrl        = new_String();
+    d->place.initialPos       = rect.pos;
+    d->place.normalRect       = rect;
+    d->place.lastNotifiedSize = zero_I2();
+    d->place.snap             = 0;
+    d->keyboardHeight         = 0;
+#if defined(iPlatformMobile)
+    const iInt2 minSize = zero_I2(); /* windows aren't independently resizable */
+#else
     const iInt2 minSize = init_I2(425, 325);
-    SDL_SetWindowMinimumSize(d->win, minSize.x, minSize.y);
-    SDL_SetWindowTitle(d->win, "Lagrange");
+#endif
+    SDL_SetWindowMinimumSize(d->base.win, minSize.x, minSize.y);
+    SDL_SetWindowTitle(d->base.win, "Lagrange");
     /* Some info. */ {
         SDL_RendererInfo info;
-        SDL_GetRendererInfo(d->render, &info);
+        SDL_GetRendererInfo(d->base.render, &info);
         isOpenGLRenderer_ = !iCmpStr(info.name, "opengl");
-        printf("[window] renderer: %s%s\n", info.name,
+        printf("[window] renderer: %s%s\n",
+               info.name,
                info.flags & SDL_RENDERER_ACCELERATED ? " (accelerated)" : "");
-#if !defined (NDEBUG)
+#if !defined(NDEBUG)
         printf("[window] max texture size: %d x %d\n",
                info.max_texture_width,
                info.max_texture_height);
         for (size_t i = 0; i < info.num_texture_formats; ++i) {
-            printf("[window] supported texture format: %s\n", SDL_GetPixelFormatName(
-                       info.texture_formats[i]));
+            printf("[window] supported texture format: %s\n",
+                   SDL_GetPixelFormatName(info.texture_formats[i]));
         }
 #endif
     }
-    drawBlank_Window_(d);
-    d->pixelRatio   = pixelRatio_Window_(d); /* point/pixel conversion */
-    d->displayScale = displayScale_Window_(d);
-    d->uiScale      = initialUiScale_;
-    setScale_Metrics(d->pixelRatio * d->displayScale * d->uiScale);
-#if defined (iPlatformMsys)
-    SDL_SetWindowMinimumSize(d->win, minSize.x * d->displayScale, minSize.y * d->displayScale);
-    useExecutableIconResource_SDLWindow(d->win);
+#if defined(iPlatformMsys)
+    SDL_SetWindowMinimumSize(d->base.win, minSize.x * d->base.displayScale, minSize.y * d->base.displayScale);
+    useExecutableIconResource_SDLWindow(d->base.win);
 #endif
 #if defined (iPlatformLinux)
-    SDL_SetWindowMinimumSize(d->win, minSize.x * d->pixelRatio, minSize.y * d->pixelRatio);
+    SDL_SetWindowMinimumSize(d->win, minSize.x * d->base.pixelRatio, minSize.y * d->base.pixelRatio);
     /* Load the window icon. */ {
         SDL_Surface *surf = loadImage_(&imageLagrange64_Embedded, 0);
         SDL_SetWindowIcon(d->win, surf);
@@ -481,20 +539,16 @@ void init_Window(iWindow *d, iRect rect) {
     }
 #endif
 #if defined (iPlatformAppleMobile)
-    setupWindow_iOS(d);
+    setupWindow_iOS(as_Window(d));
 #endif
-    d->presentTime = 0.0;
-    d->frameTime = SDL_GetTicks();
-    d->loadAnimTimer = 0;
-    init_Text(d->render);
-    SDL_GetRendererOutputSize(d->render, &d->size.x, &d->size.y);
-    setupUserInterface_Window(d);
+    setCurrent_Text(d->base.text);
+    SDL_GetRendererOutputSize(d->base.render, &d->base.size.x, &d->base.size.y);
+    setupUserInterface_MainWindow(d);
     postCommand_App("~bindings.changed"); /* update from bindings */
-    //updateSize_Window_(d, iFalse);
     /* Load the border shadow texture. */ {
         SDL_Surface *surf = loadImage_(&imageShadow_Embedded, 0);
-        d->borderShadow = SDL_CreateTextureFromSurface(d->render, surf);
-        SDL_SetTextureBlendMode(d->borderShadow, SDL_BLENDMODE_BLEND);
+        d->base.borderShadow = SDL_CreateTextureFromSurface(d->base.render, surf);
+        SDL_SetTextureBlendMode(d->base.borderShadow, SDL_BLENDMODE_BLEND);
         free(surf->pixels);
         SDL_FreeSurface(surf);
     }
@@ -504,36 +558,26 @@ void init_Window(iWindow *d, iRect rect) {
     if (prefs_App()->customFrame) {
         SDL_Surface *surf = loadImage_(&imageLagrange64_Embedded, appIconSize_Root());
         SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0");
-        d->appIcon = SDL_CreateTextureFromSurface(d->render, surf);
+        d->appIcon = SDL_CreateTextureFromSurface(d->base.render, surf);
         free(surf->pixels);
         SDL_FreeSurface(surf);
         /* We need to observe non-client-area events. */
         SDL_EventState(SDL_SYSWMEVENT, SDL_TRUE);
     }
 #endif
+    SDL_HideWindow(d->base.win);
 }
 
-void deinit_Window(iWindow *d) {
-    iRecycle();
-    iForIndices(i, d->roots) {
-        if (d->roots[i]) {
-            setCurrent_Root(d->roots[i]);
-            deinit_Root(d->roots[i]);
-        }
-    }
-    if (theWindow_ == d) {
+void deinit_MainWindow(iMainWindow *d) {
+    deinitRoots_Window_(as_Window(d));
+    if (theWindow_ == as_Window(d)) {
         theWindow_ = NULL;
     }
-    setCurrent_Root(NULL);
-    delete_String(d->pendingSplitUrl);
-    deinit_Text();
-    SDL_DestroyRenderer(d->render);
-    SDL_DestroyWindow(d->win);
-    iForIndices(i, d->cursors) {
-        if (d->cursors[i]) {
-            SDL_FreeCursor(d->cursors[i]);
-        }
+    if (theMainWindow_ == d) {
+        theMainWindow_ = NULL;
     }
+    delete_String(d->pendingSplitUrl);
+    deinit_Window(&d->base);
 }
 
 SDL_Renderer *renderer_Window(const iWindow *d) {
@@ -546,8 +590,8 @@ iInt2 maxTextureSize_Window(const iWindow *d) {
     return init_I2(info.max_texture_width, info.max_texture_height);
 }
 
-iBool isFullscreen_Window(const iWindow *d) {
-    return snap_Window(d) == fullscreen_WindowSnap;
+iBool isFullscreen_MainWindow(const iMainWindow *d) {
+    return snap_MainWindow(d) == fullscreen_WindowSnap;
 }
 
 iRoot *findRoot_Window(const iWindow *d, const iWidget *widget) {
@@ -566,36 +610,41 @@ iRoot *otherRoot_Window(const iWindow *d, iRoot *root) {
     return root == d->roots[0] && d->roots[1] ? d->roots[1] : d->roots[0];
 }
 
-static void invalidate_Window_(iWindow *d, iBool forced) {
-    if (d && (!d->isInvalidated || forced)) {
-        d->isInvalidated = iTrue;
-        resetFonts_Text();
+static void invalidate_MainWindow_(iMainWindow *d, iBool forced) {
+    if (d && (!d->base.isInvalidated || forced)) {
+        d->base.isInvalidated = iTrue;
+        resetFonts_Text(text_Window(d));
         postCommand_App("theme.changed auto:1"); /* forces UI invalidation */
     }
 }
 
-void invalidate_Window(iWindow *d) {
-    invalidate_Window_(d, iFalse);
+void invalidate_Window(iAnyWindow *d) {
+    if (type_Window(d) == main_WindowType) {
+        invalidate_MainWindow_(as_MainWindow(d), iFalse);
+    }
+    else {
+        iAssert(type_Window(d) == main_WindowType);
+    }
 }
 
-static iBool isNormalPlacement_Window_(const iWindow *d) {
+static iBool isNormalPlacement_MainWindow_(const iMainWindow *d) {
     if (d->isDrawFrozen) return iFalse;
 #if defined (iPlatformApple)
     /* Maximized mode is not special on macOS. */
-    if (snap_Window(d) == maximized_WindowSnap) {
+    if (snap_MainWindow(d) == maximized_WindowSnap) {
         return iTrue;
     }
 #endif
-    if (snap_Window(d)) return iFalse;
-    return !(SDL_GetWindowFlags(d->win) & SDL_WINDOW_MINIMIZED);
+    if (snap_MainWindow(d)) return iFalse;
+    return !(SDL_GetWindowFlags(d->base.win) & SDL_WINDOW_MINIMIZED);
 }
 
-static iBool unsnap_Window_(iWindow *d, const iInt2 *newPos) {
+static iBool unsnap_MainWindow_(iMainWindow *d, const iInt2 *newPos) {
 #if defined (LAGRANGE_ENABLE_CUSTOM_FRAME)
     if (!prefs_App()->customFrame) {
         return iFalse;
     }
-    const int snap = snap_Window(d);
+    const int snap = snap_MainWindow(d);
     if (snap == yMaximized_WindowSnap || snap == left_WindowSnap || snap == right_WindowSnap) {
         if (!newPos || (d->place.lastHit == SDL_HITTEST_RESIZE_LEFT ||
                         d->place.lastHit == SDL_HITTEST_RESIZE_RIGHT)) {
@@ -603,21 +652,21 @@ static iBool unsnap_Window_(iWindow *d, const iInt2 *newPos) {
         }
         if (newPos) {
             SDL_Rect usable;
-            SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(d->win), &usable);
+            SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(d->base.win), &usable);
             /* Snap to top. */
             if (snap == yMaximized_WindowSnap &&
                 iAbs(newPos->y - usable.y) < lineHeight_Text(uiContent_FontId) * 2) {
-                setSnap_Window(d, redo_WindowSnap | yMaximized_WindowSnap);
+                setSnap_MainWindow(d, redo_WindowSnap | yMaximized_WindowSnap);
                 return iFalse;
             }
         }
     }
     if (snap && snap != fullscreen_WindowSnap) {
-        if (snap_Window(d) == yMaximized_WindowSnap && newPos) {
+        if (snap_MainWindow(d) == yMaximized_WindowSnap && newPos) {
             d->place.normalRect.pos = *newPos;
         }
         //printf("unsnap\n"); fflush(stdout);
-        setSnap_Window(d, none_WindowSnap);
+        setSnap_MainWindow(d, none_WindowSnap);
         return iTrue;
     }
 #endif
@@ -627,7 +676,7 @@ static iBool unsnap_Window_(iWindow *d, const iInt2 *newPos) {
 static void notifyMetricsChange_Window_(const iWindow *d) {
     /* Dynamic UI metrics change. Widgets need to update themselves. */
     setScale_Metrics(d->pixelRatio * d->displayScale * d->uiScale);
-    resetFonts_Text();
+    resetFonts_Text(d->text);
     postCommand_App("metrics.changed");
 }
 
@@ -649,146 +698,178 @@ static void checkPixelRatioChange_Window_(iWindow *d) {
 }
 
 static iBool handleWindowEvent_Window_(iWindow *d, const SDL_WindowEvent *ev) {
+    if (ev->windowID != SDL_GetWindowID(d->win)) {
+        return iFalse;
+    }
     switch (ev->event) {
-#if defined (iPlatformDesktop)
         case SDL_WINDOWEVENT_EXPOSED:
-            if (!d->isExposed) {
-                drawBlank_Window_(d); /* avoid showing system-provided contents */
-                d->isExposed = iTrue;
-            }
+            d->isExposed = iTrue;
+            postRefresh_App();
+            return iTrue;
+        case SDL_WINDOWEVENT_RESTORED:
+        case SDL_WINDOWEVENT_SHOWN:
+            postRefresh_App();
+            return iTrue;
+        case SDL_WINDOWEVENT_FOCUS_LOST:
+            /* Popup windows are currently only used for menus. */
+            closeMenu_Widget(d->roots[0]->widget);
+            return iTrue;
+        case SDL_WINDOWEVENT_LEAVE:
+            unhover_Widget();
+            d->isMouseInside = iFalse;
+            //postCommand_App("window.mouse.exited");
+//            SDL_SetWindowInputFocus(mainWindow_App()->base.win);
+            printf("mouse leaves popup\n"); fflush(stdout);
+            //SDL_RaiseWindow(mainWindow_App()->base.win);
+            postRefresh_App();
+            return iTrue;
+        case SDL_WINDOWEVENT_ENTER:
+            d->isMouseInside = iTrue;
+            //postCommand_App("window.mouse.entered");
+            printf("mouse enters popup\n"); fflush(stdout);
+            return iTrue;
+    }
+    return iFalse;
+}
+
+static iBool handleWindowEvent_MainWindow_(iMainWindow *d, const SDL_WindowEvent *ev) {
+    switch (ev->event) {
+#if defined(iPlatformDesktop)
+        case SDL_WINDOWEVENT_EXPOSED:
+            d->base.isExposed = iTrue;
             /* Since we are manually controlling when to redraw the window, we are responsible
                for ensuring that window contents get redrawn after expose events. Under certain
                circumstances (e.g., under openbox), not doing this would mean that the window
                is missing contents until other events trigger a refresh. */
             postRefresh_App();
-#if defined (LAGRANGE_ENABLE_WINDOWPOS_FIX)
+#if defined(LAGRANGE_ENABLE_WINDOWPOS_FIX)
             if (d->place.initialPos.x >= 0) {
                 int bx, by;
                 SDL_GetWindowBordersSize(d->win, &by, &bx, NULL, NULL);
-                SDL_SetWindowPosition(d->win, d->place.initialPos.x + bx, d->place.initialPos.y + by);
+                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 (d->isMinimized) {
+            if (d->base.isMinimized) {
                 return iFalse;
             }
-            checkPixelRatioChange_Window_(d);
+            checkPixelRatioChange_Window_(as_Window(d));
             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;
+                d->base.isMinimized = iTrue;
                 return iFalse;
             }
-#if defined (LAGRANGE_ENABLE_CUSTOM_FRAME)
+#if defined(LAGRANGE_ENABLE_CUSTOM_FRAME)
             /* Set the snap position depending on where the mouse cursor is. */
             if (prefs_App()->customFrame) {
                 SDL_Rect usable;
-                iInt2 mouse = cursor_Win32(); /* SDL is unaware of the current cursor pos */
-                SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(d->win), &usable);
-                const iBool isTop = iAbs(mouse.y - usable.y) < gap_UI * 20;
+                iInt2    mouse = cursor_Win32(); /* SDL is unaware of the current cursor pos */
+                SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(d->base.win), &usable);
+                const iBool isTop    = iAbs(mouse.y - usable.y) < gap_UI * 20;
                 const iBool isBottom = iAbs(usable.y + usable.h - mouse.y) < gap_UI * 20;
                 if (iAbs(mouse.x - usable.x) < gap_UI) {
-                    setSnap_Window(d,
-                                   redo_WindowSnap | left_WindowSnap |
-                                       (isTop ? topBit_WindowSnap : 0) |
-                                       (isBottom ? bottomBit_WindowSnap : 0));
+                    setSnap_MainWindow(d,
+                                       redo_WindowSnap | left_WindowSnap |
+                                           (isTop ? topBit_WindowSnap : 0) |
+                                           (isBottom ? bottomBit_WindowSnap : 0));
                     return iTrue;
                 }
                 if (iAbs(mouse.x - usable.x - usable.w) < gap_UI) {
-                    setSnap_Window(d,
-                                   redo_WindowSnap | right_WindowSnap |
-                                       (isTop ? topBit_WindowSnap : 0) |
-                                       (isBottom ? bottomBit_WindowSnap : 0));
+                    setSnap_MainWindow(d,
+                                       redo_WindowSnap | right_WindowSnap |
+                                           (isTop ? topBit_WindowSnap : 0) |
+                                           (isBottom ? bottomBit_WindowSnap : 0));
                     return iTrue;
                 }
                 if (iAbs(mouse.y - usable.y) < 2) {
-                    setSnap_Window(d,
-                                   redo_WindowSnap | (d->place.lastHit == SDL_HITTEST_RESIZE_TOP
-                                                          ? yMaximized_WindowSnap
-                                                          : maximized_WindowSnap));
+                    setSnap_MainWindow(d,
+                                       redo_WindowSnap | (d->place.lastHit == SDL_HITTEST_RESIZE_TOP
+                                                              ? yMaximized_WindowSnap
+                                                              : maximized_WindowSnap));
                     return iTrue;
                 }
             }
 #endif /* defined LAGRANGE_ENABLE_CUSTOM_FRAME */
-            //printf("MOVED: %d, %d\n", ev->data1, ev->data2); fflush(stdout);
-            if (unsnap_Window_(d, &newPos)) {
+            if (unsnap_MainWindow_(d, &newPos)) {
                 return iTrue;
             }
-            if (isNormalPlacement_Window_(d)) {
+            if (isNormalPlacement_MainWindow_(d)) {
                 d->place.normalRect.pos = newPos;
-                //printf("normal rect set (move)\n"); fflush(stdout);
+                // 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);
+#if !defined(iPlatformApple)
+                SDL_GetWindowBordersSize(d->base.win, &border.y, &border.x, NULL, NULL);
 #endif
-                d->place.normalRect.pos = max_I2(zero_I2(), sub_I2(d->place.normalRect.pos, border));
+                d->place.normalRect.pos =
+                    max_I2(zero_I2(), sub_I2(d->place.normalRect.pos, border));
             }
             return iTrue;
         }
         case SDL_WINDOWEVENT_RESIZED:
-            if (d->isMinimized) {
-                //updateSize_Window_(d, iTrue);
+            if (d->base.isMinimized) {
+                // updateSize_Window_(d, iTrue);
                 return iTrue;
             }
-            if (unsnap_Window_(d, NULL)) {
+            if (unsnap_MainWindow_(d, NULL)) {
                 return iTrue;
             }
-            if (isNormalPlacement_Window_(d)) {
+            if (isNormalPlacement_MainWindow_(d)) {
                 d->place.normalRect.size = init_I2(ev->data1, ev->data2);
-                //printf("normal rect set (resize)\n"); fflush(stdout);
+                // printf("normal rect set (resize)\n"); fflush(stdout);
             }
-            checkPixelRatioChange_Window_(d);
-            //updateSize_Window_(d, iTrue /* we were already redrawing during the resize */);
+            checkPixelRatioChange_Window_(as_Window(d));
             postRefresh_App();
             return iTrue;
         case SDL_WINDOWEVENT_RESTORED:
         case SDL_WINDOWEVENT_SHOWN:
-            updateSize_Window_(d, iTrue);
-            invalidate_Window_(d, iTrue);
-            d->isMinimized = iFalse;
+            updateSize_MainWindow_(d, iTrue);
+            invalidate_MainWindow_(d, iTrue);
+            d->base.isMinimized = iFalse;
             postRefresh_App();
             return iTrue;
         case SDL_WINDOWEVENT_MINIMIZED:
-            d->isMinimized = iTrue;
+            d->base.isMinimized = iTrue;
+            return iTrue;
+#else /* if defined (!iPlatformDesktop) */
+        case SDL_WINDOWEVENT_RESIZED:
+            /* On mobile, this occurs when the display is rotated. */
+            invalidate_Window(d);
+            postRefresh_App();
             return iTrue;
-#endif /* defined (iPlatformDesktop) */
+#endif
         case SDL_WINDOWEVENT_LEAVE:
             unhover_Widget();
-            d->isMouseInside = iFalse;
+            d->base.isMouseInside = iFalse;
             postCommand_App("window.mouse.exited");
             return iTrue;
         case SDL_WINDOWEVENT_ENTER:
-            d->isMouseInside = iTrue;
+            d->base.isMouseInside = iTrue;
+            SDL_SetWindowInputFocus(d->base.win);
             postCommand_App("window.mouse.entered");
             return iTrue;
-#if defined (iPlatformMobile)
-        case SDL_WINDOWEVENT_RESIZED:
-            /* On mobile, this occurs when the display is rotated. */
-            invalidate_Window(d);
-            postRefresh_App();
-            return iTrue;
-#endif
         case SDL_WINDOWEVENT_FOCUS_GAINED:
-            d->focusGainedAt = SDL_GetTicks();
+            d->base.focusGainedAt = SDL_GetTicks();
             setCapsLockDown_Keys(iFalse);
             postCommand_App("window.focus.gained");
-            d->isExposed = iTrue;
-#if defined (iPlatformMobile)
+            d->base.isExposed = iTrue;
+#if !defined (iPlatformDesktop)
             /* Returned to foreground, may have lost buffered content. */
-            invalidate_Window_(d, iTrue);
+            invalidate_MainWindow_(d, iTrue);
             postCommand_App("window.unfreeze");
 #endif
             return iFalse;
         case SDL_WINDOWEVENT_FOCUS_LOST:
             postCommand_App("window.focus.lost");
-#if defined (iPlatformMobile)
-            setFreezeDraw_Window(d, iTrue);
+#if !defined (iPlatformDesktop)
+            setFreezeDraw_MainWindow(d, iTrue);
 #endif
             return iFalse;
         case SDL_WINDOWEVENT_TAKE_FOCUS:
-            SDL_SetWindowInputFocus(d->win);
+            SDL_SetWindowInputFocus(d->base.win);
             postRefresh_App();
             return iTrue;
         default:
@@ -805,6 +886,7 @@ static void applyCursor_Window_(iWindow *d) {
 }
 
 iBool processEvent_Window(iWindow *d, const SDL_Event *ev) {
+    iMainWindow *mw = (type_Window(d) == main_WindowType ? as_MainWindow(d) : NULL);
     switch (ev->type) {
 #if defined (LAGRANGE_ENABLE_CUSTOM_FRAME)
         case SDL_SYSWMEVENT: {
@@ -817,21 +899,28 @@ iBool processEvent_Window(iWindow *d, const SDL_Event *ev) {
         }
 #endif
         case SDL_WINDOWEVENT: {
-            return handleWindowEvent_Window_(d, &ev->window);
+            if (mw) {
+                return handleWindowEvent_MainWindow_(mw, &ev->window);
+            }
+            else {
+                return handleWindowEvent_Window_(d, &ev->window);
+            }
         }
         case SDL_RENDER_TARGETS_RESET:
         case SDL_RENDER_DEVICE_RESET: {
-            invalidate_Window_(d, iTrue /* force full reset */);
+            if (mw) {
+                invalidate_MainWindow_(mw, iTrue /* force full reset */);
+            }
             break;
         }
         default: {
             SDL_Event event = *ev;
-            if (event.type == SDL_USEREVENT && isCommand_UserEvent(ev, "window.unfreeze")) {
-                d->isDrawFrozen = iFalse;
+            if (event.type == SDL_USEREVENT && isCommand_UserEvent(ev, "window.unfreeze") && mw) {
+                mw->isDrawFrozen = iFalse;
                 if (SDL_GetWindowFlags(d->win) & SDL_WINDOW_HIDDEN) {
                     SDL_ShowWindow(d->win);
                 }
-                postRefresh_App();
+                draw_MainWindow(mw); /* don't show a frame of placeholder content */
                 postCommand_App("media.player.update"); /* in case a player needs updating */
                 return iTrue;
             }
@@ -873,7 +962,7 @@ iBool processEvent_Window(iWindow *d, const SDL_Event *ev) {
                     }
                 }
             }
-            const iWidget *oldHover = d->hover;
+//            const iWidget *oldHover = d->hover;
             iBool wasUsed = iFalse;
             /* Dispatch first to the mouse-grabbed widget. */
 //            iWidget *widget = d->root.widget;
@@ -913,7 +1002,7 @@ iBool processEvent_Window(iWindow *d, const SDL_Event *ev) {
                     updateMetrics_Root(d->roots[i]);
                 }
             }
-            if (isCommand_UserEvent(&event, "lang.changed")) {
+            if (isCommand_UserEvent(&event, "lang.changed") && mw) {
 #if defined (iHaveNativeMenus)
                 /* Retranslate the menus. */
                 removeMacMenus_();
@@ -927,9 +1016,6 @@ iBool processEvent_Window(iWindow *d, const SDL_Event *ev) {
                     }
                 }
             }
-            if (oldHover != d->hover) {
-                postRefresh_App();
-            }
             if (event.type == SDL_MOUSEMOTION) {
                 applyCursor_Window_(d);
             }
@@ -949,6 +1035,10 @@ iBool setKeyRoot_Window(iWindow *d, iRoot *root) {
     return iFalse;
 }
 
+iLocalDef iBool isEscapeKeypress_(const SDL_Event *ev) {
+    return (ev->type == SDL_KEYDOWN || ev->type == SDL_KEYUP) && ev->key.keysym.sym == SDLK_ESCAPE;
+}
+
 iBool dispatchEvent_Window(iWindow *d, const SDL_Event *ev) {
     if (ev->type == SDL_MOUSEMOTION) {
         /* Hover widget may change. */
@@ -964,12 +1054,19 @@ iBool dispatchEvent_Window(iWindow *d, const SDL_Event *ev) {
             }
             if ((ev->type == SDL_KEYDOWN || ev->type == SDL_KEYUP || ev->type == SDL_TEXTINPUT)
                      && d->keyRoot != root) {
-                continue; /* Key events go only to the root with keyboard focus. */
+                if (!isEscapeKeypress_(ev)) {
+                    /* Key events go only to the root with keyboard focus, with the exception
+                       of Escape that will also affect the entire window. */
+                    continue;
+                }
             }
             if (ev->type == SDL_MOUSEWHEEL && !contains_Rect(rect_Root(root),
                                                              coord_MouseWheelEvent(&ev->wheel))) {
                 continue; /* Only process the event in the relevant split. */
             }
+            if (!root->widget) {
+                continue;
+            }
             setCurrent_Root(root);
             const iBool wasUsed = dispatchEvent_Widget(root->widget, ev);
             if (wasUsed) {
@@ -1012,32 +1109,60 @@ iBool postContextClick_Window(iWindow *d, const SDL_MouseButtonEvent *ev) {
 }
 
 void draw_Window(iWindow *d) {
+    if (SDL_GetWindowFlags(d->win) & SDL_WINDOW_HIDDEN) {
+        return;
+    }
+    iPaint p;
+    init_Paint(&p);
+    iRoot *root = d->roots[0];
+    setCurrent_Root(root);
+    unsetClip_Paint(&p); /* update clip to full window */
+    const iColor back = get_Color(uiBackground_ColorId);
+    SDL_SetRenderDrawColor(d->render, back.r, back.g, back.b, 255);
+    SDL_RenderClear(d->render);
+    d->frameTime = SDL_GetTicks();
+    if (isExposed_Window(d)) {
+        d->isInvalidated = iFalse;
+        extern int drawCount_;
+        drawRoot_Widget(root->widget);
+#if !defined (NDEBUG)
+        draw_Text(defaultBold_FontId, safeRect_Root(root).pos, red_ColorId, "%d", drawCount_);
+        drawCount_ = 0;
+#endif
+    }
+//    drawRectThickness_Paint(&p, (iRect){ zero_I2(), sub_I2(d->size, one_I2()) }, gap_UI / 4, uiSeparator_ColorId);
+    setCurrent_Root(NULL);
+    SDL_RenderPresent(d->render);
+}
+
+void draw_MainWindow(iMainWindow *d) {
+    /* TODO: Try to make this a specialization of `draw_Window`? */
+    iWindow *w = as_Window(d);
     if (d->isDrawFrozen) {
         return;
     }
-//#if defined (iPlatformMobile)
+    setCurrent_Text(d->base.text);
     /* Check if root needs resizing. */ {
         iInt2 renderSize;
-        SDL_GetRendererOutputSize(d->render, &renderSize.x, &renderSize.y);
-        if (!isEqual_I2(renderSize, d->size)) {
-            updateSize_Window_(d, iTrue);
+        SDL_GetRendererOutputSize(w->render, &renderSize.x, &renderSize.y);
+        if (!isEqual_I2(renderSize, w->size)) {
+            updateSize_MainWindow_(d, iTrue);
             processEvents_App(postedEventsOnly_AppEventMode);
         }
     }
-//#endif
-    const int   winFlags = SDL_GetWindowFlags(d->win);
+    const int   winFlags = SDL_GetWindowFlags(d->base.win);
     const iBool gotFocus = (winFlags & SDL_WINDOW_INPUT_FOCUS) != 0;
     iPaint p;
     init_Paint(&p);
     /* Clear the window. The clear color is visible as a border around the window
        when the custom frame is being used. */ {
-        setCurrent_Root(d->roots[0]);
-#if defined (iPlatformAppleMobile)
-       iColor back = get_Color(uiBackground_ColorId);
-       if (deviceType_App() == phone_AppDeviceType) {
-           /* Page background extends to safe area, so fill it completely. */
-           back = get_Color(tmBackground_ColorId);
-       }
+        setCurrent_Root(w->roots[0]);
+#if defined (iPlatformMobile)
+        iColor back = get_Color(uiBackground_ColorId);
+        if (deviceType_App() == phone_AppDeviceType) {
+            /* Page background extends to safe area, so fill it completely. */
+            back = get_Color(tmBackground_ColorId);
+        }
 #else
         const iColor back = get_Color(gotFocus && d->place.snap != maximized_WindowSnap &&
                                               ~winFlags & SDL_WINDOW_FULLSCREEN_DESKTOP
@@ -1045,19 +1170,20 @@ void draw_Window(iWindow *d) {
                                           : uiSeparator_ColorId);
 #endif
         unsetClip_Paint(&p); /* update clip to full window */
-        SDL_SetRenderDrawColor(d->render, back.r, back.g, back.b, 255);
-        SDL_RenderClear(d->render);
+        SDL_SetRenderDrawColor(w->render, back.r, back.g, back.b, 255);
+        SDL_RenderClear(w->render);
     }
     /* Draw widgets. */
-    d->frameTime = SDL_GetTicks();
-    if (isExposed_Window(d)) {
-        d->isInvalidated = iFalse;
-        iForIndices(i, d->roots) {
-            iRoot *root = d->roots[i];
+    w->frameTime = SDL_GetTicks();
+    if (isExposed_Window(w)) {
+        w->isInvalidated = iFalse;
+        extern int drawCount_;
+        iForIndices(i, w->roots) {
+            iRoot *root = w->roots[i];
             if (root) {
                 setCurrent_Root(root);
                 unsetClip_Paint(&p); /* update clip to current root */
-                draw_Widget(root->widget);
+                drawRoot_Widget(root->widget);
 #if defined (LAGRANGE_ENABLE_CUSTOM_FRAME)
                 /* App icon. */
                 const iWidget *appIcon = findChild_Widget(root->widget, "winbar.icon");
@@ -1070,14 +1196,14 @@ void draw_Window(iWindow *d) {
                     SDL_SetTextureColorMod(d->appIcon, iconColor.r, iconColor.g, iconColor.b);
                     SDL_SetTextureAlphaMod(d->appIcon, gotFocus || !isLight ? 255 : 92);
                     SDL_RenderCopy(
-                        d->render,
+                        w->render,
                         d->appIcon,
                         NULL,
                         &(SDL_Rect){ left_Rect(rect) + gap_UI * 1.25f, mid.y - size / 2, size, size });
                 }
 #endif
                 /* Root separator and keyboard focus indicator. */
-                if (numRoots_Window(d) > 1){
+                if (numRoots_Window(w) > 1){
                     const iRect bounds = bounds_Widget(root->widget);
                     if (i == 1) {
                         fillRect_Paint(&p, (iRect){
@@ -1085,7 +1211,7 @@ void draw_Window(iWindow *d) {
                             init_I2(gap_UI / 4, height_Rect(bounds))
                         }, uiSeparator_ColorId);
                     }
-                    if (root == d->keyRoot) {
+                    if (root == w->keyRoot) {
                         const iBool isDark = isDark_ColorTheme(colorTheme_App());
                         fillRect_Paint(&p, (iRect){
                             topLeft_Rect(bounds),
@@ -1097,6 +1223,10 @@ void draw_Window(iWindow *d) {
             }
         }
         setCurrent_Root(NULL);
+#if !defined (NDEBUG)
+        draw_Text(defaultBold_FontId, safeRect_Root(w->roots[0]).pos, red_ColorId, "%d", drawCount_);
+        drawCount_ = 0;
+#endif
     }
 #if 0
     /* Text cache debugging. */ {
@@ -1106,21 +1236,21 @@ void draw_Window(iWindow *d) {
         SDL_RenderCopy(d->render, glyphCache_Text(), NULL, &rect);
     }
 #endif
-    SDL_RenderPresent(d->render);
+    SDL_RenderPresent(w->render);
 }
 
-void resize_Window(iWindow *d, int w, int h) {
+void resize_MainWindow(iMainWindow *d, int w, int h) {
     if (w > 0 && h > 0) {
-        SDL_SetWindowSize(d->win, w, h);
-        updateSize_Window_(d, iFalse);
+        SDL_SetWindowSize(d->base.win, w, h);
+        updateSize_MainWindow_(d, iFalse);
     }
     else {
-        updateSize_Window_(d, iTrue); /* notify always */
+        updateSize_MainWindow_(d, iTrue); /* notify always */
     }
 }
 
-void setTitle_Window(iWindow *d, const iString *title) {
-    SDL_SetWindowTitle(d->win, cstr_String(title));
+void setTitle_MainWindow(iMainWindow *d, const iString *title) {
+    SDL_SetWindowTitle(d->base.win, cstr_String(title));
     iLabelWidget *bar = findChild_Widget(get_Root()->widget, "winbar.title");
     if (bar) {
         updateText_LabelWidget(bar, title);
@@ -1128,6 +1258,9 @@ void setTitle_Window(iWindow *d, const iString *title) {
 }
 
 void setUiScale_Window(iWindow *d, float uiScale) {
+    if (uiScale <= 0.0f) {
+        uiScale = 1.0f;
+    }
     uiScale = iClamp(uiScale, 0.5f, 4.0f);
     if (d) {
         if (iAbs(d->uiScale - uiScale) > 0.0001f) {
@@ -1140,7 +1273,7 @@ void setUiScale_Window(iWindow *d, float uiScale) {
     }
 }
 
-void setFreezeDraw_Window(iWindow *d, iBool freezeDraw) {
+void setFreezeDraw_MainWindow(iMainWindow *d, iBool freezeDraw) {
     d->isDrawFrozen = freezeDraw;
 }
 
@@ -1191,63 +1324,80 @@ iWindow *get_Window(void) {
     return theWindow_;
 }
 
+void setCurrent_Window(iAnyWindow *d) {
+    theWindow_ = d;
+    if (type_Window(d) == main_WindowType) {
+        theMainWindow_ = d;
+    }
+    if (d) {
+        setCurrent_Text(theWindow_->text);
+        setCurrent_Root(theWindow_->keyRoot);
+    }
+    else {
+        setCurrent_Text(NULL);
+        setCurrent_Root(NULL);
+    }
+}
+
+iMainWindow *get_MainWindow(void) {
+    return theMainWindow_;
+}
+
 iBool isOpenGLRenderer_Window(void) {
     return isOpenGLRenderer_;
 }
 
-void setKeyboardHeight_Window(iWindow *d, int height) {
+void setKeyboardHeight_MainWindow(iMainWindow *d, int height) {
     if (d->keyboardHeight != height) {
         d->keyboardHeight = height;
-        if (height == 0) {
-            setFlags_Anim(&d->rootOffset, easeBoth_AnimFlag, iTrue);
-            setValue_Anim(&d->rootOffset, 0, 250);
-        }
         postCommandf_App("keyboard.changed arg:%d", height);
         postRefresh_App();
     }
 }
 
-void checkPendingSplit_Window(iWindow *d) {
+void checkPendingSplit_MainWindow(iMainWindow *d) {
     if (d->splitMode != d->pendingSplitMode) {
-        setSplitMode_Window(d, d->pendingSplitMode);
+        setSplitMode_MainWindow(d, d->pendingSplitMode);
     }
 }
 
-void swapRoots_Window(iWindow *d) {
-    if (numRoots_Window(d) == 2) {
-        iSwap(iRoot *, d->roots[0], d->roots[1]);
-        updateSize_Window_(d, iTrue);
+void swapRoots_MainWindow(iMainWindow *d) {
+    iWindow *w = as_Window(d);
+    if (numRoots_Window(w) == 2) {
+        iSwap(iRoot *, w->roots[0], w->roots[1]);
+        updateSize_MainWindow_(d, iTrue);
     }
 }
 
-void setSplitMode_Window(iWindow *d, int splitFlags) {
+void setSplitMode_MainWindow(iMainWindow *d, int splitFlags) {
     const int splitMode = splitFlags & mode_WindowSplit;
     if (deviceType_App() == phone_AppDeviceType) {
         /* There isn't enough room on the phone. */
         /* TODO: Maybe in landscape only? */
         return;
     }
+    iWindow *w = as_Window(d);
     iAssert(current_Root() == NULL);
     if (d->splitMode != splitMode) {
-        int oldCount = numRoots_Window(d);
-        setFreezeDraw_Window(d, iTrue);
+        int oldCount = numRoots_Window(w);
+        setFreezeDraw_MainWindow(d, iTrue);
         if (oldCount == 2 && splitMode == 0) {
             /* Keep references to the tabs of the second root. */
-            const iDocumentWidget *curPage = document_Root(d->keyRoot);
+            const iDocumentWidget *curPage = document_Root(w->keyRoot);
             if (!curPage) {
                 /* All tabs closed on that side. */
-                curPage = document_Root(otherRoot_Window(d, d->keyRoot));
+                curPage = document_Root(otherRoot_Window(w, w->keyRoot));
             }
-            iObjectList *tabs = listDocuments_App(d->roots[1]);
+            iObjectList *tabs = listDocuments_App(w->roots[1]);
             iForEach(ObjectList, i, tabs) {
-                setRoot_Widget(i.object, d->roots[0]);
+                setRoot_Widget(i.object, w->roots[0]);
             }
             setFocus_Widget(NULL);
-            delete_Root(d->roots[1]);
-            d->roots[1] = NULL;
-            d->keyRoot = d->roots[0];
+            delete_Root(w->roots[1]);
+            w->roots[1] = NULL;
+            w->keyRoot = w->roots[0];
             /* Move the deleted root's tabs to the first root. */
-            setCurrent_Root(d->roots[0]);
+            setCurrent_Root(w->roots[0]);
             iWidget *docTabs = findWidget_Root("doctabs");
             iForEach(ObjectList, j, tabs) {
                 appendTabPage_Widget(docTabs, j.object, "", 0, 0);
@@ -1259,38 +1409,48 @@ void setSplitMode_Window(iWindow *d, int splitFlags) {
         }
         else if (splitMode && oldCount == 1) {
             /* Add a second root. */
-            iDocumentWidget *moved = document_Root(d->roots[0]);
-            iAssert(d->roots[1] == NULL);
+            iDocumentWidget *moved = document_Root(w->roots[0]);
+            iAssert(w->roots[1] == NULL);
             const iBool addToLeft = (prefs_App()->pinSplit == 2);
             size_t newRootIndex = 1;
             if (addToLeft) {
-                iSwap(iRoot *, d->roots[0], d->roots[1]);
+                iSwap(iRoot *, w->roots[0], w->roots[1]);
                 newRootIndex = 0;
             }
-            d->roots[newRootIndex] = new_Root();
-            d->keyRoot             = d->roots[newRootIndex];
-            setCurrent_Root(d->roots[newRootIndex]);
-            createUserInterface_Root(d->roots[newRootIndex]);
+            w->roots[newRootIndex] = new_Root();
+            w->keyRoot             = w->roots[newRootIndex];
+            w->keyRoot->window     = w;
+            setCurrent_Root(w->roots[newRootIndex]);
+            createUserInterface_Root(w->roots[newRootIndex]);
+            /* Bookmark folder state will match the old root's state. */ {
+                for (int sb = 0; sb < 2; sb++) {
+                    const char *sbId = (sb == 0 ? "sidebar" : "sidebar2");
+                    setClosedFolders_SidebarWidget(
+                        findChild_Widget(w->roots[newRootIndex]->widget, sbId),
+                        closedFolders_SidebarWidget(
+                            findChild_Widget(w->roots[newRootIndex ^ 1]->widget, sbId)));
+                }
+            }
             if (!isEmpty_String(d->pendingSplitUrl)) {
-                postCommandf_Root(d->roots[newRootIndex], "open url:%s",
+                postCommandf_Root(w->roots[newRootIndex], "open url:%s",
                                   cstr_String(d->pendingSplitUrl));
                 clear_String(d->pendingSplitUrl);
             }
             else if (~splitFlags & noEvents_WindowSplit) {
-                iWidget *docTabs0 = findChild_Widget(d->roots[newRootIndex ^ 1]->widget, "doctabs");
-                iWidget *docTabs1 = findChild_Widget(d->roots[newRootIndex]->widget, "doctabs");
+                iWidget *docTabs0 = findChild_Widget(w->roots[newRootIndex ^ 1]->widget, "doctabs");
+                iWidget *docTabs1 = findChild_Widget(w->roots[newRootIndex]->widget, "doctabs");
                 /* If the old root has multiple tabs, move the current one to the new split. */
                 if (tabCount_Widget(docTabs0) >= 2) {
                     int movedIndex = tabPageIndex_Widget(docTabs0, moved);
                     removeTabPage_Widget(docTabs0, movedIndex);
                     showTabPage_Widget(docTabs0, tabPage_Widget(docTabs0, iMax(movedIndex - 1, 0)));
                     iRelease(removeTabPage_Widget(docTabs1, 0)); /* delete the default tab */
-                    setRoot_Widget(as_Widget(moved), d->roots[newRootIndex]);
+                    setRoot_Widget(as_Widget(moved), w->roots[newRootIndex]);
                     prependTabPage_Widget(docTabs1, iClob(moved), "", 0, 0);
                     postCommandf_App("tabs.switch page:%p", moved);
                 }
                 else {
-                    postCommand_Root(d->roots[newRootIndex], "navigate.home");
+                    postCommand_Root(w->roots[newRootIndex], "navigate.home");
                 }
             }
             setCurrent_Root(NULL);
@@ -1319,26 +1479,26 @@ void setSplitMode_Window(iWindow *d, int splitFlags) {
         }
 #endif
         if (~splitFlags & noEvents_WindowSplit) {
-            updateSize_Window_(d, iTrue);
+            updateSize_MainWindow_(d, iTrue);
             postCommand_App("window.unfreeze");
         }
     }
 }
 
-void setSnap_Window(iWindow *d, int snapMode) {
+void setSnap_MainWindow(iMainWindow *d, int snapMode) {
     if (!prefs_App()->customFrame) {
         if (snapMode == maximized_WindowSnap) {
-            SDL_MaximizeWindow(d->win);
+            SDL_MaximizeWindow(d->base.win);
         }
         else if (snapMode == fullscreen_WindowSnap) {
-            SDL_SetWindowFullscreen(d->win, SDL_WINDOW_FULLSCREEN_DESKTOP);
+            SDL_SetWindowFullscreen(d->base.win, SDL_WINDOW_FULLSCREEN_DESKTOP);
         }
         else {
-            if (snap_Window(d) == fullscreen_WindowSnap) {
-                SDL_SetWindowFullscreen(d->win, 0);
+            if (snap_MainWindow(d) == fullscreen_WindowSnap) {
+                SDL_SetWindowFullscreen(d->base.win, 0);
             }
             else {
-                SDL_RestoreWindow(d->win);
+                SDL_RestoreWindow(d->base.win);
             }
         }
         return;
@@ -1350,9 +1510,9 @@ void setSnap_Window(iWindow *d, int snapMode) {
     const int snapDist = gap_UI * 4;
     iRect newRect = zero_Rect();
     SDL_Rect usable;
-    SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(d->win), &usable);
+    SDL_GetDisplayUsableBounds(SDL_GetWindowDisplayIndex(d->base.win), &usable);
     if (d->place.snap == fullscreen_WindowSnap) {
-        SDL_SetWindowFullscreen(d->win, 0);
+        SDL_SetWindowFullscreen(d->base.win, 0);
     }
     d->place.snap = snapMode & ~redo_WindowSnap;
     switch (snapMode & mask_WindowSnap) {
@@ -1373,8 +1533,8 @@ void setSnap_Window(iWindow *d, int snapMode) {
         case yMaximized_WindowSnap:
             newRect.pos.y = 0;
             newRect.size.y = usable.h;
-            SDL_GetWindowSize(d->win, &newRect.size.x, NULL);
-            SDL_GetWindowPosition(d->win, &newRect.pos.x, NULL);
+            SDL_GetWindowSize(d->base.win, &newRect.size.x, NULL);
+            SDL_GetWindowPosition(d->base.win, &newRect.pos.x, NULL);
             /* Snap the window to left/right edges, if close by. */
             if (iAbs(right_Rect(newRect) - (usable.x + usable.w)) < snapDist) {
                 newRect.pos.x = usable.x + usable.w - width_Rect(newRect);
@@ -1384,7 +1544,7 @@ void setSnap_Window(iWindow *d, int snapMode) {
             }
             break;
         case fullscreen_WindowSnap:
-            SDL_SetWindowFullscreen(d->win, SDL_WINDOW_FULLSCREEN_DESKTOP);
+            SDL_SetWindowFullscreen(d->base.win, SDL_WINDOW_FULLSCREEN_DESKTOP);
             break;
     }
     if (snapMode & (topBit_WindowSnap | bottomBit_WindowSnap)) {
@@ -1416,9 +1576,9 @@ void setSnap_Window(iWindow *d, int snapMode) {
 #endif /* defined (LAGRANGE_ENABLE_CUSTOM_FRAME) */
 }
 
-int snap_Window(const iWindow *d) {
+int snap_MainWindow(const iMainWindow *d) {
     if (!prefs_App()->customFrame) {
-        const int flags = SDL_GetWindowFlags(d->win);
+        const int flags = SDL_GetWindowFlags(d->base.win);
         if (flags & SDL_WINDOW_FULLSCREEN_DESKTOP) {
             return fullscreen_WindowSnap;
         }
@@ -1429,3 +1589,27 @@ int snap_Window(const iWindow *d) {
     }
     return d->place.snap;
 }
+
+/*----------------------------------------------------------------------------------------------*/
+
+iWindow *newPopup_Window(iInt2 screenPos, iWidget *rootWidget) {
+    iWindow *win =
+        new_Window(popup_WindowType,
+                   (iRect){ screenPos, divf_I2(rootWidget->rect.size, get_Window()->pixelRatio) },
+                   SDL_WINDOW_ALWAYS_ON_TOP |
+#if !defined (iPlatformAppleDesktop)
+                   SDL_WINDOW_BORDERLESS |
+#endif
+                   SDL_WINDOW_POPUP_MENU |
+                   SDL_WINDOW_SKIP_TASKBAR);
+#if defined (iPlatformAppleDesktop)
+    hideTitleBar_MacOS(win); /* make it a borderless window */
+#endif
+    iRoot *root   = new_Root();
+    win->roots[0] = root;
+    win->keyRoot  = root;
+    root->widget  = rootWidget;
+    root->window  = win;
+    setRoot_Widget(rootWidget, root);
+    return win;
+}