font.c File Reference

#include <precomp.h>
#include <math.h>
#include <strsafe.h>
#include <debug.h>

Include dependency graph for font.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	MAXTCIINDEX   32
#define	INITIAL_FAMILY_COUNT   64
#define	IFFCX_CHARSET   1
#define	IFFCX_STYLE   2
#define	IEFF_UNICODE   1
#define	IEFF_EXTENDED   2
#define	EfdFontFamilies   3

Functions
static __inline INT	GDI_ROUND (FLOAT val)
VOID FASTCALL	FONT_TextMetricWToA (const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA)
static LPWSTR	FONT_mbtowc (HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
static LPSTR	FONT_GetCharsByRangeA (HDC hdc, UINT firstChar, UINT lastChar, PINT pByteLen)
VOID FASTCALL	NewTextMetricW2A (NEWTEXTMETRICA *tma, NEWTEXTMETRICW *tmw)
VOID FASTCALL	NewTextMetricExW2A (NEWTEXTMETRICEXA *tma, NEWTEXTMETRICEXW *tmw)
FORCEINLINE int FASTCALL	IntFontFamilyCompareEx (const FONTFAMILYINFO *ffi1, const FONTFAMILYINFO *ffi2, DWORD dwCompareFlags)
static int __cdecl	IntFontFamilyCompare (const void *ffi1, const void *ffi2)
int FASTCALL	IntFontFamilyListUnique (FONTFAMILYINFO *InfoList, INT nCount, const LOGFONTW *plf, DWORD dwFlags)
static int FASTCALL	IntEnumFontFamilies (HDC Dc, const LOGFONTW *LogFont, PVOID EnumProc, LPARAM lParam, DWORD dwFlags)
int WINAPI	EnumFontFamiliesExW (HDC hdc, LPLOGFONTW lpLogfont, FONTENUMPROCW lpEnumFontFamExProc, LPARAM lParam, DWORD dwFlags)
int WINAPI	EnumFontFamiliesW (HDC hdc, LPCWSTR lpszFamily, FONTENUMPROCW lpEnumFontFamProc, LPARAM lParam)
int WINAPI	EnumFontFamiliesExA (HDC hdc, LPLOGFONTA lpLogfont, FONTENUMPROCA lpEnumFontFamExProc, LPARAM lParam, DWORD dwFlags)
int WINAPI	EnumFontFamiliesA (HDC hdc, LPCSTR lpszFamily, FONTENUMPROCA lpEnumFontFamProc, LPARAM lParam)
DWORD WINAPI	GetCharacterPlacementA (HDC hdc, LPCSTR lpString, INT uCount, INT nMaxExtent, GCP_RESULTSA *lpResults, DWORD dwFlags)
DWORD WINAPI	GetCharacterPlacementW (HDC hdc, LPCWSTR lpString, INT uCount, INT nMaxExtent, GCP_RESULTSW *lpResults, DWORD dwFlags)
DWORD WINAPI	NewGetCharacterPlacementW (HDC hdc, LPCWSTR lpString, INT uCount, INT nMaxExtent, GCP_RESULTSW *lpResults, DWORD dwFlags)
BOOL WINAPI	GetCharABCWidthsFloatW (HDC hdc, UINT FirstChar, UINT LastChar, LPABCFLOAT abcF)
BOOL WINAPI	GetCharWidthFloatW (HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBuffer)
BOOL WINAPI	GetCharWidthW (HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer)
BOOL WINAPI	GetCharWidth32W (HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer)
BOOL WINAPI	GetCharABCWidthsW (HDC hdc, UINT FirstChar, UINT LastChar, LPABC lpabc)
BOOL WINAPI	GetCharWidthA (HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer)
BOOL WINAPI	GetCharWidth32A (HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer)
BOOL APIENTRY	GetCharWidthFloatA (HDC hdc, UINT iFirstChar, UINT iLastChar, PFLOAT pxBuffer)
BOOL APIENTRY	GetCharABCWidthsA (HDC hdc, UINT iFirstChar, UINT iLastChar, LPABC lpabc)
BOOL APIENTRY	GetCharABCWidthsFloatA (HDC hdc, UINT iFirstChar, UINT iLastChar, LPABCFLOAT lpABCF)
BOOL WINAPI	GetCharABCWidthsI (HDC hdc, UINT giFirst, UINT cgi, LPWORD pgi, LPABC lpabc)
BOOL WINAPI	GetCharWidthI (HDC hdc, UINT giFirst, UINT cgi, LPWORD pgi, LPINT lpBuffer)
DWORD WINAPI	GetFontLanguageInfo (HDC hDc)
DWORD WINAPI	GetGlyphIndicesA (HDC hdc, LPCSTR lpstr, INT count, LPWORD pgi, DWORD flags)
DWORD WINAPI	GetGlyphOutlineA (HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm, DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
DWORD WINAPI	GetGlyphOutlineW (HDC hdc, UINT uChar, UINT uFormat, LPGLYPHMETRICS lpgm, DWORD cbBuffer, LPVOID lpvBuffer, CONST MAT2 *lpmat2)
DWORD WINAPI	GetGlyphOutlineWow (DWORD a0, DWORD a1, DWORD a2, DWORD a3, DWORD a4, DWORD a5, DWORD a6)
UINT APIENTRY	GetOutlineTextMetricsA (HDC hdc, UINT cbData, LPOUTLINETEXTMETRICA lpOTM)
static INT	INTERNAL_YDSTOWS (XFORM *xForm, INT height)
static INT	width_to_LP (XFORM *xForm, INT width)
static INT	height_to_LP (XFORM *xForm, INT height)
UINT APIENTRY	GetOutlineTextMetricsW (HDC hdc, UINT cbData, LPOUTLINETEXTMETRICW lpOTM)
DWORD WINAPI	GetKerningPairsW (HDC hdc, ULONG cPairs, LPKERNINGPAIR pkpDst)
DWORD WINAPI	GetKerningPairsA (HDC hDC, DWORD cPairs, LPKERNINGPAIR kern_pairA)
HFONT WINAPI	CreateFontIndirectExA (const ENUMLOGFONTEXDVA *elfexd)
HFONT WINAPI	CreateFontIndirectExW (const ENUMLOGFONTEXDVW *elfexd)
HFONT WINAPI	CreateFontIndirectA (CONST LOGFONTA *lplf)
HFONT WINAPI	CreateFontIndirectW (CONST LOGFONTW *lplf)
HFONT WINAPI	CreateFontA (int nHeight, int nWidth, int nEscapement, int nOrientation, int fnWeight, DWORD fdwItalic, DWORD fdwUnderline, DWORD fdwStrikeOut, DWORD fdwCharSet, DWORD fdwOutputPrecision, DWORD fdwClipPrecision, DWORD fdwQuality, DWORD fdwPitchAndFamily, LPCSTR lpszFace)
HFONT WINAPI	CreateFontW (int nHeight, int nWidth, int nEscapement, int nOrientation, int nWeight, DWORD fnItalic, DWORD fdwUnderline, DWORD fdwStrikeOut, DWORD fdwCharSet, DWORD fdwOutputPrecision, DWORD fdwClipPrecision, DWORD fdwQuality, DWORD fdwPitchAndFamily, LPCWSTR lpszFace)
PWSTR FASTCALL	IntConvertFontPaths (_In_ PCWSTR pszFiles, _Out_ PDWORD pcFiles, _Out_ PDWORD pcwc, _Inout_ PDWORD pfl, _In_ BOOL bFlag)
BOOL WINAPI	CreateScalableFontResourceA (DWORD fdwHidden, LPCSTR lpszFontRes, LPCSTR lpszFontFile, LPCSTR lpszCurrentPath)
INT WINAPI	AddFontResourceExW (_In_ LPCWSTR lpszFilename, _In_ DWORD fl, _In_opt_ PVOID pvReserved)
INT WINAPI	AddFontResourceExA (_In_ LPCSTR lpszFilename, _In_ DWORD fl, _In_opt_ PVOID pvReserved)
INT WINAPI	AddFontResourceA (_In_ LPCSTR lpszFilename)
INT WINAPI	AddFontResourceW (_In_ LPCWSTR lpszFilename)
BOOL WINAPI	RemoveFontResourceW (_In_ LPCWSTR lpFileName)
BOOL WINAPI	RemoveFontResourceA (_In_ LPCSTR lpFileName)
BOOL WINAPI	RemoveFontResourceExA (_In_ LPCSTR lpFileName, _In_ DWORD fl, _In_opt_ PVOID pdv)
BOOL WINAPI	RemoveFontResourceExW (_In_ LPCWSTR lpFileName, _In_ DWORD fl, _In_opt_ PVOID pdv)
LONG WINAPI	GdiGetCharDimensions (HDC hdc, LPTEXTMETRICW lptm, LONG *height)
BOOL WINAPI	TranslateCharsetInfo (LPDWORD lpSrc, LPCHARSETINFO lpCs, DWORD flags)
DWORD WINAPI	SetMapperFlags (HDC hDC, DWORD flags)
int WINAPI	EnumFontsW (HDC hDC, LPCWSTR lpFaceName, FONTENUMPROCW FontFunc, LPARAM lParam)
int WINAPI	EnumFontsA (HDC hDC, LPCSTR lpFaceName, FONTENUMPROCA FontFunc, LPARAM lParam)
INT WINAPI	NewEnumFontFamiliesExW (HDC hDC, LPLOGFONTW lpLogfont, FONTENUMPROCW lpEnumFontFamExProcW, LPARAM lParam, DWORD dwFlags)
INT WINAPI	GdiAddFontResourceW (LPCWSTR lpszFilename, FLONG fl, DESIGNVECTOR *pdv)
HANDLE WINAPI	AddFontMemResourceEx (PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
BOOL WINAPI	RemoveFontMemResourceEx (HANDLE fh)
int WINAPI	AddFontResourceTracking (LPCSTR lpString, int unknown)
int WINAPI	RemoveFontResourceTracking (LPCSTR lpString, int unknown)
BOOL WINAPI	CreateScalableFontResourceW (DWORD fdwHidden, LPCWSTR lpszFontRes, LPCWSTR lpszFontFile, LPCWSTR lpszCurrentPath)
BOOL WINAPI	bInitSystemAndFontsDirectoriesW (LPWSTR *SystemDir, LPWSTR *FontsDir)
BOOL WINAPI	EudcLoadLinkW (LPCWSTR pBaseFaceName, LPCWSTR pEudcFontPath, INT iPriority, INT iFontLinkType)
BOOL WINAPI	EudcUnloadLinkW (LPCWSTR pBaseFaceName, LPCWSTR pEudcFontPath)
ULONG WINAPI	GetEUDCTimeStamp (VOID)
DWORD WINAPI	GetEUDCTimeStampExW (LPWSTR lpBaseFaceName)
ULONG WINAPI	GetFontAssocStatus (HDC hdc)
DWORD WINAPI	QueryFontAssocStatus (VOID)
VOID WINAPI	UnloadNetworkFonts (DWORD unknown)
DWORD WINAPI	GetFontData (HDC hdc, DWORD dwTable, DWORD dwOffset, LPVOID lpvBuffer, DWORD cbData)
DWORD WINAPI	cGetTTFFromFOT (DWORD x1, DWORD x2, DWORD x3, DWORD x4, DWORD x5, DWORD x6, DWORD x7)

Variables
static const CHARSETINFO	FONT_tci [MAXTCIINDEX]

Macro Definition Documentation

EfdFontFamilies

#define EfdFontFamilies   3

Definition at line 2486 of file font.c.

IEFF_EXTENDED

#define IEFF_EXTENDED   2

Definition at line 254 of file font.c.

IEFF_UNICODE

#define IEFF_UNICODE   1

Definition at line 253 of file font.c.

IFFCX_CHARSET

#define IFFCX_CHARSET   1

Definition at line 210 of file font.c.

IFFCX_STYLE

#define IFFCX_STYLE   2

Definition at line 211 of file font.c.

INITIAL_FAMILY_COUNT

#define INITIAL_FAMILY_COUNT   64

Definition at line 74 of file font.c.

MAXTCIINDEX

#define MAXTCIINDEX   32

Definition at line 32 of file font.c.

NDEBUG

#define NDEBUG

Definition at line 17 of file font.c.

Function Documentation

AddFontMemResourceEx()

HANDLE WINAPI AddFontMemResourceEx	(	PVOID	pbFont,
		DWORD	cbFont,
		PVOID	pdv,
		DWORD *	pcFonts
	)

Definition at line 2597 of file font.c.

{
    if ( pbFont && cbFont && pcFonts)
    {
        return NtGdiAddFontMemResourceEx(pbFont, cbFont, NULL, 0, pcFonts);
    }
    SetLastError(ERROR_INVALID_PARAMETER);
    return NULL;
}

AddFontResourceA()

INT WINAPI AddFontResourceA

(

_In_ LPCSTR

lpszFilename

)

Definition at line 2175 of file font.c.

{
    return AddFontResourceExA(lpszFilename, 0, NULL);
}

Referenced by Test_AddFontResourceA().

AddFontResourceExA()

INT WINAPI AddFontResourceExA	(	_In_ LPCSTR	lpszFilename,
		_In_ DWORD	fl,
		_In_opt_ PVOID	pvReserved
	)

Definition at line 2134 of file font.c.

{
    if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (!lpszFilename)
        return 0;
 
    PWSTR FilenameW;
    WCHAR szBuff[MAX_PATH];
 
    _SEH2_TRY
    {
        FilenameW = HEAP_strdupA2W_buf(lpszFilename, szBuff, _countof(szBuff));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        _SEH2_YIELD(return 0);
    }
    _SEH2_END;
 
    if (!FilenameW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return 0;
    }
 
    INT ret = GdiAddFontResourceW(FilenameW, fl, NULL);
    HEAP_strdupA2W_buf_free(FilenameW, szBuff);
    return ret;
}

AddFontResourceExW()

INT WINAPI AddFontResourceExW	(	_In_ LPCWSTR	lpszFilename,
		_In_ DWORD	fl,
		_In_opt_ PVOID	pvReserved
	)

Definition at line 2117 of file font.c.

{
    if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    return GdiAddFontResourceW(lpszFilename, fl, NULL);
}

AddFontResourceTracking()

int WINAPI AddFontResourceTracking	(	LPCSTR	lpString,
		int	unknown
	)

Definition at line 2633 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

AddFontResourceW()

INT WINAPI AddFontResourceW

(

_In_ LPCWSTR

lpszFilename

)

Definition at line 2183 of file font.c.

{
    return GdiAddFontResourceW(lpszFilename, 0, NULL);
}

Referenced by DoEntry(), DoInstallFontFile(), and wWinMain().

bInitSystemAndFontsDirectoriesW()

BOOL WINAPI bInitSystemAndFontsDirectoriesW	(	LPWSTR *	SystemDir,
		LPWSTR *	FontsDir
	)

Definition at line 2688 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

cGetTTFFromFOT()

DWORD WINAPI cGetTTFFromFOT	(	DWORD	x1,
		DWORD	x2,
		DWORD	x3,
		DWORD	x4,
		DWORD	x5,
		DWORD	x6,
		DWORD	x7
	)

Definition at line 2811 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

CreateFontA()

HFONT WINAPI CreateFontA	(	int	nHeight,
		int	nWidth,
		int	nEscapement,
		int	nOrientation,
		int	fnWeight,
		DWORD	fdwItalic,
		DWORD	fdwUnderline,
		DWORD	fdwStrikeOut,
		DWORD	fdwCharSet,
		DWORD	fdwOutputPrecision,
		DWORD	fdwClipPrecision,
		DWORD	fdwQuality,
		DWORD	fdwPitchAndFamily,
		LPCSTR	lpszFace
	)

Definition at line 1862 of file font.c.

{
    ANSI_STRING StringA;
    UNICODE_STRING StringU;
    HFONT ret;
 
    RtlInitAnsiString(&StringA, lpszFace);
    RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE);
 
    ret = CreateFontW(nHeight,
                      nWidth,
                      nEscapement,
                      nOrientation,
                      fnWeight,
                      fdwItalic,
                      fdwUnderline,
                      fdwStrikeOut,
                      fdwCharSet,
                      fdwOutputPrecision,
                      fdwClipPrecision,
                      fdwQuality,
                      fdwPitchAndFamily,
                      StringU.Buffer);
 
    RtlFreeUnicodeString(&StringU);
 
    return ret;
}

CreateFontIndirectA()

HFONT WINAPI CreateFontIndirectA

(

CONST LOGFONTA *

lplf

)

Definition at line 1717 of file font.c.

{
    if (lplf)
    {
        LOGFONTW tlf;
 
        LogFontA2W(&tlf, lplf);
        return CreateFontIndirectW(&tlf);
    }
    else return NULL;
}

CreateFontIndirectExA()

HFONT WINAPI CreateFontIndirectExA

(

const ENUMLOGFONTEXDVA *

elfexd

)

Definition at line 1675 of file font.c.

{
    if (elfexd)
    {
        ENUMLOGFONTEXDVW Logfont;
 
        EnumLogFontExW2A( (LPENUMLOGFONTEXA) elfexd,
                          &Logfont.elfEnumLogfontEx );
 
        RtlCopyMemory( &Logfont.elfDesignVector,
                       &elfexd->elfDesignVector,
                       sizeof(DESIGNVECTOR));
 
        return NtGdiHfontCreate( &Logfont, 0, 0, 0, NULL);
    }
    else return NULL;
}

Referenced by Test_CreateFontIndirectExA().

CreateFontIndirectExW()

HFONT WINAPI CreateFontIndirectExW

(

const ENUMLOGFONTEXDVW *

elfexd

)

Definition at line 1699 of file font.c.

{
    /* Msdn: Note, this function ignores the elfDesignVector member in
             ENUMLOGFONTEXDV.
     */
    if ( elfexd )
    {
        return NtGdiHfontCreate((PENUMLOGFONTEXDVW) elfexd, 0, 0, 0, NULL );
    }
    else return NULL;
}

Referenced by CreateFontIndirectW(), and Test_CreateFontIndirectExW().

CreateFontIndirectW()

HFONT WINAPI CreateFontIndirectW

(

CONST LOGFONTW *

lplf

)

Definition at line 1821 of file font.c.

{
#if 0
    static BOOL bDidTest = FALSE;
    if (!bDidTest)
    {
        bDidTest = TRUE;
        DoFontSystemUnittest();
    }
#endif
    if (lplf)
    {
        ENUMLOGFONTEXDVW Logfont;
 
        RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW));
        // Need something other than just cleaning memory here.
        // Guess? Use caller data to determine the rest.
        RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfFullName,
                       sizeof(Logfont.elfEnumLogfontEx.elfFullName));
        RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfStyle,
                       sizeof(Logfont.elfEnumLogfontEx.elfStyle));
        RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfScript,
                       sizeof(Logfont.elfEnumLogfontEx.elfScript));
 
        Logfont.elfDesignVector.dvNumAxes = 0; // No more than MM_MAX_NUMAXES
 
        RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR));
 
        return CreateFontIndirectExW(&Logfont);
    }
    else return NULL;
}

