ReactOS 0.4.15-dev-7934-g1dc8d80
font.c File Reference
#include <precomp.h>
#include <math.h>
#include <strsafe.h>
#include <debug.h>
Include dependency graph for font.c:

Go to the source code of this file.

Macros

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

Functions

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

Variables

static const CHARSETINFO FONT_tci [MAXTCIINDEX]
 

Macro Definition Documentation

◆ EfdFontFamilies

#define EfdFontFamilies   3

Definition at line 2322 of file font.c.

◆ IEFF_EXTENDED

#define IEFF_EXTENDED   2

Definition at line 252 of file font.c.

◆ IEFF_UNICODE

#define IEFF_UNICODE   1

Definition at line 251 of file font.c.

◆ IFFCX_CHARSET

#define IFFCX_CHARSET   1

Definition at line 208 of file font.c.

◆ IFFCX_STYLE

#define IFFCX_STYLE   2

Definition at line 209 of file font.c.

◆ INITIAL_FAMILY_COUNT

#define INITIAL_FAMILY_COUNT   64

Definition at line 72 of file font.c.

◆ MAXTCIINDEX

#define MAXTCIINDEX   32

Definition at line 30 of file font.c.

◆ NDEBUG

#define NDEBUG

Definition at line 15 of file font.c.

Function Documentation

◆ AddFontMemResourceEx()

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

Definition at line 2455 of file font.c.

2461{
2462 if ( pbFont && cbFont && pcFonts)
2463 {
2464 return NtGdiAddFontMemResourceEx(pbFont, cbFont, NULL, 0, pcFonts);
2465 }
2467 return NULL;
2468}
#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 ( LPCSTR  lpszFilename)

Definition at line 2011 of file font.c.

2012{
2014 PWSTR FilenameW;
2015 int rc = 0;
2016
2017 Status = HEAP_strdupA2W ( &FilenameW, lpszFilename );
2018 if ( !NT_SUCCESS (Status) )
2019 {
2021 }
2022 else
2023 {
2024 rc = GdiAddFontResourceW ( FilenameW, 0, 0);
2025
2026 HEAP_free ( FilenameW );
2027 }
2028 return rc;
2029}
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS HEAP_strdupA2W(LPWSTR *ppszW, LPCSTR lpszA)
Definition: heap.c:43
VOID HEAP_free(LPVOID memory)
Definition: heap.c:63
Status
Definition: gdiplustypes.h:25
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
uint16_t * PWSTR
Definition: typedefs.h:56
int WINAPI GdiAddFontResourceW(LPCWSTR lpszFilename, FLONG fl, DESIGNVECTOR *pdv)
Definition: font.c:2404

◆ AddFontResourceExA()

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

Definition at line 1981 of file font.c.

1982{
1984 PWSTR FilenameW;
1985 int rc;
1986
1987 if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
1988 {
1990 return 0;
1991 }
1992
1993 Status = HEAP_strdupA2W ( &FilenameW, lpszFilename );
1994 if ( !NT_SUCCESS (Status) )
1995 {
1997 return 0;
1998 }
1999
2000 rc = GdiAddFontResourceW ( FilenameW, fl, 0 );
2001 HEAP_free ( FilenameW );
2002 return rc;
2003}
_In_ FLONG fl
Definition: winddi.h:1279

◆ AddFontResourceExW()

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

Definition at line 1964 of file font.c.

1965{
1966 if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
1967 {
1969 return 0;
1970 }
1971
1972 return GdiAddFontResourceW(lpszFilename, fl,0);
1973}

◆ AddFontResourceTracking()

int WINAPI AddFontResourceTracking ( LPCSTR  lpString,
int  unknown 
)

Definition at line 2491 of file font.c.

2495{
2498 return 0;
2499}
#define UNIMPLEMENTED
Definition: debug.h:115
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102

◆ AddFontResourceW()

int WINAPI AddFontResourceW ( LPCWSTR  lpszFilename)

Definition at line 2037 of file font.c.

2038{
2039 return GdiAddFontResourceW ( lpszFilename, 0, 0 );
2040}

◆ bInitSystemAndFontsDirectoriesW()

BOOL WINAPI bInitSystemAndFontsDirectoriesW ( LPWSTR SystemDir,
LPWSTR FontsDir 
)

Definition at line 2546 of file font.c.

2547{
2550 return 0;
2551}

◆ cGetTTFFromFOT()

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

Definition at line 2669 of file font.c.

2670{
2673 return 0;
2674}

◆ CreateFontA()

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

Definition at line 1844 of file font.c.

1860{
1861 ANSI_STRING StringA;
1862 UNICODE_STRING StringU;
1863 HFONT ret;
1864
1865 RtlInitAnsiString(&StringA, (LPSTR)lpszFace);
1866 RtlAnsiStringToUnicodeString(&StringU, &StringA, TRUE);
1867
1868 ret = CreateFontW(nHeight,
1869 nWidth,
1870 nEscapement,
1871 nOrientation,
1872 fnWeight,
1873 fdwItalic,
1874 fdwUnderline,
1875 fdwStrikeOut,
1876 fdwCharSet,
1877 fdwOutputPrecision,
1878 fdwClipPrecision,
1879 fdwQuality,
1880 fdwPitchAndFamily,
1881 StringU.Buffer);
1882
1883 RtlFreeUnicodeString(&StringU);
1884
1885 return ret;
1886}
#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)
int ret
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 1699 of file font.c.

1702{
1703 if (lplf)
1704 {
1705 LOGFONTW tlf;
1706
1707 LogFontA2W(&tlf, lplf);
1708 return CreateFontIndirectW(&tlf);
1709 }
1710 else return NULL;
1711}
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 1657 of file font.c.

1658{
1659 if (elfexd)
1660 {
1661 ENUMLOGFONTEXDVW Logfont;
1662
1664 &Logfont.elfEnumLogfontEx );
1665
1667 (PVOID) &elfexd->elfDesignVector,
1668 sizeof(DESIGNVECTOR));
1669
1670 return NtGdiHfontCreate( &Logfont, 0, 0, 0, NULL);
1671 }
1672 else return NULL;
1673}
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 1681 of file font.c.

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

Referenced by CreateFontIndirectW(), and Test_CreateFontIndirectExW().

◆ CreateFontIndirectW()

HFONT WINAPI CreateFontIndirectW ( CONST LOGFONTW lplf)

Definition at line 1803 of file font.c.

1806{
1807#if 0
1808 static BOOL bDidTest = FALSE;
1809 if (!bDidTest)
1810 {
1811 bDidTest = TRUE;
1812 DoFontSystemUnittest();
1813 }
1814#endif
1815 if (lplf)
1816 {
1817 ENUMLOGFONTEXDVW Logfont;
1818
1819 RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW));
1820 // Need something other than just cleaning memory here.
1821 // Guess? Use caller data to determine the rest.
1823 sizeof(Logfont.elfEnumLogfontEx.elfFullName));
1825 sizeof(Logfont.elfEnumLogfontEx.elfStyle));
1827 sizeof(Logfont.elfEnumLogfontEx.elfScript));
1828
1829 Logfont.elfDesignVector.dvNumAxes = 0; // No more than MM_MAX_NUMAXES
1830
1831 RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR));
1832
1833 return CreateFontIndirectExW(&Logfont);
1834 }
1835 else return NULL;
1836}
#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:1681

◆ CreateFontW()

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

Definition at line 1894 of file font.c.

