WIP -- SkFont

src/core/SkFont.cpp

Index: src/core/SkFont.cpp
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7fb13b7b9158eac81690542a34f802396e8c4463
--- /dev/null
+++ b/src/core/SkFont.cpp
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkFont.h"
+#include "SkTypeface.h"
+#include "SkUtils.h"
+
+static SkTypeface* ref_or_default(SkTypeface* face) {
+    return face ? SkRef(face) : SkTypeface::RefDefault();
+}
+
+SkFont::SkFont(SkTypeface* face, SkScalar size, SkScalar scaleX, SkScalar skewX, MaskType mt,
+               uint32_t flags)
+    : fTypeface(ref_or_default(face))
+    , fSize(size)
+    , fScaleX(scaleX)
+    , fSkewX(skewX)
+    , fFlags(flags)
+    , fMaskType(SkToU8(mt))
+    , fPad(0)
+{
+    SkASSERT(size > 0);
+    SkASSERT(scaleX > 0);
+    SkASSERT(SkScalarIsFinite(skewX));
+    SkASSERT(0 == (flags & ~kAllFlags));
+}
+
+SkFont* SkFont::Create(SkTypeface* face, SkScalar size, SkScalar scaleX, SkScalar skewX,
+                       MaskType mt, uint32_t flags) {
+    if (!(size > 0)) {
+        size = 12;
+    }
+    if (!(scaleX > 0)) {
+        scaleX = 1;
+    }
+    if (!SkScalarIsFinite(skewX)) {
+        skewX = 0;
+    }
+    flags &= kAllFlags;
+    return SkNEW_ARGS(SkFont, (face, size, scaleX, skewX, mt, flags));
+}
+
+SkFont* SkFont::Create(SkTypeface* face, SkScalar size, MaskType mt, uint32_t flags) {
+    return SkFont::Create(face, size, 1, 0, mt, flags);
+}
+
+SkFont* SkFont::Create(const SkFont& src, SkScalar newSize) {
+    return SkFont::Create(src.getTypeface(), newSize, src.getScaleX(), src.getSkewX(),
+                          src.getMaskType(), src.getFlags());
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+SkFont::~SkFont() {
+    SkSafeUnref(fTypeface);
+}
+
+int SkFont::textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
+                         uint16_t glyphs[], int maxGlyphCount) const {
+    if (0 == byteLength) {
+        return 0;
+    }
+    
+    SkASSERT(text);
+
+    int count;
+    switch (encoding) {
+        case kUTF8_SkTextEncoding:
+            count = SkUTF8_CountUnichars((const char*)text, byteLength);
+        case kUTF16_SkTextEncoding:
+            count = SkUTF16_CountUnichars((const uint16_t*)text, SkToInt(byteLength >> 1));
+        case kUTF32_SkTextEncoding:
+            count = SkToInt(byteLength >> 2);
+        case kGlyphID_SkTextEncoding:
+            count = SkToInt(byteLength >> 1);
+    }
+    if (NULL == glyphs) {
+        return count;
+    }
+
+    if (kGlyphID_SkTextEncoding == encoding) {
+        memcpy(glyphs, text, count << 1);
+        return count;
+    }
+
+    // TODO: unify/eliminate SkTypeface::Encoding with SkTextEncoding
+    SkTypeface::Encoding typeface_encoding;
+    switch (encoding) {
+        case kUTF8_SkTextEncoding:
+            typeface_encoding = SkTypeface::kUTF8_Encoding;
+            break;
+        case kUTF16_SkTextEncoding:
+            typeface_encoding = SkTypeface::kUTF16_Encoding;
+            break;
+        case kUTF32_SkTextEncoding:
+            typeface_encoding = SkTypeface::kUTF32_Encoding;
+            break;
+        case kGlyphID_SkTextEncoding:
+            SkASSERT(0);    // can't get here
+    }
+
+    (void)fTypeface->charsToGlyphs(text, typeface_encoding, glyphs, count);
+    return count;
+}
+
+SkScalar SkFont::measureText(const void* text, size_t byteLength, SkTextEncoding encoding) const {
+    // TODO: need access to the cache
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "SkPaint.h"
+
+SkFont* SkFont::Testing_CreateFromPaint(const SkPaint& paint) {
+    uint32_t flags = 0;
+    if (paint.isVerticalText()) {
+        flags |= kVertical_Flag;
+    }
+    if (paint.isEmbeddedBitmapText()) {
+        flags |= kEmbeddedBitmaps_Flag;
+    }
+    if (paint.getFlags() & SkPaint::kGenA8FromLCD_Flag) {
+        flags |= kGenA8FromLCD_Flag;
+    }
+    if (paint.isFakeBoldText()) {
+        flags |= kEmbolden_Flag;
+    }
+
+    if (SkPaint::kFull_Hinting == paint.getHinting()) {

[bungeman-skia, 2014/03/27 19:13:15]

I believe that on all back-ends we currently consider both normal and full to
enable bytecode (then autohint), with 'slight' meaning autohint (no bytecode),
and 'none' meaning none. The only distinction we currently have between normal
and full is on FreeType, where it enables subpixel (cleartype) style hints. I'm
not sure that's a distinction we're really interest in, and I'm not sure who
uses it or notices the difference (on most platforms there is none).

+        flags |= kEnableByteCodeHints_Flag;
+    }
+    if (paint.isAutohinted()) {

[bungeman-skia, 2014/03/27 19:13:15]

If set, the 'autohinted' flag means (on FreeType only, since it's the only one
which cares about this flag) that if paint hinting is set to normal or full that
autohinting should be enabled and bytecode hinting disabled.

+        flags |= kEnableAutoHints_Flag;
+    }
+    if (paint.isSubpixelText() || paint.isLinearText()) {

[bungeman-skia, 2014/03/27 19:13:15]

According to the android docs, setting linear should probably override any
hinting and disable the hinting flags? I can honestly say that there is no
general consensus amongst the back-ends about what the 'subpixel' flag actually
does, but this looks like what it might actually be doing.

+        // this is our default
+    } else {
+        flags |= kUseNonlinearMetrics_Flag;
+    }
+
+    MaskType maskType = SkFont::kBW_MaskType;
+    if (paint.isAntiAlias()) {
+        maskType = paint.isLCDRenderText() ? kLCD_MaskType : kA8_MaskType;
+    }
+
+    return Create(paint.getTypeface(),
+                  paint.getTextSize(), paint.getTextScaleX(), paint.getTextSkewX(),
+                  maskType, flags);
+}