Remove vertical/horizontal metrics selection.

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 541 matching lines @@
     // 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;
     virtual void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
     virtual void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
-    virtual void generateFontMetrics(SkPaint::FontMetrics* mX,
-                                     SkPaint::FontMetrics* mY) SK_OVERRIDE;
+    virtual void generateFontMetrics(SkPaint::FontMetrics*) SK_OVERRIDE;
 
 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;
@@ skipping 397 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_GDI::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
-    if (!(mx || my)) {
-      return;
+void SkScalerContext_GDI::generateFontMetrics(SkPaint::FontMetrics* metrics) {
+    if (NULL == metrics) {
+        return;
     }
-
-    if (mx) {
-        sk_bzero(mx, sizeof(*mx));
-    }
-    if (my) {
-        sk_bzero(my, sizeof(*my));
-    }
+    sk_bzero(metrics, sizeof(*metrics));
 
     SkASSERT(fDDC);
 
 #ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
     if (fType == SkScalerContext_GDI::kBitmap_Type || fType == SkScalerContext_GDI::kLine_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) {
-            my->fTop = SkIntToScalar(-fTM.tmAscent);
-            my->fAscent = SkIntToScalar(-fTM.tmAscent);
-            my->fDescent = SkIntToScalar(fTM.tmDescent);
-            my->fBottom = SkIntToScalar(fTM.tmDescent);
-            my->fLeading = SkIntToScalar(fTM.tmExternalLeading);
-            my->fAvgCharWidth = SkIntToScalar(fTM.tmAveCharWidth);
-            my->fMaxCharWidth = SkIntToScalar(fTM.tmMaxCharWidth);
-            my->fXMin = 0;
-            my->fXMax = my->fMaxCharWidth;
-            //my->fXHeight = 0;
-        }
+        metrics->fTop = SkIntToScalar(-fTM.tmAscent);
+        metrics->fAscent = SkIntToScalar(-fTM.tmAscent);
+        metrics->fDescent = SkIntToScalar(fTM.tmDescent);
+        metrics->fBottom = SkIntToScalar(fTM.tmDescent);
+        metrics->fLeading = SkIntToScalar(fTM.tmExternalLeading);
+        metrics->fAvgCharWidth = SkIntToScalar(fTM.tmAveCharWidth);
+        metrics->fMaxCharWidth = SkIntToScalar(fTM.tmMaxCharWidth);
+        metrics->fXMin = 0;
+        metrics->fXMax = metrics->fMaxCharWidth;
+        //metrics->fXHeight = 0;
 #ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
         return;
     }
 #endif
 
     OUTLINETEXTMETRIC otm;
 
     uint32_t ret = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
     if (0 == ret) {
         LogFontTypeface::EnsureAccessible(this->getTypeface());
         ret = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);
     }
     if (0 == ret) {
         return;
     }
 
-    if (mx) {
-        mx->fTop = SkIntToScalar(-otm.otmrcFontBox.left);
-        mx->fAscent = SkIntToScalar(-otm.otmAscent);
-        mx->fDescent = SkIntToScalar(-otm.otmDescent);
-        mx->fBottom = SkIntToScalar(otm.otmrcFontBox.right);
-        mx->fLeading = SkIntToScalar(otm.otmLineGap);
-        mx->fUnderlineThickness = SkIntToScalar(otm.otmsUnderscoreSize);
-        mx->fUnderlinePosition = -SkIntToScalar(otm.otmsUnderscorePosition);
+#ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
+    metrics->fTop = SkIntToScalar(-otm.otmrcFontBox.top);
+    metrics->fAscent = SkIntToScalar(-otm.otmAscent);
+    metrics->fDescent = SkIntToScalar(-otm.otmDescent);
+    metrics->fBottom = SkIntToScalar(-otm.otmrcFontBox.bottom);
+    metrics->fLeading = SkIntToScalar(otm.otmLineGap);
+    metrics->fAvgCharWidth = SkIntToScalar(otm.otmTextMetrics.tmAveCharWidth);
+    metrics->fMaxCharWidth = SkIntToScalar(otm.otmTextMetrics.tmMaxCharWidth);
+    metrics->fXMin = SkIntToScalar(otm.otmrcFontBox.left);
+    metrics->fXMax = SkIntToScalar(otm.otmrcFontBox.right);
+#endif
+    metrics->fUnderlineThickness = SkIntToScalar(otm.otmsUnderscoreSize);
+    metrics->fUnderlinePosition = -SkIntToScalar(otm.otmsUnderscorePosition);
 
-        mx->fFlags |= SkPaint::FontMetrics::kUnderlineThinknessIsValid_Flag;
-        mx->fFlags |= SkPaint::FontMetrics::kUnderlinePositionIsValid_Flag;
-    }
+    metrics->fFlags |= SkPaint::FontMetrics::kUnderlineThinknessIsValid_Flag;
+    metrics->fFlags |= SkPaint::FontMetrics::kUnderlinePositionIsValid_Flag;
 