1910{
1911 LOGFONTW logfont;
1912
1913 logfont.lfHeight = nHeight;
1914 logfont.lfWidth = nWidth;
1915 logfont.lfEscapement = nEscapement;
1916 logfont.lfOrientation = nOrientation;
1917 logfont.lfWeight = nWeight;
1918 logfont.lfItalic = (BYTE)fnItalic;
1919 logfont.lfUnderline = (BYTE)fdwUnderline;
1920 logfont.lfStrikeOut = (BYTE)fdwStrikeOut;
1921 logfont.lfCharSet = (BYTE)fdwCharSet;
1922 logfont.lfOutPrecision = (BYTE)fdwOutputPrecision;
1923 logfont.lfClipPrecision = (BYTE)fdwClipPrecision;
1924 logfont.lfQuality = (BYTE)fdwQuality;
1925 logfont.lfPitchAndFamily = (BYTE)fdwPitchAndFamily;
1926
1927 if (NULL != lpszFace)
1928 {
1929 int Size = sizeof(logfont.lfFaceName) / sizeof(WCHAR);
1930 wcsncpy((wchar_t *)logfont.lfFaceName, lpszFace, Size - 1);
1931 /* Be 101% sure to have '\0' at end of string */
1932 logfont.lfFaceName[Size - 1] = '\0';
1933 }
1934 else
1935 {
1936 logfont.lfFaceName[0] = L'\0';
1937 }
1938
1939 return CreateFontIndirectW(&logfont);
1940}
#define L(x)
Definition: ntvdm.h:50
_CRTIMP wchar_t *__cdecl wcsncpy(wchar_t *_Dest, const wchar_t *_Source, size_t _Count)
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
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193

◆ CreateScalableFontResourceA()

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

Definition at line 1948 of file font.c.

1954{
1955 return FALSE;
1956}

◆ CreateScalableFontResourceW()

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

Definition at line 2515 of file font.c.

2521{
2522 HANDLE f;
2523
2525
2526 /* fHidden=1 - only visible for the calling app, read-only, not
2527 * enumerated with EnumFonts/EnumFontFamilies
2528 * lpszCurrentPath can be NULL
2529 */
2530
2531 /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
2532 if ((f = CreateFileW(lpszFontRes, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE)
2533 {
2534 CloseHandle(f);
2536 return FALSE;
2537 }
2538 return FALSE; /* create failed */
2539}
#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 480 of file font.c.

482{
483 LOGFONTW LogFont;
484
485 DPRINT("EnumFontFamiliesA(%p, %s, %p, %p)\n",
486 hdc, lpszFamily, lpEnumFontFamProc, lParam);
487
488 ZeroMemory(&LogFont, sizeof(LOGFONTW));
489 LogFont.lfCharSet = DEFAULT_CHARSET;
490 if (NULL != lpszFamily)
491 {
492 if (!*lpszFamily) return 1;
493 MultiByteToWideChar(CP_THREAD_ACP, 0, lpszFamily, -1, LogFont.lfFaceName, LF_FACESIZE);
494 }
495
496 return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, 0);
497}
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:71
static int FASTCALL IntEnumFontFamilies(HDC Dc, const LOGFONTW *LogFont, PVOID EnumProc, LPARAM lParam, DWORD dwFlags)
Definition: font.c:288
#define ZeroMemory
Definition: winbase.h:1712
#define DEFAULT_CHARSET
Definition: wingdi.h:384
#define CP_THREAD_ACP
Definition: winnls.h:233

◆ EnumFontFamiliesExA()

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

Definition at line 447 of file font.c.

449{
450 LOGFONTW LogFontW, *pLogFontW;
451
452 if (lpLogfont)
453 {
454 DPRINT("EnumFontFamiliesExA(%p, %p(%s, %u, %u), %p, %p, 0x%08lX)\n",
455 hdc, lpLogfont, lpLogfont->lfFaceName, lpLogfont->lfCharSet,
456 lpLogfont->lfPitchAndFamily, lpEnumFontFamExProc, lParam, dwFlags);
457 }
458 else
459 {
460 DPRINT("EnumFontFamiliesExA(%p, NULL, %p, %p, 0x%08lX)\n",
461 hdc, lpEnumFontFamExProc, lParam, dwFlags);
462 }
463
464 if (lpLogfont)
465 {
466 LogFontA2W(&LogFontW,lpLogfont);
467 pLogFontW = &LogFontW;
468 }
469 else pLogFontW = NULL;
470
471 /* no need to convert LogFontW back to lpLogFont b/c it's an [in] parameter only */
472 return IntEnumFontFamilies(hdc, pLogFontW, lpEnumFontFamExProc, lParam, IEFF_EXTENDED);
473}
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:252
_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 400 of file font.c.

402{
403 if (lpLogfont)
404 {
405 DPRINT("EnumFontFamiliesExW(%p, %p(%S, %u, %u), %p, %p, 0x%08lX)\n",
406 hdc, lpLogfont, lpLogfont->lfFaceName, lpLogfont->lfCharSet,
407 lpLogfont->lfPitchAndFamily, lpEnumFontFamExProc, lParam, dwFlags);
408 }
409 else
410 {
411 DPRINT("EnumFontFamiliesExW(%p, NULL, %p, %p, 0x%08lX)\n",
412 hdc, lpEnumFontFamExProc, lParam, dwFlags);
413 }
414 return IntEnumFontFamilies(hdc, lpLogfont, lpEnumFontFamExProc, lParam,
416}
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:251

◆ EnumFontFamiliesW()

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

Definition at line 423 of file font.c.

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

◆ EnumFontsA()

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

Definition at line 2295 of file font.c.

2301{
2302#if 0
2304 LPWSTR lpFaceNameW;
2305 int rc = 0;
2306
2307 Status = HEAP_strdupA2W ( &lpFaceNameW, lpFaceName );
2308 if (!NT_SUCCESS (Status))
2310 else
2311 {
2312 rc = NtGdiEnumFonts ( hDC, lpFaceNameW, FontFunc, lParam );
2313
2314 HEAP_free ( lpFaceNameW );
2315 }
2316 return rc;
2317#else
2318 return EnumFontFamiliesA( hDC, lpFaceName, FontFunc, lParam );
2319#endif
2320}
static HDC hDC
Definition: 3dtext.c:33
__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 2276 of file font.c.

2282{
2283#if 0
2284 return NtGdiEnumFonts ( hDC, lpFaceName, FontFunc, lParam );
2285#else
2286 return EnumFontFamiliesW( hDC, lpFaceName, FontFunc, lParam );
2287#endif
2288}
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 2558 of file font.c.

2559{
2562 return 0;
2563}

◆ EudcUnloadLinkW()

BOOL WINAPI EudcUnloadLinkW ( LPCWSTR  pBaseFaceName,
LPCWSTR  pEudcFontPath 
)

Definition at line 2570 of file font.c.

2571{
2574 return 0;
2575}

◆ FONT_GetCharsByRangeA()

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

Definition at line 146 of file font.c.

147{
148 INT i, count = lastChar - firstChar + 1;
149 UINT c;
150 LPSTR str;
151
152 if (count <= 0)
153 return NULL;
154
155 switch (GdiGetCodePage(hdc))
156 {
157 case 932:
158 case 936:
159 case 949:
160 case 950:
161 case 1361:
162 if (lastChar > 0xffff)
163 return NULL;
164 if ((firstChar ^ lastChar) > 0xff)
165 return NULL;
166 break;
167 default:
168 if (lastChar > 0xff)
169 return NULL;
170 break;
171 }
172
173 str = HeapAlloc(GetProcessHeap(), 0, count * 2 + 1);
174 if (str == NULL)
175 return NULL;
176
177 for(i = 0, c = firstChar; c <= lastChar; i++, c++)
178 {
179 if (c > 0xff)
180 str[i++] = (BYTE)(c >> 8);
181 str[i] = (BYTE)c;
182 }
183 str[i] = '\0';
184
185 *pByteLen = i;
186
187 return str;
188}
#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
int32_t INT
Definition: typedefs.h:58
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 124 of file font.c.

125{
127 INT lenW;
128 LPWSTR strW;
129
130 if(count == -1) count = strlen(str);
131 lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
132 strW = HeapAlloc(GetProcessHeap(), 0, lenW*sizeof(WCHAR));
133 if (!strW)
134 return NULL;
135 if(!MultiByteToWideChar(cp, 0, str, count, strW, lenW))
136 {
138 return NULL;
139 }
140 DPRINT("mapped %s -> %S\n", str, strW);
141 if(plenW) *plenW = lenW;
142 if(pCP) *pCP = cp;
143 return strW;
144}
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 79 of file font.c.

80{
81 ptmA->tmHeight = ptmW->tmHeight;
82 ptmA->tmAscent = ptmW->tmAscent;
83 ptmA->tmDescent = ptmW->tmDescent;
86 ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
87 ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
88 ptmA->tmWeight = ptmW->tmWeight;
89 ptmA->tmOverhang = ptmW->tmOverhang;
92 ptmA->tmFirstChar = min(ptmW->tmFirstChar, 255);
93 if (ptmW->tmCharSet == SYMBOL_CHARSET)
94 {
95 ptmA->tmFirstChar = 0x1e;
96 ptmA->tmLastChar = 0xff; /* win9x behaviour - we need the OS2 table data to calculate correctly */
97 }
98 else
99 {
100 ptmA->tmFirstChar = ptmW->tmDefaultChar - 1;
101 ptmA->tmLastChar = min(ptmW->tmLastChar, 0xff);
102 }
103 ptmA->tmDefaultChar = (CHAR)ptmW->tmDefaultChar;
104 ptmA->tmBreakChar = (CHAR)ptmW->tmBreakChar;
105 ptmA->tmItalic = ptmW->tmItalic;
106 ptmA->tmUnderlined = ptmW->tmUnderlined;
107 ptmA->tmStruckOut = ptmW->tmStruckOut;
109 ptmA->tmCharSet = ptmW->tmCharSet;
110}
#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 22 of file font.c.

23{
24 return (int)floor(val + 0.5);
25}
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 2404 of file font.c.

2408{
2409 INT Ret;
2410 WCHAR lpszBuffer[MAX_PATH];
2411 WCHAR lpszAbsPath[MAX_PATH];
2412 UNICODE_STRING NtAbsPath;
2413
2414 /* FIXME: We don't support multiple files passed in lpszFilename
2415 * as L"abcxxxxx.pfm|abcxxxxx.pfb"
2416 */
2417
2418 /* Does the file exist in CurrentDirectory or in the Absolute Path passed? */
2419 GetCurrentDirectoryW(MAX_PATH, lpszBuffer);
2420
2421 if (!SearchPathW(lpszBuffer, lpszFilename, NULL, MAX_PATH, lpszAbsPath, NULL))
2422 {
2423 /* Nope. Then let's check Fonts folder */
2424 GetWindowsDirectoryW(lpszBuffer, MAX_PATH);
2425 StringCbCatW(lpszBuffer, sizeof(lpszBuffer), L"\\Fonts");
2426
2427 if (!SearchPathW(lpszBuffer, lpszFilename, NULL, MAX_PATH, lpszAbsPath, NULL))
2428 {
2429 DPRINT1("Font not found. The Buffer is: %ls, the FileName is: %S\n", lpszBuffer, lpszFilename);
2430 return 0;
2431 }
2432 }
2433
2434 /* We found the font file so: */
2435 if (!RtlDosPathNameToNtPathName_U(lpszAbsPath, &NtAbsPath, NULL, NULL))
2436 {
2437 DPRINT1("Can't convert Path! Path: %ls\n", lpszAbsPath);
2438 return 0;
2439 }
2440
2441 /* The Nt call expects a null-terminator included in cwc param. */
2442 ASSERT(NtAbsPath.Buffer[NtAbsPath.Length / sizeof(WCHAR)] == UNICODE_NULL);
2443 Ret = NtGdiAddFontResourceW(NtAbsPath.Buffer, NtAbsPath.Length / sizeof(WCHAR) + 1, 1, fl, 0, pdv);
2444
2445 RtlFreeUnicodeString(&NtAbsPath);
2446
2447 return Ret;
2448}
INT APIENTRY NtGdiAddFontResourceW(_In_reads_(cwc) WCHAR *pwszFiles, _In_ ULONG cwc, _In_ ULONG cFiles, _In_ FLONG f, _In_ DWORD dwPidTid, _In_opt_ DESIGNVECTOR *pdv)
#define DPRINT1
Definition: precomp.h:8
#define GetCurrentDirectoryW(x, y)
Definition: compat.h:756
#define MAX_PATH
Definition: compat.h:34
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 ASSERT(a)
Definition: mode.c:44
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 UNICODE_NULL
STRSAFEAPI StringCbCatW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:342
_In_ ULONG_PTR _In_opt_ DESIGNVECTOR * pdv
Definition: winddi.h:3723

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

◆ GdiGetCharDimensions()

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

Definition at line 2145 of file font.c.

2146{
2147 SIZE sz;
2149 static const WCHAR alphabet[] =
2150 {
2151 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
2152 'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
2153 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0
2154 };
2155
2156 if(!GetTextMetricsW(hdc, &tm)) return 0;
2157
2158 if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
2159
2160 if (lptm) *lptm = tm;
2161 if (height) *height = tm.tmHeight;
2162
2163 return (sz.cx / 26 + 1) / 2;
2164}
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 create_taskdialog_template(), DIALOG_CreateIndirect(), EDIT_EM_SetMargins(), EDIT_UpdateUniscribeData_linedef(), GetDialogBaseUnits(), LoadDialog(), OleCreatePropertyFrameIndirect(), SoftModalMessageBox(), Test_GdiGetCharDimensions(), test_margins_default(), and test_margins_usefontinfo().

◆ GetCharABCWidthsA()

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

Definition at line 934 of file font.c.

940{
941 INT wlen, count = 0;
942 LPSTR str;
943 LPWSTR wstr;
944 BOOL ret = TRUE;
945
946 DPRINT("GetCharABCWidthsA\n");
947
948 str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
949 if (!str)
950 return FALSE;
951
952 wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
953 if (!wstr)
954 {
956 return FALSE;
957 }
958
960 wstr[0],
961 wlen - 1,
962 (PWCHAR)wstr,
964 (PVOID)lpabc);
965
967 HeapFree(GetProcessHeap(), 0, wstr);
968
969 return ret;
970}
__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:146
static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
Definition: font.c:124

◆ GetCharABCWidthsFloatA()

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

Definition at line 977 of file font.c.

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

◆ GetCharABCWidthsFloatW()

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

Definition at line 686 of file font.c.

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

◆ GetCharABCWidthsI()

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

Definition at line 1014 of file font.c.

1019{
1020 DPRINT("GetCharABCWidthsI\n");
1022 giFirst,
1023 (ULONG) cgi,
1024 (PWCHAR) pgi,
1026 (PVOID)lpabc);
1027}
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 787 of file font.c.

