add helper to create fancy underlines

src/core/SkPaint.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
@@ skipping 1181 matching lines @@
     const SkPath*   iterPath;
     while (iter.next(&iterPath, &xpos)) {
         matrix.postTranslate(xpos - prevXPos, 0);
         if (iterPath) {
             path->addPath(*iterPath, matrix);
         }
         prevXPos = xpos;
     }
 }
 
+int SkPaint::getTextIntercepts(const void* textData, size_t length,
+                               SkScalar x, SkScalar y, const SkScalar bounds[2], 
+                               SkScalar* array) const {
+    SkASSERT(length == 0 || textData != nullptr);
+    if (!length) {
+        return 0;
+    }
+
+    const char* text = (const char*) textData;
+    SkTextInterceptsIter iter(text, length, *this, bounds, x, y,
+            SkTextInterceptsIter::TextType::kText);
+    int count = 0;
+    while (iter.next(array, &count)) {
+    }
+    return count;
+}
+
 void SkPaint::getPosTextPath(const void* textData, size_t length,
                              const SkPoint pos[], SkPath* path) const {
     SkASSERT(length == 0 || textData != nullptr);
 
     const char* text = (const char*)textData;
     if (text == nullptr || length == 0 || path == nullptr) {
         return;
     }
 
     SkTextToPathIter    iter(text, length, *this, false);
     SkMatrix            matrix;
     SkPoint             prevPos;
     prevPos.set(0, 0);
 
     matrix.setScale(iter.getPathScale(), iter.getPathScale());
     path->reset();
 
     unsigned int    i = 0;
     const SkPath*   iterPath;
     while (iter.next(&iterPath, nullptr)) {
         matrix.postTranslate(pos[i].fX - prevPos.fX, pos[i].fY - prevPos.fY);
         if (iterPath) {
             path->addPath(*iterPath, matrix);
         }
         prevPos = pos[i];
         i++;
     }
 }
 
+int SkPaint::getPosTextIntercepts(const void* textData, size_t length, const SkPoint pos[],
+                                  const SkScalar bounds[2], SkScalar* array) const {
+    SkASSERT(length == 0 || textData != nullptr);
+    if (!length) {
+        return 0;
+    }
+
+    const char* text = (const char*) textData;
+    SkTextInterceptsIter iter(text, length, *this, bounds, pos[0].fX, pos[0].fY,
+            SkTextInterceptsIter::TextType::kPosText);
+    int i = 0;
+    int count = 0;
+    while (iter.next(array, &count)) {
+        i++;
+        iter.setPosition(pos[i].fX, pos[i].fY);
+    }
+    return count;
+}
+
 SkRect SkPaint::getFontBounds() const {
     SkMatrix m;
     m.setScale(fTextSize * fTextScaleX, fTextSize);
     m.postSkew(fTextSkewX, 0);
 
     SkTypeface* typeface = this->getTypeface();
     if (nullptr == typeface) {
         typeface = SkTypeface::GetDefaultTypeface();
     }
 
@@ skipping 1044 matching lines @@
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool has_thick_frame(const SkPaint& paint) {
     return  paint.getStrokeWidth() > 0 &&
             paint.getStyle() != SkPaint::kFill_Style;
 }
 
-SkTextToPathIter::SkTextToPathIter(const char text[], size_t length,
+SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
                                    const SkPaint& paint,
                                    bool applyStrokeAndPathEffects)
     : fPaint(paint) {
     fGlyphCacheProc = paint.getMeasureCacheProc(true);
 
     fPaint.setLinearText(true);
     fPaint.setMaskFilter(nullptr);   // don't want this affecting our path-cache lookup
 
     if (fPaint.getPathEffect() == nullptr && !has_thick_frame(fPaint)) {
         applyStrokeAndPathEffects = false;
@@ skipping 42 matching lines @@
     }
     fXPos = xOffset;
     fPrevAdvance = 0;
 
     fText = text;
     fStop = text + length;
 
     fXYIndex = paint.isVerticalText() ? 1 : 0;
 }
 
-SkTextToPathIter::~SkTextToPathIter() {
+SkTextBaseIter::~SkTextBaseIter() {
     SkGlyphCache::AttachCache(fCache);
 }
 
 bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
     if (fText < fStop) {
         const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
 
         fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
         fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
 
         if (glyph.fWidth) {
             if (path) {
                 *path = fCache->findPath(glyph);
             }
         } else {
             if (path) {
                 *path = nullptr;
             }
         }
         if (xpos) {
             *xpos = fXPos;
         }
         return true;
     }
     return false;
 }
 
+bool SkTextInterceptsIter::next(SkScalar* array, int* count) {
+    const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
+    fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
+    fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
+    if (fCache->findPath(glyph)) {
+        fCache->findIntercepts(fBounds, fScale, fXPos, SkToBool(fXYIndex),
+                const_cast<SkGlyph*>(&glyph), array, count);
+    }
+    return fText < fStop;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 // return true if the filter exists, and may affect alpha
 static bool affects_alpha(const SkColorFilter* cf) {
     return cf && !(cf->getFlags() & SkColorFilter::kAlphaUnchanged_Flag);
 }
 
 // return true if the filter exists, and may affect alpha
 static bool affects_alpha(const SkImageFilter* imf) {
     // TODO: check if we should allow imagefilters to broadcast that they don't affect alpha
@@ skipping 27 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     static_assert(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
                   "SkPaint_notPackedTightly");
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }