[apple/icu.git] / icuSources / samples / layout / GDIFontInstance.cpp

/*
 *******************************************************************************
 *
 *   © 2016 and later: Unicode, Inc. and others.
 *   License & terms of use: http://www.unicode.org/copyright.html#License
 *
 *******************************************************************************
 *******************************************************************************
 *
 *   Copyright (C) 1999-2008, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  GDIFontInstance.cpp
 *
 *   created on: 08/09/2000
 *   created by: Eric R. Mader
 */

#include <windows.h>

#include "layout/LETypes.h"
#include "layout/LESwaps.h"
#include "layout/LEFontInstance.h"

#include "GDIFontInstance.h"
#include "sfnt.h"
#include "cmaps.h"

GDISurface::GDISurface(HDC theHDC)
    : fHdc(theHDC), fCurrentFont(NULL)
{
    // nothing else to do
}

GDISurface::~GDISurface()
{
    // nothing to do
}

void GDISurface::setHDC(HDC theHDC)
{
    fHdc         = theHDC;
    fCurrentFont = NULL;
}

void GDISurface::setFont(const GDIFontInstance *font)
{
#if 0
    if (fCurrentFont != font) {
        fCurrentFont = font;
        SelectObject(fHdc, font->getFont());
    }
#else
    SelectObject(fHdc, font->getFont());
#endif
}

void GDISurface::drawGlyphs(const LEFontInstance *font, const LEGlyphID *glyphs, le_int32 count, const float *positions,
    le_int32 x, le_int32 y, le_int32 width, le_int32 height)
{
    TTGlyphID *ttGlyphs = LE_NEW_ARRAY(TTGlyphID, count);
    le_int32  *dx = LE_NEW_ARRAY(le_int32, count);
    float     *ps = LE_NEW_ARRAY(float, count * 2 + 2);
    le_int32   out = 0;
    RECT clip;

    clip.top    = 0;
    clip.left   = 0;
    clip.bottom = height;
    clip.right  = width;

    for (le_int32 g = 0; g < count; g += 1) {
        TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyphs[g]);

        if (ttGlyph < 0xFFFE) {
            ttGlyphs[out] = ttGlyph;
            dx[out] = (le_int32) (positions[g * 2 + 2] - positions[g * 2]);
            ps[out * 2] = positions[g * 2];
            ps[out * 2 + 1] = positions[g * 2 + 1];
            out += 1;
        }
    }

    le_int32 dyStart, dyEnd;

    setFont((GDIFontInstance *) font);

    dyStart = dyEnd = 0;

    while (dyEnd < out) {
        float yOffset = ps[dyStart * 2 + 1];
        float xOffset = ps[dyStart * 2];

        while (dyEnd < out && yOffset == ps[dyEnd * 2 + 1]) {
            dyEnd += 1;
        }

        ExtTextOut(fHdc, x + (le_int32) xOffset, y + (le_int32) yOffset - font->getAscent(), ETO_CLIPPED | ETO_GLYPH_INDEX, &clip,
            (LPCWSTR) &ttGlyphs[dyStart], dyEnd - dyStart, (INT *) &dx[dyStart]);

        dyStart = dyEnd;
    }

    LE_DELETE_ARRAY(ps);
    LE_DELETE_ARRAY(dx);
    LE_DELETE_ARRAY(ttGlyphs);
}

GDIFontInstance::GDIFontInstance(GDISurface *surface, TCHAR *faceName, le_int16 pointSize, LEErrorCode &status)
    : FontTableCache(), fSurface(surface), fFont(NULL),
      fPointSize(pointSize), fUnitsPerEM(0), fAscent(0), fDescent(0), fLeading(0),
      fDeviceScaleX(1), fDeviceScaleY(1), fMapper(NULL)
{
    LOGFONT lf;
    FLOAT dpiX, dpiY;
    POINT pt;
    OUTLINETEXTMETRIC otm;
    HDC hdc = surface->getHDC();

    if (LE_FAILURE(status)) {
        return;
    }

    SaveDC(hdc);

    SetGraphicsMode(hdc, GM_ADVANCED);
    ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
    SetViewportOrgEx(hdc, 0, 0, NULL);
    SetWindowOrgEx(hdc, 0, 0, NULL);

    dpiX = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSX);
    dpiY = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSY);

#if 1
    pt.x = (int) (pointSize * dpiX / 72);
    pt.y = (int) (pointSize * dpiY / 72);

    DPtoLP(hdc, &pt, 1);
