ReactOS 0.4.16-dev-1007-g2e85425
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 2470 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 2581 of file font.c.

2587{
2588 if ( pbFont && cbFont && pcFonts)
2589 {
2590 return NtGdiAddFontMemResourceEx(pbFont, cbFont, NULL, 0, pcFonts);
2591 }
2593 return NULL;
2594}
#define NULL
Definition: types.h:112
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
__kernel_entry W32KAPI HANDLE APIENTRY NtGdiAddFontMemResourceEx(_In_reads_bytes_(cjBuffer) PVOID pvBuffer, _In_ DWORD cjBuffer, _In_reads_bytes_opt_(cjDV) DESIGNVECTOR *pdv, _In_ ULONG cjDV, _Out_ DWORD *pNumFonts)

◆ AddFontResourceA()

INT WINAPI AddFontResourceA ( _In_ LPCSTR  lpszFilename)

Definition at line 2159 of file font.c.

2160{
2161 return AddFontResourceExA(lpszFilename, 0, NULL);
2162}
INT WINAPI AddFontResourceExA(_In_ LPCSTR pszFilename, _In_ DWORD fl, _Reserved_ PVOID pvReserved)

Referenced by Test_AddFontResourceA().

◆ AddFontResourceExA()

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

Definition at line 2118 of file font.c.

2122{
2123 if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
2124 {
2126 return 0;
2127 }
2128
2129 if (!lpszFilename)
2130 return 0;
2131
2132 PWSTR FilenameW;
2133 WCHAR szBuff[MAX_PATH];
2134
2135 _SEH2_TRY
2136 {
2137 FilenameW = HEAP_strdupA2W_buf(lpszFilename, szBuff, _countof(szBuff));
2138 }
2140 {
2141 _SEH2_YIELD(return 0);
2142 }
2143 _SEH2_END;
2144
2145 if (!FilenameW)
2146 {
2148 return 0;
2149 }
2150
2151 INT ret = GdiAddFontResourceW(FilenameW, fl, NULL);
2152 HEAP_strdupA2W_buf_free(FilenameW, szBuff);
2153 return ret;
2154}
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define MAX_PATH
Definition: compat.h:34
PWSTR FASTCALL HEAP_strdupA2W_buf(_In_ PCSTR lpszA, _In_ PWSTR pszStaticBuff, _In_ SIZE_T cchStaticBuff)
Definition: heap.c:53
static VOID FASTCALL HEAP_strdupA2W_buf_free(_In_opt_ PWSTR pszDynamicBuff, _In_ PWSTR pszStaticBuff)
Definition: gdi32p.h:244
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
#define _SEH2_END
Definition: pseh2_64.h:171
#define _SEH2_TRY
Definition: pseh2_64.h:71
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:184
#define _countof(array)
Definition: sndvol32.h:70
uint16_t * PWSTR
Definition: typedefs.h:56
int32_t INT
Definition: typedefs.h:58
int ret
INT WINAPI GdiAddFontResourceW(LPCWSTR lpszFilename, FLONG fl, DESIGNVECTOR *pdv)
Definition: font.c:2550
_In_ FLONG fl
Definition: winddi.h:1279
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ AddFontResourceExW()

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

Definition at line 2101 of file font.c.

2105{
2106 if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
2107 {
2109 return 0;
2110 }
2111
2112 return GdiAddFontResourceW(lpszFilename, fl, NULL);
2113}

◆ AddFontResourceTracking()

int WINAPI AddFontResourceTracking ( LPCSTR  lpString,
int  unknown 
)

Definition at line 2617 of file font.c.

2621{
2624 return 0;
2625}
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102

◆ AddFontResourceW()

INT WINAPI AddFontResourceW ( _In_ LPCWSTR  lpszFilename)

Definition at line 2167 of file font.c.

2168{
2169 return GdiAddFontResourceW(lpszFilename, 0, NULL);
2170}

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

◆ bInitSystemAndFontsDirectoriesW()

BOOL WINAPI bInitSystemAndFontsDirectoriesW ( LPWSTR SystemDir,
LPWSTR FontsDir 
)

Definition at line 2672 of file font.c.

2673{
2676 return 0;
2677}

◆ cGetTTFFromFOT()

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

Definition at line 2795 of file font.c.

2796{
2799 return 0;
2800}

◆ 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 1846 of file font.c.

1862{
1863 ANSI_STRING StringA;
1864 UNICODE_STRING StringU;
1865 HFONT ret;
1866
1867 RtlInitAnsiString(&StringA, (LPSTR)lpszFace);
1868 RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE);
1869
1870 ret = CreateFontW(nHeight,
1871 nWidth,
1872 nEscapement,
1873 nOrientation,
1874 fnWeight,
1875 fdwItalic,
1876 fdwUnderline,
1877 fdwStrikeOut,
1878 fdwCharSet,
1879 fdwOutputPrecision,
1880 fdwClipPrecision,
1881 fdwQuality,
1882 fdwPitchAndFamily,
1883 StringU.Buffer);
1884
1885 RtlFreeUnicodeString(&StringU);
1886
1887 return ret;
1888}
#define TRUE
Definition: types.h:120
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
HFONT WINAPI CreateFontW(_In_ int, _In_ int, _In_ int, _In_ int, _In_ int, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_ DWORD, _In_opt_ LPCWSTR)
char * LPSTR
Definition: xmlstorage.h:182

◆ CreateFontIndirectA()

HFONT WINAPI CreateFontIndirectA ( CONST LOGFONTA lplf)

Definition at line 1701 of file font.c.

1704{
1705 if (lplf)
1706 {
1707 LOGFONTW tlf;
1708
1709 LogFontA2W(&tlf, lplf);
1710 return CreateFontIndirectW(&tlf);
1711 }
1712 else return NULL;
1713}
VOID NTAPI LogFontA2W(LPLOGFONTW pW, CONST LOGFONTA *pA)
Definition: utils.c:348
HFONT WINAPI CreateFontIndirectW(_In_ const LOGFONTW *)

◆ CreateFontIndirectExA()

HFONT WINAPI CreateFontIndirectExA ( const ENUMLOGFONTEXDVA elfexd)

Definition at line 1659 of file font.c.

1660{
1661 if (elfexd)
1662 {
1663 ENUMLOGFONTEXDVW Logfont;
1664
1666 &Logfont.elfEnumLogfontEx );
1667
1669 (PVOID) &elfexd->elfDesignVector,
1670 sizeof(DESIGNVECTOR));
1671
1672 return NtGdiHfontCreate( &Logfont, 0, 0, 0, NULL);
1673 }
1674 else return NULL;
1675}
VOID WINAPI EnumLogFontExW2A(LPENUMLOGFONTEXA fontA, CONST ENUMLOGFONTEXW *fontW)
Definition: utils.c:402
__kernel_entry W32KAPI HFONT APIENTRY NtGdiHfontCreate(_In_reads_bytes_(cjElfw) ENUMLOGFONTEXDVW *pelfw, _In_ ULONG cjElfw, _In_ LFTYPE lft, _In_ FLONG fl, _In_ PVOID pvCliData)
DESIGNVECTOR elfDesignVector
Definition: wingdi.h:2775
DESIGNVECTOR elfDesignVector
Definition: wingdi.h:2780
ENUMLOGFONTEXW elfEnumLogfontEx
Definition: wingdi.h:2779
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

Referenced by Test_CreateFontIndirectExA().

◆ CreateFontIndirectExW()

HFONT WINAPI CreateFontIndirectExW ( const ENUMLOGFONTEXDVW elfexd)

Definition at line 1683 of file font.c.

1684{
1685 /* Msdn: Note, this function ignores the elfDesignVector member in
1686 ENUMLOGFONTEXDV.
1687 */
1688 if ( elfexd )
1689 {
1690 return NtGdiHfontCreate((PENUMLOGFONTEXDVW) elfexd, 0, 0, 0, NULL );
1691 }
1692 else return NULL;
1693}

Referenced by CreateFontIndirectW(), and Test_CreateFontIndirectExW().

◆ CreateFontIndirectW()

HFONT WINAPI CreateFontIndirectW ( CONST LOGFONTW lplf)

Definition at line 1805 of file font.c.

1808{
1809#if 0
1810 static BOOL bDidTest = FALSE;
1811 if (!bDidTest)
1812 {
1813 bDidTest = TRUE;
1814 DoFontSystemUnittest();
1815 }
1816#endif
1817 if (lplf)
1818 {
1819 ENUMLOGFONTEXDVW Logfont;
1820
1821 RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW));
1822 // Need something other than just cleaning memory here.
1823 // Guess? Use caller data to determine the rest.
1825 sizeof(Logfont.elfEnumLogfontEx.elfFullName));
1827 sizeof(Logfont.elfEnumLogfontEx.elfStyle));
1829 sizeof(Logfont.elfEnumLogfontEx.elfScript));
1830
1831 Logfont.elfDesignVector.dvNumAxes = 0; // No more than MM_MAX_NUMAXES
1832
1833 RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR));
1834
1835 return CreateFontIndirectExW(&Logfont);
1836 }
1837 else return NULL;
1838}
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD dvNumAxes
Definition: wingdi.h:2769
WCHAR elfStyle[LF_FACESIZE]
Definition: wingdi.h:2704
LOGFONTW elfLogFont
Definition: wingdi.h:2702
WCHAR elfFullName[LF_FULLFACESIZE]
Definition: wingdi.h:2703
WCHAR elfScript[LF_FACESIZE]
Definition: wingdi.h:2705
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
HFONT WINAPI CreateFontIndirectExW(const ENUMLOGFONTEXDVW *elfexd)
Definition: font.c:1683

◆ 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 1896 of file font.c.

1912{
1913 LOGFONTW logfont;
1914
1915 logfont.lfHeight = nHeight;
1916 logfont.lfWidth = nWidth;
1917 logfont.lfEscapement = nEscapement;
1918 logfont.lfOrientation = nOrientation;
1919 logfont.lfWeight = nWeight;
1920 logfont.lfItalic = (BYTE)fnItalic;
1921 logfont.lfUnderline = (BYTE)fdwUnderline;
1922 logfont.lfStrikeOut = (BYTE)fdwStrikeOut;
1923 logfont.lfCharSet = (BYTE)fdwCharSet;
1924 logfont.lfOutPrecision = (BYTE)fdwOutputPrecision;
1925 logfont.lfClipPrecision = (BYTE)fdwClipPrecision;
1926 logfont.lfQuality = (BYTE)fdwQuality;
1927 logfont.lfPitchAndFamily = (BYTE)fdwPitchAndFamily;
1928
1929 if (NULL != lpszFace)
1930 {
1931 int Size = sizeof(logfont.lfFaceName) / sizeof(WCHAR);
1932 wcsncpy((wchar_t *)logfont.lfFaceName, lpszFace, Size - 1);
1933 /* Be 101% sure to have '\0' at end of string */
1934 logfont.lfFaceName[Size - 1] = '\0';
1935 }
1936 else
1937 {
1938 logfont.lfFaceName[0] = L'\0';
1939 }
1940
1941 return CreateFontIndirectW(&logfont);
1942}
wcsncpy
#define L(x)
Definition: ntvdm.h:50
BYTE lfOutPrecision
Definition: dimm.idl:68
BYTE lfStrikeOut
Definition: dimm.idl:66
BYTE lfItalic
Definition: dimm.idl:64
LONG lfHeight
Definition: dimm.idl:59
LONG lfWeight
Definition: dimm.idl:63
WCHAR lfFaceName[LF_FACESIZE]
Definition: dimm.idl:72
LONG lfOrientation
Definition: dimm.idl:62
LONG lfWidth
Definition: dimm.idl:60
BYTE lfUnderline
Definition: dimm.idl:65
BYTE lfClipPrecision
Definition: dimm.idl:69
LONG lfEscapement
Definition: dimm.idl:61
BYTE lfCharSet
Definition: dimm.idl:67
BYTE lfQuality
Definition: dimm.idl:70
BYTE lfPitchAndFamily
Definition: dimm.idl:71
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
unsigned char BYTE
Definition: xxhash.c:193

◆ CreateScalableFontResourceA()

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

