Text: Fixed drawing wrapped text without HarfBuzz

2 files changed, 52 insertions, 7 deletions

diff --git a/src/ui/text.c b/src/ui/text.c
index 866ae7fa..0a8386e4 100644
--- a/src/ui/text.c
+++ b/src/ui/text.c
@@ -1824,7 +1824,6 @@ static iBool cbAdvanceOneLine_(iWrapText *d, iRangecc range, int origin, int adv
 }
 
 iInt2 tryAdvance_Text(int fontId, iRangecc text, int width, const char **endPos) {
-    /* FIXME: Get rid of this. Caller could use WrapText directly? */
     iWrapText wrap = { .mode     = word_WrapTextMode,
                        .text     = text,
                        .maxWidth = width,
@@ -1835,8 +1834,7 @@ iInt2 tryAdvance_Text(int fontId, iRangecc text, int width, const char **endPos)
 }
 
 iInt2 tryAdvanceNoWrap_Text(int fontId, iRangecc text, int width, const char **endPos) {
-    /* TODO: "NoWrap" means words aren't wrapped; the line is broken at nearest character. */
-    /* FIXME: Get rid of this. Caller could use WrapText directly? */
+    /* "NoWrap" means words aren't wrapped; the line is broken at nearest character. */
     iWrapText wrap = { .mode     = anyCharacter_WrapTextMode,
                        .text     = text,
                        .maxWidth = width,
@@ -2019,6 +2017,27 @@ iTextMetrics measure_WrapText(iWrapText *d, int fontId) {
 
 iTextMetrics draw_WrapText(iWrapText *d, int fontId, iInt2 pos, int color) {
     iTextMetrics tm;
+#if !defined (LAGRANGE_ENABLE_HARFBUZZ)
+    /* In simple mode, each line must be wrapped first so we can break at the right points
+       and do wrap notifications before drawing. */
+    iRangecc text = d->text;
+    iZap(tm);
+    d->wrapRange_ = (iRangecc){ d->text.start, d->text.start };
+    const iInt2 orig = pos;
+    while (!isEmpty_Range(&text)) {
+        const char *endPos;
+        const int width = d->mode == word_WrapTextMode
+                              ? tryAdvance_Text(fontId, text, d->maxWidth, &endPos).x
+                              : tryAdvanceNoWrap_Text(fontId, text, d->maxWidth, &endPos).x;
+        notify_WrapText_(d, endPos, 0, width, iFalse);
+        drawRange_Text(fontId, pos, color, (iRangecc){ text.start, endPos });
+        text.start = endPos;
+        pos.y += lineHeight_Text(fontId);
+        tm.bounds.size.x = iMax(tm.bounds.size.x, width);
+        tm.bounds.size.y = pos.y - orig.y;
+    }
+    tm.advance = sub_I2(pos, orig);
+#else
     tm.bounds = run_Font_(font_Text_(fontId),
               &(iRunArgs){ .mode  = draw_RunMode | runFlagsFromId_(fontId) |
                                     (color & permanent_ColorId ? permanentColorFlag_RunMode : 0) |
@@ -2029,6 +2048,7 @@ iTextMetrics draw_WrapText(iWrapText *d, int fontId, iInt2 pos, int color) {
                            .color = color & mask_ColorId,
                            .cursorAdvance_out = &tm.advance,
     });
+#endif
     return tm;
 }
 
diff --git a/src/ui/text_simple.c b/src/ui/text_simple.c
index a1b8e859..3afc631a 100644
--- a/src/ui/text_simple.c
+++ b/src/ui/text_simple.c
@@ -60,8 +60,8 @@ static iRect runSimple_Font_(iFont *d, const iRunArgs *args) {
     /* This function shapes text using a simplified, incomplete algorithm. It works for English 
        and other non-complex LTR scripts. Composed glyphs are not supported (must rely on text
        being in a pre-composed form). This algorithm is used if HarfBuzz is not available. */
-    iRect       bounds      = zero_Rect();
     const iInt2 orig        = args->pos;
+    iRect       bounds      = { orig, init_I2(0, d->height) };
     float       xpos        = orig.x;
     float       xposMax     = xpos;
     float       monoAdvance = 0;
@@ -76,13 +76,17 @@ static iRect runSimple_Font_(iFont *d, const iRunArgs *args) {
     //iAssert(xposLimit == 0 || isMeasuring_(mode));
     iAssert(args->text.end >= args->text.start);
     if (wrap) {
-        wrap->wrapRange_ = args->text;
+        wrap->wrapRange_        = args->text;
+        wrap->hitAdvance_out    = zero_I2();
+        wrap->hitChar_out       = NULL;
+        wrap->hitGlyphNormX_out = 0.0f;
     }
 //    if (args->continueFrom_out) {
 //        *args->continueFrom_out = args->text.end;
 //    }
-    iChar prevCh = 0;
-    const iBool isMonospaced = d->isMonospaced && !(mode & alwaysVariableWidthFlag_RunMode);
+    const iBool checkHitPoint = wrap && !isEqual_I2(wrap->hitPoint, zero_I2());
+    const iBool checkHitChar  = wrap && wrap->hitChar;
+    const iBool isMonospaced  = d->isMonospaced && !(mode & alwaysVariableWidthFlag_RunMode);
     if (isMonospaced) {
         monoAdvance = glyph_Font_(d, 'M')->advance;
     }
@@ -91,10 +95,21 @@ static iRect runSimple_Font_(iFont *d, const iRunArgs *args) {
         SDL_SetRenderDrawColor(text_.render, initial.r, initial.g, initial.b, 0);
     }
     /* Text rendering is not very straightforward! Let's dive in... */
+    iChar       prevCh = 0;
     const char *chPos;
     for (chPos = args->text.start; chPos != args->text.end; ) {
         iAssert(chPos < args->text.end);
         const char *currentPos = chPos;
+        const iBool isHitPointOnThisLine = (checkHitPoint && wrap->hitPoint.y >= ypos &&
+                                            wrap->hitPoint.y < ypos + d->height);
+        if (checkHitChar && currentPos == wrap->hitChar) {
+            wrap->hitAdvance_out = sub_I2(init_I2(xpos, ypos), orig);
+        }
+        /* Check if the hit point is on the left side of the line. */
+        if (isHitPointOnThisLine && !wrap->hitChar_out && wrap->hitPoint.x < orig.x) {
+            wrap->hitChar_out = currentPos;
+            wrap->hitGlyphNormX_out = 0.0f;
+        }
         if (*chPos == 0x1b) { /* ANSI escape. */
             chPos++;
             iRegExpMatch m;
@@ -213,6 +228,13 @@ static iRect runSimple_Font_(iFont *d, const iRunArgs *args) {
             glyph = glyph_Font_(d, ch); /* cache may have been reset */
         }
         int x2 = x1 + glyph->rect[hoff].size.x;
+        if (isHitPointOnThisLine) {
+            if (wrap->hitPoint.x >= x1) { /* may also be off to the right */
+                wrap->hitChar_out = currentPos;
+                wrap->hitGlyphNormX_out =
+                    wrap->hitPoint.x < x2 ? (wrap->hitPoint.x - x1) / glyph->advance : 1.0f;
+            }
+        }
         /* Out of the allotted space on the line? */
         if (xposLimit > 0 && x2 > xposLimit) {
             iAssert(wrap);
@@ -340,6 +362,9 @@ static iRect runSimple_Font_(iFont *d, const iRunArgs *args) {
         }
     }
     notify_WrapText_(wrap, chPos, 0, xpos - orig.x, iFalse);
+    if (checkHitChar && wrap->hitChar == args->text.end) {
+        wrap->hitAdvance_out = sub_I2(init_I2(xpos, ypos), orig);
+    }
     if (args->cursorAdvance_out) {
         *args->cursorAdvance_out = sub_I2(init_I2(xpos, ypos), orig);
     }