Implement onCountGlyphs and onGetUPEM on Windows.

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"
 #include "SkColorPriv.h"
 #include "SkData.h"
 #include "SkDescriptor.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost.h"
 #include "SkGlyph.h"
 #include "SkMaskGamma.h"
+#include "SkOTTable_maxp.h"
 #include "SkOTUtils.h"
 #include "SkPath.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTemplates.h"
 #include "SkThread.h"
 #include "SkTypeface_win.h"
 #include "SkTypefaceCache.h"
 #include "SkUtils.h"
 
@@ skipping 105 matching lines @@
     return *(FIXED*)(&x);
 }
 static inline SkFixed SkFIXEDToFixed(FIXED x) {
     return *(SkFixed*)(&x);
 }
 
 static inline FIXED SkScalarToFIXED(SkScalar x) {
     return SkFixedToFIXED(SkScalarToFixed(x));
 }
 
-static unsigned calculateOutlineGlyphCount(HDC hdc) {
+static unsigned calculateGlyphCount(HDC hdc, const LOGFONT& lf) {
+    TEXTMETRIC textMetric;
+    if (0 == GetTextMetrics(hdc, &textMetric)) {
+        call_ensure_accessible(lf);
+        if (0 == GetTextMetrics(hdc, &textMetric)) {
+            textMetric.tmPitchAndFamily = TMPF_TRUETYPE;

[vandebo (ex-Chrome), 2013/07/15 17:32:56]

Maybe put this on line 146 to make it more obvious what's going on?  It would
also avoid the if on 148.

[bungeman-skia, 2013/07/15 18:21:36]

Done. I dislike unneeded stores, but I suppose I dislike unneeded compares and
branches more. 

+        }
+    }
+
+    if (!(textMetric.tmPitchAndFamily & TMPF_VECTOR)) {
+        return textMetric.tmLastChar;
+    }
+
     // The 'maxp' table stores the number of glyphs at offset 4, in 2 bytes.
-    const DWORD maxpTag =
-        SkEndian_SwapBE32(SkSetFourByteTag('m', 'a', 'x', 'p'));
     uint16_t glyphs;
-    if (GetFontData(hdc, maxpTag, 4, &glyphs, sizeof(glyphs)) != GDI_ERROR) {
+    if (GDI_ERROR != GetFontData(hdc, SkOTTableMaximumProfile::TAG, 4, &glyphs, sizeof(glyphs))) {
         return SkEndian_SwapBE16(glyphs);
     }
 
     // Binary search for glyph count.
     static const MAT2 mat2 = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
     int32_t max = SK_MaxU16 + 1;
     int32_t min = 0;
     GLYPHMETRICS gm;
     while (min < max) {
         int32_t mid = min + ((max - min) / 2);
         if (GetGlyphOutlineW(hdc, mid, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0,
                              NULL, &mat2) == GDI_ERROR) {
             max = mid;
         } else {
             min = mid + 1;
         }
     }
     SkASSERT(min == max);
     return min;
 }
 
+static unsigned calculateUPEM(HDC hdc, const LOGFONT& lf) {
+    TEXTMETRIC textMetric;

[vandebo (ex-Chrome), 2013/07/15 17:32:56]

If you pull this out into a helper function you could do:

TEXTMETRIC textMetric;
if (get_text_metric(hdc, &textMetrics) && !(textMetric.tmPitchAndFamily ...

[bungeman-skia, 2013/07/15 18:21:36]

This doesn't want to be in a helper, it wants to be in the LogFontTypeface (and
it almost is). I was trying to avoid that this time around.

+    if (0 == GetTextMetrics(hdc, &textMetric)) {
+        call_ensure_accessible(lf);
+        if (0 == GetTextMetrics(hdc, &textMetric)) {
+            textMetric.tmPitchAndFamily = TMPF_TRUETYPE;
+        }
+    }
+
+    if (!(textMetric.tmPitchAndFamily & TMPF_VECTOR)) {
+        return textMetric.tmMaxCharWidth;
+    }
+
+    OUTLINETEXTMETRIC otm;
+    unsigned int otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
+    if (0 == otmRet) {
+        call_ensure_accessible(lf);
+        otmRet = GetOutlineTextMetrics(hdc, sizeof(otm), &otm);
+    }
+
+    return (0 == otmRet) ? 0 : otm.otmEMSquare;
+}
+
 class LogFontTypeface : public SkTypeface {
 public:
     LogFontTypeface(SkTypeface::Style style, SkFontID fontID, const LOGFONT& lf, bool serializeAsStream = false) :
         SkTypeface(style, fontID, false), fLogFont(lf), fSerializeAsStream(serializeAsStream) {
 
         // If the font has cubic outlines, it will not be rendered with ClearType.
         HFONT font = CreateFontIndirect(&lf);
 
         HDC deviceContext = ::CreateCompatibleDC(NULL);
         HFONT savefont = (HFONT)SelectObject(deviceContext, font);
@@ skipping 41 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;
 };
 
 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 476 matching lines @@
         ::ScriptFreeCache(&fSC);
     }
 }
 
 bool SkScalerContext_Windows::isValid() const {
     return fDDC && fFont;
 }
 
 unsigned SkScalerContext_Windows::generateGlyphCount() {
     if (fGlyphCount < 0) {
-        if (fType == SkScalerContext_Windows::kBitmap_Type) {
-           return fTM.tmLastChar;
-        }
-        fGlyphCount = calculateOutlineGlyphCount(fDDC);
+        fGlyphCount = calculateGlyphCount(
+                          fDDC, static_cast<const LogFontTypeface*>(this->getTypeface())->fLogFont);
     }
     return fGlyphCount;
 }
 
 uint16_t SkScalerContext_Windows::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.
@@ skipping 698 matching lines @@
     }
     if (!otmRet || !GetTextFace(hdc, LF_FACESIZE, lf.lfFaceName)) {
         goto Error;
     }
     lf.lfHeight = -SkToS32(otm.otmEMSquare);
     designFont = CreateFontIndirect(&lf);
     SelectObject(hdc, designFont);
     if (!GetOutlineTextMetrics(hdc, sizeof(otm), &otm)) {
         goto Error;
     }
-    glyphCount = calculateOutlineGlyphCount(hdc);
+    glyphCount = calculateGlyphCount(hdc, fLogFont);
 
     info = new SkAdvancedTypefaceMetrics;
     info->fEmSize = otm.otmEMSquare;
     info->fMultiMaster = false;
     info->fLastGlyphID = SkToU16(glyphCount - 1);
     info->fStyle = 0;
     tchar_to_skstring(lf.lfFaceName, &info->fFontName);
 
     if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) {
         populate_glyph_to_unicode(hdc, glyphCount, &(info->fGlyphToUnicode));
@@ skipping 217 matching lines @@
         }
     }
 
     SelectObject(hdc, savefont);
     DeleteObject(font);
     DeleteDC(hdc);
 
     return stream;
 }
 
+int LogFontTypeface::onCountGlyphs() const {
+    HDC hdc = ::CreateCompatibleDC(NULL);
+    HFONT font = CreateFontIndirect(&fLogFont);
+    HFONT savefont = (HFONT)SelectObject(hdc, font);
+
+    unsigned int glyphCount = calculateGlyphCount(hdc, fLogFont);
+
+    SelectObject(hdc, savefont);
+    DeleteObject(font);
+    DeleteDC(hdc);
+
+    return glyphCount;
+}
+
+int LogFontTypeface::onGetUPEM() const {
+    HDC hdc = ::CreateCompatibleDC(NULL);
+    HFONT font = CreateFontIndirect(&fLogFont);
+    HFONT savefont = (HFONT)SelectObject(hdc, font);
+
+    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,
                                                 (const_cast<LogFontTypeface*>(this), desc));
     if (!ctx->isValid()) {
         SkDELETE(ctx);
         ctx = NULL;
     }
     return ctx;
 }
 
@@ skipping 247 matching lines @@
         return this->createFromStream(stream);
     }
 
 private:
     SkTDArray<ENUMLOGFONTEX> fLogFontArray;
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgrGDI);
 }