/*
* For TranslateCharsetInfo
*/
-#define FS(x) {{0,0,0,0},{0x1<<(x),0}}
#define MAXTCIINDEX 32
static const CHARSETINFO FONT_tci[MAXTCIINDEX] = {
/* ANSI */
- { ANSI_CHARSET, 1252, FS(0)},
- { EASTEUROPE_CHARSET, 1250, FS(1)},
- { RUSSIAN_CHARSET, 1251, FS(2)},
- { GREEK_CHARSET, 1253, FS(3)},
- { TURKISH_CHARSET, 1254, FS(4)},
- { HEBREW_CHARSET, 1255, FS(5)},
- { ARABIC_CHARSET, 1256, FS(6)},
- { BALTIC_CHARSET, 1257, FS(7)},
- { VIETNAMESE_CHARSET, 1258, FS(8)},
+ { ANSI_CHARSET, 1252, {{0,0,0,0},{FS_LATIN1,0}} },
+ { EASTEUROPE_CHARSET, 1250, {{0,0,0,0},{FS_LATIN2,0}} },
+ { RUSSIAN_CHARSET, 1251, {{0,0,0,0},{FS_CYRILLIC,0}} },
+ { GREEK_CHARSET, 1253, {{0,0,0,0},{FS_GREEK,0}} },
+ { TURKISH_CHARSET, 1254, {{0,0,0,0},{FS_TURKISH,0}} },
+ { HEBREW_CHARSET, 1255, {{0,0,0,0},{FS_HEBREW,0}} },
+ { ARABIC_CHARSET, 1256, {{0,0,0,0},{FS_ARABIC,0}} },
+ { BALTIC_CHARSET, 1257, {{0,0,0,0},{FS_BALTIC,0}} },
+ { VIETNAMESE_CHARSET, 1258, {{0,0,0,0},{FS_VIETNAMESE,0}} },
/* reserved by ANSI */
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
/* ANSI and OEM */
- { THAI_CHARSET, 874, FS(16)},
- { SHIFTJIS_CHARSET, 932, FS(17)},
- { GB2312_CHARSET, 936, FS(18)},
- { HANGEUL_CHARSET, 949, FS(19)},
- { CHINESEBIG5_CHARSET, 950, FS(20)},
- { JOHAB_CHARSET, 1361, FS(21)},
+ { THAI_CHARSET, 874, {{0,0,0,0},{FS_THAI,0}} },
+ { SHIFTJIS_CHARSET, 932, {{0,0,0,0},{FS_JISJAPAN,0}} },
+ { GB2312_CHARSET, 936, {{0,0,0,0},{FS_CHINESESIMP,0}} },
+ { HANGEUL_CHARSET, 949, {{0,0,0,0},{FS_WANSUNG,0}} },
+ { CHINESEBIG5_CHARSET, 950, {{0,0,0,0},{FS_CHINESETRAD,0}} },
+ { JOHAB_CHARSET, 1361, {{0,0,0,0},{FS_JOHAB,0}} },
/* reserved for alternate ANSI and OEM */
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
- { DEFAULT_CHARSET, 0, FS(0)},
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
/* reserved for system */
- { DEFAULT_CHARSET, 0, FS(0)},
- { SYMBOL_CHARSET, CP_SYMBOL, FS(31)},
+ { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
+ { SYMBOL_CHARSET, CP_SYMBOL, {{0,0,0,0},{FS_SYMBOL,0}} }
};
#define INITIAL_FAMILY_COUNT 64
*/
static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
{
- UINT cp = CP_ACP; // GdiGetCodePage( hdc );
+ UINT cp = GdiGetCodePage( hdc );
INT lenW;
LPWSTR strW;
lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
strW = HeapAlloc(GetProcessHeap(), 0, lenW*sizeof(WCHAR));
MultiByteToWideChar(cp, 0, str, count, strW, lenW);
- DPRINT1("mapped %s -> %S\n", str, strW);
+ DPRINT("mapped %s -> %S\n", str, strW);
if(plenW) *plenW = lenW;
if(pCP) *pCP = cp;
return strW;
if (Unicode)
{
Ret = ((FONTENUMPROCW) EnumProc)(
- &Info[i].EnumLogFontEx,
- &Info[i].NewTextMetricEx,
+ (VOID*)&Info[i].EnumLogFontEx,
+ (VOID*)&Info[i].NewTextMetricEx,
Info[i].FontType, lParam);
}
else
NewTextMetricExW2A(&NewTextMetricExA,
&Info[i].NewTextMetricEx);
Ret = ((FONTENUMPROCA) EnumProc)(
- &EnumLogFontExA,
- &NewTextMetricExA,
+ (VOID*)&EnumLogFontExA,
+ (VOID*)&NewTextMetricExA,
Info[i].FontType, lParam);
}
}
/*
* @implemented
*/
-int STDCALL
+int WINAPI
EnumFontFamiliesExW(HDC hdc, LPLOGFONTW lpLogfont, FONTENUMPROCW lpEnumFontFamExProc,
LPARAM lParam, DWORD dwFlags)
{
/*
* @implemented
*/
-int STDCALL
+int WINAPI
EnumFontFamiliesW(HDC hdc, LPCWSTR lpszFamily, FONTENUMPROCW lpEnumFontFamProc,
LPARAM lParam)
{
LogFont.lfCharSet = DEFAULT_CHARSET;
if (NULL != lpszFamily)
{
+ if (!*lpszFamily) return 1;
lstrcpynW(LogFont.lfFaceName, lpszFamily, LF_FACESIZE);
}
/*
* @implemented
*/
-int STDCALL
+int WINAPI
EnumFontFamiliesExA (HDC hdc, LPLOGFONTA lpLogfont, FONTENUMPROCA lpEnumFontFamExProc,
LPARAM lParam, DWORD dwFlags)
{
- LOGFONTW LogFontW;
+ LOGFONTW LogFontW, *pLogFontW;
- LogFontA2W(&LogFontW, lpLogfont);
+ if (lpLogfont)
+ {
+ LogFontA2W(&LogFontW,lpLogfont);
+ pLogFontW = &LogFontW;
+ }
+ else pLogFontW = NULL;
/* no need to convert LogFontW back to lpLogFont b/c it's an [in] parameter only */
- return IntEnumFontFamilies(hdc, &LogFontW, lpEnumFontFamExProc, lParam, FALSE);
+ return IntEnumFontFamilies(hdc, pLogFontW, lpEnumFontFamExProc, lParam, FALSE);
}
/*
* @implemented
*/
-int STDCALL
+int WINAPI
EnumFontFamiliesA(HDC hdc, LPCSTR lpszFamily, FONTENUMPROCA lpEnumFontFamProc,
LPARAM lParam)
{
LogFont.lfCharSet = DEFAULT_CHARSET;
if (NULL != lpszFamily)
{
+ if (!*lpszFamily) return 1;
MultiByteToWideChar(CP_THREAD_ACP, 0, lpszFamily, -1, LogFont.lfFaceName, LF_FACESIZE);
}
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GetCharacterPlacementW(
HDC hdc,
LPCWSTR lpString,
*
*/
BOOL
-STDCALL
+WINAPI
GetCharABCWidthsFloatW(HDC hdc,
UINT FirstChar,
UINT LastChar,
LPABCFLOAT abcF)
{
-DPRINT("GetCharABCWidthsFloatW\n");
+ DPRINT("GetCharABCWidthsFloatW\n");
if ((!abcF) || (FirstChar > LastChar))
{
SetLastError(ERROR_INVALID_PARAMETER);
*
*/
BOOL
-STDCALL
+WINAPI
GetCharWidthFloatW(HDC hdc,
UINT iFirstChar,
UINT iLastChar,
PFLOAT pxBuffer)
{
-DPRINT("GetCharWidthsFloatW\n");
+ DPRINT("GetCharWidthsFloatW\n");
if ((!pxBuffer) || (iFirstChar > iLastChar))
{
SetLastError(ERROR_INVALID_PARAMETER);
*
*/
BOOL
-STDCALL
+WINAPI
GetCharWidthW(HDC hdc,
UINT iFirstChar,
UINT iLastChar,
LPINT lpBuffer)
{
-DPRINT("GetCharWidthsW\n");
+ DPRINT("GetCharWidthsW\n");
if ((!lpBuffer) || (iFirstChar > iLastChar))
{
SetLastError(ERROR_INVALID_PARAMETER);
*
*/
BOOL
-STDCALL
+WINAPI
GetCharWidth32W(HDC hdc,
UINT iFirstChar,
UINT iLastChar,
LPINT lpBuffer)
{
-DPRINT("GetCharWidths32W\n");
+ DPRINT("GetCharWidths32W\n");
if ((!lpBuffer) || (iFirstChar > iLastChar))
{
SetLastError(ERROR_INVALID_PARAMETER);
*
*/
BOOL
-STDCALL
+WINAPI
GetCharABCWidthsW(HDC hdc,
UINT FirstChar,
UINT LastChar,
LPABC lpabc)
{
-DPRINT("GetCharABCWidthsW\n");
+ DPRINT("GetCharABCWidthsW\n");
if ((!lpabc) || (FirstChar > LastChar))
{
SetLastError(ERROR_INVALID_PARAMETER);
* @implemented
*/
BOOL
-STDCALL
+WINAPI
GetCharWidthA(
HDC hdc,
UINT iFirstChar,
LPINT lpBuffer
)
{
-DPRINT("GetCharWidthsA\n");
INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1);
LPSTR str;
LPWSTR wstr;
BOOL ret = TRUE;
+ DPRINT("GetCharWidthsA\n");
if(count <= 0) return FALSE;
- str = HeapAlloc(GetProcessHeap(), 0, count);
+ str = HeapAlloc(GetProcessHeap(), 0, count+1);
+ if (!str)
+ return FALSE;
+
for(i = 0; i < count; i++)
- str[i] = (BYTE)(iFirstChar + i);
+ str[i] = (BYTE)(iFirstChar + i);
+ str[i] = '\0';
- wstr = FONT_mbtowc(NULL, str, count, &wlen, NULL);
+ wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
+ if (!wstr)
+ {
+ HeapFree(GetProcessHeap(), 0, str);
+ return FALSE;
+ }
ret = NtGdiGetCharWidthW( hdc,
wstr[0],
- (ULONG) count,
- (PWCHAR) wstr,
- GCW_NOFLOAT,
- (PVOID) lpBuffer);
+ (ULONG) count,
+ (PWCHAR) wstr,
+ GCW_NOFLOAT,
+ (PVOID) lpBuffer);
HeapFree(GetProcessHeap(), 0, str);
HeapFree(GetProcessHeap(), 0, wstr);
* @implemented
*/
BOOL
-STDCALL
+WINAPI
GetCharWidth32A(
HDC hdc,
UINT iFirstChar,
LPINT lpBuffer
)
{
-DPRINT("GetCharWidths32A\n");
INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1);
LPSTR str;
LPWSTR wstr;
BOOL ret = TRUE;
+ DPRINT("GetCharWidths32A\n");
if(count <= 0) return FALSE;
- str = HeapAlloc(GetProcessHeap(), 0, count);
+ str = HeapAlloc(GetProcessHeap(), 0, count+1);
+ if (!str)
+ return FALSE;
for(i = 0; i < count; i++)
- str[i] = (BYTE)(iFirstChar + i);
+ str[i] = (BYTE)(iFirstChar + i);
+ str[i] = '\0';
- wstr = FONT_mbtowc(NULL, str, count, &wlen, NULL);
+ wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
+ if (!wstr)
+ {
+ HeapFree(GetProcessHeap(), 0, str);
+ return FALSE;
+ }
ret = NtGdiGetCharWidthW( hdc,
wstr[0],
- (ULONG) count,
- (PWCHAR) wstr,
- GCW_NOFLOAT|GCW_WIN32,
- (PVOID) lpBuffer);
+ (ULONG) count,
+ (PWCHAR) wstr,
+ GCW_NOFLOAT|GCW_WIN32,
+ (PVOID) lpBuffer);
HeapFree(GetProcessHeap(), 0, str);
HeapFree(GetProcessHeap(), 0, wstr);
PFLOAT pxBuffer
)
{
-DPRINT("GetCharWidthsFloatA\n");
INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1);
LPSTR str;
LPWSTR wstr;
BOOL ret = TRUE;
+ DPRINT("GetCharWidthsFloatA\n");
if(count <= 0) return FALSE;
- str = HeapAlloc(GetProcessHeap(), 0, count);
+ str = HeapAlloc(GetProcessHeap(), 0, count+1);
+ if (!str)
+ return FALSE;
for(i = 0; i < count; i++)
- str[i] = (BYTE)(iFirstChar + i);
-
- wstr = FONT_mbtowc(NULL, str, count, &wlen, NULL);
+ str[i] = (BYTE)(iFirstChar + i);
+ str[i] = '\0';
+ wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
+ if (!wstr)
+ {
+ HeapFree(GetProcessHeap(), 0, str);
+ return FALSE;
+ }
ret = NtGdiGetCharWidthW( hdc, wstr[0], (ULONG) count, (PWCHAR) wstr, 0, (PVOID) pxBuffer);
HeapFree(GetProcessHeap(), 0, str);
LPABC lpabc
)
{
-DPRINT("GetCharABCWidthsA\n");
INT i, wlen, count = (INT)(uLastChar - uFirstChar + 1);
LPSTR str;
LPWSTR wstr;
BOOL ret = TRUE;
+ DPRINT("GetCharABCWidthsA\n");
if(count <= 0) return FALSE;
- str = HeapAlloc(GetProcessHeap(), 0, count);
+ str = HeapAlloc(GetProcessHeap(), 0, count+1);
+ if (!str)
+ return FALSE;
for(i = 0; i < count; i++)
- str[i] = (BYTE)(uFirstChar + i);
+ str[i] = (BYTE)(uFirstChar + i);
+ str[i] = '\0';
- wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
+ wstr = FONT_mbtowc(hdc, str, count+1, &wlen, NULL);
+ if (!wstr)
+ {
+ HeapFree(GetProcessHeap(), 0, str);
+ return FALSE;
+ }
ret = NtGdiGetCharABCWidthsW( hdc,
wstr[0],
- (ULONG)count,
- (PWCHAR)wstr,
- GCABCW_NOFLOAT,
- (PVOID)lpabc);
+ (ULONG)count,
+ (PWCHAR)wstr,
+ GCABCW_NOFLOAT,
+ (PVOID)lpabc);
HeapFree(GetProcessHeap(), 0, str);
HeapFree(GetProcessHeap(), 0, wstr);
LPABCFLOAT lpABCF
)
{
-DPRINT("GetCharABCWidthsFloatA\n");
INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1);
LPSTR str;
LPWSTR wstr;
BOOL ret = TRUE;
+ DPRINT("GetCharABCWidthsFloatA\n");
if (count <= 0) return FALSE;
- str = HeapAlloc(GetProcessHeap(), 0, count);
+ str = HeapAlloc(GetProcessHeap(), 0, count+1);
+ if (!str)
+ return FALSE;
for(i = 0; i < count; i++)
str[i] = (BYTE)(iFirstChar + i);
+ str[i] = '\0';
- wstr = FONT_mbtowc( hdc, str, count, &wlen, NULL );
-
+ wstr = FONT_mbtowc( hdc, str, count+1, &wlen, NULL );
+ if (!wstr)
+ {
+ HeapFree( GetProcessHeap(), 0, str );
+ return FALSE;
+ }
ret = NtGdiGetCharABCWidthsW( hdc,wstr[0],(ULONG)count, (PWCHAR)wstr, 0, (PVOID)lpABCF);
HeapFree( GetProcessHeap(), 0, str );
* @implemented
*/
BOOL
-STDCALL
+WINAPI
GetCharABCWidthsI(HDC hdc,
UINT giFirst,
UINT cgi,
LPWORD pgi,
LPABC lpabc)
{
-DPRINT("GetCharABCWidthsI\n");
+ DPRINT("GetCharABCWidthsI\n");
return NtGdiGetCharABCWidthsW( hdc,
giFirst,
(ULONG) cgi,
* @implemented
*/
BOOL
-STDCALL
+WINAPI
GetCharWidthI(HDC hdc,
UINT giFirst,
UINT cgi,
LPINT lpBuffer
)
{
-DPRINT("GetCharWidthsI\n");
+ DPRINT("GetCharWidthsI\n");
if (!lpBuffer || (!pgi && (giFirst == MAXUSHORT))) // Cannot be at max.
{
SetLastError(ERROR_INVALID_PARAMETER);
* @implemented
*/
DWORD
-STDCALL
+WINAPI
+GetFontLanguageInfo(
+ HDC hDc
+ )
+{
+ DWORD Gcp = 0, Ret = 0;
+ if (gbLpk)
+ {
+ Ret = NtGdiGetTextCharsetInfo(hDc, NULL, 0);
+ if ((Ret == ARABIC_CHARSET) || (Ret == HEBREW_CHARSET))
+ Ret = (GCP_KASHIDA|GCP_DIACRITIC|GCP_LIGATE|GCP_GLYPHSHAPE|GCP_REORDER);
+ }
+ Gcp = GetDCDWord(hDc, GdiGetFontLanguageInfo, GCP_ERROR);
+ if ( Gcp == GCP_ERROR)
+ return Gcp;
+ else
+ Ret = Gcp | Ret;
+ return Ret;
+}
+
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
GetGlyphIndicesA(
HDC hdc,
LPCSTR lpstr,
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GetGlyphOutlineA(
HDC hdc,
UINT uChar,
LPWSTR p = NULL;
DWORD ret;
UINT c;
- DPRINT1("GetGlyphOutlineA uChar %x\n", uChar);
+ DPRINT("GetGlyphOutlineA uChar %x\n", uChar);
if(!(uFormat & GGO_GLYPH_INDEX)) {
int len;
char mbchs[2];
len = 1;
mbchs[0] = (uChar & 0xff);
}
- p = FONT_mbtowc(NULL, mbchs, len, NULL, NULL);
- c = p[0];
+ p = FONT_mbtowc(hdc, mbchs, len, NULL, NULL);
+ c = p[0];
} else
c = uChar;
ret = NtGdiGetGlyphOutline(hdc, c, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GetGlyphOutlineW(
HDC hdc,
UINT uChar,
CONST MAT2 *lpmat2
)
{
- DPRINT("GetGlyphOutlineW uChar %x\n", uChar);
+ DPRINT("GetGlyphOutlineW uChar %x\n", uChar);
if (!lpgm & !lpmat2) return GDI_ERROR;
if (!lpvBuffer) cbBuffer = 0;
return NtGdiGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2, TRUE);
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GetKerningPairsW(HDC hdc,
ULONG cPairs,
LPKERNINGPAIR pkpDst)
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GetKerningPairsA( HDC hDC,
DWORD cPairs,
LPKERNINGPAIR kern_pairA )
* @implemented
*/
HFONT
-STDCALL
+WINAPI
CreateFontIndirectExA(const ENUMLOGFONTEXDVA *elfexd)
{
if (elfexd)
* @implemented
*/
HFONT
-STDCALL
+WINAPI
CreateFontIndirectExW(const ENUMLOGFONTEXDVW *elfexd)
{
/* Msdn: Note, this function ignores the elfDesignVector member in
* @implemented
*/
HFONT
-STDCALL
+WINAPI
CreateFontIndirectA(
CONST LOGFONTA *lplf
)
* @implemented
*/
HFONT
-STDCALL
+WINAPI
CreateFontIndirectW(
CONST LOGFONTW *lplf
)
RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfScript,
sizeof(Logfont.elfEnumLogfontEx.elfScript));
+ Logfont.elfDesignVector.dvNumAxes = 0; // No more than MM_MAX_NUMAXES
+
RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR));
return CreateFontIndirectExW(&Logfont);
* @implemented
*/
HFONT
-STDCALL
+WINAPI
CreateFontA(
int nHeight,
int nWidth,
* @implemented
*/
HFONT
-STDCALL
+WINAPI
CreateFontW(
int nHeight,
int nWidth,
* @unimplemented
*/
BOOL
-STDCALL
+WINAPI
CreateScalableFontResourceA(
DWORD fdwHidden,
LPCSTR lpszFontRes,
* @implemented
*/
int
-STDCALL
+WINAPI
AddFontResourceExW ( LPCWSTR lpszFilename, DWORD fl, PVOID pvReserved )
{
if (fl & ~(FR_PRIVATE | FR_NOT_ENUM))
* @implemented
*/
int
-STDCALL
+WINAPI
AddFontResourceExA ( LPCSTR lpszFilename, DWORD fl, PVOID pvReserved )
{
NTSTATUS Status;
* @implemented
*/
int
-STDCALL
+WINAPI
AddFontResourceA ( LPCSTR lpszFilename )
{
NTSTATUS Status;
* @implemented
*/
int
-STDCALL
+WINAPI
AddFontResourceW ( LPCWSTR lpszFilename )
{
return GdiAddFontResourceW ( lpszFilename, 0, 0 );
* @implemented
*/
BOOL
-STDCALL
+WINAPI
RemoveFontResourceW(LPCWSTR lpFileName)
{
return RemoveFontResourceExW(lpFileName,0,0);
* @implemented
*/
BOOL
-STDCALL
+WINAPI
RemoveFontResourceA(LPCSTR lpFileName)
{
return RemoveFontResourceExA(lpFileName,0,0);
* @unimplemented
*/
BOOL
-STDCALL
+WINAPI
RemoveFontResourceExA(LPCSTR lpFileName,
DWORD fl,
PVOID pdv
* @unimplemented
*/
BOOL
-STDCALL
+WINAPI
RemoveFontResourceExW(LPCWSTR lpFileName,
DWORD fl,
PVOID pdv)
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height)
{
SIZE sz;
* @unimplemented
*/
BOOL
-STDCALL
+WINAPI
TranslateCharsetInfo(
LPDWORD lpSrc, /* [in]
if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
* @implemented
*/
DWORD
-STDCALL
+WINAPI
SetMapperFlags(
HDC hDC,
DWORD flags
* @unimplemented
*/
int
-STDCALL
+WINAPI
EnumFontsW(
HDC hDC,
LPCWSTR lpFaceName,
* @unimplemented
*/
int
-STDCALL
+WINAPI
EnumFontsA (
HDC hDC,
LPCSTR lpFaceName,
#define EfdFontFamilies 3
INT
-STDCALL
+WINAPI
NewEnumFontFamiliesExW(
HDC hDC,
LPLOGFONTW lpLogfont,
{
PNTMW_INTERNAL pNtmwi = (PNTMW_INTERNAL)((ULONG_PTR)pEfdw + pEfdw->ulNtmwiOffset);
- ret = lpEnumFontFamExProcW(&pEfdw->elfexdv.elfEnumLogfontEx,
- &pNtmwi->ntmw,
+ ret = lpEnumFontFamExProcW((VOID*)&pEfdw->elfexdv.elfEnumLogfontEx,
+ (VOID*)&pNtmwi->ntmw,
pEfdw->dwFontType,
lParam);
projects / reactos.git / blobdiff