refactoring for SK_FONTHOST_USES_FONTMGR option

src/ports/SkFontHost_win.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 "SkAdvancedTypefaceMetrics.h"
 #include "SkBase64.h"
@@ skipping 232 matching lines @@
 protected:
     virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE;
     virtual SkScalerContext* onCreateScalerContext(const SkDescriptor*) const SK_OVERRIDE;
     virtual void onFilterRec(SkScalerContextRec*) const SK_OVERRIDE;
     virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics(
                                 SkAdvancedTypefaceMetrics::PerGlyphInfo,
                                 const uint32_t*, uint32_t) const SK_OVERRIDE;
     virtual void onGetFontDescriptor(SkFontDescriptor*, bool*) const SK_OVERRIDE;
     virtual int onCountGlyphs() const SK_OVERRIDE;
     virtual int onGetUPEM() const SK_OVERRIDE;
+    virtual SkTypeface* onRefMatchingStyle(Style) const SK_OVERRIDE;
 };
 
 class FontMemResourceTypeface : public LogFontTypeface {
 public:
     /**
      *  Takes ownership of fontMemResource.
      */
     FontMemResourceTypeface(SkTypeface::Style style, SkFontID fontID, const LOGFONT& lf, HANDLE fontMemResource) :
         LogFontTypeface(style, fontID, lf, true), fFontMemResource(fontMemResource) {
     }
@@ skipping 252 matching lines @@
         return NULL;
     }
     *srcRBPtr = srcRB;
     // offset to the start of the image
     return (const char*)fBits + (fHeight - glyph.fHeight) * srcRB;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 #define BUFFERSIZE (1 << 13)
 
-class SkScalerContext_Windows : public SkScalerContext {
+class SkScalerContext_GDI : public SkScalerContext {
 public:
-    SkScalerContext_Windows(SkTypeface*, const SkDescriptor* desc);
-    virtual ~SkScalerContext_Windows();
+    SkScalerContext_GDI(SkTypeface*, const SkDescriptor* desc);
+    virtual ~SkScalerContext_GDI();
 
     // Returns true if the constructor was able to complete all of its
     // initializations (which may include calling GDI).
     bool isValid() const;
 
 protected:
     virtual unsigned generateGlyphCount() SK_OVERRIDE;
     virtual uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
     virtual void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
     virtual void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
@@ skipping 46 matching lines @@
             return CLEARTYPE_QUALITY;
         default:
             if (rec.fFlags & SkScalerContext::kGenA8FromLCD_Flag) {
                 return CLEARTYPE_QUALITY;
             } else {
                 return ANTIALIASED_QUALITY;
             }
     }
 }
 
-SkScalerContext_Windows::SkScalerContext_Windows(SkTypeface* rawTypeface,
+SkScalerContext_GDI::SkScalerContext_GDI(SkTypeface* rawTypeface,
                                                  const SkDescriptor* desc)
         : SkScalerContext(rawTypeface, desc)
         , fDDC(0)
         , fSavefont(0)
         , fFont(0)
         , fSC(0)
         , fGlyphCount(-1)
 {
     LogFontTypeface* typeface = reinterpret_cast<LogFontTypeface*>(rawTypeface);
 
@@ skipping 94 matching lines @@
     // otherwise we have a vector FON, which we don't support.
     // This was determined by testing with Type1 PFM/PFB and OpenTypeCFF OTF,
     // as well as looking at Wine bugs and sources.
     SkASSERT(!(fTM.tmPitchAndFamily & TMPF_VECTOR) ||
               (fTM.tmPitchAndFamily & (TMPF_TRUETYPE | TMPF_DEVICE)));
 
     XFORM xform;
     if (fTM.tmPitchAndFamily & TMPF_VECTOR) {
         // Truetype or PostScript.
         // Stroked FON also gets here (TMPF_VECTOR), but we don't handle it.
-        fType = SkScalerContext_Windows::kTrueType_Type;
+        fType = SkScalerContext_GDI::kTrueType_Type;
 
         // fPost2x2 is column-major, left handed (y down).
         // XFORM 2x2 is row-major, left handed (y down).
         xform.eM11 = SkScalarToFloat(sA.get(SkMatrix::kMScaleX));
         xform.eM12 = SkScalarToFloat(sA.get(SkMatrix::kMSkewY));
         xform.eM21 = SkScalarToFloat(sA.get(SkMatrix::kMSkewX));
         xform.eM22 = SkScalarToFloat(sA.get(SkMatrix::kMScaleY));
         xform.eDx = 0;
         xform.eDy = 0;
 
@@ skipping 25 matching lines @@
                 fHighResMat22.eM22 = float2FIXED(textScale);
 
                 SkScalar invScale = SkScalarInvert(scale);
                 fHiResMatrix = A;
                 fHiResMatrix.preScale(invScale, invScale);
             }
         }
 
     } else {
         // Assume bitmap
-        fType = SkScalerContext_Windows::kBitmap_Type;
+        fType = SkScalerContext_GDI::kBitmap_Type;
 
         xform.eM11 = 1.0f;
         xform.eM12 = 0.0f;
         xform.eM21 = 0.0f;
         xform.eM22 = 1.0f;
         xform.eDx = 0.0f;
         xform.eDy = 0.0f;
 
         // fPost2x2 is column-major, left handed (y down).
         // MAT2 is row major, right handed (y up).
         fMat22.eM11 = SkScalarToFIXED(fRec.fPost2x2[0][0]);
         fMat22.eM12 = SkScalarToFIXED(-fRec.fPost2x2[1][0]);
         fMat22.eM21 = SkScalarToFIXED(-fRec.fPost2x2[0][1]);
         fMat22.eM22 = SkScalarToFIXED(fRec.fPost2x2[1][1]);
     }
 
     fOffscreen.init(fFont, xform);
 }
 
