14 files changed, 591 insertions, 159 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 84e81e9f..17fded2b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@
 cmake_minimum_required (VERSION 3.9)
 
 project (Lagrange
-    VERSION 1.4.1
+    VERSION 1.5.0
     DESCRIPTION "A Beautiful Gemini Client"
     LANGUAGES C
 )
diff --git a/src/app.c b/src/app.c
index 3b6752de..6d172c02 100644
--- a/src/app.c
+++ b/src/app.c
@@ -1049,6 +1049,23 @@ void processEvents_App(enum iAppEventMode eventMode) {
                     }
                     continue;
                 }
+                else if (ev.type == SDL_USEREVENT && ev.user.code == arrange_UserEventCode) {
+                    printf("[App] rearrange\n");
+                    resize_Window(d->window, -1, -1);
+                    iForIndices(i, d->window->roots) {
+                        if (d->window->roots[i]) {
+                            d->window->roots[i]->pendingArrange = iFalse;
+                        }
+                    }
+//                    if (ev.user.data2 == d->window->roots[0]) {
+//                        arrange_Widget(d->window->roots[0]->widget);
+//                    }
+//                    else if (d->window->roots[1]) {
+//                        arrange_Widget(d->window->roots[1]->widget);
+//                    }
+//                    postRefresh_App();
+                    continue;
+                }
                 d->lastEventTime = SDL_GetTicks();
                 if (d->isIdling) {
 //                    printf("[App] ...woke up\n");
@@ -1561,6 +1578,10 @@ static iBool handlePrefsCommands_(iWidget *d, const char *cmd) {
             setToggle_Widget(findChild_Widget(d, "prefs.ostheme"), iFalse);
         }
     }
+    else if (equalWidget_Command(cmd, d, "input.resized")) {
+        updatePreferencesLayout_Widget(d);
+        return iFalse;
+    }
     return iFalse;
 }
 