791{
792 DPRINT("GetCharABCWidthsW\n");
793 if ((!lpabc) || (FirstChar > LastChar))
794 {
796 return FALSE;
797 }
799 FirstChar,
800 (ULONG)(LastChar - FirstChar + 1),
801 (PWCHAR) NULL,
803 (PVOID)lpabc);
804}

◆ GetCharacterPlacementA()

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

Definition at line 505 of file font.c.

512{
513 WCHAR *lpStringW;
514 INT uCountW;
515 GCP_RESULTSW resultsW;
516 DWORD ret;
517 UINT font_cp;
518
519 if ( !lpString || uCount <= 0 || !lpResults || (nMaxExtent < 0 && nMaxExtent != -1 ) )
520 {
522 return 0;
523 }
524 /* TRACE("%s, %d, %d, 0x%08x\n",
525 debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
526 */
527 /* both structs are equal in size */
528 memcpy(&resultsW, lpResults, sizeof(resultsW));
529
530 lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
531 if (lpStringW == NULL)
532 {
533 return 0;
534 }
535 if(lpResults->lpOutString)
536 {
537 resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
538 if (resultsW.lpOutString == NULL)
539 {
540 HeapFree(GetProcessHeap(), 0, lpStringW);
541 return 0;
542 }
543 }
544
545 ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
546
547 lpResults->nGlyphs = resultsW.nGlyphs;
548 lpResults->nMaxFit = resultsW.nMaxFit;
549
550 if(lpResults->lpOutString)
551 {
552 WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
553 lpResults->lpOutString, uCount, NULL, NULL );
554 }
555
556 HeapFree(GetProcessHeap(), 0, lpStringW);
557 HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
558
559 return ret;
560}
#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 568 of file font.c.

