Working on multiple UI roots

Root focus switching and opening links in the other root.

9 files changed, 96 insertions, 29 deletions

diff --git a/src/ui/documentwidget.c b/src/ui/documentwidget.c
index 2f20958f..1d6c340c 100644
--- a/src/ui/documentwidget.c
+++ b/src/ui/documentwidget.c
@@ -845,7 +845,8 @@ static void updateVisible_DocumentWidget_(iDocumentWidget *d) {
 }
 
 static void updateWindowTitle_DocumentWidget_(const iDocumentWidget *d) {
-    iLabelWidget *tabButton = tabPageButton_Widget(findWidget_App("doctabs"), d);
+    iLabelWidget *tabButton = tabPageButton_Widget(findChild_Widget(root_Widget(constAs_Widget(d)),
+                                                                    "doctabs"), d);
     if (!tabButton) {
         /* Not part of the UI at the moment. */
         return;
@@ -2868,8 +2869,16 @@ static iBool processEvent_DocumentWidget_(iDocumentWidget *d, const SDL_Event *e
                                 { openTabBg_Icon " ${link.newtab.background}",
                                   0,
                                   0,
-                                  format_CStr("!open newtab:2 url:%s", cstr_String(linkUrl)) } },
-                            2);
+                                  format_CStr("!open newtab:2 url:%s", cstr_String(linkUrl)) },
+                                { "${link.side}",
+                                  0,
+                                  0,
+                                  format_CStr("!open newtab:4 url:%s", cstr_String(linkUrl)) },
+                                { "${link.side.newtab}",
+                                  0,
+                                  0,
+                                  format_CStr("!open newtab:5 url:%s", cstr_String(linkUrl)) } },
+                            4);
                     }
                     else if (!willUseProxy_App(scheme)) {
                         pushBack_Array(
diff --git a/src/ui/keys.c b/src/ui/keys.c
index 6ad9d360..68319598 100644
--- a/src/ui/keys.c
+++ b/src/ui/keys.c
@@ -22,6 +22,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
 
 #include "keys.h"
 #include "util.h"
+#include "window.h"
 #include "app.h"
 
 #include <the_Foundation/file.h>
@@ -223,6 +224,7 @@ static const struct { int id; iMenuItem bind; int flags; } defaultBindings_[] =
     { 77, { "${keys.tab.close}",            closeTab_KeyShortcut,           "tabs.close"                        }, 0 },
     { 80, { "${keys.tab.prev}",             prevTab_KeyShortcut,            "tabs.prev"                         }, 0 },
     { 81, { "${keys.tab.next}",             nextTab_KeyShortcut,            "tabs.next"                         }, 0 },
+    { 91, { "${keys.frame.next}",           SDLK_TAB, KMOD_CTRL,            "keyroot.next",                     }, 0 },
     { 100,{ "${keys.hoverurl}",             '/', KMOD_PRIMARY,              "prefs.hoverlink.toggle"            }, 0 },
     /* The following cannot currently be changed (built-in duplicates). */
 #if defined (iPlatformApple)
@@ -424,21 +426,22 @@ void setLabel_Keys(int id, const char *label) {
 
 iBool processEvent_Keys(const SDL_Event *ev) {
     iKeys *d = &keys_;
+    iRoot *root = get_Window()->keyRoot;
     if (ev->type == SDL_KEYDOWN || ev->type == SDL_KEYUP) {
         const iBinding *bind = find_Keys_(d, ev->key.keysym.sym, keyMods_Sym(ev->key.keysym.mod));
         if (bind) {
             if (ev->type == SDL_KEYUP) {
                 if (bind->flags & argRelease_BindFlag) {
-                    postCommandf_App("%s release:1", cstr_String(&bind->command));
+                    postCommandf_Root(root, "%s release:1", cstr_String(&bind->command));
                     return iTrue;
                 }
                 return iFalse;
             }
             if (ev->key.repeat && (bind->flags & argRepeat_BindFlag)) {
-                postCommandf_App("%s repeat:1", cstr_String(&bind->command));
+                postCommandf_Root(root, "%s repeat:1", cstr_String(&bind->command));
             }
             else {
-                postCommandString_Root(NULL, &bind->command);
+                postCommandString_Root(root, &bind->command);
             }
             return iTrue;
         }
diff --git a/src/ui/lookupwidget.c b/src/ui/lookupwidget.c
index e0de97bf..b3e88ce8 100644
--- a/src/ui/lookupwidget.c
+++ b/src/ui/lookupwidget.c
@@ -742,7 +742,8 @@ static iBool processEvent_LookupWidget_(iLookupWidget *d, const SDL_Event *ev) {
                     return iTrue;
             }
         }
-        if (key == SDLK_DOWN && !mods && focus_Widget() == findWidget_App("url") &&
+        if (isVisible_Widget(w) &&
+            key == SDLK_DOWN && !mods && focus_Widget() == findWidget_App("url") &&
             numItems_ListWidget(d->list)) {
             setCursor_LookupWidget_(d, 1); /* item 0 is always the first heading */
             setFocus_Widget(w);
diff --git a/src/ui/root.c b/src/ui/root.c
index 8faeb215..aec5f26f 100644
--- a/src/ui/root.c
+++ b/src/ui/root.c
@@ -716,14 +716,14 @@ static iBool handleSearchBarCommands_(iWidget *searchBar, const char *cmd) {
         equal_Rangecc(range_Command(cmd, "id"), "find.input")) {
         iInputWidget *input = findChild_Widget(searchBar, "find.input");
         if (arg_Command(cmd) && argLabel_Command(cmd, "enter") && isVisible_Widget(input)) {
-            postCommand_App("find.next");
+            postCommand_Root(searchBar->root, "find.next");
             /* Keep focus when pressing Enter. */
             if (!isEmpty_String(text_InputWidget(input))) {
-                postCommand_App("focus.set id:find.input");
+                postCommand_Root(searchBar->root, "focus.set id:find.input");
             }
         }
         else {
-            postCommand_App("find.clearmark");
+            postCommand_Root(searchBar->root, "find.clearmark");
         }
         return iTrue;
     }
diff --git a/src/ui/util.c b/src/ui/util.c
index b487e13d..9a023ab9 100644
--- a/src/ui/util.c
+++ b/src/ui/util.c
@@ -171,7 +171,9 @@ int keyMods_Sym(int kmods) {
 
 int openTabMode_Sym(int kmods) {
     const int km = keyMods_Sym(kmods);
-    return ((km & KMOD_PRIMARY) && (km & KMOD_SHIFT)) ? 1 : (km & KMOD_PRIMARY) ? 2 : 0;
+    return (km & KMOD_ALT ? otherRoot_OpenTabFlag : 0) | /* open to the side */
+           (((km & KMOD_PRIMARY) && (km & KMOD_SHIFT)) ? new_OpenTabFlag :
+            (km & KMOD_PRIMARY) ? newBackground_OpenTabFlag : 0);
 }
 
 iRangei intersect_Rangei(iRangei a, iRangei b) {
diff --git a/src/ui/util.h b/src/ui/util.h
index b8d10cf0..8dd16a7f 100644
--- a/src/ui/util.h
+++ b/src/ui/util.h
@@ -64,11 +64,17 @@ iLocalDef iBool isPerPixel_MouseWheelEvent(const SDL_MouseWheelEvent *ev) {
 #   define KMOD_SECONDARY   KMOD_GUI
 #endif
 
+enum iOpenTabFlag {
+    new_OpenTabFlag           = iBit(1),
+    newBackground_OpenTabFlag = iBit(2),
+    otherRoot_OpenTabFlag     = iBit(3),
+};
+
 iBool       isMod_Sym           (int key);
 int         normalizedMod_Sym   (int key);
 int         keyMods_Sym         (int kmods); /* shift, alt, control, or gui */
 void        toString_Sym        (int key, int kmods, iString *str);
-int         openTabMode_Sym     (int kmods);
+int         openTabMode_Sym     (int kmods); /* returns OpenTabFlags */
 
 iRangei     intersect_Rangei    (iRangei a, iRangei b);
 iRangei     union_Rangei        (iRangei a, iRangei b);
diff --git a/src/ui/widget.c b/src/ui/widget.c
index 6d6bc202..bb71df7c 100644
--- a/src/ui/widget.c
+++ b/src/ui/widget.c
@@ -1346,6 +1346,7 @@ void setFocus_Widget(iWidget *d) {
         win->focus = d;
         if (d) {
             iAssert(flags_Widget(d) & focusable_WidgetFlag);
+            setKeyRoot_Window(get_Window(), d->root);
             postCommand_Widget(d, "focus.gained");
         }
     }
@@ -1404,13 +1405,17 @@ static const iWidget *findFocusRoot_Widget_(const iWidget *d) {
 }
 
 iAny *findFocusable_Widget(const iWidget *startFrom, enum iWidgetFocusDir focusDir) {
-    const iWidget *root = findFocusRoot_Widget_(get_Root()->widget);
-    iAssert(root != NULL);
+    iRoot *uiRoot = (startFrom ? startFrom->root : get_Window()->keyRoot);
+    const iWidget *focusRoot = findFocusRoot_Widget_(uiRoot->widget);
+    iAssert(focusRoot != NULL);
     iBool getNext = (startFrom ? iFalse : iTrue);
-    const iWidget *found = findFocusable_Widget_(root, startFrom, &getNext, focusDir);
+    const iWidget *found = findFocusable_Widget_(focusRoot, startFrom, &getNext, focusDir);
     if (!found && startFrom) {
         getNext = iTrue;
-        found = findFocusable_Widget_(root, NULL, &getNext, focusDir);
+        /* Switch to the next root, if available. */
+        found = findFocusable_Widget_(findFocusRoot_Widget_(otherRoot_Window(get_Window(),
+                                                                             uiRoot)->widget),
+                                      NULL, &getNext, focusDir);
     }
     return iConstCast(iWidget *, found);
 }
diff --git a/src/ui/window.c b/src/ui/window.c
index 78ea182c..54f05a20 100644
--- a/src/ui/window.c
+++ b/src/ui/window.c
@@ -179,21 +179,22 @@ static void setupUserInterface_Window(iWindow *d) {
         createUserInterface_Root(d->roots[i]);
         setCurrent_Root(NULL);
     }
+    /* One of the roots always has keyboard input focus. */
+    d->keyRoot = d->roots[0];
 }
 
 static void windowSizeChanged_Window_(iWindow *d) {
     const int numRoots = numRoots_Window(d);
     /* Horizontal split frame. */
-    const iInt2 rootSize = div_I2(d->size, init_I2(numRoots, 1));
+    const iInt2 rootSize = d->size;
     iForIndices(i, d->roots) {
         iRoot *root = d->roots[i];
         if (root) {
-            root->widget->rect.pos  = init_I2(rootSize.x * i, 0);
-            root->widget->rect.size = addX_I2(rootSize, -gap_UI / 4);
-            if (i == 1) {
-                root->widget->rect.pos.x += gap_UI / 8;
-            }
-            root->widget->minSize   = root->widget->rect.size;
+            iRect *rect = &root->widget->rect;
+            /* Horizontal split frame. */
+            rect->pos  = init_I2(rootSize.x * i / numRoots, 0);
+            rect->size = init_I2(rootSize.x * (i + 1) / numRoots - rect->pos.x, rootSize.y);
+            root->widget->minSize = rect->size;
             updatePadding_Root(root);
             arrange_Widget(root->widget);
         }
@@ -530,6 +531,10 @@ iRoot *findRoot_Window(const iWindow *d, const iWidget *widget) {
     return NULL;
 }
 
+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) {
     iUnused(d);
     resetFonts_Text();
@@ -881,19 +886,35 @@ iBool processEvent_Window(iWindow *d, const SDL_Event *ev) {
     return iFalse;
 }
 
+iBool setKeyRoot_Window(iWindow *d, iRoot *root) {
+    if (d->keyRoot != root) {
+        d->keyRoot = root;
+        postRefresh_App();
+        return iTrue;
+    }
+    return iFalse;
+}
+
 iBool dispatchEvent_Window(iWindow *d, const SDL_Event *ev) {
     if (ev->type == SDL_MOUSEMOTION) {
         /* Hover widget may change. */
         setHover_Widget(NULL);
     }
-    iForIndices(i, d->roots) {
-        if (d->roots[i]) {
-            if (isCommand_SDLEvent(ev) && ev->user.data2 && ev->user.data2 != d->roots[i]) {
+    iRoot *order[2];
+    rootOrder_App(order);
+    iForIndices(i, order) {
+        iRoot *root = order[i];
+        if (root) {
+            if (isCommand_SDLEvent(ev) && ev->user.data2 && ev->user.data2 != root) {
                 continue; /* Not meant for this root. */
             }
-            setCurrent_Root(d->roots[i]);
-            const iBool wasUsed = dispatchEvent_Widget(d->roots[i]->widget, ev);
+            setCurrent_Root(root);
+            const iBool wasUsed = dispatchEvent_Widget(root->widget, ev);
             if (wasUsed) {
+                if (ev->type == SDL_MOUSEBUTTONDOWN ||
+                    ev->type == SDL_MOUSEWHEEL) {
+                    setKeyRoot_Window(d, root);
+                }
                 return iTrue;
             }
         }
@@ -982,7 +1003,24 @@ void draw_Window(iWindow *d) {
                         NULL,
                         &(SDL_Rect){ left_Rect(rect) + gap_UI * 1.25f, mid.y - size / 2, size, size });
                 }
-#endif                
+#endif
+                /* Root separator and keyboard focus indicator. */ {
+                    iPaint p;
+                    init_Paint(&p);
+                    const iRect bounds = bounds_Widget(root->widget);
+                    if (i == 1) {
+                        fillRect_Paint(&p, (iRect){
+                            addX_I2(topLeft_Rect(bounds), -gap_UI / 8),
+                            init_I2(gap_UI / 4, height_Rect(bounds))
+                        }, uiSeparator_ColorId);
+                    }
+                    if (root == d->keyRoot) {
+                        fillRect_Paint(&p, (iRect){
+                            topLeft_Rect(bounds),
+                            init_I2(width_Rect(bounds), gap_UI / 2)                            
+                        }, uiBackgroundSelected_ColorId);
+                    }
+                }
             }
         }
         setCurrent_Root(NULL);
diff --git a/src/ui/window.h b/src/ui/window.h
index de0133b1..b2b22e90 100644
--- a/src/ui/window.h
+++ b/src/ui/window.h
@@ -68,6 +68,7 @@ struct Impl_Window {
     SDL_Renderer *render;
     iInt2         size;
     iRoot *       roots[2];     /* root widget and UI state; second one is for split mode */
+    iRoot *       keyRoot;      /* root that has the current keyboard input focus */
     iWidget *     hover;
     iWidget *     mouseGrab;
     iWidget *     focus;
@@ -93,6 +94,7 @@ void        resize_Window           (iWindow *, int w, int h);
 void        setTitle_Window         (iWindow *, const iString *title);
 void        setUiScale_Window       (iWindow *, float uiScale);
 void        setFreezeDraw_Window    (iWindow *, iBool freezeDraw);
+iBool       setKeyRoot_Window       (iWindow *, iRoot *root);
 void        setCursor_Window        (iWindow *, int cursor);
 void        setSnap_Window          (iWindow *, int snapMode);
 void        setKeyboardHeight_Window(iWindow *, int height);
@@ -111,6 +113,7 @@ SDL_Renderer *renderer_Window       (const iWindow *);
 int         snap_Window             (const iWindow *);
 iBool       isFullscreen_Window     (const iWindow *);
 iRoot *     findRoot_Window         (const iWindow *, const iWidget *widget);
+iRoot *     otherRoot_Window        (const iWindow *, iRoot *root);
 
 iWindow *   get_Window              (void);