diff --git a/src/app.h b/src/app.h
index c8f0f1c2..aa647bfb 100644
--- a/src/app.h
+++ b/src/app.h
@@ -57,14 +57,15 @@ enum iAppEventMode {
 
 enum iUserEventCode {
     command_UserEventCode = 1,
-    refresh_UserEventCode = 2,
-    asleep_UserEventCode = 3,
+    refresh_UserEventCode,
+    arrange_UserEventCode,
+    asleep_UserEventCode,
     /* The start of a potential touch tap event is notified via a custom event because
        sending SDL_MOUSEBUTTONDOWN would be premature: we don't know how long the tap will
        take, it could turn into a tap-and-hold for example. */
-    widgetTapBegins_UserEventCode = 4,
-    widgetTouchEnds_UserEventCode = 5, /* finger lifted, but momentum may continue */
-    immediateRefresh_UserEventCode = 6, /* refresh even though more events are pending */
+    widgetTapBegins_UserEventCode,
+    widgetTouchEnds_UserEventCode, /* finger lifted, but momentum may continue */
+    immediateRefresh_UserEventCode, /* refresh even though more events are pending */
 };
 
 const iString *execPath_App     (void);
diff --git a/src/gmdocument.c b/src/gmdocument.c
index da99fd0d..4fc0dd5e 100644
--- a/src/gmdocument.c
+++ b/src/gmdocument.c
@@ -726,7 +726,7 @@ static void doLayout_GmDocument_(iGmDocument *d) {
             const int wrapAvail = d->size.x - run.bounds.pos.x - rightMargin * gap_Text;
             const int avail = isWordWrapped ? wrapAvail : 0;
             const char *contPos;
-            const iInt2 dims  = tryAdvance_Text(run.font, runLine, avail, &contPos);
+            const iInt2 dims = tryAdvance_Text(run.font, runLine, avail, &contPos);
             iChangeFlags(run.flags, wide_GmRunFlag, (isPreformat && dims.x > d->size.x));
             run.bounds.size.x = iMax(wrapAvail, dims.x); /* Extends to the right edge for selection. */
             run.bounds.size.y = dims.y;
diff --git a/src/ui/documentwidget.c b/src/ui/documentwidget.c
index 048f8ce4..d23e95a6 100644
--- a/src/ui/documentwidget.c
+++ b/src/ui/documentwidget.c
@@ -304,7 +304,7 @@ void init_DocumentWidget(iDocumentWidget *d) {
     iWidget *w = as_Widget(d);
     init_Widget(w);
     setId_Widget(w, format_CStr("document%03d", ++docEnum_));
-    setFlags_Widget(w, hover_WidgetFlag, iTrue);
+    setFlags_Widget(w, hover_WidgetFlag | noBackground_WidgetFlag, iTrue);
     init_PersistentDocumentState(&d->mod);
     d->flags           = 0;
     d->phoneToolbar    = NULL;
@@ -1571,6 +1571,43 @@ static void togglePreFold_DocumentWidget_(iDocumentWidget *d, uint16_t preId) {
     refresh_Widget(as_Widget(d));
 }
 
+static iString *makeQueryUrl_DocumentWidget_(const iDocumentWidget *d,
+                                             const iString *userEnteredText) {
+    iString *url = copy_String(d->mod.url);
+    /* Remove the existing query string. */
+    const size_t qPos = indexOfCStr_String(url, "?");
+    if (qPos != iInvalidPos) {
+        remove_Block(&url->chars, qPos, iInvalidSize);
+    }
+    appendCStr_String(url, "?");
+    append_String(url, collect_String(urlEncode_String(userEnteredText)));
+    return url;
+}
+
+static void inputQueryValidator_(iInputWidget *input, void *context) {
+    iDocumentWidget *d = context;
+    iString *url = makeQueryUrl_DocumentWidget_(d, text_InputWidget(input));
+    iWidget *dlg = parent_Widget(input);
+    iLabelWidget *counter = findChild_Widget(dlg, "valueinput.counter");
+    iAssert(counter);
+    int avail = 1024 - (int) size_String(url);
+    setFlags_Widget(findChild_Widget(dlg, "default"), disabled_WidgetFlag, avail < 0);
+    setEnterKeyEnabled_InputWidget(input, avail >= 0);
+    int len = length_String(text_InputWidget(input));
+    if (len > 1024) {
+        iString *trunc = copy_String(text_InputWidget(input));
+        truncate_String(trunc, 1024);
+        setText_InputWidget(input, trunc);
+        delete_String(trunc);
+    }
+    setTextCStr_LabelWidget(counter, format_CStr("%d", avail)); /* Gemini URL maxlen */
+    setTextColor_LabelWidget(counter,
+                             avail < 0   ? uiTextCaution_ColorId :
+                             avail < 128 ? uiTextStrong_ColorId
+                                         : uiTextDim_ColorId);
+    delete_String(url);
+}
+
 static void checkResponse_DocumentWidget_(iDocumentWidget *d) {
     if (!d->request) {
         return;
@@ -1598,13 +1635,21 @@ static void checkResponse_DocumentWidget_(iDocumentWidget *d) {
                     isEmpty_String(&resp->meta)
                         ? format_CStr(cstr_Lang("dlg.input.prompt"), cstr_Rangecc(parts.path))
                         : cstr_String(&resp->meta),
-                    uiTextCaution_ColorEscape "${dlg.input.send} \u21d2",
+                    uiTextCaution_ColorEscape "${dlg.input.send}",
                     format_CStr("!document.input.submit doc:%p", d));
+                setId_Widget(addChildPosFlags_Widget(findChild_Widget(dlg, "dialogbuttons"),
+                                                     iClob(new_LabelWidget("", NULL)),
+                                                     front_WidgetAddPos, frameless_WidgetFlag),
+                             "valueinput.counter");
+                setValidator_InputWidget(findChild_Widget(dlg, "input"), inputQueryValidator_, d);
                 setSensitiveContent_InputWidget(findChild_Widget(dlg, "input"),
                                                 statusCode == sensitiveInput_GmStatusCode);
                 if (document_App() != d) {
                     postCommandf_App("tabs.switch page:%p", d);
                 }
+                else {
+                    updateTheme_DocumentWidget_(d);
+                }
                 break;
             }
             case categorySuccess_GmStatusCode:
@@ -2229,17 +2274,10 @@ static iBool handleCommand_DocumentWidget_(iDocumentWidget *d, const char *cmd)
         return iTrue;
     }
     else if (equal_Command(cmd, "document.input.submit") && document_Command(cmd) == d) {
-        iString *value = suffix_Command(cmd, "value");
-        set_String(value, collect_String(urlEncode_String(value)));
-        iString *url = collect_String(copy_String(d->mod.url));
-        const size_t qPos = indexOfCStr_String(url, "?");
-        if (qPos != iInvalidPos) {
-            remove_Block(&url->chars, qPos, iInvalidSize);
-        }
-        appendCStr_String(url, "?");
-        append_String(url, value);
-        postCommandf_Root(w->root, "open url:%s", cstr_String(url));
-        delete_String(value);
+        postCommandf_Root(w->root,
+                          "open url:%s",
+                          cstrCollect_String(makeQueryUrl_DocumentWidget_
+                                             (d, collect_String(suffix_Command(cmd, "value")))));
         return iTrue;
     }
     else if (equal_Command(cmd, "valueinput.cancelled") &&
@@ -4172,7 +4210,7 @@ static void draw_DocumentWidget_(const iDocumentWidget *d) {
     if (width_Rect(bounds) <= 0) {
         return;
     }
-    draw_Widget(w);
+//    draw_Widget(w);
     if (d->drawBufs->flags & updateTimestampBuf_DrawBufsFlag) {
         updateTimestampBuf_DocumentWidget_(d);
     }
@@ -4250,7 +4288,7 @@ static void draw_DocumentWidget_(const iDocumentWidget *d) {
     if (colorTheme_App() == pureWhite_ColorTheme) {
         drawHLine_Paint(&ctx.paint, topLeft_Rect(bounds), width_Rect(bounds), uiSeparator_ColorId);
     }
-    draw_Widget(w);
+    drawChildren_Widget(w);
     /* Alt text. */
     const float altTextOpacity = value_Anim(&d->altTextOpacity) * 6 - 5;
     if (d->hoverAltPre && altTextOpacity > 0) {
diff --git a/src/ui/inputwidget.c b/src/ui/inputwidget.c
index a1635128..5f86f5bf 100644
--- a/src/ui/inputwidget.c
+++ b/src/ui/inputwidget.c
@@ -75,21 +75,48 @@ enum iInputWidgetFlag {
     isMarking_InputWidgetFlag        = iBit(7),
     markWords_InputWidgetFlag        = iBit(8),
     needUpdateBuffer_InputWidgetFlag = iBit(9),
+    enterKeyEnabled_InputWidgetFlag  = iBit(10),
 };
 
+/*----------------------------------------------------------------------------------------------*/
+
+iDeclareType(InputLine)
+    
+struct Impl_InputLine {
+    size_t offset; /* character position from the beginning */
+    iString text; /* UTF-8 */
+};
+
+static void init_InputLine(iInputLine *d) {
+    d->offset = 0;
+    init_String(&d->text);
+}
+
+static void deinit_InputLine(iInputLine *d) {
+    deinit_String(&d->text);
+}
+
+iDefineTypeConstruction(InputLine)
+    
+/*----------------------------------------------------------------------------------------------*/
+    
 struct Impl_InputWidget {
     iWidget         widget;
     enum iInputMode mode;
     int             inFlags;
     size_t          maxLen;
+    size_t          maxLayoutLines;
     iArray          text;    /* iChar[] */
     iArray          oldText; /* iChar[] */
+    iArray          lines;
     iString         hint;
     iString         srcHint;
     int             leftPadding;
     int             rightPadding;
-    size_t          cursor;
+    size_t          cursor; /* offset from beginning */
     size_t          lastCursor;
+    size_t          cursorLine;
+    int             verticalMoveX;
     iRanges         mark;
     iRanges         initialMark;
     iArray          undoStack;
@@ -98,6 +125,8 @@ struct Impl_InputWidget {
     int             cursorVis;
     uint32_t        timer;
     iTextBuf *      buffered;
+    iInputWidgetValidatorFunc validator;
+    void *          validatorContext;
 };
 
 iDefineObjectConstructionArgs(InputWidget, (size_t maxLen), maxLen)
@@ -109,8 +138,20 @@ static void clearUndo_InputWidget_(iInputWidget *d) {
     clear_Array(&d->undoStack);
 }
 
+static void updateCursorLine_InputWidget_(iInputWidget *d) {
+    d->cursorLine = 0;
+    iConstForEach(Array, i, &d->lines) {
+        const iInputLine *line = i.value;
+        if (line->offset > d->cursor) {
+            break;
+        }
+        d->cursorLine = index_ArrayConstIterator(&i);
+    }
+}
+
 static void showCursor_InputWidget_(iInputWidget *d) {
     d->cursorVis = 2;
+    updateCursorLine_InputWidget_(d);
 }
 
 static void invalidateBuffered_InputWidget_(iInputWidget *d) {
@@ -120,6 +161,21 @@ static void invalidateBuffered_InputWidget_(iInputWidget *d) {
     }
 }
 
+iLocalDef iInt2 padding_(void) {
+    return init_I2(gap_UI / 2, gap_UI / 2);
+}
+
+static iRect contentBounds_InputWidget_(const iInputWidget *d) {
+    const iWidget *w         = constAs_Widget(d);
+    const iRect widgetBounds = bounds_Widget(w);
+    iRect          bounds = adjusted_Rect(bounds_Widget(w),
+                                          addX_I2(padding_(), d->leftPadding),
+                                          neg_I2(addX_I2(padding_(), d->rightPadding)));
+    shrink_Rect(&bounds, init_I2(gap_UI * (flags_Widget(w) & tight_WidgetFlag ? 1 : 2), 0));
+    bounds.pos.y += padding_().y / 2;
+    return bounds;
+}
+
 static void updateSizeForFixedLength_InputWidget_(iInputWidget *d) {
     if (d->maxLen) {
         /* Set a fixed size based on maximum possible width of the text. */
@@ -135,29 +191,122 @@ static void updateSizeForFixedLength_InputWidget_(iInputWidget *d) {
     }
 }
 
+static const iChar sensitiveChar_ = 0x25cf; /* black circle */
+
+static iString *utf32toUtf8_InputWidget_(const iInputWidget *d) {
+    return newUnicodeN_String(constData_Array(&d->text), size_Array(&d->text));
+}
+
+static iString *visText_InputWidget_(const iInputWidget *d) {
+    iString *text;
+    if (~d->inFlags & isSensitive_InputWidgetFlag) {
+        text = utf32toUtf8_InputWidget_(d);
+    }
+    else {
+        text = new_String();
+        for (size_t i = 0; i < size_Array(&d->text); ++i) {
+            appendChar_String(text, sensitiveChar_);
+        }
+    }
+    return text;
+}
+
+static void clearLines_InputWidget_(iInputWidget *d) {
+    iForEach(Array, i, &d->lines) {
+        deinit_InputLine(i.value);
+    }
+    clear_Array(&d->lines);
+}
+
+static void updateLines_InputWidget_(iInputWidget *d) {
+    clearLines_InputWidget_(d);
+    if (d->maxLen) {
+        /* Everything on a single line. */
+        iInputLine line;
+        init_InputLine(&line);
+        iString *u8 = visText_InputWidget_(d);
+        set_String(&line.text, u8);
+        delete_String(u8);
+        pushBack_Array(&d->lines, &line);
+        updateCursorLine_InputWidget_(d);
+        return;
+    }
+    /* Word-wrapped lines. */
+    iString *u8 = visText_InputWidget_(d);
+    size_t charPos = 0;
+    iRangecc content = range_String(u8);
+    const int wrapWidth = contentBounds_InputWidget_(d).size.x;
+    while (wrapWidth > 0 && content.end != content.start) {
+        const char *endPos;
+        if (d->inFlags & isUrl_InputWidgetFlag) {
+            tryAdvanceNoWrap_Text(d->font, content, wrapWidth, &endPos);
+        }
+        else {
+            tryAdvance_Text(d->font, content, wrapWidth, &endPos);
+        }
+        const iRangecc part = (iRangecc){ content.start, endPos };
+        iInputLine line;
+        init_InputLine(&line);
+        setRange_String(&line.text, part);
+        line.offset = charPos;
+        pushBack_Array(&d->lines, &line);
+        charPos += length_String(&line.text);
+        content.start = endPos;        
+    }
+    if (isEmpty_Array(&d->lines) || endsWith_String(u8, "\n")) {
+        /* Always at least one empty line. */
+        iInputLine line;
+        init_InputLine(&line);
+        pushBack_Array(&d->lines, &line);
+    }
+    else {
+        iAssert(charPos == length_String(u8));
+    }
+    delete_String(u8);        
+    updateCursorLine_InputWidget_(d);
+}
+
+static int contentHeight_InputWidget_(const iInputWidget *d, iBool forLayout) {
+    size_t numLines = iMax(1, size_Array(&d->lines));
+    if (forLayout) {
+        numLines = iMin(numLines, d->maxLayoutLines);
+    }
+    return numLines * lineHeight_Text(d->font);
+}
+
 static void updateMetrics_InputWidget_(iInputWidget *d) {
     iWidget *w = as_Widget(d);
     updateSizeForFixedLength_InputWidget_(d);
     /* Caller must arrange the width, but the height is fixed. */
-    w->rect.size.y = lineHeight_Text(d->font) * 1.3f;
+    w->rect.size.y = contentHeight_InputWidget_(d, iTrue) + 3 * padding_().y; /* TODO: Why 3x? */
     if (flags_Widget(w) & extraPadding_WidgetFlag) {
         w->rect.size.y += 2 * gap_UI;
     }
     invalidateBuffered_InputWidget_(d);
-    if (parent_Widget(w)) {
-        arrange_Widget(w);
+    postCommand_Widget(d, "input.resized");
+}
+
+static void updateLinesAndResize_InputWidget_(iInputWidget *d) {
+    const size_t oldCount = size_Array(&d->lines);
+    updateLines_InputWidget_(d);
+    if (oldCount != size_Array(&d->lines)) {
+        d->click.minHeight = contentHeight_InputWidget_(d, iFalse);
+        updateMetrics_InputWidget_(d);
     }
 }
 
 void init_InputWidget(iInputWidget *d, size_t maxLen) {
     iWidget *w = &d->widget;
     init_Widget(w);
+    d->validator = NULL;
+    d->validatorContext = NULL;
     setFlags_Widget(w, focusable_WidgetFlag | hover_WidgetFlag | touchDrag_WidgetFlag, iTrue);
 #if defined (iPlatformMobile)
     setFlags_Widget(w, extraPadding_WidgetFlag, iTrue);
 #endif
     init_Array(&d->text, sizeof(iChar));
     init_Array(&d->oldText, sizeof(iChar));
+    init_Array(&d->lines, sizeof(iInputLine));
     init_String(&d->hint);
     init_String(&d->srcHint);
     init_Array(&d->undoStack, sizeof(iInputUndo));
@@ -166,18 +315,23 @@ void init_InputWidget(iInputWidget *d, size_t maxLen) {
     d->rightPadding = 0;
     d->cursor       = 0;
     d->lastCursor   = 0;
-    d->inFlags      = eatEscape_InputWidgetFlag;
+    d->cursorLine   = 0;
+    d->verticalMoveX = -1; /* TODO: Use this. */
+    d->inFlags      = eatEscape_InputWidgetFlag | enterKeyEnabled_InputWidgetFlag;
     iZap(d->mark);
     setMaxLen_InputWidget(d, maxLen);
+    d->maxLayoutLines = iInvalidSize;
     setFlags_Widget(w, fixedHeight_WidgetFlag, iTrue);
     init_Click(&d->click, d, SDL_BUTTON_LEFT);
     d->timer = 0;
     d->cursorVis = 0;
     d->buffered = NULL;
+    updateLines_InputWidget_(d);
     updateMetrics_InputWidget_(d);
 }
 
 void deinit_InputWidget(iInputWidget *d) {
+    clearLines_InputWidget_(d);
     if (isSelected_Widget(d)) {
         SDL_StopTextInput();
         enableEditorKeysInMenus_(iTrue);
@@ -190,6 +344,7 @@ void deinit_InputWidget(iInputWidget *d) {
     }
     deinit_String(&d->srcHint);
     deinit_String(&d->hint);
+    deinit_Array(&d->lines);
     deinit_Array(&d->oldText);
     deinit_Array(&d->text);
 }
@@ -199,6 +354,11 @@ void setFont_InputWidget(iInputWidget *d, int fontId) {
     updateMetrics_InputWidget_(d);
 }
 
+static const iInputLine *line_InputWidget_(const iInputWidget *d, size_t index) {
+    iAssert(!isEmpty_Array(&d->lines));
+    return constAt_Array(&d->lines, index);
+}
+
 static void pushUndo_InputWidget_(iInputWidget *d) {
     iInputUndo undo;
     init_InputUndo_(&undo, &d->text, d->cursor);
@@ -241,10 +401,6 @@ static const iString *omitDefaultScheme_(iString *url) {
     return url;
 }
 
-static iString *utf32toUtf8_InputWidget_(const iInputWidget *d) {
-    return newUnicodeN_String(constData_Array(&d->text), size_Array(&d->text));
-}
-
 const iString *text_InputWidget(const iInputWidget *d) {
     if (d) {
         iString *text = collect_String(utf32toUtf8_InputWidget_(d));
@@ -267,6 +423,20 @@ void setMaxLen_InputWidget(iInputWidget *d, size_t maxLen) {
     updateSizeForFixedLength_InputWidget_(d);
 }
 
+void setMaxLayoutLines_InputWidget(iInputWidget *d, size_t maxLayoutLines) {
+    d->maxLayoutLines = maxLayoutLines;
+    updateMetrics_InputWidget_(d);
+}
+
+void setValidator_InputWidget(iInputWidget *d, iInputWidgetValidatorFunc validator, void *context) {
+    d->validator = validator;
+    d->validatorContext = context;
+}
+
+void setEnterKeyEnabled_InputWidget(iInputWidget *d, iBool enterKeyEnabled) {
+    iChangeFlags(d->inFlags, enterKeyEnabled_InputWidgetFlag, enterKeyEnabled);
+}
+
 void setHint_InputWidget(iInputWidget *d, const char *hintText) {
     /* Keep original for retranslations. */
     setCStr_String(&d->srcHint, hintText);
@@ -285,27 +455,12 @@ void setContentPadding_InputWidget(iInputWidget *d, int left, int right) {
     refresh_Widget(d);
 }
 
-static const iChar sensitiveChar_ = 0x25cf; /* black circle */
-
-static iString *visText_InputWidget_(const iInputWidget *d) {
-    iString *text;
-    if (~d->inFlags & isSensitive_InputWidgetFlag) {
-        text = newUnicodeN_String(constData_Array(&d->text), size_Array(&d->text));
-    }
-    else {
-        text = new_String();
-        for (size_t i = 0; i < size_Array(&d->text); ++i) {
-            appendChar_String(text, sensitiveChar_);
-        }
-    }
-    return text;
-}
-
 static void updateBuffered_InputWidget_(iInputWidget *d) {
-    iWindow *win = get_Window();
     invalidateBuffered_InputWidget_(d);
     iString *bufText = NULL;
+#if 0
     if (d->inFlags & isUrl_InputWidgetFlag && as_Widget(d)->root == win->keyRoot) {
+        /* TODO: Move this omitting to `updateLines_`? */
         /* Highlight the host name. */
         iUrl parts;
         const iString *text = collect_String(utf32toUtf8_InputWidget_(d));
@@ -319,6 +474,7 @@ static void updateBuffered_InputWidget_(iInputWidget *d) {
             appendRange_String(bufText, (iRangecc){ parts.host.end, constEnd_String(text) });
         }
     }
+#endif
     if (!bufText) {
         bufText = visText_InputWidget_(d);
     }
@@ -350,7 +506,7 @@ void setText_InputWidget(iInputWidget *d, const iString *text) {
     }
     if (isFocused_Widget(d)) {
         d->cursor = size_Array(&d->text);
-        selectAll_InputWidget(d);
+//        selectAll_InputWidget(d);
     }
     else {
         d->cursor = iMin(d->cursor, size_Array(&d->text));
@@ -359,6 +515,7 @@ void setText_InputWidget(iInputWidget *d, const iString *text) {
     if (!isFocused_Widget(d)) {
         d->inFlags |= needUpdateBuffer_InputWidgetFlag;
     }
+    updateLinesAndResize_InputWidget_(d);
     refresh_Widget(as_Widget(d));
 }
 
@@ -404,8 +561,9 @@ void begin_InputWidget(iInputWidget *d) {
     else {
         d->cursor = iMin(size_Array(&d->text), d->maxLen - 1);
     }
+    updateCursorLine_InputWidget_(d);
     SDL_StartTextInput();
-    setFlags_Widget(w, selected_WidgetFlag, iTrue);
+    setFlags_Widget(w, selected_WidgetFlag | keepOnTop_WidgetFlag, iTrue);
     showCursor_InputWidget_(d);
     refresh_Widget(w);
     d->timer = SDL_AddTimer(refreshInterval_InputWidget_, cursorTimer_, d);
@@ -433,9 +591,10 @@ void end_InputWidget(iInputWidget *d, iBool accept) {
     SDL_RemoveTimer(d->timer);
     d->timer = 0;
     SDL_StopTextInput();
-    setFlags_Widget(w, selected_WidgetFlag, iFalse);
+    setFlags_Widget(w, selected_WidgetFlag | keepOnTop_WidgetFlag, iFalse);
     const char *id = cstr_String(id_Widget(as_Widget(d)));
     if (!*id) id = "_";
+    updateLinesAndResize_InputWidget_(d);
     refresh_Widget(w);
     postCommand_Widget(w,
                        "input.ended id:%s enter:%d arg:%d",
@@ -476,7 +635,6 @@ iLocalDef iBool isMarking_(void) {
 }
 
 void setCursor_InputWidget(iInputWidget *d, size_t pos) {
-    showCursor_InputWidget_(d);
     if (isEmpty_Array(&d->text)) {
         d->cursor = 0;
     }
@@ -496,6 +654,51 @@ void setCursor_InputWidget(iInputWidget *d, size_t pos) {
     else {
         iZap(d->mark);
     }
+    showCursor_InputWidget_(d);
+}
+
+static size_t indexForRelativeX_InputWidget_(const iInputWidget *d, int x, const iInputLine *line) {
+    if (x <= 0) {
+        return line->offset;
+    }
+    const char *endPos;
+    tryAdvanceNoWrap_Text(d->font, range_String(&line->text), x, &endPos);
+    size_t index = line->offset;
+    if (endPos == constEnd_String(&line->text)) {
+        index += length_String(&line->text);
+    }
+    else {
+        /* Need to know the actual character index. */
+        /* TODO: tryAdvance could tell us this directly with an extra return value */
+        iConstForEach(String, i, &line->text) {
+            if (i.pos >= endPos) break;
+            index++;
+        }
+    }
+    return index;
+}
+
+static iBool moveCursorByLine_InputWidget_(iInputWidget *d, int dir) {
+    const iInputLine *line = line_InputWidget_(d, d->cursorLine);
+    int xPos = advanceN_Text(d->font, cstr_String(&line->text), d->cursor - line->offset).x;
+    size_t newCursor = iInvalidPos;
+    const size_t numLines = size_Array(&d->lines);
+    if (dir < 0 && d->cursorLine > 0) {
+        newCursor = indexForRelativeX_InputWidget_(d, xPos, --line);
+    }
+    else if (dir > 0 && d->cursorLine < numLines - 1) {
+        newCursor = indexForRelativeX_InputWidget_(d, xPos, ++line);
+    }
+    if (newCursor != iInvalidPos) {
+        /* Clamp it to the current line. */
+        newCursor = iMax(newCursor, line->offset);
+        newCursor = iMin(newCursor, line->offset + length_String(&line->text) -
+                         /* last line is allowed to go to the cursorMax */
+                         ((const void *) line < constAt_Array(&d->lines, numLines - 1) ? 1 : 0));
+        setCursor_InputWidget(d, newCursor);
+        return iTrue;
+    }
+    return iFalse;
 }
 
 void setSensitiveContent_InputWidget(iInputWidget *d, iBool isSensitive) {
@@ -526,6 +729,10 @@ static iRanges mark_InputWidget_(const iInputWidget *d) {
 }
 
 static void contentsWereChanged_InputWidget_(iInputWidget *d) {
+    if (d->validator) {
+        d->validator(d, d->validatorContext); /* this may change the contents */
+    }
+    updateLinesAndResize_InputWidget_(d);
     if (d->inFlags & notifyEdits_InputWidgetFlag) {
         postCommand_Widget(d, "input.edited id:%s", cstr_String(id_Widget(constAs_Widget(d))));
     }
@@ -591,21 +798,18 @@ static size_t skipWord_InputWidget_(const iInputWidget *d, size_t pos, int dir)
     return pos;
 }
 
-iLocalDef iInt2 padding_(void) {
-    return init_I2(gap_UI / 2, gap_UI / 2);
-}
-
-static iInt2 textOrigin_InputWidget_(const iInputWidget *d, const char *visText) {
-    const iWidget *w         = constAs_Widget(d);
-    iRect          bounds    = adjusted_Rect(bounds_Widget(w),
+#if 0
+static iInt2 textOrigin_InputWidget_(const iInputWidget *d) { //}, const char *visText) {
+//    const iWidget *w         = constAs_Widget(d);
+    iRect          bounds    = contentBounds_InputWidget_(d);/* adjusted_Rect(bounds_Widget(w),
                                  addX_I2(padding_(), d->leftPadding),
-                                 neg_I2(addX_I2(padding_(), d->rightPadding)));
-    const iInt2    emSize    = advance_Text(d->font, "M");
-    const int      textWidth = advance_Text(d->font, visText).x;
-    const int      cursorX   = advanceN_Text(d->font, visText, d->cursor).x;
-    int            xOff      = 0;
-    shrink_Rect(&bounds, init_I2(gap_UI * (flags_Widget(w) & tight_WidgetFlag ? 1 : 2), 0));
-    if (d->maxLen == 0) {
+                                 neg_I2(addX_I2(padding_(), d->rightPadding)));*/
+//    const iInt2    emSize    = advance_Text(d->font, "M");
+//    const int      textWidth = advance_Text(d->font, visText).x;
+//    const int      cursorX   = advanceN_Text(d->font, visText, d->cursor).x;
+//    int            xOff      = 0;
+//    shrink_Rect(&bounds, init_I2(gap_UI * (flags_Widget(w) & tight_WidgetFlag ? 1 : 2), 0));
+/*    if (d->maxLen == 0) {
         if (textWidth > width_Rect(bounds) - emSize.x) {
             xOff = width_Rect(bounds) - emSize.x - textWidth;
         }
@@ -613,32 +817,20 @@ static iInt2 textOrigin_InputWidget_(const iInputWidget *d, const char *visText)
             xOff = width_Rect(bounds) / 2 - cursorX;
         }
         xOff = iMin(xOff, 0);
-    }
-    const int yOff = (height_Rect(bounds) - lineHeight_Text(d->font)) / 2;
-    return add_I2(topLeft_Rect(bounds), init_I2(xOff, yOff));
+    }*/
+//    const int yOff = 0.3f * lineHeight_Text(d->font); // (height_Rect(bounds) - lineHeight_Text(d->font)) / 2;
+//    return addY_I2(topLeft_Rect(bounds), yOff);
+    
 }
+#endif
 
 static size_t coordIndex_InputWidget_(const iInputWidget *d, iInt2 coord) {
-    iString *visText = visText_InputWidget_(d);
-    iInt2    pos     = sub_I2(coord, textOrigin_InputWidget_(d, cstr_String(visText)));
-    size_t   index   = 0;
-    if (pos.x > 0) {
-        const char *endPos;
-        tryAdvanceNoWrap_Text(d->font, range_String(visText), pos.x, &endPos);
-        if (endPos == constEnd_String(visText)) {
-            index = cursorMax_InputWidget_(d);
-        }
-        else {
-            /* Need to know the actual character index. */
-            /* TODO: tryAdvance could tell us this directly with an extra return value */
-            iConstForEach(String, i, visText) {
-                if (i.pos >= endPos) break;
-                index++;
-            }
-        }
-    }
-    delete_String(visText);
-    return index;
+    const iInt2 pos = sub_I2(coord, contentBounds_InputWidget_(d).pos);
+    const size_t lineNumber = iMin(pos.y / lineHeight_Text(d->font), (int) size_Array(&d->lines) - 1);
+    const iInputLine *line = line_InputWidget_(d, lineNumber);
+    const char *endPos;
+    tryAdvanceNoWrap_Text(d->font, range_String(&line->text), pos.x, &endPos);
+    return indexForRelativeX_InputWidget_(d, pos.x, line);
 }
 
 static iBool copy_InputWidget_(iInputWidget *d, iBool doCut) {
@@ -683,6 +875,14 @@ static iChar at_InputWidget_(const iInputWidget *d, size_t pos) {
     return *(const iChar *) constAt_Array(&d->text, pos);
 }
 
+static iRanges lineRange_InputWidget_(const iInputWidget *d) {
+    if (isEmpty_Array(&d->lines)) {
+        return (iRanges){ 0, 0 };
+    }
+    const iInputLine *line = line_InputWidget_(d, d->cursorLine);
+    return (iRanges){ line->offset, line->offset + length_String(&line->text) };
+}
+
 static void extendRange_InputWidget_(iInputWidget *d, size_t *pos, int dir) {
     const size_t textLen = size_Array(&d->text);
     if (dir < 0 && *pos > 0) {
@@ -700,6 +900,20 @@ static void extendRange_InputWidget_(iInputWidget *d, size_t *pos, int dir) {
     }
 }
 
+static iRect bounds_InputWidget_(const iInputWidget *d) {
+    const iWidget *w = constAs_Widget(d);
+    iRect bounds = bounds_Widget(w);
+    if (!isFocused_Widget(d)) {
+        return bounds;
+    }
+    bounds.size.y = contentHeight_InputWidget_(d, iFalse) + 3 * padding_().y;
+    return bounds;
+}
+
+static iBool contains_InputWidget_(const iInputWidget *d, iInt2 coord) {
+    return contains_Rect(bounds_InputWidget_(d), coord);
+}
+
 static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
     iWidget *w = as_Widget(d);
     if (isCommand_Widget(w, ev, "focus.gained")) {
@@ -746,19 +960,22 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
     }
     else if (isMetricsChange_UserEvent(ev)) {
         updateMetrics_InputWidget_(d);
+        updateLinesAndResize_InputWidget_(d);
     }
     else if (isResize_UserEvent(ev)) {
         if (d->inFlags & isUrl_InputWidgetFlag) {
             /* Restore/omit the default scheme if necessary. */
             setText_InputWidget(d, text_InputWidget(d));
         }
+        updateLinesAndResize_InputWidget_(d);
     }
     else if (isFocused_Widget(d) && isCommand_UserEvent(ev, "copy")) {
         copy_InputWidget_(d, iFalse);
         return iTrue;
     }
-    if (ev->type == SDL_MOUSEMOTION && isHover_Widget(d)) {
-        const iInt2 inner = windowToInner_Widget(w, init_I2(ev->motion.x, ev->motion.y));
+    if (ev->type == SDL_MOUSEMOTION && (isHover_Widget(d) || flags_Widget(w) & keepOnTop_WidgetFlag)) {
+        const iInt2 coord = init_I2(ev->motion.x, ev->motion.y);
+        const iInt2 inner = windowToInner_Widget(w, coord);
         setCursor_Window(get_Window(),
                          inner.x >= 2 * gap_UI + d->leftPadding &&
                          inner.x < width_Widget(w) - d->rightPadding
@@ -768,30 +985,38 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
     switch (processEvent_Click(&d->click, ev)) {
         case none_ClickResult:
             break;
-        case started_ClickResult:
+        case started_ClickResult: {
             setFocus_Widget(w);
+            const size_t oldCursor = d->cursor;
             setCursor_InputWidget(d, coordIndex_InputWidget_(d, pos_Click(&d->click)));
-            iZap(d->mark);
-            iZap(d->initialMark);
-            d->inFlags &= ~(isMarking_InputWidgetFlag | markWords_InputWidgetFlag);
-            if (d->click.count == 2) {
-                d->inFlags |= isMarking_InputWidgetFlag | markWords_InputWidgetFlag;
-                d->mark.start = d->mark.end = d->cursor;
-                extendRange_InputWidget_(d, &d->mark.start, -1);
-                extendRange_InputWidget_(d, &d->mark.end, +1);
-                d->initialMark = d->mark;
-                refresh_Widget(w);
+            if (keyMods_Sym(modState_Keys()) == KMOD_SHIFT) {
+                d->mark = d->initialMark = (iRanges){ oldCursor, d->cursor };
+                d->inFlags |= isMarking_InputWidgetFlag;
             }
-            if (d->click.count == 3) {
-                selectAll_InputWidget(d);
+            else {
+                iZap(d->mark);
+                iZap(d->initialMark);
+                d->inFlags &= ~(isMarking_InputWidgetFlag | markWords_InputWidgetFlag);
+                if (d->click.count == 2) {
+                    d->inFlags |= isMarking_InputWidgetFlag | markWords_InputWidgetFlag;
+                    d->mark.start = d->mark.end = d->cursor;
+                    extendRange_InputWidget_(d, &d->mark.start, -1);
+                    extendRange_InputWidget_(d, &d->mark.end, +1);
+                    d->initialMark = d->mark;
+                    refresh_Widget(w);
+                }
+                if (d->click.count == 3) {
+                    selectAll_InputWidget(d);
+                }
             }
             return iTrue;
+        }
         case aborted_ClickResult:
             d->inFlags &= ~isMarking_InputWidgetFlag;
             return iTrue;
         case drag_ClickResult:
-            showCursor_InputWidget_(d);
             d->cursor = coordIndex_InputWidget_(d, pos_Click(&d->click));
+            showCursor_InputWidget_(d);
             if (~d->inFlags & isMarking_InputWidgetFlag) {
                 d->inFlags |= isMarking_InputWidgetFlag;
                 d->mark.start = d->cursor;
@@ -808,6 +1033,12 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
             d->inFlags &= ~isMarking_InputWidgetFlag;
             return iTrue;
     }
+    if (ev->type == SDL_MOUSEMOTION && flags_Widget(w) & keepOnTop_WidgetFlag) {
+        const iInt2 coord = init_I2(ev->motion.x, ev->motion.y);
+        if (contains_Click(&d->click, coord)) {
+            return iTrue;
+        }
+    }
     if (ev->type == SDL_MOUSEBUTTONDOWN && ev->button.button == SDL_BUTTON_RIGHT &&
         contains_Widget(w, init_I2(ev->button.x, ev->button.y))) {
         iWidget *clipMenu = findWidget_App("clipmenu");
@@ -822,7 +1053,10 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
     if (ev->type == SDL_KEYUP && isFocused_Widget(w)) {
         return iTrue;
     }
-    const size_t curMax = cursorMax_InputWidget_(d);
+    const size_t  curMax    = cursorMax_InputWidget_(d);
+    const iRanges lineRange = lineRange_InputWidget_(d);
+    const size_t  lineFirst = lineRange.start;
+    const size_t  lineLast  = lineRange.end == curMax ? curMax : iMax(lineRange.start, lineRange.end - 1);
     if (ev->type == SDL_KEYDOWN && isFocused_Widget(w)) {
         const int key  = ev->key.keysym.sym;
         const int mods = keyMods_Sym(ev->key.keysym.mod);
@@ -852,8 +1086,17 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
                 return iTrue;
             case SDLK_RETURN:
             case SDLK_KP_ENTER:
-                d->inFlags |= enterPressed_InputWidgetFlag;
-                setFocus_Widget(NULL);
+                if (mods == KMOD_SHIFT) {
+                    pushUndo_InputWidget_(d);
+                    deleteMarked_InputWidget_(d);
+                    insertChar_InputWidget_(d, '\n');
+                    contentsWereChanged_InputWidget_(d);
+                    return iTrue;
+                }
+                if (d->inFlags & enterKeyEnabled_InputWidgetFlag) {
+                    d->inFlags |= enterPressed_InputWidgetFlag;
+                    setFocus_Widget(NULL);
+                }
                 return iTrue;
             case SDLK_ESCAPE:
                 end_InputWidget(d, iFalse);
@@ -927,7 +1170,7 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
                 break;
             case SDLK_HOME:
             case SDLK_END:
-                setCursor_InputWidget(d, key == SDLK_HOME ? 0 : curMax);
+                setCursor_InputWidget(d, key == SDLK_HOME ? lineFirst : lineLast);
                 refresh_Widget(w);
                 return iTrue;
             case SDLK_a:
@@ -944,7 +1187,7 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
                 /* fall through for Emacs-style Home/End */
             case SDLK_e:
                 if (mods == KMOD_CTRL || mods == (KMOD_CTRL | KMOD_SHIFT)) {
-                    setCursor_InputWidget(d, key == 'a' ? 0 : curMax);
+                    setCursor_InputWidget(d, key == 'a' ? lineFirst : lineLast);
                     refresh_Widget(w);
                     return iTrue;
                 }
@@ -953,7 +1196,7 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
             case SDLK_RIGHT: {
                 const int dir = (key == SDLK_LEFT ? -1 : +1);
                 if (mods & byLine_KeyModifier) {
-                    setCursor_InputWidget(d, dir < 0 ? 0 : curMax);
+                    setCursor_InputWidget(d, dir < 0 ? lineFirst : lineLast);
                 }
                 else if (mods & byWord_KeyModifier) {
                     setCursor_InputWidget(d, skipWord_InputWidget_(d, d->cursor, dir));
@@ -970,9 +1213,22 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
                 return iTrue;
             }
             case SDLK_TAB:
-            case SDLK_DOWN: /* for moving to lookup from url entry */
                 /* Allow focus switching. */
                 return processEvent_Widget(as_Widget(d), ev);
+            case SDLK_UP:
+                if (moveCursorByLine_InputWidget_(d, -1)) {
+                    refresh_Widget(d);
+                    return iTrue;
+                }
+                /* For moving to lookup from url entry. */
+                return processEvent_Widget(as_Widget(d), ev);
+            case SDLK_DOWN:
+                if (moveCursorByLine_InputWidget_(d, +1)) {
+                    refresh_Widget(d);
+                    return iTrue;
+                }
+                /* For moving to lookup from url entry. */
+                return processEvent_Widget(as_Widget(d), ev);
         }
         if (mods & (KMOD_PRIMARY | KMOD_SECONDARY)) {
             return iFalse;
@@ -1003,21 +1259,23 @@ static iBool isWhite_(const iString *str) {
 
 static void draw_InputWidget_(const iInputWidget *d) {
     const iWidget *w         = constAs_Widget(d);
-    iRect          bounds    = adjusted_Rect(bounds_Widget(w), padding_(), neg_I2(padding_()));
+    iRect          bounds    = adjusted_Rect(bounds_InputWidget_(d), padding_(), neg_I2(padding_()));
     iBool          isHint    = iFalse;
     const iBool    isFocused = isFocused_Widget(w);
     const iBool    isHover   = isHover_Widget(w) &&
-                               contains_Widget(w, mouseCoord_Window(get_Window()));
+                               contains_InputWidget_(d, mouseCoord_Window(get_Window()));
     if (d->inFlags & needUpdateBuffer_InputWidgetFlag) {
         updateBuffered_InputWidget_(iConstCast(iInputWidget *, d));
     }
     iPaint p;
     init_Paint(&p);
-    iString *text = visText_InputWidget_(d);
-    if (isWhite_(text) && !isEmpty_String(&d->hint)) {
-        set_String(text, &d->hint);
-        isHint = iTrue;
-    }
+    /* `lines` is already up to date and ready for drawing. */
+    /* TODO: If empty, draw the hint. */
+//    iString *text = visText_InputWidget_(d);
+//    if (isWhite_(text) && !isEmpty_String(&d->hint)) {
+//        set_String(text, &d->hint);
+//        isHint = iTrue;
+//    }
     fillRect_Paint(
         &p, bounds, isFocused ? uiInputBackgroundFocused_ColorId : uiInputBackground_ColorId);
     drawRectThickness_Paint(&p,
@@ -1026,29 +1284,53 @@ static void draw_InputWidget_(const iInputWidget *d) {
                             isFocused ? uiInputFrameFocused_ColorId
                                       : isHover ? uiInputFrameHover_ColorId : uiInputFrame_ColorId);
     setClip_Paint(&p, adjusted_Rect(bounds, init_I2(d->leftPadding, 0), init_I2(-d->rightPadding, 0)));
-    const iInt2 textOrigin = textOrigin_InputWidget_(d, cstr_String(text));
-    if (isFocused && !isEmpty_Range(&d->mark)) {
-        /* Draw the selected range. */
-        const int m1 = advanceN_Text(d->font, cstr_String(text), d->mark.start).x;
-        const int m2 = advanceN_Text(d->font, cstr_String(text), d->mark.end).x;
-        fillRect_Paint(&p,
-                       (iRect){ addX_I2(textOrigin, iMin(m1, m2)),
-                                init_I2(iAbs(m2 - m1), lineHeight_Text(d->font)) },
-                       uiMarked_ColorId);
-    }
-    if (d->buffered && !isFocused && !isHint) {
-        /* Most input widgets will use this, since only one is focused at a time. */
-        draw_TextBuf(d->buffered, textOrigin, white_ColorId);
-    }
-    else {
-        draw_Text(d->font,
-                  textOrigin,
-                  isHint ? uiAnnotation_ColorId
-                         : isFocused && !isEmpty_Array(&d->text) ? uiInputTextFocused_ColorId
-                                                                 : uiInputText_ColorId,
-                  "%s",
-                  cstr_String(text));
-    }
+    const iRect contentBounds = contentBounds_InputWidget_(d);
+//    const iInt2 textOrigin = textOrigin_InputWidget_(d); //, cstr_String(text));
+    iInt2       drawPos    = topLeft_Rect(contentBounds);
+    const int   fg         = isHint                                  ? uiAnnotation_ColorId
+                             : isFocused && !isEmpty_Array(&d->text) ? uiInputTextFocused_ColorId
+                                                                     : uiInputText_ColorId;
+    /* TODO: If buffered, just draw the buffered copy. */
+    iConstForEach(Array, i, &d->lines) {
+        const iInputLine *line      = i.value;
+        const iBool       isLast    = index_ArrayConstIterator(&i) == size_Array(&d->lines) - 1;
+        const iInputLine *nextLine  = isLast ? NULL : (line + 1);
+        const iRanges     lineRange = { line->offset,
+                                        nextLine ? nextLine->offset : size_Array(&d->text) };
+        if (isFocused && !isEmpty_Range(&d->mark)) {
+            /* Draw the selected range. */
+            const iRanges mark = mark_InputWidget_(d);
+            if (mark.start < lineRange.end && mark.end > lineRange.start) {
+                const int m1 = advanceN_Text(d->font,
+                                             cstr_String(&line->text),
+                                             iMax(lineRange.start, mark.start) - line->offset)
+                                   .x;
+                const int m2 = advanceN_Text(d->font,
+                                             cstr_String(&line->text),
+                                             iMin(lineRange.end, mark.end) - line->offset)
+                                   .x;
+                fillRect_Paint(&p,
+                               (iRect){ addX_I2(drawPos, iMin(m1, m2)),
+                                        init_I2(iAbs(m2 - m1), lineHeight_Text(d->font)) },
+                               uiMarked_ColorId);
+            }
+        }
+        drawRange_Text(d->font, drawPos, fg, range_String(&line->text));
+        drawPos.y += lineHeight_Text(d->font);
+    }
+//    if (d->buffered && !isFocused && !isHint) {
+//        /* Most input widgets will use this, since only one is focused at a time. */
+//        draw_TextBuf(d->buffered, textOrigin, white_ColorId);
+//    }
+//    else {
+//        draw_Text(d->font,
+//                  textOrigin,
+//                  isHint ? uiAnnotation_ColorId
+//                         : isFocused && !isEmpty_Array(&d->text) ? uiInputTextFocused_ColorId
+//                                                                 : uiInputText_ColorId,
+//                  "%s",
+//                  cstr_String(text));
+//    }
     unsetClip_Paint(&p);
     /* Cursor blinking. */
     if (isFocused && d->cursorVis) {
@@ -1073,23 +1355,36 @@ static void draw_InputWidget_(const iInputWidget *d) {
             /* Bar cursor. */
             curSize = init_I2(gap_UI / 2, lineHeight_Text(d->font));
         }
+        const iInputLine *curLine = line_InputWidget_(d, d->cursorLine);
+        const iString *   text    = &curLine->text;
         /* The `gap_UI` offsets below are a hack. They are used because for some reason the
            cursor rect and the glyph inside don't quite position like during `run_Text_()`. */
-        const iInt2 prefixSize = advanceN_Text(d->font, cstr_String(text), d->cursor);
-        const iInt2 curPos     = addX_I2(textOrigin, prefixSize.x +
+        const iInt2 prefixSize = advanceN_Text(d->font, cstr_String(text), d->cursor - curLine->offset);
+        const iInt2 curPos     = addX_I2(addY_I2(contentBounds.pos, lineHeight_Text(d->font) * d->cursorLine),
+                                         prefixSize.x +
                                          (d->mode == insert_InputMode ? -curSize.x / 2 : 0));
         const iRect curRect    = { curPos, curSize };
         fillRect_Paint(&p, curRect, uiInputCursor_ColorId);
         if (d->mode == overwrite_InputMode) {
-            draw_Text(d->font, addX_I2(curPos, iMin(1, gap_UI / 8)), uiInputCursorText_ColorId, "%s", cstr_String(&cur));
+            draw_Text(d->font,
+                      addX_I2(curPos, iMin(1, gap_UI / 8)),
+                      uiInputCursorText_ColorId,
+                      "%s",
+                      cstr_String(&cur));
             deinit_String(&cur);
         }
     }
-    delete_String(text);
+//    delete_String(text);
     drawChildren_Widget(w);
 }
 
+//static void sizeChanged_InputWidget_(iInputWidget *d) {
+//    printf("[InputWidget] %p: size changed, updating layout\n", d);
+//    updateLinesAndResize_InputWidget_(d, iFalse);
+//}
+
 iBeginDefineSubclass(InputWidget, Widget)
     .processEvent = (iAny *) processEvent_InputWidget_,
     .draw         = (iAny *) draw_InputWidget_,
+//    .sizeChanged  = (iAny *) sizeChanged_InputWidget_,
 iEndDefineSubclass(InputWidget)
diff --git a/src/ui/inputwidget.h b/src/ui/inputwidget.h
index 86484dcc..cb32a29c 100644
--- a/src/ui/inputwidget.h
+++ b/src/ui/inputwidget.h
@@ -39,6 +39,8 @@ struct Impl_InputWidgetContentPadding {
     int right;
 };
 
+typedef void (*iInputWidgetValidatorFunc)(iInputWidget *, void *context);
+
 void    setHint_InputWidget     (iInputWidget *, const char *hintText);
 void    setMode_InputWidget     (iInputWidget *, enum iInputMode mode);
 void    setMaxLen_InputWidget   (iInputWidget *, size_t maxLen);
@@ -47,6 +49,9 @@ void    setTextCStr_InputWidget (iInputWidget *, const char *cstr);
 void    setFont_InputWidget     (iInputWidget *, int fontId);
 void    setCursor_InputWidget   (iInputWidget *, size_t pos);
 void    setContentPadding_InputWidget   (iInputWidget *, int left, int right); /* only affects the text entry */
+void    setMaxLayoutLines_InputWidget   (iInputWidget *, size_t maxLayoutLines);
+void    setValidator_InputWidget        (iInputWidget *, iInputWidgetValidatorFunc validator, void *context);
+void    setEnterKeyEnabled_InputWidget  (iInputWidget *, iBool enterKeyEnabled);
 void    begin_InputWidget       (iInputWidget *);
 void    end_InputWidget         (iInputWidget *, iBool accept);
 void    selectAll_InputWidget   (iInputWidget *);
diff --git a/src/ui/root.c b/src/ui/root.c
index 43fadbfa..76ef05c4 100644
--- a/src/ui/root.c
+++ b/src/ui/root.c
@@ -285,6 +285,16 @@ void destroyPending_Root(iRoot *d) {
     setCurrent_Root(NULL);
 }
 
+void postArrange_Root(iRoot *d) {
+    if (!d->pendingArrange) {
+        d->pendingArrange = iTrue;
+        SDL_Event ev = { .type = SDL_USEREVENT };
+        ev.user.code = arrange_UserEventCode;
+        ev.user.data2 = d;
+        SDL_PushEvent(&ev);
+    }
+}
+
 iPtrArray *onTop_Root(iRoot *d) {
     if (!d->onTop) {
         d->onTop = new_PtrArray();
@@ -337,6 +347,12 @@ static iBool handleRootCommands_(iWidget *root, const char *cmd) {
         setFocus_Widget(findWidget_App(cstr_Rangecc(range_Command(cmd, "id"))));
         return iTrue;
     }
+    else if (equal_Command(cmd, "input.resized")) {
+        /* No parent handled this, so do a full rearrangement. */
+        arrange_Widget(root);
+        postRefresh_App();
+        return iTrue;
+    }
     else if (equal_Command(cmd, "window.focus.lost")) {
 #if !defined (iPlatformMobile) /* apps don't share input focus on mobile */
         setFocus_Widget(NULL);
@@ -518,13 +534,17 @@ static iBool willPerformSearchQuery_(const iString *userInput) {
     return !isEmpty_String(&prefs_App()->searchUrl) && !isLikelyUrl_String(userInput);
 }
 
+static void updateUrlInputContentPadding_(iWidget *navBar) {
+    iInputWidget *url = findChild_Widget(navBar, "url");
+    const iWidget *indicators = findChild_Widget(navBar, "url.rightembed");
+    setContentPadding_InputWidget(url, -1,
+                                  width_Widget(indicators));
+}
+
 static void showSearchQueryIndicator_(iBool show) {
     iWidget *indicator = findWidget_App("input.indicator.search");
     showCollapsed_Widget(indicator, show);
-    iAssert(isInstance_Object(parent_Widget(parent_Widget(indicator)), &Class_InputWidget));
-    iInputWidget *url = (iInputWidget *) parent_Widget(parent_Widget(indicator));
-    setContentPadding_InputWidget(url, -1, contentPadding_InputWidget(url).left +
-                                               (show ? width_Widget(indicator) : 0));
+    updateUrlInputContentPadding_(findWidget_Root("navbar"));
 }
 
 static int navBarAvailableSpace_(iWidget *navBar) {
@@ -992,6 +1012,7 @@ void createUserInterface_Root(iRoot *d) {
             setFlags_Widget(as_Widget(url), resizeHeightOfChildren_WidgetFlag, iTrue);
             setSelectAllOnFocus_InputWidget(url, iTrue);
             setId_Widget(as_Widget(url), "url");
+            setMaxLayoutLines_InputWidget(url, 1);
             setUrlContent_InputWidget(url, iTrue);
             setNotifyEdits_InputWidget(url, iTrue);
             setTextCStr_InputWidget(url, "gemini://");
@@ -1017,7 +1038,7 @@ void createUserInterface_Root(iRoot *d) {
                                      moveToParentRightEdge_WidgetFlag);
             /* Feeds refresh indicator is inside the input field. */ {
                 iLabelWidget *queryInd =
-                    new_LabelWidget(uiTextAction_ColorEscape "\u21d2 ${status.query}", NULL);
+                    new_LabelWidget(uiTextAction_ColorEscape "${status.query} \u21a9", NULL);
                 setId_Widget(as_Widget(queryInd), "input.indicator.search");
                 setBackgroundColor_Widget(as_Widget(queryInd), uiBackground_ColorId);
                 setFrameColor_Widget(as_Widget(queryInd), uiTextAction_ColorId);
diff --git a/src/ui/root.h b/src/ui/root.h
index 00555224..96864a15 100644
--- a/src/ui/root.h
+++ b/src/ui/root.h
@@ -11,6 +11,7 @@ struct Impl_Root {
     iWidget *  widget;
     iPtrArray *onTop; /* order is important; last one is topmost */
     iPtrSet *  pendingDestruction;
+    iBool      pendingArrange;
     int        loadAnimTimer;
     iColor     tmPalette[tmMax_ColorId]; /* theme-specific palette */
 };
@@ -28,6 +29,7 @@ iAnyObject *findWidget_Root                     (const char *id); /* under curre
 
 iPtrArray * onTop_Root                          (iRoot *);
 void        destroyPending_Root                 (iRoot *);
+void        postArrange_Root                    (iRoot *);
 
 void        updateMetrics_Root                  (iRoot *);
 void        updatePadding_Root                  (iRoot *); /* TODO: is part of metrics? */
@@ -39,4 +41,4 @@ iRect       rect_Root                           (const iRoot *);
 iRect       safeRect_Root                       (const iRoot *);
 iInt2       visibleSize_Root                    (const iRoot *); /* may be obstructed by software keyboard */
 iBool       isNarrow_Root                       (const iRoot *);
-int         appIconSize_Root                    (void);
\ No newline at end of file
+int         appIconSize_Root                    (void);
diff --git a/src/ui/text.c b/src/ui/text.c
index 8cf4464e..9838fb00 100644
--- a/src/ui/text.c
+++ b/src/ui/text.c
@@ -923,6 +923,13 @@ static iRect run_Font_(iFont *d, const iRunArgs *args) {
             }
             /* TODO: Check out if `uc_wordbreak_property()` from libunistring can be used here. */
             if (ch == '\n') {
+                if (args->xposLimit > 0 && ~mode & noWrapFlag_RunMode) {
+                    /* Stop the line here, this is a hard warp. */
+                    if (args->continueFrom_out) {
+                        *args->continueFrom_out = chPos;
+                    }
+                    break;
+                }
                 xpos = xposExtend = orig.x;
                 ypos += d->height;
                 prevCh = ch;
diff --git a/src/ui/util.c b/src/ui/util.c
index 92cf85b7..04cdf27f 100644
--- a/src/ui/util.c
+++ b/src/ui/util.c
@@ -378,10 +378,20 @@ void init_Click(iClick *d, iAnyObject *widget, int button) {
     d->isActive = iFalse;
     d->button   = button;
     d->bounds   = as_Widget(widget);
+    d->minHeight = 0;
     d->startPos = zero_I2();
     d->pos      = zero_I2();
 }
 
+iBool contains_Click(const iClick *d, iInt2 coord) {
+    if (d->minHeight) {
+        iRect rect = bounds_Widget(d->bounds);
+        rect.size.y = iMax(d->minHeight, rect.size.y);
+        return contains_Rect(rect, coord);
+    }
+    return contains_Widget(d->bounds, coord);
+}
+
 enum iClickResult processEvent_Click(iClick *d, const SDL_Event *event) {
     if (event->type == SDL_MOUSEMOTION) {
         const iInt2 pos = init_I2(event->motion.x, event->motion.y);
@@ -403,7 +413,7 @@ enum iClickResult processEvent_Click(iClick *d, const SDL_Event *event) {
     }
     if (!d->isActive) {
         if (mb->state == SDL_PRESSED) {
-            if (contains_Widget(d->bounds, pos)) {
+            if (contains_Click(d, pos)) {
                 d->isActive = iTrue;
                 d->startPos = d->pos = pos;
                 setMouseGrab_Widget(d->bounds);
@@ -413,7 +423,7 @@ enum iClickResult processEvent_Click(iClick *d, const SDL_Event *event) {
     }
     else { /* Active. */
         if (mb->state == SDL_RELEASED) {
-            enum iClickResult result = contains_Widget(d->bounds, pos)
+            enum iClickResult result = contains_Click(d, pos)
                                            ? finished_ClickResult
                                            : aborted_ClickResult;
             d->isActive = iFalse;
@@ -891,6 +901,14 @@ static iBool isTabPage_Widget_(const iWidget *tabs, const iWidget *page) {
     return page && page->parent == findChild_Widget(tabs, "tabs.pages");
 }
 
+static void unfocusFocusInsideTabPage_(const iWidget *page) {
+    iWidget *focus = focus_Widget();
+    if (page && focus && hasParent_Widget(focus, page)) {
+        printf("unfocus inside page: %p\n", focus);
+        setFocus_Widget(NULL);
+    }
+}
+
 static iBool tabSwitcher_(iWidget *tabs, const char *cmd) {
     if (equal_Command(cmd, "tabs.switch")) {
         iWidget *target = pointerLabel_Command(cmd, "page");
@@ -898,6 +916,7 @@ static iBool tabSwitcher_(iWidget *tabs, const char *cmd) {
             target = findChild_Widget(tabs, cstr_Rangecc(range_Command(cmd, "id")));
         }
         if (!target) return iFalse;
+        unfocusFocusInsideTabPage_(currentTabPage_Widget(tabs));
         if (flags_Widget(target) & focusable_WidgetFlag) {
             setFocus_Widget(target);
         }
@@ -915,6 +934,7 @@ static iBool tabSwitcher_(iWidget *tabs, const char *cmd) {
         }
     }
     else if (equal_Command(cmd, "tabs.next") || equal_Command(cmd, "tabs.prev")) {
+        unfocusFocusInsideTabPage_(currentTabPage_Widget(tabs));
         iWidget *pages = findChild_Widget(tabs, "tabs.pages");
         int tabIndex = 0;
         iConstForEach(ObjectList, i, pages->children) {
@@ -1881,6 +1901,9 @@ iWidget *makeDialogButtons_Widget(const iMenuItem *actions, size_t numActions) {
         }
         iLabelWidget *button =
             addChild_Widget(div, iClob(newKeyMods_LabelWidget(label, key, kmods, cmd)));
+        if (isDefault) {
+            setId_Widget(as_Widget(button), "default");
+        }
         setFlags_Widget(as_Widget(button), alignLeft_WidgetFlag | drawKey_WidgetFlag, isDefault);
         setFont_LabelWidget(button, isDefault ? fonts[1] : fonts[0]);
     }
@@ -2175,6 +2198,10 @@ static void addDialogInputWithHeading_(iWidget *headings, iWidget *values, const
     setPadding_Widget(as_Widget(head), 0, gap_UI, 0, 0);
 #endif
     setId_Widget(addChild_Widget(values, input), inputId);
+    if (deviceType_App() != phone_AppDeviceType) {
+        /* Ensure that the label has the same height as the input widget. */
+        as_Widget(head)->sizeRef = as_Widget(input);
+    }
 }
 
 iInputWidget *addTwoColumnDialogInputField_Widget(iWidget *headings, iWidget *values,
@@ -2202,10 +2229,13 @@ iWidget *makePreferences_Widget(void) {
     /* General preferences. */ {
         appendTwoColumnPage_(tabs, "${heading.prefs.general}", '1', &headings, &values);
 #if defined (LAGRANGE_ENABLE_DOWNLOAD_EDIT)
-        addChild_Widget(headings, iClob(makeHeading_Widget("${prefs.downloads}")));
-        setId_Widget(addChild_Widget(values, iClob(new_InputWidget(0))), "prefs.downloads");
+        //addChild_Widget(headings, iClob(makeHeading_Widget("${prefs.downloads}")));
+        //setId_Widget(addChild_Widget(values, iClob(new_InputWidget(0))), "prefs.downloads");
+        addPrefsInputWithHeading_(headings, values, "prefs.downloads", iClob(new_InputWidget(0)));
 #endif
-        addPrefsInputWithHeading_(headings, values, "prefs.searchurl", iClob(new_InputWidget(0)));
+        iInputWidget *searchUrl;
+        addPrefsInputWithHeading_(headings, values, "prefs.searchurl", iClob(searchUrl = new_InputWidget(0)));
+        setUrlContent_InputWidget(searchUrl, iTrue);
         addChild_Widget(headings, iClob(makePadding_Widget(bigGap)));
         addChild_Widget(values, iClob(makePadding_Widget(bigGap)));
         addChild_Widget(headings, iClob(makeHeading_Widget("${prefs.collapsepreonload}")));
diff --git a/src/ui/util.h b/src/ui/util.h
index cbedefaa..50845280 100644
--- a/src/ui/util.h
+++ b/src/ui/util.h
@@ -154,6 +154,7 @@ struct Impl_Click {
     int      button;
     int      count;
     iWidget *bounds;
+    int      minHeight;
     iInt2    startPos;
     iInt2    pos;
 };
@@ -166,6 +167,7 @@ iBool               isMoved_Click       (const iClick *);
 iInt2               pos_Click           (const iClick *);
 iRect               rect_Click          (const iClick *);
 iInt2               delta_Click         (const iClick *);
+iBool               contains_Click      (const iClick *, iInt2 coord);
 
 /*-----------------------------------------------------------------------------------------------*/
 
diff --git a/src/ui/widget.c b/src/ui/widget.c
index 67ce1345..c1c920d2 100644
--- a/src/ui/widget.c
+++ b/src/ui/widget.c
@@ -54,6 +54,7 @@ void init_Widget(iWidget *d) {
     d->flags          = 0;
     d->rect           = zero_Rect();
     d->minSize        = zero_I2();
+    d->sizeRef        = NULL;
     d->bgColor        = none_ColorId;
     d->frameColor     = none_ColorId;
     init_Anim(&d->visualOffset, 0.0f);
@@ -329,6 +330,9 @@ static void setWidth_Widget_(iWidget *d, int width) {
 
 static void setHeight_Widget_(iWidget *d, int height) {
     iAssert(height >= 0);
+    if (d->sizeRef) {
+        return; /* height defined by another widget */
+    }
     TRACE(d, "attempt to set height to %d (current: %d, min height: %d)", height, d->rect.size.y, d->minSize.y);
     height = iMax(height, d->minSize.y);
     if (~d->flags & fixedHeight_WidgetFlag) { //} || d->flags & collapse_WidgetFlag) {
@@ -415,6 +419,10 @@ static void boundsOfChildren_Widget_(const iWidget *d, iRect *bounds_out) {
 
 static void arrange_Widget_(iWidget *d) {
     TRACE(d, "arranging...");
+    if (d->sizeRef) {
+        d->rect.size.y = height_Widget(d->sizeRef);
+        TRACE(d, "use referenced height: %d", d->rect.size.y);
+    }
     if (d->flags & moveToParentLeftEdge_WidgetFlag) {
         d->rect.pos.x = d->padding[0]; /* FIXME: Shouldn't this be d->parent->padding[0]? */
         TRACE(d, "move to parent left edge: %d", d->rect.pos.x);
@@ -1035,6 +1043,7 @@ void drawBackground_Widget(const iWidget *d) {
         init_Paint(&p);
         drawSoftShadow_Paint(&p, bounds_Widget(d), 12 * gap_UI, black_ColorId, 30);
     }
+    
     if (fadeBackground && ~d->flags & noFadeBackground_WidgetFlag) {
         iPaint p;
         init_Paint(&p);
@@ -1131,10 +1140,10 @@ void drawChildren_Widget(const iWidget *d) {
         }
     }
     /* Root draws the on-top widgets on top of everything else. */
-    if (!d->parent) {
+    if (d == d->root->widget) {
         iConstForEach(PtrArray, i, onTop_Root(d->root)) {
             const iWidget *top = *i.value;
-            draw_Widget(top);
+            class_Widget(top)->draw(top);
         }
     }
 }
diff --git a/src/ui/widget.h b/src/ui/widget.h
index 5b6b18e1..5c05e917 100644
--- a/src/ui/widget.h
+++ b/src/ui/widget.h
@@ -134,6 +134,7 @@ struct Impl_Widget {
     int64_t      flags;
     iRect        rect;
     iInt2        minSize;
+    iWidget *    sizeRef;
     int          padding[4]; /* left, top, right, bottom */
     iAnim        visualOffset;
     int          bgColor;