Definition at line 2088 of file font.c.

2094{
2095 return FALSE;
2096}

◆ CreateScalableFontResourceW()

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

Definition at line 2641 of file font.c.

2647{
2648 HANDLE f;
2649
2651
2652 /* fHidden=1 - only visible for the calling app, read-only, not
2653 * enumerated with EnumFonts/EnumFontFamilies
2654 * lpszCurrentPath can be NULL
2655 */
2656
2657 /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
2658 if ((f = CreateFileW(lpszFontRes, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE)
2659 {
2660 CloseHandle(f);
2662 return FALSE;
2663 }
2664 return FALSE; /* create failed */
2665}
#define CloseHandle
Definition: compat.h:739
#define OPEN_EXISTING
Definition: compat.h:775
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define CreateFileW
Definition: compat.h:741
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
GLfloat f
Definition: glext.h:7540
#define f
Definition: ke_i.h:83
#define ERROR_FILE_EXISTS
Definition: winerror.h:165

◆ EnumFontFamiliesA()

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

Definition at line 482 of file font.c.

484{
485 LOGFONTW LogFont;
486
487 DPRINT("EnumFontFamiliesA(%p, %s, %p, %p)\n",
488 hdc, lpszFamily, lpEnumFontFamProc, lParam);
489
490 ZeroMemory(&LogFont, sizeof(LOGFONTW));
491 LogFont.lfCharSet = DEFAULT_CHARSET;
492 if (NULL != lpszFamily)
493 {
494 if (!*lpszFamily) return 1;
495 MultiByteToWideChar(CP_THREAD_ACP, 0, lpszFamily, -1, LogFont.lfFaceName, LF_FACESIZE);
496 }
497
498 return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, 0);
499}
LPARAM lParam
Definition: combotst.c:139
#define LF_FACESIZE
Definition: dimm.idl:39
#define MultiByteToWideChar
Definition: compat.h:110
HDC hdc
Definition: main.c:9
#define DPRINT
Definition: sndvol32.h:73
static int FASTCALL IntEnumFontFamilies(HDC Dc, const LOGFONTW *LogFont, PVOID EnumProc, LPARAM lParam, DWORD dwFlags)
Definition: font.c:290
#define ZeroMemory
Definition: winbase.h:1743
#define DEFAULT_CHARSET
Definition: wingdi.h:384
#define CP_THREAD_ACP
Definition: winnls.h:235

◆ EnumFontFamiliesExA()

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

Definition at line 449 of file font.c.

451{
452 LOGFONTW LogFontW, *pLogFontW;
453
454 if (lpLogfont)
455 {
456 DPRINT("EnumFontFamiliesExA(%p, %p(%s, %u, %u), %p, %p, 0x%08lX)\n",
457 hdc, lpLogfont, lpLogfont->lfFaceName, lpLogfont->lfCharSet,
458 lpLogfont->lfPitchAndFamily, lpEnumFontFamExProc, lParam, dwFlags);
459 }
460 else
461 {
462 DPRINT("EnumFontFamiliesExA(%p, NULL, %p, %p, 0x%08lX)\n",
463 hdc, lpEnumFontFamExProc, lParam, dwFlags);
464 }
465
466 if (lpLogfont)
467 {
468 LogFontA2W(&LogFontW,lpLogfont);
469 pLogFontW = &LogFontW;
470 }
471 else pLogFontW = NULL;
472
473 /* no need to convert LogFontW back to lpLogFont b/c it's an [in] parameter only */
474 return IntEnumFontFamilies(hdc, pLogFontW, lpEnumFontFamExProc, lParam, IEFF_EXTENDED);
475}
BYTE lfCharSet
Definition: wingdi.h:1889
BYTE lfPitchAndFamily
Definition: wingdi.h:1893
CHAR lfFaceName[LF_FACESIZE]
Definition: wingdi.h:1894
#define IEFF_EXTENDED
Definition: font.c:254
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

◆ EnumFontFamiliesExW()

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

Definition at line 402 of file font.c.

404{
405 if (lpLogfont)
406 {
407 DPRINT("EnumFontFamiliesExW(%p, %p(%S, %u, %u), %p, %p, 0x%08lX)\n",
408 hdc, lpLogfont, lpLogfont->lfFaceName, lpLogfont->lfCharSet,
409 lpLogfont->lfPitchAndFamily, lpEnumFontFamExProc, lParam, dwFlags);
410 }
411 else
412 {
413 DPRINT("EnumFontFamiliesExW(%p, NULL, %p, %p, 0x%08lX)\n",
414 hdc, lpEnumFontFamExProc, lParam, dwFlags);
415 }
416 return IntEnumFontFamilies(hdc, lpLogfont, lpEnumFontFamExProc, lParam,
418}
BYTE lfCharSet
Definition: wingdi.h:1905
WCHAR lfFaceName[LF_FACESIZE]
Definition: wingdi.h:1910
BYTE lfPitchAndFamily
Definition: wingdi.h:1909
#define IEFF_UNICODE
Definition: font.c:253

◆ EnumFontFamiliesW()

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

Definition at line 425 of file font.c.

427{
428 LOGFONTW LogFont;
429
430 DPRINT("EnumFontFamiliesW(%p, %S, %p, %p)\n",
431 hdc, lpszFamily, lpEnumFontFamProc, lParam);
432
433 ZeroMemory(&LogFont, sizeof(LOGFONTW));
434 LogFont.lfCharSet = DEFAULT_CHARSET;
435 if (NULL != lpszFamily)
436 {
437 if (!*lpszFamily) return 1;
438 lstrcpynW(LogFont.lfFaceName, lpszFamily, LF_FACESIZE);
439 }
440
441 return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, IEFF_UNICODE);
442}
#define lstrcpynW
Definition: compat.h:738

◆ EnumFontsA()

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

Definition at line 2443 of file font.c.

2449{
2450#if 0
2452 LPWSTR lpFaceNameW;
2453 int rc = 0;
2454
2455 Status = HEAP_strdupA2W ( &lpFaceNameW, lpFaceName );
2456 if (!NT_SUCCESS (Status))
2458 else
2459 {
2460 rc = NtGdiEnumFonts ( hDC, lpFaceNameW, FontFunc, lParam );
2461
2462 HEAP_free ( lpFaceNameW );
2463 }
2464 return rc;
2465#else
2466 return EnumFontFamiliesA( hDC, lpFaceName, FontFunc, lParam );
2467#endif
2468}
static HDC hDC
Definition: 3dtext.c:33
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
static VOID FASTCALL HEAP_free(_In_ __drv_freesMem(Mem) PVOID memory)
Definition: gdi32p.h:226
NTSTATUS FASTCALL HEAP_strdupA2W(_Outptr_ PWSTR *ppszW, _In_ PCSTR lpszA)
Definition: heap.c:34
Status
Definition: gdiplustypes.h:25
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiEnumFonts(_In_ HDC hdc, _In_ ULONG iEnumType, _In_ FLONG flWin31Compat, _In_ ULONG cchFaceName, _In_reads_opt_(cchFaceName) LPCWSTR pwszFaceName, _In_ ULONG lfCharSet, _Inout_ ULONG *pulCount, _Out_writes_bytes_opt_(*pulCount) PVOID pvUserModeBuffer)
int WINAPI EnumFontFamiliesA(_In_ HDC, _In_opt_ LPCSTR, _In_ FONTENUMPROCA, _In_ LPARAM)
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ EnumFontsW()

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

Definition at line 2424 of file font.c.

2430{
2431#if 0
2432 return NtGdiEnumFonts ( hDC, lpFaceName, FontFunc, lParam );
2433#else
2434 return EnumFontFamiliesW( hDC, lpFaceName, FontFunc, lParam );
2435#endif
2436}
int WINAPI EnumFontFamiliesW(_In_ HDC, _In_opt_ LPCWSTR, _In_ FONTENUMPROCW, _In_ LPARAM)

◆ EudcLoadLinkW()

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

Definition at line 2684 of file font.c.

2685{
2688 return 0;
2689}

◆ EudcUnloadLinkW()

BOOL WINAPI EudcUnloadLinkW ( LPCWSTR  pBaseFaceName,
LPCWSTR  pEudcFontPath 
)

Definition at line 2696 of file font.c.

2697{
2700 return 0;
2701}

◆ FONT_GetCharsByRangeA()

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

Definition at line 148 of file font.c.

149{
150 INT i, count = lastChar - firstChar + 1;
151 UINT c;
152 LPSTR str;
153
154 if (count <= 0)
155 return NULL;
156
157 switch (GdiGetCodePage(hdc))
158 {
159 case 932:
160 case 936:
161 case 949:
162 case 950:
163 case 1361:
164 if (lastChar > 0xffff)
165 return NULL;
166 if ((firstChar ^ lastChar) > 0xff)
167 return NULL;
168 break;
169 default:
170 if (lastChar > 0xff)
171 return NULL;
172 break;
173 }
174
175 str = HeapAlloc(GetProcessHeap(), 0, count * 2 + 1);
176 if (str == NULL)
177 return NULL;
178
179 for(i = 0, c = firstChar; c <= lastChar; i++, c++)
180 {
181 if (c > 0xff)
182 str[i++] = (BYTE)(c >> 8);
183 str[i] = (BYTE)c;
184 }
185 str[i] = '\0';
186
187 *pByteLen = i;
188
189 return str;
190}
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
GLuint GLuint GLsizei count
Definition: gl.h:1545
const GLubyte * c
Definition: glext.h:8905
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define c
Definition: ke_i.h:80
unsigned int UINT
Definition: ndis.h:50
const WCHAR * str
DWORD WINAPI GdiGetCodePage(HDC)

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.

127{
129 INT lenW;
130 LPWSTR strW;
131
132 if(count == -1) count = strlen(str);
133 lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
134 strW = HeapAlloc(GetProcessHeap(), 0, lenW*sizeof(WCHAR));
135 if (!strW)
136 return NULL;
137 if(!MultiByteToWideChar(cp, 0, str, count, strW, lenW))
138 {
140 return NULL;
141 }
142 DPRINT("mapped %s -> %S\n", str, strW);
143 if(plenW) *plenW = lenW;
144 if(pCP) *pCP = cp;
145 return strW;
146}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define HeapFree(x, y, z)
Definition: compat.h:735
POINT cp
Definition: magnifier.c:59
WCHAR strW[12]
Definition: clipboard.c:2029

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.

82{
83 ptmA->tmHeight = ptmW->tmHeight;
84 ptmA->tmAscent = ptmW->tmAscent;
85 ptmA->tmDescent = ptmW->tmDescent;
88 ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
89 ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
90 ptmA->tmWeight = ptmW->tmWeight;
91 ptmA->tmOverhang = ptmW->tmOverhang;
94 ptmA->tmFirstChar = min(ptmW->tmFirstChar, 255);
95 if (ptmW->tmCharSet == SYMBOL_CHARSET)
96 {
97 ptmA->tmFirstChar = 0x1e;
98 ptmA->tmLastChar = 0xff; /* win9x behaviour - we need the OS2 table data to calculate correctly */
99 }
100 else
101 {
102 ptmA->tmFirstChar = ptmW->tmDefaultChar - 1;
103 ptmA->tmLastChar = min(ptmW->tmLastChar, 0xff);
104 }
105 ptmA->tmDefaultChar = (CHAR)ptmW->tmDefaultChar;
106 ptmA->tmBreakChar = (CHAR)ptmW->tmBreakChar;
107 ptmA->tmItalic = ptmW->tmItalic;
108 ptmA->tmUnderlined = ptmW->tmUnderlined;
109 ptmA->tmStruckOut = ptmW->tmStruckOut;
111 ptmA->tmCharSet = ptmW->tmCharSet;
112}
#define CHAR(Char)
#define min(a, b)
Definition: monoChain.cc:55
BYTE tmStruckOut
Definition: wingdi.h:2378
BYTE tmPitchAndFamily
Definition: wingdi.h:2379
BYTE tmCharSet
Definition: wingdi.h:2380
LONG tmDescent
Definition: wingdi.h:2363
LONG tmDigitizedAspectX
Definition: wingdi.h:2370
BYTE tmFirstChar
Definition: wingdi.h:2372
LONG tmExternalLeading
Definition: wingdi.h:2365
LONG tmWeight
Definition: wingdi.h:2368
BYTE tmBreakChar
Definition: wingdi.h:2375
LONG tmInternalLeading
Definition: wingdi.h:2364
BYTE tmLastChar
Definition: wingdi.h:2373
BYTE tmUnderlined
Definition: wingdi.h:2377
LONG tmMaxCharWidth
Definition: wingdi.h:2367
LONG tmAveCharWidth
Definition: wingdi.h:2366
BYTE tmDefaultChar
Definition: wingdi.h:2374
LONG tmAscent
Definition: wingdi.h:2362
LONG tmOverhang
Definition: wingdi.h:2369
LONG tmHeight
Definition: wingdi.h:2361
BYTE tmItalic
Definition: wingdi.h:2376
LONG tmDigitizedAspectY
Definition: wingdi.h:2371
WCHAR tmFirstChar
Definition: wingdi.h:2394
LONG tmDigitizedAspectX
Definition: wingdi.h:2392
LONG tmDigitizedAspectY
Definition: wingdi.h:2393
LONG tmOverhang
Definition: wingdi.h:2391
LONG tmAveCharWidth
Definition: wingdi.h:2388
LONG tmAscent
Definition: wingdi.h:2384
LONG tmMaxCharWidth
Definition: wingdi.h:2389
BYTE tmItalic
Definition: wingdi.h:2398
BYTE tmStruckOut
Definition: wingdi.h:2400
LONG tmInternalLeading
Definition: wingdi.h:2386
BYTE tmUnderlined
Definition: wingdi.h:2399
LONG tmExternalLeading
Definition: wingdi.h:2387
BYTE tmPitchAndFamily
Definition: wingdi.h:2401
LONG tmWeight
Definition: wingdi.h:2390
WCHAR tmBreakChar
Definition: wingdi.h:2397
WCHAR tmDefaultChar
Definition: wingdi.h:2396
BYTE tmCharSet
Definition: wingdi.h:2402
WCHAR tmLastChar
Definition: wingdi.h:2395
LONG tmHeight
Definition: wingdi.h:2383
LONG tmDescent
Definition: wingdi.h:2385
#define SYMBOL_CHARSET
Definition: wingdi.h:385
char CHAR
Definition: xmlstorage.h:175

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

◆ GDI_ROUND()

static __inline INT GDI_ROUND ( FLOAT  val)
static

Definition at line 24 of file font.c.

25{
26 return (int)floor(val + 0.5);
27}
GLuint GLfloat * val
Definition: glext.h:7180
_Check_return_ _CRTIMP double __cdecl floor(_In_ double x)

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

◆ GdiAddFontResourceW()

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

Definition at line 2550 of file font.c.

2554{
2555 ULONG cFiles, cwc;
2556 PWSTR pszConverted = IntConvertFontPaths(lpszFilename, &cFiles, &cwc, &fl, FALSE);
2557 if (!pszConverted)
2558 return 0;
2559
2560 INT ret = NtGdiAddFontResourceW(pszConverted, cwc, cFiles, fl, 0, pdv);
2561 HEAP_free(pszConverted);
2562 if (ret)
2563 return ret;
2564
2565 pszConverted = IntConvertFontPaths(lpszFilename, &cFiles, &cwc, &fl, TRUE);
2566 if (!pszConverted)
2567 return 0;
2568
2569 ret = NtGdiAddFontResourceW(pszConverted, cwc, cFiles, fl, 0, pdv);
2570 HEAP_free(pszConverted);
2571 if (!ret)
2573 return ret;
2574}
INT APIENTRY NtGdiAddFontResourceW(_In_reads_(cwc) WCHAR *pwszFiles, _In_ ULONG cwc, _In_ ULONG cFiles, _In_ FLONG f, _In_ DWORD dwPidTid, _In_opt_ DESIGNVECTOR *pdv)
Definition: font.c:465
uint32_t ULONG
Definition: typedefs.h:59
PWSTR FASTCALL IntConvertFontPaths(_In_ PCWSTR pszFiles, _Out_ PDWORD pcFiles, _Out_ PDWORD pcwc, _Inout_ PDWORD pfl, _In_ BOOL bFlag)
Definition: font.c:1947
_In_ ULONG_PTR _In_opt_ DESIGNVECTOR * pdv
Definition: winddi.h:3723

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

◆ GdiGetCharDimensions()

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

Definition at line 2293 of file font.c.

2294{
2295 SIZE sz;
2297 static const WCHAR alphabet[] =
2298 {
2299 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
2300 'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
2301 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0
2302 };
2303
2304 if(!GetTextMetricsW(hdc, &tm)) return 0;
2305
2306 if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
2307
2308 if (lptm) *lptm = tm;
2309 if (height) *height = tm.tmHeight;
2310
2311 return (sz.cx / 26 + 1) / 2;
2312}
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
static LPTEXTMETRICW lptm
Definition: font.c:42
LONG cx
Definition: kdterminal.h:27
Definition: time.h:68
BOOL WINAPI GetTextMetricsW(_In_ HDC, _Out_ LPTEXTMETRICW)
Definition: text.c:221
BOOL WINAPI GetTextExtentPointW(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE lpsz)

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 936 of file font.c.

942{
943 INT wlen, count = 0;
944 LPSTR str;
945 LPWSTR wstr;
946 BOOL ret = TRUE;
947
948 DPRINT("GetCharABCWidthsA\n");
949
950 str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
951 if (!str)
952 return FALSE;
953
954 wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
955 if (!wstr)
956 {
958 return FALSE;
959 }
960
962 wstr[0],
963 wlen - 1,
964 (PWCHAR)wstr,
966 (PVOID)lpabc);
967
969 HeapFree(GetProcessHeap(), 0, wstr);
970
971 return ret;
972}
__kernel_entry W32KAPI BOOL APIENTRY NtGdiGetCharABCWidthsW(_In_ HDC hdc, _In_ UINT wchFirst, _In_ ULONG cwch, _In_reads_opt_(cwch) PWCHAR pwch, _In_ FLONG fl, _Out_writes_bytes_(cwch *sizeof(ABC)) PVOID pvBuf)
#define GCABCW_NOFLOAT
Definition: ntgdityp.h:209
uint16_t * PWCHAR
Definition: typedefs.h:56
static LPSTR FONT_GetCharsByRangeA(HDC hdc, UINT firstChar, UINT lastChar, PINT pByteLen)
Definition: font.c:148
static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
Definition: font.c:126

