Code drop from //branches/cupcake/...@124589

1 files changed, 391 insertions, 244 deletions

diff --git a/libsgl/ports/SkFontHost_win.cpp b/libsgl/ports/SkFontHost_win.cpp
index d8c2b12..c2ee51e 100644
--- a/libsgl/ports/SkFontHost_win.cpp
+++ b/libsgl/ports/SkFontHost_win.cpp
@@ -1,8 +1,18 @@
-/* libs/graphics/ports/SkFontHost_win.cpp

-**

-** Copyright 2006, The Android Open Source Project
-**

-*/

+/*

+ ** Copyright 2006, The Android Open Source Project

+ **

+ ** Licensed under the Apache License, Version 2.0 (the "License"); 

+ ** you may not use this file except in compliance with the License. 

+ ** You may obtain a copy of the License at 

+ **

+ **     http://www.apache.org/licenses/LICENSE-2.0 

+ **

+ ** Unless required by applicable law or agreed to in writing, software 

+ ** distributed under the License is distributed on an "AS IS" BASIS, 

+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

+ ** See the License for the specific language governing permissions and 

+ ** limitations under the License.

+ */

 

 #include "SkString.h"

 //#include "SkStream.h"

@@ -15,151 +25,273 @@
 #include "windows.h"

 #include "tchar.h"

 

-static SkMutex      gFTMutex;

+// client3d has to undefine this for now

+#define CAN_USE_LOGFONT_NAME

 

-static LOGFONT gDefaultFont;

+static SkMutex gFTMutex;

+

+// these globals are loaded (once) by get_default_font()

+static LOGFONT gDefaultFont = {0};

 

 static const uint16_t BUFFERSIZE = (16384 - 32);

 static uint8_t glyphbuf[BUFFERSIZE]; 

 

-#ifndef SK_FONTKEY

-    #define SK_FONTKEY "Windows Font Key"

-#endif

+// Give 1MB font cache budget

+#define FONT_CACHE_MEMORY_BUDGET    (1024 * 1024)

 