576{
577 DWORD ret=0;
578 SIZE size;
579 UINT i, nSet;
580 DPRINT("GetCharacterPlacementW\n");
581
582 if (dwFlags&(~GCP_REORDER)) DPRINT("flags 0x%08lx ignored\n", dwFlags);
583 if (lpResults->lpClass) DPRINT("classes not implemented\n");
584
585 nSet = (UINT)uCount;
586 if (nSet > lpResults->nGlyphs)
587 nSet = lpResults->nGlyphs;
588
589 /* return number of initialized fields */
590 lpResults->nGlyphs = nSet;
591
592 if (dwFlags & GCP_REORDER)
593 {
594 if (LoadLPK(LPK_GCP))
595 return LpkGetCharacterPlacement(hdc, lpString, uCount, nMaxExtent, lpResults, dwFlags, 0);
596 }
597
598 /* Treat the case where no special handling was requested in a fastpath way */
599 /* copy will do if the GCP_REORDER flag is not set */
600 if (lpResults->lpOutString)
601 lstrcpynW( lpResults->lpOutString, lpString, nSet );
602
603 if (lpResults->lpOrder)
604 {
605 for (i = 0; i < nSet; i++)
606 lpResults->lpOrder[i] = i;
607 }
608
609 /* FIXME: Will use the placement chars */
610 if (lpResults->lpDx)
611 {
612 int c;
613 for (i = 0; i < nSet; i++)
614 {
615 if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
616 lpResults->lpDx[i]= c;
617 }
618 }
619
620 if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
621 {
622 int pos = 0;
623
624 lpResults->lpCaretPos[0] = 0;
625 for (i = 1; i < nSet; i++)
626 if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
627 lpResults->lpCaretPos[i] = (pos += size.cx);
628 }
629
630 if (lpResults->lpGlyphs)
631 NtGdiGetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
632
633 if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
634 ret = MAKELONG(size.cx, size.cy);
635
636 return ret;
637}
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:7070
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:761
#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 854 of file font.c.

860{
861 INT wlen, count = 0;
862 LPSTR str;
863 LPWSTR wstr;
864 BOOL ret = TRUE;
865
866 DPRINT("GetCharWidths32A\n");
867
868 str = FONT_GetCharsByRangeA(hdc, iFirstChar, iLastChar, &count);
869 if (!str)
870 return FALSE;
871
872 wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
873 if (!wstr)
874 {
876 return FALSE;
877 }
878
880 wstr[0],
881 (ULONG) count,
882 (PWCHAR) wstr,
884 (PVOID) lpBuffer);
885
887 HeapFree(GetProcessHeap(), 0, wstr);
888
889 return ret;
890}
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 761 of file font.c.

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

Referenced by GetCharacterPlacementW().

◆ GetCharWidthA()

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

Definition at line 811 of file font.c.

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

◆ GetCharWidthFloatA()

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

Definition at line 897 of file font.c.

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

◆ GetCharWidthFloatW()

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

Definition at line 711 of file font.c.

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

◆ GetCharWidthI()

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

Definition at line 1034 of file font.c.

1040{
1041 DPRINT("GetCharWidthsI\n");
1042 if (!lpBuffer || (!pgi && (giFirst == MAXUSHORT))) // Cannot be at max.
1043 {
1045 return FALSE;
1046 }
1047 if (!cgi) return TRUE;
1048 return NtGdiGetCharWidthW( hdc,
1049 giFirst,
1050 cgi,
1051 (PWCHAR) pgi,
1053 (PVOID) lpBuffer );
1054}
#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 736 of file font.c.

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

◆ GetEUDCTimeStamp()

ULONG WINAPI GetEUDCTimeStamp ( VOID  )

Definition at line 2582 of file font.c.

2583{
2585}
__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 2592 of file font.c.

2593{
2594 DWORD retValue = 0;
2595
2596 if (!lpBaseFaceName)
2597 {
2598 retValue = NtGdiGetEudcTimeStampEx(NULL,0,FALSE);
2599 }
2600 else
2601 {
2602 retValue = NtGdiGetEudcTimeStampEx(lpBaseFaceName, wcslen(lpBaseFaceName), FALSE);
2603 }
2604
2605 return retValue;
2606}
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)

◆ GetFontAssocStatus()

ULONG WINAPI GetFontAssocStatus ( HDC  hdc)

Definition at line 2613 of file font.c.

2614{
2615 ULONG retValue = 0;
2616
2617 if (hdc)
2618 {
2619 retValue = NtGdiQueryFontAssocInfo(hdc);
2620 }
2621
2622 return retValue;
2623}
__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 2654 of file font.c.

2659{
2660 if (!lpvBuffer)
2661 {
2662 cbData = 0;
2663 }
2664 return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2665}
_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:588

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

◆ GetFontLanguageInfo()

DWORD WINAPI GetFontLanguageInfo ( HDC  hDc)

Definition at line 1061 of file font.c.

1064{
1065 DWORD Gcp = 0, Ret = 0;
1066 if (gbLpk)
1067 {
1068 Ret = NtGdiGetTextCharsetInfo(hDc, NULL, 0);
1069 if ((Ret == ARABIC_CHARSET) || (Ret == HEBREW_CHARSET))
1071 }
1073 if ( Gcp == GCP_ERROR)
1074 return Gcp;
1075 else
1076 Ret = Gcp | Ret;
1077 return Ret;
1078}
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 1085 of file font.c.

1092{
1093 DWORD Ret;
1094 WCHAR *lpstrW;
1095 INT countW;
1096
1097 lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
1098
1099 if (lpstrW == NULL)
1100 return GDI_ERROR;
1101
1102 Ret = NtGdiGetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
1103 HeapFree(GetProcessHeap(), 0, lpstrW);
1104 return Ret;
1105}
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 1112 of file font.c.