#else
    pt.x = pt.y = pointSize;
#endif

    lf.lfHeight = - pt.y;
    lf.lfWidth = 0;
    lf.lfEscapement = 0;
    lf.lfOrientation = 0;
    lf.lfWeight = 0;
    lf.lfItalic = 0;
    lf.lfUnderline = 0;
    lf.lfStrikeOut = 0;
    lf.lfCharSet = DEFAULT_CHARSET;
    lf.lfOutPrecision = 0;
    lf.lfClipPrecision = 0;
    lf.lfQuality = 0;
    lf.lfPitchAndFamily = 0;

    lstrcpy(lf.lfFaceName, faceName);

    fFont = CreateFontIndirect(&lf);

    if (fFont == NULL) {
        status = LE_FONT_FILE_NOT_FOUND_ERROR;
        return;
    }

    SelectObject(hdc, fFont);

    UINT ret = GetOutlineTextMetrics(hdc, sizeof otm, &otm);

    if (ret == 0) {
        status = LE_MISSING_FONT_TABLE_ERROR;
        goto restore;
    }

    fUnitsPerEM = otm.otmEMSquare;
    fAscent  = otm.otmTextMetrics.tmAscent;
    fDescent = otm.otmTextMetrics.tmDescent;
    fLeading = otm.otmTextMetrics.tmExternalLeading;

    status = initMapper();

    if (LE_FAILURE(status)) {
        goto restore;
    }

#if 0
    status = initFontTableCache();
#endif

restore:
    RestoreDC(hdc, -1);
}

GDIFontInstance::GDIFontInstance(GDISurface *surface, const char *faceName, le_int16 pointSize, LEErrorCode &status)
    : FontTableCache(), fSurface(surface), fFont(NULL),
      fPointSize(pointSize), fUnitsPerEM(0), fAscent(0), fDescent(0), fLeading(0),
      fDeviceScaleX(1), fDeviceScaleY(1), fMapper(NULL)
{
    LOGFONTA lf;
    FLOAT dpiX, dpiY;
    POINT pt;
    OUTLINETEXTMETRIC otm;
    HDC hdc = surface->getHDC();

    if (LE_FAILURE(status)) {
        return;
    }

    SaveDC(hdc);

    SetGraphicsMode(hdc, GM_ADVANCED);
    ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
    SetViewportOrgEx(hdc, 0, 0, NULL);
    SetWindowOrgEx(hdc, 0, 0, NULL);

    dpiX = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSX);
    dpiY = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSY);

    fDeviceScaleX = dpiX / 72;
    fDeviceScaleY = dpiY / 72;

#if 1
    pt.x = (int) (pointSize * fDeviceScaleX);
    pt.y = (int) (pointSize * fDeviceScaleY);

    DPtoLP(hdc, &pt, 1);
#else
    pt.x = pt.y = pointSize;
#endif

    lf.lfHeight = - pt.y;
    lf.lfWidth = 0;
    lf.lfEscapement = 0;
    lf.lfOrientation = 0;
    lf.lfWeight = 0;
    lf.lfItalic = 0;
    lf.lfUnderline = 0;
    lf.lfStrikeOut = 0;
    lf.lfCharSet = DEFAULT_CHARSET;
    lf.lfOutPrecision = 0;
    lf.lfClipPrecision = 0;
    lf.lfQuality = 0;
    lf.lfPitchAndFamily = 0;

    strcpy(lf.lfFaceName, faceName);

    fFont = CreateFontIndirectA(&lf);

    if (fFont == NULL) {
        status = LE_FONT_FILE_NOT_FOUND_ERROR;
        return;
    }

    SelectObject(hdc, fFont);

    UINT ret = GetOutlineTextMetrics(hdc, sizeof otm, &otm);

    if (ret != 0) {
        fUnitsPerEM = otm.otmEMSquare;
        fAscent  = otm.otmTextMetrics.tmAscent;
        fDescent = otm.otmTextMetrics.tmDescent;
        fLeading = otm.otmTextMetrics.tmExternalLeading;
    } else {
        const HEADTable *headTable = NULL;
        const HHEATable *hheaTable = NULL;

        // read unitsPerEm from 'head' table
        headTable = (const HEADTable *) readFontTable(LE_HEAD_TABLE_TAG);

        if (headTable == NULL) {
            status = LE_MISSING_FONT_TABLE_ERROR;
            goto restore;
        }

        fUnitsPerEM   = SWAPW(headTable->unitsPerEm);
        freeFontTable((const void *)headTable);

        hheaTable = (HHEATable *) readFontTable(LE_HHEA_TABLE_TAG);

        if (hheaTable == NULL) {
            status = LE_MISSING_FONT_TABLE_ERROR;
            goto restore;
        }

        fAscent  = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->ascent));
        fDescent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->descent));
        fLeading = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->lineGap));

        freeFontTable((const void *) hheaTable);
    }

    status = initMapper();

    if (LE_FAILURE(status)) {
        goto restore;
    }

#if 0
    status = initFontTableCache();
#endif

restore:
    RestoreDC(hdc, -1);
}

GDIFontInstance::~GDIFontInstance()
{
#if 0
    flushFontTableCache();
    delete[] fTableCache;
#endif

    if (fFont != NULL) {
        // FIXME: call RemoveObject first?
        DeleteObject(fFont);
    }

    delete fMapper;
    fMapper = NULL;
}

LEErrorCode GDIFontInstance::initMapper()
{
    LETag cmapTag = LE_CMAP_TABLE_TAG;
    const CMAPTable *cmap = (const CMAPTable *) readFontTable(cmapTag);

    if (cmap == NULL) {
        return LE_MISSING_FONT_TABLE_ERROR;
    }

    fMapper = CMAPMapper::createUnicodeMapper(cmap);

    if (fMapper == NULL) {
        return LE_MISSING_FONT_TABLE_ERROR;
    }

    return LE_NO_ERROR;
}

const void *GDIFontInstance::getFontTable(LETag tableTag) const
{
    return FontTableCache::find(tableTag);
}

const void *GDIFontInstance::readFontTable(LETag tableTag) const
{
    fSurface->setFont(this);

    HDC   hdc    = fSurface->getHDC();
    DWORD stag   = SWAPL(tableTag);
    DWORD len    = GetFontData(hdc, stag, 0, NULL, 0);
    void *result = NULL;

    if (len != GDI_ERROR) {
        result = LE_NEW_ARRAY(char, len);
        GetFontData(hdc, stag, 0, result, len);
    }

    return result;
}

void GDIFontInstance::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const
{
    advance.fX = 0;
    advance.fY = 0;

    if (glyph == 0xFFFE || glyph == 0xFFFF) {
        return;
    }


    GLYPHMETRICS metrics;
    DWORD result;
    MAT2 identity = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
    HDC hdc = fSurface->getHDC();

    fSurface->setFont(this);

    result = GetGlyphOutline(hdc, glyph, GGO_GLYPH_INDEX | GGO_METRICS, &metrics, 0, NULL, &identity);

    if (result == GDI_ERROR) {
        return;
    }

    advance.fX = metrics.gmCellIncX;
    return;
}

le_bool GDIFontInstance::getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const
{
#if 0
    hsFixedPoint2 pt;
    le_bool result;

    result = fFontInstance->getGlyphPoint(glyph, pointNumber, pt);

    if (result) {
        point.fX = xUnitsToPoints(pt.fX);
        point.fY = yUnitsToPoints(pt.fY);
    }

    return result;
#else
    return FALSE;
#endif
}
Commit	Line	Data
b75a7d8f	1	/*
f3c0d7a5 A	2	*******************************************************************************
	3	*
	4	* © 2016 and later: Unicode, Inc. and others.
	5	* License & terms of use: http://www.unicode.org/copyright.html#License
	6	*
	7	*******************************************************************************
b75a7d8f A	8	*******************************************************************************
b75a7d8f A	9	*
46f4442e	10	* Copyright (C) 1999-2008, International Business Machines
b75a7d8f A	11	* Corporation and others. All Rights Reserved.
	12	*
	13	*******************************************************************************
	14	* file name: GDIFontInstance.cpp
	15	*
	16	* created on: 08/09/2000
	17	* created by: Eric R. Mader
	18	*/
	19
	20	#include <windows.h>
	21
	22	#include "layout/LETypes.h"
	23	#include "layout/LESwaps.h"
	24	#include "layout/LEFontInstance.h"
	25
	26	#include "GDIFontInstance.h"
	27	#include "sfnt.h"
	28	#include "cmaps.h"
	29
	30	GDISurface::GDISurface(HDC theHDC)
	31	: fHdc(theHDC), fCurrentFont(NULL)
	32	{
	33	// nothing else to do
	34	}
	35
	36	GDISurface::~GDISurface()
	37	{
	38	// nothing to do
	39	}
	40
	41	void GDISurface::setHDC(HDC theHDC)
	42	{
	43	fHdc = theHDC;
	44	fCurrentFont = NULL;
	45	}
	46
	47	void GDISurface::setFont(const GDIFontInstance *font)
	48	{
	49	#if 0
	50	if (fCurrentFont != font) {
	51	fCurrentFont = font;
	52	SelectObject(fHdc, font->getFont());
	53	}
	54	#else
	55	SelectObject(fHdc, font->getFont());
	56	#endif
	57	}
	58
	59	void GDISurface::drawGlyphs(const LEFontInstance font, const LEGlyphID glyphs, le_int32 count, const float *positions,
	60	le_int32 x, le_int32 y, le_int32 width, le_int32 height)
	61	{
	62	TTGlyphID *ttGlyphs = LE_NEW_ARRAY(TTGlyphID, count);
	63	le_int32 *dx = LE_NEW_ARRAY(le_int32, count);
73c04bcf A	64	float ps = LE_NEW_ARRAY(float, count 2 + 2);
73c04bcf A	65	le_int32 out = 0;
b75a7d8f A	66	RECT clip;
	67
	68	clip.top = 0;
	69	clip.left = 0;
	70	clip.bottom = height;
	71	clip.right = width;
	72
	73	for (le_int32 g = 0; g < count; g += 1) {
73c04bcf A	74	TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyphs[g]);
	75
	76	if (ttGlyph < 0xFFFE) {
	77	ttGlyphs[out] = ttGlyph;
	78	dx[out] = (le_int32) (positions[g * 2 + 2] - positions[g * 2]);
	79	ps[out * 2] = positions[g * 2];
	80	ps[out * 2 + 1] = positions[g * 2 + 1];
	81	out += 1;
b75a7d8f	82	}
b75a7d8f A	83	}
	84
	85	le_int32 dyStart, dyEnd;
	86
	87	setFont((GDIFontInstance *) font);
	88
	89	dyStart = dyEnd = 0;
	90
73c04bcf A	91	while (dyEnd < out) {
	92	float yOffset = ps[dyStart * 2 + 1];
	93	float xOffset = ps[dyStart * 2];
b75a7d8f	94
73c04bcf	95	while (dyEnd < out && yOffset == ps[dyEnd * 2 + 1]) {
b75a7d8f A	96	dyEnd += 1;
	97	}
	98
	99	ExtTextOut(fHdc, x + (le_int32) xOffset, y + (le_int32) yOffset - font->getAscent(), ETO_CLIPPED \| ETO_GLYPH_INDEX, &clip,
73c04bcf	100	(LPCWSTR) &ttGlyphs[dyStart], dyEnd - dyStart, (INT *) &dx[dyStart]);
b75a7d8f A	101
	102	dyStart = dyEnd;
	103	}
	104
73c04bcf	105	LE_DELETE_ARRAY(ps);
b75a7d8f A	106	LE_DELETE_ARRAY(dx);
	107	LE_DELETE_ARRAY(ttGlyphs);
	108	}
	109
	110	GDIFontInstance::GDIFontInstance(GDISurface surface, TCHAR faceName, le_int16 pointSize, LEErrorCode &status)
	111	: FontTableCache(), fSurface(surface), fFont(NULL),
	112	fPointSize(pointSize), fUnitsPerEM(0), fAscent(0), fDescent(0), fLeading(0),
	113	fDeviceScaleX(1), fDeviceScaleY(1), fMapper(NULL)
	114	{
	115	LOGFONT lf;
	116	FLOAT dpiX, dpiY;
	117	POINT pt;
	118	OUTLINETEXTMETRIC otm;
	119	HDC hdc = surface->getHDC();
	120
	121	if (LE_FAILURE(status)) {
	122	return;
	123	}
	124
	125	SaveDC(hdc);
	126
	127	SetGraphicsMode(hdc, GM_ADVANCED);
	128	ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
	129	SetViewportOrgEx(hdc, 0, 0, NULL);
	130	SetWindowOrgEx(hdc, 0, 0, NULL);
	131
	132	dpiX = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSX);
	133	dpiY = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSY);
	134
	135	#if 1
	136	pt.x = (int) (pointSize * dpiX / 72);
	137	pt.y = (int) (pointSize * dpiY / 72);
	138
	139	DPtoLP(hdc, &pt, 1);
	140	#else
	141	pt.x = pt.y = pointSize;
	142	#endif
	143
	144	lf.lfHeight = - pt.y;
	145	lf.lfWidth = 0;
	146	lf.lfEscapement = 0;
	147	lf.lfOrientation = 0;
	148	lf.lfWeight = 0;
	149	lf.lfItalic = 0;
	150	lf.lfUnderline = 0;
	151	lf.lfStrikeOut = 0;
	152	lf.lfCharSet = DEFAULT_CHARSET;
	153	lf.lfOutPrecision = 0;
	154	lf.lfClipPrecision = 0;
	155	lf.lfQuality = 0;
	156	lf.lfPitchAndFamily = 0;
	157
	158	lstrcpy(lf.lfFaceName, faceName);
	159
	160	fFont = CreateFontIndirect(&lf);
	161
	162	if (fFont == NULL) {
	163	status = LE_FONT_FILE_NOT_FOUND_ERROR;
	164	return;
	165	}
	166
	167	SelectObject(hdc, fFont);
	168
	169	UINT ret = GetOutlineTextMetrics(hdc, sizeof otm, &otm);
170
171	if (ret == 0) {
172	status = LE_MISSING_FONT_TABLE_ERROR;
173	goto restore;
174	}
175
176	fUnitsPerEM = otm.otmEMSquare;
177	fAscent = otm.otmTextMetrics.tmAscent;
178	fDescent = otm.otmTextMetrics.tmDescent;
179	fLeading = otm.otmTextMetrics.tmExternalLeading;
180
181	status = initMapper();
182
183	if (LE_FAILURE(status)) {
184	goto restore;
185	}
186
187	#if 0
188	status = initFontTableCache();
189	#endif
190
191	restore:
192	RestoreDC(hdc, -1);
193	}
194
195	GDIFontInstance::GDIFontInstance(GDISurface surface, const char faceName, le_int16 pointSize, LEErrorCode &status)
196	: FontTableCache(), fSurface(surface), fFont(NULL),
197	fPointSize(pointSize), fUnitsPerEM(0), fAscent(0), fDescent(0), fLeading(0),
198	fDeviceScaleX(1), fDeviceScaleY(1), fMapper(NULL)
199	{
200	LOGFONTA lf;
201	FLOAT dpiX, dpiY;
202	POINT pt;
203	OUTLINETEXTMETRIC otm;
204	HDC hdc = surface->getHDC();
205
206	if (LE_FAILURE(status)) {
207	return;
208	}
209
210	SaveDC(hdc);
211
212	SetGraphicsMode(hdc, GM_ADVANCED);
213	ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
214	SetViewportOrgEx(hdc, 0, 0, NULL);
215	SetWindowOrgEx(hdc, 0, 0, NULL);
216
217	dpiX = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSX);
218	dpiY = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSY);
219
220	fDeviceScaleX = dpiX / 72;
221	fDeviceScaleY = dpiY / 72;
222
223	#if 1
224	pt.x = (int) (pointSize * fDeviceScaleX);
225	pt.y = (int) (pointSize * fDeviceScaleY);
226
227	DPtoLP(hdc, &pt, 1);
228	#else
229	pt.x = pt.y = pointSize;
230	#endif
231
232	lf.lfHeight = - pt.y;
233	lf.lfWidth = 0;
234	lf.lfEscapement = 0;
235	lf.lfOrientation = 0;
236	lf.lfWeight = 0;
237	lf.lfItalic = 0;
238	lf.lfUnderline = 0;
239	lf.lfStrikeOut = 0;
240	lf.lfCharSet = DEFAULT_CHARSET;
241	lf.lfOutPrecision = 0;
242	lf.lfClipPrecision = 0;
243	lf.lfQuality = 0;
244	lf.lfPitchAndFamily = 0;
245
246	strcpy(lf.lfFaceName, faceName);
247
248	fFont = CreateFontIndirectA(&lf);
249
250	if (fFont == NULL) {
251	status = LE_FONT_FILE_NOT_FOUND_ERROR;
252	return;
253	}
254
255	SelectObject(hdc, fFont);
256
257	UINT ret = GetOutlineTextMetrics(hdc, sizeof otm, &otm);
258
46f4442e A	259	if (ret != 0) {
	260	fUnitsPerEM = otm.otmEMSquare;
	261	fAscent = otm.otmTextMetrics.tmAscent;
	262	fDescent = otm.otmTextMetrics.tmDescent;
	263	fLeading = otm.otmTextMetrics.tmExternalLeading;
	264	} else {
	265	const HEADTable *headTable = NULL;
	266	const HHEATable *hheaTable = NULL;
	267
	268	// read unitsPerEm from 'head' table
	269	headTable = (const HEADTable *) readFontTable(LE_HEAD_TABLE_TAG);
	270
	271	if (headTable == NULL) {
	272	status = LE_MISSING_FONT_TABLE_ERROR;
	273	goto restore;
	274	}
b75a7d8f	275
46f4442e A	276	fUnitsPerEM = SWAPW(headTable->unitsPerEm);
	277	freeFontTable((const void *)headTable);
	278
	279	hheaTable = (HHEATable *) readFontTable(LE_HHEA_TABLE_TAG);
	280
	281	if (hheaTable == NULL) {
	282	status = LE_MISSING_FONT_TABLE_ERROR;
	283	goto restore;
	284	}
	285
	286	fAscent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->ascent));
	287	fDescent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->descent));
	288	fLeading = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->lineGap));
	289
	290	freeFontTable((const void *) hheaTable);
	291	}
b75a7d8f A	292
	293	status = initMapper();
	294
	295	if (LE_FAILURE(status)) {
	296	goto restore;
	297	}
	298
	299	#if 0
	300	status = initFontTableCache();
	301	#endif
	302
	303	restore:
	304	RestoreDC(hdc, -1);
	305	}
	306
	307	GDIFontInstance::~GDIFontInstance()
	308	{
	309	#if 0
	310	flushFontTableCache();
	311	delete[] fTableCache;
	312	#endif
	313
	314	if (fFont != NULL) {
	315	// FIXME: call RemoveObject first?
	316	DeleteObject(fFont);
	317	}
	318
	319	delete fMapper;
	320	fMapper = NULL;
	321	}
	322
	323	LEErrorCode GDIFontInstance::initMapper()
	324	{
	325	LETag cmapTag = LE_CMAP_TABLE_TAG;
	326	const CMAPTable cmap = (const CMAPTable ) readFontTable(cmapTag);
	327
	328	if (cmap == NULL) {
	329	return LE_MISSING_FONT_TABLE_ERROR;
	330	}
	331
	332	fMapper = CMAPMapper::createUnicodeMapper(cmap);
	333
	334	if (fMapper == NULL) {
	335	return LE_MISSING_FONT_TABLE_ERROR;
	336	}
	337
	338	return LE_NO_ERROR;
	339	}
	340
	341	const void *GDIFontInstance::getFontTable(LETag tableTag) const
	342	{
	343	return FontTableCache::find(tableTag);
	344	}
	345
	346	const void *GDIFontInstance::readFontTable(LETag tableTag) const
	347	{
	348	fSurface->setFont(this);
	349
	350	HDC hdc = fSurface->getHDC();
	351	DWORD stag = SWAPL(tableTag);
	352	DWORD len = GetFontData(hdc, stag, 0, NULL, 0);
	353	void *result = NULL;
	354
	355	if (len != GDI_ERROR) {
356	result = LE_NEW_ARRAY(char, len);
357	GetFontData(hdc, stag, 0, result, len);
358	}
359
360	return result;
361	}
362
363	void GDIFontInstance::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const
364	{
365	advance.fX = 0;
366	advance.fY = 0;
367
368	if (glyph == 0xFFFE \|\| glyph == 0xFFFF) {
369	return;
370	}
371
372
373	GLYPHMETRICS metrics;
374	DWORD result;
375	MAT2 identity = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};
376	HDC hdc = fSurface->getHDC();
377
378	fSurface->setFont(this);
379
380	result = GetGlyphOutline(hdc, glyph, GGO_GLYPH_INDEX \| GGO_METRICS, &metrics, 0, NULL, &identity);
381
382	if (result == GDI_ERROR) {
383	return;
384	}
385
386	advance.fX = metrics.gmCellIncX;
387	return;
388	}
389
390	le_bool GDIFontInstance::getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const
391	{
392	#if 0
393	hsFixedPoint2 pt;
394	le_bool result;
395
396	result = fFontInstance->getGlyphPoint(glyph, pointNumber, pt);
397
398	if (result) {
399	point.fX = xUnitsToPoints(pt.fX);
400	point.fY = yUnitsToPoints(pt.fY);
401	}
402
403	return result;
404	#else
374ca955	405	return FALSE;
b75a7d8f A	406	#endif
	407	}
	408