From f3d36ca4c425f8964515c57d513922a6e3cb4636 Mon Sep 17 00:00:00 2001
From: Christian Kaiser <info@ckaiser.com.ar>
Date: Wed, 18 Dec 2024 09:19:30 -0300
Subject: [PATCH 01/15] User data with multiple lines of text (new TextEdit
 widget) (#3130, #3131, #4743, #4968)

---
 data/extensions/aseprite-theme/theme.xml  |    6 +
 data/widgets/layer_properties.xml         |    4 +-
 data/widgets/user_data.xml                |    4 +-
 src/app/commands/cmd_cel_properties.cpp   |    2 +-
 src/app/commands/cmd_layer_properties.cpp |    2 +-
 src/app/ui/skin/skin_theme.cpp            |    2 +
 src/app/ui/slice_window.cpp               |    7 +-
 src/app/ui/user_data_view.cpp             |   12 +-
 src/app/ui/user_data_view.h               |    5 +-
 src/app/widget_loader.cpp                 |    6 +-
 src/gen/ui_class.cpp                      |    2 +
 src/ui/CMakeLists.txt                     |    1 +
 src/ui/textedit.cpp                       | 1059 +++++++++++++++++++++
 src/ui/textedit.h                         |  188 ++++
 src/ui/theme.h                            |    1 +
 src/ui/widget.cpp                         |    3 +
 src/ui/widget_type.h                      |    1 +
 17 files changed, 1287 insertions(+), 18 deletions(-)
 create mode 100644 src/ui/textedit.cpp
 create mode 100644 src/ui/textedit.h

diff --git a/data/extensions/aseprite-theme/theme.xml b/data/extensions/aseprite-theme/theme.xml
index 186251240..aa52a6124 100644
--- a/data/extensions/aseprite-theme/theme.xml
+++ b/data/extensions/aseprite-theme/theme.xml
@@ -1046,6 +1046,12 @@
             <text color="slider_empty_text" align="center middle"/>
             <text color="slider_empty_text" align="center middle" state="focus" y="1"/>
         </style>
+        <style id="textedit" border="2">
+            <background color="textbox_face" />
+            <text color="textbox_text" align="left" />
+            <text color="selected" align="left" state="selected" />
+            <text color="selected_text" align="left" state="selected" />
+        </style>
         <style id="mini_slider" extends="slider" font="mini">
             <background part="mini_slider_empty"/>
             <text color="slider_empty_text" align="center middle"/>
diff --git a/data/widgets/layer_properties.xml b/data/widgets/layer_properties.xml
index ce722668c..b5500a2a3 100644
--- a/data/widgets/layer_properties.xml
+++ b/data/widgets/layer_properties.xml
@@ -4,8 +4,8 @@
 <gui>
 <window id="layer_properties" text="@.title">
   <vbox>
-    <grid id="properties_grid" columns="3">
-      <label text="@.name" for="name" />
+    <grid id="properties_grid" columns="3" expansive="true">
+      <label text="@.name" />
       <entry text="" id="name" magnet="true" maxsize="256" minwidth="64" cell_align="horizontal" />
       <button id="user_data" icon="icon_user_data" tooltip="@general.user_data" />
 
diff --git a/data/widgets/user_data.xml b/data/widgets/user_data.xml
index a1e70f603..6f5d7f157 100644
--- a/data/widgets/user_data.xml
+++ b/data/widgets/user_data.xml
@@ -6,6 +6,8 @@
     <label id="color_label" text="@.color" for="color" />
     <label id="entry_label" text="@.user_data" for="entry" />
     <colorpicker id="color" simple="true" expansive="true" />
-    <entry id="entry" maxsize="65535" minwidth="128" expansive="true" />
+    <view id="text_edit_view" height="30" expansive="true">
+      <textedit id="text_edit" />
+    </view>
   </hbox>
 </gui>
diff --git a/src/app/commands/cmd_cel_properties.cpp b/src/app/commands/cmd_cel_properties.cpp
index d5a7bb0e0..7009f4e34 100644
--- a/src/app/commands/cmd_cel_properties.cpp
+++ b/src/app/commands/cmd_cel_properties.cpp
@@ -344,7 +344,7 @@ private:
         color_t c = m_cel->data()->userData().color();
         m_userDataView.color()->setColor(
           Color::fromRgb(rgba_getr(c), rgba_getg(c), rgba_getb(c), rgba_geta(c)));
-        m_userDataView.entry()->setText(m_cel->data()->userData().text());
+        m_userDataView.textEdit()->setText(m_cel->data()->userData().text());
         // Set last filled values in CelPropertiesWindow
         m_lastValues.opacity = m_cel->opacity();
         m_lastValues.zIndex = m_cel->zIndex();
diff --git a/src/app/commands/cmd_layer_properties.cpp b/src/app/commands/cmd_layer_properties.cpp
index e3e210eb7..3373ddb28 100644
--- a/src/app/commands/cmd_layer_properties.cpp
+++ b/src/app/commands/cmd_layer_properties.cpp
@@ -465,7 +465,7 @@ private:
       color_t c = m_layer->userData().color();
       m_userDataView.color()->setColor(
         Color::fromRgb(rgba_getr(c), rgba_getg(c), rgba_getb(c), rgba_geta(c)));
-      m_userDataView.entry()->setText(m_layer->userData().text());
+      m_userDataView.textEdit()->setText(m_layer->userData().text());
     }
     else {
       name()->setText(Strings::layer_properties_no_layer());
diff --git a/src/app/ui/skin/skin_theme.cpp b/src/app/ui/skin/skin_theme.cpp
index 9612f9e8b..bd0d599bd 100644
--- a/src/app/ui/skin/skin_theme.cpp
+++ b/src/app/ui/skin/skin_theme.cpp
@@ -1233,6 +1233,8 @@ void SkinTheme::initWidget(Widget* widget)
       widget->setStyle(styles.textboxText());
       break;
 
+    case kTextEditWidget: widget->setStyle(styles.textedit()); break;
+
     case kViewWidget:
       widget->setChildSpacing(0);
       widget->setBgColor(colors.windowFace());
diff --git a/src/app/ui/slice_window.cpp b/src/app/ui/slice_window.cpp
index 17b964756..639b22a26 100644
--- a/src/app/ui/slice_window.cpp
+++ b/src/app/ui/slice_window.cpp
@@ -90,10 +90,9 @@ SliceWindow::SliceWindow(const doc::Sprite* sprite,
       entry->Change.connect([this, entry, mod] { onModifyField(entry, mod); });
     }
 
-    ui::Entry* userDataEntry = m_userDataView.entry();
-    userDataEntry->setSuffix("*");
-    userDataEntry->Change.connect(
-      [this, userDataEntry] { onModifyField(userDataEntry, kUserData); });
+    ui::TextEdit* userDataEntry = m_userDataView.textEdit();
+    // userDataEntry->setSuffix("*");
+    userDataEntry->Change.connect([this, userDataEntry] { onModifyField(nullptr, kUserData); });
 
     ColorButton* colorButton = m_userDataView.color();
     colorButton->Click.connect([this] { onPossibleColorChange(); });
diff --git a/src/app/ui/user_data_view.cpp b/src/app/ui/user_data_view.cpp
index b76cc6d83..4d2a052b6 100644
--- a/src/app/ui/user_data_view.cpp
+++ b/src/app/ui/user_data_view.cpp
@@ -58,14 +58,14 @@ void UserDataView::configureAndSet(const doc::UserData& userData, ui::Grid* pare
     parent->addChildInCell(colorLabel(), hspan1, vspan, ui::LEFT);
     parent->addChildInCell(color(), hspan2, vspan, ui::HORIZONTAL);
     parent->addChildInCell(entryLabel(), hspan1, vspan, ui::LEFT);
-    parent->addChildInCell(entry(), hspan2, vspan, ui::HORIZONTAL);
+    parent->addChildInCell(textEditView(), hspan2, vspan, ui::HORIZONTAL | ui::VERTICAL);
     color()->Change.connect([this] { onColorChange(); });
-    entry()->Change.connect([this] { onEntryChange(); });
+    textEdit()->Change.connect([this] { onEntryChange(); });
     m_isConfigured = true;
   }
   m_userData = userData;
   color()->setColor(Color::fromImage(doc::IMAGE_RGB, userData.color()));
-  entry()->setText(m_userData.text());
+  textEdit()->setText(m_userData.text());
   setVisible(isVisible());
 }
 
@@ -79,15 +79,15 @@ void UserDataView::setVisible(bool state, bool saveAsDefault)
   colorLabel()->setVisible(state);
   color()->setVisible(state);
   entryLabel()->setVisible(state);
