InputWidget: Word wrapping, inserting newlines

6 files changed, 380 insertions, 108 deletions

diff --git a/src/app.c b/src/app.c
index 3b6752de..1a4112ff 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");
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/ui/inputwidget.c b/src/ui/inputwidget.c
index a1635128..22dd4c92 100644
--- a/src/ui/inputwidget.c
+++ b/src/ui/inputwidget.c
@@ -77,6 +77,28 @@ enum iInputWidgetFlag {
     needUpdateBuffer_InputWidgetFlag = iBit(9),
 };
 
+/*----------------------------------------------------------------------------------------------*/
+
+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;
@@ -84,12 +106,15 @@ struct Impl_InputWidget {
     size_t          maxLen;
     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;
@@ -109,8 +134,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 +157,20 @@ 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);
+    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,17 +186,97 @@ 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;
+        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) {
+    return iMax(1, size_Array(&d->lines)) * 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) + 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)) {
+        updateMetrics_InputWidget_(d);
     }
 }
 
@@ -158,6 +289,7 @@ void init_InputWidget(iInputWidget *d, size_t maxLen) {
 #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,6 +298,8 @@ void init_InputWidget(iInputWidget *d, size_t maxLen) {
     d->rightPadding = 0;
     d->cursor       = 0;
     d->lastCursor   = 0;
+    d->cursorLine   = 0;
+    d->verticalMoveX = -1;
     d->inFlags      = eatEscape_InputWidgetFlag;
     iZap(d->mark);
     setMaxLen_InputWidget(d, maxLen);
@@ -174,10 +308,12 @@ void init_InputWidget(iInputWidget *d, size_t maxLen) {
     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 +326,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 +336,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 +383,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));
@@ -285,27 +423,13 @@ 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();
+//    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 +443,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 +475,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 +484,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,6 +530,7 @@ 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);
     showCursor_InputWidget_(d);
@@ -436,6 +563,7 @@ void end_InputWidget(iInputWidget *d, iBool accept) {
     setFlags_Widget(w, selected_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 +604,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 +623,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 +698,7 @@ static iRanges mark_InputWidget_(const iInputWidget *d) {
 }
 
 static void contentsWereChanged_InputWidget_(iInputWidget *d) {
+    updateLinesAndResize_InputWidget_(d);
     if (d->inFlags & notifyEdits_InputWidgetFlag) {
         postCommand_Widget(d, "input.edited id:%s", cstr_String(id_Widget(constAs_Widget(d))));
     }
@@ -591,21 +764,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 +783,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 +841,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) {
@@ -746,12 +912,14 @@ 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);
@@ -790,8 +958,8 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
             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;
@@ -822,7 +990,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,6 +1023,13 @@ static iBool processEvent_InputWidget_(iInputWidget *d, const SDL_Event *ev) {
                 return iTrue;
             case SDLK_RETURN:
             case SDLK_KP_ENTER:
+                if (mods == KMOD_SHIFT) {
+                    pushUndo_InputWidget_(d);
+                    deleteMarked_InputWidget_(d);
+                    insertChar_InputWidget_(d, '\n');
+                    contentsWereChanged_InputWidget_(d);
+                    return iTrue;
+                }
                 d->inFlags |= enterPressed_InputWidgetFlag;
                 setFocus_Widget(NULL);
                 return iTrue;
@@ -927,7 +1105,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 +1122,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 +1131,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 +1148,21 @@ 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;
+                }
+                break;
+            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;
@@ -1013,11 +1203,13 @@ static void draw_InputWidget_(const 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 +1218,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 +1289,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/root.c b/src/ui/root.c
index 43fadbfa..8db8f7af 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);
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 9532e35a..aacc8d3d 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;