◆ GetCharABCWidthsFloatA()

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

Definition at line 979 of file font.c.

985{
986 INT wlen, count = 0;
987 LPSTR str;
988 LPWSTR wstr;
989 BOOL ret = TRUE;
990
991 DPRINT("GetCharABCWidthsFloatA\n");
992
993 str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
994 if (!str)
995 return FALSE;
996
997 wstr = FONT_mbtowc( hdc, str, count+1, &wlen, NULL );
998 if (!wstr)
999 {
1000 HeapFree( GetProcessHeap(), 0, str );
1001 return FALSE;
1002 }
1003 ret = NtGdiGetCharABCWidthsW( hdc,wstr[0],(ULONG)count, (PWCHAR)wstr, 0, (PVOID)lpABCF);
1004
1005 HeapFree( GetProcessHeap(), 0, str );
1006 HeapFree( GetProcessHeap(), 0, wstr );
1007
1008 return ret;
1009}

◆ GetCharABCWidthsFloatW()

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

Definition at line 688 of file font.c.

692{
693 DPRINT("GetCharABCWidthsFloatW\n");
694 if ((!abcF) || (FirstChar > LastChar))
695 {
697 return FALSE;
698 }
700 FirstChar,
701 (ULONG)(LastChar - FirstChar + 1),
702 (PWCHAR) NULL,
703 0,
704 (PVOID)abcF);
705}

◆ GetCharABCWidthsI()

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

Definition at line 1016 of file font.c.

1021{
1022 DPRINT("GetCharABCWidthsI\n");
1024 giFirst,
1025 (ULONG) cgi,
1026 (PWCHAR) pgi,
1028 (PVOID)lpabc);
1029}
static LPCSTR INT LPWORD pgi
Definition: font.c:51
#define GCABCW_INDICES
Definition: ntgdityp.h:210

◆ GetCharABCWidthsW()

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

Definition at line 789 of file font.c.

793{
794 DPRINT("GetCharABCWidthsW\n");
795 if ((!lpabc) || (FirstChar > LastChar))
796 {
798 return FALSE;
799 }
801 FirstChar,
802 (ULONG)(LastChar - FirstChar + 1),
803 (PWCHAR) NULL,
805 (PVOID)lpabc);
806}

◆ 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.

514{
515 WCHAR *lpStringW;
516 INT uCountW;
517 GCP_RESULTSW resultsW;
518 DWORD ret;
519 UINT font_cp;
520
521 if ( !lpString || uCount <= 0 || !lpResults || (nMaxExtent < 0 && nMaxExtent != -1 ) )
522 {
524 return 0;
525 }
526 /* TRACE("%s, %d, %d, 0x%08x\n",
527 debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
528 */
529 /* both structs are equal in size */
530 memcpy(&resultsW, lpResults, sizeof(resultsW));
531
532 lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
533 if (lpStringW == NULL)
534 {
535 return 0;
536 }
537 if(lpResults->lpOutString)
538 {
539 resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
540 if (resultsW.lpOutString == NULL)
541 {
542 HeapFree(GetProcessHeap(), 0, lpStringW);
543 return 0;
544 }
545 }
546
547 ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
548
549 lpResults->nGlyphs = resultsW.nGlyphs;
550 lpResults->nMaxFit = resultsW.nMaxFit;
551
552 if(lpResults->lpOutString)
553 {
554 WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
555 lpResults->lpOutString, uCount, NULL, NULL );
556 }
557
558 HeapFree(GetProcessHeap(), 0, lpStringW);
559 HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
560
561 return ret;
562}
#define WideCharToMultiByte
Definition: compat.h:111
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
LPSTR lpOutString
Definition: wingdi.h:2421
LPWSTR lpOutString
Definition: wingdi.h:2432
DWORD WINAPI GetCharacterPlacementW(_In_ HDC hdc, _In_reads_(nCount) LPCWSTR lpString, _In_ int nCount, _In_ int nMexExtent, _Inout_ LPGCP_RESULTSW lpResults, _In_ DWORD dwFlags)

◆ 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.

578{
579 DWORD ret=0;
580 SIZE size;
581 UINT i, nSet;
582 DPRINT("GetCharacterPlacementW\n");
583
584 if (dwFlags&(~GCP_REORDER)) DPRINT("flags 0x%08lx ignored\n", dwFlags);
585 if (lpResults->lpClass) DPRINT("classes not implemented\n");
586
587 nSet = (UINT)uCount;
588 if (nSet > lpResults->nGlyphs)
589 nSet = lpResults->nGlyphs;
590
591 /* return number of initialized fields */
592 lpResults->nGlyphs = nSet;
593
594 if (dwFlags & GCP_REORDER)
595 {
596 if (LoadLPK(LPK_GCP))
597 return LpkGetCharacterPlacement(hdc, lpString, uCount, nMaxExtent, lpResults, dwFlags, 0);
598 }
599
600 /* Treat the case where no special handling was requested in a fastpath way */
601 /* copy will do if the GCP_REORDER flag is not set */
602 if (lpResults->lpOutString)
603 lstrcpynW( lpResults->lpOutString, lpString, nSet );
604
605 if (lpResults->lpOrder)
606 {
607 for (i = 0; i < nSet; i++)
608 lpResults->lpOrder[i] = i;
609 }
610
611 /* FIXME: Will use the placement chars */
612 if (lpResults->lpDx)
613 {
614 int c;
615 for (i = 0; i < nSet; i++)
616 {
617 if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
618 lpResults->lpDx[i]= c;
619 }
620 }
621
622 if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
623 {
624 int pos = 0;
625
626 lpResults->lpCaretPos[0] = 0;
627 for (i = 1; i < nSet; i++)
628 if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
629 lpResults->lpCaretPos[i] = (pos += size.cx);
630 }
631
632 if (lpResults->lpGlyphs)
633 NtGdiGetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
634
635 if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
636 ret = MAKELONG(size.cx, size.cy);
637
638 return ret;
639}
LPKGCP LpkGetCharacterPlacement
Definition: utils.c:6
#define LPK_GCP
Definition: gdi32p.h:83
BOOL WINAPI LoadLPK(INT LpkFunctionID)
Definition: utils.c:423
GLsizeiptr size
Definition: glext.h:5919
__kernel_entry W32KAPI DWORD APIENTRY NtGdiGetGlyphIndicesW(_In_ HDC hdc, _In_reads_opt_(cwc) LPCWSTR pwc, _In_ INT cwc, _Out_writes_opt_(cwc) LPWORD pgi, _In_ DWORD iMode)
Definition: freetype.c:7921
INT * lpCaretPos
Definition: wingdi.h:2435
LPWSTR lpClass
Definition: wingdi.h:2436
UINT * lpOrder
Definition: wingdi.h:2433
LPWSTR lpGlyphs
Definition: wingdi.h:2437
#define MAKELONG(a, b)
Definition: typedefs.h:249
BOOL WINAPI GetCharWidth32W(HDC hdc, UINT iFirstChar, UINT iLastChar, LPINT lpBuffer)
Definition: font.c:763
#define GCP_REORDER
Definition: wingdi.h:843
BOOL WINAPI GetTextExtentPoint32W(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE psizl)

◆ GetCharWidth32A()

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

Definition at line 856 of file font.c.

862{
863 INT wlen, count = 0;
864 LPSTR str;
865 LPWSTR wstr;
866 BOOL ret = TRUE;
867
868 DPRINT("GetCharWidths32A\n");
869
870 str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
871 if (!str)
872 return FALSE;
873
874 wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
875 if (!wstr)
876 {
878 return FALSE;
879 }
880
882 wstr[0],
883 (ULONG) count,
884 (PWCHAR) wstr,
886 (PVOID) lpBuffer);
887
889 HeapFree(GetProcessHeap(), 0, wstr);
890
891 return ret;
892}
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
__kernel_entry W32KAPI BOOL APIENTRY NtGdiGetCharWidthW(_In_ HDC hdc, _In_ UINT wcFirst, _In_ UINT cwc, _In_reads_opt_(cwc) PWCHAR pwc, _In_ FLONG fl, _Out_writes_bytes_(cwc *sizeof(ULONG)) PVOID pvBuf)
#define GCW_WIN32
Definition: ntgdityp.h:204
#define GCW_NOFLOAT
Definition: ntgdityp.h:205

◆ GetCharWidth32W()

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

Definition at line 763 of file font.c.

767{
768 DPRINT("GetCharWidths32W\n");
769 if ((!lpBuffer) || (iFirstChar > iLastChar))
770 {
772 return FALSE;
773 }
774 return NtGdiGetCharWidthW( hdc,
775 iFirstChar,
776 (ULONG)(iLastChar - iFirstChar + 1),
777 (PWCHAR) NULL,
779 (PVOID) lpBuffer);
780}

Referenced by GetCharacterPlacementW().

◆ GetCharWidthA()

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

Definition at line 813 of file font.c.

819{
820 INT wlen, count = 0;
821 LPSTR str;
822 LPWSTR wstr;
823 BOOL ret = TRUE;
824
825 DPRINT("GetCharWidthsA\n");
826
827 str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
828 if (!str)
829 return FALSE;
830
831 wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
832 if (!wstr)
833 {
835 return FALSE;
836 }
837
839 wstr[0],
840 (ULONG) count,
841 (PWCHAR) wstr,
843 (PVOID) lpBuffer);
844
846 HeapFree(GetProcessHeap(), 0, wstr);
847
848 return ret;
849}

◆ GetCharWidthFloatA()

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

Definition at line 899 of file font.c.

905{
906 INT wlen, count = 0;
907 LPSTR str;
908 LPWSTR wstr;
909 BOOL ret = TRUE;
910
911 DPRINT("GetCharWidthsFloatA\n");
912
913 str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
914 if (!str)
915 return FALSE;
916
917 wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
918 if (!wstr)
919 {
921 return FALSE;
922 }
923 ret = NtGdiGetCharWidthW( hdc, wstr[0], (ULONG) count, (PWCHAR) wstr, 0, (PVOID) pxBuffer);
924
926 HeapFree(GetProcessHeap(), 0, wstr);
927
928 return ret;
929}

◆ GetCharWidthFloatW()

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

Definition at line 713 of file font.c.

717{
718 DPRINT("GetCharWidthsFloatW\n");
719 if ((!pxBuffer) || (iFirstChar > iLastChar))
720 {
722 return FALSE;
723 }
724 return NtGdiGetCharWidthW( hdc,
725 iFirstChar,
726 (ULONG)(iLastChar - iFirstChar + 1),
727 (PWCHAR) NULL,
728 0,
729 (PVOID) pxBuffer);
730}

◆ GetCharWidthI()

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

Definition at line 1036 of file font.c.

1042{
1043 DPRINT("GetCharWidthsI\n");
1044 if (!lpBuffer || (!pgi && (giFirst == MAXUSHORT))) // Cannot be at max.
1045 {
1047 return FALSE;
1048 }
1049 if (!cgi) return TRUE;
1050 return NtGdiGetCharWidthW( hdc,
1051 giFirst,
1052 cgi,
1053 (PWCHAR) pgi,
1055 (PVOID) lpBuffer );
1056}
#define GCW_INDICES
Definition: ntgdityp.h:206
#define MAXUSHORT
Definition: typedefs.h:83

◆ GetCharWidthW()

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

Definition at line 738 of file font.c.

742{
743 DPRINT("GetCharWidthsW\n");
744 if ((!lpBuffer) || (iFirstChar > iLastChar))
745 {
747 return FALSE;
748 }
749 return NtGdiGetCharWidthW( hdc,
750 iFirstChar,
751 (ULONG)(iLastChar - iFirstChar + 1),
752 (PWCHAR) NULL,
754 (PVOID) lpBuffer);
755}

◆ GetEUDCTimeStamp()

ULONG WINAPI GetEUDCTimeStamp ( VOID  )

Definition at line 2708 of file font.c.

2709{
2711}
__kernel_entry W32KAPI ULONG APIENTRY NtGdiGetEudcTimeStampEx(_In_reads_opt_(cwcBaseFaceName) LPWSTR lpBaseFaceName, _In_ ULONG cwcBaseFaceName, _In_ BOOL bSystemTimeStamp)

◆ GetEUDCTimeStampExW()

DWORD WINAPI GetEUDCTimeStampExW ( LPWSTR  lpBaseFaceName)

Definition at line 2718 of file font.c.

2719{
2720 DWORD retValue = 0;
2721
2722 if (!lpBaseFaceName)
2723 {
2724 retValue = NtGdiGetEudcTimeStampEx(NULL,0,FALSE);
2725 }
2726 else
2727 {
2728 retValue = NtGdiGetEudcTimeStampEx(lpBaseFaceName, wcslen(lpBaseFaceName), FALSE);
2729 }
2730
2731 return retValue;
2732}
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)

◆ GetFontAssocStatus()

ULONG WINAPI GetFontAssocStatus ( HDC  hdc)

Definition at line 2739 of file font.c.

2740{
2741 ULONG retValue = 0;
2742
2743 if (hdc)
2744 {
2745 retValue = NtGdiQueryFontAssocInfo(hdc);
2746 }
2747
2748 return retValue;
2749}
__kernel_entry W32KAPI ULONG APIENTRY NtGdiQueryFontAssocInfo(_In_ HDC hdc)

◆ GetFontData()

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

Definition at line 2780 of file font.c.

2785{
2786 if (!lpvBuffer)
2787 {
2788 cbData = 0;
2789 }
2790 return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2791}
_In_ DWORD _In_ DWORD dwOffset
Definition: ntgdi.h:2033
_In_ DWORD dwTable
Definition: ntgdi.h:2032
DWORD APIENTRY NtGdiGetFontData(HDC hDC, DWORD Table, DWORD Offset, LPVOID Buffer, DWORD Size)
Definition: font.c:663

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 1063 of file font.c.

1066{
1067 DWORD Gcp = 0, Ret = 0;
1068 if (gbLpk)
1069 {
1070 Ret = NtGdiGetTextCharsetInfo(hDc, NULL, 0);
1071 if ((Ret == ARABIC_CHARSET) || (Ret == HEBREW_CHARSET))
1073 }
1075 if ( Gcp == GCP_ERROR)
1076 return Gcp;
1077 else
1078 Ret = Gcp | Ret;
1079 return Ret;
1080}
BOOL gbLpk
Definition: dllmain.c:12
DWORD WINAPI GetDCDWord(_In_ HDC hdc, _In_ UINT u, _In_ DWORD dwError)
Definition: dc.c:787
__kernel_entry W32KAPI INT APIENTRY NtGdiGetTextCharsetInfo(_In_ HDC hdc, _Out_opt_ LPFONTSIGNATURE lpSig, _In_ DWORD dwFlags)
@ GdiGetFontLanguageInfo
Definition: ntgdityp.h:54
#define GCP_GLYPHSHAPE
Definition: wingdi.h:833
#define GCP_DIACRITIC
Definition: wingdi.h:831
#define GCP_LIGATE
Definition: wingdi.h:837
#define ARABIC_CHARSET
Definition: wingdi.h:394
#define GCP_KASHIDA
Definition: wingdi.h:836
#define GCP_ERROR
Definition: wingdi.h:829
#define HEBREW_CHARSET
Definition: wingdi.h:393

◆ GetGlyphIndicesA()

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

Definition at line 1087 of file font.c.

1094{
1095 DWORD Ret;
1096 WCHAR *lpstrW;
1097 INT countW;
1098
1099 lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
1100
1101 if (lpstrW == NULL)
1102 return GDI_ERROR;
1103
1104 Ret = NtGdiGetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
1105 HeapFree(GetProcessHeap(), 0, lpstrW);
1106 return Ret;
1107}
GLbitfield flags
Definition: glext.h:7161
static LPCSTR lpstr
Definition: font.c:51
#define GDI_ERROR
Definition: wingdi.h:1309

◆ GetGlyphOutlineA()

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

Definition at line 1114 of file font.c.

1123{
1124
1125 LPWSTR p = NULL;
1126 DWORD ret;
1127 UINT c;
1128 DPRINT("GetGlyphOutlineA uChar %x\n", uChar);
1129 if (!lpgm || !lpmat2) return GDI_ERROR;
1130 if(!(uFormat & GGO_GLYPH_INDEX))
1131 {
1132 int len;
1133 char mbchs[2];
1134 if(uChar > 0xff) /* but, 2 bytes character only */
1135 {
1136 len = 2;
1137 mbchs[0] = (uChar & 0xff00) >> 8;
1138 mbchs[1] = (uChar & 0xff);
1139 }
1140 else
1141 {
1142 len = 1;
1143 mbchs[0] = (uChar & 0xff);
1144 }
1145 p = FONT_mbtowc(hdc, mbchs, len, NULL, NULL);
1146 if(!p)
1147 return GDI_ERROR;
1148 c = p[0];
1149 }
1150 else
1151 c = uChar;
1152 ret = NtGdiGetGlyphOutline(hdc, c, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
1153 HeapFree(GetProcessHeap(), 0, p);
1154 return ret;
1155}
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
__kernel_entry W32KAPI ULONG APIENTRY NtGdiGetGlyphOutline(_In_ HDC hdc, _In_ WCHAR wch, _In_ UINT iFormat, _Out_ LPGLYPHMETRICS pgm, _In_ ULONG cjBuf, _Out_writes_bytes_opt_(cjBuf) PVOID pvBuf, _In_ LPMAT2 pmat2, _In_ BOOL bIgnoreRotation)
#define CONST
Definition: pedump.c:81
Definition: wingdi.h:2472
#define GGO_GLYPH_INDEX
Definition: wingdi.h:855

◆ GetGlyphOutlineW()

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

Definition at line 1163 of file font.c.

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

◆ GetGlyphOutlineWow()

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

Definition at line 1184 of file font.c.

1193{
1196 return 0;
1197}

◆ GetKerningPairsA()

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

Definition at line 1577 of file font.c.

1580{
1581 INT charset;
1582 CHARSETINFO csi;
1583 CPINFO cpi;
1584 DWORD i, total_kern_pairs, kern_pairs_copied = 0;
1585 KERNINGPAIR *kern_pairW;
1586
1587 if (!cPairs && kern_pairA)
1588 {
1590 return 0;
1591 }
1592
1595 {
1596 DPRINT1("Can't find codepage for charset %d\n", charset);
1597 return 0;
1598 }
1599 /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
1600 * to fail on an invalid character for CP_SYMBOL.
1601 */
1602 cpi.DefaultChar[0] = 0;
1603 if (csi.ciACP != CP_SYMBOL && !GetCPInfo(csi.ciACP, &cpi))
1604 {
1605 DPRINT1("Can't find codepage %u info\n", csi.ciACP);
1606 return 0;
1607 }
1608 DPRINT("charset %d => codepage %u\n", charset, csi.ciACP);
1609
1610 total_kern_pairs = NtGdiGetKerningPairs(hDC, 0, NULL);
1611 if (!total_kern_pairs) return 0;
1612
1613 if (!cPairs && !kern_pairA) return total_kern_pairs;
1614
1615 kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
1616 if (kern_pairW == NULL)
1617 {
1618 return 0;
1619 }
1620 GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
1621
1622 for (i = 0; i < total_kern_pairs; i++)
1623 {
1624 char first, second;
1625
1626 if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
1627 continue;
1628
1629 if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
1630 continue;
1631
1632 if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
1633 continue;
1634
1635 if (kern_pairA)
1636 {
1637 if (kern_pairs_copied >= cPairs) break;
1638
1639 kern_pairA->wFirst = (BYTE)first;
1640 kern_pairA->wSecond = (BYTE)second;
1641 kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
1642 kern_pairA++;
1643 }
1644 kern_pairs_copied++;
1645 }
1646
1647 HeapFree(GetProcessHeap(), 0, kern_pairW);
1648
1649 return kern_pairs_copied;
1650}
#define DPRINT1
Definition: precomp.h:8
#define ULongToPtr(ul)
Definition: basetsd.h:92
CFF_Charset charset
Definition: cffcmap.c:138
BOOL WINAPI GetCPInfo(UINT codepage, LPCPINFO cpinfo)
Definition: locale.c:2144
const GLint * first
Definition: glext.h:5794
static UINT first
Definition: font.c:44
__kernel_entry W32KAPI ULONG APIENTRY NtGdiGetKerningPairs(_In_ HDC hdc, _In_ ULONG cPairs, _Out_writes_to_opt_(cPairs, return) KERNINGPAIR *pkpDst)
BYTE DefaultChar[MAX_DEFAULTCHAR]
Definition: winnls.h:584
WORD wSecond
Definition: wingdi.h:2465
int iKernAmount
Definition: wingdi.h:2466
int WINAPI GetTextCharset(_In_ HDC)
Definition: text.c:187
#define TCI_SRCCHARSET
Definition: wingdi.h:961
DWORD WINAPI GetKerningPairsW(_In_ HDC hdc, _In_ DWORD nPairs, _Out_writes_to_opt_(nPairs, return) LPKERNINGPAIR lpKernPair)
BOOL WINAPI TranslateCharsetInfo(_Inout_ PDWORD, _Out_ LPCHARSETINFO, _In_ DWORD)
#define CP_SYMBOL
Definition: winnls.h:236

◆ GetKerningPairsW()

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

Definition at line 1557 of file font.c.

1560{
1561 if ((cPairs != 0) || (pkpDst == 0))
1562 {
1563 return NtGdiGetKerningPairs(hdc,cPairs,pkpDst);
1564 }
1565 else
1566 {
1568 return 0;
1569 }
1570}

◆ GetOutlineTextMetricsA()

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

Definition at line 1204 of file font.c.

1209{
1210 char buf[512], *ptr;
1211 UINT ret, needed;
1213 OUTLINETEXTMETRICA *output = lpOTM;
1214 INT left, len;
1215
1216 if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1217 return 0;
1218 if(ret > sizeof(buf))
1219 {
1220 lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1221 if (lpOTMW == NULL)
1222 {
1223 return 0;
1224 }
1225 }
1226 GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1227
1228 needed = sizeof(OUTLINETEXTMETRICA);
1229 if(lpOTMW->otmpFamilyName)
1230 needed += WideCharToMultiByte(CP_ACP, 0,
1231 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFamilyName), -1,
1232 NULL, 0, NULL, NULL);
1233 if(lpOTMW->otmpFaceName)
1234 needed += WideCharToMultiByte(CP_ACP, 0,
1235 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFaceName), -1,
1236 NULL, 0, NULL, NULL);
1237 if(lpOTMW->otmpStyleName)
1238 needed += WideCharToMultiByte(CP_ACP, 0,
1239 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpStyleName), -1,
1240 NULL, 0, NULL, NULL);
1241 if(lpOTMW->otmpFullName)
1242 needed += WideCharToMultiByte(CP_ACP, 0,
1243 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFullName), -1,
1244 NULL, 0, NULL, NULL);
1245
1246 if(!lpOTM)
1247 {
1248 ret = needed;
1249 goto end;
1250 }
1251
1252 DPRINT("needed = %u\n", needed);
1253 if(needed > cbData)
1254 {
1255 /* Since the supplied buffer isn't big enough, we'll alloc one
1256 that is and memcpy the first cbData bytes into the lpOTM at
1257 the end. */
1258 output = HeapAlloc(GetProcessHeap(), 0, needed);
1259 if (output == NULL)
1260 {
1261 goto end;
1262 }
1263 }
1264
1265 ret = output->otmSize = min(needed, cbData);
1267 output->otmFiller = 0;
1268 output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1269 output->otmfsSelection = lpOTMW->otmfsSelection;
1270 output->otmfsType = lpOTMW->otmfsType;
1271 output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1272 output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1273 output->otmItalicAngle = lpOTMW->otmItalicAngle;
1274 output->otmEMSquare = lpOTMW->otmEMSquare;
1275 output->otmAscent = lpOTMW->otmAscent;
1276 output->otmDescent = lpOTMW->otmDescent;
1277 output->otmLineGap = lpOTMW->otmLineGap;
1278 output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1279 output->otmsXHeight = lpOTMW->otmsXHeight;
1280 output->otmrcFontBox = lpOTMW->otmrcFontBox;
1281 output->otmMacAscent = lpOTMW->otmMacAscent;
1282 output->otmMacDescent = lpOTMW->otmMacDescent;
1283 output->otmMacLineGap = lpOTMW->otmMacLineGap;
1284 output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1285 output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1289 output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1291 output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1293
1294
1295 ptr = (char*)(output + 1);
1296 left = needed - sizeof(*output);
1297
1298 if(lpOTMW->otmpFamilyName)
1299 {
1300 output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1302 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFamilyName), -1,
1303 ptr, left, NULL, NULL);
1304 left -= len;
1305 ptr += len;
1306 }
1307 else
1308 output->otmpFamilyName = 0;
1309
1310 if(lpOTMW->otmpFaceName)
1311 {
1312 output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1314 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFaceName), -1,
1315 ptr, left, NULL, NULL);
1316 left -= len;
1317 ptr += len;
1318 }
1319 else
1320 output->otmpFaceName = 0;
1321
1322 if(lpOTMW->otmpStyleName)
1323 {
1324 output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1326 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpStyleName), -1,
1327 ptr, left, NULL, NULL);
1328 left -= len;
1329 ptr += len;
1330 }
1331 else
1332 output->otmpStyleName = 0;
1333
1334 if(lpOTMW->otmpFullName)
1335 {
1336 output->otmpFullName = (LPSTR)(ptr - (char*)output);
1338 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFullName), -1,
1339 ptr, left, NULL, NULL);
1340 left -= len;
1341 }
1342 else
1343 output->otmpFullName = 0;
1344
1345 ASSERT(left == 0);
1346
1347 if(output != lpOTM)
1348 {
1349 memcpy(lpOTM, output, cbData);
1350 HeapFree(GetProcessHeap(), 0, output);
1351
1352 /* check if the string offsets really fit into the provided size */
1353 /* FIXME: should we check string length as well? */
1354 if ((UINT_PTR)lpOTM->otmpFamilyName >= lpOTM->otmSize)
1355 lpOTM->otmpFamilyName = 0; /* doesn't fit */
1356
1357 if ((UINT_PTR)lpOTM->otmpFaceName >= lpOTM->otmSize)
1358 lpOTM->otmpFaceName = 0; /* doesn't fit */
1359
1360 if ((UINT_PTR)lpOTM->otmpStyleName >= lpOTM->otmSize)
1361 lpOTM->otmpStyleName = 0; /* doesn't fit */
1362
1363 if ((UINT_PTR)lpOTM->otmpFullName >= lpOTM->otmSize)
1364 lpOTM->otmpFullName = 0; /* doesn't fit */
1365 }
1366
1367end:
1368 if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1369 HeapFree(GetProcessHeap(), 0, lpOTMW);
1370
1371 return ret;
1372}
#define CP_ACP
Definition: compat.h:109
GLuint GLuint end
Definition: gl.h:1545
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLint left
Definition: glext.h:7726
#define ASSERT(a)
Definition: mode.c:44
static PVOID ptr
Definition: dispmode.c:27
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
int otmsStrikeoutPosition
Definition: wingdi.h:2504
POINT otmptSuperscriptOffset
Definition: wingdi.h:2502
POINT otmptSubscriptSize
Definition: wingdi.h:2499
PANOSE otmPanoseNumber
Definition: wingdi.h:2482
POINT otmptSubscriptOffset
Definition: wingdi.h:2500
TEXTMETRICA otmTextMetrics
Definition: wingdi.h:2480
POINT otmptSuperscriptSize
Definition: wingdi.h:2501
int otmsUnderscorePosition
Definition: wingdi.h:2506
UINT otmsStrikeoutSize
Definition: wingdi.h:2503
PANOSE otmPanoseNumber
Definition: wingdi.h:2516
POINT otmptSuperscriptOffset
Definition: wingdi.h:2536
POINT otmptSuperscriptSize
Definition: wingdi.h:2535
POINT otmptSubscriptSize
Definition: wingdi.h:2533
int otmsStrikeoutPosition
Definition: wingdi.h:2538
int otmsUnderscorePosition
Definition: wingdi.h:2540
TEXTMETRICW otmTextMetrics
Definition: wingdi.h:2514
POINT otmptSubscriptOffset
Definition: wingdi.h:2534
UINT otmsStrikeoutSize
Definition: wingdi.h:2537
int intptr_t
Definition: vcruntime.h:134
VOID FASTCALL FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA)
Definition: font.c:81
struct _OUTLINETEXTMETRICA OUTLINETEXTMETRICA
UINT WINAPI GetOutlineTextMetricsW(_In_ HDC hdc, _In_ UINT cjCopy, _Out_writes_bytes_opt_(cjCopy) LPOUTLINETEXTMETRICW potm)

◆ GetOutlineTextMetricsW()

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

Definition at line 1403 of file font.c.

1408{
1409 TMDIFF Tmd; // Should not be zero.
1410 UINT Size, AvailableSize = 0, StringSize;
1411 XFORM DevToWorld;
1412 OUTLINETEXTMETRICW* LocalOTM;
1413 WCHAR* Str;
1414 BYTE* Ptr;
1415
1416 /* Get the structure */
1418 if (!Size)
1419 return 0;
1420 if (!lpOTM || (cbData < sizeof(*lpOTM)))
1421 return Size;
1422
1423 LocalOTM = HeapAlloc(GetProcessHeap(), 0, Size);
1424 LocalOTM->otmSize = Size;
1426 if (!Size)
1427 {
1428 HeapFree(GetProcessHeap(), 0, LocalOTM);
1429 return 0;
1430 }
1431
1433 {
1434 DPRINT1("NtGdiGetTransform failed!\n");
1435 HeapFree(GetProcessHeap(), 0, LocalOTM);
1437 return 0;
1438 }
1439
1440 /* Fill in DC specific data */
1443 LocalOTM->otmTextMetrics.tmHeight = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmHeight );
1444 LocalOTM->otmTextMetrics.tmAscent = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmAscent );
1445 LocalOTM->otmTextMetrics.tmDescent = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmDescent );
1448 LocalOTM->otmTextMetrics.tmAveCharWidth = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmAveCharWidth );
1449 LocalOTM->otmTextMetrics.tmMaxCharWidth = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmMaxCharWidth );
1450 LocalOTM->otmTextMetrics.tmOverhang = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmOverhang );
1451 LocalOTM->otmAscent = height_to_LP( &DevToWorld, LocalOTM->otmAscent);
1452 LocalOTM->otmDescent = height_to_LP( &DevToWorld, LocalOTM->otmDescent);
1453 LocalOTM->otmLineGap = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmLineGap));
1454 LocalOTM->otmsCapEmHeight = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsCapEmHeight));
1455 LocalOTM->otmsXHeight = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsXHeight));
1456 LocalOTM->otmrcFontBox.top = height_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.top);
1457 LocalOTM->otmrcFontBox.bottom = height_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.bottom);
1458 LocalOTM->otmrcFontBox.left = width_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.left);
1459 LocalOTM->otmrcFontBox.right = width_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.right);
1460 LocalOTM->otmMacAscent = height_to_LP( &DevToWorld, LocalOTM->otmMacAscent);
1461 LocalOTM->otmMacDescent = height_to_LP( &DevToWorld, LocalOTM->otmMacDescent);
1462 LocalOTM->otmMacLineGap = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmMacLineGap));
1463 LocalOTM->otmptSubscriptSize.x = width_to_LP( &DevToWorld, LocalOTM->otmptSubscriptSize.x);
1464 LocalOTM->otmptSubscriptSize.y = height_to_LP( &DevToWorld, LocalOTM->otmptSubscriptSize.y);
1465 LocalOTM->otmptSubscriptOffset.x = width_to_LP( &DevToWorld, LocalOTM->otmptSubscriptOffset.x);
1466 LocalOTM->otmptSubscriptOffset.y = height_to_LP( &DevToWorld, LocalOTM->otmptSubscriptOffset.y);
1467 LocalOTM->otmptSuperscriptSize.x = width_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptSize.x);
1468 LocalOTM->otmptSuperscriptSize.y = height_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptSize.y);
1469 LocalOTM->otmptSuperscriptOffset.x = width_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptOffset.x);
1470 LocalOTM->otmptSuperscriptOffset.y = height_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptOffset.y);
1471 LocalOTM->otmsStrikeoutSize = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsStrikeoutSize));
1472 LocalOTM->otmsStrikeoutPosition = height_to_LP( &DevToWorld, LocalOTM->otmsStrikeoutPosition);
1473 LocalOTM->otmsUnderscoreSize = height_to_LP( &DevToWorld, LocalOTM->otmsUnderscoreSize);
1474 LocalOTM->otmsUnderscorePosition = height_to_LP( &DevToWorld, LocalOTM->otmsUnderscorePosition);
1475
1476 /* Copy what we can */
1477 CopyMemory(lpOTM, LocalOTM, min(Size, cbData));
1478
1479 lpOTM->otmpFamilyName = NULL;
1480 lpOTM->otmpFaceName = NULL;
1481 lpOTM->otmpStyleName = NULL;
1482 lpOTM->otmpFullName = NULL;
1483
1484 Size = sizeof(*lpOTM);
1485 AvailableSize = cbData - Size;
1486 Ptr = (BYTE*)lpOTM + sizeof(*lpOTM);
1487
1488 /* Fix string values up */
1489 if (LocalOTM->otmpFamilyName)
1490 {
1491 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFamilyName);
1492 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1493 if (AvailableSize >= StringSize)
1494 {
1495 CopyMemory(Ptr, Str, StringSize);
1496 lpOTM->otmpFamilyName = (PSTR)(Ptr - (BYTE*)lpOTM);
1497 Ptr += StringSize;
1498 AvailableSize -= StringSize;
1499 Size += StringSize;
1500 }
1501 }
1502
1503 if (LocalOTM->otmpFaceName)
1504 {
1505 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFaceName);
1506 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1507 if (AvailableSize >= StringSize)
1508 {
1509 CopyMemory(Ptr, Str, StringSize);
1510 lpOTM->otmpFaceName = (PSTR)(Ptr - (BYTE*)lpOTM);
1511 Ptr += StringSize;
1512 AvailableSize -= StringSize;
1513 Size += StringSize;
1514 }
1515 }
1516
1517 if (LocalOTM->otmpStyleName)
1518 {
1519 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpStyleName);
1520 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1521 if (AvailableSize >= StringSize)
1522 {
1523 CopyMemory(Ptr, Str, StringSize);
1524 lpOTM->otmpStyleName = (PSTR)(Ptr - (BYTE*)lpOTM);
1525 Ptr += StringSize;
1526 AvailableSize -= StringSize;
1527 Size += StringSize;
1528 }
1529 }
1530
1531 if (LocalOTM->otmpFullName)
1532 {
1533 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFullName);
1534 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1535 if (AvailableSize >= StringSize)
1536 {
1537 CopyMemory(Ptr, Str, StringSize);
1538 lpOTM->otmpFullName = (PSTR)(Ptr - (BYTE*)lpOTM);
1539 Ptr += StringSize;
1540 AvailableSize -= StringSize;
1541 Size += StringSize;
1542 }
1543 }
1544
1545 lpOTM->otmSize = Size;
1546
1547 HeapFree(GetProcessHeap(), 0, LocalOTM);
1548
1549 return Size;
1550}
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
__kernel_ptrdiff_t ptrdiff_t
Definition: linux.h:247
#define abs(i)
Definition: fconv.c:206
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
BOOL APIENTRY NtGdiGetTransform(_In_ HDC hdc, _In_ DWORD iXform, _Out_ LPXFORM pxf)
__kernel_entry W32KAPI ULONG APIENTRY NtGdiGetOutlineTextMetricsInternalW(_In_ HDC hdc, _In_ ULONG cjotm, _Out_writes_bytes_opt_(cjotm) OUTLINETEXTMETRICW *potmw, _Out_ TMDIFF *ptmd)
#define GdiDeviceSpaceToWorldSpace
Definition: ntgdityp.h:185
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
char * PSTR
Definition: typedefs.h:51
static INT width_to_LP(XFORM *xForm, INT width)
Definition: font.c:1388
static INT INTERNAL_YDSTOWS(XFORM *xForm, INT height)
Definition: font.c:1377
static INT height_to_LP(XFORM *xForm, INT height)
Definition: font.c:1393
#define CopyMemory
Definition: winbase.h:1741
int WINAPI GetDeviceCaps(_In_opt_ HDC, _In_ int)
#define LOGPIXELSY
Definition: wingdi.h:719
#define LOGPIXELSX
Definition: wingdi.h:718

◆ height_to_LP()

static INT height_to_LP ( XFORM xForm,
INT  height 
)
inlinestatic

Definition at line 1393 of file font.c.

1394{
1395 return GDI_ROUND( (double)height * fabs( xForm->eM22 ));
1396}
_Check_return_ _CRT_JIT_INTRINSIC double __cdecl fabs(_In_ double x)
Definition: fabs.c:17
FLOAT eM22
Definition: wingdi.h:1724
static __inline INT GDI_ROUND(FLOAT val)
Definition: font.c:24

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 1947 of file font.c.

1953{
1954 // FIXME: pfl
1955 // FIXME: bFlag
1956
1957 *pcwc = *pcFiles = 0;
1958
1959 if (!*pszFiles)
1960 {
1962 return NULL;
1963 }
1964
1965 // Build "Fonts" path
1966 WCHAR szFontsDir[MAX_PATH];
1967 GetWindowsDirectoryW(szFontsDir, _countof(szFontsDir));
1968 StringCchCatW(szFontsDir, _countof(szFontsDir), L"\\Fonts");
1969
1970 // Count the number of paths separated by '|'.
1971 ULONG pathCount = 1;
1972 for (PCWSTR pch1 = pszFiles; *pch1; ++pch1)
1973 {
1974 if (*pch1 == L'|')
1975 pathCount++;
1976 }
1977
1978 // Allocate memory for the paths.
1979 SIZE_T cchBuff = pathCount * MAX_PATH;
1980 PWSTR pszBuff = HEAP_alloc(cchBuff * sizeof(WCHAR));
1981 if (!pszBuff)
1982 return NULL;
1983
1984 pszBuff[0] = UNICODE_NULL;
1985 *pcFiles = pathCount;
1986
1987 // Convert paths
1988 DWORD dwError = ERROR_SUCCESS;
1989 PCWSTR pch1, pch1Prev;
1990 BOOL bFirst = TRUE;
1991 for (pch1 = pch1Prev = pszFiles;; ++pch1)
1992 {
1993 if (*pch1 && *pch1 != L'|')
1994 continue;
1995
1996 UINT_PTR spanLen = pch1 - pch1Prev;
1997 if (spanLen < _countof(L".ttf") || spanLen >= MAX_PATH)
1998 {
1999 dwError = ERROR_INVALID_FUNCTION;
2000 break;
2001 }
2002
2003 WCHAR szFileName[MAX_PATH], szFullPath[MAX_PATH];
2004 StringCchCopyNW(szFileName, _countof(szFileName), pch1Prev, spanLen);
2005
2006 // Search file
2007 if (!SearchPathW(L".", szFileName, NULL, _countof(szFullPath), szFullPath, NULL) &&
2008 !SearchPathW(szFontsDir, szFileName, NULL, _countof(szFullPath), szFullPath, NULL))
2009 {
2010 dwError = ERROR_FILE_NOT_FOUND;
2011 break;
2012 }
2013
2014 if (bFirst)
2015 {
2016 bFirst = FALSE;
2017 }
2018 else
2019 {
2020 SIZE_T cch = wcslen(szFullPath);
2021 if (cch < _countof(L".pfb"))
2022 {
2023 dwError = ERROR_INVALID_FUNCTION;
2024 break;
2025 }
2026
2027 // Check filename extension
2028 PCWSTR pchDotExt = &szFullPath[cch - 4];
2029 if (_wcsicmp(pchDotExt, L".pfb") != 0 &&
2030 _wcsicmp(pchDotExt, L".mmm") != 0)
2031 {
2032 dwError = ERROR_INVALID_FUNCTION;
2033 break;
2034 }
2035 }
2036
2037 // Convert to an NT path
2038 UNICODE_STRING NtAbsPath;
2039 if (!RtlDosPathNameToNtPathName_U(szFullPath, &NtAbsPath, NULL, NULL))
2040 {
2041 dwError = ERROR_OUTOFMEMORY;
2042 break;
2043 }
2044
2045 // Append a path and '|' to pszBuff
2046 if (StringCchCatW(pszBuff, cchBuff, NtAbsPath.Buffer) != S_OK ||
2047 StringCchCatW(pszBuff, cchBuff, L"|") != S_OK)
2048 {
2049 RtlFreeUnicodeString(&NtAbsPath);
2050 dwError = ERROR_INVALID_FUNCTION;
2051 break;
2052 }
2053
2054 RtlFreeUnicodeString(&NtAbsPath);
2055
2056 if (!*pch1)
2057 break;
2058
2059 pch1Prev = pch1 + 1;
2060 }
2061
2062 if (dwError != ERROR_SUCCESS)
2063 {
2064 HEAP_free(pszBuff);
2065 *pcwc = *pcFiles = 0;
2066 if (dwError != ERROR_INVALID_FUNCTION)
2067 SetLastError(dwError);
2068 return NULL;
2069 }
2070
2071 *pcwc = (DWORD)wcslen(pszBuff);
2072
2073 // Convert '|' to '\0'
2074 for (PWSTR pch2 = pszBuff; *pch2; ++pch2)
2075 {
2076 if (*pch2 == L'|')
2077 *pch2 = UNICODE_NULL;
2078 }
2079
2080 return pszBuff;
2081}
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD WINAPI SearchPathW(IN LPCWSTR lpPath OPTIONAL, IN LPCWSTR lpFileName, IN LPCWSTR lpExtension OPTIONAL, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart OPTIONAL)
Definition: path.c:1298
UINT WINAPI GetWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2352
#define S_OK
Definition: intsafe.h:52
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:202
NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToNtPathName_U(_In_opt_z_ PCWSTR DosPathName, _Out_ PUNICODE_STRING NtPathName, _Out_opt_ PCWSTR *NtFileNamePart, _Out_opt_ PRTL_RELATIVE_NAME_U DirectoryInfo)
#define DWORD
Definition: nt_native.h:44
#define UNICODE_NULL
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:325
STRSAFEAPI StringCchCopyNW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:236
const uint16_t * PCWSTR
Definition: typedefs.h:57
ULONG_PTR SIZE_T
Definition: typedefs.h:80

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.

292{
293 int FontFamilyCount;
295 int Ret = 1;
296 int i;
297 ENUMLOGFONTEXA EnumLogFontExA;
298 NEWTEXTMETRICEXA NewTextMetricExA;
299 LOGFONTW lfW;
300 LONG InfoCount;
303
306 if (Info == NULL)
307 {
308 return 1;
309 }
310
311 /* Initialize the LOGFONT structure */
312 ZeroMemory(&lfW, sizeof(lfW));
313 if (!LogFont)
314 {
316 }
317 else
318 {
319 lfW.lfCharSet = LogFont->lfCharSet;
320 lfW.lfPitchAndFamily = LogFont->lfPitchAndFamily;
321 StringCbCopyW(lfW.lfFaceName, sizeof(lfW.lfFaceName), LogFont->lfFaceName);
322 }
323
324 /* Retrieve the font information */
325 InfoCount = INITIAL_FAMILY_COUNT;
326 FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, &lfW, Info, &InfoCount);
327 if (FontFamilyCount < 0)
328 {
330 return 1;
331 }
332
333 /* Resize the buffer if the buffer is too small */
334 if (INITIAL_FAMILY_COUNT < InfoCount)
335 {
337
338 Status = RtlULongMult(InfoCount, sizeof(FONTFAMILYINFO), &DataSize);
340 {
341 DPRINT1("Overflowed.\n");
342 return 1;
343 }
345 if (Info == NULL)
346 {
347 return 1;
348 }
349 FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, &lfW, Info, &InfoCount);
350 if (FontFamilyCount < 0 || FontFamilyCount < InfoCount)
351 {
353 return 1;
354 }
355 }
356
357 /* Sort and remove redundant information */
358 qsort(Info, FontFamilyCount, sizeof(*Info), IntFontFamilyCompare);
359 FontFamilyCount = IntFontFamilyListUnique(Info, FontFamilyCount, &lfW, dwFlags);
360
361 /* call the callback */
362 for (i = 0; i < FontFamilyCount; i++)
363 {
364 if (dwFlags & IEFF_UNICODE)
365 {
366 Ret = ((FONTENUMPROCW) EnumProc)(
367 (VOID*)&Info[i].EnumLogFontEx,
368 (VOID*)&Info[i].NewTextMetricEx,
369 Info[i].FontType, lParam);
370 }
371 else
372 {
373 // Could use EnumLogFontExW2A here?
374 LogFontW2A(&EnumLogFontExA.elfLogFont, &Info[i].EnumLogFontEx.elfLogFont);
375 WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfFullName, -1,
376 (LPSTR)EnumLogFontExA.elfFullName, LF_FULLFACESIZE, NULL, NULL);
377 WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfStyle, -1,
378 (LPSTR)EnumLogFontExA.elfStyle, LF_FACESIZE, NULL, NULL);
379 WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfScript, -1,
380 (LPSTR)EnumLogFontExA.elfScript, LF_FACESIZE, NULL, NULL);
381 NewTextMetricExW2A(&NewTextMetricExA,
382 &Info[i].NewTextMetricEx);
383 Ret = ((FONTENUMPROCA) EnumProc)(
384 (VOID*)&EnumLogFontExA,
385 (VOID*)&NewTextMetricExA,
386 Info[i].FontType, lParam);
387 }
388
389 if(Ret == 0)
390 break;
391 }
392
394
395 return Ret;
396}
static BOOL CALLBACK EnumProc(_In_ HWND hWnd, _In_ LPARAM lParam)
Definition: SetParent.c:53
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:616
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:634
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
LONG NTAPI NtGdiGetFontFamilyInfo(HDC Dc, const LOGFONTW *UnsafeLogFont, PFONTFAMILYINFO UnsafeInfo, LPLONG UnsafeInfoCount)
Definition: freetype.c:6556
VOID NTAPI LogFontW2A(LPLOGFONTA pA, CONST LOGFONTW *pW)
Definition: utils.c:375
#define LONG_MAX
Definition: intsafe.h:154
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4755
struct tagFONTFAMILYINFO FONTFAMILYINFO
long LONG
Definition: pedump.c:60
STRSAFEAPI StringCbCopyW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:166
LOGFONTA elfLogFont
Definition: wingdi.h:2696
BYTE elfFullName[LF_FULLFACESIZE]
Definition: wingdi.h:2697
BYTE elfScript[LF_FACESIZE]
Definition: wingdi.h:2699
BYTE elfStyle[LF_FACESIZE]
Definition: wingdi.h:2698
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
VOID FASTCALL NewTextMetricExW2A(NEWTEXTMETRICEXA *tma, NEWTEXTMETRICEXW *tmw)
Definition: font.c:203
static int __cdecl IntFontFamilyCompare(const void *ffi1, const void *ffi2)
Definition: font.c:247
int FASTCALL IntFontFamilyListUnique(FONTFAMILYINFO *InfoList, INT nCount, const LOGFONTW *plf, DWORD dwFlags)
Definition: font.c:257
#define INITIAL_FAMILY_COUNT
Definition: font.c:74
FARPROC FONTENUMPROCW
Definition: wingdi.h:2897
FARPROC FONTENUMPROCA
Definition: wingdi.h:2896
#define LF_FULLFACESIZE
Definition: wingdi.h:41

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

◆ INTERNAL_YDSTOWS()

static INT INTERNAL_YDSTOWS ( XFORM xForm,
INT  height 
)
inlinestatic

Definition at line 1377 of file font.c.

1378{
1379 double floatHeight;
1380
1381 /* Perform operation with floating point */
1382 floatHeight = (double)height * xForm->eM22;
1383 /* Round to integers */
1384 return GDI_ROUND(floatHeight);
1385}
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:89

Referenced by GetOutlineTextMetricsW().

◆ IntFontFamilyCompare()

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

Definition at line 247 of file font.c.

248{
250}
FORCEINLINE int FASTCALL IntFontFamilyCompareEx(const FONTFAMILYINFO *ffi1, const FONTFAMILYINFO *ffi2, DWORD dwCompareFlags)
Definition: font.c:214
#define IFFCX_STYLE
Definition: font.c:211
#define IFFCX_CHARSET
Definition: font.c:210

Referenced by IntEnumFontFamilies().

◆ IntFontFamilyCompareEx()

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

Definition at line 214 of file font.c.

216{
217 const LOGFONTW *plf1 = &ffi1->EnumLogFontEx.elfLogFont;
218 const LOGFONTW *plf2 = &ffi2->EnumLogFontEx.elfLogFont;
219 ULONG WeightDiff1, WeightDiff2;
220 int cmp = _wcsicmp(plf1->lfFaceName, plf2->lfFaceName);
221 if (cmp)
222 return cmp;
223 if (dwCompareFlags & IFFCX_CHARSET)
224 {
225 if (plf1->lfCharSet < plf2->lfCharSet)
226 return -1;
227 if (plf1->lfCharSet > plf2->lfCharSet)
228 return 1;
229 }
230 if (dwCompareFlags & IFFCX_STYLE)
231 {
232 WeightDiff1 = labs(plf1->lfWeight - FW_NORMAL);
233 WeightDiff2 = labs(plf2->lfWeight - FW_NORMAL);
234 if (WeightDiff1 < WeightDiff2)
235 return -1;
236 if (WeightDiff1 > WeightDiff2)
237 return 1;
238 if (plf1->lfItalic < plf2->lfItalic)
239 return -1;
240 if (plf1->lfItalic > plf2->lfItalic)
241 return 1;
242 }
243 return 0;
244}
_Check_return_ long __cdecl labs(_In_ long x)
#define cmp(status, error)
Definition: error.c:114
ENUMLOGFONTEXW EnumLogFontEx
Definition: ntgdibad.h:47
#define FW_NORMAL
Definition: wingdi.h:373

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.

259{
261 DWORD dwCompareFlags = 0;
262
263 if (plf->lfFaceName[0])
264 dwCompareFlags |= IFFCX_STYLE;
265
267 dwCompareFlags |= IFFCX_CHARSET;
268
269 first = InfoList;
270 last = &InfoList[nCount];
271
272 /* std::unique(first, last, IntFontFamilyCompareEx); */
273 if (first == last)
274 return 0;
275
276 result = first;
277 while (++first != last)
278 {
279 if (IntFontFamilyCompareEx(result, first, dwCompareFlags) != 0)
280 {
281 *(++result) = *first;
282 }
283 }
284 nCount = (int)(++result - InfoList);
285
286 return nCount;
287}
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
GLuint64EXT * result
Definition: glext.h:11304
static UINT UINT last
Definition: font.c:45

Referenced by IntEnumFontFamilies().

◆ NewEnumFontFamiliesExW()

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

Definition at line 2474 of file font.c.

2480{
2481 ULONG_PTR idEnum;
2482 ULONG cbDataSize, cbRetSize;
2483 PENUMFONTDATAW pEfdw;
2484 PBYTE pBuffer;
2485 PBYTE pMax;
2486 INT ret = 1;
2487
2488 /* Open enumeration handle and find out how much memory we need */
2489 idEnum = NtGdiEnumFontOpen(hDC,
2491 0,
2493 (lpLogfont && lpLogfont->lfFaceName[0])? lpLogfont->lfFaceName : NULL,
2494 lpLogfont? lpLogfont->lfCharSet : DEFAULT_CHARSET,
2495 &cbDataSize);
2496 if (idEnum == 0)
2497 {
2498 return 0;
2499 }
2500 if (cbDataSize == 0)
2501 {
2502 NtGdiEnumFontClose(idEnum);
2503 return 0;
2504 }
2505
2506 /* Allocate memory */
2507 pBuffer = HeapAlloc(GetProcessHeap(), 0, cbDataSize);
2508 if (pBuffer == NULL)
2509 {
2511 NtGdiEnumFontClose(idEnum);
2512 return 0;
2513 }
2514
2515 /* Do the enumeration */
2516 if (!NtGdiEnumFontChunk(hDC, idEnum, cbDataSize, &cbRetSize, (PVOID)pBuffer))
2517 {
2519 NtGdiEnumFontClose(idEnum);
2520 return 0;
2521 }
2522
2523 /* Get start and end address */
2524 pEfdw = (PENUMFONTDATAW)pBuffer;
2525 pMax = pBuffer + cbDataSize;
2526
2527 /* Iterate through the structures */
2528 while ((PBYTE)pEfdw < pMax && ret)
2529 {
2530 PNTMW_INTERNAL pNtmwi = (PNTMW_INTERNAL)((ULONG_PTR)pEfdw + pEfdw->ulNtmwiOffset);
2531
2532 ret = lpEnumFontFamExProcW((VOID*)&pEfdw->elfexdv.elfEnumLogfontEx,
2533 (VOID*)&pNtmwi->ntmw,
2534 pEfdw->dwFontType,
2535 lParam);
2536
2537 pEfdw = (PENUMFONTDATAW)((ULONG_PTR)pEfdw + pEfdw->cbSize);
2538 }
2539
2540 /* Release the memory and close handle */
2542 NtGdiEnumFontClose(idEnum);
2543
2544 return ret;
2545}
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
__kernel_entry W32KAPI BOOL APIENTRY NtGdiEnumFontChunk(_In_ HDC hdc, _In_ ULONG_PTR idEnum, _In_ ULONG cjEfdw, _Out_ ULONG *pcjEfdw, _Out_ PENUMFONTDATAW pefdw)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiEnumFontClose(_In_ ULONG_PTR idEnum)
__kernel_entry W32KAPI ULONG_PTR APIENTRY NtGdiEnumFontOpen(_In_ HDC hdc, _In_ ULONG iEnumType, _In_ FLONG flWin31Compat, _In_ ULONG cwchMax, _In_opt_ LPWSTR pwszFaceName, _In_ ULONG lfCharSet, _Out_ ULONG *pulCount)
struct _ENUMFONTDATAW * PENUMFONTDATAW
struct _NTMW_INTERNAL * PNTMW_INTERNAL
BYTE * PBYTE
Definition: pedump.c:66
PVOID pBuffer
ULONG cbSize
Definition: ntgdityp.h:382
DWORD dwFontType
Definition: ntgdityp.h:384
ENUMLOGFONTEXDVW elfexdv
Definition: ntgdityp.h:385
ULONG ulNtmwiOffset
Definition: ntgdityp.h:383
NEWTEXTMETRICEXW ntmw
Definition: ntgdityp.h:377
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define EfdFontFamilies
Definition: font.c:2470