CreateFontW()

HFONT WINAPI CreateFontW	(	int	nHeight,
		int	nWidth,
		int	nEscapement,
		int	nOrientation,
		int	nWeight,
		DWORD	fnItalic,
		DWORD	fdwUnderline,
		DWORD	fdwStrikeOut,
		DWORD	fdwCharSet,
		DWORD	fdwOutputPrecision,
		DWORD	fdwClipPrecision,
		DWORD	fdwQuality,
		DWORD	fdwPitchAndFamily,
		LPCWSTR	lpszFace
	)

Definition at line 1912 of file font.c.

{
    LOGFONTW logfont;
 
    logfont.lfHeight = nHeight;
    logfont.lfWidth = nWidth;
    logfont.lfEscapement = nEscapement;
    logfont.lfOrientation = nOrientation;
    logfont.lfWeight = nWeight;
    logfont.lfItalic = (BYTE)fnItalic;
    logfont.lfUnderline = (BYTE)fdwUnderline;
    logfont.lfStrikeOut = (BYTE)fdwStrikeOut;
    logfont.lfCharSet = (BYTE)fdwCharSet;
    logfont.lfOutPrecision = (BYTE)fdwOutputPrecision;
    logfont.lfClipPrecision = (BYTE)fdwClipPrecision;
    logfont.lfQuality = (BYTE)fdwQuality;
    logfont.lfPitchAndFamily = (BYTE)fdwPitchAndFamily;
 
    if (NULL != lpszFace)
    {
        int Size = sizeof(logfont.lfFaceName) / sizeof(WCHAR);
        wcsncpy((wchar_t *)logfont.lfFaceName, lpszFace, Size - 1);
        /* Be 101% sure to have '\0' at end of string */
        logfont.lfFaceName[Size - 1] = '\0';
    }
    else
    {
        logfont.lfFaceName[0] = L'\0';
    }
 
    return CreateFontIndirectW(&logfont);
}

CreateScalableFontResourceA()

BOOL WINAPI CreateScalableFontResourceA	(	DWORD	fdwHidden,
		LPCSTR	lpszFontRes,
		LPCSTR	lpszFontFile,
		LPCSTR	lpszCurrentPath
	)

Definition at line 2104 of file font.c.

{
    return FALSE;
}

CreateScalableFontResourceW()

BOOL WINAPI CreateScalableFontResourceW	(	DWORD	fdwHidden,
		LPCWSTR	lpszFontRes,
		LPCWSTR	lpszFontFile,
		LPCWSTR	lpszCurrentPath
	)

Definition at line 2657 of file font.c.

{
    HANDLE f;
 
    UNIMPLEMENTED;
 
    /* fHidden=1 - only visible for the calling app, read-only, not
     * enumerated with EnumFonts/EnumFontFamilies
     * lpszCurrentPath can be NULL
     */
 
    /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
    if ((f = CreateFileW(lpszFontRes, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE)
    {
        CloseHandle(f);
        SetLastError(ERROR_FILE_EXISTS);
        return FALSE;
    }
    return FALSE; /* create failed */
}

EnumFontFamiliesA()

int WINAPI EnumFontFamiliesA	(	HDC	hdc,
		LPCSTR	lpszFamily,
		FONTENUMPROCA	lpEnumFontFamProc,
		LPARAM	lParam
	)

Definition at line 482 of file font.c.

{
    LOGFONTW LogFont;
 
    DPRINT("EnumFontFamiliesA(%p, %s, %p, %p)\n",
           hdc, lpszFamily, lpEnumFontFamProc, lParam);
 
    ZeroMemory(&LogFont, sizeof(LOGFONTW));
    LogFont.lfCharSet = DEFAULT_CHARSET;
    if (NULL != lpszFamily)
    {
        if (!*lpszFamily) return 1;
        MultiByteToWideChar(CP_THREAD_ACP, 0, lpszFamily, -1, LogFont.lfFaceName, LF_FACESIZE);
    }
 
    return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, 0);
}

EnumFontFamiliesExA()

int WINAPI EnumFontFamiliesExA	(	HDC	hdc,
		LPLOGFONTA	lpLogfont,
		FONTENUMPROCA	lpEnumFontFamExProc,
		LPARAM	lParam,
		DWORD	dwFlags
	)

Definition at line 449 of file font.c.

{
    LOGFONTW LogFontW, *pLogFontW;
 
    if (lpLogfont)
    {
        DPRINT("EnumFontFamiliesExA(%p, %p(%s, %u, %u), %p, %p, 0x%08lX)\n",
               hdc, lpLogfont, lpLogfont->lfFaceName, lpLogfont->lfCharSet,
               lpLogfont->lfPitchAndFamily, lpEnumFontFamExProc, lParam, dwFlags);
    }
    else
    {
        DPRINT("EnumFontFamiliesExA(%p, NULL, %p, %p, 0x%08lX)\n",
               hdc, lpEnumFontFamExProc, lParam, dwFlags);
    }
 
    if (lpLogfont)
    {
        LogFontA2W(&LogFontW,lpLogfont);
        pLogFontW = &LogFontW;
    }
    else pLogFontW = NULL;
 
    /* no need to convert LogFontW back to lpLogFont b/c it's an [in] parameter only */
    return IntEnumFontFamilies(hdc, pLogFontW, lpEnumFontFamExProc, lParam, IEFF_EXTENDED);
}

EnumFontFamiliesExW()

int WINAPI EnumFontFamiliesExW	(	HDC	hdc,
		LPLOGFONTW	lpLogfont,
		FONTENUMPROCW	lpEnumFontFamExProc,
		LPARAM	lParam,
		DWORD	dwFlags
	)

Definition at line 402 of file font.c.

{
    if (lpLogfont)
    {
        DPRINT("EnumFontFamiliesExW(%p, %p(%S, %u, %u), %p, %p, 0x%08lX)\n",
               hdc, lpLogfont, lpLogfont->lfFaceName, lpLogfont->lfCharSet,
               lpLogfont->lfPitchAndFamily, lpEnumFontFamExProc, lParam, dwFlags);
    }
    else
    {
        DPRINT("EnumFontFamiliesExW(%p, NULL, %p, %p, 0x%08lX)\n",
               hdc, lpEnumFontFamExProc, lParam, dwFlags);
    }
    return IntEnumFontFamilies(hdc, lpLogfont, lpEnumFontFamExProc, lParam,
                               IEFF_UNICODE | IEFF_EXTENDED);
}

EnumFontFamiliesW()

int WINAPI EnumFontFamiliesW	(	HDC	hdc,
		LPCWSTR	lpszFamily,
		FONTENUMPROCW	lpEnumFontFamProc,
		LPARAM	lParam
	)

Definition at line 425 of file font.c.

{
    LOGFONTW LogFont;
 
    DPRINT("EnumFontFamiliesW(%p, %S, %p, %p)\n",
           hdc, lpszFamily, lpEnumFontFamProc, lParam);
 
    ZeroMemory(&LogFont, sizeof(LOGFONTW));
    LogFont.lfCharSet = DEFAULT_CHARSET;
    if (NULL != lpszFamily)
    {
        if (!*lpszFamily) return 1;
        lstrcpynW(LogFont.lfFaceName, lpszFamily, LF_FACESIZE);
    }
 
    return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, IEFF_UNICODE);
}

EnumFontsA()

int WINAPI EnumFontsA	(	HDC	hDC,
		LPCSTR	lpFaceName,
		FONTENUMPROCA	FontFunc,
		LPARAM	lParam
	)

Definition at line 2459 of file font.c.

{
#if 0
    NTSTATUS Status;
    LPWSTR lpFaceNameW;
    int rc = 0;
 
    Status = HEAP_strdupA2W ( &lpFaceNameW, lpFaceName );
    if (!NT_SUCCESS (Status))
        SetLastError (RtlNtStatusToDosError(Status));
    else
    {
        rc = NtGdiEnumFonts ( hDC, lpFaceNameW, FontFunc, lParam );
 
        HEAP_free ( lpFaceNameW );
    }
    return rc;
#else
    return EnumFontFamiliesA( hDC, lpFaceName, FontFunc, lParam );
#endif
}

EnumFontsW()

int WINAPI EnumFontsW	(	HDC	hDC,
		LPCWSTR	lpFaceName,
		FONTENUMPROCW	FontFunc,
		LPARAM	lParam
	)

Definition at line 2440 of file font.c.

{
#if 0
    return NtGdiEnumFonts ( hDC, lpFaceName, FontFunc, lParam );
#else
    return EnumFontFamiliesW( hDC, lpFaceName, FontFunc, lParam );
#endif
}

EudcLoadLinkW()

BOOL WINAPI EudcLoadLinkW	(	LPCWSTR	pBaseFaceName,
		LPCWSTR	pEudcFontPath,
		INT	iPriority,
		INT	iFontLinkType
	)

Definition at line 2700 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

EudcUnloadLinkW()

BOOL WINAPI EudcUnloadLinkW	(	LPCWSTR	pBaseFaceName,
		LPCWSTR	pEudcFontPath
	)

Definition at line 2712 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

FONT_GetCharsByRangeA()

static LPSTR FONT_GetCharsByRangeA ( HDC  hdc, UINT  firstChar, UINT  lastChar, PINT  pByteLen  )

static

Definition at line 148 of file font.c.

{
    INT i, count = lastChar - firstChar + 1;
    UINT c;
    LPSTR str;
 
    if (count <= 0)
        return NULL;
 
    switch (GdiGetCodePage(hdc))
    {
    case 932:
    case 936:
    case 949:
    case 950:
    case 1361:
        if (lastChar > 0xffff)
            return NULL;
        if ((firstChar ^ lastChar) > 0xff)
            return NULL;
        break;
    default:
        if (lastChar > 0xff)
            return NULL;
        break;
    }
 
    str = HeapAlloc(GetProcessHeap(), 0, count * 2 + 1);
    if (str == NULL)
        return NULL;
 
    for(i = 0, c = firstChar; c <= lastChar; i++, c++)
    {
        if (c > 0xff)
            str[i++] = (BYTE)(c >> 8);
        str[i] = (BYTE)c;
    }
    str[i] = '\0';
 
    *pByteLen = i;
 
    return str;
}

Referenced by GetCharABCWidthsA(), GetCharABCWidthsFloatA(), GetCharWidth32A(), GetCharWidthA(), and GetCharWidthFloatA().

FONT_mbtowc()

static LPWSTR FONT_mbtowc ( HDC  hdc, LPCSTR  str, INT  count, INT *  plenW, UINT *  pCP  )

static

Definition at line 126 of file font.c.

{
    UINT cp = GdiGetCodePage( hdc );
    INT lenW;
    LPWSTR strW;
 
    if(count == -1) count = strlen(str);
    lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
    strW = HeapAlloc(GetProcessHeap(), 0, lenW*sizeof(WCHAR));
    if (!strW)
        return NULL;
    if(!MultiByteToWideChar(cp, 0, str, count, strW, lenW))
    {
        HeapFree(GetProcessHeap(), 0, strW);
        return NULL;
    }
    DPRINT("mapped %s -> %S\n", str, strW);
    if(plenW) *plenW = lenW;
    if(pCP) *pCP = cp;
    return strW;
}

Referenced by GetCharABCWidthsA(), GetCharABCWidthsFloatA(), GetCharacterPlacementA(), GetCharWidth32A(), GetCharWidthA(), GetCharWidthFloatA(), GetGlyphIndicesA(), and GetGlyphOutlineA().

FONT_TextMetricWToA()

VOID FASTCALL FONT_TextMetricWToA	(	const TEXTMETRICW *	ptmW,
		LPTEXTMETRICA	ptmA
	)

Definition at line 81 of file font.c.

{
    ptmA->tmHeight = ptmW->tmHeight;
    ptmA->tmAscent = ptmW->tmAscent;
    ptmA->tmDescent = ptmW->tmDescent;
    ptmA->tmInternalLeading = ptmW->tmInternalLeading;
    ptmA->tmExternalLeading = ptmW->tmExternalLeading;
    ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
    ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
    ptmA->tmWeight = ptmW->tmWeight;
    ptmA->tmOverhang = ptmW->tmOverhang;
    ptmA->tmDigitizedAspectX = ptmW->tmDigitizedAspectX;
    ptmA->tmDigitizedAspectY = ptmW->tmDigitizedAspectY;
    ptmA->tmFirstChar = min(ptmW->tmFirstChar, 255);
    if (ptmW->tmCharSet == SYMBOL_CHARSET)
    {
        ptmA->tmFirstChar = 0x1e;
        ptmA->tmLastChar = 0xff;  /* win9x behaviour - we need the OS2 table data to calculate correctly */
    }
    else
    {
        ptmA->tmFirstChar = ptmW->tmDefaultChar - 1;
        ptmA->tmLastChar = min(ptmW->tmLastChar, 0xff);
    }
    ptmA->tmDefaultChar = (CHAR)ptmW->tmDefaultChar;
    ptmA->tmBreakChar = (CHAR)ptmW->tmBreakChar;
    ptmA->tmItalic = ptmW->tmItalic;
    ptmA->tmUnderlined = ptmW->tmUnderlined;
    ptmA->tmStruckOut = ptmW->tmStruckOut;
    ptmA->tmPitchAndFamily = ptmW->tmPitchAndFamily;
    ptmA->tmCharSet = ptmW->tmCharSet;
}

Referenced by GetOutlineTextMetricsA(), GetTextMetricsA(), and NewTextMetricW2A().

GDI_ROUND()

static __inline INT GDI_ROUND ( FLOAT  val )

static

Definition at line 24 of file font.c.

{
   return (int)floor(val + 0.5);
}

Referenced by height_to_LP(), INTERNAL_YDSTOWS(), and width_to_LP().

GdiAddFontResourceW()

INT WINAPI GdiAddFontResourceW	(	LPCWSTR	lpszFilename,
		FLONG	fl,
		DESIGNVECTOR *	pdv
	)

Definition at line 2566 of file font.c.

{
    ULONG cFiles, cwc;
    PWSTR pszConverted = IntConvertFontPaths(lpszFilename, &cFiles, &cwc, &fl, FALSE);
    if (!pszConverted)
        return 0;
 
    INT ret = NtGdiAddFontResourceW(pszConverted, cwc, cFiles, fl, 0, pdv);
    HEAP_free(pszConverted);
    if (ret)
        return ret;
 
    pszConverted = IntConvertFontPaths(lpszFilename, &cFiles, &cwc, &fl, TRUE);
    if (!pszConverted)
        return 0;
 
    ret = NtGdiAddFontResourceW(pszConverted, cwc, cFiles, fl, 0, pdv);
    HEAP_free(pszConverted);
    if (!ret)
        SetLastError(ERROR_INVALID_PARAMETER);
    return ret;
}

Referenced by AddFontResourceExA(), AddFontResourceExW(), and AddFontResourceW().

GdiGetCharDimensions()

LONG WINAPI GdiGetCharDimensions	(	HDC	hdc,
		LPTEXTMETRICW	lptm,
		LONG *	height
	)

Definition at line 2309 of file font.c.

{
    SIZE sz;
    TEXTMETRICW tm;
    static const WCHAR alphabet[] =
    {
        'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
        'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
        'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0
    };
 
    if(!GetTextMetricsW(hdc, &tm)) return 0;
 
    if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
 
    if (lptm) *lptm = tm;
    if (height) *height = tm.tmHeight;
 
    return (sz.cx / 26 + 1) / 2;
}

Referenced by CalculateCharWidth(), DIALOG_CreateIndirect(), EDIT_EM_SetMargins(), EDIT_UpdateUniscribeData_linedef(), GetDialogBaseUnits(), LoadDialog(), OleCreatePropertyFrameIndirect(), SoftModalMessageBox(), taskdialog_init(), Test_GdiGetCharDimensions(), test_margins_default(), and test_margins_usefontinfo().

GetCharABCWidthsA()

BOOL APIENTRY GetCharABCWidthsA	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		LPABC	lpabc
	)

Definition at line 949 of file font.c.

{
    INT wlen, count = 0;
    LPSTR str;
    LPWSTR wstr;
    BOOL ret = TRUE;
 
    DPRINT("GetCharABCWidthsA\n");
 
    str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
    if (!str)
        return FALSE;
 
    wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
    if (!wstr)
    {
        HeapFree(GetProcessHeap(), 0, str);
        return FALSE;
    }
 
    ret = NtGdiGetCharABCWidthsW( hdc,
                                  wstr[0],
                                  wlen - 1,
                                  (PWCHAR)wstr,
                                  GCABCW_NOFLOAT,
                                  (PVOID)lpabc);
 
    HeapFree(GetProcessHeap(), 0, str);
    HeapFree(GetProcessHeap(), 0, wstr);
 
    return ret;
}

GetCharABCWidthsFloatA()

BOOL APIENTRY GetCharABCWidthsFloatA	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		LPABCFLOAT	lpABCF
	)

Definition at line 992 of file font.c.

{
    INT wlen, count = 0;
    LPSTR str;
    LPWSTR wstr;
    BOOL ret = TRUE;
 
    DPRINT("GetCharABCWidthsFloatA\n");
 
    str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
    if (!str)
        return FALSE;
 
    wstr = FONT_mbtowc( hdc, str, count+1, &wlen, NULL );
    if (!wstr)
    {
        HeapFree( GetProcessHeap(), 0, str );
        return FALSE;
    }
    ret = NtGdiGetCharABCWidthsW(hdc, wstr[0], count, wstr, 0, lpABCF);
 
    HeapFree( GetProcessHeap(), 0, str );
    HeapFree( GetProcessHeap(), 0, wstr );
 
    return ret;
}

GetCharABCWidthsFloatW()

BOOL WINAPI GetCharABCWidthsFloatW	(	HDC	hdc,
		UINT	FirstChar,
		UINT	LastChar,
		LPABCFLOAT	abcF
	)

Definition at line 688 of file font.c.

{
    DPRINT("GetCharABCWidthsFloatW\n");
    if ((!abcF) || (FirstChar > LastChar))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return NtGdiGetCharABCWidthsW( hdc,
                                   FirstChar,
                                   (ULONG)(LastChar - FirstChar + 1),
                                   NULL,
                                   0,
                                   abcF);
}

GetCharABCWidthsI()

BOOL WINAPI GetCharABCWidthsI	(	HDC	hdc,
		UINT	giFirst,
		UINT	cgi,
		LPWORD	pgi,
		LPABC	lpabc
	)

Definition at line 1029 of file font.c.

{
    DPRINT("GetCharABCWidthsI\n");
    return NtGdiGetCharABCWidthsW( hdc,
                                   giFirst,
                                   (ULONG) cgi,
                                   (PWCHAR) pgi,
                                   GCABCW_NOFLOAT|GCABCW_INDICES,
                                   (PVOID)lpabc);
}

GetCharABCWidthsW()

BOOL WINAPI GetCharABCWidthsW	(	HDC	hdc,
		UINT	FirstChar,
		UINT	LastChar,
		LPABC	lpabc
	)

Definition at line 787 of file font.c.

{
    DPRINT("GetCharABCWidthsW\n");
    if ((!lpabc) || (FirstChar > LastChar))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return NtGdiGetCharABCWidthsW( hdc,
                                   FirstChar,
                                   (ULONG)(LastChar - FirstChar + 1),
                                   NULL,
                                   GCABCW_NOFLOAT,
                                   lpabc);
}

GetCharacterPlacementA()

DWORD WINAPI GetCharacterPlacementA	(	HDC	hdc,
		LPCSTR	lpString,
		INT	uCount,
		INT	nMaxExtent,
		GCP_RESULTSA *	lpResults,
		DWORD	dwFlags
	)

Definition at line 507 of file font.c.

{
    WCHAR *lpStringW;
    INT uCountW;
    GCP_RESULTSW resultsW;
    DWORD ret;
    UINT font_cp;
 
    if ( !lpString || uCount <= 0 || !lpResults || (nMaxExtent < 0 && nMaxExtent != -1 ) )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    /*    TRACE("%s, %d, %d, 0x%08x\n",
              debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
    */
    /* both structs are equal in size */
    memcpy(&resultsW, lpResults, sizeof(resultsW));
 
    lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
    if (lpStringW == NULL)
    {
        return 0;
    }
    if(lpResults->lpOutString)
    {
        resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
        if (resultsW.lpOutString == NULL)
        {
            HeapFree(GetProcessHeap(), 0, lpStringW);
            return 0;
        }
    }
 
    ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
 
    lpResults->nGlyphs = resultsW.nGlyphs;
    lpResults->nMaxFit = resultsW.nMaxFit;
 
    if(lpResults->lpOutString)
    {
        WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
                            lpResults->lpOutString, uCount, NULL, NULL );
    }
 
    HeapFree(GetProcessHeap(), 0, lpStringW);
    HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
 
    return ret;
}

GetCharacterPlacementW()

DWORD WINAPI GetCharacterPlacementW	(	HDC	hdc,
		LPCWSTR	lpString,
		INT	uCount,
		INT	nMaxExtent,
		GCP_RESULTSW *	lpResults,
		DWORD	dwFlags
	)

Definition at line 570 of file font.c.

{
    DWORD ret=0;
    SIZE size;
    UINT i, nSet;
    DPRINT("GetCharacterPlacementW\n");
 
    if (dwFlags&(~GCP_REORDER)) DPRINT("flags 0x%08lx ignored\n", dwFlags);
    if (lpResults->lpClass) DPRINT("classes not implemented\n");
 
    nSet = (UINT)uCount;
    if (nSet > lpResults->nGlyphs)
        nSet = lpResults->nGlyphs;
 
    /* return number of initialized fields */
    lpResults->nGlyphs = nSet;
 
    if (dwFlags & GCP_REORDER)
    {
        if (LoadLPK(LPK_GCP))
            return LpkGetCharacterPlacement(hdc, lpString, uCount, nMaxExtent, lpResults, dwFlags, 0);
    }
 
    /* Treat the case where no special handling was requested in a fastpath way */
    /* copy will do if the GCP_REORDER flag is not set */
    if (lpResults->lpOutString)
        lstrcpynW( lpResults->lpOutString, lpString, nSet );
 
    if (lpResults->lpOrder)
    {
        for (i = 0; i < nSet; i++)
            lpResults->lpOrder[i] = i;
    }
 
    /* FIXME: Will use the placement chars */
    if (lpResults->lpDx)
    {
        int c;
        for (i = 0; i < nSet; i++)
        {
            if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
                lpResults->lpDx[i]= c;
        }
    }
 
    if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
    {
        int pos = 0;
 
        lpResults->lpCaretPos[0] = 0;
        for (i = 1; i < nSet; i++)
            if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
                lpResults->lpCaretPos[i] = (pos += size.cx);
    }
 
    if (lpResults->lpGlyphs)
        NtGdiGetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
 
    if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
        ret = MAKELONG(size.cx, size.cy);
 
    return ret;
}

GetCharWidth32A()

BOOL WINAPI GetCharWidth32A	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		LPINT	lpBuffer
	)

Definition at line 859 of file font.c.

{
    INT wlen, count = 0;
    LPSTR str;
    LPWSTR wstr;
    BOOL ret = TRUE;
 
    DPRINT("GetCharWidths32A\n");
 
    if (!lpBuffer || (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) || !GdiValidateHandle(hdc))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
    if (!str)
        return FALSE;
 
    wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
    if (!wstr)
    {
        HeapFree(GetProcessHeap(), 0, str);
        return FALSE;
    }
 
    ret = NtGdiGetCharWidthW( hdc,
                              wstr[0],
                              count,
                              wstr,
                              GCW_NOFLOAT|GCW_WIN32,
                              lpBuffer);
 
    HeapFree(GetProcessHeap(), 0, str);
    HeapFree(GetProcessHeap(), 0, wstr);
 
    return ret;
}

GetCharWidth32W()

BOOL WINAPI GetCharWidth32W	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		LPINT	lpBuffer
	)

Definition at line 762 of file font.c.

{
    DPRINT("GetCharWidths32W\n");
    if ((!lpBuffer) || (iFirstChar > iLastChar) || HIWORD(iLastChar) ||
        (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) || !GdiValidateHandle(hdc))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return NtGdiGetCharWidthW( hdc,
                               iFirstChar,
                               (ULONG)(iLastChar - iFirstChar + 1),
                               NULL,
                               GCW_NOFLOAT|GCW_WIN32,
                               lpBuffer);
}

Referenced by GetCharacterPlacementW().

GetCharWidthA()

BOOL WINAPI GetCharWidthA	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		LPINT	lpBuffer
	)

Definition at line 811 of file font.c.

{
    INT wlen, count = 0;
    LPSTR str;
    LPWSTR wstr;
    BOOL ret = TRUE;
 
    DPRINT("GetCharWidthsA\n");
 
    if (!lpBuffer || (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) || !GdiValidateHandle(hdc))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
    if (!str)
        return FALSE;
 
    wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
    if (!wstr)
    {
        HeapFree(GetProcessHeap(), 0, str);
        return FALSE;
    }
 
    ret = NtGdiGetCharWidthW( hdc,
                              wstr[0],
                              count,
                              wstr,
                              GCW_NOFLOAT,
                              lpBuffer);
 
    HeapFree(GetProcessHeap(), 0, str);
    HeapFree(GetProcessHeap(), 0, wstr);
 
    return ret;
}

GetCharWidthFloatA()

BOOL APIENTRY GetCharWidthFloatA	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		PFLOAT	pxBuffer
	)

Definition at line 907 of file font.c.

{
    INT wlen, count = 0;
    LPSTR str;
    LPWSTR wstr;
    BOOL ret = TRUE;
 
    DPRINT("GetCharWidthsFloatA\n");
 
    if (!pxBuffer || (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) || !GdiValidateHandle(hdc))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
    if (!str)
        return FALSE;
 
    wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
    if (!wstr)
    {
        HeapFree(GetProcessHeap(), 0, str);
        return FALSE;
    }
    ret = NtGdiGetCharWidthW(hdc, wstr[0], count, wstr, 0, pxBuffer);
 
    HeapFree(GetProcessHeap(), 0, str);
    HeapFree(GetProcessHeap(), 0, wstr);
 
    return ret;
}

GetCharWidthFloatW()

BOOL WINAPI GetCharWidthFloatW	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		PFLOAT	pxBuffer
	)

Definition at line 712 of file font.c.

{
    DPRINT("GetCharWidthsFloatW\n");
    if ((!pxBuffer) || (iFirstChar > iLastChar) || HIWORD(iLastChar) ||
        (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) || !GdiValidateHandle(hdc))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return NtGdiGetCharWidthW( hdc,
                               iFirstChar,
                               (ULONG)(iLastChar - iFirstChar + 1),
                               NULL,
                               0,
                               pxBuffer);
}

GetCharWidthI()

BOOL WINAPI GetCharWidthI	(	HDC	hdc,
		UINT	giFirst,
		UINT	cgi,
		LPWORD	pgi,
		LPINT	lpBuffer
	)

Definition at line 1049 of file font.c.

{
    DPRINT("GetCharWidthsI\n");
 
    if (!lpBuffer || (!pgi && HIWORD(giFirst)))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!cgi)
        return TRUE;
 
    return NtGdiGetCharWidthW( hdc,
                               giFirst,
                               cgi,
                               (PWCHAR) pgi,
                               GCW_INDICES|GCW_NOFLOAT|GCW_WIN32,
                               (PVOID) lpBuffer );
}

GetCharWidthW()

BOOL WINAPI GetCharWidthW	(	HDC	hdc,
		UINT	iFirstChar,
		UINT	iLastChar,
		LPINT	lpBuffer
	)

Definition at line 737 of file font.c.

{
    DPRINT("GetCharWidthsW\n");
    if ((!lpBuffer) || (iFirstChar > iLastChar) || HIWORD(iLastChar) ||
        (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) || !GdiValidateHandle(hdc))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return NtGdiGetCharWidthW( hdc,
                               iFirstChar,
                               (ULONG)(iLastChar - iFirstChar + 1),
                               NULL,
                               GCW_NOFLOAT,
                               lpBuffer);
}

GetEUDCTimeStamp()

ULONG WINAPI GetEUDCTimeStamp

(

VOID

)

Definition at line 2724 of file font.c.

{
    return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
}

GetEUDCTimeStampExW()

DWORD WINAPI GetEUDCTimeStampExW

(

LPWSTR

lpBaseFaceName

)

Definition at line 2734 of file font.c.

{
    DWORD retValue = 0;
 
    if (!lpBaseFaceName)
    {
        retValue = NtGdiGetEudcTimeStampEx(NULL,0,FALSE);
    }
    else
    {
        retValue = NtGdiGetEudcTimeStampEx(lpBaseFaceName, wcslen(lpBaseFaceName), FALSE);
    }
 
    return retValue;
}

GetFontAssocStatus()

ULONG WINAPI GetFontAssocStatus

(

HDC

hdc

)

Definition at line 2755 of file font.c.

{
    ULONG retValue = 0;
 
    if (hdc)
    {
        retValue = NtGdiQueryFontAssocInfo(hdc);
    }
 
    return retValue;
}

GetFontData()

DWORD WINAPI GetFontData	(	HDC	hdc,
		DWORD	dwTable,
		DWORD	dwOffset,
		LPVOID	lpvBuffer,
		DWORD	cbData
	)

Definition at line 2796 of file font.c.

{
    if (!lpvBuffer)
    {
        cbData = 0;
    }
    return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
}

Referenced by check_vertical_metrics(), get_first_last_from_cmap(), get_font_metrics(), get_ttf_nametable_entry(), init_script_cache(), load_CMAP_format12_table(), load_gdef_table(), load_gpos_table(), load_gsub_table(), test_fullname2_helper(), and test_text_metrics().

GetFontLanguageInfo()

DWORD WINAPI GetFontLanguageInfo

(

HDC

hDc

)

Definition at line 1079 of file font.c.

{
    DWORD Gcp = 0, Ret = 0;
    if (gbLpk)
    {
        Ret = NtGdiGetTextCharsetInfo(hDc, NULL, 0);
        if ((Ret == ARABIC_CHARSET) || (Ret == HEBREW_CHARSET))
            Ret = (GCP_KASHIDA|GCP_DIACRITIC|GCP_LIGATE|GCP_GLYPHSHAPE|GCP_REORDER);
    }
    Gcp = GetDCDWord(hDc, GdiGetFontLanguageInfo, GCP_ERROR);
    if ( Gcp == GCP_ERROR)
        return Gcp;
    else
        Ret = Gcp | Ret;
    return Ret;
}

GetGlyphIndicesA()

DWORD WINAPI GetGlyphIndicesA	(	HDC	hdc,
		LPCSTR	lpstr,
		INT	count,
		LPWORD	pgi,
		DWORD	flags
	)

Definition at line 1103 of file font.c.

{
    DWORD Ret;
    WCHAR *lpstrW;
    INT countW;
 
    lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
 
    if (lpstrW == NULL)
        return GDI_ERROR;
 
    Ret = NtGdiGetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
    HeapFree(GetProcessHeap(), 0, lpstrW);
    return Ret;
}

GetGlyphOutlineA()

DWORD WINAPI GetGlyphOutlineA	(	HDC	hdc,
		UINT	uChar,
		UINT	uFormat,
		LPGLYPHMETRICS	lpgm,
		DWORD	cbBuffer,
		LPVOID	lpvBuffer,
		CONST MAT2 *	lpmat2
	)

Definition at line 1130 of file font.c.

{
 
    LPWSTR p = NULL;
    DWORD ret;
    UINT c;
    DPRINT("GetGlyphOutlineA uChar %x\n", uChar);
    if (!lpgm || !lpmat2) return GDI_ERROR;
    if(!(uFormat & GGO_GLYPH_INDEX))
    {
        int len;
        char mbchs[2];
        if(uChar > 0xff)   /* but, 2 bytes character only */
        {
            len = 2;
            mbchs[0] = (uChar & 0xff00) >> 8;
            mbchs[1] = (uChar & 0xff);
        }
        else
        {
            len = 1;
            mbchs[0] = (uChar & 0xff);
        }
        p = FONT_mbtowc(hdc, mbchs, len, NULL, NULL);
        if(!p)
            return GDI_ERROR;
        c = p[0];
    }
    else
        c = uChar;
    ret = NtGdiGetGlyphOutline(hdc, c, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
    HeapFree(GetProcessHeap(), 0, p);
    return ret;
}

GetGlyphOutlineW()

DWORD WINAPI GetGlyphOutlineW	(	HDC	hdc,
		UINT	uChar,
		UINT	uFormat,
		LPGLYPHMETRICS	lpgm,
		DWORD	cbBuffer,
		LPVOID	lpvBuffer,
		CONST MAT2 *	lpmat2
	)

Definition at line 1179 of file font.c.

{
    DPRINT("GetGlyphOutlineW uChar %x\n", uChar);
    if (!lpgm || !lpmat2) return GDI_ERROR;
    if (!lpvBuffer) cbBuffer = 0;
    return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
}

GetGlyphOutlineWow()

DWORD WINAPI GetGlyphOutlineWow	(	DWORD	a0,
		DWORD	a1,
		DWORD	a2,
		DWORD	a3,
		DWORD	a4,
		DWORD	a5,
		DWORD	a6
	)

Definition at line 1200 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

GetKerningPairsA()

DWORD WINAPI GetKerningPairsA	(	HDC	hDC,
		DWORD	cPairs,
		LPKERNINGPAIR	kern_pairA
	)

Definition at line 1593 of file font.c.

{
    INT charset;
    CHARSETINFO csi;
    CPINFO cpi;
    DWORD i, total_kern_pairs, kern_pairs_copied = 0;
    KERNINGPAIR *kern_pairW;
 
    if (!cPairs && kern_pairA)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    charset = GetTextCharset(hDC);
    if (!TranslateCharsetInfo(ULongToPtr(charset), &csi, TCI_SRCCHARSET))
    {
        DPRINT1("Can't find codepage for charset %d\n", charset);
        return 0;
    }
    /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
     * to fail on an invalid character for CP_SYMBOL.
     */
    cpi.DefaultChar[0] = 0;
    if (csi.ciACP != CP_SYMBOL && !GetCPInfo(csi.ciACP, &cpi))
    {
        DPRINT1("Can't find codepage %u info\n", csi.ciACP);
        return 0;
    }
    DPRINT("charset %d => codepage %u\n", charset, csi.ciACP);
 
    total_kern_pairs = NtGdiGetKerningPairs(hDC, 0, NULL);
    if (!total_kern_pairs) return 0;
 
    if (!cPairs && !kern_pairA) return total_kern_pairs;
 
    kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
    if (kern_pairW == NULL)
    {
        return 0;
    }
    GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
 
    for (i = 0; i < total_kern_pairs; i++)
    {
        char first, second;
 
        if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
            continue;
 
        if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
            continue;
 
        if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
            continue;
 
        if (kern_pairA)
        {
            if (kern_pairs_copied >= cPairs) break;
 
            kern_pairA->wFirst = (BYTE)first;
            kern_pairA->wSecond = (BYTE)second;
            kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
            kern_pairA++;
        }
        kern_pairs_copied++;
    }
 
    HeapFree(GetProcessHeap(), 0, kern_pairW);
 
    return kern_pairs_copied;
}

GetKerningPairsW()

DWORD WINAPI GetKerningPairsW	(	HDC	hdc,
		ULONG	cPairs,
		LPKERNINGPAIR	pkpDst
	)

Definition at line 1573 of file font.c.

{
    if ((cPairs != 0) || (pkpDst == 0))
    {
        return NtGdiGetKerningPairs(hdc,cPairs,pkpDst);
    }
    else
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
}

GetOutlineTextMetricsA()

UINT APIENTRY GetOutlineTextMetricsA	(	HDC	hdc,
		UINT	cbData,
		LPOUTLINETEXTMETRICA	lpOTM
	)

Definition at line 1220 of file font.c.

{
    char buf[512], *ptr;
    UINT ret, needed;
    OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
    OUTLINETEXTMETRICA *output = lpOTM;
    INT left, len;
 
    if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
        return 0;
    if(ret > sizeof(buf))
    {
        lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
        if (lpOTMW == NULL)
        {
            return 0;
        }
    }
    GetOutlineTextMetricsW(hdc, ret, lpOTMW);
 
    needed = sizeof(OUTLINETEXTMETRICA);
    if(lpOTMW->otmpFamilyName)
        needed += WideCharToMultiByte(CP_ACP, 0,
                                      (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFamilyName), -1,
                                      NULL, 0, NULL, NULL);
    if(lpOTMW->otmpFaceName)
        needed += WideCharToMultiByte(CP_ACP, 0,
                                      (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFaceName), -1,
                                      NULL, 0, NULL, NULL);
    if(lpOTMW->otmpStyleName)
        needed += WideCharToMultiByte(CP_ACP, 0,
                                      (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpStyleName), -1,
                                      NULL, 0, NULL, NULL);
    if(lpOTMW->otmpFullName)
        needed += WideCharToMultiByte(CP_ACP, 0,
                                      (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFullName), -1,
                                      NULL, 0, NULL, NULL);
 
    if(!lpOTM)
    {
        ret = needed;
        goto end;
    }
 
    DPRINT("needed = %u\n", needed);
    if(needed > cbData)
    {
        /* Since the supplied buffer isn't big enough, we'll alloc one
           that is and memcpy the first cbData bytes into the lpOTM at
           the end. */
        output = HeapAlloc(GetProcessHeap(), 0, needed);
        if (output == NULL)
        {
            goto end;
        }
    }
 
    ret = output->otmSize = min(needed, cbData);
    FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
    output->otmFiller = 0;
    output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
    output->otmfsSelection = lpOTMW->otmfsSelection;
    output->otmfsType = lpOTMW->otmfsType;
    output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
    output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
    output->otmItalicAngle = lpOTMW->otmItalicAngle;
    output->otmEMSquare = lpOTMW->otmEMSquare;
    output->otmAscent = lpOTMW->otmAscent;
    output->otmDescent = lpOTMW->otmDescent;
    output->otmLineGap = lpOTMW->otmLineGap;
    output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
    output->otmsXHeight = lpOTMW->otmsXHeight;
    output->otmrcFontBox = lpOTMW->otmrcFontBox;
    output->otmMacAscent = lpOTMW->otmMacAscent;
    output->otmMacDescent = lpOTMW->otmMacDescent;
    output->otmMacLineGap = lpOTMW->otmMacLineGap;
    output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
    output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
    output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
    output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
    output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
    output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
    output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
    output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
    output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
 
 
    ptr = (char*)(output + 1);
    left = needed - sizeof(*output);
 
    if(lpOTMW->otmpFamilyName)
    {
        output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
        len = WideCharToMultiByte(CP_ACP, 0,
                                  (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFamilyName), -1,
                                  ptr, left, NULL, NULL);
        left -= len;
        ptr += len;
    }
    else
        output->otmpFamilyName = 0;
 
    if(lpOTMW->otmpFaceName)
    {
        output->otmpFaceName = (LPSTR)(ptr - (char*)output);
        len = WideCharToMultiByte(CP_ACP, 0,
                                  (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFaceName), -1,
                                  ptr, left, NULL, NULL);
        left -= len;
        ptr += len;
    }
    else
        output->otmpFaceName = 0;
 
    if(lpOTMW->otmpStyleName)
    {
        output->otmpStyleName = (LPSTR)(ptr - (char*)output);
        len = WideCharToMultiByte(CP_ACP, 0,
                                  (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpStyleName), -1,
                                  ptr, left, NULL, NULL);
        left -= len;
        ptr += len;
    }
    else
        output->otmpStyleName = 0;
 
    if(lpOTMW->otmpFullName)
    {
        output->otmpFullName = (LPSTR)(ptr - (char*)output);
        len = WideCharToMultiByte(CP_ACP, 0,
                                  (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFullName), -1,
                                  ptr, left, NULL, NULL);
        left -= len;
    }
    else
        output->otmpFullName = 0;
 
    ASSERT(left == 0);
 
    if(output != lpOTM)
    {
        memcpy(lpOTM, output, cbData);
        HeapFree(GetProcessHeap(), 0, output);
 
        /* check if the string offsets really fit into the provided size */
        /* FIXME: should we check string length as well? */
        if ((UINT_PTR)lpOTM->otmpFamilyName >= lpOTM->otmSize)
            lpOTM->otmpFamilyName = 0; /* doesn't fit */
 
        if ((UINT_PTR)lpOTM->otmpFaceName >= lpOTM->otmSize)
            lpOTM->otmpFaceName = 0; /* doesn't fit */
 
        if ((UINT_PTR)lpOTM->otmpStyleName >= lpOTM->otmSize)
            lpOTM->otmpStyleName = 0; /* doesn't fit */
 
        if ((UINT_PTR)lpOTM->otmpFullName >= lpOTM->otmSize)
            lpOTM->otmpFullName = 0; /* doesn't fit */
    }
 
end:
    if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
        HeapFree(GetProcessHeap(), 0, lpOTMW);
 
    return ret;
}

GetOutlineTextMetricsW()

UINT APIENTRY GetOutlineTextMetricsW	(	HDC	hdc,
		UINT	cbData,
		LPOUTLINETEXTMETRICW	lpOTM
	)

Definition at line 1419 of file font.c.

{
    TMDIFF Tmd;   // Should not be zero.
    UINT Size, AvailableSize = 0, StringSize;
    XFORM DevToWorld;
    OUTLINETEXTMETRICW* LocalOTM;
    WCHAR* Str;
    BYTE* Ptr;
 
    /* Get the structure */
    Size = NtGdiGetOutlineTextMetricsInternalW(hdc, 0, NULL, &Tmd);
    if (!Size)
        return 0;
    if (!lpOTM || (cbData < sizeof(*lpOTM)))
        return Size;
 
    LocalOTM = HeapAlloc(GetProcessHeap(), 0, Size);
    LocalOTM->otmSize = Size;
    Size = NtGdiGetOutlineTextMetricsInternalW(hdc, Size, LocalOTM, &Tmd);
    if (!Size)
    {
        HeapFree(GetProcessHeap(), 0, LocalOTM);
        return 0;
    }
 
    if (!NtGdiGetTransform(hdc, GdiDeviceSpaceToWorldSpace, &DevToWorld))
    {
        DPRINT1("NtGdiGetTransform failed!\n");
        HeapFree(GetProcessHeap(), 0, LocalOTM);
        SetLastError(ERROR_INVALID_HANDLE);
        return 0;
    }
 
    /* Fill in DC specific data */
    LocalOTM->otmTextMetrics.tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
    LocalOTM->otmTextMetrics.tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
    LocalOTM->otmTextMetrics.tmHeight = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmHeight );
    LocalOTM->otmTextMetrics.tmAscent = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmAscent );
    LocalOTM->otmTextMetrics.tmDescent = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmDescent );
    LocalOTM->otmTextMetrics.tmInternalLeading = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmInternalLeading );
    LocalOTM->otmTextMetrics.tmExternalLeading = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmExternalLeading );
    LocalOTM->otmTextMetrics.tmAveCharWidth = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmAveCharWidth );
    LocalOTM->otmTextMetrics.tmMaxCharWidth = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmMaxCharWidth );
    LocalOTM->otmTextMetrics.tmOverhang = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmOverhang );
    LocalOTM->otmAscent                = height_to_LP( &DevToWorld, LocalOTM->otmAscent);
    LocalOTM->otmDescent               = height_to_LP( &DevToWorld, LocalOTM->otmDescent);
    LocalOTM->otmLineGap               = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmLineGap));
    LocalOTM->otmsCapEmHeight          = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsCapEmHeight));
    LocalOTM->otmsXHeight              = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsXHeight));
    LocalOTM->otmrcFontBox.top         = height_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.top);
    LocalOTM->otmrcFontBox.bottom      = height_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.bottom);
    LocalOTM->otmrcFontBox.left        = width_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.left);
    LocalOTM->otmrcFontBox.right       = width_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.right);
    LocalOTM->otmMacAscent             = height_to_LP( &DevToWorld, LocalOTM->otmMacAscent);
    LocalOTM->otmMacDescent            = height_to_LP( &DevToWorld, LocalOTM->otmMacDescent);
    LocalOTM->otmMacLineGap            = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmMacLineGap));
    LocalOTM->otmptSubscriptSize.x     = width_to_LP( &DevToWorld, LocalOTM->otmptSubscriptSize.x);
    LocalOTM->otmptSubscriptSize.y     = height_to_LP( &DevToWorld, LocalOTM->otmptSubscriptSize.y);
    LocalOTM->otmptSubscriptOffset.x   = width_to_LP( &DevToWorld, LocalOTM->otmptSubscriptOffset.x);
    LocalOTM->otmptSubscriptOffset.y   = height_to_LP( &DevToWorld, LocalOTM->otmptSubscriptOffset.y);
    LocalOTM->otmptSuperscriptSize.x   = width_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptSize.x);
    LocalOTM->otmptSuperscriptSize.y   = height_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptSize.y);
    LocalOTM->otmptSuperscriptOffset.x = width_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptOffset.x);
    LocalOTM->otmptSuperscriptOffset.y = height_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptOffset.y);
    LocalOTM->otmsStrikeoutSize        = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsStrikeoutSize));
    LocalOTM->otmsStrikeoutPosition    = height_to_LP( &DevToWorld, LocalOTM->otmsStrikeoutPosition);
    LocalOTM->otmsUnderscoreSize       = height_to_LP( &DevToWorld, LocalOTM->otmsUnderscoreSize);
    LocalOTM->otmsUnderscorePosition   = height_to_LP( &DevToWorld, LocalOTM->otmsUnderscorePosition);
 
    /* Copy what we can */
    CopyMemory(lpOTM, LocalOTM, min(Size, cbData));
 
    lpOTM->otmpFamilyName = NULL;
    lpOTM->otmpFaceName = NULL;
    lpOTM->otmpStyleName = NULL;
    lpOTM->otmpFullName = NULL;
 
    Size = sizeof(*lpOTM);
    AvailableSize = cbData - Size;
    Ptr = (BYTE*)lpOTM + sizeof(*lpOTM);
 
    /* Fix string values up */
    if (LocalOTM->otmpFamilyName)
    {
        Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFamilyName);
        StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
        if (AvailableSize >= StringSize)
        {
            CopyMemory(Ptr, Str, StringSize);
            lpOTM->otmpFamilyName = (PSTR)(Ptr - (BYTE*)lpOTM);
            Ptr += StringSize;
            AvailableSize -= StringSize;
            Size += StringSize;
        }
    }
 
    if (LocalOTM->otmpFaceName)
    {
        Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFaceName);
        StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
        if (AvailableSize >= StringSize)
        {
            CopyMemory(Ptr, Str, StringSize);
            lpOTM->otmpFaceName = (PSTR)(Ptr - (BYTE*)lpOTM);
            Ptr += StringSize;
            AvailableSize -= StringSize;
            Size += StringSize;
        }
    }
 
    if (LocalOTM->otmpStyleName)
    {
        Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpStyleName);
        StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
        if (AvailableSize >= StringSize)
        {
            CopyMemory(Ptr, Str, StringSize);
            lpOTM->otmpStyleName = (PSTR)(Ptr - (BYTE*)lpOTM);
            Ptr += StringSize;
            AvailableSize -= StringSize;
            Size += StringSize;
        }
    }
 
    if (LocalOTM->otmpFullName)
    {
        Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFullName);
        StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
        if (AvailableSize >= StringSize)
        {
            CopyMemory(Ptr, Str, StringSize);
            lpOTM->otmpFullName = (PSTR)(Ptr - (BYTE*)lpOTM);
            Ptr += StringSize;
            AvailableSize -= StringSize;
            Size += StringSize;
        }
    }
 
    lpOTM->otmSize = Size;
 
    HeapFree(GetProcessHeap(), 0, LocalOTM);
 
    return Size;
}

height_to_LP()

static INT height_to_LP ( XFORM *  xForm, INT  height  )

inlinestatic

Definition at line 1409 of file font.c.

{
    return GDI_ROUND( (double)height * fabs( xForm->eM22 ));
}

Referenced by GetOutlineTextMetricsW().

IntConvertFontPaths()

PWSTR FASTCALL IntConvertFontPaths	(	_In_ PCWSTR	pszFiles,
		_Out_ PDWORD	pcFiles,
		_Out_ PDWORD	pcwc,
		_Inout_ PDWORD	pfl,
		_In_ BOOL	bFlag
	)

Definition at line 1963 of file font.c.

{
    // FIXME: pfl
    // FIXME: bFlag
 
    *pcwc = *pcFiles = 0;
 
    if (!*pszFiles)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    // Build "Fonts" path
    WCHAR szFontsDir[MAX_PATH];
    GetWindowsDirectoryW(szFontsDir, _countof(szFontsDir));
    StringCchCatW(szFontsDir, _countof(szFontsDir), L"\\Fonts");
 
    // Count the number of paths separated by '|'.
    ULONG pathCount = 1;
    for (PCWSTR pch1 = pszFiles; *pch1; ++pch1)
    {
        if (*pch1 == L'|')
            pathCount++;
    }
 
    // Allocate memory for the paths.
    SIZE_T cchBuff = pathCount * MAX_PATH;
    PWSTR pszBuff = HEAP_alloc(cchBuff * sizeof(WCHAR));
    if (!pszBuff)
        return NULL;
 
    pszBuff[0] = UNICODE_NULL;
    *pcFiles = pathCount;
 
    // Convert paths
    DWORD dwError = ERROR_SUCCESS;
    PCWSTR pch1, pch1Prev;
    BOOL bFirst = TRUE;
    for (pch1 = pch1Prev = pszFiles;; ++pch1)
    {
        if (*pch1 && *pch1 != L'|')
            continue;
 
        UINT_PTR spanLen = pch1 - pch1Prev;
        if (spanLen < _countof(L".ttf") || spanLen >= MAX_PATH)
        {
            dwError = ERROR_INVALID_FUNCTION;
            break;
        }
 
        WCHAR szFileName[MAX_PATH], szFullPath[MAX_PATH];
        StringCchCopyNW(szFileName, _countof(szFileName), pch1Prev, spanLen);
 
        // Search file
        if (!SearchPathW(L".", szFileName, NULL, _countof(szFullPath), szFullPath, NULL) &&
            !SearchPathW(szFontsDir, szFileName, NULL, _countof(szFullPath), szFullPath, NULL))
        {
            dwError = ERROR_FILE_NOT_FOUND;
            break;
        }
 
        if (bFirst)
        {
            bFirst = FALSE;
        }
        else
        {
            SIZE_T cch = wcslen(szFullPath);
            if (cch < _countof(L".pfb"))
            {
                dwError = ERROR_INVALID_FUNCTION;
                break;
            }
 
            // Check filename extension
            PCWSTR pchDotExt = &szFullPath[cch - 4];
            if (_wcsicmp(pchDotExt, L".pfb") != 0 &&
                _wcsicmp(pchDotExt, L".mmm") != 0)
            {
                dwError = ERROR_INVALID_FUNCTION;
                break;
            }
        }
 
        // Convert to an NT path
        UNICODE_STRING NtAbsPath;
        if (!RtlDosPathNameToNtPathName_U(szFullPath, &NtAbsPath, NULL, NULL))
        {
            dwError = ERROR_OUTOFMEMORY;
            break;
        }
 
        // Append a path and '|' to pszBuff
        if (StringCchCatW(pszBuff, cchBuff, NtAbsPath.Buffer) != S_OK ||
            StringCchCatW(pszBuff, cchBuff, L"|") != S_OK)
        {
            RtlFreeUnicodeString(&NtAbsPath);
            dwError = ERROR_INVALID_FUNCTION;
            break;
        }
 
        RtlFreeUnicodeString(&NtAbsPath);
 
        if (!*pch1)
            break;
 
        pch1Prev = pch1 + 1;
    }
 
    if (dwError != ERROR_SUCCESS)
    {
        HEAP_free(pszBuff);
        *pcwc = *pcFiles = 0;
        if (dwError != ERROR_INVALID_FUNCTION)
            SetLastError(dwError);
        return NULL;
    }
 
    *pcwc = (DWORD)wcslen(pszBuff);
 
    // Convert '|' to '\0'
    for (PWSTR pch2 = pszBuff; *pch2; ++pch2)
    {
        if (*pch2 == L'|')
            *pch2 = UNICODE_NULL;
    }
 
    return pszBuff;
}

Referenced by GdiAddFontResourceW(), and RemoveFontResourceExW().

IntEnumFontFamilies()

static int FASTCALL IntEnumFontFamilies ( HDC  Dc, const LOGFONTW *  LogFont, PVOID  EnumProc, LPARAM  lParam, DWORD  dwFlags  )

static

Definition at line 290 of file font.c.

{
    int FontFamilyCount;
    PFONTFAMILYINFO Info;
    int Ret = 1;
    int i;
    ENUMLOGFONTEXA EnumLogFontExA;
    NEWTEXTMETRICEXA NewTextMetricExA;
    LOGFONTW lfW;
    LONG InfoCount;
    ULONG DataSize;
    NTSTATUS Status;
 
    DataSize = INITIAL_FAMILY_COUNT * sizeof(FONTFAMILYINFO);
    Info = RtlAllocateHeap(GetProcessHeap(), 0, DataSize);
    if (Info == NULL)
    {
        return 1;
    }
 
    /* Initialize the LOGFONT structure */
    ZeroMemory(&lfW, sizeof(lfW));
    if (!LogFont)
    {
        lfW.lfCharSet = DEFAULT_CHARSET;
    }
    else
    {
        lfW.lfCharSet = LogFont->lfCharSet;
        lfW.lfPitchAndFamily = LogFont->lfPitchAndFamily;
        StringCbCopyW(lfW.lfFaceName, sizeof(lfW.lfFaceName), LogFont->lfFaceName);
    }
 
    /* Retrieve the font information */
    InfoCount = INITIAL_FAMILY_COUNT;
    FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, &lfW, Info, &InfoCount);
    if (FontFamilyCount < 0)
    {
        RtlFreeHeap(GetProcessHeap(), 0, Info);
        return 1;
    }
 
    /* Resize the buffer if the buffer is too small */
    if (INITIAL_FAMILY_COUNT < InfoCount)
    {
        RtlFreeHeap(GetProcessHeap(), 0, Info);
 
        Status = RtlULongMult(InfoCount, sizeof(FONTFAMILYINFO), &DataSize);
        if (!NT_SUCCESS(Status) || DataSize > LONG_MAX)
        {
            DPRINT1("Overflowed.\n");
            return 1;
        }
        Info = RtlAllocateHeap(GetProcessHeap(), 0, DataSize);
        if (Info == NULL)
        {
            return 1;
        }
        FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, &lfW, Info, &InfoCount);
        if (FontFamilyCount < 0 || FontFamilyCount < InfoCount)
        {
            RtlFreeHeap(GetProcessHeap(), 0, Info);
            return 1;
        }
    }
 
    /* Sort and remove redundant information */
    qsort(Info, FontFamilyCount, sizeof(*Info), IntFontFamilyCompare);
    FontFamilyCount = IntFontFamilyListUnique(Info, FontFamilyCount, &lfW, dwFlags);
 
    /* call the callback */
    for (i = 0; i < FontFamilyCount; i++)
    {
        if (dwFlags & IEFF_UNICODE)
        {
            Ret = ((FONTENUMPROCW) EnumProc)(
                      (VOID*)&Info[i].EnumLogFontEx,
                      (VOID*)&Info[i].NewTextMetricEx,
                      Info[i].FontType, lParam);
        }
        else
        {
            // Could use EnumLogFontExW2A here?
            LogFontW2A(&EnumLogFontExA.elfLogFont, &Info[i].EnumLogFontEx.elfLogFont);
            WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfFullName, -1,
                                (LPSTR)EnumLogFontExA.elfFullName, LF_FULLFACESIZE, NULL, NULL);
            WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfStyle, -1,
                                (LPSTR)EnumLogFontExA.elfStyle, LF_FACESIZE, NULL, NULL);
            WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfScript, -1,
                                (LPSTR)EnumLogFontExA.elfScript, LF_FACESIZE, NULL, NULL);
            NewTextMetricExW2A(&NewTextMetricExA,
                               &Info[i].NewTextMetricEx);
            Ret = ((FONTENUMPROCA) EnumProc)(
                      (VOID*)&EnumLogFontExA,
                      (VOID*)&NewTextMetricExA,
                      Info[i].FontType, lParam);
        }
 
        if(Ret == 0)
            break;
    }
 
    RtlFreeHeap(GetProcessHeap(), 0, Info);
 
    return Ret;
}

Referenced by EnumFontFamiliesA(), EnumFontFamiliesExA(), EnumFontFamiliesExW(), and EnumFontFamiliesW().

INTERNAL_YDSTOWS()

static INT INTERNAL_YDSTOWS ( XFORM *  xForm, INT  height  )

inlinestatic

Definition at line 1393 of file font.c.

{
    double floatHeight;
 
    /* Perform operation with floating point */
    floatHeight = (double)height * xForm->eM22;
    /* Round to integers */
    return GDI_ROUND(floatHeight);
}

Referenced by GetOutlineTextMetricsW().

IntFontFamilyCompare()

static int __cdecl IntFontFamilyCompare ( const void *  ffi1, const void *  ffi2  )

static

Definition at line 247 of file font.c.

{
    return IntFontFamilyCompareEx(ffi1, ffi2, IFFCX_STYLE | IFFCX_CHARSET);
}

Referenced by IntEnumFontFamilies().

IntFontFamilyCompareEx()

FORCEINLINE int FASTCALL IntFontFamilyCompareEx	(	const FONTFAMILYINFO *	ffi1,
		const FONTFAMILYINFO *	ffi2,
		DWORD	dwCompareFlags
	)

Definition at line 214 of file font.c.

{
    const LOGFONTW *plf1 = &ffi1->EnumLogFontEx.elfLogFont;
    const LOGFONTW *plf2 = &ffi2->EnumLogFontEx.elfLogFont;
    ULONG WeightDiff1, WeightDiff2;
    int cmp = _wcsicmp(plf1->lfFaceName, plf2->lfFaceName);
    if (cmp)
        return cmp;
    if (dwCompareFlags & IFFCX_CHARSET)
    {
        if (plf1->lfCharSet < plf2->lfCharSet)
            return -1;
        if (plf1->lfCharSet > plf2->lfCharSet)
            return 1;
    }
    if (dwCompareFlags & IFFCX_STYLE)
    {
        WeightDiff1 = labs(plf1->lfWeight - FW_NORMAL);
        WeightDiff2 = labs(plf2->lfWeight - FW_NORMAL);
        if (WeightDiff1 < WeightDiff2)
            return -1;
        if (WeightDiff1 > WeightDiff2)
            return 1;
        if (plf1->lfItalic < plf2->lfItalic)
            return -1;
        if (plf1->lfItalic > plf2->lfItalic)
            return 1;
    }
    return 0;
}

Referenced by IntFontFamilyCompare(), and IntFontFamilyListUnique().

IntFontFamilyListUnique()

int FASTCALL IntFontFamilyListUnique	(	FONTFAMILYINFO *	InfoList,
		INT	nCount,
		const LOGFONTW *	plf,
		DWORD	dwFlags
	)

Definition at line 257 of file font.c.

