SkTextBlob: Begin implementing Extended TextBlob API

tools/using_skia_and_harfbuzz.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This sample progam demonstrates how to use Skia and HarfBuzz to
 // produce a PDF file from UTF-8 text in stdin.
 
 #include <cassert>
 #include <cstdlib>
 #include <iostream>
 #include <map>
 #include <string>
 #include <sstream>
 
 #include <hb-ot.h>
 
 #include "SkCanvas.h"
 #include "SkDocument.h"
+#include "SkFontMgr.h"
 #include "SkStream.h"
 #include "SkTextBlob.h"
 #include "SkTypeface.h"
 
 struct BaseOption {
   std::string selector;
   std::string description;
   virtual void set(std::string _value) = 0;
   virtual std::string valueToString() = 0;
 
@@ skipping 47 matching lines @@
 };
 
 struct Config {
   DoubleOption *page_width = new DoubleOption("-w", "Page width", 600.0f);
   DoubleOption *page_height = new DoubleOption("-h", "Page height", 800.0f);
   SkStringOption *title = new SkStringOption("-t", "PDF title", SkString("---"));
   SkStringOption *author = new SkStringOption("-a", "PDF author", SkString("---"));
   SkStringOption *subject = new SkStringOption("-k", "PDF subject", SkString("---"));
   SkStringOption *keywords = new SkStringOption("-c", "PDF keywords", SkString("---"));
   SkStringOption *creator = new SkStringOption("-t", "PDF creator", SkString("---"));
-  StdStringOption *font_file = new StdStringOption("-f", ".ttf font file", "fonts/DejaVuSans.ttf");
+  StdStringOption *font_file = new StdStringOption("-f", ".ttf font file", "");
   DoubleOption *font_size = new DoubleOption("-z", "Font size", 8.0f);
   DoubleOption *left_margin = new DoubleOption("-m", "Left margin", 20.0f);
   DoubleOption *line_spacing_ratio = new DoubleOption("-h", "Line spacing ratio", 1.5f);
   StdStringOption *output_file_name = new StdStringOption("-o", ".pdf output file name", "out-skiahf.pdf");
 
   std::map<std::string, BaseOption*> options = {
     { page_width->selector, page_width },
     { page_height->selector, page_height },
     { title->selector, title },
     { author->selector, author },
@@ skipping 63 matching lines @@
     hb_blob_destroy(blob);
     assert(face);
     if (!face) {
         fSkiaTypeface.reset();
         return;
     }
     hb_face_set_index(face, (unsigned)index);
     hb_face_set_upem(face, fSkiaTypeface->getUnitsPerEm());
     fHarfBuzzFace.reset(face);
   }
+  Face(sk_sp<SkTypeface> typeface) {
+    fSkiaTypeface = std::move(typeface);
+    int ttcIndex = 0;
+    std::unique_ptr<SkStreamAsset> asset(fSkiaTypeface->openStream(&ttcIndex));
+    size_t length = asset->getLength();
+    void* data = sk_malloc_throw(length);
+    asset->read(data, length);
+    asset = nullptr;
+    hb_blob_t* blob = hb_blob_create(
+            static_cast<const char*>(data), SkToUInt(length),
+            HB_MEMORY_MODE_WRITABLE, data, sk_free);
+    assert(blob);
+    hb_blob_make_immutable(blob);
+    hb_face_t* face = hb_face_create(blob, (unsigned)ttcIndex);
+    hb_blob_destroy(blob);
+    assert(face);
+    if (!face) {
+        fSkiaTypeface.reset();
+        return;
+    }
+    hb_face_set_index(face, (unsigned)ttcIndex);
+    hb_face_set_upem(face, fSkiaTypeface->getUnitsPerEm());
+    fHarfBuzzFace.reset(face);
+  }
 };
 
 class Placement {
  public:
   Placement(Config &_config, SkWStream* outputStream) : config(_config) {
-    face = new Face(config.font_file->value.c_str(), 0 /* index */);
+    const char* font_file = config.font_file->value.c_str();
+    if (font_file && strlen(font_file)) {
+      face = new Face(config.font_file->value.c_str(), 0 /* index */);
+    } else {
+      sk_sp<SkFontMgr> mgr(SkFontMgr::RefDefault());
+      sk_sp<SkTypeface> typeface(mgr->matchFamilyStyle(nullptr, SkFontStyle()));
+      face = new Face(std::move(typeface));
+    }
     hb_font = hb_font_create(face->fHarfBuzzFace.get());
-
     hb_font_set_scale(hb_font,
         FONT_SIZE_SCALE * config.font_size->value,
         FONT_SIZE_SCALE * config.font_size->value);
     hb_ot_font_set_funcs(hb_font);
 
     SkDocument::PDFMetadata pdf_info;
     pdf_info.fTitle = config.title->value;
     pdf_info.fAuthor = config.author->value;
     pdf_info.fSubject = config.subject->value;
     pdf_info.fKeywords = config.keywords->value;
@@ skipping 28 matching lines @@
 
   void WriteLine(const char *text) {
     /* Create hb-buffer and populate. */
     hb_buffer_t *hb_buffer = hb_buffer_create ();
     hb_buffer_add_utf8 (hb_buffer, text, -1, 0, -1);
     hb_buffer_guess_segment_properties (hb_buffer);
 
     /* Shape it! */
     hb_shape (hb_font, hb_buffer, NULL, 0);
 
-    DrawGlyphs(hb_buffer);
+    DrawGlyphs(text, hb_buffer);
 
     hb_buffer_destroy (hb_buffer);
 
     // Advance to the next line.
     current_y += config.line_spacing_ratio->value * config.font_size->value;
     if (current_y > config.page_height->value) {
       pdfDocument->endPage();
       NewPage();
     }
   }
@@ skipping 21 matching lines @@
 
   void NewPage() {
     pageCanvas = pdfDocument->beginPage(config.page_width->value, config.page_height->value);
 
     pageCanvas->drawPaint(white_paint);
 
     current_x = config.left_margin->value;
     current_y = config.line_spacing_ratio->value * config.font_size->value;
   }
 
-  bool DrawGlyphs(hb_buffer_t *hb_buffer) {
+  bool DrawGlyphs(const char *text, hb_buffer_t *hb_buffer) {
     SkTextBlobBuilder textBlobBuilder;
     unsigned len = hb_buffer_get_length (hb_buffer);
     if (len == 0) {
       return true;
     }
     hb_glyph_info_t *info = hb_buffer_get_glyph_infos (hb_buffer, NULL);
     hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (hb_buffer, NULL);
-    auto runBuffer = textBlobBuilder.allocRunPos(glyph_paint, len);
+    size_t text_len = strlen(text);
+    auto runBuffer = textBlobBuilder.allocRunTextPos(
+        glyph_paint, len, text_len, SkString());
+    memcpy(runBuffer.utf8text, text, text_len);
 
     double x = 0;
     double y = 0;
     for (unsigned int i = 0; i < len; i++)
     {
       runBuffer.glyphs[i] = info[i].codepoint;
+      runBuffer.clusters[i] = info[i].cluster;
       reinterpret_cast<SkPoint*>(runBuffer.pos)[i] = SkPoint::Make(
         x + pos[i].x_offset / FONT_SIZE_SCALE,
         y - pos[i].y_offset / FONT_SIZE_SCALE);
       x += pos[i].x_advance / FONT_SIZE_SCALE;
       y += pos[i].y_advance / FONT_SIZE_SCALE;
     }
 
     pageCanvas->drawTextBlob(textBlobBuilder.build(), current_x, current_y, glyph_paint);
     return true;
   } // end of DrawGlyphs
 }; // end of Placement class
 
 int main(int argc, char** argv) {
     Config config(argc, argv);
 
     Placement placement(config, new SkFILEWStream(config.output_file_name->value.c_str()));
     for (std::string line; std::getline(std::cin, line);) {
       placement.WriteLine(line.c_str());
     }
     placement.Close();
 
     return 0;
 }