◆ 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.

651{
652 ULONG nSet;
653 SIZE Size = {0,0};
654
655 if ( !lpString || uCount <= 0 || (nMaxExtent < 0 && nMaxExtent != -1 ) )
656 {
658 return 0;
659 }
660
661 if ( !lpResults )
662 {
663 if ( GetTextExtentPointW(hdc, lpString, uCount, &Size) )
664 {
665 return MAKELONG(Size.cx, Size.cy);
666 }
667 return 0;
668 }
669
670 nSet = uCount;
671 if ( nSet > lpResults->nGlyphs )
672 nSet = lpResults->nGlyphs;
673
675 (LPWSTR)lpString,
676 nSet,
677 nMaxExtent,
678 lpResults,
679 dwFlags);
680}
__kernel_entry W32KAPI DWORD APIENTRY NtGdiGetCharacterPlacementW(_In_ HDC hdc, _In_reads_z_(nCount) LPWSTR pwsz, _In_ INT nCount, _In_ INT nMaxExtent, _Inout_ LPGCP_RESULTSW pgcpw, _In_ DWORD dwFlags)

◆ NewTextMetricExW2A()

VOID FASTCALL NewTextMetricExW2A ( NEWTEXTMETRICEXA tma,
NEWTEXTMETRICEXW tmw 
)

Definition at line 203 of file font.c.

204{
205 NewTextMetricW2A(&tma->ntmTm, &tmw->ntmTm);
206 tma->ntmFontSig = tmw->ntmFontSig;
207}
NEWTEXTMETRICA ntmTm
Definition: wingdi.h:2671
FONTSIGNATURE ntmFontSig
Definition: wingdi.h:2672
NEWTEXTMETRICW ntmTm
Definition: wingdi.h:2675
FONTSIGNATURE ntmFontSig
Definition: wingdi.h:2676
VOID FASTCALL NewTextMetricW2A(NEWTEXTMETRICA *tma, NEWTEXTMETRICW *tmw)
Definition: font.c:193

Referenced by IntEnumFontFamilies().

◆ NewTextMetricW2A()

VOID FASTCALL NewTextMetricW2A ( NEWTEXTMETRICA tma,
NEWTEXTMETRICW tmw 
)

Definition at line 193 of file font.c.

194{
196 tma->ntmFlags = tmw->ntmFlags;
197 tma->ntmSizeEM = tmw->ntmSizeEM;
198 tma->ntmCellHeight = tmw->ntmCellHeight;
199 tma->ntmAvgWidth = tmw->ntmAvgWidth;
200}
UINT ntmCellHeight
Definition: wingdi.h:2640

Referenced by NewTextMetricExW2A().

◆ QueryFontAssocStatus()

DWORD WINAPI QueryFontAssocStatus ( VOID  )

Definition at line 2756 of file font.c.

2757{
2760 return 0;
2761}

◆ RemoveFontMemResourceEx()

BOOL WINAPI RemoveFontMemResourceEx ( HANDLE  fh)

Definition at line 2601 of file font.c.

2602{
2603 if (fh)
2604 {
2606 }
2608 return FALSE;
2609}
__kernel_entry W32KAPI BOOL APIENTRY NtGdiRemoveFontMemResourceEx(_In_ HANDLE hMMFont)

Referenced by START_TEST().

◆ RemoveFontResourceA()

BOOL WINAPI RemoveFontResourceA ( _In_ LPCSTR  lpFileName)

Definition at line 2183 of file font.c.

2184{
2186}
BOOL WINAPI RemoveFontResourceExA(_In_ LPCSTR lpFileName, _In_ DWORD fl, _In_opt_ PVOID pdv)
Definition: font.c:2191
_In_ LPCSTR lpFileName
Definition: winbase.h:3102

Referenced by Test_AddFontResourceA().

◆ RemoveFontResourceExA()

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

Definition at line 2191 of file font.c.

2195{
2196 if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
2197 {
2199 return FALSE;
2200 }
2201
2202 if (!lpFileName)
2203 return FALSE;
2204
2205 WCHAR szBuff[MAX_PATH];
2206 PWSTR FilenameW;
2207
2208 _SEH2_TRY
2209 {
2210 FilenameW = HEAP_strdupA2W_buf(lpFileName, szBuff, _countof(szBuff));
2211 }
2213 {
2214 FilenameW = NULL;
2215 }
2216 _SEH2_END;
2217
2218 if (!FilenameW)
2219 {
2221 return FALSE;
2222 }
2223
2224 BOOL result = RemoveFontResourceExW(FilenameW, fl, pdv);
2225 HEAP_strdupA2W_buf_free(FilenameW, szBuff);
2226 return result;
2227}
BOOL WINAPI RemoveFontResourceExW(_In_ LPCWSTR lpFileName, _In_ DWORD fl, _In_opt_ PVOID pdv)
Definition: font.c:2232

Referenced by RemoveFontResourceA(), and test_long_names().

◆ RemoveFontResourceExW()

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

Definition at line 2232 of file font.c.

2236{
2237 DPRINT("RemoveFontResourceExW\n");
2238
2239 if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
2240 {
2242 return FALSE;
2243 }
2244
2245 if (!lpFileName)
2246 return FALSE;
2247
2248 ULONG cFiles, cwc;
2249 PWSTR pszConverted = IntConvertFontPaths(lpFileName, &cFiles, &cwc, &fl, TRUE);
2250 if (!pszConverted)
2251 return FALSE;
2252
2253 BOOL ret = NtGdiRemoveFontResourceW(pszConverted, cwc, cFiles, fl, 0, NULL);
2254 HEAP_free(pszConverted);
2255 return ret;
2256}
__kernel_entry W32KAPI BOOL APIENTRY NtGdiRemoveFontResourceW(_In_reads_(cwc) WCHAR *pwszFiles, _In_ ULONG cwc, _In_ ULONG cFiles, _In_ ULONG fl, _In_ DWORD dwPidTid, _In_opt_ DESIGNVECTOR *pdv)
Definition: font.c:519

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

◆ RemoveFontResourceTracking()

int WINAPI RemoveFontResourceTracking ( LPCSTR  lpString,
int  unknown 
)

Definition at line 2632 of file font.c.

2633{
2636 return 0;
2637}

◆ RemoveFontResourceW()

BOOL WINAPI RemoveFontResourceW ( _In_ LPCWSTR  lpFileName)

Definition at line 2175 of file font.c.

2176{
2178}

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

◆ SetMapperFlags()

DWORD WINAPI SetMapperFlags ( HDC  hDC,
DWORD  flags 
)

Definition at line 2383 of file font.c.

2387{
2388 DWORD Ret = GDI_ERROR;
2389 PDC_ATTR Dc_Attr;
2390
2391 /* Get the DC attribute */
2392 Dc_Attr = GdiGetDcAttr(hDC);
2393 if (Dc_Attr == NULL)
2394 {
2396 return GDI_ERROR;
2397 }
2398
2399 if (NtCurrentTeb()->GdiTebBatch.HDC == hDC)
2400 {
2401 if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY)
2402 {
2403 NtGdiFlush();
2405 }
2406 }
2407
2408 if ( flags & ~1 )
2410 else
2411 {
2412 Ret = Dc_Attr->flFontMapper;
2413 Dc_Attr->flFontMapper = flags;
2414 }
2415 return Ret;
2416}
FORCEINLINE PDC_ATTR GdiGetDcAttr(HDC hdc)
Definition: gdi32p.h:477
#define NtCurrentTeb
__kernel_entry W32KAPI NTSTATUS APIENTRY NtGdiFlush(VOID)
Definition: gdibatch.c:471
#define DC_FONTTEXT_DIRTY
Definition: ntgdihdl.h:145
#define DC_MODE_DIRTY
Definition: ntgdihdl.h:144
ULONG ulDirty_
Definition: ntgdihdl.h:294
FLONG flFontMapper
Definition: ntgdihdl.h:316

◆ TranslateCharsetInfo()

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

Definition at line 2334 of file font.c.

2342{
2343 int index = 0;
2344 switch (flags)
2345 {
2346 case TCI_SRCFONTSIG:
2347 while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++;
2348 break;
2349 case TCI_SRCCODEPAGE:
2350 while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++;
2351 break;
2352 case TCI_SRCCHARSET:
2353 while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++;
2354 break;
2355 case TCI_SRCLOCALE:
2356 {
2357 LCID lCid = (LCID)PtrToUlong(lpSrc);
2358 LOCALESIGNATURE LocSig;
2359 INT Ret = GetLocaleInfoW(lCid, LOCALE_FONTSIGNATURE, (LPWSTR)&LocSig, 0);
2360 if ( GetLocaleInfoW(lCid, LOCALE_FONTSIGNATURE, (LPWSTR)&LocSig, Ret))
2361 {
2362 while (index < MAXTCIINDEX && !(LocSig.lsCsbDefault[0]>>index & 0x0001)) index++;
2363 break;
2364 }
2365 }
2366 default:
2368 return FALSE;
2369 }
2370 if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
2371 DPRINT("Index %d Charset %u CodePage %u FontSig %lu\n",
2372 index,FONT_tci[index].ciCharset,FONT_tci[index].ciACP,FONT_tci[index].fs.fsCsb[0]);
2373 memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
2374 return TRUE;
2375}
INT WINAPI GetLocaleInfoW(LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len)
Definition: locale.c:1666
#define PtrToUlong(u)
Definition: config.h:107
VOID WINAPI GdiSetLastError(DWORD dwErrCode)
Definition: misc.c:873
GLuint index
Definition: glext.h:6031
DWORD LCID
Definition: nls.h:13
Definition: ffs.h:70
static const CHARSETINFO FONT_tci[MAXTCIINDEX]
Definition: font.c:33
#define MAXTCIINDEX
Definition: font.c:32
#define TCI_SRCLOCALE
Definition: wingdi.h:964
#define TCI_SRCFONTSIG
Definition: wingdi.h:963
#define TCI_SRCCODEPAGE
Definition: wingdi.h:962
#define LOCALE_FONTSIGNATURE
Definition: winnls.h:127

◆ UnloadNetworkFonts()

VOID WINAPI UnloadNetworkFonts ( DWORD  unknown)

Definition at line 2768 of file font.c.

◆ width_to_LP()

static INT width_to_LP ( XFORM xForm,
INT  width 
)
inlinestatic

Definition at line 1388 of file font.c.

1389{
1390 return GDI_ROUND( (double)width * fabs( xForm->eM11));
1391}
GLint GLint GLsizei width
Definition: gl.h:1546
FLOAT eM11
Definition: wingdi.h:1721

Referenced by GetOutlineTextMetricsW().

Variable Documentation

◆ FONT_tci

const CHARSETINFO FONT_tci[MAXTCIINDEX]
static

Definition at line 33 of file font.c.

Referenced by TranslateCharsetInfo().