Fix subpixel metrics with GDI.

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 532 matching lines @@
 
 private:
     DWORD getGDIGlyphPath(const SkGlyph& glyph, UINT flags,
                           SkAutoSTMalloc<BUFFERSIZE, uint8_t>* glyphbuf);
 
     HDCOffscreen fOffscreen;
     /** fGsA is the non-rotational part of total matrix without the text height scale.
      *  Used to find the magnitude of advances.
      */
     MAT2         fGsA;
+    /** The total matrix without the textSize. */
     MAT2         fMat22;
+    /** Scales font to EM size. */
+    MAT2         fHighResMat22;
     HDC          fDDC;
     HFONT        fSavefont;
     HFONT        fFont;
-    HFONT        fHiResFont;
     SCRIPT_CACHE fSC;
     int          fGlyphCount;
 
+    /** The total matrix which also removes EM scale. */
     SkMatrix     fHiResMatrix;
     /** fG_inv is the inverse of the rotational part of the total matrix.
      *  Used to set the direction of advances.
      */
     SkMatrix     fG_inv;
     enum Type {
         kTrueType_Type, kBitmap_Type,
     } fType;
     TEXTMETRIC fTM;
 };
@@ skipping 17 matching lines @@
             }
     }
 }
 
 SkScalerContext_Windows::SkScalerContext_Windows(SkTypeface* rawTypeface,
                                                  const SkDescriptor* desc)
         : SkScalerContext(rawTypeface, desc)
         , fDDC(0)
         , fSavefont(0)
         , fFont(0)
-        , fHiResFont(0)
         , fSC(0)
         , fGlyphCount(-1)
 {
     LogFontTypeface* typeface = reinterpret_cast<LogFontTypeface*>(rawTypeface);
 
     fDDC = ::CreateCompatibleDC(NULL);
     if (!fDDC) {
         return;
     }
     SetGraphicsMode(fDDC, GM_ADVANCED);
@@ skipping 119 matching lines @@
 
         // Create a hires font if we need linear metrics.
         if (this->isSubpixel()) {
             OUTLINETEXTMETRIC otm;
             UINT success = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
             if (0 == success) {
                 call_ensure_accessible(lf);
                 success = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
             }
             if (0 != success) {
-                lf.lfHeight = -SkToS32(otm.otmEMSquare);
-                fHiResFont = CreateFontIndirect(&lf);
-                if (!fHiResFont) {
-                    return;
-                }
+                SkScalar scale = SkIntToScalar(otm.otmEMSquare);
 
-                // construct a matrix to go from HIRES logical units to our device units
-                fRec.getSingleMatrix(&fHiResMatrix);
-                SkScalar scale = SkScalarInvert(SkIntToScalar(otm.otmEMSquare));
-                fHiResMatrix.preScale(scale, scale);
+                SkScalar textScale = scale / textSize;
+                fHighResMat22.eM11 = float2FIXED(textScale);
+                fHighResMat22.eM12 = float2FIXED(0);
+                fHighResMat22.eM21 = float2FIXED(0);
+                fHighResMat22.eM22 = float2FIXED(textScale);
+
+                SkScalar invScale = SkScalarInvert(scale);
+                fHiResMatrix = A;
+                fHiResMatrix.preScale(invScale, invScale);
             }
         }
 
     } else {
         // Assume bitmap
         fType = SkScalerContext_Windows::kBitmap_Type;
 
         xform.eM11 = 1.0f;
         xform.eM12 = 0.0f;
         xform.eM21 = 0.0f;
@@ skipping 13 matching lines @@
 }
 
 SkScalerContext_Windows::~SkScalerContext_Windows() {
     if (fDDC) {
         ::SelectObject(fDDC, fSavefont);
         ::DeleteDC(fDDC);
     }
     if (fFont) {
         ::DeleteObject(fFont);
     }
-    if (fHiResFont) {
-        ::DeleteObject(fHiResFont);
-    }
     if (fSC) {
         ::ScriptFreeCache(&fSC);
     }
 }
 
 bool SkScalerContext_Windows::isValid() const {
     return fDDC && fFont;
 }
 
 unsigned SkScalerContext_Windows::generateGlyphCount() {
@@ skipping 26 matching lines @@
         SkAssertResult(SUCCEEDED(ScriptShape(
             fDDC, &fSC, c, 2, 1, &si[0].a, &index, log, &vsa, &glyphs)));
     }
     return index;
 }
 
 void SkScalerContext_Windows::generateAdvance(SkGlyph* glyph) {
     this->generateMetrics(glyph);
 }
 
-static const MAT2 gMat2Identity = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
 void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {
     SkASSERT(fDDC);
 
     if (fType == SkScalerContext_Windows::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);
@@ skipping 50 matching lines @@
         glyph->fWidth = gm.gmBlackBoxX + 4;
         glyph->fHeight = gm.gmBlackBoxY + 4;
         glyph->fTop -= 2;
         glyph->fLeft -= 2;
     }
     glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX);
     glyph->fAdvanceY = SkIntToFixed(gm.gmCellIncY);
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
 
-    if (fHiResFont) {
-        SelectObject(fDDC, fHiResFont);
+    if (this->isSubpixel()) {
         sk_bzero(&gm, sizeof(gm));
-        status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &gMat2Identity);
+        status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fHighResMat22);
         if (GDI_ERROR != status) {
             SkPoint advance;
             fHiResMatrix.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
             glyph->fAdvanceX = SkScalarToFixed(advance.fX);
             glyph->fAdvanceY = SkScalarToFixed(advance.fY);
         }
-        SelectObject(fDDC, fFont);
     } else if (!isAxisAligned(this->fRec)) {
         status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, NULL, &fGsA);
         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) {
     if (!(mx || my)) {
       return;
     }
 
     if (mx) {
         sk_bzero(mx, sizeof(*mx));
     }
     if (my) {
         sk_bzero(my, sizeof(*my));
@@ skipping 1383 matching lines @@
         return this->createFromStream(stream);
     }
 
 private:
     SkTDArray<ENUMLOGFONTEX> fLogFontArray;
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgrGDI);
 }