-  entry()->setVisible(state);
+  textEditView()->setVisible(state);
   if (saveAsDefault)
     m_visibility.setValue(state);
 }
 
 void UserDataView::onEntryChange()
 {
-  if (entry()->text() != m_userData.text()) {
-    m_userData.setText(entry()->text());
+  if (textEdit()->text() != m_userData.text()) {
+    m_userData.setText(textEdit()->text());
     if (!m_selfUpdate)
       UserDataChange();
   }
diff --git a/src/app/ui/user_data_view.h b/src/app/ui/user_data_view.h
index 4aae0888b..4fdb839ba 100644
--- a/src/app/ui/user_data_view.h
+++ b/src/app/ui/user_data_view.h
@@ -13,9 +13,9 @@
 #include "doc/user_data.h"
 #include "obs/signal.h"
 #include "ui/base.h"
-#include "ui/entry.h"
 #include "ui/grid.h"
 #include "ui/label.h"
+#include "ui/textedit.h"
 
 #include "user_data.xml.h"
 
@@ -31,7 +31,8 @@ public:
 
   const doc::UserData& userData() const { return m_userData; }
   ColorButton* color() { return m_container.color(); }
-  ui::Entry* entry() { return m_container.entry(); }
+  ui::TextEdit* textEdit() { return m_container.textEdit(); }
+  ui::View* textEditView() { return m_container.textEditView(); }
   ui::Label* colorLabel() { return m_container.colorLabel(); }
   ui::Label* entryLabel() { return m_container.entryLabel(); }
 
diff --git a/src/app/widget_loader.cpp b/src/app/widget_loader.cpp
index 63f573a5d..ad4cf1f0d 100644
--- a/src/app/widget_loader.cpp
+++ b/src/app/widget_loader.cpp
@@ -35,6 +35,7 @@
 #include "base/fs.h"
 #include "base/memory.h"
 #include "os/system.h"
+#include "ui/textedit.h"
 #include "ui/ui.h"
 
 #include "tinyxml2.h"
@@ -259,13 +260,16 @@ Widget* WidgetLoader::convertXmlElementToWidget(const XMLElement* elem,
     if (elem_name == "expr" && decimals)
       ((ExprEntry*)widget)->setDecimals(strtol(decimals, nullptr, 10));
   }
-  if (elem_name == "filename") {
+  else if (elem_name == "filename") {
     const bool buttononly = bool_attr(elem, "buttononly", false);
     const app::FilenameField::Type type = (buttononly ? app::FilenameField::Type::ButtonOnly :
                                                         app::FilenameField::Type::EntryAndButton);
 
     widget = new app::FilenameField(type, "");
   }
+  else if (elem_name == "textedit") {
+    widget = new TextEdit();
+  }
   else if (elem_name == "grid") {
     const char* columns = elem->Attribute("columns");
     bool same_width_columns = bool_attr(elem, "same_width_columns", false);
diff --git a/src/gen/ui_class.cpp b/src/gen/ui_class.cpp
index 891c10447..b2fe700fc 100644
--- a/src/gen/ui_class.cpp
+++ b/src/gen/ui_class.cpp
@@ -102,6 +102,8 @@ static Item convert_to_item(XMLElement* elem)
     return item.typeIncl("app::DropDownButton", "app/ui/drop_down_button.h");
   if (name == "entry")
     return item.typeIncl("ui::Entry", "ui/entry.h");
+  if (name == "textedit")
+    return item.typeIncl("ui::TextEdit", "ui/textedit.h");
   if (name == "expr")
     return item.typeIncl("app::ExprEntry", "app/ui/expr_entry.h");
   if (name == "filename")
diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index 479b531f1..fd318316f 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -50,6 +50,7 @@ add_library(ui-lib
   style.cpp
   system.cpp
   textbox.cpp
+  textedit.cpp
   theme.cpp
   timer.cpp
   tooltips.cpp
diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
new file mode 100644
index 000000000..bf680e2da
--- /dev/null
+++ b/src/ui/textedit.cpp
@@ -0,0 +1,1059 @@
+// Aseprite
+// Copyright (C) 2024  Igara Studio S.A.
+// Copyright (C) 2001-2018  David Capello
+//
+// This program is distributed under the terms of
+// the End-User License Agreement for Aseprite.
+
+#ifdef HAVE_CONFIG_H
+  #include "config.h"
+#endif
+
+#include "ui/textedit.h"
+
+#include "base/replace_string.h"
+#include "base/split_string.h"
+#include "os/system.h"
+#include "text/font_metrics.h"
+#include "text/font_mgr.h"
+#include "text/text_blob.h"
+#include "ui/menu.h"
+#include "ui/message.h"
+#include "ui/paint_event.h"
+#include "ui/resize_event.h"
+#include "ui/scale.h"
+#include "ui/scroll_helper.h"
+#include "ui/scroll_region_event.h"
+#include "ui/size_hint_event.h"
+#include "ui/system.h"
+#include "ui/theme.h"
+#include "ui/timer.h"
+#include "ui/view.h"
+
+#include <algorithm>
+
+namespace ui {
+
+// Shared timer between all editors.
+static std::unique_ptr<Timer> s_timer;
+
+TextEdit::TextEdit() : Widget(kTextEditWidget), m_caret(&m_lines)
+{
+  enableFlags(CTRL_RIGHT_CLICK);
+  setFocusStop(true);
+  InitTheme.connect([this] {
+    ASSERT(style()->layers().size() == 4);
+    m_colorBG = style()->layers()[0].color();
+
+    m_textPaint.color(style()->layers()[1].color());
+    m_textPaint.style(os::Paint::Fill);
+
+    m_colorSelected = style()->layers()[2].color();
+
+    m_selectedTextPaint.color(style()->layers()[3].color());
+    m_selectedTextPaint.style(os::Paint::Fill);
+  });
+  initTheme();
+}
+
+void TextEdit::cut()
+{
+  if (m_selection.isEmpty())
+    return;
+
+  copy();
+
+  deleteSelection();
+}
+
+void TextEdit::copy()
+{
+  if (m_selection.isEmpty())
+    return;
+
+  const size_t startPos = m_selection.start().absolutePos();
+  set_clipboard_text(text().substr(startPos, m_selection.end().absolutePos() - startPos));
+}
+
+void TextEdit::paste()
+{
+  if (!m_caret.isValid())
+    m_caret = Caret(&m_lines, 0, 0); // TODO: Can we just ensure this doesn't happen?
+
+  std::string clipboard;
+  if (!get_clipboard_text(clipboard) || clipboard.empty())
+    return;
+
+  deleteSelection();
+  base::replace_string(clipboard, "\r\n", "\n");
+
+  std::string newText = text();
+  newText.insert(m_caret.absolutePos(), clipboard);
+
+  if (!m_lines.empty() && clipboard.find('\n') == std::string::npos) {
+    auto& line = m_lines[m_caret.line()];
+    line.insertText(m_caret.pos(), clipboard);
+    line.buildBlob(this);
+    setTextQuiet(newText);
+    Change();
+  }
+  else {
+    setText(newText);
+  }
+
+  m_caret.advanceBy(clipboard.size());
+}
+
+void TextEdit::selectAll()
+{
+  if (text().empty() || m_lines.empty())
+    return;
+
+  const Caret startCaret(&m_lines);
+  Caret endCaret(startCaret);
+  endCaret.set(m_lines.size() - 1, m_lines.back().glyphCount);
+
+  m_selection.set(startCaret, endCaret);
+}
+
+bool TextEdit::onProcessMessage(Message* msg)
+{
+  switch (msg->type()) {
+    case kTimerMessage: {
+      if (hasFocus() && static_cast<TimerMessage*>(msg)->timer() == s_timer.get()) {
+        m_drawCaret = !m_drawCaret;
+        invalidateRect(m_caretRect);
+      }
+      break;
+    }
+    case kFocusEnterMessage: {
+      startTimer();
+      m_drawCaret = true; // Immediately draw the caret for fast UI feedback.
+      invalidate();
+      os::System::instance()->setTextInput(true, m_caretRect.center());
+      break;
+    }
+    case kFocusLeaveMessage: {
+      stopTimer();
+      m_drawCaret = false;
+      invalidateRect(m_caretRect);
+      os::System::instance()->setTextInput(false);
+      break;
+    }
+    case kKeyDownMessage: {
+      if (hasFocus() && onKeyDown(static_cast<KeyMessage*>(msg))) {
+        m_drawCaret = true;
+        invalidate();
+        ensureCaretVisible();
+        return true;
+      }
+      break;
+    }
+    case kDoubleClickMessage: {
+      if (!hasFocus())
+        requestFocus();
+
+      const auto* mouseMessage = static_cast<MouseMessage*>(msg);
+      Caret leftCaret = caretFromPosition(mouseMessage->position());
+      if (!leftCaret.isValid())
+        return false;
+
+      Caret rightCaret = leftCaret;
+      leftCaret.leftWord();
+      rightCaret.rightWord();
+
+      if (leftCaret != rightCaret) {
+        m_selection.set(leftCaret, rightCaret);
+        m_caret = rightCaret;
+        invalidate();
+        captureMouse();
+        return true;
+      }
+      break;
+    }
+    case kMouseDownMessage:
+      if (msg->shiftPressed())
+        m_lockedSelectionStart = m_selection.isEmpty() ? m_caret : m_selection.start();
+      else if (!hasCapture() && static_cast<MouseMessage*>(msg)->left()) {
+        // Only clear the selection when we don't have a capture, to avoid stepping on double click
+        // selection.
+        m_selection.clear();
+      }
+
+      captureMouse();
+
+      stopTimer();
+      m_drawCaret = true;
+
+      [[fallthrough]]; // onMouseMove sets our caret position when we click.
+    case kMouseMoveMessage:
+      if (hasCapture() && onMouseMove(static_cast<MouseMessage*>(msg))) {
+        invalidate();
+        ensureCaretVisible();
+        return true;
+      }
+      break;
+    case kMouseUpMessage: {
+      if (hasCapture()) {
+        releaseMouse();
+        startTimer();
+
+        const auto* mouseMsg = static_cast<MouseMessage*>(msg);
+        if (mouseMsg->right()) {
+          showEditPopupMenu(mouseMsg->position());
+          requestFocus();
+          return true;
+        }
+
+        if (msg->shiftPressed()) {
+          m_selection.set(m_lockedSelectionStart, m_caret);
+        }
+        m_lockedSelectionStart.clear();
+      }
+      break;
+    }
+    case kMouseWheelMessage: {
+      View::scrollByMessage(this, msg);
+      break;
+    }
+  }
+
+  return Widget::onProcessMessage(msg);
+}
+
+bool TextEdit::onKeyDown(const KeyMessage* keyMessage)
+{
+  const KeyScancode scancode = keyMessage->scancode();
+  const bool byWord = keyMessage->ctrlPressed();
+  const Caret prevCaret(m_caret);
+
+  switch (scancode) {
+    case kKeyLeft:  m_caret.left(byWord); break;
+    case kKeyRight: m_caret.right(byWord); break;
+    case kKeyHome:  m_caret.setPos(0); break;
+    case kKeyEnd:   m_caret.set(m_lines.back().i, m_lines.back().glyphCount); break;
+    case kKeyUp:    m_caret.up(); break;
+    case kKeyDown:  m_caret.down(); break;
+    case kKeyEnter: {
+      deleteSelection();
+
+      std::string newText = text();
+      newText.insert(m_caret.absolutePos(), "\n");
+      setText(newText);
+
+      m_caret.set(m_caret.line() + 1, 0);
+      return true;
+    }
+    case kKeyBackspace: [[fallthrough]];
+    case kKeyDel:       {
+      if (m_selection.isEmpty() || !m_selection.isValid()) {
+        Caret startCaret = m_caret;
+        Caret endCaret = startCaret;
+
+        if (scancode == kKeyBackspace) {
+          startCaret.left(byWord);
+        }
+        else {
+          endCaret.right(byWord);
+        }
+
+        m_selection.set(startCaret, endCaret);
+      }
+
+      deleteSelection();
+      return true;
+    }
+    default:
+      if (keyMessage->unicodeChar() >= 32) {
+        deleteSelection();
+        if (keyMessage->isDeadKey()) {
+          return true;
+        }
+
+        insertCharacter(keyMessage->unicodeChar());
+        return true;
+      }
+      if (scancode >= kKeyFirstModifierScancode) {
+        return true;
+      }
+#if defined __APPLE__
+      if (keyMessage->onlyCmdPressed())
+#else
+      if (keyMessage->onlyCtrlPressed())
+#endif
+      {
+        switch (scancode) {
+          case kKeyX: {
+            cut();
+            return true;
+          }
+          case kKeyC: {
+            copy();
+            return true;
+          }
+          case kKeyV: {
+            paste();
+            return true;
+          }
+          case kKeyA: {
+            selectAll();
+            return true;
+          }
+        }
+      }
+      return false;
+  }
+
+  // Selection modification
+  if (keyMessage->shiftPressed()) {
+    if (!m_selection.isValid() || m_selection.isEmpty()) {
+      m_lockedSelectionStart = prevCaret;
+    }
+
+    m_selection.set(m_lockedSelectionStart, m_caret);
+  }
+  else
+    m_selection.clear();
+
+  return true;
+}
+
+bool TextEdit::onMouseMove(const MouseMessage* mouseMessage)
+{
+  const Caret mouseCaret = caretFromPosition(mouseMessage->position());
+  if (!mouseCaret.isValid() || mouseMessage->right())
+    return false;
+
+  m_caret = mouseCaret;
+
+  if (!m_lockedSelectionStart.isValid()) {
+    m_lockedSelectionStart = m_caret;
+    return true;
+  }
+
+  m_selection.set(m_lockedSelectionStart, m_caret);
+  return true;
+}
+
+void TextEdit::onPaint(PaintEvent& ev)
+{
+  Graphics* g = ev.graphics();
+  const auto* view = View::getView(this);
+  ASSERT(view);
+  if (!view)
+    return;
+
+  const gfx::Rect rect = view->viewportBounds().offset(-bounds().origin());
+  g->fillRect(m_colorBG, rect);
+
+  const auto& scroll = view->viewScroll();
+  gfx::PointF point(border().left(), border().top());
+  point -= scroll;
+
+  m_caretRect =
+    gfx::Rect(border().left() - scroll.x, border().top() - scroll.y, 2, font()->lineHeight());
+
+  const gfx::Rect clipBounds = g->getClipBounds();
+
+  for (const auto& line : m_lines) {
+    const bool caretLine = (line.i == m_caret.line());
+
+    // Skip drawing lines when they're out of scroll bounds or they're outside the clip bounds,
+    // unless we're in the caret line, in which case we need to draw the text to avoid blank
+    // characters.
+    const bool skip =
+      (point.y + line.height < scroll.y || point.y > scroll.y + rect.h) ||
+      (!clipBounds.intersects(gfx::Rect(point.x, point.y, line.width, line.height)) && !caretLine);
+
+    if (!skip) {
+      g->drawTextBlob(line.blob, point, m_textPaint);
+
+      // Drawing the selection rect and any selected text.
+      // We're technically drawing over the old text, so ideally we want to clip that off as well?
+      const gfx::RectF selectionRect = getSelectionRect(line, point);
+      if (!selectionRect.isEmpty()) {
+        g->fillRect(m_colorSelected, selectionRect);
+
+        const IntersectClip clip(g, selectionRect);
+        if (clip)
+          g->drawTextBlob(line.blob, point, m_selectedTextPaint);
+      }
+    }
+
+    // If we're in the caret's line, run this blob to grab where we should position it.
+    if (caretLine) {
+      if (m_caret.isLastInLine()) {
+        m_caretRect.x += line.width;
+      }
+      else if (m_caret.pos() > 0) {
+        m_caretRect.x += line.getBounds(m_caret.pos()).x;
+      }
+
+      m_caretRect.y = point.y;
+      m_caretRect.h = line.height; // Ensure the caret height corresponds with the tallest glyph
+    }
+
+    point.y += line.height;
+  }
+
+  if (m_drawCaret)
+    g->drawRect(m_caretRect, m_textPaint);
+
+  m_caretRect.offset(gfx::Point(g->getInternalDeltaX(), g->getInternalDeltaY()));
+}
+
+void TextEdit::onSizeHint(SizeHintEvent& ev)
+{
+  ev.setSizeHint(m_textSize);
+}
+
+void TextEdit::onScrollRegion(ScrollRegionEvent& ev)
+{
+  invalidateRegion(ev.region());
+}
+
+gfx::RectF TextEdit::getSelectionRect(const Line& line, const gfx::PointF& offset) const
+{
+  if (m_selection.isEmpty() || !m_selection.isValid())
+    return gfx::RectF();
+
+  if (m_selection.start().line() > line.i || m_selection.end().line() < line.i)
+    return gfx::RectF();
+
+  gfx::RectF selectionRect(offset, gfx::SizeF{});
+
+  if (!line.blob) {
+    // No blob so this must be an empty line in the middle of a selection, just give it a marginal
+    // width so it's noticeable.
+    selectionRect.w = line.height / 2.0;
+  }
+  else if (
+    // Detect when this entire line is selected, to avoid doing any runs and just painting it all
+    // Case 1: Start and end line is this line, and the firstPos and endPos is 0 and the line's
+    // length.
+    (m_selection.start().line() == line.i && m_selection.end().line() == line.i &&
+     m_selection.start().pos() == 0 && m_selection.end().pos() == line.glyphCount)
+    // Case 2: We start at this line and position zero, we end in a higher line.
+    || (m_selection.start().line() == line.i && m_selection.start().pos() == 0 &&
+        m_selection.end().line() > line.i)
+    // Case 3: We started on a previous line, and we continue on another.
+    || (m_selection.start().line() < line.i && m_selection.end().line() > line.i)) {
+    selectionRect.w = line.width;
+  }
+  else if (m_selection.start().line() < line.i && m_selection.end().line() == line.i) {
+    // The selection ends in this line, starts from the leftmost side
+    const auto& lineBounds = line.getBounds(0, m_selection.end().pos());
+    selectionRect.x += lineBounds.x;
+    selectionRect.w = lineBounds.w;
+  }
+  else if (m_selection.start().line() == line.i && m_selection.end().line() == line.i) {
+    // Selection is contained within this line
+    const auto& lineBounds = line.getBounds(m_selection.start().pos(), m_selection.end().pos());
+    selectionRect.x += lineBounds.x;
+    selectionRect.w = lineBounds.w;
+  }
+  else if (m_selection.start().line() == line.i) {
+    // The selection starts in this line at an offset position, and ends at the end of the run
+    const auto& lineBounds = line.getBounds(m_selection.start().pos(),
+                                            m_lines[m_selection.start().line()].glyphCount);
+    selectionRect.x += lineBounds.x;
+    selectionRect.w = lineBounds.w;
+  }
+
+  selectionRect.h = line.height; // Normalize the height of the rect so it doesn't vary.
+  return selectionRect;
+}
+
+TextEdit::Caret TextEdit::caretFromPosition(const gfx::Point& position)
+{
+  const auto* view = View::getView(this);
+  if (!view)
+    return Caret();
+
+  if (m_lines.empty())
+    return Caret(&m_lines, 0, 0);
+
+  // Deduce the position the user wants to go when clicking outside of bounds
+  if (!view->viewportBounds().contains(position)) {
+    if (position.y < view->viewportBounds().y) {
+      return Caret(&m_lines, 0, 0);
+    }
+
+    if (position.y > view->viewportBounds().y2()) {
+      return Caret(&m_lines, m_lines.size() - 1, m_lines.back().glyphCount);
+    }
+
+    if (position.x > view->viewportBounds().x2()) {
+      Caret caret = m_caret;
+      caret.right();
+      return caret;
+    }
+
+    return Caret();
+  }
+
+  // Normalize the mouse position to the internal coordinates of the widget
+  gfx::PointF offsetPosition(position.x - (bounds().x + border().left()),
+                             position.y - (bounds().y + border().top()));
+
+  offsetPosition += View::getView(this)->viewScroll();
+
+  Caret caret(&m_lines);
+  const int lineHeight = font()->lineHeight();
+
+  // First check if the offset position is blank (below all the lines)
+  if (offsetPosition.y > m_lines.size() * lineHeight) {
+    // Get the last character in the last line.
+    caret.setLine(m_lines.size() - 1);
+
+    // Check the line width and if we're more than halfway past the line, we can set the caret to
+    // the full line.
+    caret.setPos(
+      (offsetPosition.x > m_lines[caret.line()].width / 2) ? m_lines[caret.line()].glyphCount : 0);
+    return caret;
+  }
+
+  for (const Line& line : m_lines) {
+    const size_t lineStartY = line.i * lineHeight;
+    const size_t lineEndY = (line.i + 1) * lineHeight;
+
+    if (offsetPosition.y > lineEndY || offsetPosition.y < lineStartY)
+      continue; // We're not in this line
+
+    caret.setLine(line.i);
+
+    if (!line.blob)
+      break; // Line has no text, we can end it here.
+
+    if (offsetPosition.x > line.width) {
+      // Clicking on the blank space next to a line should put our caret at the end of it.
+      caret.setPos(line.glyphCount);
+      break;
+    }
+
+    // Find the exact character we're standing on, with a slight bias to the left or right
+    // depending on where we click wrt the glyph bounds
+    size_t advance = 0;
+    bool found = false;
+
+    line.blob->visitRuns([&](const text::TextBlob::RunInfo& run) {
+      if (found) {
+        return;
+      }
+
+      for (int i = 0; i < run.glyphCount; ++i) {
+        gfx::RectF glyphBounds = run.getGlyphBounds(i).offset(gfx::PointF(0, lineStartY));
+
+        if (glyphBounds.contains(offsetPosition)) {
+          found = true;
+
+          if (offsetPosition.x > glyphBounds.center().x && advance != line.glyphCount)
+            ++advance; // If the mouse is to the right of the glyph, prefer the next position.
+
+          return;
+        }
+
+        ++advance;
+      }
+    });
+
+    if (found) {
+      caret.setPos(advance);
+    }
+  }
+
+  return caret;
+}
+
+void TextEdit::showEditPopupMenu(const gfx::Point& position)
+{
+  auto* translate = UISystem::instance()->translationDelegate();
+  ASSERT(translate); // We provide UISystem as default translation delegate
+  if (!translate)
+    return;
+
+  Menu menu;
+  MenuItem cut(translate->cut());
+  MenuItem copy(translate->copy());
+  MenuItem paste(translate->paste());
+  MenuItem selectAll(translate->selectAll());
+
+  cut.processMnemonicFromText();
+  copy.processMnemonicFromText();
+  paste.processMnemonicFromText();
+  selectAll.processMnemonicFromText();
+
+  menu.addChild(&cut);
+  menu.addChild(&copy);
+  menu.addChild(&paste);
+  menu.addChild(new MenuSeparator);
+  menu.addChild(&selectAll);
+
+  cut.setEnabled(!m_selection.isEmpty());
+  copy.setEnabled(!m_selection.isEmpty());
+
+  cut.Click.connect(&TextEdit::cut, this);
+  copy.Click.connect(&TextEdit::copy, this);
+  paste.Click.connect(&TextEdit::paste, this);
+  selectAll.Click.connect(&TextEdit::selectAll, this);
+
+  menu.showPopup(position, display());
+}
+
+void TextEdit::insertCharacter(base::codepoint_t character)
+{
+  const std::string unicodeStr = base::codepoint_to_utf8(character);
+
+  if (m_lines.empty()) {
+    // Fast path for the first char.
+    setText(unicodeStr);
+    m_caret.setPos(m_caret.pos() + 1);
+    return;
+  }
+
+  auto& line = m_lines[m_caret.line()];
+  line.insertText(m_caret.pos(), unicodeStr);
+  line.buildBlob(this);
+
+  std::string newText = text();
+  newText.insert(m_caret.absolutePos(), unicodeStr);
+  setTextQuiet(newText);
+  Change();
+
+  m_caret.setPos(m_caret.pos() + 1);
+}
+
+void TextEdit::deleteSelection()
+{
+  if (m_selection.isEmpty() || !m_selection.isValid())
+    return;
+
+  std::string newText = text();
+  newText.erase(newText.begin() + m_selection.start().absolutePos(),
+                newText.begin() + m_selection.end().absolutePos());
+
+  if (m_selection.start().line() == m_selection.end().line()) {
+    auto& line = m_lines[m_selection.start().line()];
+    size_t end;
+    if (m_selection.end().isLastInLine())
+      end = line.utfSize.back().end;
+    else
+      end = line.utfSize[m_selection.end().pos()].begin;
+
+    line.text.erase(line.text.begin() + line.utfSize[m_selection.start().pos()].begin,
+                    line.text.begin() + end);
+    line.buildBlob(this);
+
+    // Only rebuilds the one line
+    setTextQuiet(newText);
+    Change();
+  }
+  else {
+    setText(newText);
+  }
+
+  m_caret = m_selection.start();
+  m_selection.clear();
+}
+
+void TextEdit::ensureCaretVisible()
+{
+  auto* view = View::getView(this);
+  if (!view || !view->hasScrollBars() || !m_caret.isValid())
+    return;
+
+  const int scrollBarWidth = theme()->getScrollbarSize();
+
+  if (view->viewportBounds().shrink(scrollBarWidth).intersects(m_caretRect))
+    return; // We are visible and don't need to do anything.
+
+  const int lineHeight = font()->lineHeight();
+  gfx::Point scroll = view->viewScroll();
+  const gfx::Size visibleBounds = view->viewportBounds().size();
+
+  if (view->verticalBar()->isVisible()) {
+    const int heightLimit = (visibleBounds.h + scroll.y - lineHeight) / 2;
+    const size_t currentLine = (m_caret.line() * lineHeight) / 2;
+
+    if (currentLine <= scroll.y)
+      scroll.y = currentLine;
+    else if (currentLine >= heightLimit) // TODO: I do not like this
+      scroll.y = currentLine - ((visibleBounds.h - (lineHeight * 2)) / 2);
+  }
+
+  const auto& line = m_lines[m_caret.line()];
+  if (view->horizontalBar()->isVisible() && line.blob && line.width > visibleBounds.w) {
+    const int caretX = line.getBounds(0, m_caret.pos()).w;
+    const int horizontalLimit = scroll.x + visibleBounds.w - view->horizontalBar()->getBarWidth();
+
+    if (m_caret.pos() == 0)
+      scroll.x = 0;
+    else if (caretX > horizontalLimit)
+      scroll.x = caretX - horizontalLimit;
+    else if (scroll.x > caretX / 2) // TODO: Something's a bit bouncy here (in a bad way)
+      scroll.x = caretX / 2;
+  }
+
+  view->setViewScroll(scroll);
+}
+
+void TextEdit::onSetText()
+{
+  std::vector<std::string_view> newLines;
+  newLines.reserve(m_lines.size()); // Assume lines will be around the same size as before, if any
+
+  // Recalculate all the lines based on the widget's text
+  m_lines.clear();
+
+  base::split_string(text(), newLines, "\n");
+  m_lines.reserve(newLines.size());
+
+  int longestWidth = 0;
+  int totalHeight = 0;
+
+  for (const auto& lineString : newLines) {
+    Line newLine;
+    newLine.text = lineString;
+    newLine.buildBlob(this);
+
+    longestWidth = std::max(newLine.width, longestWidth);
+    totalHeight += newLine.height;
+
+    newLine.i = m_lines.size();
+    m_lines.push_back(newLine);
+  }
+
+  m_textSize.w = longestWidth;
+  m_textSize.h = totalHeight;
+
+  if (auto* view = View::getView(this))
+    view->updateView();
+
+  Change();
+  Widget::onSetText();
+
+  // TODO: Test with IMEs? Is this function made to be called a bunch?
+  os::System::instance()->setTextInput(true, m_drawCaret ? m_caretRect.center() : gfx::Point{});
+}
+
+void TextEdit::onSetFont()
+{
+  Widget::onSetFont();
+
+  // Invalidate all blobs
+  onSetText();
+}
+
+void TextEdit::startTimer()
+{
+  if (s_timer)
+    s_timer->stop();
+  s_timer = std::make_unique<Timer>(500, this);
+  s_timer->start();
+}
+
+void TextEdit::stopTimer()
+{
+  if (s_timer) {
+    s_timer->stop();
+    s_timer.reset();
+  }
+}
+
+struct Utf8RangeBuilder : public text::TextBlob::RunHandler {
+  explicit Utf8RangeBuilder(size_t minSize) { ranges.reserve(minSize); }
+
+  void commitRunBuffer(TextBlob::RunInfo& info) override
+  {
+    ASSERT(info.clusters == nullptr || *info.clusters == 0);
+    for (size_t i = 0; i < info.glyphCount; ++i) {
+      ranges.push_back(info.getGlyphUtf8Range(i));
+    }
+  }
+
+  std::vector<TextBlob::Utf8Range> ranges;
+};
+
+void TextEdit::Line::buildBlob(const Widget* forWidget)
+{
+  utfSize.clear();
+
+  if (text.empty()) {
+    blob = nullptr;
+    width = 0;
+    glyphCount = 0;
+    height = forWidget->font()->metrics(nullptr);
+    return;
+  }
+
+  Utf8RangeBuilder rangeBuilder(text.size());
+  blob = text::TextBlob::MakeWithShaper(forWidget->theme()->fontMgr(),
+                                        forWidget->font(),
+                                        text,
+                                        &rangeBuilder);
+
+  utfSize = std::move(rangeBuilder.ranges);
+  glyphCount = utfSize.size();
+
+  width = blob->bounds().w;
+  height = std::max(blob->bounds().h, forWidget->font()->metrics(nullptr));
+}
+
+// Insert text into this line based on a caret position, taking into account utf8 size.
+void TextEdit::Line::insertText(size_t pos, const std::string& str)
+{
+  if (pos == 0)
+    text.insert(0, str);
+  else if (pos == glyphCount)
+    text.append(str);
+  else
+    text.insert(utfSize[pos - 1].end, str);
+}
+
+gfx::Rect TextEdit::Line::getBounds(size_t glyph) const
+{
+  size_t advance = 0;
+  gfx::Rect result;
+  blob->visitRuns([&](const text::TextBlob::RunInfo& run) {
+    for (size_t i = 0; i < run.glyphCount; ++i) {
+      if (advance == glyph) {
+        result = run.getGlyphBounds(i);
+        return;
+      }
+      ++advance;
+    }
+  });
+  return result;
+}
+
+gfx::Rect TextEdit::Line::getBounds(size_t startGlyph, size_t endGlyph) const
+{
+  if (startGlyph == endGlyph)
+    return getBounds(startGlyph);
+
+  ASSERT(endGlyph > startGlyph);
+
+  size_t advance = 0; // The amount of glyphs we've advanced through.
+  gfx::Rect resultBounds;
+
+  blob->visitRuns([&](text::TextBlob::RunInfo& run) {
+    if (advance >= endGlyph)
+      return;
+
+    if (startGlyph > (advance + run.glyphCount)) {
+      advance += run.glyphCount;
+      return; // Skip this run
+    }
+
+    size_t j = 0;
+    if (advance < startGlyph) {
+      j = startGlyph - advance;
+      advance += j;
+    }
+
+    for (; j < run.glyphCount; ++j) {
+      ++advance;
+      resultBounds |= run.getGlyphBounds(j);
+
+      if (advance >= endGlyph)
+        return;
+    }
+  });
+
+  ASSERT(advance == endGlyph);
+
+  return resultBounds;
+}
+
+void TextEdit::Caret::setPos(size_t pos)
+{
+  ASSERT(pos >= 0 && pos <= lineObj().glyphCount);
+  m_pos = pos;
+}
+
+void TextEdit::Caret::set(size_t line, size_t pos)
+{
+  m_line = line;
+  m_pos = pos;
+}
+
+bool TextEdit::Caret::left(bool byWord)
+{
+  if (byWord)
+    return leftWord();
+
+  m_pos -= 1;
+
+  if (((int64_t)(m_pos)-1) < 0) {
+    if (m_line == 0) {
+      m_pos = 0;
+      return false;
+    }
+
+    m_line -= 1;
+    m_pos = lineObj().glyphCount;
+  }
+
+  return true;
+}
+
+bool TextEdit::Caret::leftWord()
+{
+  if (m_pos == 0)
+    return false;
+
+  auto startPos = m_pos;
+  while (isWordPart(m_pos)) {
+    if (!left())
+      return m_pos != startPos;
+  }
+  return true;
+}
+
+bool TextEdit::Caret::right(bool byWord)
+{
+  if (byWord)
+    return rightWord();
+
+  m_pos += 1;
+
+  if (m_pos > lineObj().glyphCount) {
+    if (m_line == m_lines->size() - 1) {
+      m_pos -= 1; // Undo movement, we've reached the end of the text.
+      return false;
+    }
+
+    m_line += 1;
+    m_pos = 0;
+  }
+
+  return true;
+}
+
+bool TextEdit::Caret::rightWord()
+{
+  if (m_pos == lineObj().glyphCount)
+    return false;
+
+  auto startPos = m_pos;
+  while (isWordPart(m_pos)) {
+    if (!right())
+      return m_pos != startPos;
+  }
+  return true;
+}
+
+void TextEdit::Caret::up()
+{
+  m_line = std::clamp(m_line - 1, size_t(0), m_lines->size() - 1);
+  m_pos = std::clamp(m_pos, size_t(0), lineObj().glyphCount);
+}
+
+void TextEdit::Caret::down()
+{
+  m_line = std::clamp(m_line + 1, size_t(0), m_lines->size() - 1);
+  m_pos = std::clamp(m_pos, size_t(0), lineObj().glyphCount);
+}
+
+size_t TextEdit::Caret::absolutePos() const
+{
+  if (m_pos == 0 && m_line == 0)
+    return 0;
+
+  size_t apos = 0;
+  for (const auto& l : *m_lines) {
+    const bool hasNextLine = l.i < (m_lines->size() - 1);
+
+    if (l.i == m_line) {
+      if (l.text.empty() || m_pos == 0)
+        return apos;
+
+      if (m_pos >= l.utfSize.size())
+        apos += l.utfSize.back().end;
+      else if (m_pos > l.utfSize.size())
+        apos += l.utfSize.back().end + (hasNextLine ? 1 : 0);
+      else
+        apos += l.utfSize[m_pos].begin;
+      return apos;
+    }
+
+    if (!l.text.empty() && !l.utfSize.empty())
+      apos += l.utfSize.back().end;
+
+    if (hasNextLine)
+      apos += 1; // Newline glyph.
+  }
+  return apos;
+}
+
+bool TextEdit::Caret::isWordPart(size_t pos) const
+{
+  if (!lineObj().glyphCount || lineObj().utfSize.size() <= pos)
+    return false;
+
+  const auto& utfPos = lineObj().utfSize[pos];
+  const std::string_view word = text().substr(utfPos.begin, utfPos.end - utfPos.begin);
+  return (!word.empty() && std::isspace(word[0]) == 0 && std::ispunct(word[0]) == 0);
+}
+
+void TextEdit::Caret::advanceBy(size_t characters)
+{
+  size_t remaining = characters;
+  size_t activeLine = m_line;
+  for (size_t i = m_line; i < m_lines->size(); ++i) {
+    const auto& line = (*m_lines)[i];
+    for (size_t j = m_pos; j < line.glyphCount; ++j) {
+      remaining -= line.utfSize[j].end - line.utfSize[j].begin;
+      right();
+
+      if (remaining <= 0)
+        return;
+
+      if (m_line != activeLine) {
+        activeLine = m_line;
+        break;
+      }
+    }
+  }
+}
+
+bool TextEdit::Caret::isValid() const
+{
+  if (m_lines == nullptr)
+    return false;
+
+  if (m_line >= m_lines->size())
+    return false;
+
+  if (m_pos > lineObj().glyphCount)
+    return false;
+
+  return true;
+}
+
+void TextEdit::Caret::clear()
+{
+  m_lines = nullptr;
+  m_line = 0;
+  m_pos = 0;
+}
+
+void TextEdit::Selection::set(const Caret& startCaret, const Caret& endCaret)
+{
+  if (startCaret > endCaret) {
+    m_start = endCaret;
+    m_end = startCaret;
+  }
+  else {
+    m_start = startCaret;
+    m_end = endCaret;
+  }
+}
+
+void TextEdit::Selection::clear()
+{
+  m_start.clear();
+  m_end.clear();
+}
+
+} // namespace ui
diff --git a/src/ui/textedit.h b/src/ui/textedit.h
new file mode 100644
index 000000000..5f936649d
--- /dev/null
+++ b/src/ui/textedit.h
@@ -0,0 +1,188 @@
+// Aseprite
+// Copyright (C) 2024  Igara Studio S.A.
+// Copyright (C) 2001-2018  David Capello
+//
+// This program is distributed under the terms of
+// the End-User License Agreement for Aseprite.
+
+#ifndef UI_TEXT_EDIT_H_INCLUDED
+#define UI_TEXT_EDIT_H_INCLUDED
+#pragma once
+
+#include "text/font_mgr.h"
+#include "text/text_blob.h"
+#include "ui/box.h"
+#include "ui/theme.h"
+#include "ui/view.h"
+
+namespace ui {
+using namespace text;
+
+class TextEdit : public Widget,
+                 public ViewableWidget {
+public:
+  TextEdit();
+
+  void cut();
+  void copy();
+  void paste();
+  void selectAll();
+
+  obs::signal<void()> Change;
+
+protected:
+  bool onProcessMessage(Message* msg) override;
+  void onPaint(PaintEvent& ev) override;
+  void onSizeHint(SizeHintEvent& ev) override;
+  void onScrollRegion(ScrollRegionEvent& ev) override;
+  void onSetText() override;
+  void onSetFont() override;
+
+  bool onKeyDown(const KeyMessage* keyMessage);
+  bool onMouseMove(const MouseMessage* mouseMessage);
+
+private:
+  struct Line {
+    std::string text;
+    std::vector<TextBlob::Utf8Range> utfSize;
+    size_t glyphCount = 0;
+    text::TextBlobRef blob;
+
+    int width = 0;
+    int height = 0;
+
+    // Line index for more convenient loops
+    size_t i = 0;
+
+    void buildBlob(const Widget* forWidget);
+
+    // Insert text into this line based on a caret position, taking into account utf8 size.
+    void insertText(size_t pos, const std::string& str);
+
+    gfx::Rect getBounds(size_t glyph) const;
+
+    // Get the screen size between the start and end glyph positions.
+    gfx::Rect getBounds(size_t startGlyph, size_t endGlyph) const;
+  };
+
+  struct Caret {
+    explicit Caret(std::vector<Line>* lines = nullptr) : m_lines(lines) {}
+    explicit Caret(std::vector<Line>* lines, size_t line, size_t pos)
+      : m_line(line)
+      , m_pos(pos)
+      , m_lines(lines)
+    {
+    }
+    Caret(const Caret& caret) : m_line(caret.m_line), m_pos(caret.m_pos), m_lines(caret.m_lines) {}
+
+    size_t line() const { return m_line; }
+    size_t pos() const { return m_pos; }
+
+    void setPos(size_t pos);
+    void setLine(size_t line) { m_line = line; }
+    void set(size_t line, size_t pos);
+
+    bool left(bool byWord = false);
+    // Moves the position to the next word on the left, doesn't wrap around lines.
+    bool leftWord();
+    bool right(bool byWord = false);
+    // Moves the position to the next word on the right, doesn't wrap around lines.
+    bool rightWord();
+    void up();
+    void down();
+    bool isLastInLine() const { return m_pos == lineObj().glyphCount; }
+    bool isLastLine() const { return m_line == m_lines->size() - 1; }
+
+    // Returns the absolute position of the caret, aka the position in the main string that has all
+    // the newlines.
+    size_t absolutePos() const;
+    bool isWordPart(size_t pos) const;
+    void advanceBy(size_t characters);
+    bool isValid() const;
+    void clear();
+
+    bool operator==(const Caret& other) const
+    {
+      return m_line == other.m_line && m_pos == other.m_pos;
+    }
+
+    bool operator!=(const Caret& other) const
+    {
+      return m_line != other.m_line || m_pos != other.m_pos;
+    }
+
+    bool operator>(const Caret& other) const
+    {
+      return (m_line == other.m_line) ? m_pos > other.m_pos :
+                                        (m_line + m_pos) > (other.m_line + m_pos);
+    }
+
+  private:
+    size_t m_line = 0;
+    size_t m_pos = 0;
+    std::string_view text() const { return (*m_lines)[m_line].text; }
+    Line& lineObj() const { return (*m_lines)[m_line]; }
+    std::vector<Line>* m_lines;
+  };
+
+  struct Selection {
+    Selection() = default;
+    Selection(const Caret& startCaret, const Caret& endCaret) { set(startCaret, endCaret); }
+
+    bool isEmpty() const
+    {
+      return (m_start.line() == m_end.line() && m_start.pos() == m_end.pos());
+    }
+
+    void setStart(const Caret& caret) { m_start = caret; }
+    void setEnd(const Caret& caret) { m_end = caret; }
+    void set(const Caret& startCaret, const Caret& endCaret);
+
+    const Caret& start() const { return m_start; }
+    const Caret& end() const { return m_end; }
+    bool isValid() const { return m_start.isValid() && m_end.isValid(); }
+
+    void clear();
+
+  private:
+    Caret m_start;
+    Caret m_end;
+  };
+
+  // Get the selection rect for the given line, if any
+  gfx::RectF getSelectionRect(const Line& line, const gfx::PointF& offset) const;
+  Caret caretFromPosition(const gfx::Point& position);
+  void showEditPopupMenu(const gfx::Point& position);
+  void insertCharacter(base::codepoint_t character);
+  void deleteSelection();
+  void ensureCaretVisible();
+
+  void startTimer();
+  void stopTimer();
+
+  Selection m_selection;
+  Caret m_caret;
+  Caret m_lockedSelectionStart;
+
+  std::vector<Line> m_lines;
+
+  // Whether or not we're currently drawing the caret, driven by a timer.
+  bool m_drawCaret = false;
+
+  // The last position the caret was drawn, to invalidate that region when repainting.
+  gfx::Rect m_caretRect;
+
+  // The total size of the complete text, calculated as the longest single line width and the sum of
+  // the total line heights
+  gfx::Size m_textSize;
+
+  // Color cache
+  gfx::Color m_colorBG;
+  gfx::Color m_colorSelected;
+  os::Paint m_textPaint;
+  os::Paint m_selectedTextPaint;
+};
+
+} // namespace ui
+
+#endif
diff --git a/src/ui/theme.h b/src/ui/theme.h
index 7ab9382bb..708546a92 100644
--- a/src/ui/theme.h
+++ b/src/ui/theme.h
@@ -77,6 +77,7 @@ public:
   virtual gfx::Size getEntryCaretSize(Widget* widget) { return gfx::Size(kDefaultFontHeight, 1); }
 
   virtual void paintEntry(PaintEvent& ev) {}
+  virtual void paintTextEdit(PaintEvent& ev) {}
   virtual void paintListBox(PaintEvent& ev);
   virtual void paintMenu(PaintEvent& ev) {}
   virtual void paintMenuItem(PaintEvent& ev) {}
diff --git a/src/ui/widget.cpp b/src/ui/widget.cpp
index 837af5308..1d83c72a8 100644
--- a/src/ui/widget.cpp
+++ b/src/ui/widget.cpp
@@ -148,6 +148,9 @@ double Widget::textDouble() const
 
 void Widget::setText(const std::string& text)
 {
+  if (text == this->text())
+    return;
+
   setTextQuiet(text);
   onSetText();
 }
diff --git a/src/ui/widget_type.h b/src/ui/widget_type.h
index a46231ac9..47be5cf4f 100644
--- a/src/ui/widget_type.h
+++ b/src/ui/widget_type.h
@@ -38,6 +38,7 @@ enum WidgetType : int {
   kSliderWidget,
   kSplitterWidget,
   kTextBoxWidget,
+  kTextEditWidget,
   kViewScrollbarWidget,
   kViewViewportWidget,
   kViewWidget,

From 85863cf4ed3986483ce2bc329903d91c8853e3d4 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 12:10:16 -0300
Subject: [PATCH 02/15] We cannot bypass onSetText() as ui::Entry requires this

Without this fix, "Run Command" will crash.
---
 src/ui/widget.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/ui/widget.cpp b/src/ui/widget.cpp
index 1d83c72a8..837af5308 100644
--- a/src/ui/widget.cpp
+++ b/src/ui/widget.cpp
@@ -148,9 +148,6 @@ double Widget::textDouble() const
 
 void Widget::setText(const std::string& text)
 {
-  if (text == this->text())
-    return;
-
   setTextQuiet(text);
   onSetText();
 }

From 7e4b310a4243a22b9200c12db4025105d4bf6d3c Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 12:28:46 -0300
Subject: [PATCH 03/15] Enter from the numeric keypad can be used for new lines
 too

---
 src/ui/textedit.cpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index bf680e2da..a300b6ee2 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -228,13 +228,14 @@ bool TextEdit::onKeyDown(const KeyMessage* keyMessage)
   const Caret prevCaret(m_caret);
 
   switch (scancode) {
-    case kKeyLeft:  m_caret.left(byWord); break;
-    case kKeyRight: m_caret.right(byWord); break;
-    case kKeyHome:  m_caret.setPos(0); break;
-    case kKeyEnd:   m_caret.set(m_lines.back().i, m_lines.back().glyphCount); break;
-    case kKeyUp:    m_caret.up(); break;
-    case kKeyDown:  m_caret.down(); break;
-    case kKeyEnter: {
+    case kKeyLeft:     m_caret.left(byWord); break;
+    case kKeyRight:    m_caret.right(byWord); break;
+    case kKeyHome:     m_caret.setPos(0); break;
+    case kKeyEnd:      m_caret.set(m_lines.back().i, m_lines.back().glyphCount); break;
+    case kKeyUp:       m_caret.up(); break;
+    case kKeyDown:     m_caret.down(); break;
+    case kKeyEnter:
+    case kKeyEnterPad: {
       deleteSelection();
 
       std::string newText = text();

From d1f010cc47c39aa4aaa9e313b28b6dca13aa88a5 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 12:37:31 -0300
Subject: [PATCH 04/15] Fix End key to go to EOL and added Ctrl+Home/End to go
 to BOF/EOF

---
 src/ui/textedit.cpp | 33 ++++++++++++++++++++++++++++-----
 src/ui/textedit.h   |  5 ++++-
 2 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index a300b6ee2..c6482ec7d 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2024  Igara Studio S.A.
+// Copyright (C) 2024-2025  Igara Studio S.A.
 // Copyright (C) 2001-2018  David Capello
 //
 // This program is distributed under the terms of
@@ -228,10 +228,28 @@ bool TextEdit::onKeyDown(const KeyMessage* keyMessage)
   const Caret prevCaret(m_caret);
 
   switch (scancode) {
-    case kKeyLeft:     m_caret.left(byWord); break;
-    case kKeyRight:    m_caret.right(byWord); break;
-    case kKeyHome:     m_caret.setPos(0); break;
-    case kKeyEnd:      m_caret.set(m_lines.back().i, m_lines.back().glyphCount); break;
+    case kKeyLeft:  m_caret.left(byWord); break;
+    case kKeyRight: m_caret.right(byWord); break;
+    case kKeyHome:
+      // Beginning of text
+      if (keyMessage->ctrlPressed()) {
+        m_caret.set(0, 0);
+      }
+      // Beginning of line
+      else {
+        m_caret.setPos(0);
+      }
+      break;
+    case kKeyEnd:
+      // End of text
+      if (keyMessage->ctrlPressed()) {
+        m_caret.set(m_lines.back().i, m_lines.back().glyphCount);
+      }
+      // End of line
+      else {
+        m_caret.eol();
+      }
+      break;
     case kKeyUp:       m_caret.up(); break;
     case kKeyDown:     m_caret.down(); break;
     case kKeyEnter:
@@ -956,6 +974,11 @@ void TextEdit::Caret::down()
   m_pos = std::clamp(m_pos, size_t(0), lineObj().glyphCount);
 }
 
+void TextEdit::Caret::eol()
+{
+  m_pos = lineObj().glyphCount;
+}
+
 size_t TextEdit::Caret::absolutePos() const
 {
   if (m_pos == 0 && m_line == 0)
diff --git a/src/ui/textedit.h b/src/ui/textedit.h
index 5f936649d..d3696bec0 100644
--- a/src/ui/textedit.h
+++ b/src/ui/textedit.h
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2024  Igara Studio S.A.
+// Copyright (C) 2024-2025  Igara Studio S.A.
 // Copyright (C) 2001-2018  David Capello
 //
 // This program is distributed under the terms of
@@ -93,6 +93,9 @@ private:
     bool isLastInLine() const { return m_pos == lineObj().glyphCount; }
     bool isLastLine() const { return m_line == m_lines->size() - 1; }
 
+    // Go to the end of line.
+    void eol();
+
     // Returns the absolute position of the caret, aka the position in the main string that has all
     // the newlines.
     size_t absolutePos() const;

From f6ed430bd6da380b859e4484f4f0e0eaa0381e9d Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 14:39:51 -0300
Subject: [PATCH 05/15] Change size_t to int for position/line numbers

---
 src/ui/textedit.cpp | 80 ++++++++++++++++++++-------------------------
 src/ui/textedit.h   | 32 +++++++++---------
 2 files changed, 52 insertions(+), 60 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index c6482ec7d..2458d3174 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -71,7 +71,7 @@ void TextEdit::copy()
   if (m_selection.isEmpty())
     return;
 
-  const size_t startPos = m_selection.start().absolutePos();
+  const int startPos = m_selection.start().absolutePos();
   set_clipboard_text(text().substr(startPos, m_selection.end().absolutePos() - startPos));
 }
 
@@ -533,8 +533,8 @@ TextEdit::Caret TextEdit::caretFromPosition(const gfx::Point& position)
   }
 
   for (const Line& line : m_lines) {
-    const size_t lineStartY = line.i * lineHeight;
-    const size_t lineEndY = (line.i + 1) * lineHeight;
+    const int lineStartY = line.i * lineHeight;
+    const int lineEndY = (line.i + 1) * lineHeight;
 
     if (offsetPosition.y > lineEndY || offsetPosition.y < lineStartY)
       continue; // We're not in this line
@@ -552,7 +552,7 @@ TextEdit::Caret TextEdit::caretFromPosition(const gfx::Point& position)
 
     // Find the exact character we're standing on, with a slight bias to the left or right
     // depending on where we click wrt the glyph bounds
-    size_t advance = 0;
+    int advance = 0;
     bool found = false;
 
     line.blob->visitRuns([&](const text::TextBlob::RunInfo& run) {
@@ -653,7 +653,7 @@ void TextEdit::deleteSelection()
 
   if (m_selection.start().line() == m_selection.end().line()) {
     auto& line = m_lines[m_selection.start().line()];
-    size_t end;
+    int end;
     if (m_selection.end().isLastInLine())
       end = line.utfSize.back().end;
     else
@@ -692,7 +692,7 @@ void TextEdit::ensureCaretVisible()
 
   if (view->verticalBar()->isVisible()) {
     const int heightLimit = (visibleBounds.h + scroll.y - lineHeight) / 2;
-    const size_t currentLine = (m_caret.line() * lineHeight) / 2;
+    const int currentLine = (m_caret.line() * lineHeight) / 2;
 
     if (currentLine <= scroll.y)
       scroll.y = currentLine;
@@ -780,12 +780,12 @@ void TextEdit::stopTimer()
 }
 
 struct Utf8RangeBuilder : public text::TextBlob::RunHandler {
-  explicit Utf8RangeBuilder(size_t minSize) { ranges.reserve(minSize); }
+  explicit Utf8RangeBuilder(int minSize) { ranges.reserve(minSize); }
 
   void commitRunBuffer(TextBlob::RunInfo& info) override
   {
     ASSERT(info.clusters == nullptr || *info.clusters == 0);
-    for (size_t i = 0; i < info.glyphCount; ++i) {
+    for (int i = 0; i < info.glyphCount; ++i) {
       ranges.push_back(info.getGlyphUtf8Range(i));
     }
   }
@@ -819,7 +819,7 @@ void TextEdit::Line::buildBlob(const Widget* forWidget)
 }
 
 // Insert text into this line based on a caret position, taking into account utf8 size.
-void TextEdit::Line::insertText(size_t pos, const std::string& str)
+void TextEdit::Line::insertText(int pos, const std::string& str)
 {
   if (pos == 0)
     text.insert(0, str);
@@ -829,12 +829,12 @@ void TextEdit::Line::insertText(size_t pos, const std::string& str)
     text.insert(utfSize[pos - 1].end, str);
 }
 
-gfx::Rect TextEdit::Line::getBounds(size_t glyph) const
+gfx::Rect TextEdit::Line::getBounds(int glyph) const
 {
-  size_t advance = 0;
+  int advance = 0;
   gfx::Rect result;
   blob->visitRuns([&](const text::TextBlob::RunInfo& run) {
-    for (size_t i = 0; i < run.glyphCount; ++i) {
+    for (int i = 0; i < run.glyphCount; ++i) {
       if (advance == glyph) {
         result = run.getGlyphBounds(i);
         return;
@@ -845,14 +845,14 @@ gfx::Rect TextEdit::Line::getBounds(size_t glyph) const
   return result;
 }
 
-gfx::Rect TextEdit::Line::getBounds(size_t startGlyph, size_t endGlyph) const
+gfx::Rect TextEdit::Line::getBounds(int startGlyph, int endGlyph) const
 {
   if (startGlyph == endGlyph)
     return getBounds(startGlyph);
 
   ASSERT(endGlyph > startGlyph);
 
-  size_t advance = 0; // The amount of glyphs we've advanced through.
+  int advance = 0; // The amount of glyphs we've advanced through.
   gfx::Rect resultBounds;
 
   blob->visitRuns([&](text::TextBlob::RunInfo& run) {
@@ -864,7 +864,7 @@ gfx::Rect TextEdit::Line::getBounds(size_t startGlyph, size_t endGlyph) const
       return; // Skip this run
     }
 
-    size_t j = 0;
+    int j = 0;
     if (advance < startGlyph) {
       j = startGlyph - advance;
       advance += j;
@@ -884,13 +884,13 @@ gfx::Rect TextEdit::Line::getBounds(size_t startGlyph, size_t endGlyph) const
   return resultBounds;
 }
 
-void TextEdit::Caret::setPos(size_t pos)
+void TextEdit::Caret::setPos(int pos)
 {
   ASSERT(pos >= 0 && pos <= lineObj().glyphCount);
   m_pos = pos;
 }
 
-void TextEdit::Caret::set(size_t line, size_t pos)
+void TextEdit::Caret::set(int line, int pos)
 {
   m_line = line;
   m_pos = pos;
@@ -901,18 +901,14 @@ bool TextEdit::Caret::left(bool byWord)
   if (byWord)
     return leftWord();
 
-  m_pos -= 1;
-
-  if (((int64_t)(m_pos)-1) < 0) {
+  if (--m_pos < 0) {
     if (m_line == 0) {
       m_pos = 0;
       return false;
     }
-
-    m_line -= 1;
-    m_pos = lineObj().glyphCount;
+    --m_line;
+    eol();
   }
-
   return true;
 }
 
@@ -934,18 +930,14 @@ bool TextEdit::Caret::right(bool byWord)
   if (byWord)
     return rightWord();
 
-  m_pos += 1;
-
-  if (m_pos > lineObj().glyphCount) {
-    if (m_line == m_lines->size() - 1) {
-      m_pos -= 1; // Undo movement, we've reached the end of the text.
+  if (++m_pos > lineObj().glyphCount) {
+    if (m_line == int(m_lines->size()) - 1) {
+      --m_pos; // Undo movement, we've reached the end of the text.
       return false;
     }
-
-    m_line += 1;
+    ++m_line;
     m_pos = 0;
   }
-
   return true;
 }
 
@@ -964,14 +956,14 @@ bool TextEdit::Caret::rightWord()
 
 void TextEdit::Caret::up()
 {
-  m_line = std::clamp(m_line - 1, size_t(0), m_lines->size() - 1);
-  m_pos = std::clamp(m_pos, size_t(0), lineObj().glyphCount);
+  m_line = std::clamp(m_line - 1, 0, int(m_lines->size()) - 1);
+  m_pos = std::clamp(m_pos, 0, lineObj().glyphCount);
 }
 
 void TextEdit::Caret::down()
 {
-  m_line = std::clamp(m_line + 1, size_t(0), m_lines->size() - 1);
-  m_pos = std::clamp(m_pos, size_t(0), lineObj().glyphCount);
+  m_line = std::clamp(m_line + 1, 0, int(m_lines->size()) - 1);
+  m_pos = std::clamp(m_pos, 0, lineObj().glyphCount);
 }
 
 void TextEdit::Caret::eol()
@@ -979,12 +971,12 @@ void TextEdit::Caret::eol()
   m_pos = lineObj().glyphCount;
 }
 
-size_t TextEdit::Caret::absolutePos() const
+int TextEdit::Caret::absolutePos() const
 {
   if (m_pos == 0 && m_line == 0)
     return 0;
 
-  size_t apos = 0;
+  int apos = 0;
   for (const auto& l : *m_lines) {
     const bool hasNextLine = l.i < (m_lines->size() - 1);
 
@@ -1010,7 +1002,7 @@ size_t TextEdit::Caret::absolutePos() const
   return apos;
 }
 
-bool TextEdit::Caret::isWordPart(size_t pos) const
+bool TextEdit::Caret::isWordPart(int pos) const
 {
   if (!lineObj().glyphCount || lineObj().utfSize.size() <= pos)
     return false;
@@ -1020,13 +1012,13 @@ bool TextEdit::Caret::isWordPart(size_t pos) const
   return (!word.empty() && std::isspace(word[0]) == 0 && std::ispunct(word[0]) == 0);
 }
 
-void TextEdit::Caret::advanceBy(size_t characters)
+void TextEdit::Caret::advanceBy(int characters)
 {
-  size_t remaining = characters;
-  size_t activeLine = m_line;
-  for (size_t i = m_line; i < m_lines->size(); ++i) {
+  int remaining = characters;
+  int activeLine = m_line;
+  for (int i = m_line; i < m_lines->size(); ++i) {
     const auto& line = (*m_lines)[i];
-    for (size_t j = m_pos; j < line.glyphCount; ++j) {
+    for (int j = m_pos; j < line.glyphCount; ++j) {
       remaining -= line.utfSize[j].end - line.utfSize[j].begin;
       right();
 
diff --git a/src/ui/textedit.h b/src/ui/textedit.h
index d3696bec0..36f77b4dd 100644
--- a/src/ui/textedit.h
+++ b/src/ui/textedit.h
@@ -45,29 +45,29 @@ private:
   struct Line {
     std::string text;
     std::vector<TextBlob::Utf8Range> utfSize;
-    size_t glyphCount = 0;
+    int glyphCount = 0;
     text::TextBlobRef blob;
 
     int width = 0;
     int height = 0;
 
     // Line index for more convenient loops
-    size_t i = 0;
+    int i = 0;
 
     void buildBlob(const Widget* forWidget);
 
     // Insert text into this line based on a caret position, taking into account utf8 size.
-    void insertText(size_t pos, const std::string& str);
+    void insertText(int pos, const std::string& str);
 
-    gfx::Rect getBounds(size_t glyph) const;
+    gfx::Rect getBounds(int glyph) const;
 
     // Get the screen size between the start and end glyph positions.
-    gfx::Rect getBounds(size_t startGlyph, size_t endGlyph) const;
+    gfx::Rect getBounds(int startGlyph, int endGlyph) const;
   };
 
   struct Caret {
     explicit Caret(std::vector<Line>* lines = nullptr) : m_lines(lines) {}
-    explicit Caret(std::vector<Line>* lines, size_t line, size_t pos)
+    explicit Caret(std::vector<Line>* lines, int line, int pos)
       : m_line(line)
       , m_pos(pos)
       , m_lines(lines)
@@ -75,12 +75,12 @@ private:
     }
     Caret(const Caret& caret) : m_line(caret.m_line), m_pos(caret.m_pos), m_lines(caret.m_lines) {}
 
-    size_t line() const { return m_line; }
-    size_t pos() const { return m_pos; }
+    int line() const { return m_line; }
+    int pos() const { return m_pos; }
 
-    void setPos(size_t pos);
-    void setLine(size_t line) { m_line = line; }
-    void set(size_t line, size_t pos);
+    void setPos(int pos);
+    void setLine(int line) { m_line = line; }
+    void set(int line, int pos);
 
     bool left(bool byWord = false);
     // Moves the position to the next word on the left, doesn't wrap around lines.
@@ -98,9 +98,9 @@ private:
 
     // Returns the absolute position of the caret, aka the position in the main string that has all
     // the newlines.
-    size_t absolutePos() const;
-    bool isWordPart(size_t pos) const;
-    void advanceBy(size_t characters);
+    int absolutePos() const;
+    bool isWordPart(int pos) const;
+    void advanceBy(int characters);
     bool isValid() const;
     void clear();
 
@@ -121,8 +121,8 @@ private:
     }
 
   private:
-    size_t m_line = 0;
-    size_t m_pos = 0;
+    int m_line = 0;
+    int m_pos = 0;
     std::string_view text() const { return (*m_lines)[m_line].text; }
     Line& lineObj() const { return (*m_lines)[m_line]; }
     std::vector<Line>* m_lines;

From 27cd52ba3bcb56b366cbddb474a4943776304a2f Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 14:42:49 -0300
Subject: [PATCH 06/15] Jump between words correctly with Ctrl+Left/Right

---
 src/ui/textedit.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 2458d3174..cff7e8247 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -914,14 +914,16 @@ bool TextEdit::Caret::left(bool byWord)
 
 bool TextEdit::Caret::leftWord()
 {
-  if (m_pos == 0)
-    return false;
-
   auto startPos = m_pos;
+  while (left()) {
+    if (isWordPart(m_pos))
+      break;
+  }
   while (isWordPart(m_pos)) {
     if (!left())
       return m_pos != startPos;
   }
+  right();
   return true;
 }
 
@@ -943,10 +945,11 @@ bool TextEdit::Caret::right(bool byWord)
 
 bool TextEdit::Caret::rightWord()
 {
-  if (m_pos == lineObj().glyphCount)
-    return false;
-
   auto startPos = m_pos;
+  while (right()) {
+    if (isWordPart(m_pos))
+      break;
+  }
   while (isWordPart(m_pos)) {
     if (!right())
       return m_pos != startPos;

From b93a2fc0354e8dab9efd8986cdc52f33cf9db82a Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 15:32:45 -0300
Subject: [PATCH 07/15] Fix caret position when a line has multiple runs (e.g.
 there's an emoji present)

---
 src/ui/textedit.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index cff7e8247..4237b18f9 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -829,16 +829,14 @@ void TextEdit::Line::insertText(int pos, const std::string& str)
     text.insert(utfSize[pos - 1].end, str);
 }
 
-gfx::Rect TextEdit::Line::getBounds(int glyph) const
+gfx::Rect TextEdit::Line::getBounds(const int glyph) const
 {
   int advance = 0;
   gfx::Rect result;
-  blob->visitRuns([&](const text::TextBlob::RunInfo& run) {
+  blob->visitRuns([&advance, &result, glyph](const text::TextBlob::RunInfo& run) {
     for (int i = 0; i < run.glyphCount; ++i) {
-      if (advance == glyph) {
+      if (advance == glyph)
         result = run.getGlyphBounds(i);
-        return;
-      }
       ++advance;
     }
   });

From c99360e4d5c302d7b5cdca0facb642499d080273 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 15:46:44 -0300
Subject: [PATCH 08/15] Improve caret/char selection with the mouse

---
 src/ui/textedit.cpp | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 4237b18f9..6fd539e54 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -31,6 +31,7 @@
 #include "ui/view.h"
 
 #include <algorithm>
+#include <limits>
 
 namespace ui {
 
@@ -553,32 +554,21 @@ TextEdit::Caret TextEdit::caretFromPosition(const gfx::Point& position)
     // Find the exact character we're standing on, with a slight bias to the left or right
     // depending on where we click wrt the glyph bounds
     int advance = 0;
-    bool found = false;
+    int best = 0;
+    float bestDiff = std::numeric_limits<float>::max();
 
     line.blob->visitRuns([&](const text::TextBlob::RunInfo& run) {
-      if (found) {
-        return;
-      }
-
       for (int i = 0; i < run.glyphCount; ++i) {
-        gfx::RectF glyphBounds = run.getGlyphBounds(i).offset(gfx::PointF(0, lineStartY));
-
-        if (glyphBounds.contains(offsetPosition)) {
-          found = true;
-
-          if (offsetPosition.x > glyphBounds.center().x && advance != line.glyphCount)
-            ++advance; // If the mouse is to the right of the glyph, prefer the next position.
-
-          return;
+        const float diff = std::fabs(run.getGlyphBounds(i).center().x - offsetPosition.x);
+        if (diff < bestDiff) {
+          best = advance;
+          bestDiff = diff;
         }
-
         ++advance;
       }
     });
 
-    if (found) {
-      caret.setPos(advance);
-    }
+    caret.setPos(best);
   }
 
   return caret;

From 3c0b4e294039060927f75f35bd4371d5fcacd4c5 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 16:29:00 -0300
Subject: [PATCH 09/15] Implement "selection by words" after double-clicking

This is the same behavior as in ui::Entry widget.
---
 src/ui/textedit.cpp | 87 +++++++++++++++++++++++++++++++++------------
 src/ui/textedit.h   | 23 +++++++++---
 2 files changed, 83 insertions(+), 27 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 6fd539e54..0ec5edc73 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -155,22 +155,15 @@ bool TextEdit::onProcessMessage(Message* msg)
         requestFocus();
 
       const auto* mouseMessage = static_cast<MouseMessage*>(msg);
-      Caret leftCaret = caretFromPosition(mouseMessage->position());
-      if (!leftCaret.isValid())
+      Caret caret = caretFromPosition(mouseMessage->position());
+      if (!caret.isValid())
         return false;
 
-      Caret rightCaret = leftCaret;
-      leftCaret.leftWord();
-      rightCaret.rightWord();
-
-      if (leftCaret != rightCaret) {
-        m_selection.set(leftCaret, rightCaret);
-        m_caret = rightCaret;
-        invalidate();
-        captureMouse();
-        return true;
-      }
-      break;
+      m_selection = m_selectionWords = Selection::SelectWords(caret);
+      m_caret = m_selection.end();
+      invalidate();
+      captureMouse();
+      return true;
     }
     case kMouseDownMessage:
       if (msg->shiftPressed())
@@ -199,6 +192,9 @@ bool TextEdit::onProcessMessage(Message* msg)
         releaseMouse();
         startTimer();
 
+        if (!m_selectionWords.isEmpty())
+          m_selectionWords.clear();
+
         const auto* mouseMsg = static_cast<MouseMessage*>(msg);
         if (mouseMsg->right()) {
           showEditPopupMenu(mouseMsg->position());
@@ -351,7 +347,17 @@ bool TextEdit::onMouseMove(const MouseMessage* mouseMessage)
     return true;
   }
 
-  m_selection.set(m_lockedSelectionStart, m_caret);
+  if (!m_selectionWords.isEmpty()) {
+    m_selection = m_selectionWords;
+    m_selection |= Selection::SelectWords(m_caret);
+    if (m_caret < m_selectionWords.start())
+      m_caret = m_selection.start();
+    else
+      m_caret = m_selection.end();
+  }
+  else
+    m_selection.set(m_lockedSelectionStart, m_caret);
+
   return true;
 }
 
@@ -904,10 +910,10 @@ bool TextEdit::Caret::leftWord()
 {
   auto startPos = m_pos;
   while (left()) {
-    if (isWordPart(m_pos))
+    if (isWordPart())
       break;
   }
-  while (isWordPart(m_pos)) {
+  while (isWordPart()) {
     if (!left())
       return m_pos != startPos;
   }
@@ -935,10 +941,10 @@ bool TextEdit::Caret::rightWord()
 {
   auto startPos = m_pos;
   while (right()) {
-    if (isWordPart(m_pos))
+    if (isWordPart())
       break;
   }
-  while (isWordPart(m_pos)) {
+  while (isWordPart()) {
     if (!right())
       return m_pos != startPos;
   }
@@ -993,12 +999,12 @@ int TextEdit::Caret::absolutePos() const
   return apos;
 }
 
-bool TextEdit::Caret::isWordPart(int pos) const
+bool TextEdit::Caret::isWordPart() const
 {
-  if (!lineObj().glyphCount || lineObj().utfSize.size() <= pos)
+  if (!lineObj().glyphCount || lineObj().utfSize.size() <= m_pos)
     return false;
 
-  const auto& utfPos = lineObj().utfSize[pos];
+  const auto& utfPos = lineObj().utfSize[m_pos];
   const std::string_view word = text().substr(utfPos.begin, utfPos.end - utfPos.begin);
   return (!word.empty() && std::isspace(word[0]) == 0 && std::ispunct(word[0]) == 0);
 }
@@ -1045,9 +1051,44 @@ void TextEdit::Caret::clear()
   m_pos = 0;
 }
 
+TextEdit::Selection TextEdit::Selection::SelectWords(const Caret& from)
+{
+  Caret left = from;
+  Caret right = from;
+
+  // Select word space
+  if (left.isWordPart()) {
+    while (left.left()) {
+      if (!left.isWordPart()) {
+        left.right();
+        break;
+      }
+    }
+    while (right.right()) {
+      if (!right.isWordPart())
+        break;
+    }
+  }
+  // Select punctuation space
+  else {
+    while (left.left()) {
+      if (left.isWordPart()) {
+        left.right();
+        break;
+      }
+    }
+    while (right.right()) {
+      if (right.isWordPart())
+        break;
+    }
+  }
+
+  return Selection(left, right);
+}
+
 void TextEdit::Selection::set(const Caret& startCaret, const Caret& endCaret)
 {
-  if (startCaret > endCaret) {
+  if (endCaret < startCaret) {
     m_start = endCaret;
     m_end = startCaret;
   }
diff --git a/src/ui/textedit.h b/src/ui/textedit.h
index 36f77b4dd..8d3f745a6 100644
--- a/src/ui/textedit.h
+++ b/src/ui/textedit.h
@@ -15,6 +15,8 @@
 #include "ui/theme.h"
 #include "ui/view.h"
 
+#include <algorithm>
+
 namespace ui {
 using namespace text;
 
@@ -99,7 +101,7 @@ private:
     // Returns the absolute position of the caret, aka the position in the main string that has all
     // the newlines.
     int absolutePos() const;
-    bool isWordPart(int pos) const;
+    bool isWordPart() const;
     void advanceBy(int characters);
     bool isValid() const;
     void clear();
@@ -114,10 +116,13 @@ private:
       return m_line != other.m_line || m_pos != other.m_pos;
     }
 
-    bool operator>(const Caret& other) const
+    bool operator<(const Caret& other) const
     {
-      return (m_line == other.m_line) ? m_pos > other.m_pos :
-                                        (m_line + m_pos) > (other.m_line + m_pos);
+      if (m_line < other.m_line)
+        return true;
+      if (m_line > other.m_line)
+        return false;
+      return m_pos < other.m_pos;
     }
 
   private:
@@ -132,6 +137,8 @@ private:
     Selection() = default;
     Selection(const Caret& startCaret, const Caret& endCaret) { set(startCaret, endCaret); }
 
+    static Selection SelectWords(const Caret& from);
+
     bool isEmpty() const
     {
       return (m_start.line() == m_end.line() && m_start.pos() == m_end.pos());
@@ -147,6 +154,13 @@ private:
 
     void clear();
 
+    Selection& operator|=(const Selection& other)
+    {
+      m_start = std::min(m_start, other.start());
+      m_end = std::max(m_end, other.end());
+      return *this;
+    }
+
   private:
     Caret m_start;
     Caret m_end;
@@ -164,6 +178,7 @@ private:
   void stopTimer();
 
   Selection m_selection;
+  Selection m_selectionWords;
   Caret m_caret;
   Caret m_lockedSelectionStart;
 

From d8193f5accc9ac08697be15056158349732f03bc Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 16:40:50 -0300
Subject: [PATCH 10/15] Invalidate all blobs after changing theme

We've moved the InitTheme code from the InitTheme.connect() signal to
the onInitTheme() member function.
---
 src/ui/textedit.cpp | 32 ++++++++++++++++++++------------
 src/ui/textedit.h   |  1 +
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 0ec5edc73..5169ec7db 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -42,18 +42,6 @@ TextEdit::TextEdit() : Widget(kTextEditWidget), m_caret(&m_lines)
 {
   enableFlags(CTRL_RIGHT_CLICK);
   setFocusStop(true);
-  InitTheme.connect([this] {
-    ASSERT(style()->layers().size() == 4);
-    m_colorBG = style()->layers()[0].color();
-
-    m_textPaint.color(style()->layers()[1].color());
-    m_textPaint.style(os::Paint::Fill);
-
-    m_colorSelected = style()->layers()[2].color();
-
-    m_selectedTextPaint.color(style()->layers()[3].color());
-    m_selectedTextPaint.style(os::Paint::Fill);
-  });
   initTheme();
 }
 
@@ -428,6 +416,26 @@ void TextEdit::onPaint(PaintEvent& ev)
   m_caretRect.offset(gfx::Point(g->getInternalDeltaX(), g->getInternalDeltaY()));
 }
 
+void TextEdit::onInitTheme(InitThemeEvent& ev)
+{
+  Widget::onInitTheme(ev);
+
+  // TODO we cannot expect a specific number of layers in the theme style
+  ASSERT(style()->layers().size() == 4);
+  m_colorBG = style()->layers()[0].color();
+
+  m_textPaint.color(style()->layers()[1].color());
+  m_textPaint.style(os::Paint::Fill);
+
+  m_colorSelected = style()->layers()[2].color();
+
+  m_selectedTextPaint.color(style()->layers()[3].color());
+  m_selectedTextPaint.style(os::Paint::Fill);
+
+  // Invalidate all blobs
+  onSetText();
+}
+
 void TextEdit::onSizeHint(SizeHintEvent& ev)
 {
   ev.setSizeHint(m_textSize);
diff --git a/src/ui/textedit.h b/src/ui/textedit.h
index 8d3f745a6..a51a490b4 100644
--- a/src/ui/textedit.h
+++ b/src/ui/textedit.h
@@ -35,6 +35,7 @@ public:
 protected:
   bool onProcessMessage(Message* msg) override;
   void onPaint(PaintEvent& ev) override;
+  void onInitTheme(InitThemeEvent& ev) override;
   void onSizeHint(SizeHintEvent& ev) override;
   void onScrollRegion(ScrollRegionEvent& ev) override;
   void onSetText() override;

From 0faf9c020672387db55d74aba17d7ca372209a74 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Mon, 6 Oct 2025 18:27:34 -0300
Subject: [PATCH 11/15] Fix TextEdit::caretFromPosition() when lines have
 different heights

---
 src/ui/textedit.cpp | 22 ++++++++++++++++------
 src/ui/textedit.h   |  1 +
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 5169ec7db..763da8dd0 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -533,10 +533,9 @@ TextEdit::Caret TextEdit::caretFromPosition(const gfx::Point& position)
   offsetPosition += View::getView(this)->viewScroll();
 
   Caret caret(&m_lines);
-  const int lineHeight = font()->lineHeight();
 
   // First check if the offset position is blank (below all the lines)
-  if (offsetPosition.y > m_lines.size() * lineHeight) {
+  if (offsetPosition.y >= maxHeight()) {
     // Get the last character in the last line.
     caret.setLine(m_lines.size() - 1);
 
@@ -547,12 +546,13 @@ TextEdit::Caret TextEdit::caretFromPosition(const gfx::Point& position)
     return caret;
   }
 
+  int lineStartY = 0;
   for (const Line& line : m_lines) {
-    const int lineStartY = line.i * lineHeight;
-    const int lineEndY = (line.i + 1) * lineHeight;
-
-    if (offsetPosition.y > lineEndY || offsetPosition.y < lineStartY)
+    const int lineEndY = lineStartY + line.height;
+    if (offsetPosition.y < lineStartY || offsetPosition.y >= lineEndY) {
+      lineStartY = lineEndY;
       continue; // We're not in this line
+    }
 
     caret.setLine(line.i);
 
@@ -582,7 +582,9 @@ TextEdit::Caret TextEdit::caretFromPosition(const gfx::Point& position)
       }
     });
 
+    // Done, we've found the clicked caret position
     caret.setPos(best);
+    break;
   }
 
   return caret;
@@ -767,6 +769,14 @@ void TextEdit::onSetFont()
   onSetText();
 }
 
+int TextEdit::maxHeight() const
+{
+  int h = 0;
+  for (const auto& line : m_lines)
+    h += line.height;
+  return h;
+}
+
 void TextEdit::startTimer()
 {
   if (s_timer)
diff --git a/src/ui/textedit.h b/src/ui/textedit.h
index a51a490b4..78d80f93d 100644
--- a/src/ui/textedit.h
+++ b/src/ui/textedit.h
@@ -174,6 +174,7 @@ private:
   void insertCharacter(base::codepoint_t character);
   void deleteSelection();
   void ensureCaretVisible();
+  int maxHeight() const;
 
   void startTimer();
   void stopTimer();

From fb4f4d9fa6cb59cb0f318141ca0240334f35a577 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Tue, 7 Oct 2025 09:25:38 -0300
Subject: [PATCH 12/15] Fix TextEdit selection bounds for multiple lines

If we select from the beginning of a line to the previous line the
selection painting process was including the first character of the
line where we started, but it shouldn't be included (as the cursor
started in pos=0).
---
 src/ui/textedit.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 763da8dd0..2213bb6d4 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -860,7 +860,7 @@ gfx::Rect TextEdit::Line::getBounds(const int glyph) const
 gfx::Rect TextEdit::Line::getBounds(int startGlyph, int endGlyph) const
 {
   if (startGlyph == endGlyph)
-    return getBounds(startGlyph);
+    return {};
 
   ASSERT(endGlyph > startGlyph);
 

From 0dc4bc9aa74400f5aeb6f5250046da3faa97cf98 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Tue, 7 Oct 2025 09:32:53 -0300
Subject: [PATCH 13/15] Use gfx::RectF instead of gfx::Rect for text line
 bounds

---
 src/ui/textedit.cpp | 4 ++--
 src/ui/textedit.h   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 2213bb6d4..21af66c8a 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -843,7 +843,7 @@ void TextEdit::Line::insertText(int pos, const std::string& str)
     text.insert(utfSize[pos - 1].end, str);
 }
 
-gfx::Rect TextEdit::Line::getBounds(const int glyph) const
+gfx::RectF TextEdit::Line::getBounds(const int glyph) const
 {
   int advance = 0;
   gfx::Rect result;
@@ -857,7 +857,7 @@ gfx::Rect TextEdit::Line::getBounds(const int glyph) const
   return result;
 }
 
-gfx::Rect TextEdit::Line::getBounds(int startGlyph, int endGlyph) const
+gfx::RectF TextEdit::Line::getBounds(const int startGlyph, const int endGlyph) const
 {
   if (startGlyph == endGlyph)
     return {};
diff --git a/src/ui/textedit.h b/src/ui/textedit.h
index 78d80f93d..8512ff9be 100644
--- a/src/ui/textedit.h
+++ b/src/ui/textedit.h
@@ -62,10 +62,10 @@ private:
     // Insert text into this line based on a caret position, taking into account utf8 size.
     void insertText(int pos, const std::string& str);
 
-    gfx::Rect getBounds(int glyph) const;
+    gfx::RectF getBounds(int glyph) const;
 
     // Get the screen size between the start and end glyph positions.
-    gfx::Rect getBounds(int startGlyph, int endGlyph) const;
+    gfx::RectF getBounds(int startGlyph, int endGlyph) const;
   };
 
   struct Caret {

From c781d82cf6961d1010459b1fbae6b903c72e4ccc Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Tue, 7 Oct 2025 11:08:41 -0300
Subject: [PATCH 14/15] Match text caret size with Entry widget

---
 src/app/ui/skin/skin_theme.cpp | 18 ++++++++++++++----
 src/app/ui/skin/skin_theme.h   |  2 +-
 src/ui/entry.cpp               |  8 ++++----
 src/ui/int_entry.cpp           |  2 +-
 src/ui/textedit.cpp            |  9 +++++----
 src/ui/theme.h                 |  2 +-
 6 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/src/app/ui/skin/skin_theme.cpp b/src/app/ui/skin/skin_theme.cpp
index bd0d599bd..3655eefe5 100644
--- a/src/app/ui/skin/skin_theme.cpp
+++ b/src/app/ui/skin/skin_theme.cpp
@@ -1296,12 +1296,22 @@ int SkinTheme::getScrollbarSize()
   return dimensions.scrollbarSize();
 }
 
-gfx::Size SkinTheme::getEntryCaretSize(Widget* widget)
+gfx::Size SkinTheme::getCaretSize(Widget* widget)
 {
+  int caretHeight;
+  if (widget->type() == kTextEditWidget) {
+    // We cannot use the height of the widget text, because it
+    // includes the line height of every single line in the widget.
+    caretHeight = widget->font()->lineHeight();
+  }
+  else {
+    caretHeight = widget->textHeight();
+  }
+
   if (widget->font()->type() == text::FontType::FreeType)
-    return gfx::Size(2 * guiscale(), widget->textHeight());
+    return gfx::Size(2 * guiscale(), caretHeight);
   else
-    return gfx::Size(2 * guiscale(), widget->textHeight() + 2 * guiscale());
+    return gfx::Size(2 * guiscale(), caretHeight + 2 * guiscale());
 }
 
 void SkinTheme::paintEntry(PaintEvent& ev)
@@ -1866,7 +1876,7 @@ void SkinTheme::drawEntryCaret(ui::Graphics* g, Entry* widget, int x, int y)
 {
   gfx::Color color = colors.text();
   int textHeight = widget->textHeight();
-  gfx::Size caretSize = getEntryCaretSize(widget);
+  gfx::Size caretSize = getCaretSize(widget);
 
   for (int u = x; u < x + caretSize.w; ++u)
     g->drawVLine(color, u, y + textHeight / 2 - caretSize.h / 2, caretSize.h);
diff --git a/src/app/ui/skin/skin_theme.h b/src/app/ui/skin/skin_theme.h
index 8a70711ab..f7dcb75a5 100644
--- a/src/app/ui/skin/skin_theme.h
+++ b/src/app/ui/skin/skin_theme.h
@@ -80,7 +80,7 @@ public:
   void initWidget(ui::Widget* widget) override;
   void getWindowMask(ui::Widget* widget, gfx::Region& region) override;
   int getScrollbarSize() override;
-  gfx::Size getEntryCaretSize(ui::Widget* widget) override;
+  gfx::Size getCaretSize(ui::Widget* widget) override;
 
   void paintEntry(ui::PaintEvent& ev) override;
   void paintListBox(ui::PaintEvent& ev) override;
diff --git a/src/ui/entry.cpp b/src/ui/entry.cpp
index 04daf2541..3fe1970ef 100644
--- a/src/ui/entry.cpp
+++ b/src/ui/entry.cpp
@@ -139,7 +139,7 @@ gfx::Point Entry::caretPosOnScreen() const
 
 void Entry::setCaretPos(const int pos)
 {
-  gfx::Size caretSize = theme()->getEntryCaretSize(this);
+  gfx::Size caretSize = theme()->getCaretSize(this);
   int textlen = lastCaretPos();
   m_caret = std::clamp(pos, 0, textlen);
   m_scroll = std::clamp(m_scroll, 0, textlen);
@@ -521,7 +521,7 @@ gfx::Size Entry::sizeHintWithText(Entry* entry, const std::string& text)
 {
   const auto& font = entry->font();
 
-  int w = font->textLength(text) + +2 * entry->theme()->getEntryCaretSize(entry).w +
+  int w = font->textLength(text) + +2 * entry->theme()->getCaretSize(entry).w +
           entry->border().width();
 
   w = std::min(w, guiscale() * kMaxWidthHintForEntry);
@@ -546,7 +546,7 @@ void Entry::onSizeHint(SizeHintEvent& ev)
   const auto& font = this->font();
 
   int trailing = font->textLength(getSuffix());
-  trailing = std::max(trailing, 2 * theme()->getEntryCaretSize(this).w);
+  trailing = std::max(trailing, 2 * theme()->getCaretSize(this).w);
 
   int w = font->textLength("w") * std::min(m_maxsize, 6) + +trailing + border().width();
 
@@ -1012,7 +1012,7 @@ void Entry::recalcCharBoxes(const std::string& text)
   box.codepoint = 0;
   box.from = box.to = lastTextIndex;
   box.x = lastX;
-  box.width = theme()->getEntryCaretSize(this).w;
+  box.width = theme()->getCaretSize(this).w;
   m_boxes.push_back(box);
 }
 
diff --git a/src/ui/int_entry.cpp b/src/ui/int_entry.cpp
index 90d0d53d2..fa43b5b02 100644
--- a/src/ui/int_entry.cpp
+++ b/src/ui/int_entry.cpp
@@ -141,7 +141,7 @@ void IntEntry::onSizeHint(SizeHintEvent& ev)
 {
   const text::FontRef& font = this->font();
   int trailing = font->textLength(getSuffix());
-  trailing = std::max(trailing, 2 * theme()->getEntryCaretSize(this).w);
+  trailing = std::max(trailing, 2 * theme()->getCaretSize(this).w);
 
   int min_w = font->textLength(m_slider->convertValueToText(m_min));
   int max_w = font->textLength(m_slider->convertValueToText(m_max)) + trailing;
diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 21af66c8a..9b91af5fb 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -364,8 +364,8 @@ void TextEdit::onPaint(PaintEvent& ev)
   gfx::PointF point(border().left(), border().top());
   point -= scroll;
 
-  m_caretRect =
-    gfx::Rect(border().left() - scroll.x, border().top() - scroll.y, 2, font()->lineHeight());
+  m_caretRect = gfx::Rect(gfx::Point(border().left() - scroll.x, border().top() - scroll.y),
+                          theme()->getCaretSize(this));
 
   const gfx::Rect clipBounds = g->getClipBounds();
 
@@ -403,8 +403,9 @@ void TextEdit::onPaint(PaintEvent& ev)
         m_caretRect.x += line.getBounds(m_caret.pos()).x;
       }
 
-      m_caretRect.y = point.y;
-      m_caretRect.h = line.height; // Ensure the caret height corresponds with the tallest glyph
+      // Ensure the caret height corresponds with the tallest glyph
+      m_caretRect.h = std::max(m_caretRect.h, line.height);
+      m_caretRect.y = point.y + line.height / 2 - m_caretRect.h / 2;
     }
 
     point.y += line.height;
diff --git a/src/ui/theme.h b/src/ui/theme.h
index 708546a92..148034dcf 100644
--- a/src/ui/theme.h
+++ b/src/ui/theme.h
@@ -74,7 +74,7 @@ public:
   virtual void getWindowMask(Widget* widget, gfx::Region& region) {}
   virtual void setDecorativeWidgetBounds(Widget* widget);
   virtual int getScrollbarSize() { return kDefaultFontHeight; }
-  virtual gfx::Size getEntryCaretSize(Widget* widget) { return gfx::Size(kDefaultFontHeight, 1); }
+  virtual gfx::Size getCaretSize(Widget* widget) { return gfx::Size(kDefaultFontHeight, 1); }
 
   virtual void paintEntry(PaintEvent& ev) {}
   virtual void paintTextEdit(PaintEvent& ev) {}

From 35d209a4b121c49284efb11e88b5e5e434778cf3 Mon Sep 17 00:00:00 2001
From: David Capello <david@igara.com>
Date: Tue, 7 Oct 2025 11:25:00 -0300
Subject: [PATCH 15/15] Remove ASSERT() that can fail if we paste a RTL text

---
 src/ui/textedit.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/ui/textedit.cpp b/src/ui/textedit.cpp
index 9b91af5fb..44023ebd8 100644
--- a/src/ui/textedit.cpp
+++ b/src/ui/textedit.cpp
@@ -799,7 +799,6 @@ struct Utf8RangeBuilder : public text::TextBlob::RunHandler {
 
   void commitRunBuffer(TextBlob::RunInfo& info) override
   {
-    ASSERT(info.clusters == nullptr || *info.clusters == 0);
     for (int i = 0; i < info.glyphCount; ++i) {
       ranges.push_back(info.getGlyphUtf8Range(i));
     }