/*
* 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);
}
return IntEnumFontFamilies(hdc, &LogFont, lpEnumFontFamProc, lParam, FALSE);
}
-
-/*
- * @implemented
- */
-BOOL
-STDCALL
-GetCharWidthA (
- HDC hdc,
- UINT iFirstChar,
- UINT iLastChar,
- LPINT lpBuffer
- )
-{
-DPRINT1("GCWA iFirstChar %x\n",iFirstChar);
-
- return GetCharWidth32A ( hdc, iFirstChar, iLastChar, lpBuffer );
-}
-
-
-/*
- * @implemented
- */
-BOOL
-STDCALL
-GetCharWidth32A(
- HDC hdc,
- UINT iFirstChar,
- UINT iLastChar,
- LPINT lpBuffer
- )
-{
- INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1);
- LPSTR str;
- LPWSTR wstr;
- BOOL ret = TRUE;
-DPRINT1("GCW32A iFirstChar %x\n",iFirstChar);
-
- if(count <= 0) return FALSE;
-
- str = HeapAlloc(GetProcessHeap(), 0, count);
- for(i = 0; i < count; i++)
- str[i] = (BYTE)(iFirstChar + i);
-
- wstr = FONT_mbtowc(NULL, str, count, &wlen, NULL);
-
- for(i = 0; i < wlen; i++)
- {
- /* FIXME should be NtGdiGetCharWidthW */
- if(!NtGdiGetCharWidth32 (hdc, wstr[i], wstr[i], lpBuffer))
- {
- ret = FALSE;
- break;
- }
- lpBuffer++;
- }
-
- HeapFree(GetProcessHeap(), 0, str);
- HeapFree(GetProcessHeap(), 0, wstr);
-
- return ret;
-}
-
-
-/*
- * @implemented
- */
-BOOL
-STDCALL
-GetCharWidthW (
- HDC hdc,
- UINT iFirstChar,
- UINT iLastChar,
- LPINT lpBuffer
- )
-{
-DPRINT1("GCW32w uFirstChar %x\n",iFirstChar);
-
- /* FIXME should be NtGdiGetCharWidthW */
- return NtGdiGetCharWidth32 ( hdc, iFirstChar, iLastChar, lpBuffer );
-}
-
-
/*
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GetCharacterPlacementW(
HDC hdc,
LPCWSTR lpString,
DWORD ret=0;
SIZE size;
UINT i, nSet;
+ DPRINT("GetCharacterPlacementW\n");
if(dwFlags&(~GCP_REORDER)) DPRINT("flags 0x%08lx ignored\n", dwFlags);
if(lpResults->lpClass) DPRINT("classes not implemented\n");
int c;
for (i = 0; i < nSet; i++)
{
- if (NtGdiGetCharWidth32(hdc, lpString[i], lpString[i], &c))
+ if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
lpResults->lpDx[i]= c;
}
}
return ret;
}
+/*
+ * @implemented
+ *
+ */
+BOOL
+WINAPI
+GetCharABCWidthsFloatW(HDC hdc,
+ UINT FirstChar,
+ UINT LastChar,
+ LPABCFLOAT abcF)
+{
+ DPRINT("GetCharABCWidthsFloatW\n");
+ if ((!abcF) || (FirstChar > LastChar))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+ return NtGdiGetCharABCWidthsW( hdc,
+ FirstChar,
+ (ULONG)(LastChar - FirstChar + 1),
+ (PWCHAR) NULL,
+ 0,
+ (PVOID)abcF);
+}
+
+/*
+ * @implemented
+ *
+ */
+BOOL
+WINAPI
+GetCharWidthFloatW(HDC hdc,
+ UINT iFirstChar,
+ UINT iLastChar,
+ PFLOAT pxBuffer)
+{
+ DPRINT("GetCharWidthsFloatW\n");
+ if ((!pxBuffer) || (iFirstChar > iLastChar))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+ return NtGdiGetCharWidthW( hdc,
+ iFirstChar,
+ (ULONG)(iLastChar - iFirstChar + 1),
+ (PWCHAR) NULL,
+ 0,
+ (PVOID) pxBuffer);
+}
/*
- * @unimplemented
+ * @implemented
+ *
+ */
+BOOL
+WINAPI
+GetCharWidthW(HDC hdc,
+ UINT iFirstChar,
+ UINT iLastChar,
+ LPINT lpBuffer)
+{
+ DPRINT("GetCharWidthsW\n");
+ if ((!lpBuffer) || (iFirstChar > iLastChar))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+ return NtGdiGetCharWidthW( hdc,
+ iFirstChar,
+ (ULONG)(iLastChar - iFirstChar + 1),
+ (PWCHAR) NULL,
+ GCW_NOFLOAT,
+ (PVOID) lpBuffer);
+}
+
+/*
+ * @implemented
+ *
+ */
+BOOL
+WINAPI
+GetCharWidth32W(HDC hdc,
+ UINT iFirstChar,
+ UINT iLastChar,
+ LPINT lpBuffer)
+{
+ DPRINT("GetCharWidths32W\n");
+ if ((!lpBuffer) || (iFirstChar > iLastChar))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+ return NtGdiGetCharWidthW( hdc,
+ iFirstChar,
+ (ULONG)(iLastChar - iFirstChar + 1),
+ (PWCHAR) NULL,
+ GCW_NOFLOAT|GCW_WIN32,
+ (PVOID) lpBuffer);
+}
+
+
+/*
+ * @implemented
+ *
+ */
+BOOL
+WINAPI
+GetCharABCWidthsW(HDC hdc,
+ UINT FirstChar,
+ UINT LastChar,
+ LPABC lpabc)
+{
+ DPRINT("GetCharABCWidthsW\n");
+ if ((!lpabc) || (FirstChar > LastChar))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+ return NtGdiGetCharABCWidthsW( hdc,
+ FirstChar,
+ (ULONG)(LastChar - FirstChar + 1),
+ (PWCHAR) NULL,
+ GCABCW_NOFLOAT,
+ (PVOID)lpabc);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+GetCharWidthA(
+ HDC hdc,
+ UINT iFirstChar,
+ UINT iLastChar,
+ LPINT lpBuffer
+ )
+{
+ 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+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+1, &wlen, NULL);
+ if (!wstr)
+ {
+ HeapFree(GetProcessHeap(), 0, str);
+ return FALSE;
+ }
+
+ ret = NtGdiGetCharWidthW( hdc,
+ wstr[0],
+ (ULONG) count,
+ (PWCHAR) wstr,
+ GCW_NOFLOAT,
+ (PVOID) lpBuffer);
+
+ HeapFree(GetProcessHeap(), 0, str);
+ HeapFree(GetProcessHeap(), 0, wstr);
+
+ return ret;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+GetCharWidth32A(
+ HDC hdc,
+ UINT iFirstChar,
+ UINT iLastChar,
+ LPINT lpBuffer
+ )
+{
+ 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+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+1, &wlen, NULL);
+ if (!wstr)
+ {
+ HeapFree(GetProcessHeap(), 0, str);
+ return FALSE;
+ }
+
+ ret = NtGdiGetCharWidthW( hdc,
+ wstr[0],
+ (ULONG) count,
+ (PWCHAR) wstr,
+ GCW_NOFLOAT|GCW_WIN32,
+ (PVOID) lpBuffer);
+
+ HeapFree(GetProcessHeap(), 0, str);
+ HeapFree(GetProcessHeap(), 0, wstr);
+
+ return ret;
+}
+
+/*
+ * @implemented
*/
BOOL
APIENTRY
PFLOAT pxBuffer
)
{
- /* FIXME what to do with iFirstChar and iLastChar ??? */
- return FALSE;
-}
+ 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+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+1, &wlen, NULL);
+ if (!wstr)
+ {
+ HeapFree(GetProcessHeap(), 0, str);
+ return FALSE;
+ }
+ ret = NtGdiGetCharWidthW( hdc, wstr[0], (ULONG) count, (PWCHAR) wstr, 0, (PVOID) pxBuffer);
+ HeapFree(GetProcessHeap(), 0, str);
+ HeapFree(GetProcessHeap(), 0, wstr);
+
+ return ret;
+}
/*
* @implemented
LPABC lpabc
)
{
-DPRINT1("GCABCWA uFirstChar %x\n",uFirstChar);
+ INT i, wlen, count = (INT)(uLastChar - uFirstChar + 1);
+ LPSTR str;
+ LPWSTR wstr;
+ BOOL ret = TRUE;
-return NtGdiGetCharABCWidths(hdc, uFirstChar, uLastChar, lpabc);
-}
+ DPRINT("GetCharABCWidthsA\n");
+ if(count <= 0) return FALSE;
+
+ str = HeapAlloc(GetProcessHeap(), 0, count+1);
+ if (!str)
+ return FALSE;
+ for(i = 0; i < count; i++)
+ str[i] = (BYTE)(uFirstChar + i);
+ str[i] = '\0';
+
+ 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);
+
+ HeapFree(GetProcessHeap(), 0, str);
+ HeapFree(GetProcessHeap(), 0, wstr);
+
+ return ret;
+}
/*
- * @unimplemented
+ * @implemented
*/
BOOL
APIENTRY
LPABCFLOAT lpABCF
)
{
-DPRINT1("GCABCWFA iFirstChar %x\n",iFirstChar);
+ INT i, wlen, count = (INT)(iLastChar - iFirstChar + 1);
+ LPSTR str;
+ LPWSTR wstr;
+ BOOL ret = TRUE;
- /* FIXME what to do with iFirstChar and iLastChar ??? */
- return FALSE;
+ DPRINT("GetCharABCWidthsFloatA\n");
+ if (count <= 0) return FALSE;
+
+ 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+1, &wlen, NULL );
+ if (!wstr)
+ {
+ HeapFree( GetProcessHeap(), 0, str );
+ return FALSE;
+ }
+ ret = NtGdiGetCharABCWidthsW( hdc,wstr[0],(ULONG)count, (PWCHAR)wstr, 0, (PVOID)lpABCF);
+
+ HeapFree( GetProcessHeap(), 0, str );
+ HeapFree( GetProcessHeap(), 0, wstr );
+
+ return ret;
}
/*
* @implemented
*/
BOOL
-STDCALL
+WINAPI
GetCharABCWidthsI(HDC hdc,
UINT giFirst,
UINT cgi,
LPWORD pgi,
- LPABC lpabc
+ LPABC lpabc)
+{
+ DPRINT("GetCharABCWidthsI\n");
+ return NtGdiGetCharABCWidthsW( hdc,
+ giFirst,
+ (ULONG) cgi,
+ (PWCHAR) pgi,
+ GCABCW_NOFLOAT|GCABCW_INDICES,
+ (PVOID)lpabc);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+GetCharWidthI(HDC hdc,
+ UINT giFirst,
+ UINT cgi,
+ LPWORD pgi,
+ LPINT lpBuffer
)
{
- return NtGdiGetCharABCWidthsW( hdc, giFirst, (ULONG) cgi, (PWCHAR) pgi, 3, (PVOID)lpabc);
+ DPRINT("GetCharWidthsI\n");
+ if (!lpBuffer || (!pgi && (giFirst == MAXUSHORT))) // Cannot be at max.
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+ if (!cgi) return TRUE;
+ return NtGdiGetCharWidthW( hdc,
+ giFirst,
+ cgi,
+ (PWCHAR) pgi,
+ GCW_INDICES|GCW_NOFLOAT|GCW_WIN32,
+ (PVOID) lpBuffer );
+}
+
+/*
+ * @implemented
+ */
+DWORD
+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
-STDCALL
+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
)
{
- DPRINT1("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);
}
return NtGdiGetOutlineTextMetricsInternalW(hdc, cbData, lpOTM, &Tmd);
}
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
+GetKerningPairsW(HDC hdc,
+ ULONG cPairs,
+ LPKERNINGPAIR pkpDst)
+{
+ if ((cPairs != 0) || (pkpDst == 0))
+ {
+ return NtGdiGetKerningPairs(hdc,cPairs,pkpDst);
+ }
+ else
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+}
+
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
+GetKerningPairsA( HDC hDC,
+ DWORD cPairs,
+ LPKERNINGPAIR kern_pairA )
+{
+ INT charset;
+ CHARSETINFO csi;
+ CPINFO cpi;
+ DWORD i, total_kern_pairs, kern_pairs_copied = 0;
+ KERNINGPAIR *kern_pairW;
+
+ if (!cPairs && kern_pairA)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+
+ charset = GetTextCharset(hDC);
+ if (!TranslateCharsetInfo(ULongToPtr(charset), &csi, TCI_SRCCHARSET))
+ {
+ DPRINT1("Can't find codepage for charset %d\n", charset);
+ return 0;
+ }
+ /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
+ * to fail on an invalid character for CP_SYMBOL.
+ */
+ cpi.DefaultChar[0] = 0;
+ if (csi.ciACP != CP_SYMBOL && !GetCPInfo(csi.ciACP, &cpi))
+ {
+ DPRINT1("Can't find codepage %u info\n", csi.ciACP);
+ return 0;
+ }
+ DPRINT("charset %d => codepage %u\n", charset, csi.ciACP);
+
+ total_kern_pairs = NtGdiGetKerningPairs(hDC, 0, NULL);
+ if (!total_kern_pairs) return 0;
+
+ if (!cPairs && !kern_pairA) return total_kern_pairs;
+
+ kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
+ GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
+
+ for (i = 0; i < total_kern_pairs; i++)
+ {
+ char first, second;
+
+ if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
+ continue;
+
+ if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
+ continue;
+
+ if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
+ continue;
+
+ if (kern_pairA)
+ {
+ if (kern_pairs_copied >= cPairs) break;
+
+ kern_pairA->wFirst = (BYTE)first;
+ kern_pairA->wSecond = (BYTE)second;
+ kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
+ kern_pairA++;
+ }
+ kern_pairs_copied++;
+ }
+
+ HeapFree(GetProcessHeap(), 0, kern_pairW);
+
+ return kern_pairs_copied;
+}
+
+
/*
* @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,
/*
- * @implemented
- */
-BOOL
-STDCALL
-CreateScalableFontResourceW(
- DWORD fdwHidden,
- LPCWSTR lpszFontRes,
- LPCWSTR lpszFontFile,
- LPCWSTR lpszCurrentPath
- )
-{
- return NtGdiCreateScalableFontResource ( fdwHidden,
- lpszFontRes,
- lpszFontFile,
- lpszCurrentPath );
-}
-
-
-/*
- * @implemented
+ * @unimplemented
*/
BOOL
-STDCALL
+WINAPI
CreateScalableFontResourceA(
DWORD fdwHidden,
LPCSTR lpszFontRes,
LPCSTR lpszCurrentPath
)
{
- NTSTATUS Status;
- LPWSTR lpszFontResW, lpszFontFileW, lpszCurrentPathW;
- BOOL rc = FALSE;
-
- Status = HEAP_strdupA2W ( &lpszFontResW, lpszFontRes );
- if (!NT_SUCCESS (Status))
- SetLastError (RtlNtStatusToDosError(Status));
- else
- {
- Status = HEAP_strdupA2W ( &lpszFontFileW, lpszFontFile );
- if (!NT_SUCCESS (Status))
- SetLastError (RtlNtStatusToDosError(Status));
- else
- {
- Status = HEAP_strdupA2W ( &lpszCurrentPathW, lpszCurrentPath );
- if (!NT_SUCCESS (Status))
- SetLastError (RtlNtStatusToDosError(Status));
- else
- {
- rc = NtGdiCreateScalableFontResource ( fdwHidden,
- lpszFontResW,
- lpszFontFileW,
- lpszCurrentPathW );
-
- HEAP_free ( lpszCurrentPathW );
- }
-
- HEAP_free ( lpszFontFileW );
- }
-
- HEAP_free ( lpszFontResW );
- }
- return rc;
+ return FALSE;
}
* @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);
}
/*
- * @implemented
+ * @unimplemented
*/
BOOL
-STDCALL
+WINAPI
RemoveFontResourceExA(LPCSTR lpFileName,
DWORD fl,
PVOID pdv
{
NTSTATUS Status;
LPWSTR lpFileNameW;
- BOOL rc = 0;
/* FIXME the flags */
/* FIXME the pdv */
SetLastError (RtlNtStatusToDosError(Status));
else
{
- rc = NtGdiRemoveFontResource ( lpFileNameW );
HEAP_free ( lpFileNameW );
}
- return rc;
+ return 0;
}
/*
* @unimplemented
*/
BOOL
-STDCALL
+WINAPI
RemoveFontResourceExW(LPCWSTR lpFileName,
DWORD fl,
PVOID pdv)
/* FIXME the flags */
/* FIXME the pdv */
/* FIXME NtGdiRemoveFontResource handle flags and pdv */
- return NtGdiRemoveFontResource ( lpFileName);
+ return 0;
}
* @implemented
*/
DWORD
-STDCALL
+WINAPI
GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height)
{
SIZE sz;
+ TEXTMETRICW tm;
static const WCHAR alphabet[] = {
'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
- if(lptm && !GetTextMetricsW(hdc, lptm)) return 0;
+ if(!GetTextMetricsW(hdc, &tm)) return 0;
if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
- if (height) *height = sz.cy;
+ if (lptm) *lptm = tm;
+ if (height) *height = tm.tmHeight;
+
return (sz.cx / 26 + 1) / 2;
}
* @unimplemented
*/
BOOL
-STDCALL
+WINAPI
TranslateCharsetInfo(
LPDWORD lpSrc, /* [in]
if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
}
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
+SetMapperFlags(
+ HDC hDC,
+ DWORD flags
+ )
+{
+ DWORD Ret = GDI_ERROR;
+ PDC_ATTR Dc_Attr;
+#if 0
+ if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC)
+ {
+ if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC)
+ return MFDRV_SetMapperFlags( hDC, flags);
+ else
+ {
+ PLDC pLDC = Dc_Attr->pvLDC;
+ if ( !pLDC )
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ return GDI_ERROR;
+ }
+ if (pLDC->iType == LDC_EMFLDC)
+ {
+ return EMFDRV_SetMapperFlags( hDC, flags);
+ }
+ }
+ }
+#endif
+ if (!GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return GDI_ERROR;
+
+ if (NtCurrentTeb()->GdiTebBatch.HDC == hDC)
+ {
+ if (Dc_Attr->ulDirty_ & DC_FONTTEXT_DIRTY)
+ {
+ NtGdiFlush();
+ Dc_Attr->ulDirty_ &= ~(DC_MODE_DIRTY|DC_FONTTEXT_DIRTY);
+ }
+ }
+
+ if ( flags & ~1 )
+ SetLastError(ERROR_INVALID_PARAMETER);
+ else
+ {
+ Ret = Dc_Attr->flFontMapper;
+ Dc_Attr->flFontMapper = flags;
+ }
+ return Ret;
+}
+
+
/*
* @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);