SkPDF: drawText makes use of SkPaint.measureText() for alignment.

src/pdf/SkPDFDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFDevice.h"
 #include "SkAnnotationKeys.h"
 #include "SkBitmapDevice.h"
@@ skipping 60 matching lines @@
             result.setStyle(SkPaint::kStrokeAndFill_Style);
         } else {
             width += result.getStrokeWidth();
         }
         result.setStrokeWidth(width);
     }
     return result;
 }
 
 // Stolen from measure_text in SkDraw.cpp and then tweaked.
-static void align_text(SkPaint::GlyphCacheProc glyphCacheProc, const SkPaint& paint,
+static void align_text(const SkPaint& paint,
                        const uint16_t* glyphs, size_t len,
                        SkScalar* x, SkScalar* y) {
     if (paint.getTextAlign() == SkPaint::kLeft_Align) {
         return;
     }
-
-    SkMatrix ident;
-    ident.reset();
-    SkAutoGlyphCache autoCache(paint, nullptr, &ident);
-    SkGlyphCache* cache = autoCache.getCache();
-
-    const char* start = reinterpret_cast<const char*>(glyphs);
-    const char* stop = reinterpret_cast<const char*>(glyphs + len);
-    SkScalar xAdv = 0, yAdv = 0;
-
-    // TODO(vandebo): This probably needs to take kerning into account.
-    while (start < stop) {
-        const SkGlyph& glyph = glyphCacheProc(cache, &start);
-        xAdv += SkFloatToScalar(glyph.fAdvanceX);
-        yAdv += SkFloatToScalar(glyph.fAdvanceY);
-    };
-    if (paint.getTextAlign() == SkPaint::kLeft_Align) {
-        return;
+    SkScalar advance = paint.measureText(glyphs, len * sizeof(uint16_t));
+    if (paint.getTextAlign() == SkPaint::kCenter_Align) {
+        advance *= 0.5f;
     }
-
-    if (paint.getTextAlign() == SkPaint::kCenter_Align) {
-        xAdv = SkScalarHalf(xAdv);
-        yAdv = SkScalarHalf(yAdv);
+    if (paint.isVerticalText()) {
+        *y -= advance;
+    } else {
+        *x -= advance;
     }
-    *x = *x - xAdv;
-    *y = *y - yAdv;
 }
 
 static int max_glyphid_for_typeface(SkTypeface* typeface) {
     SkAutoResolveDefaultTypeface autoResolve(typeface);
     typeface = autoResolve.get();
     return typeface->countGlyphs() - 1;
 }
 
 typedef SkAutoSTMalloc<128, uint16_t> SkGlyphStorage;
 
@@ skipping 1084 matching lines @@
     ScopedContentEntry content(this, d, textPaint, true);
     if (!content.entry()) {
         return;
     }
 
     SkGlyphStorage storage(0);
     const uint16_t* glyphIDs = nullptr;
     int numGlyphs = force_glyph_encoding(paint, text, len, &storage, &glyphIDs);
     textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
-    SkPaint::GlyphCacheProc glyphCacheProc = SkPaint::GetGlyphCacheProc(textPaint.getTextEncoding(),
-                                                                        textPaint.isDevKernText(),
-                                                                        true);
-    align_text(glyphCacheProc, textPaint, glyphIDs, numGlyphs, &x, &y);
+    align_text(textPaint, glyphIDs, numGlyphs, &x, &y);
     content.entry()->fContent.writeText("BT\n");
     set_text_transform(x, y, textPaint.getTextSkewX(),
                        &content.entry()->fContent);
     int consumedGlyphCount = 0;
 
     SkTDArray<uint16_t> glyphIDsCopy(glyphIDs, numGlyphs);
 
     SkPDFGlyphSetMap* fontGlyphUsage = fDocument->getGlyphUsage();
 
     while (numGlyphs > consumedGlyphCount) {
@@ skipping 55 matching lines @@
     ScopedContentEntry content(this, d, textPaint, true);
     if (!content.entry()) {
         return;
     }
 
     SkGlyphStorage storage(0);
     const uint16_t* glyphIDs = nullptr;
     size_t numGlyphs = force_glyph_encoding(paint, text, len, &storage, &glyphIDs);
     textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
-    SkPaint::GlyphCacheProc glyphCacheProc = SkPaint::GetGlyphCacheProc(textPaint.getTextEncoding(),
-                                                                        textPaint.isDevKernText(),
-                                                                        true);
     content.entry()->fContent.writeText("BT\n");
     this->updateFont(textPaint, glyphIDs[0], content.entry());
     GlyphPositioner glyphPositioner(&content.entry()->fContent,
                                     textPaint.getTextSkewX(),
                                     content.entry()->fState.fFont->multiByteGlyphs());
     SkPDFGlyphSetMap* fontGlyphUsage = fDocument->getGlyphUsage();
     for (size_t i = 0; i < numGlyphs; i++) {
         SkPDFFont* font = content.entry()->fState.fFont;
         uint16_t encodedValue = glyphIDs[i];
         if (font->glyphsToPDFFontEncoding(&encodedValue, 1) != 1) {
             // The current pdf font cannot encode the current glyph.
             // Try to get a pdf font which can encode the current glyph.
             glyphPositioner.flush();
             this->updateFont(textPaint, glyphIDs[i], content.entry());
             font = content.entry()->fState.fFont;
             glyphPositioner.setWideChars(font->multiByteGlyphs());
             if (font->glyphsToPDFFontEncoding(&encodedValue, 1) != 1) {
                 SkDEBUGFAIL("PDF could not encode glyph.");
                 continue;
             }
         }
 
         fontGlyphUsage->noteGlyphUsage(font, &encodedValue, 1);
         SkScalar x = offset.x() + pos[i * scalarsPerPos];
         SkScalar y = offset.y() + (2 == scalarsPerPos ? pos[i * scalarsPerPos + 1] : 0);
-        align_text(glyphCacheProc, textPaint, glyphIDs + i, 1, &x, &y);
+        align_text(textPaint, glyphIDs + i, 1, &x, &y);
 
         SkScalar advanceWidth = textPaint.measureText(&encodedValue, sizeof(uint16_t));
         glyphPositioner.writeGlyph(x, y, advanceWidth, encodedValue);
     }
     glyphPositioner.flush();  // Must flush before ending text object.
     content.entry()->fContent.writeText("ET\n");
 }
 
 void SkPDFDevice::drawVertices(const SkDraw& d, SkCanvas::VertexMode,
                                int vertexCount, const SkPoint verts[],
@@ skipping 909 matching lines @@
 }
 
 sk_sp<SkSpecialImage> SkPDFDevice::makeSpecial(const SkImage* image) {
     return SkSpecialImage::MakeFromImage(SkIRect::MakeWH(image->width(), image->height()),
                                          image->makeNonTextureImage());
 }
 
 sk_sp<SkSpecialImage> SkPDFDevice::snapSpecial() {
     return nullptr;
 }