-    if (my) {
-#ifndef SK_GDI_ALWAYS_USE_TEXTMETRICS_FOR_FONT_METRICS
-        my->fTop = SkIntToScalar(-otm.otmrcFontBox.top);
-        my->fAscent = SkIntToScalar(-otm.otmAscent);
-        my->fDescent = SkIntToScalar(-otm.otmDescent);
-        my->fBottom = SkIntToScalar(-otm.otmrcFontBox.bottom);
-        my->fLeading = SkIntToScalar(otm.otmLineGap);
-        my->fAvgCharWidth = SkIntToScalar(otm.otmTextMetrics.tmAveCharWidth);
-        my->fMaxCharWidth = SkIntToScalar(otm.otmTextMetrics.tmMaxCharWidth);
-        my->fXMin = SkIntToScalar(otm.otmrcFontBox.left);
-        my->fXMax = SkIntToScalar(otm.otmrcFontBox.right);
-#endif
-        my->fUnderlineThickness = SkIntToScalar(otm.otmsUnderscoreSize);
-        my->fUnderlinePosition = -SkIntToScalar(otm.otmsUnderscorePosition);
-
-        my->fFlags |= SkPaint::FontMetrics::kUnderlineThinknessIsValid_Flag;
-        my->fFlags |= SkPaint::FontMetrics::kUnderlinePositionIsValid_Flag;
-
-        my->fXHeight = SkIntToScalar(otm.otmsXHeight);
-
-        GLYPHMETRICS gm;
-        sk_bzero(&gm, sizeof(gm));
-        DWORD len = GetGlyphOutlineW(fDDC, 'x', GGO_METRICS, &gm, 0, 0, &gMat2Identity);
-        if (len != GDI_ERROR && gm.gmBlackBoxY > 0) {
-            my->fXHeight = SkIntToScalar(gm.gmBlackBoxY);
-        }
+    metrics->fXHeight = SkIntToScalar(otm.otmsXHeight);
+    GLYPHMETRICS gm;
+    sk_bzero(&gm, sizeof(gm));
+    DWORD len = GetGlyphOutlineW(fDDC, 'x', GGO_METRICS, &gm, 0, 0, &gMat2Identity);
+    if (len != GDI_ERROR && gm.gmBlackBoxY > 0) {
+        metrics->fXHeight = SkIntToScalar(gm.gmBlackBoxY);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 
 #define SK_SHOW_TEXT_BLIT_COVERAGE 0
 
 static void build_power_table(uint8_t table[], float ee) {
     for (int i = 0; i < 256; i++) {
         float x = i / 255.f;
@@ skipping 1319 matching lines @@
 }
 
 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 |
+    unsigned flagsWeDontSupport = SkScalerContext::kVertical_Flag |
+                                  SkScalerContext::kDevKernText_Flag |
                                   SkScalerContext::kForceAutohinting_Flag |
                                   SkScalerContext::kEmbeddedBitmapText_Flag |
                                   SkScalerContext::kEmbolden_Flag |
                                   SkScalerContext::kLCD_BGROrder_Flag |
                                   SkScalerContext::kLCD_Vertical_Flag;
     rec->fFlags &= ~flagsWeDontSupport;
 
     SkPaint::Hinting h = rec->getHinting();
     switch (h) {
         case SkPaint::kNo_Hinting:
@@ skipping 196 matching lines @@
 
 private:
     SkTDArray<ENUMLOGFONTEX> fLogFontArray;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr_New_GDI() {
     return SkNEW(SkFontMgrGDI);
 }