-inline FIXED SkFixedToFIXED(SkFixed x) {

+static inline FIXED SkFixedToFIXED(SkFixed x) {

     return *(FIXED*)(&x);

 }

 

-class FontFaceRec_Typeface : public SkTypeface {

-public:

-#if 0

-    FontFaceRec_Typeface(const LOGFONT& face) : fFace(face)

-    {

-        int style = 0;

-        if (face.lfWeight == FW_SEMIBOLD || face.lfWeight == FW_DEMIBOLD || face.lfWeight == FW_BOLD)

-            style |= SkTypeface::kBold;

-        if (face.lfItalic)

-            style |= SkTypeface::kItalic;

-        this->setStyle((SkTypeface::Style)style); 

+static inline FIXED SkScalarToFIXED(SkScalar x) {

+    return SkFixedToFIXED(SkScalarToFixed(x));

+}

+

+// This will generate a unique ID based on the fontname + fontstyle

+// and also used by upper layer

+uint32_t FontFaceChecksum(const TCHAR *q, SkTypeface::Style style)

+{

+    if (!q) return style;

+    

+    // From "Performance in Practice of String Hashing Functions"

+    // Ramakrishna & Zobel

+    const uint32_t L = 5;

+    const uint32_t R = 2;

+    

+    uint32_t h = 0x12345678;

+    while (*q) {

+        //uint32_t ql = tolower(*q);

+        h ^= ((h << L) + (h >> R) + *q);

+        q ++;

     }

-#endif

-    ~FontFaceRec_Typeface() {};

+    

+    // add style

+    h = _rotl(h, 3) ^ style;

+    

+    return h;

+}

 

-    TCHAR* GetFontName() { return fFace.lfFaceName; }

+static SkTypeface::Style GetFontStyle(const LOGFONT& lf) {         

+    int style = SkTypeface::kNormal;

+    if (lf.lfWeight == FW_SEMIBOLD || lf.lfWeight == FW_DEMIBOLD || lf.lfWeight == FW_BOLD)

+        style |= SkTypeface::kBold;

+    if (lf.lfItalic)

+        style |= SkTypeface::kItalic;

+    

+    return (SkTypeface::Style)style;

+}

+

+struct SkFaceRec {

+    SkFaceRec*      fNext;

+    uint32_t        fRefCnt;

+    uint32_t        fFontID;    // checksum of fFace

+    LOGFONT         fFace;

+    

+    SkFaceRec() : fFontID(-1), fRefCnt(0) { 

+        memset(&fFace, 0, sizeof(LOGFONT));

+    }

+    ~SkFaceRec() {}

+    

+    uint32_t ref() {

+        return ++fRefCnt;

+    }

+};

+

+// Font Face list

+static SkFaceRec*   gFaceRecHead = NULL;

 

-    SkTypeface::Style GetFontStyle() {         

-        int style = SkTypeface::kNormal;

-        if (fFace.lfWeight == FW_SEMIBOLD || fFace.lfWeight == FW_DEMIBOLD || fFace.lfWeight == FW_BOLD)

-            style |= SkTypeface::kBold;

-        if (fFace.lfItalic)

-            style |= SkTypeface::kItalic;

+static SkFaceRec* find_ft_face(uint32_t fontID) {

+    SkFaceRec* rec = gFaceRecHead;

+    while (rec) {

+        if (rec->fFontID == fontID) {

+            return rec;

+        }

+        rec = rec->fNext;

+    }

+    

+    return NULL;

+}

 

-        return (SkTypeface::Style)style;

+static SkFaceRec* insert_ft_face(const LOGFONT& lf) {

+    // need a const char*

+    uint32_t id = FontFaceChecksum(&(lf.lfFaceName[0]), GetFontStyle(lf));

+    SkFaceRec* rec = find_ft_face(id);

+    if (rec) {

+        return rec;  // found?

     }

+    

+    rec = SkNEW(SkFaceRec);

+    rec->fFontID = id;

+    memcpy(&(rec->fFace), &lf, sizeof(LOGFONT));

+    rec->fNext = gFaceRecHead;

+    gFaceRecHead = rec;

+    

+    return rec;

+}

 

-    long GetFontSize() { return fFace.lfHeight; }

+static void unref_ft_face(uint32_t fontID) {

+    

+    SkFaceRec* rec = gFaceRecHead;

+    SkFaceRec* prev = NULL;

+    while (rec) {

+        SkFaceRec* next = rec->fNext;

+        if (rec->fFontID == fontID) {

+            if (--rec->fRefCnt == 0) {

+                if (prev)

+                    prev->fNext = next;

+                else

+                    gFaceRecHead = next;

+                

+                SkDELETE(rec);

+            }

+            return;

+        }

+        prev = rec;

+        rec = next;

+    }

+    SkASSERT("shouldn't get here, face not in list");

+}

 

-    LOGFONT fFace;

+// have to do this because SkTypeface::SkTypeface() is protected

+class FontFaceRec_Typeface : public SkTypeface {

+public:

+    

+    FontFaceRec_Typeface(Style style, uint32_t id) : SkTypeface(style, id) {};

+    

+    virtual ~FontFaceRec_Typeface() {};

 };

 

-

-static const LOGFONT* get_default_font()

-{

+static const LOGFONT* get_default_font() {

     // don't hardcode on Windows, Win2000, XP, Vista, and international all have different default

     // and the user could change too

-

+    

+    if (gDefaultFont.lfFaceName[0] != 0) {

+        return &gDefaultFont;

+    }

+    

     NONCLIENTMETRICS ncm;

     ncm.cbSize = sizeof(NONCLIENTMETRICS);

     SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);

-

+    

     memcpy(&gDefaultFont, &(ncm.lfMessageFont), sizeof(LOGFONT));

-

+    

     return &gDefaultFont;

 }

 

-static uint32_t FontFaceChecksum(const LOGFONT& face)

-{

-    uint32_t cs = 0;

-    uint32_t bytesize = sizeof(LOGFONT);

-    bytesize >>= 2;

-    uint32_t *p32 = (uint32_t*)&face;

-

-    while (bytesize) {

-        bytesize --;

-        cs ^= *p32;

-        p32 ++;

+static SkTypeface* CreateTypeface_(const LOGFONT& lf) {

+    

+    SkTypeface::Style style = GetFontStyle(lf);

+    FontFaceRec_Typeface* ptypeface = new FontFaceRec_Typeface(style, FontFaceChecksum(lf.lfFaceName, style));

+    

+    if (NULL == ptypeface) {

+        SkASSERT(false);

+        return NULL;

     }

-

-    return cs;

+    

+    SkFaceRec* rec = insert_ft_face(lf);

+    SkASSERT(rec);

+    

+    return ptypeface;

 }

 

 class SkScalerContext_Windows : public SkScalerContext {

 public:

     SkScalerContext_Windows(const SkDescriptor* desc);

     virtual ~SkScalerContext_Windows();

-

+    

 protected:

     virtual unsigned generateGlyphCount() const;

     virtual uint16_t generateCharToGlyph(SkUnichar uni);

+    virtual void generateAdvance(SkGlyph* glyph);

     virtual void generateMetrics(SkGlyph* glyph);

     virtual void generateImage(const SkGlyph& glyph);

     virtual void generatePath(const SkGlyph& glyph, SkPath* path);

     virtual void generateLineHeight(SkPoint* ascent, SkPoint* descent);

-

+    virtual void generateFontMetrics(SkPaint::FontMetrics* mX, SkPaint::FontMetrics* mY);

+    //virtual SkDeviceContext getDC() {return ddc;}

 private:

-    LOGFONT*    plf;              

+    uint32_t    fFontID;

+    LOGFONT     lf;              

     MAT2        mat22;

+    HDC         ddc;

+    HFONT       savefont;

+    HFONT       font;

 };

 

-SkScalerContext_Windows::SkScalerContext_Windows(const SkDescriptor* desc)

-    : SkScalerContext(desc), plf(NULL)

-{

+SkScalerContext_Windows::SkScalerContext_Windows(const SkDescriptor* desc) : SkScalerContext(desc), ddc(0), font(0), savefont(0) {

     SkAutoMutexAcquire  ac(gFTMutex);

-

-    const LOGFONT** face = (const LOGFONT**)desc->findEntry(kTypeface_SkDescriptorTag, NULL);

-    plf = (LOGFONT*)*face;

-    SkASSERT(plf);

-  

-    mat22.eM11 = SkFixedToFIXED(fRec.fPost2x2[0][0]);    

-    mat22.eM12 = SkFixedToFIXED(-fRec.fPost2x2[0][1]);

-    mat22.eM21 = SkFixedToFIXED(fRec.fPost2x2[1][0]);

-    mat22.eM22 = SkFixedToFIXED(-fRec.fPost2x2[1][1]);

+    

+    fFontID = fRec.fFontID;

+    SkFaceRec* rec = find_ft_face(fRec.fFontID);

+    if (rec) {

+        rec->ref();

+        memcpy(&lf, &(rec->fFace), sizeof(LOGFONT));

+    }

+    else {

+        SkASSERT(false);

+        memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));

+    }

+    

+    mat22.eM11 = SkScalarToFIXED(fRec.fPost2x2[0][0]);    

+    mat22.eM12 = SkScalarToFIXED(-fRec.fPost2x2[0][1]);

+    mat22.eM21 = SkScalarToFIXED(fRec.fPost2x2[1][0]);

+    mat22.eM22 = SkScalarToFIXED(-fRec.fPost2x2[1][1]);

+    

+    ddc = ::CreateCompatibleDC(NULL);

+    SetBkMode(ddc, TRANSPARENT);

+    

+    lf.lfHeight = SkScalarFloor(fRec.fTextSize);

+    font = CreateFontIndirect(&lf);

+    savefont = (HFONT)SelectObject(ddc, font);

 }

 

 SkScalerContext_Windows::~SkScalerContext_Windows() {

+    unref_ft_face(fFontID);

+    

+    if (ddc) {

+        ::SelectObject(ddc, savefont);

+        ::DeleteDC(ddc);

+        ddc = NULL;

+    }

+    if (font) {

+        ::DeleteObject(font);

+    }

 }

 

 unsigned SkScalerContext_Windows::generateGlyphCount() const {

     return 0xFFFF;

-//    return fFace->num_glyphs;

+    //    return fFace->num_glyphs;

 }

 

 uint16_t SkScalerContext_Windows::generateCharToGlyph(SkUnichar uni) {

-

+    

+    //uint16_t index = 0;

+    //GetGlyphIndicesW(ddc, &(uint16_t&)uni, 1, &index, 0);

+    //return index;

+    

     // let's just use the uni as index on Windows

     return SkToU16(uni);

 }

 

-void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {

-

-    HDC ddc = ::CreateCompatibleDC(NULL);

-    SetBkMode(ddc, TRANSPARENT);

-

-    SkASSERT(plf);

-    plf->lfHeight = -SkFixedFloor(fRec.fTextSize);

+void SkScalerContext_Windows::generateAdvance(SkGlyph* glyph) {

+    this->generateMetrics(glyph);

+}

 

-    HFONT font = CreateFontIndirect(plf);

-    HFONT oldfont = (HFONT)SelectObject(ddc, font);

+void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {

+    

+    SkASSERT(ddc);

     

     GLYPHMETRICS gm;

     memset(&gm, 0, sizeof(gm));

-

+    

     glyph->fRsbDelta = 0;

     glyph->fLsbDelta = 0;

-

+    

+    UINT glyphIndexFlag = 0; //glyph->fIsCodePoint ? 0 : GGO_GLYPH_INDEX;

+    //    UINT glyphIndexFlag = GGO_GLYPH_INDEX;

     // Note: need to use GGO_GRAY8_BITMAP instead of GGO_METRICS because GGO_METRICS returns a smaller

     // BlackBlox; we need the bigger one in case we need the image.  fAdvance is the same.

-    uint32_t ret = GetGlyphOutlineW(ddc, glyph->f_GlyphID, GGO_GRAY8_BITMAP, &gm, 0, NULL, &mat22);

+    uint32_t ret = GetGlyphOutlineW(ddc, glyph->getGlyphID(0), GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, 0, NULL, &mat22);

     

     if (GDI_ERROR != ret) {

         if (ret == 0) {

@@ -168,48 +300,68 @@ void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {
         }

         glyph->fWidth   = gm.gmBlackBoxX;

         glyph->fHeight  = gm.gmBlackBoxY;

-        glyph->fTop     = gm.gmptGlyphOrigin.y - gm.gmBlackBoxY;

-        glyph->fLeft    = gm.gmptGlyphOrigin.x;

+        glyph->fTop     = SkToS16(gm.gmptGlyphOrigin.y - gm.gmBlackBoxY);

+        glyph->fLeft    = SkToS16(gm.gmptGlyphOrigin.x);

         glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX);

         glyph->fAdvanceY = -SkIntToFixed(gm.gmCellIncY);

+    } else {

+        glyph->fWidth = 0;

     }

+    

+#if 0

+    char buf[1024];

+    sprintf(buf, "generateMetrics: id:%d, w=%d, h=%d, font:%s, fh:%d\n", glyph->fID, glyph->fWidth, glyph->fHeight, lf.lfFaceName, lf.lfHeight);

+    OutputDebugString(buf);

+#endif

+}

 

-    ::SelectObject(ddc, oldfont);

-    ::DeleteObject(font);

-    ::DeleteDC(ddc);

+void SkScalerContext_Windows::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {

+    //SkASSERT(false);

+    if (mx)

+        memset(mx, 0, sizeof(SkPaint::FontMetrics));

+    if (my)

+        memset(my, 0, sizeof(SkPaint::FontMetrics));

+    return;

 }

 

 void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {

-

+    

     SkAutoMutexAcquire  ac(gFTMutex);

-

-    SkASSERT(plf);

-

-    HDC ddc = ::CreateCompatibleDC(NULL);

-    SetBkMode(ddc, TRANSPARENT);

-

-    plf->lfHeight = -SkFixedFloor(fRec.fTextSize);

-

-    HFONT font = CreateFontIndirect(plf);

-    HFONT oldfont = (HFONT)SelectObject(ddc, font);

-

+    

+    SkASSERT(ddc);

+    

     GLYPHMETRICS gm;

     memset(&gm, 0, sizeof(gm));

-

-    uint32_t total_size = GetGlyphOutlineW(ddc, glyph.f_GlyphID, GGO_GRAY8_BITMAP, &gm, 0, NULL, &mat22);

+    

+#if 0

+    char buf[1024];

+    sprintf(buf, "generateImage: id:%d, w=%d, h=%d, font:%s,fh:%d\n", glyph.fID, glyph.fWidth, glyph.fHeight, lf.lfFaceName, lf.lfHeight);

+    OutputDebugString(buf);

+#endif

+    

+    uint32_t bytecount = 0;

+    UINT glyphIndexFlag = 0; //glyph.fIsCodePoint ? 0 : GGO_GLYPH_INDEX;

+    //    UINT glyphIndexFlag = GGO_GLYPH_INDEX;

+    uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, 0, NULL, &mat22);

     if (GDI_ERROR != total_size && total_size > 0) {

         uint8_t *pBuff = new uint8_t[total_size];

         if (NULL != pBuff) {

-            total_size = GetGlyphOutlineW(ddc, glyph.f_GlyphID, GGO_GRAY8_BITMAP, &gm, total_size, pBuff, &mat22);

-    

+            total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, total_size, pBuff, &mat22);

+            

             SkASSERT(total_size != GDI_ERROR);

-

+            

+            SkASSERT(glyph.fWidth == gm.gmBlackBoxX);

+            SkASSERT(glyph.fHeight == gm.gmBlackBoxY);

+            

             uint8_t* dst = (uint8_t*)glyph.fImage;

             uint32_t pitch = (gm.gmBlackBoxX + 3) & ~0x3;

-

+            if (pitch != glyph.rowBytes()) {

+                SkASSERT(false); // glyph.fImage has different rowsize!?

+            }

+            

             for (int32_t y = gm.gmBlackBoxY - 1; y >= 0; y--) {

                 uint8_t* src = pBuff + pitch * y;

-

+                

                 for (uint32_t x = 0; x < gm.gmBlackBoxX; x++) {

                     if (*src > 63) {

                         *dst = 0xFF;

@@ -219,233 +371,228 @@ void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
                     }

                     dst++;

                     src++;

+                    bytecount++;

                 }

+                memset(dst, 0, glyph.rowBytes() - glyph.fWidth);

+                dst += glyph.rowBytes() - glyph.fWidth;

             }

-

+            

             delete[] pBuff;

         }

     }

-            

+    

     SkASSERT(GDI_ERROR != total_size && total_size >= 0);

-

-    ::SelectObject(ddc, oldfont);

-    ::DeleteObject(font);

-    ::DeleteDC(ddc);

+    

 }

 

 void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {

-

+    

     SkAutoMutexAcquire  ac(gFTMutex);

-

+    

     SkASSERT(&glyph && path);

-

-    SkASSERT(plf);

-

+    SkASSERT(ddc);

+    

     path->reset();

-

-    HDC ddc = ::CreateCompatibleDC(NULL);

-    SetBkMode(ddc, TRANSPARENT);

-

-    plf->lfHeight = -SkFixedFloor(fRec.fTextSize);

-

-    HFONT font = CreateFontIndirect(plf);

-    HFONT oldfont = (HFONT)SelectObject(ddc, font);

-

+    

+#if 0

+    char buf[1024];

+    sprintf(buf, "generatePath: id:%d, w=%d, h=%d, font:%s,fh:%d\n", glyph.fID, glyph.fWidth, glyph.fHeight, lf.lfFaceName, lf.lfHeight);

+    OutputDebugString(buf);

+#endif

+    

     GLYPHMETRICS gm;

-

-    uint32_t total_size = GetGlyphOutlineW(ddc, glyph.f_GlyphID, GGO_NATIVE, &gm, BUFFERSIZE, glyphbuf, &mat22);

-

-    if (GDI_ERROR != total_size) {

+    UINT glyphIndexFlag = 0; //glyph.fIsCodePoint ? 0 : GGO_GLYPH_INDEX;

+    uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_NATIVE | glyphIndexFlag, &gm, BUFFERSIZE, glyphbuf, &mat22);

     

+    if (GDI_ERROR != total_size) {

+        

         const uint8_t* cur_glyph = glyphbuf;

         const uint8_t* end_glyph = glyphbuf + total_size;

-    

+        

         while(cur_glyph < end_glyph) {

             const TTPOLYGONHEADER* th = (TTPOLYGONHEADER*)cur_glyph;

-        

+            

             const uint8_t* end_poly = cur_glyph + th->cb;

             const uint8_t* cur_poly = cur_glyph + sizeof(TTPOLYGONHEADER);

-        

-            path->moveTo(*(SkFixed*)(&th->pfxStart.x), *(SkFixed*)(&th->pfxStart.y));

-        

+            

+            path->moveTo(SkFixedToScalar(*(SkFixed*)(&th->pfxStart.x)), SkFixedToScalar(*(SkFixed*)(&th->pfxStart.y)));

+            

             while(cur_poly < end_poly) {

                 const TTPOLYCURVE* pc = (const TTPOLYCURVE*)cur_poly;

-            

+                

                 if (pc->wType == TT_PRIM_LINE) {

                     for (uint16_t i = 0; i < pc->cpfx; i++) {

-                        path->lineTo(*(SkFixed*)(&pc->apfx[i].x), *(SkFixed*)(&pc->apfx[i].y));

+                        path->lineTo(SkFixedToScalar(*(SkFixed*)(&pc->apfx[i].x)), SkFixedToScalar(*(SkFixed*)(&pc->apfx[i].y)));

                     }

                 }

-            

+                

                 if (pc->wType == TT_PRIM_QSPLINE) {

                     for (uint16_t u = 0; u < pc->cpfx - 1; u++) { // Walk through points in spline

                         POINTFX pnt_b = pc->apfx[u];    // B is always the current point

                         POINTFX pnt_c = pc->apfx[u+1];

-                    

+                        

                         if (u < pc->cpfx - 2) {          // If not on last spline, compute C                            

                             pnt_c.x = SkFixedToFIXED(SkFixedAve(*(SkFixed*)(&pnt_b.x), *(SkFixed*)(&pnt_c.x)));

                             pnt_c.y = SkFixedToFIXED(SkFixedAve(*(SkFixed*)(&pnt_b.y), *(SkFixed*)(&pnt_c.y)));

                         }

-

-                        path->quadTo(*(SkFixed*)(&pnt_b.x), *(SkFixed*)(&pnt_b.y), *(SkFixed*)(&pnt_c.x), *(SkFixed*)(&pnt_c.y));

+                        

+                        path->quadTo(SkFixedToScalar(*(SkFixed*)(&pnt_b.x)), SkFixedToScalar(*(SkFixed*)(&pnt_b.y)), SkFixedToScalar(*(SkFixed*)(&pnt_c.x)), SkFixedToScalar(*(SkFixed*)(&pnt_c.y)));

                     }

                 }

                 cur_poly += sizeof(uint16_t) * 2 + sizeof(POINTFX) * pc->cpfx;

             }

             cur_glyph += th->cb;

+            path->close();

         }

     }

     else {

         SkASSERT(false);

     }

-

-    path->close();

-

-    ::SelectObject(ddc, oldfont);

-    ::DeleteObject(font);

-    ::DeleteDC(ddc);

+    //char buf[1024];

+    //sprintf(buf, "generatePath: count:%d\n", count);

+    //OutputDebugString(buf);

 }

 

 

 // Note:  not sure this is the correct implementation

 void SkScalerContext_Windows::generateLineHeight(SkPoint* ascent, SkPoint* descent) {

-

-    HDC ddc = ::CreateCompatibleDC(NULL);

-    SetBkMode(ddc, TRANSPARENT);

-

-    SkASSERT(plf);

-    plf->lfHeight = -SkFixedFloor(fRec.fTextSize);

-

-    HFONT font = CreateFontIndirect(plf);

-    HFONT oldfont = (HFONT)SelectObject(ddc, font);

-

+    

+    SkASSERT(ddc);

+    

     OUTLINETEXTMETRIC otm;

-

+    

     uint32_t ret = GetOutlineTextMetrics(ddc, sizeof(otm), &otm);

-

+    

     if (sizeof(otm) == ret) {

         if (ascent)

             ascent->iset(0, otm.otmAscent);

         if (descent)

             descent->iset(0, otm.otmDescent);

     }

-

-    ::SelectObject(ddc, oldfont);

-    ::DeleteObject(font);

-    ::DeleteDC(ddc);

-

+    

     return;

 }

 

-SkTypeface* SkFontHost::CreateTypeface( const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style) {

-

-    FontFaceRec_Typeface* ptypeface = new FontFaceRec_Typeface;

-

-    if (NULL == ptypeface) {

-        SkASSERT(false);

-        return NULL;

-    }

-

-    memset(&ptypeface->fFace, 0, sizeof(LOGFONT));

-

-    // default

-    ptypeface->fFace.lfHeight = -11; // default

-    ptypeface->fFace.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ; 

-    ptypeface->fFace.lfItalic = ((style & SkTypeface::kItalic) != 0);

-    ptypeface->fFace.lfQuality = PROOF_QUALITY;

-

-    _tcscpy(ptypeface->fFace.lfFaceName, familyName);

-

+void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {

+    SkASSERT(!"SkFontHost::Serialize unimplemented");

+}

 

-    return ptypeface;

+SkTypeface* SkFontHost::Deserialize(SkStream* stream) {

+    SkASSERT(!"SkFontHost::Deserialize unimplemented");

+    return NULL;

 }

 

-uint32_t SkFontHost::FlattenTypeface(const SkTypeface* tface, void* buffer) {

-    const LOGFONT* face;

+SkTypeface* SkFontHost::CreateTypeface(SkStream* stream) {

     

-    if (tface)

-        face = &((const FontFaceRec_Typeface*)tface)->fFace;

-    else

-       face = get_default_font();

-

-    size_t size = sizeof(face);

-

-    size += sizeof(uint32_t);

-

-    if (buffer) {

-        uint8_t* buf = (uint8_t*)buffer;

-        memcpy(buf, &face, sizeof(face));

-        uint32_t cs = FontFaceChecksum(*face);

-

-        memcpy(buf+sizeof(face), &cs, sizeof(cs));

-    }

-

-    return size;

+    //Should not be used on Windows, keep linker happy

+    SkASSERT(false);

+    get_default_font();

+    return CreateTypeface_(gDefaultFont);

 }

 

 SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc) {

     return SkNEW_ARGS(SkScalerContext_Windows, (desc));

 }

 

-void SkFontHost::GetDescriptorKeyString(const SkDescriptor* desc, SkString* keyString) {

-    const LOGFONT** face = (const LOGFONT**)desc->findEntry(kTypeface_SkDescriptorTag, NULL);

-    LOGFONT*lf = (LOGFONT*)*face;

-    keyString->set(SK_FONTKEY);

-    if (lf) {

-        keyString->append(lf->lfFaceName);

-    }

-}

-

 SkScalerContext* SkFontHost::CreateFallbackScalerContext(const SkScalerContext::Rec& rec) {

-    const LOGFONT* face = get_default_font();

-

-    SkAutoDescriptor    ad(sizeof(rec) + sizeof(face) + SkDescriptor::ComputeOverhead(2));

+    get_default_font();

+    

+    SkAutoDescriptor    ad(sizeof(rec) + sizeof(gDefaultFont) + SkDescriptor::ComputeOverhead(2));

     SkDescriptor*       desc = ad.getDesc();

-

+    

     desc->init();

-    desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);

-    desc->addEntry(kTypeface_SkDescriptorTag, sizeof(face), &face);

+    SkScalerContext::Rec* newRec =

+    (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);

+    

+    get_default_font();

+    CreateTypeface_(gDefaultFont);

+    newRec->fFontID = FontFaceChecksum(gDefaultFont.lfFaceName, GetFontStyle(gDefaultFont));

     desc->computeChecksum();

-

+    

     return SkFontHost::CreateScalerContext(desc);

 }

 

-SkStream* SkFontHost::OpenDescriptorStream(const SkDescriptor* desc, const char keyString[]) {

-    SkASSERT(!"SkFontHost::OpenDescriptorStream unimplemented");

-    return NULL;

-}

+/** 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 famillyName.

+ 2) If famillyName is null, use familyFace.

+ 3) If both are null, return the default font that best matches style

+ This MUST not return NULL.

+ */

 

-uint32_t SkFontHost::TypefaceHash(const SkTypeface* face) {

+SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style) {

     

-//    FontFaceRec_Typeface *ptypeface = dynamic_cast<FontFaceRec_Typeface*>(face); 

-    FontFaceRec_Typeface *ptypeface = (FontFaceRec_Typeface*)(face); 

-    SkASSERT(ptypeface);

+    SkAutoMutexAcquire  ac(gFTMutex);

 

-    return FontFaceChecksum(ptypeface->fFace);

-}

+#ifndef CAN_USE_LOGFONT_NAME

+    familyName = NULL;

+    familyFace = NULL;

+#endif

 

-bool SkFontHost::TypefaceEqual(const SkTypeface* facea, const SkTypeface* faceb) {

+    // clip to legal style bits

+    style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);

     

-    FontFaceRec_Typeface *ptypefaceA = (FontFaceRec_Typeface*)facea; 

-    SkASSERT(ptypefaceA);

-

-    FontFaceRec_Typeface *ptypefaceB = (FontFaceRec_Typeface*)faceb; 

-    SkASSERT(ptypefaceB);

+    SkTypeface* tf = NULL;

+    if (NULL == familyFace && NULL == familyName) {

+        LOGFONT lf;

+        get_default_font();

+        memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));

+        lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ; 

+        lf.lfItalic = ((style & SkTypeface::kItalic) != 0);

+        tf = CreateTypeface_(lf);

+    } else {

+#ifdef CAN_USE_LOGFONT_NAME

+        LOGFONT lf;

+        if (NULL != familyFace) {

+            uint32_t id = familyFace->uniqueID();

+            SkFaceRec* rec = find_ft_face(id);

+            if (!rec) {

+                SkASSERT(false);

+                get_default_font();

+                memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));

+            }

+            else {

+                memcpy(&lf, &(rec->fFace), sizeof(LOGFONT));

+            }

+        }

+        else {

+            memset(&lf, 0, sizeof(LOGFONT));

+            

+            lf.lfHeight = -11; // default

+            lf.lfQuality = PROOF_QUALITY;

+            lf.lfCharSet = DEFAULT_CHARSET;

+            

+            _tcsncpy(lf.lfFaceName, familyName, LF_FACESIZE);

+            lf.lfFaceName[LF_FACESIZE-1] = '\0';

+        }

+        

+        // use the style desired

+        lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ; 

+        lf.lfItalic = ((style & SkTypeface::kItalic) != 0);

+        tf = CreateTypeface_(lf);

+#endif

+    }

 

-    if (_tcscmp(ptypefaceA->GetFontName(), ptypefaceB->GetFontName())) return false;

-    if (ptypefaceA->GetFontStyle() != ptypefaceB->GetFontStyle()) return false;

-    if (ptypefaceA->GetFontSize() != ptypefaceB->GetFontSize()) return false;

+    if (NULL == tf) {

+        get_default_font();

+        tf = CreateTypeface_(gDefaultFont);

+    }

+    return tf;

+}

 

-    return true;

+size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) {

+    if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)

+        return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;

+    else

+        return 0;   // nothing to do

 }

 

-int SkFontHost::ComputeGammaFlag(const SkPaint& paint)

-{

+int SkFontHost::ComputeGammaFlag(const SkPaint& paint) {

     return 0;

 }

 

-void SkFontHost::GetGammaTables(const uint8_t* tables[2])

-{

+void SkFontHost::GetGammaTables(const uint8_t* tables[2]) {

     tables[0] = NULL;   // black gamma (e.g. exp=1.4)

     tables[1] = NULL;   // white gamma (e.g. exp= 1/1.4)

 }