-SkScalerContext_Windows::~SkScalerContext_Windows() {
+SkScalerContext_GDI::~SkScalerContext_GDI() {
     if (fDDC) {
         ::SelectObject(fDDC, fSavefont);
         ::DeleteDC(fDDC);
     }
     if (fFont) {
         ::DeleteObject(fFont);
     }
     if (fSC) {
         ::ScriptFreeCache(&fSC);
     }
 }
 
-bool SkScalerContext_Windows::isValid() const {
+bool SkScalerContext_GDI::isValid() const {
     return fDDC && fFont;
 }
 
-unsigned SkScalerContext_Windows::generateGlyphCount() {
+unsigned SkScalerContext_GDI::generateGlyphCount() {
     if (fGlyphCount < 0) {
         fGlyphCount = calculateGlyphCount(
                           fDDC, static_cast<const LogFontTypeface*>(this->getTypeface())->fLogFont);
     }
     return fGlyphCount;
 }
 
-uint16_t SkScalerContext_Windows::generateCharToGlyph(SkUnichar uni) {
+uint16_t SkScalerContext_GDI::generateCharToGlyph(SkUnichar uni) {
     uint16_t index = 0;
     WCHAR c[2];
     // TODO(ctguil): Support characters that generate more than one glyph.
     if (SkUTF16_FromUnichar(uni, (uint16_t*)c) == 1) {
         // Type1 fonts fail with uniscribe API. Use GetGlyphIndices for plane 0.
         SkAssertResult(GetGlyphIndicesW(fDDC, c, 1, &index, 0));
     } else {
         // Use uniscribe to detemine glyph index for non-BMP characters.
         // Need to add extra item to SCRIPT_ITEM to work around a bug in older
         // windows versions. https://bugzilla.mozilla.org/show_bug.cgi?id=366643
         SCRIPT_ITEM si[2 + 1];
         int items;
         SkAssertResult(
             SUCCEEDED(ScriptItemize(c, 2, 2, NULL, NULL, si, &items)));
 
         WORD log[2];
         SCRIPT_VISATTR vsa;
         int glyphs;
         SkAssertResult(SUCCEEDED(ScriptShape(
             fDDC, &fSC, c, 2, 1, &si[0].a, &index, log, &vsa, &glyphs)));
     }
     return index;
 }
 
-void SkScalerContext_Windows::generateAdvance(SkGlyph* glyph) {
+void SkScalerContext_GDI::generateAdvance(SkGlyph* glyph) {
     this->generateMetrics(glyph);
 }
 
-void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {
+void SkScalerContext_GDI::generateMetrics(SkGlyph* glyph) {
     SkASSERT(fDDC);
 
-    if (fType == SkScalerContext_Windows::kBitmap_Type) {
+    if (fType == SkScalerContext_GDI::kBitmap_Type) {
         SIZE size;
         WORD glyphs = glyph->getGlyphID(0);
         if (0 == GetTextExtentPointI(fDDC, &glyphs, 1, &size)) {
             glyph->fWidth = SkToS16(fTM.tmMaxCharWidth);
         } else {
             glyph->fWidth = SkToS16(size.cx);
         }
         glyph->fHeight = SkToS16(size.cy);
 
         glyph->fTop = SkToS16(-fTM.tmAscent);
@@ skipping 67 matching lines @@
         if (GDI_ERROR != status) {
             SkPoint advance;
             fG_inv.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
             glyph->fAdvanceX = SkScalarToFixed(advance.fX);
             glyph->fAdvanceY = SkScalarToFixed(advance.fY);
         }
     }
 }
 
 static const MAT2 gMat2Identity = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
-void SkScalerContext_Windows::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
+void SkScalerContext_GDI::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
     if (!(mx || my)) {
       return;
     }
 
     if (mx) {
         sk_bzero(mx, sizeof(*mx));
     }
     if (my) {
         sk_bzero(my, sizeof(*my));
     }
 
     SkASSERT(fDDC);
 
 #ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
-    if (fType == SkScalerContext_Windows::kBitmap_Type) {
+    if (fType == SkScalerContext_GDI::kBitmap_Type) {
 #endif
         if (mx) {
             mx->fTop = SkIntToScalar(-fTM.tmAscent);
             mx->fAscent = SkIntToScalar(-fTM.tmAscent);
             mx->fDescent = SkIntToScalar(fTM.tmDescent);
             mx->fBottom = SkIntToScalar(fTM.tmDescent);
             mx->fLeading = SkIntToScalar(fTM.tmExternalLeading);
         }
 
         if (my) {
@@ skipping 298 matching lines @@
         src = SkTAddOffset<const SkGdiRGB>(src, srcRB);
         dst = (uint32_t*)((char*)dst - dstRB);
     }
 }
 
 static inline unsigned clamp255(unsigned x) {
     SkASSERT(x <= 256);
     return x - (x >> 8);
 }
 
-void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
+void SkScalerContext_GDI::generateImage(const SkGlyph& glyph) {
     SkASSERT(fDDC);
 
     const bool isBW = SkMask::kBW_Format == fRec.fMaskFormat;
     const bool isAA = !isLCD(fRec);
 
     size_t srcRB;
     const void* bits = fOffscreen.draw(glyph, isBW, &srcRB);
     if (NULL == bits) {
         LogFontTypeface::EnsureAccessible(this->getTypeface());
         bits = fOffscreen.draw(glyph, isBW, &srcRB);
@@ skipping 329 matching lines @@
                 }
             }
             // Advance past this TTPOLYCURVE.
             cur_poly += sizeof(WORD) * 2 + sizeof(POINTFX) * pc->cpfx;
         }
         cur_glyph += th->cb;
         path->close();
     }
 }
 
-DWORD SkScalerContext_Windows::getGDIGlyphPath(const SkGlyph& glyph, UINT flags,
+DWORD SkScalerContext_GDI::getGDIGlyphPath(const SkGlyph& glyph, UINT flags,
                                                SkAutoSTMalloc<BUFFERSIZE, uint8_t>* glyphbuf)
 {
     GLYPHMETRICS gm;
 
     DWORD total_size = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, BUFFERSIZE, glyphbuf->get(), &fMat22);
     // Sometimes GetGlyphOutlineW returns a number larger than BUFFERSIZE even if BUFFERSIZE > 0.
     // It has been verified that this does not involve a buffer overrun.
     if (GDI_ERROR == total_size || total_size > BUFFERSIZE) {
         // GDI_ERROR because the BUFFERSIZE was too small, or because the data was not accessible.
         // When the data is not accessable GetGlyphOutlineW fails rather quickly,
@@ skipping 16 matching lines @@
             ret = GetGlyphOutlineW(fDDC, glyph.fID, flags, &gm, total_size, glyphbuf->get(), &fMat22);
             if (GDI_ERROR == ret) {
                 SkASSERT(false);
                 return 0;
             }
         }
     }
     return total_size;
 }
 
-void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {
+void SkScalerContext_GDI::generatePath(const SkGlyph& glyph, SkPath* path) {
     SkASSERT(&glyph && path);
     SkASSERT(fDDC);
 
     path->reset();
 
     // Out of all the fonts on a typical Windows box,
     // 25% of glyphs require more than 2KB.
     // 1% of glyphs require more than 4KB.
     // 0.01% of glyphs require more than 8KB.
     // 8KB is less than 1% of the normal 1MB stack on Windows.
@@ skipping 324 matching lines @@
         return NULL;
     }
 
     // Create the typeface.
     LOGFONT lf;
     logfont_for_name(familyName, &lf);
 
     return SkCreateFontMemResourceTypefaceFromLOGFONT(lf, fontReference);
 }
 
-SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {
-    return create_from_stream(stream);
-}
-
 SkStream* LogFontTypeface::onOpenStream(int* ttcIndex) const {
     *ttcIndex = 0;
 
     const DWORD kTTCTag =
         SkEndian_SwapBE32(SkSetFourByteTag('t', 't', 'c', 'f'));
     LOGFONT lf = fLogFont;
 
     HDC hdc = ::CreateCompatibleDC(NULL);
     HFONT font = CreateFontIndirect(&lf);
     HFONT savefont = (HFONT)SelectObject(hdc, font);
@@ skipping 46 matching lines @@
     unsigned int upem = calculateUPEM(hdc, fLogFont);
 
     SelectObject(hdc, savefont);
     DeleteObject(font);
     DeleteDC(hdc);
 
     return upem;
 }
 
 SkScalerContext* LogFontTypeface::onCreateScalerContext(const SkDescriptor* desc) const {
-    SkScalerContext_Windows* ctx = SkNEW_ARGS(SkScalerContext_Windows,
+    SkScalerContext_GDI* ctx = SkNEW_ARGS(SkScalerContext_GDI,
                                                 (const_cast<LogFontTypeface*>(this), desc));
     if (!ctx->isValid()) {
         SkDELETE(ctx);
         ctx = NULL;
     }
     return ctx;
 }
 
-/** Return the closest matching typeface given either an existing family
- (specified by a typeface in that family) or by a familyName, and a
- requested style.
- 1) If familyFace is null, use familyName.
- 2) If familyName is null, use familyFace.
- 3) If both are null, return the default font that best matches style
- This MUST not return NULL.
- */
-
-SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
-                                       const char familyName[],
-                                       SkTypeface::Style style) {
-    LOGFONT lf;
-    if (NULL == familyFace && NULL == familyName) {
-        lf = get_default_font();
-    } else if (familyFace) {
-        LogFontTypeface* face = (LogFontTypeface*)familyFace;
-        lf = face->fLogFont;
-    } else {
-        logfont_for_name(familyName, &lf);
-    }
-    setStyle(&lf, style);
-    return SkCreateTypefaceFromLOGFONT(lf);
-}
-
-SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
-    SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
-    return stream.get() ? CreateTypefaceFromStream(stream) : NULL;
-}
-
 void LogFontTypeface::onFilterRec(SkScalerContextRec* rec) const {
     if (rec->fFlags & SkScalerContext::kLCD_BGROrder_Flag ||
         rec->fFlags & SkScalerContext::kLCD_Vertical_Flag)
     {
         rec->fMaskFormat = SkMask::kA8_Format;
         rec->fFlags |= SkScalerContext::kGenA8FromLCD_Flag;
     }
 
     unsigned flagsWeDontSupport = SkScalerContext::kDevKernText_Flag |
                                   SkScalerContext::kAutohinting_Flag |
@@ skipping 34 matching lines @@
         rec->fMaskFormat = SkMask::kA8_Format;
     }
 #endif
 
     if (!fCanBeLCD && isLCD(*rec)) {
         rec->fMaskFormat = SkMask::kA8_Format;
         rec->fFlags &= ~SkScalerContext::kGenA8FromLCD_Flag;
     }
 }
 
+static SkTypeface* create_typeface(const SkTypeface* familyFace,
+                                   const char familyName[],
+                                   unsigned styleBits) {
+    LOGFONT lf;
+    if (NULL == familyFace && NULL == familyName) {
+        lf = get_default_font();
+    } else if (familyFace) {
+        LogFontTypeface* face = (LogFontTypeface*)familyFace;
+        lf = face->fLogFont;
+    } else {
+        logfont_for_name(familyName, &lf);
+    }
+    setStyle(&lf, (SkTypeface::Style)styleBits);
+    return SkCreateTypefaceFromLOGFONT(lf);
+}
+
+SkTypeface* LogFontTypeface::onRefMatchingStyle(Style style) const {
+    return create_typeface(this, NULL, style);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkFontMgr.h"
 #include "SkDataTable.h"
 
 static bool valid_logfont_for_enum(const LOGFONT& lf, DWORD fontType) {
     return TRUETYPE_FONTTYPE == fontType
         && lf.lfFaceName[0]
         && lf.lfFaceName[0] != '@'
         && OUT_STROKE_PRECIS == lf.lfOutPrecision
@@ skipping 147 matching lines @@
         SkAutoTUnref<SkStream> stream(SkNEW_ARGS(SkMemoryStream, (data)));
         return this->createFromStream(stream);
     }
 
     virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) SK_OVERRIDE {
         // could be in base impl
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
         return this->createFromStream(stream);
     }
 
+    virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
+                                               unsigned styleBits) SK_OVERRIDE {
+        return create_typeface(NULL, familyName, styleBits);
+    }
+
 private:
     SkTDArray<ENUMLOGFONTEX> fLogFontArray;
 };
 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef SK_FONTHOST_USES_FONTMGR
+
+SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
+                                       const char familyName[],
+                                       SkTypeface::Style style) {
+    return create_typeface(familyFace, familyName, styleBits);
+}
+
+SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
+    SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
+    return stream.get() ? CreateTypefaceFromStream(stream) : NULL;
+}
+
+SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {
+    return create_from_stream(stream);
+}
+
+#endif
+
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgrGDI);
 }