1121{
1122
1123 LPWSTR p = NULL;
1124 DWORD ret;
1125 UINT c;
1126 DPRINT("GetGlyphOutlineA uChar %x\n", uChar);
1127 if (!lpgm || !lpmat2) return GDI_ERROR;
1128 if(!(uFormat & GGO_GLYPH_INDEX))
1129 {
1130 int len;
1131 char mbchs[2];
1132 if(uChar > 0xff) /* but, 2 bytes character only */
1133 {
1134 len = 2;
1135 mbchs[0] = (uChar & 0xff00) >> 8;
1136 mbchs[1] = (uChar & 0xff);
1137 }
1138 else
1139 {
1140 len = 1;
1141 mbchs[0] = (uChar & 0xff);
1142 }
1143 p = FONT_mbtowc(hdc, mbchs, len, NULL, NULL);
1144 if(!p)
1145 return GDI_ERROR;
1146 c = p[0];
1147 }
1148 else
1149 c = uChar;
1150 ret = NtGdiGetGlyphOutline(hdc, c, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
1151 HeapFree(GetProcessHeap(), 0, p);
1152 return ret;
1153}
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 1161 of file font.c.

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

◆ GetGlyphOutlineWow()

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

Definition at line 1182 of file font.c.

1191{
1194 return 0;
1195}

◆ GetKerningPairsA()

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

Definition at line 1575 of file font.c.

1578{
1579 INT charset;
1580 CHARSETINFO csi;
1581 CPINFO cpi;
1582 DWORD i, total_kern_pairs, kern_pairs_copied = 0;
1583 KERNINGPAIR *kern_pairW;
1584
1585 if (!cPairs && kern_pairA)
1586 {
1588 return 0;
1589 }
1590
1593 {
1594 DPRINT1("Can't find codepage for charset %d\n", charset);
1595 return 0;
1596 }
1597 /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
1598 * to fail on an invalid character for CP_SYMBOL.
1599 */
1600 cpi.DefaultChar[0] = 0;
1601 if (csi.ciACP != CP_SYMBOL && !GetCPInfo(csi.ciACP, &cpi))
1602 {
1603 DPRINT1("Can't find codepage %u info\n", csi.ciACP);
1604 return 0;
1605 }
1606 DPRINT("charset %d => codepage %u\n", charset, csi.ciACP);
1607
1608 total_kern_pairs = NtGdiGetKerningPairs(hDC, 0, NULL);
1609 if (!total_kern_pairs) return 0;
1610
1611 if (!cPairs && !kern_pairA) return total_kern_pairs;
1612
1613 kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
1614 if (kern_pairW == NULL)
1615 {
1616 return 0;
1617 }
1618 GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
1619
1620 for (i = 0; i < total_kern_pairs; i++)
1621 {
1622 char first, second;
1623
1624 if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
1625 continue;
1626
1627 if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
1628 continue;
1629
1630 if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
1631 continue;
1632
1633 if (kern_pairA)
1634 {
1635 if (kern_pairs_copied >= cPairs) break;
1636
1637 kern_pairA->wFirst = (BYTE)first;
1638 kern_pairA->wSecond = (BYTE)second;
1639 kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
1640 kern_pairA++;
1641 }
1642 kern_pairs_copied++;
1643 }
1644
1645 HeapFree(GetProcessHeap(), 0, kern_pairW);
1646
1647 return kern_pairs_copied;
1648}
#define ULongToPtr(ul)
Definition: basetsd.h:92
CFF_Charset charset
Definition: cffcmap.c:138
BOOL WINAPI GetCPInfo(UINT CodePage, LPCPINFO CodePageInfo)
Definition: nls.c:2039
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:582
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:234

◆ GetKerningPairsW()

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

Definition at line 1555 of file font.c.

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

◆ GetOutlineTextMetricsA()

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

Definition at line 1202 of file font.c.

1207{
1208 char buf[512], *ptr;
1209 UINT ret, needed;
1211 OUTLINETEXTMETRICA *output = lpOTM;
1212 INT left, len;
1213
1214 if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1215 return 0;
1216 if(ret > sizeof(buf))
1217 {
1218 lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1219 if (lpOTMW == NULL)
1220 {
1221 return 0;
1222 }
1223 }
1224 GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1225
1226 needed = sizeof(OUTLINETEXTMETRICA);
1227 if(lpOTMW->otmpFamilyName)
1228 needed += WideCharToMultiByte(CP_ACP, 0,
1229 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFamilyName), -1,
1230 NULL, 0, NULL, NULL);
1231 if(lpOTMW->otmpFaceName)
1232 needed += WideCharToMultiByte(CP_ACP, 0,
1233 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFaceName), -1,
1234 NULL, 0, NULL, NULL);
1235 if(lpOTMW->otmpStyleName)
1236 needed += WideCharToMultiByte(CP_ACP, 0,
1237 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpStyleName), -1,
1238 NULL, 0, NULL, NULL);
1239 if(lpOTMW->otmpFullName)
1240 needed += WideCharToMultiByte(CP_ACP, 0,
1241 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFullName), -1,
1242 NULL, 0, NULL, NULL);
1243
1244 if(!lpOTM)
1245 {
1246 ret = needed;
1247 goto end;
1248 }
1249
1250 DPRINT("needed = %u\n", needed);
1251 if(needed > cbData)
1252 {
1253 /* Since the supplied buffer isn't big enough, we'll alloc one
1254 that is and memcpy the first cbData bytes into the lpOTM at
1255 the end. */
1256 output = HeapAlloc(GetProcessHeap(), 0, needed);
1257 if (output == NULL)
1258 {
1259 goto end;
1260 }
1261 }
1262
1263 ret = output->otmSize = min(needed, cbData);
1265 output->otmFiller = 0;
1266 output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1267 output->otmfsSelection = lpOTMW->otmfsSelection;
1268 output->otmfsType = lpOTMW->otmfsType;
1269 output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1270 output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1271 output->otmItalicAngle = lpOTMW->otmItalicAngle;
1272 output->otmEMSquare = lpOTMW->otmEMSquare;
1273 output->otmAscent = lpOTMW->otmAscent;
1274 output->otmDescent = lpOTMW->otmDescent;
1275 output->otmLineGap = lpOTMW->otmLineGap;
1276 output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1277 output->otmsXHeight = lpOTMW->otmsXHeight;
1278 output->otmrcFontBox = lpOTMW->otmrcFontBox;
1279 output->otmMacAscent = lpOTMW->otmMacAscent;
1280 output->otmMacDescent = lpOTMW->otmMacDescent;
1281 output->otmMacLineGap = lpOTMW->otmMacLineGap;
1282 output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1283 output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1287 output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1289 output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1291
1292
1293 ptr = (char*)(output + 1);
1294 left = needed - sizeof(*output);
1295
1296 if(lpOTMW->otmpFamilyName)
1297 {
1298 output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1300 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFamilyName), -1,
1301 ptr, left, NULL, NULL);
1302 left -= len;
1303 ptr += len;
1304 }
1305 else
1306 output->otmpFamilyName = 0;
1307
1308 if(lpOTMW->otmpFaceName)
1309 {
1310 output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1312 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFaceName), -1,
1313 ptr, left, NULL, NULL);
1314 left -= len;
1315 ptr += len;
1316 }
1317 else
1318 output->otmpFaceName = 0;
1319
1320 if(lpOTMW->otmpStyleName)
1321 {
1322 output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1324 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpStyleName), -1,
1325 ptr, left, NULL, NULL);
1326 left -= len;
1327 ptr += len;
1328 }
1329 else
1330 output->otmpStyleName = 0;
1331
1332 if(lpOTMW->otmpFullName)
1333 {
1334 output->otmpFullName = (LPSTR)(ptr - (char*)output);
1336 (WCHAR*)((char*)lpOTMW + (intptr_t)lpOTMW->otmpFullName), -1,
1337 ptr, left, NULL, NULL);
1338 left -= len;
1339 }
1340 else
1341 output->otmpFullName = 0;
1342
1343 ASSERT(left == 0);
1344
1345 if(output != lpOTM)
1346 {
1347 memcpy(lpOTM, output, cbData);
1348 HeapFree(GetProcessHeap(), 0, output);
1349
1350 /* check if the string offsets really fit into the provided size */
1351 /* FIXME: should we check string length as well? */
1352 if ((UINT_PTR)lpOTM->otmpFamilyName >= lpOTM->otmSize)
1353 lpOTM->otmpFamilyName = 0; /* doesn't fit */
1354
1355 if ((UINT_PTR)lpOTM->otmpFaceName >= lpOTM->otmSize)
1356 lpOTM->otmpFaceName = 0; /* doesn't fit */
1357
1358 if ((UINT_PTR)lpOTM->otmpStyleName >= lpOTM->otmSize)
1359 lpOTM->otmpStyleName = 0; /* doesn't fit */
1360
1361 if ((UINT_PTR)lpOTM->otmpFullName >= lpOTM->otmSize)
1362 lpOTM->otmpFullName = 0; /* doesn't fit */
1363 }
1364
1365end:
1366 if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1367 HeapFree(GetProcessHeap(), 0, lpOTMW);
1368
1369 return ret;
1370}
int intptr_t
Definition: crtdefs.h:304
#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
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
VOID FASTCALL FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA)
Definition: font.c:79
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 1401 of file font.c.

1406{
1407 TMDIFF Tmd; // Should not be zero.
1408 UINT Size, AvailableSize = 0, StringSize;
1409 XFORM DevToWorld;
1410 OUTLINETEXTMETRICW* LocalOTM;
1411 WCHAR* Str;
1412 BYTE* Ptr;
1413
1414 /* Get the structure */
1416 if (!Size)
1417 return 0;
1418 if (!lpOTM || (cbData < sizeof(*lpOTM)))
1419 return Size;
1420
1421 LocalOTM = HeapAlloc(GetProcessHeap(), 0, Size);
1422 LocalOTM->otmSize = Size;
1424 if (!Size)
1425 {
1426 HeapFree(GetProcessHeap(), 0, LocalOTM);
1427 return 0;
1428 }
1429
1431 {
1432 DPRINT1("NtGdiGetTransform failed!\n");
1433 HeapFree(GetProcessHeap(), 0, LocalOTM);
1435 return 0;
1436 }
1437
1438 /* Fill in DC specific data */
1441 LocalOTM->otmTextMetrics.tmHeight = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmHeight );
1442 LocalOTM->otmTextMetrics.tmAscent = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmAscent );
1443 LocalOTM->otmTextMetrics.tmDescent = height_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmDescent );
1446 LocalOTM->otmTextMetrics.tmAveCharWidth = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmAveCharWidth );
1447 LocalOTM->otmTextMetrics.tmMaxCharWidth = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmMaxCharWidth );
1448 LocalOTM->otmTextMetrics.tmOverhang = width_to_LP( &DevToWorld, LocalOTM->otmTextMetrics.tmOverhang );
1449 LocalOTM->otmAscent = height_to_LP( &DevToWorld, LocalOTM->otmAscent);
1450 LocalOTM->otmDescent = height_to_LP( &DevToWorld, LocalOTM->otmDescent);
1451 LocalOTM->otmLineGap = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmLineGap));
1452 LocalOTM->otmsCapEmHeight = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsCapEmHeight));
1453 LocalOTM->otmsXHeight = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsXHeight));
1454 LocalOTM->otmrcFontBox.top = height_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.top);
1455 LocalOTM->otmrcFontBox.bottom = height_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.bottom);
1456 LocalOTM->otmrcFontBox.left = width_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.left);
1457 LocalOTM->otmrcFontBox.right = width_to_LP( &DevToWorld, LocalOTM->otmrcFontBox.right);
1458 LocalOTM->otmMacAscent = height_to_LP( &DevToWorld, LocalOTM->otmMacAscent);
1459 LocalOTM->otmMacDescent = height_to_LP( &DevToWorld, LocalOTM->otmMacDescent);
1460 LocalOTM->otmMacLineGap = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmMacLineGap));
1461 LocalOTM->otmptSubscriptSize.x = width_to_LP( &DevToWorld, LocalOTM->otmptSubscriptSize.x);
1462 LocalOTM->otmptSubscriptSize.y = height_to_LP( &DevToWorld, LocalOTM->otmptSubscriptSize.y);
1463 LocalOTM->otmptSubscriptOffset.x = width_to_LP( &DevToWorld, LocalOTM->otmptSubscriptOffset.x);
1464 LocalOTM->otmptSubscriptOffset.y = height_to_LP( &DevToWorld, LocalOTM->otmptSubscriptOffset.y);
1465 LocalOTM->otmptSuperscriptSize.x = width_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptSize.x);
1466 LocalOTM->otmptSuperscriptSize.y = height_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptSize.y);
1467 LocalOTM->otmptSuperscriptOffset.x = width_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptOffset.x);
1468 LocalOTM->otmptSuperscriptOffset.y = height_to_LP( &DevToWorld, LocalOTM->otmptSuperscriptOffset.y);
1469 LocalOTM->otmsStrikeoutSize = abs(INTERNAL_YDSTOWS(&DevToWorld,LocalOTM->otmsStrikeoutSize));
1470 LocalOTM->otmsStrikeoutPosition = height_to_LP( &DevToWorld, LocalOTM->otmsStrikeoutPosition);
1471 LocalOTM->otmsUnderscoreSize = height_to_LP( &DevToWorld, LocalOTM->otmsUnderscoreSize);
1472 LocalOTM->otmsUnderscorePosition = height_to_LP( &DevToWorld, LocalOTM->otmsUnderscorePosition);
1473
1474 /* Copy what we can */
1475 CopyMemory(lpOTM, LocalOTM, min(Size, cbData));
1476
1477 lpOTM->otmpFamilyName = NULL;
1478 lpOTM->otmpFaceName = NULL;
1479 lpOTM->otmpStyleName = NULL;
1480 lpOTM->otmpFullName = NULL;
1481
1482 Size = sizeof(*lpOTM);
1483 AvailableSize = cbData - Size;
1484 Ptr = (BYTE*)lpOTM + sizeof(*lpOTM);
1485
1486 /* Fix string values up */
1487 if (LocalOTM->otmpFamilyName)
1488 {
1489 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFamilyName);
1490 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1491 if (AvailableSize >= StringSize)
1492 {
1493 CopyMemory(Ptr, Str, StringSize);
1494 lpOTM->otmpFamilyName = (PSTR)(Ptr - (BYTE*)lpOTM);
1495 Ptr += StringSize;
1496 AvailableSize -= StringSize;
1497 Size += StringSize;
1498 }
1499 }
1500
1501 if (LocalOTM->otmpFaceName)
1502 {
1503 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFaceName);
1504 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1505 if (AvailableSize >= StringSize)
1506 {
1507 CopyMemory(Ptr, Str, StringSize);
1508 lpOTM->otmpFaceName = (PSTR)(Ptr - (BYTE*)lpOTM);
1509 Ptr += StringSize;
1510 AvailableSize -= StringSize;
1511 Size += StringSize;
1512 }
1513 }
1514
1515 if (LocalOTM->otmpStyleName)
1516 {
1517 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpStyleName);
1518 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1519 if (AvailableSize >= StringSize)
1520 {
1521 CopyMemory(Ptr, Str, StringSize);
1522 lpOTM->otmpStyleName = (PSTR)(Ptr - (BYTE*)lpOTM);
1523 Ptr += StringSize;
1524 AvailableSize -= StringSize;
1525 Size += StringSize;
1526 }
1527 }
1528
1529 if (LocalOTM->otmpFullName)
1530 {
1531 Str = (WCHAR*)((char*)LocalOTM + (ptrdiff_t)LocalOTM->otmpFullName);
1532 StringSize = (wcslen(Str) + 1) * sizeof(WCHAR);
1533 if (AvailableSize >= StringSize)
1534 {
1535 CopyMemory(Ptr, Str, StringSize);
1536 lpOTM->otmpFullName = (PSTR)(Ptr - (BYTE*)lpOTM);
1537 Ptr += StringSize;
1538 AvailableSize -= StringSize;
1539 Size += StringSize;
1540 }
1541 }
1542
1543 lpOTM->otmSize = Size;
1544
1545 HeapFree(GetProcessHeap(), 0, LocalOTM);
1546
1547 return Size;
1548}
#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:1386
static INT INTERNAL_YDSTOWS(XFORM *xForm, INT height)
Definition: font.c:1375
static INT height_to_LP(XFORM *xForm, INT height)
Definition: font.c:1391
#define CopyMemory
Definition: winbase.h:1710
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 1391 of file font.c.

1392{
1393 return GDI_ROUND( (double)height * fabs( xForm->eM22 ));
1394}
_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:22

Referenced by GetOutlineTextMetricsW().

◆ IntEnumFontFamilies()

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

Definition at line 288 of file font.c.

