SkPDF: Join Positioned Text

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"
@@ skipping 1061 matching lines @@
         SkAutoMalloc buffer(len);  // Remove every other byte.
         uint8_t* ptr = (uint8_t*)buffer.get();
         for (size_t i = 0; i < len; i++) {
             SkASSERT(0 == input[i] >> 8);
             ptr[i] = static_cast<uint8_t>(input[i]);
         }
         SkPDFUtils::WriteString(wStream, (char*)buffer.get(), len);
     }
 }
 
+namespace {
+class GlyphPositioner {
+public:
+    GlyphPositioner(SkDynamicMemoryWStream* content,
+                    SkScalar textSkewX,
+                    bool wideChars)
+        : fContent(content)
+        , fCurrentMatrixX(0.0f)
+        , fCurrentMatrixY(0.0f)
+        , fXAdvance(0.0f)
+        , fWideChars(wideChars)
+        , fInText(false) {
+        set_text_transform(0.0f, 0.0f, textSkewX, fContent);
+    }
+    ~GlyphPositioner() { SkASSERT(!fInText);  /* flush first */ }
+    void flush() {
+        if (fInText) {
+            fContent->writeText("> Tj\n");
+            fInText = false;
+        }
+    }
+    void setWideChars(bool wideChars) {
+        if (fWideChars != wideChars) {
+            SkASSERT(!fInText);
+            fWideChars = wideChars;
+        }
+    }
+    void writeGlyph(SkScalar x,
+                    SkScalar y,
+                    SkScalar advanceWidth,
+                    uint16_t glyph) {
+        SkScalar xPosition = x - fCurrentMatrixX;
+        SkScalar yPosition = y - fCurrentMatrixY;
+        if (xPosition != fXAdvance || yPosition != 0) {
+            this->flush();
+            SkPDFUtils::AppendScalar(xPosition, fContent);
+            fContent->writeText(" ");
+            SkPDFUtils::AppendScalar(-yPosition, fContent);
+            fContent->writeText(" Td ");
+            fCurrentMatrixX = x;
+            fCurrentMatrixY = y;
+            fXAdvance = 0;
+        }
+        if (!fInText) {
+            fContent->writeText("<");
+            fInText = true;
+        }
+        if (fWideChars) {
+            SkPDFUtils::WriteUInt16BE(fContent, glyph);
+        } else {
+            SkASSERT(0 == glyph >> 8);
+            SkPDFUtils::WriteUInt8(fContent, static_cast<uint8_t>(glyph));
+        }
+        fXAdvance += advanceWidth;
+    }
+
+private:
+    SkDynamicMemoryWStream* fContent;
+    SkScalar fCurrentMatrixX;
+    SkScalar fCurrentMatrixY;
+    SkScalar fXAdvance;
+    bool fWideChars;
+    bool fInText;
+};
+}  // namespace
+
 static void draw_transparent_text(SkPDFDevice* device,
                                   const SkDraw& d,
                                   const void* text, size_t len,
                                   SkScalar x, SkScalar y,
                                   const SkPaint& srcPaint) {
 
     SkPaint transparent;
     if (!SkPDFFont::CanEmbedTypeface(transparent.getTypeface(),
                                      device->getCanon())) {
         SkDEBUGFAIL("default typeface should be embeddable");
@@ skipping 131 matching lines @@
     }
 
     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 = textPaint.getGlyphCacheProc(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(glyphCacheProc, textPaint, glyphIDs + i, 1, &x, &y);
-        set_text_transform(x, y, textPaint.getTextSkewX(), &content.entry()->fContent);
-        write_wide_string(&content.entry()->fContent, &encodedValue, 1,
-                          font->multiByteGlyphs());
-        content.entry()->fContent.writeText(" Tj\n");
+        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[],
                                const SkPoint texs[], const SkColor colors[],
                                SkXfermode* xmode, const uint16_t indices[],
                                int indexCount, const SkPaint& paint) {
     if (d.fRC->isEmpty()) {
         return;
@@ skipping 853 matching lines @@
         if (!pdfimage) {
             return;
         }
         fDocument->serialize(pdfimage);  // serialize images early.
         fDocument->canon()->addPDFBitmap(key, pdfimage);
     }
     // TODO(halcanary): addXObjectResource() should take a sk_sp<SkPDFObject>
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }