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)
BOOL WINAPI	CreateScalableFontResourceA (DWORD fdwHidden, LPCSTR lpszFontRes, LPCSTR lpszFontFile, LPCSTR lpszCurrentPath)
int WINAPI	AddFontResourceExW (LPCWSTR lpszFilename, DWORD fl, PVOID pvReserved)
int WINAPI	AddFontResourceExA (LPCSTR lpszFilename, DWORD fl, PVOID pvReserved)
int WINAPI	AddFontResourceA (LPCSTR lpszFilename)
int WINAPI	AddFontResourceW (LPCWSTR lpszFilename)
BOOL WINAPI	RemoveFontResourceW (LPCWSTR lpFileName)
BOOL WINAPI	RemoveFontResourceA (LPCSTR lpFileName)
BOOL WINAPI	RemoveFontResourceExA (LPCSTR lpFileName, DWORD fl, PVOID pdv)
BOOL WINAPI	RemoveFontResourceExW (LPCWSTR lpFileName, DWORD fl, 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 2322 of file font.c.

IEFF_EXTENDED

#define IEFF_EXTENDED   2

Definition at line 252 of file font.c.

IEFF_UNICODE

#define IEFF_UNICODE   1

Definition at line 251 of file font.c.

IFFCX_CHARSET

#define IFFCX_CHARSET   1

Definition at line 208 of file font.c.

IFFCX_STYLE

#define IFFCX_STYLE   2

Definition at line 209 of file font.c.

INITIAL_FAMILY_COUNT

#define INITIAL_FAMILY_COUNT   64

Definition at line 72 of file font.c.

MAXTCIINDEX

#define MAXTCIINDEX   32

Definition at line 30 of file font.c.

NDEBUG

#define NDEBUG

Definition at line 15 of file font.c.

Function Documentation

AddFontMemResourceEx()

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

Definition at line 2455 of file font.c.

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

Referenced by GdipPrivateAddMemoryFont().

AddFontResourceA()

int WINAPI AddFontResourceA

(

LPCSTR

lpszFilename

)

Definition at line 2011 of file font.c.

{
    NTSTATUS Status;
    PWSTR FilenameW;
    int rc = 0;

    Status = HEAP_strdupA2W ( &FilenameW, lpszFilename );
    if ( !NT_SUCCESS (Status) )
    {
        SetLastError (RtlNtStatusToDosError(Status));
    }
    else
    {
        rc = GdiAddFontResourceW ( FilenameW, 0, 0);

        HEAP_free ( FilenameW );
    }
    return rc;
}

AddFontResourceExA()

int WINAPI AddFontResourceExA	(	LPCSTR	lpszFilename,
		DWORD	fl,
		PVOID	pvReserved
	)

Definition at line 1981 of file font.c.

{
    NTSTATUS Status;
    PWSTR FilenameW;
    int rc;

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

    Status = HEAP_strdupA2W ( &FilenameW, lpszFilename );
    if ( !NT_SUCCESS (Status) )
    {
        SetLastError (RtlNtStatusToDosError(Status));
        return 0;
    }

    rc = GdiAddFontResourceW ( FilenameW, fl, 0 );
    HEAP_free ( FilenameW );
    return rc;
}

Referenced by test_long_names().

AddFontResourceExW()

int WINAPI AddFontResourceExW	(	LPCWSTR	lpszFilename,
		DWORD	fl,
		PVOID	pvReserved
	)

Definition at line 1964 of file font.c.

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

    return GdiAddFontResourceW(lpszFilename, fl,0);
}

AddFontResourceTracking()

int WINAPI AddFontResourceTracking	(	LPCSTR	lpString,
		int	unknown
	)

Definition at line 2491 of file font.c.

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

AddFontResourceW()

int WINAPI AddFontResourceW

(

LPCWSTR

lpszFilename

)

Definition at line 2037 of file font.c.

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

bInitSystemAndFontsDirectoriesW()

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

Definition at line 2546 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 2669 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 1844 of file font.c.

{
    ANSI_STRING StringA;
    UNICODE_STRING StringU;
    HFONT ret;

    RtlInitAnsiString(&StringA, (LPSTR)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;
}

Referenced by test_GetTextMetrics2().

CreateFontIndirectA()

HFONT WINAPI CreateFontIndirectA

(

CONST LOGFONTA *

lplf

)

Definition at line 1699 of file font.c.

{
    if (lplf)
    {
        LOGFONTW tlf;

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

Referenced by check_vertical_font(), check_vertical_metrics(), create_fixed_pitch_font_proc(), create_font(), create_font_proc(), get_font_dpi(), get_font_fsselection(), get_glyph_indices(), test_bitmap_font_glyph_index(), test_CreateFontIndirect(), test_east_asian_font_selection(), test_fake_bold_font(), test_fstype_fixup(), test_fullname(), test_fullname2_helper(), test_GdiGetCodePage(), test_GetCharABCWidths(), test_GetCharWidth32(), test_GetCharWidthI(), test_GetGlyphIndices(), test_GetGlyphOutline(), test_GetGlyphOutline_empty_contour(), test_GetGlyphOutline_metric_clipping(), test_GetKerningPairs(), test_GetOutlineTextMetrics(), test_GetTextFace(), test_height(), test_logfont(), test_long_names(), test_max_height(), test_negative_width(), test_nonexistent_font(), test_oemcharset(), test_RealizationInfo(), test_text_extents(), and test_text_metrics().

CreateFontIndirectExA()

HFONT WINAPI CreateFontIndirectExA

(

const ENUMLOGFONTEXDVA *

elfexd

)

Definition at line 1657 of file font.c.

{
    if (elfexd)
    {
        ENUMLOGFONTEXDVW Logfont;

        EnumLogFontExW2A( (LPENUMLOGFONTEXA) elfexd,
                          &Logfont.elfEnumLogfontEx );

        RtlCopyMemory( &Logfont.elfDesignVector,
                       (PVOID) &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 1681 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 1803 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;
}

Referenced by CreateConsoleFontEx(), CreateFontIndirectA(), CreateFontW(), find_installed_font(), gdi_get_font_metrics(), GdipCreateFont(), GdipCreateFontFromLogfontW(), and test_GetTextFace().

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 1894 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);
}

Referenced by CreateFontA(), and D3DXCreateFontIndirectW().

CreateScalableFontResourceA()

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

Definition at line 1948 of file font.c.

{
    return FALSE;
}

Referenced by test_CreateScalableFontResource().

CreateScalableFontResourceW()

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

Definition at line 2515 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 480 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);
}

Referenced by EnumFontsA(), is_font_installed(), is_font_installed_fullname(), is_truetype_font_installed(), test_bitmap_font(), test_EnumFontFamilies(), and test_EnumFonts().

EnumFontFamiliesExA()

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

Definition at line 447 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);
}

Referenced by test_bitmap_font_metrics(), test_east_asian_font_selection(), test_EnumFontFamilies(), test_EnumFontFamiliesEx_default_charset(), test_EnumFonts_subst(), test_fullname2_helper(), test_GetCharABCWidths(), test_GetGlyphOutline(), test_GetTextMetrics(), test_long_names(), and test_vertical_order().

EnumFontFamiliesExW()

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

Definition at line 400 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);
}

Referenced by FaceNameList_Initialize(), FontTypeChange(), gdi_get_font_metrics(), GdipNewInstalledFontCollection(), GdipPrivateAddMemoryFont(), IsValidConsoleFont(), and test_EnumFontFamilies().

EnumFontFamiliesW()

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

Definition at line 423 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);
}

Referenced by EnumFontsW(), find_installed_font(), GdipIsStyleAvailable(), and test_EnumFontFamilies().

EnumFontsA()

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

Definition at line 2295 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 2276 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 2558 of file font.c.

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

EudcUnloadLinkW()

BOOL WINAPI EudcUnloadLinkW	(	LPCWSTR	pBaseFaceName,
		LPCWSTR	pEudcFontPath
	)

Definition at line 2570 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 146 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 124 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 79 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 22 of file font.c.

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

Referenced by height_to_LP(), INTERNAL_YDSTOWS(), PATH_Ellipse(), PATH_RoundRect(), PATH_ScaleNormalizedPoint(), and width_to_LP().

GdiAddFontResourceW()

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

Definition at line 2404 of file font.c.

{
    INT Ret;
    WCHAR lpszBuffer[MAX_PATH];
    WCHAR lpszAbsPath[MAX_PATH];
    UNICODE_STRING NtAbsPath;

    /* FIXME: We don't support multiple files passed in lpszFilename
     *        as L"abcxxxxx.pfm|abcxxxxx.pfb"
     */

    /* Does the file exist in CurrentDirectory or in the Absolute Path passed? */
    GetCurrentDirectoryW(MAX_PATH, lpszBuffer);

    if (!SearchPathW(lpszBuffer, lpszFilename, NULL, MAX_PATH, lpszAbsPath, NULL))
    {
        /* Nope. Then let's check Fonts folder */
        GetWindowsDirectoryW(lpszBuffer, MAX_PATH);
        StringCbCatW(lpszBuffer, sizeof(lpszBuffer), L"\\Fonts");

        if (!SearchPathW(lpszBuffer, lpszFilename, NULL, MAX_PATH, lpszAbsPath, NULL))
        {
            DPRINT1("Font not found. The Buffer is: %ls, the FileName is: %S\n", lpszBuffer, lpszFilename);
            return 0;
        }
    }

    /* We found the font file so: */
    if (!RtlDosPathNameToNtPathName_U(lpszAbsPath, &NtAbsPath, NULL, NULL))
    {
        DPRINT1("Can't convert Path! Path: %ls\n", lpszAbsPath);
        return 0;
    }

    /* The Nt call expects a null-terminator included in cwc param. */
    ASSERT(NtAbsPath.Buffer[NtAbsPath.Length / sizeof(WCHAR)] == UNICODE_NULL);
    Ret = NtGdiAddFontResourceW(NtAbsPath.Buffer, NtAbsPath.Length / sizeof(WCHAR) + 1, 1, fl, 0, pdv);

    RtlFreeUnicodeString(&NtAbsPath);

    return Ret;
}

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

GdiGetCharDimensions()

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

Definition at line 2145 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 create_taskdialog_template(), DIALOG_CreateIndirect(), EDIT_EM_SetMargins(), EDIT_UpdateUniscribeData_linedef(), GetDialogBaseUnits(), LoadDialog(), OleCreatePropertyFrameIndirect(), SoftModalMessageBox(), Test_GdiGetCharDimensions(), test_margins_default(), and test_margins_usefontinfo().

GetCharABCWidthsA()

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

Definition at line 934 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;
}

Referenced by test_GetCharABCWidths().

GetCharABCWidthsFloatA()

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

Definition at line 977 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],(ULONG)count, (PWCHAR)wstr, 0, (PVOID)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 686 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),
                                   (PWCHAR) NULL,
                                   0,
                                   (PVOID)abcF);
}

GetCharABCWidthsI()

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

Definition at line 1014 of file font.c.

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

Referenced by test_GetCharWidthI().

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),
                                   (PWCHAR) NULL,
                                   GCABCW_NOFLOAT,
                                   (PVOID)lpabc);
}

Referenced by check_vertical_metrics().

GetCharacterPlacementA()

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

Definition at line 505 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;
}

Referenced by test_GetCharacterPlacement().

GetCharacterPlacementW()

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

Definition at line 568 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;
}

Referenced by GetCharacterPlacementA().

GetCharWidth32A()

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

Definition at line 854 of file font.c.

{
    INT wlen, count = 0;
    LPSTR str;
    LPWSTR wstr;
    BOOL ret = TRUE;

    DPRINT("GetCharWidths32A\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 = NtGdiGetCharWidthW( hdc,
                              wstr[0],
                              (ULONG) count,
                              (PWCHAR) wstr,
                              GCW_NOFLOAT|GCW_WIN32,
                              (PVOID) 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 761 of file font.c.

{
    DPRINT("GetCharWidths32W\n");
    if ((!lpBuffer) || (iFirstChar > iLastChar))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return NtGdiGetCharWidthW( hdc,
                               iFirstChar,
                               (ULONG)(iLastChar - iFirstChar + 1),
                               (PWCHAR) NULL,
                               GCW_NOFLOAT|GCW_WIN32,
                               (PVOID) 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");

    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],
                              (ULONG) count,
                              (PWCHAR) wstr,
                              GCW_NOFLOAT,
                              (PVOID) lpBuffer);

    HeapFree(GetProcessHeap(), 0, str);
    HeapFree(GetProcessHeap(), 0, wstr);

    return ret;
}

Referenced by test_bitmap_font(), test_font_metrics(), and test_outline_font().

GetCharWidthFloatA()

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

Definition at line 897 of file font.c.

{
    INT wlen, count = 0;
    LPSTR str;
    LPWSTR wstr;
    BOOL ret = TRUE;

    DPRINT("GetCharWidthsFloatA\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 = NtGdiGetCharWidthW( hdc, wstr[0], (ULONG) count, (PWCHAR) wstr, 0, (PVOID) 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 711 of file font.c.

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

GetCharWidthI()

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

Definition at line 1034 of file font.c.

{
    DPRINT("GetCharWidthsI\n");
    if (!lpBuffer || (!pgi && (giFirst == MAXUSHORT))) // Cannot be at max.
    {
        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 );
}

Referenced by test_GetCharWidthI().

GetCharWidthW()

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

Definition at line 736 of file font.c.

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

GetEUDCTimeStamp()

ULONG WINAPI GetEUDCTimeStamp

(

VOID

)

Definition at line 2582 of file font.c.

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

GetEUDCTimeStampExW()

DWORD WINAPI GetEUDCTimeStampExW

(

LPWSTR

lpBaseFaceName

)

Definition at line 2592 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 2613 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 2654 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 1061 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 1085 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;
}

Referenced by test_GetCharWidthI().

GetGlyphOutlineA()

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

Definition at line 1112 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;
}

Referenced by test_bitmap_font_metrics(), test_fake_bold_font(), test_GetCharABCWidths(), test_GetGlyphOutline(), test_GetGlyphOutline_metric_clipping(), test_negative_width(), and test_outline_font().

GetGlyphOutlineW()

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

Definition at line 1161 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);
}

Referenced by check_vertical_font(), check_vertical_metrics(), test_GetGlyphOutline(), and test_GetGlyphOutline_empty_contour().

GetGlyphOutlineWow()

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

Definition at line 1182 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 1575 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 1555 of file font.c.

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

Referenced by GetKerningPairsA(), and test_GetKerningPairs().

GetOutlineTextMetricsA()

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

Definition at line 1202 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;
}

Referenced by check_vertical_metrics(), get_font_fsselection(), test_font_metrics(), test_fstype_fixup(), test_fullname2_helper(), test_GetOutlineTextMetrics(), and test_outline_font().

GetOutlineTextMetricsW()

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

Definition at line 1401 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;
}

Referenced by gdi_get_font_metrics(), GdipCreateFont(), GdipCreateFontFromLogfontW(), get_font_metrics(), GetOutlineTextMetricsA(), and test_GetKerningPairs().

height_to_LP()

static INT height_to_LP ( XFORM *  xForm, INT  height  )

inlinestatic

Definition at line 1391 of file font.c.

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

Referenced by GetOutlineTextMetricsW().

IntEnumFontFamilies()

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

static

Definition at line 288 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 1375 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 245 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 212 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 255 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 2326 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 641 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,
                                        (LPWSTR)lpString,
                                        nSet,
                                        nMaxExtent,
                                        lpResults,
                                        dwFlags);
}

NewTextMetricExW2A()

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

Definition at line 201 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 191 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 2630 of file font.c.

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

RemoveFontMemResourceEx()

BOOL WINAPI RemoveFontMemResourceEx

(

HANDLE

fh

)

Definition at line 2475 of file font.c.

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

Referenced by START_TEST().

RemoveFontResourceA()

BOOL WINAPI RemoveFontResourceA

(

LPCSTR

lpFileName

)

Definition at line 2059 of file font.c.

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

RemoveFontResourceExA()

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

Definition at line 2069 of file font.c.

{
    NTSTATUS Status;
    LPWSTR lpFileNameW;

    /* FIXME the flags */
    /* FIXME the pdv */
    /* FIXME NtGdiRemoveFontResource handle flags and pdv */

    Status = HEAP_strdupA2W ( &lpFileNameW, lpFileName );
    if (!NT_SUCCESS (Status))
        SetLastError (RtlNtStatusToDosError(Status));
    else
    {

        HEAP_free ( lpFileNameW );
    }

    return 0;
}

Referenced by RemoveFontResourceA(), and test_long_names().

RemoveFontResourceExW()

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

Definition at line 2098 of file font.c.

{
    /* FIXME the flags */
    /* FIXME the pdv */
    /* FIXME NtGdiRemoveFontResource handle flags and pdv */
    DPRINT("RemoveFontResourceExW\n");
    return 0;
}

Referenced by RemoveFontResourceW(), and RemoveTempFont().

RemoveFontResourceTracking()

int WINAPI RemoveFontResourceTracking	(	LPCSTR	lpString,
		int	unknown
	)

Definition at line 2506 of file font.c.

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

RemoveFontResourceW()

BOOL WINAPI RemoveFontResourceW

(

LPCWSTR

lpFileName

)

Definition at line 2048 of file font.c.

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

SetMapperFlags()

DWORD WINAPI SetMapperFlags	(	HDC	hDC,
		DWORD	flags
	)

Definition at line 2235 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;
}