{
    FONTFAMILYINFO *first, *last, *result;
    DWORD dwCompareFlags = 0;
 
    if (plf->lfFaceName[0])
        dwCompareFlags |= IFFCX_STYLE;
 
    if ((dwFlags & IEFF_EXTENDED) && plf->lfCharSet == DEFAULT_CHARSET)
        dwCompareFlags |= IFFCX_CHARSET;
 
    first = InfoList;
    last = &InfoList[nCount];
 
    /* std::unique(first, last, IntFontFamilyCompareEx); */
    if (first == last)
        return 0;
 
    result = first;
    while (++first != last)
    {
        if (IntFontFamilyCompareEx(result, first, dwCompareFlags) != 0)
        {
            *(++result) = *first;
        }
    }
    nCount = (int)(++result - InfoList);
 
    return nCount;
}

Referenced by IntEnumFontFamilies().

NewEnumFontFamiliesExW()

INT WINAPI NewEnumFontFamiliesExW	(	HDC	hDC,
		LPLOGFONTW	lpLogfont,
		FONTENUMPROCW	lpEnumFontFamExProcW,
		LPARAM	lParam,
		DWORD	dwFlags
	)

Definition at line 2490 of file font.c.

{
    ULONG_PTR idEnum;
    ULONG cbDataSize, cbRetSize;
    PENUMFONTDATAW pEfdw;
    PBYTE pBuffer;
    PBYTE pMax;
    INT ret = 1;
 
    /* Open enumeration handle and find out how much memory we need */
    idEnum = NtGdiEnumFontOpen(hDC,
                               EfdFontFamilies,
                               0,
                               LF_FACESIZE,
                               (lpLogfont && lpLogfont->lfFaceName[0])? lpLogfont->lfFaceName : NULL,
                               lpLogfont? lpLogfont->lfCharSet : DEFAULT_CHARSET,
                               &cbDataSize);
    if (idEnum == 0)
    {
        return 0;
    }
    if (cbDataSize == 0)
    {
        NtGdiEnumFontClose(idEnum);
        return 0;
    }
 
    /* Allocate memory */
    pBuffer = HeapAlloc(GetProcessHeap(), 0, cbDataSize);
    if (pBuffer == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        NtGdiEnumFontClose(idEnum);
        return 0;
    }
 
    /* Do the enumeration */
    if (!NtGdiEnumFontChunk(hDC, idEnum, cbDataSize, &cbRetSize, (PVOID)pBuffer))
    {
        HeapFree(GetProcessHeap(), 0, pBuffer);
        NtGdiEnumFontClose(idEnum);
        return 0;
    }
 
    /* Get start and end address */
    pEfdw = (PENUMFONTDATAW)pBuffer;
    pMax = pBuffer + cbDataSize;
 
    /* Iterate through the structures */
    while ((PBYTE)pEfdw < pMax && ret)
    {
        PNTMW_INTERNAL pNtmwi = (PNTMW_INTERNAL)((ULONG_PTR)pEfdw + pEfdw->ulNtmwiOffset);
 
        ret = lpEnumFontFamExProcW((VOID*)&pEfdw->elfexdv.elfEnumLogfontEx,
                                   (VOID*)&pNtmwi->ntmw,
                                   pEfdw->dwFontType,
                                   lParam);
 
        pEfdw = (PENUMFONTDATAW)((ULONG_PTR)pEfdw + pEfdw->cbSize);
    }
 
    /* Release the memory and close handle */
    HeapFree(GetProcessHeap(), 0, pBuffer);
    NtGdiEnumFontClose(idEnum);
 
    return ret;
}

NewGetCharacterPlacementW()

DWORD WINAPI NewGetCharacterPlacementW	(	HDC	hdc,
		LPCWSTR	lpString,
		INT	uCount,
		INT	nMaxExtent,
		GCP_RESULTSW *	lpResults,
		DWORD	dwFlags
	)

Definition at line 643 of file font.c.

{
    ULONG nSet;
    SIZE Size = {0,0};
 
    if ( !lpString || uCount <= 0 || (nMaxExtent < 0 && nMaxExtent != -1 ) )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if ( !lpResults )
    {
        if ( GetTextExtentPointW(hdc, lpString, uCount, &Size) )
        {
            return MAKELONG(Size.cx, Size.cy);
        }
        return 0;
    }
 
    nSet = uCount;
    if ( nSet > lpResults->nGlyphs )
        nSet = lpResults->nGlyphs;
 
    return NtGdiGetCharacterPlacementW( hdc,
                                        lpString,
                                        nSet,
                                        nMaxExtent,
                                        lpResults,
                                        dwFlags);
}

NewTextMetricExW2A()

VOID FASTCALL NewTextMetricExW2A	(	NEWTEXTMETRICEXA *	tma,
		NEWTEXTMETRICEXW *	tmw
	)

Definition at line 203 of file font.c.

{
    NewTextMetricW2A(&tma->ntmTm, &tmw->ntmTm);
    tma->ntmFontSig = tmw->ntmFontSig;
}

Referenced by IntEnumFontFamilies().

NewTextMetricW2A()

VOID FASTCALL NewTextMetricW2A	(	NEWTEXTMETRICA *	tma,
		NEWTEXTMETRICW *	tmw
	)

Definition at line 193 of file font.c.

{
    FONT_TextMetricWToA((TEXTMETRICW *) tmw, (TEXTMETRICA *) tma);
    tma->ntmFlags = tmw->ntmFlags;
    tma->ntmSizeEM = tmw->ntmSizeEM;
    tma->ntmCellHeight = tmw->ntmCellHeight;
    tma->ntmAvgWidth = tmw->ntmAvgWidth;
}

Referenced by NewTextMetricExW2A().

QueryFontAssocStatus()

DWORD WINAPI QueryFontAssocStatus

(

VOID

)

Definition at line 2772 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

RemoveFontMemResourceEx()

BOOL WINAPI RemoveFontMemResourceEx

(

HANDLE

fh

)

Definition at line 2617 of file font.c.

{
    if (fh)
    {
        return NtGdiRemoveFontMemResourceEx(fh);
    }
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}

Referenced by START_TEST().

RemoveFontResourceA()

BOOL WINAPI RemoveFontResourceA

(

_In_ LPCSTR

lpFileName

)

Definition at line 2199 of file font.c.

{
    return RemoveFontResourceExA(lpFileName, 0, NULL);
}

Referenced by Test_AddFontResourceA().

RemoveFontResourceExA()

BOOL WINAPI RemoveFontResourceExA	(	_In_ LPCSTR	lpFileName,
		_In_ DWORD	fl,
		_In_opt_ PVOID	pdv
	)

Definition at line 2207 of file font.c.

{
    if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!lpFileName)
        return FALSE;
 
    WCHAR szBuff[MAX_PATH];
    PWSTR FilenameW;
 
    _SEH2_TRY
    {
        FilenameW = HEAP_strdupA2W_buf(lpFileName, szBuff, _countof(szBuff));
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        FilenameW = NULL;
    }
    _SEH2_END;
 
    if (!FilenameW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    BOOL result = RemoveFontResourceExW(FilenameW, fl, pdv);
    HEAP_strdupA2W_buf_free(FilenameW, szBuff);
    return result;
}

Referenced by RemoveFontResourceA(), and test_long_names().

RemoveFontResourceExW()

BOOL WINAPI RemoveFontResourceExW	(	_In_ LPCWSTR	lpFileName,
		_In_ DWORD	fl,
		_In_opt_ PVOID	pdv
	)

Definition at line 2248 of file font.c.

{
    DPRINT("RemoveFontResourceExW\n");
 
    if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!lpFileName)
        return FALSE;
 
    ULONG cFiles, cwc;
    PWSTR pszConverted = IntConvertFontPaths(lpFileName, &cFiles, &cwc, &fl, TRUE);
    if (!pszConverted)
        return FALSE;
 
    BOOL ret = NtGdiRemoveFontResourceW(pszConverted, cwc, cFiles, fl, 0, NULL);
    HEAP_free(pszConverted);
    return ret;
}

Referenced by DeleteFontFiles(), DoInstallFontFile(), RemoveFontResourceExA(), RemoveFontResourceW(), and RemoveTempFont().

RemoveFontResourceTracking()

int WINAPI RemoveFontResourceTracking	(	LPCSTR	lpString,
		int	unknown
	)

Definition at line 2648 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

RemoveFontResourceW()

BOOL WINAPI RemoveFontResourceW

(

_In_ LPCWSTR

lpFileName

)

Definition at line 2191 of file font.c.

{
    return RemoveFontResourceExW(lpFileName, 0, NULL);
}

Referenced by DeleteFontFiles(), DoEntry(), DoInstallFontFile(), and wWinMain().

SetMapperFlags()

DWORD WINAPI SetMapperFlags	(	HDC	hDC,
		DWORD	flags
	)

Definition at line 2399 of file font.c.

{
    DWORD Ret = GDI_ERROR;
    PDC_ATTR Dc_Attr;
 
    /* Get the DC attribute */
    Dc_Attr = GdiGetDcAttr(hDC);
    if (Dc_Attr == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return GDI_ERROR;
    }
 
    if (NtCurrentTeb()->GdiTebBatch.HDC == hDC)
    {
        if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY)
        {
            NtGdiFlush();
            Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
        }
    }
 
    if ( flags & ~1 )
        SetLastError(ERROR_INVALID_PARAMETER);
    else
    {
        Ret = Dc_Attr->flFontMapper;
        Dc_Attr->flFontMapper = flags;
    }
    return Ret;
}

TranslateCharsetInfo()

BOOL WINAPI TranslateCharsetInfo	(	LPDWORD	lpSrc,
		LPCHARSETINFO	lpCs,
		DWORD	flags
	)

Definition at line 2350 of file font.c.

{
    int index = 0;
    switch (flags)
    {
    case TCI_SRCFONTSIG:
        while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++;
        break;
    case TCI_SRCCODEPAGE:
        while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++;
        break;
    case TCI_SRCCHARSET:
        while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++;
        break;
    case TCI_SRCLOCALE:
    {
        LCID lCid = (LCID)PtrToUlong(lpSrc);
        LOCALESIGNATURE LocSig;
        INT Ret = GetLocaleInfoW(lCid, LOCALE_FONTSIGNATURE, (LPWSTR)&LocSig, 0);
        if ( GetLocaleInfoW(lCid, LOCALE_FONTSIGNATURE, (LPWSTR)&LocSig, Ret))
        {
           while (index < MAXTCIINDEX && !(LocSig.lsCsbDefault[0]>>index & 0x0001)) index++;
           break;
        }
    }
    default:
        GdiSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
    DPRINT("Index %d Charset %u CodePage %u FontSig %lu\n",
             index,FONT_tci[index].ciCharset,FONT_tci[index].ciACP,FONT_tci[index].fs.fsCsb[0]);
    memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
    return TRUE;
}

UnloadNetworkFonts()

VOID WINAPI UnloadNetworkFonts

(

DWORD

unknown

)

Definition at line 2784 of file font.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
}

width_to_LP()

static INT width_to_LP ( XFORM *  xForm, INT  width  )

inlinestatic

Definition at line 1404 of file font.c.

{
    return GDI_ROUND( (double)width * fabs( xForm->eM11));
}

Referenced by GetOutlineTextMetricsW().

Variable Documentation

FONT_tci

const CHARSETINFO FONT_tci[MAXTCIINDEX]

static

Definition at line 33 of file font.c.

Referenced by TranslateCharsetInfo().