290{
291 int FontFamilyCount;
293 int Ret = 1;
294 int i;
295 ENUMLOGFONTEXA EnumLogFontExA;
296 NEWTEXTMETRICEXA NewTextMetricExA;
297 LOGFONTW lfW;
298 LONG InfoCount;
301
304 if (Info == NULL)
305 {
306 return 1;
307 }
308
309 /* Initialize the LOGFONT structure */
310 ZeroMemory(&lfW, sizeof(lfW));
311 if (!LogFont)
312 {
314 }
315 else
316 {
317 lfW.lfCharSet = LogFont->lfCharSet;
318 lfW.lfPitchAndFamily = LogFont->lfPitchAndFamily;
319 StringCbCopyW(lfW.lfFaceName, sizeof(lfW.lfFaceName), LogFont->lfFaceName);
320 }
321
322 /* Retrieve the font information */
323 InfoCount = INITIAL_FAMILY_COUNT;
324 FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, &lfW, Info, &InfoCount);
325 if (FontFamilyCount < 0)
326 {
328 return 1;
329 }
330
331 /* Resize the buffer if the buffer is too small */
332 if (INITIAL_FAMILY_COUNT < InfoCount)
333 {
335
336 Status = RtlULongMult(InfoCount, sizeof(FONTFAMILYINFO), &DataSize);
338 {
339 DPRINT1("Overflowed.\n");
340 return 1;
341 }
343 if (Info == NULL)
344 {
345 return 1;
346 }
347 FontFamilyCount = NtGdiGetFontFamilyInfo(Dc, &lfW, Info, &InfoCount);
348 if (FontFamilyCount < 0 || FontFamilyCount < InfoCount)
349 {
351 return 1;
352 }
353 }
354
355 /* Sort and remove redundant information */
356 qsort(Info, FontFamilyCount, sizeof(*Info), IntFontFamilyCompare);
357 FontFamilyCount = IntFontFamilyListUnique(Info, FontFamilyCount, &lfW, dwFlags);
358
359 /* call the callback */
360 for (i = 0; i < FontFamilyCount; i++)
361 {
362 if (dwFlags & IEFF_UNICODE)
363 {
364 Ret = ((FONTENUMPROCW) EnumProc)(
365 (VOID*)&Info[i].EnumLogFontEx,
366 (VOID*)&Info[i].NewTextMetricEx,
367 Info[i].FontType, lParam);
368 }
369 else
370 {
371 // Could use EnumLogFontExW2A here?
372 LogFontW2A(&EnumLogFontExA.elfLogFont, &Info[i].EnumLogFontEx.elfLogFont);
373 WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfFullName, -1,
374 (LPSTR)EnumLogFontExA.elfFullName, LF_FULLFACESIZE, NULL, NULL);
375 WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfStyle, -1,
376 (LPSTR)EnumLogFontExA.elfStyle, LF_FACESIZE, NULL, NULL);
377 WideCharToMultiByte(CP_THREAD_ACP, 0, Info[i].EnumLogFontEx.elfScript, -1,
378 (LPSTR)EnumLogFontExA.elfScript, LF_FACESIZE, NULL, NULL);
379 NewTextMetricExW2A(&NewTextMetricExA,
380 &Info[i].NewTextMetricEx);
381 Ret = ((FONTENUMPROCA) EnumProc)(
382 (VOID*)&EnumLogFontExA,
383 (VOID*)&NewTextMetricExA,
384 Info[i].FontType, lParam);
385 }
386
387 if(Ret == 0)
388 break;
389 }
390
392
393 return Ret;
394}
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:590
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:608
LONG NTAPI NtGdiGetFontFamilyInfo(HDC Dc, const LOGFONTW *UnsafeLogFont, PFONTFAMILYINFO UnsafeInfo, LPLONG UnsafeInfoCount)
Definition: freetype.c:5757
VOID NTAPI LogFontW2A(LPLOGFONTA pA, CONST LOGFONTW *pW)
Definition: utils.c:375
#define LONG_MAX
Definition: limits.h:43
_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
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 *))
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:201
static int __cdecl IntFontFamilyCompare(const void *ffi1, const void *ffi2)
Definition: font.c:245
int FASTCALL IntFontFamilyListUnique(FONTFAMILYINFO *InfoList, INT nCount, const LOGFONTW *plf, DWORD dwFlags)
Definition: font.c:255
#define INITIAL_FAMILY_COUNT
Definition: font.c:72
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 1375 of file font.c.

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

Referenced by GetOutlineTextMetricsW().

◆ IntFontFamilyCompare()

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

Definition at line 245 of file font.c.

246{
248}
FORCEINLINE int FASTCALL IntFontFamilyCompareEx(const FONTFAMILYINFO *ffi1, const FONTFAMILYINFO *ffi2, DWORD dwCompareFlags)
Definition: font.c:212
#define IFFCX_STYLE
Definition: font.c:209
#define IFFCX_CHARSET
Definition: font.c:208

Referenced by IntEnumFontFamilies().

◆ IntFontFamilyCompareEx()

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

Definition at line 212 of file font.c.

214{
215 const LOGFONTW *plf1 = &ffi1->EnumLogFontEx.elfLogFont;
216 const LOGFONTW *plf2 = &ffi2->EnumLogFontEx.elfLogFont;
217 ULONG WeightDiff1, WeightDiff2;
218 int cmp = _wcsicmp(plf1->lfFaceName, plf2->lfFaceName);
219 if (cmp)
220 return cmp;
221 if (dwCompareFlags & IFFCX_CHARSET)
222 {
223 if (plf1->lfCharSet < plf2->lfCharSet)
224 return -1;
225 if (plf1->lfCharSet > plf2->lfCharSet)
226 return 1;
227 }
228 if (dwCompareFlags & IFFCX_STYLE)
229 {
230 WeightDiff1 = labs(plf1->lfWeight - FW_NORMAL);
231 WeightDiff2 = labs(plf2->lfWeight - FW_NORMAL);
232 if (WeightDiff1 < WeightDiff2)
233 return -1;
234 if (WeightDiff1 > WeightDiff2)
235 return 1;
236 if (plf1->lfItalic < plf2->lfItalic)
237 return -1;
238 if (plf1->lfItalic > plf2->lfItalic)
239 return 1;
240 }
241 return 0;
242}
_Check_return_ long __cdecl labs(_In_ long x)
#define cmp(status, error)
Definition: error.c:114
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
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 255 of file font.c.

257{
259 DWORD dwCompareFlags = 0;
260
261 if (plf->lfFaceName[0])
262 dwCompareFlags |= IFFCX_STYLE;
263
265 dwCompareFlags |= IFFCX_CHARSET;
266
267 first = InfoList;
268 last = &InfoList[nCount];
269
270 /* std::unique(first, last, IntFontFamilyCompareEx); */
271 if (first == last)
272 return 0;
273
274 result = first;
275 while (++first != last)
276 {
277 if (IntFontFamilyCompareEx(result, first, dwCompareFlags) != 0)
278 {
279 *(++result) = *first;
280 }
281 }
282 nCount = (int)(++result - InfoList);
283
284 return nCount;
285}
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 2326 of file font.c.

2332{
2333 ULONG_PTR idEnum;
2334 ULONG cbDataSize, cbRetSize;
2335 PENUMFONTDATAW pEfdw;
2336 PBYTE pBuffer;
2337 PBYTE pMax;
2338 INT ret = 1;
2339
2340 /* Open enumeration handle and find out how much memory we need */
2341 idEnum = NtGdiEnumFontOpen(hDC,
2343 0,
2345 (lpLogfont && lpLogfont->lfFaceName[0])? lpLogfont->lfFaceName : NULL,
2346 lpLogfont? lpLogfont->lfCharSet : DEFAULT_CHARSET,
2347 &cbDataSize);
2348 if (idEnum == 0)
2349 {
2350 return 0;
2351 }
2352 if (cbDataSize == 0)
2353 {
2354 NtGdiEnumFontClose(idEnum);
2355 return 0;
2356 }
2357
2358 /* Allocate memory */
2359 pBuffer = HeapAlloc(GetProcessHeap(), 0, cbDataSize);
2360 if (pBuffer == NULL)
2361 {
2363 NtGdiEnumFontClose(idEnum);
2364 return 0;
2365 }
2366
2367 /* Do the enumeration */
2368 if (!NtGdiEnumFontChunk(hDC, idEnum, cbDataSize, &cbRetSize, (PVOID)pBuffer))
2369 {
2371 NtGdiEnumFontClose(idEnum);
2372 return 0;
2373 }
2374
2375 /* Get start and end address */
2376 pEfdw = (PENUMFONTDATAW)pBuffer;
2377 pMax = pBuffer + cbDataSize;
2378
2379 /* Iterate through the structures */
2380 while ((PBYTE)pEfdw < pMax && ret)
2381 {
2382 PNTMW_INTERNAL pNtmwi = (PNTMW_INTERNAL)((ULONG_PTR)pEfdw + pEfdw->ulNtmwiOffset);
2383
2384 ret = lpEnumFontFamExProcW((VOID*)&pEfdw->elfexdv.elfEnumLogfontEx,
2385 (VOID*)&pNtmwi->ntmw,
2386 pEfdw->dwFontType,
2387 lParam);
2388
2389 pEfdw = (PENUMFONTDATAW)((ULONG_PTR)pEfdw + pEfdw->cbSize);
2390 }
2391
2392 /* Release the memory and close handle */
2394 NtGdiEnumFontClose(idEnum);
2395
2396 return ret;
2397}
#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:2322

◆ NewGetCharacterPlacementW()

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

Definition at line 641 of file font.c.

649{
650 ULONG nSet;
651 SIZE Size = {0,0};
652
653 if ( !lpString || uCount <= 0 || (nMaxExtent < 0 && nMaxExtent != -1 ) )
654 {
656 return 0;
657 }
658
659 if ( !lpResults )
660 {
661 if ( GetTextExtentPointW(hdc, lpString, uCount, &Size) )
662 {
663 return MAKELONG(Size.cx, Size.cy);
664 }
665 return 0;
666 }
667
668 nSet = uCount;
669 if ( nSet > lpResults->nGlyphs )
670 nSet = lpResults->nGlyphs;
671
673 (LPWSTR)lpString,
674 nSet,
675 nMaxExtent,
676 lpResults,
677 dwFlags);
678}
__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 201 of file font.c.

202{
203 NewTextMetricW2A(&tma->ntmTm, &tmw->ntmTm);
204 tma->ntmFontSig = tmw->ntmFontSig;
205}
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:191

Referenced by IntEnumFontFamilies().

◆ NewTextMetricW2A()

VOID FASTCALL NewTextMetricW2A ( NEWTEXTMETRICA tma,
NEWTEXTMETRICW tmw 
)

Definition at line 191 of file font.c.

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

Referenced by NewTextMetricExW2A().

◆ QueryFontAssocStatus()

DWORD WINAPI QueryFontAssocStatus ( VOID  )

Definition at line 2630 of file font.c.

2631{
2634 return 0;
2635}

◆ RemoveFontMemResourceEx()

BOOL WINAPI RemoveFontMemResourceEx ( HANDLE  fh)

Definition at line 2475 of file font.c.

2476{
2477 if (fh)
2478 {
2480 }
2482 return FALSE;
2483}
__kernel_entry W32KAPI BOOL APIENTRY NtGdiRemoveFontMemResourceEx(_In_ HANDLE hMMFont)

Referenced by START_TEST().

◆ RemoveFontResourceA()

BOOL WINAPI RemoveFontResourceA ( LPCSTR  lpFileName)

Definition at line 2059 of file font.c.

2060{
2062}
BOOL WINAPI RemoveFontResourceExA(LPCSTR lpFileName, DWORD fl, PVOID pdv)
Definition: font.c:2069
_In_ LPCSTR lpFileName
Definition: winbase.h:3071

◆ RemoveFontResourceExA()

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

Definition at line 2069 of file font.c.

2073{
2075 LPWSTR lpFileNameW;
2076
2077 /* FIXME the flags */
2078 /* FIXME the pdv */
2079 /* FIXME NtGdiRemoveFontResource handle flags and pdv */
2080
2081 Status = HEAP_strdupA2W ( &lpFileNameW, lpFileName );
2082 if (!NT_SUCCESS (Status))
2084 else
2085 {
2086
2087 HEAP_free ( lpFileNameW );
2088 }
2089
2090 return 0;
2091}

Referenced by RemoveFontResourceA(), and test_long_names().

◆ RemoveFontResourceExW()

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

Definition at line 2098 of file font.c.

2101{
2102 /* FIXME the flags */
2103 /* FIXME the pdv */
2104 /* FIXME NtGdiRemoveFontResource handle flags and pdv */
2105 DPRINT("RemoveFontResourceExW\n");
2106 return 0;
2107}

Referenced by RemoveFontResourceW(), and RemoveTempFont().

◆ RemoveFontResourceTracking()

int WINAPI RemoveFontResourceTracking ( LPCSTR  lpString,
int  unknown 
)

Definition at line 2506 of file font.c.

2507{
2510 return 0;
2511}

◆ RemoveFontResourceW()

BOOL WINAPI RemoveFontResourceW ( LPCWSTR  lpFileName)

Definition at line 2048 of file font.c.

2049{
2051}
BOOL WINAPI RemoveFontResourceExW(LPCWSTR lpFileName, DWORD fl, PVOID pdv)
Definition: font.c:2098

◆ SetMapperFlags()

DWORD WINAPI SetMapperFlags ( HDC  hDC,
DWORD  flags 
)

Definition at line 2235 of file font.c.

2239{
2240 DWORD Ret = GDI_ERROR;
2241 PDC_ATTR Dc_Attr;
2242
2243 /* Get the DC attribute */
2244 Dc_Attr = GdiGetDcAttr(hDC);
2245 if (Dc_Attr == NULL)
2246 {
2248 return GDI_ERROR;
2249 }
2250
2251 if (NtCurrentTeb()->GdiTebBatch.HDC == hDC)
2252 {
2253 if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY)
2254 {
2255 NtGdiFlush();
2257 }
2258 }
2259
2260 if ( flags & ~1 )
2262 else
2263 {
2264 Ret = Dc_Attr->flFontMapper;
2265 Dc_Attr->flFontMapper = flags;
2266 }
2267 return Ret;
2268}
FORCEINLINE PDC_ATTR GdiGetDcAttr(HDC hdc)
Definition: gdi32p.h:451
#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 2186 of file font.c.

2194{
2195 int index = 0;
2196 switch (flags)
2197 {
2198 case TCI_SRCFONTSIG:
2199 while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++;
2200 break;
2201 case TCI_SRCCODEPAGE:
2202 while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++;
2203 break;
2204 case TCI_SRCCHARSET:
2205 while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++;
2206 break;
2207 case TCI_SRCLOCALE:
2208 {
2209 LCID lCid = (LCID)PtrToUlong(lpSrc);
2210 LOCALESIGNATURE LocSig;
2211 INT Ret = GetLocaleInfoW(lCid, LOCALE_FONTSIGNATURE, (LPWSTR)&LocSig, 0);
2212 if ( GetLocaleInfoW(lCid, LOCALE_FONTSIGNATURE, (LPWSTR)&LocSig, Ret))
2213 {
2214 while (index < MAXTCIINDEX && !(LocSig.lsCsbDefault[0]>>index & 0x0001)) index++;
2215 break;
2216 }
2217 }
2218 default:
2220 return FALSE;
2221 }
2222 if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
2223 DPRINT("Index %d Charset %u CodePage %u FontSig %lu\n",
2224 index,FONT_tci[index].ciCharset,FONT_tci[index].ciACP,FONT_tci[index].fs.fsCsb[0]);
2225 memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
2226 return TRUE;
2227}
#define PtrToUlong(u)
Definition: config.h:107
VOID WINAPI GdiSetLastError(DWORD dwErrCode)
Definition: misc.c:873
GLuint index
Definition: glext.h:6031
INT WINAPI GetLocaleInfoW(LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len)
Definition: lang.c:1108
DWORD LCID
Definition: nls.h:13
Definition: ffs.h:70
static const CHARSETINFO FONT_tci[MAXTCIINDEX]
Definition: font.c:31
#define MAXTCIINDEX
Definition: font.c:30
#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:125

◆ UnloadNetworkFonts()

VOID WINAPI UnloadNetworkFonts ( DWORD  unknown)

Definition at line 2642 of file font.c.

◆ width_to_LP()

static INT width_to_LP ( XFORM xForm,
INT  width 
)
inlinestatic

Definition at line 1386 of file font.c.

1387{
1388 return GDI_ROUND( (double)width * fabs( xForm->eM11));
1389}
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 31 of file font.c.

Referenced by TranslateCharsetInfo().