?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add the aclapi.h header file.
[wine/multimedia.git] / objects / font.c
blobc11b6d068a6e2bd49d5aa6396c017a066bbdb31e
1 /*
2 * GDI font objects
3 *
4 * Copyright 1993 Alexandre Julliard
5 * 1997 Alex Korobka
6 * Copyright 2002,2003 Shachar Shemesh
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <assert.h>
30 #include "winerror.h"
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winnls.h"
34 #include "wownt32.h"
35 #include "gdi.h"
36 #include "gdi_private.h"
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(font);
41 WINE_DECLARE_DEBUG_CHANNEL(gdi);
42
43 /* Device -> World size conversion */
44
45 /* Performs a device to world transformation on the specified width (which
46 * is in integer format).
47 */
48 static inline INT INTERNAL_XDSTOWS(DC *dc, INT width)
49 {
50 FLOAT floatWidth;
51
52 /* Perform operation with floating point */
53 floatWidth = (FLOAT)width * dc->xformVport2World.eM11;
54 /* Round to integers */
55 return GDI_ROUND(floatWidth);
56 }
57
58 /* Performs a device to world transformation on the specified size (which
59 * is in integer format).
60 */
61 static inline INT INTERNAL_YDSTOWS(DC *dc, INT height)
62 {
63 FLOAT floatHeight;
64
65 /* Perform operation with floating point */
66 floatHeight = (FLOAT)height * dc->xformVport2World.eM22;
67 /* Round to integers */
68 return GDI_ROUND(floatHeight);
69 }
70
71
72 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, void *obj, HDC hdc );
73 static INT FONT_GetObject16( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
74 static INT FONT_GetObjectA( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
75 static INT FONT_GetObjectW( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
76 static BOOL FONT_DeleteObject( HGDIOBJ handle, void *obj );
77
78 static const struct gdi_obj_funcs font_funcs =
79 {
80 FONT_SelectObject, /* pSelectObject */
81 FONT_GetObject16, /* pGetObject16 */
82 FONT_GetObjectA, /* pGetObjectA */
83 FONT_GetObjectW, /* pGetObjectW */
84 NULL, /* pUnrealizeObject */
85 FONT_DeleteObject /* pDeleteObject */
86 };
87
88 #define ENUM_UNICODE 0x00000001
89 #define ENUM_CALLED 0x00000002
90
91 typedef struct
92 {
93 GDIOBJHDR header;
94 LOGFONTW logfont;
95 } FONTOBJ;
96
97 typedef struct
98 {
99 LPLOGFONT16 lpLogFontParam;
100 FONTENUMPROC16 lpEnumFunc;
101 LPARAM lpData;
102
103 LPNEWTEXTMETRICEX16 lpTextMetric;
104 LPENUMLOGFONTEX16 lpLogFont;
105 SEGPTR segTextMetric;
106 SEGPTR segLogFont;
107 DWORD dwFlags;
108 HDC hdc;
109 DC *dc;
110 PHYSDEV physDev;
111 } fontEnum16;
112
113 typedef struct
114 {
115 LPLOGFONTW lpLogFontParam;
116 FONTENUMPROCW lpEnumFunc;
117 LPARAM lpData;
118 DWORD dwFlags;
119 HDC hdc;
120 DC *dc;
121 PHYSDEV physDev;
122 } fontEnum32;
123
124 /*
125 * For TranslateCharsetInfo
126 */
127 #define FS(x) {{0,0,0,0},{0x1<<(x),0}}
128 #define MAXTCIINDEX 32
129 static CHARSETINFO FONT_tci[MAXTCIINDEX] = {
130 /* ANSI */
131 { ANSI_CHARSET, 1252, FS(0)},
132 { EASTEUROPE_CHARSET, 1250, FS(1)},
133 { RUSSIAN_CHARSET, 1251, FS(2)},
134 { GREEK_CHARSET, 1253, FS(3)},
135 { TURKISH_CHARSET, 1254, FS(4)},
136 { HEBREW_CHARSET, 1255, FS(5)},
137 { ARABIC_CHARSET, 1256, FS(6)},
138 { BALTIC_CHARSET, 1257, FS(7)},
139 { VIETNAMESE_CHARSET, 1258, FS(8)},
140 /* reserved by ANSI */
141 { DEFAULT_CHARSET, 0, FS(0)},
142 { DEFAULT_CHARSET, 0, FS(0)},
143 { DEFAULT_CHARSET, 0, FS(0)},
144 { DEFAULT_CHARSET, 0, FS(0)},
145 { DEFAULT_CHARSET, 0, FS(0)},
146 { DEFAULT_CHARSET, 0, FS(0)},
147 { DEFAULT_CHARSET, 0, FS(0)},
148 /* ANSI and OEM */
149 { THAI_CHARSET, 874, FS(16)},
150 { SHIFTJIS_CHARSET, 932, FS(17)},
151 { GB2312_CHARSET, 936, FS(18)},
152 { HANGEUL_CHARSET, 949, FS(19)},
153 { CHINESEBIG5_CHARSET, 950, FS(20)},
154 { JOHAB_CHARSET, 1361, FS(21)},
155 /* reserved for alternate ANSI and OEM */
156 { DEFAULT_CHARSET, 0, FS(0)},
157 { DEFAULT_CHARSET, 0, FS(0)},
158 { DEFAULT_CHARSET, 0, FS(0)},
159 { DEFAULT_CHARSET, 0, FS(0)},
160 { DEFAULT_CHARSET, 0, FS(0)},
161 { DEFAULT_CHARSET, 0, FS(0)},
162 { DEFAULT_CHARSET, 0, FS(0)},
163 { DEFAULT_CHARSET, 0, FS(0)},
164 /* reserved for system */
165 { DEFAULT_CHARSET, 0, FS(0)},
166 { SYMBOL_CHARSET, CP_SYMBOL, FS(31)},
167 };
168
169 /***********************************************************************
170 * LOGFONT conversion functions.
171 */
172 static void FONT_LogFontWTo16( const LOGFONTW* font32, LPLOGFONT16 font16 )
173 {
174 font16->lfHeight = font32->lfHeight;
175 font16->lfWidth = font32->lfWidth;
176 font16->lfEscapement = font32->lfEscapement;
177 font16->lfOrientation = font32->lfOrientation;
178 font16->lfWeight = font32->lfWeight;
179 font16->lfItalic = font32->lfItalic;
180 font16->lfUnderline = font32->lfUnderline;
181 font16->lfStrikeOut = font32->lfStrikeOut;
182 font16->lfCharSet = font32->lfCharSet;
183 font16->lfOutPrecision = font32->lfOutPrecision;
184 font16->lfClipPrecision = font32->lfClipPrecision;
185 font16->lfQuality = font32->lfQuality;
186 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
187 WideCharToMultiByte( CP_ACP, 0, font32->lfFaceName, -1,
188 font16->lfFaceName, LF_FACESIZE, NULL, NULL );
189 font16->lfFaceName[LF_FACESIZE-1] = 0;
190 }
191
192 static void FONT_LogFont16ToW( const LOGFONT16 *font16, LPLOGFONTW font32 )
193 {
194 font32->lfHeight = font16->lfHeight;
195 font32->lfWidth = font16->lfWidth;
196 font32->lfEscapement = font16->lfEscapement;
197 font32->lfOrientation = font16->lfOrientation;
198 font32->lfWeight = font16->lfWeight;
199 font32->lfItalic = font16->lfItalic;
200 font32->lfUnderline = font16->lfUnderline;
201 font32->lfStrikeOut = font16->lfStrikeOut;
202 font32->lfCharSet = font16->lfCharSet;
203 font32->lfOutPrecision = font16->lfOutPrecision;
204 font32->lfClipPrecision = font16->lfClipPrecision;
205 font32->lfQuality = font16->lfQuality;
206 font32->lfPitchAndFamily = font16->lfPitchAndFamily;
207 MultiByteToWideChar( CP_ACP, 0, font16->lfFaceName, -1, font32->lfFaceName, LF_FACESIZE );
208 font32->lfFaceName[LF_FACESIZE-1] = 0;
209 }
210
211 static void FONT_LogFontAToW( const LOGFONTA *fontA, LPLOGFONTW fontW )
212 {
213 memcpy(fontW, fontA, sizeof(LOGFONTA) - LF_FACESIZE);
214 MultiByteToWideChar(CP_ACP, 0, fontA->lfFaceName, -1, fontW->lfFaceName,
215 LF_FACESIZE);
216 }
217
218 static void FONT_LogFontWToA( const LOGFONTW *fontW, LPLOGFONTA fontA )
219 {
220 memcpy(fontA, fontW, sizeof(LOGFONTA) - LF_FACESIZE);
221 WideCharToMultiByte(CP_ACP, 0, fontW->lfFaceName, -1, fontA->lfFaceName,
222 LF_FACESIZE, NULL, NULL);
223 }
224
225 static void FONT_EnumLogFontExWTo16( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEX16 font16 )
226 {
227 FONT_LogFontWTo16( (LPLOGFONTW)fontW, (LPLOGFONT16)font16);
228
229 WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
230 font16->elfFullName, LF_FULLFACESIZE, NULL, NULL );
231 font16->elfFullName[LF_FULLFACESIZE-1] = '\0';
232 WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
233 font16->elfStyle, LF_FACESIZE, NULL, NULL );
234 font16->elfStyle[LF_FACESIZE-1] = '\0';
235 WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
236 font16->elfScript, LF_FACESIZE, NULL, NULL );
237 font16->elfScript[LF_FACESIZE-1] = '\0';
238 }
239
240 static void FONT_EnumLogFontExWToA( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEXA fontA )
241 {
242 FONT_LogFontWToA( (LPLOGFONTW)fontW, (LPLOGFONTA)fontA);
243
244 WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
245 fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL );
246 fontA->elfFullName[LF_FULLFACESIZE-1] = '\0';
247 WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
248 fontA->elfStyle, LF_FACESIZE, NULL, NULL );
249 fontA->elfStyle[LF_FACESIZE-1] = '\0';
250 WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
251 fontA->elfScript, LF_FACESIZE, NULL, NULL );
252 fontA->elfScript[LF_FACESIZE-1] = '\0';
253 }
254
255 /***********************************************************************
256 * TEXTMETRIC conversion functions.
257 */
258 static void FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA )
259 {
260 ptmA->tmHeight = ptmW->tmHeight;
261 ptmA->tmAscent = ptmW->tmAscent;
262 ptmA->tmDescent = ptmW->tmDescent;
263 ptmA->tmInternalLeading = ptmW->tmInternalLeading;
264 ptmA->tmExternalLeading = ptmW->tmExternalLeading;
265 ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
266 ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
267 ptmA->tmWeight = ptmW->tmWeight;
268 ptmA->tmOverhang = ptmW->tmOverhang;
269 ptmA->tmDigitizedAspectX = ptmW->tmDigitizedAspectX;
270 ptmA->tmDigitizedAspectY = ptmW->tmDigitizedAspectY;
271 ptmA->tmFirstChar = ptmW->tmFirstChar > 255 ? 255 : ptmW->tmFirstChar;
272 ptmA->tmLastChar = ptmW->tmLastChar > 255 ? 255 : ptmW->tmLastChar;
273 ptmA->tmDefaultChar = ptmW->tmDefaultChar > 255 ? 255 : ptmW->tmDefaultChar;
274 ptmA->tmBreakChar = ptmW->tmBreakChar > 255 ? 255 : ptmW->tmBreakChar;
275 ptmA->tmItalic = ptmW->tmItalic;
276 ptmA->tmUnderlined = ptmW->tmUnderlined;
277 ptmA->tmStruckOut = ptmW->tmStruckOut;
278 ptmA->tmPitchAndFamily = ptmW->tmPitchAndFamily;
279 ptmA->tmCharSet = ptmW->tmCharSet;
280 }
281
282
283 static void FONT_NewTextMetricExWTo16(const NEWTEXTMETRICEXW *ptmW, LPNEWTEXTMETRICEX16 ptm16 )
284 {
285 ptm16->ntmTm.tmHeight = ptmW->ntmTm.tmHeight;
286 ptm16->ntmTm.tmAscent = ptmW->ntmTm.tmAscent;
287 ptm16->ntmTm.tmDescent = ptmW->ntmTm.tmDescent;
288 ptm16->ntmTm.tmInternalLeading = ptmW->ntmTm.tmInternalLeading;
289 ptm16->ntmTm.tmExternalLeading = ptmW->ntmTm.tmExternalLeading;
290 ptm16->ntmTm.tmAveCharWidth = ptmW->ntmTm.tmAveCharWidth;
291 ptm16->ntmTm.tmMaxCharWidth = ptmW->ntmTm.tmMaxCharWidth;
292 ptm16->ntmTm.tmWeight = ptmW->ntmTm.tmWeight;
293 ptm16->ntmTm.tmOverhang = ptmW->ntmTm.tmOverhang;
294 ptm16->ntmTm.tmDigitizedAspectX = ptmW->ntmTm.tmDigitizedAspectX;
295 ptm16->ntmTm.tmDigitizedAspectY = ptmW->ntmTm.tmDigitizedAspectY;
296 ptm16->ntmTm.tmFirstChar = ptmW->ntmTm.tmFirstChar > 255 ? 255 : ptmW->ntmTm.tmFirstChar;
297 ptm16->ntmTm.tmLastChar = ptmW->ntmTm.tmLastChar > 255 ? 255 : ptmW->ntmTm.tmLastChar;
298 ptm16->ntmTm.tmDefaultChar = ptmW->ntmTm.tmDefaultChar > 255 ? 255 : ptmW->ntmTm.tmDefaultChar;
299 ptm16->ntmTm.tmBreakChar = ptmW->ntmTm.tmBreakChar > 255 ? 255 : ptmW->ntmTm.tmBreakChar;
300 ptm16->ntmTm.tmItalic = ptmW->ntmTm.tmItalic;
301 ptm16->ntmTm.tmUnderlined = ptmW->ntmTm.tmUnderlined;
302 ptm16->ntmTm.tmStruckOut = ptmW->ntmTm.tmStruckOut;
303 ptm16->ntmTm.tmPitchAndFamily = ptmW->ntmTm.tmPitchAndFamily;
304 ptm16->ntmTm.tmCharSet = ptmW->ntmTm.tmCharSet;
305 ptm16->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
306 ptm16->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
307 ptm16->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
308 ptm16->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
309 memcpy(&ptm16->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
310 }
311
312 static void FONT_NewTextMetricExWToA(const NEWTEXTMETRICEXW *ptmW, NEWTEXTMETRICEXA *ptmA )
313 {
314 FONT_TextMetricWToA((LPTEXTMETRICW)ptmW, (LPTEXTMETRICA)ptmA);
315 ptmA->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
316 ptmA->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
317 ptmA->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
318 ptmA->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
319 memcpy(&ptmA->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
320 }
321
322 /***********************************************************************
323 * CreateFontIndirectA (GDI32.@)
324 */
325 HFONT WINAPI CreateFontIndirectA( const LOGFONTA *plfA )
326 {
327 LOGFONTW lfW;
328
329 if (plfA) {
330 FONT_LogFontAToW( plfA, &lfW );
331 return CreateFontIndirectW( &lfW );
332 } else
333 return CreateFontIndirectW( NULL );
334
335 }
336
337 /***********************************************************************
338 * CreateFontIndirectW (GDI32.@)
339 */
340 HFONT WINAPI CreateFontIndirectW( const LOGFONTW *plf )
341 {
342 HFONT hFont = 0;
343
344 if (plf)
345 {
346 FONTOBJ* fontPtr;
347 if ((fontPtr = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC,
348 (HGDIOBJ *)&hFont, &font_funcs )))
349 {
350 static const WCHAR ItalicW[] = {' ','I','t','a','l','i','c','\0'};
351 static const WCHAR BoldW[] = {' ','B','o','l','d','\0'};
352 WCHAR *pFaceNameItalicSuffix, *pFaceNameBoldSuffix;
353 WCHAR* pFaceNameSuffix = NULL;
354
355 memcpy( &fontPtr->logfont, plf, sizeof(LOGFONTW) );
356
357 TRACE("(%ld %ld %ld %ld %x %d %x %d %d) %s %s %s %s => %p\n",
358 plf->lfHeight, plf->lfWidth,
359 plf->lfEscapement, plf->lfOrientation,
360 plf->lfPitchAndFamily,
361 plf->lfOutPrecision, plf->lfClipPrecision,
362 plf->lfQuality, plf->lfCharSet,
363 debugstr_w(plf->lfFaceName),
364 plf->lfWeight > 400 ? "Bold" : "",
365 plf->lfItalic ? "Italic" : "",
366 plf->lfUnderline ? "Underline" : "", hFont);
367
368 if (plf->lfEscapement != plf->lfOrientation) {
369 /* this should really depend on whether GM_ADVANCED is set */
370 fontPtr->logfont.lfOrientation = fontPtr->logfont.lfEscapement;
371 WARN("orientation angle %f set to "
372 "escapement angle %f for new font %p\n",
373 plf->lfOrientation/10., plf->lfEscapement/10., hFont);
374 }
375
376 pFaceNameItalicSuffix = strstrW(fontPtr->logfont.lfFaceName, ItalicW);
377 if (pFaceNameItalicSuffix) {
378 fontPtr->logfont.lfItalic = TRUE;
379 pFaceNameSuffix = pFaceNameItalicSuffix;
380 }
381
382 pFaceNameBoldSuffix = strstrW(fontPtr->logfont.lfFaceName, BoldW);
383 if (pFaceNameBoldSuffix) {
384 if (fontPtr->logfont.lfWeight < FW_BOLD) {
385 fontPtr->logfont.lfWeight = FW_BOLD;
386 }
387 if (!pFaceNameSuffix ||
388 (pFaceNameBoldSuffix < pFaceNameSuffix)) {
389 pFaceNameSuffix = pFaceNameBoldSuffix;
390 }
391 }
392
393 if (pFaceNameSuffix) *pFaceNameSuffix = 0;
394
395 GDI_ReleaseObj( hFont );
396 }
397 }
398 else WARN("(NULL) => NULL\n");
399
400 return hFont;
401 }
402
403 /*************************************************************************
404 * CreateFontA (GDI32.@)
405 */
406 HFONT WINAPI CreateFontA( INT height, INT width, INT esc,
407 INT orient, INT weight, DWORD italic,
408 DWORD underline, DWORD strikeout, DWORD charset,
409 DWORD outpres, DWORD clippres, DWORD quality,
410 DWORD pitch, LPCSTR name )
411 {
412 LOGFONTA logfont;
413
414 logfont.lfHeight = height;
415 logfont.lfWidth = width;
416 logfont.lfEscapement = esc;
417 logfont.lfOrientation = orient;
418 logfont.lfWeight = weight;
419 logfont.lfItalic = italic;
420 logfont.lfUnderline = underline;
421 logfont.lfStrikeOut = strikeout;
422 logfont.lfCharSet = charset;
423 logfont.lfOutPrecision = outpres;
424 logfont.lfClipPrecision = clippres;
425 logfont.lfQuality = quality;
426 logfont.lfPitchAndFamily = pitch;
427
428 if (name)
429 lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
430 else
431 logfont.lfFaceName[0] = '\0';
432
433 return CreateFontIndirectA( &logfont );
434 }
435
436 /*************************************************************************
437 * CreateFontW (GDI32.@)
438 */
439 HFONT WINAPI CreateFontW( INT height, INT width, INT esc,
440 INT orient, INT weight, DWORD italic,
441 DWORD underline, DWORD strikeout, DWORD charset,
442 DWORD outpres, DWORD clippres, DWORD quality,
443 DWORD pitch, LPCWSTR name )
444 {
445 LOGFONTW logfont;
446
447 logfont.lfHeight = height;
448 logfont.lfWidth = width;
449 logfont.lfEscapement = esc;
450 logfont.lfOrientation = orient;
451 logfont.lfWeight = weight;
452 logfont.lfItalic = italic;
453 logfont.lfUnderline = underline;
454 logfont.lfStrikeOut = strikeout;
455 logfont.lfCharSet = charset;
456 logfont.lfOutPrecision = outpres;
457 logfont.lfClipPrecision = clippres;
458 logfont.lfQuality = quality;
459 logfont.lfPitchAndFamily = pitch;
460
461 if (name)
462 lstrcpynW(logfont.lfFaceName, name,
463 sizeof(logfont.lfFaceName) / sizeof(WCHAR));
464 else
465 logfont.lfFaceName[0] = '\0';
466
467 return CreateFontIndirectW( &logfont );
468 }
469
470
471 /***********************************************************************
472 * FONT_SelectObject
473 *
474 * If the driver supports vector fonts we create a gdi font first and
475 * then call the driver to give it a chance to supply its own device
476 * font. If the driver wants to do this it returns TRUE and we can
477 * delete the gdi font, if the driver wants to use the gdi font it
478 * should return FALSE, to signal an error return GDI_ERROR. For
479 * drivers that don't support vector fonts they must supply their own
480 * font.
481 */
482 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, void *obj, HDC hdc )
483 {
484 HGDIOBJ ret = 0;
485 DC *dc = DC_GetDCPtr( hdc );
486
487 if (!dc) return 0;
488
489 if (dc->hFont != handle || dc->gdiFont == NULL)
490 {
491 if(GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_VA_ABLE)
492 dc->gdiFont = WineEngCreateFontInstance(dc, handle);
493 }
494
495 if (dc->funcs->pSelectFont) ret = dc->funcs->pSelectFont( dc->physDev, handle, dc->gdiFont );
496
497 if (ret && dc->gdiFont) dc->gdiFont = 0;
498
499 if (ret == HGDI_ERROR)
500 ret = 0; /* SelectObject returns 0 on error */
501 else
502 {
503 ret = dc->hFont;
504 dc->hFont = handle;
505 }
506 GDI_ReleaseObj( hdc );
507 return ret;
508 }
509
510
511 /***********************************************************************
512 * FONT_GetObject16
513 */
514 static INT FONT_GetObject16( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
515 {
516 FONTOBJ *font = obj;
517 LOGFONT16 lf16;
518
519 FONT_LogFontWTo16( &font->logfont, &lf16 );
520
521 if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
522 memcpy( buffer, &lf16, count );
523 return count;
524 }
525
526 /***********************************************************************
527 * FONT_GetObjectA
528 */
529 static INT FONT_GetObjectA( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
530 {
531 FONTOBJ *font = obj;
532 LOGFONTA lfA;
533
534 if(!buffer)
535 return sizeof(lfA);
536 FONT_LogFontWToA( &font->logfont, &lfA );
537
538 if (count > sizeof(lfA)) count = sizeof(lfA);
539 memcpy( buffer, &lfA, count );
540 return count;
541 }
542
543 /***********************************************************************
544 * FONT_GetObjectW
545 */
546 static INT FONT_GetObjectW( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
547 {
548 FONTOBJ *font = obj;
549 if(!buffer)
550 return sizeof(LOGFONTW);
551 if (count > sizeof(LOGFONTW)) count = sizeof(LOGFONTW);
552 memcpy( buffer, &font->logfont, count );
553 return count;
554 }
555
556
557 /***********************************************************************
558 * FONT_DeleteObject
559 */
560 static BOOL FONT_DeleteObject( HGDIOBJ handle, void *obj )
561 {
562 WineEngDestroyFontInstance( handle );
563 return GDI_FreeObject( handle, obj );
564 }
565
566
567 /***********************************************************************
568 * FONT_EnumInstance16
569 *
570 * Called by the device driver layer to pass font info
571 * down to the application.
572 *
573 * Note: plf is really an ENUMLOGFONTEXW, and ptm is a NEWTEXTMETRICEXW.
574 * We have to use other types because of the FONTENUMPROCW definition.
575 */
576 static INT CALLBACK FONT_EnumInstance16( const LOGFONTW *plf, const TEXTMETRICW *ptm,
577 DWORD fType, LPARAM lp )
578 {
579 fontEnum16 *pfe = (fontEnum16*)lp;
580 INT ret = 1;
581 DC *dc;
582
583 if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
584 pfe->lpLogFontParam->lfCharSet == plf->lfCharSet )
585 {
586 WORD args[7];
587 DWORD result;
588
589 FONT_EnumLogFontExWTo16((const ENUMLOGFONTEXW *)plf, pfe->lpLogFont);
590 FONT_NewTextMetricExWTo16((const NEWTEXTMETRICEXW *)ptm, pfe->lpTextMetric);
591 pfe->dwFlags |= ENUM_CALLED;
592 GDI_ReleaseObj( pfe->hdc ); /* release the GDI lock */
593
594 args[6] = SELECTOROF(pfe->segLogFont);
595 args[5] = OFFSETOF(pfe->segLogFont);
596 args[4] = SELECTOROF(pfe->segTextMetric);
597 args[3] = OFFSETOF(pfe->segTextMetric);
598 args[2] = fType;
599 args[1] = HIWORD(pfe->lpData);
600 args[0] = LOWORD(pfe->lpData);
601 WOWCallback16Ex( (DWORD)pfe->lpEnumFunc, WCB16_PASCAL, sizeof(args), args, &result );
602 ret = LOWORD(result);
603
604 /* get the lock again and make sure the DC is still valid */
605 dc = DC_GetDCPtr( pfe->hdc );
606 if (!dc || dc != pfe->dc || dc->physDev != pfe->physDev)
607 {
608 if (dc) GDI_ReleaseObj( pfe->hdc );
609 pfe->hdc = 0; /* make sure we don't try to release it later on */
610 ret = 0;
611 }
612 }
613 return ret;
614 }
615
616 /***********************************************************************
617 * FONT_EnumInstance
618 *
619 * Note: plf is really an ENUMLOGFONTEXW, and ptm is a NEWTEXTMETRICEXW.
620 * We have to use other types because of the FONTENUMPROCW definition.
621 */
622 static INT CALLBACK FONT_EnumInstance( const LOGFONTW *plf, const TEXTMETRICW *ptm,
623 DWORD fType, LPARAM lp )
624 {
625 fontEnum32 *pfe = (fontEnum32*)lp;
626 INT ret = 1;
627 DC *dc;
628
629 /* lfCharSet is at the same offset in both LOGFONTA and LOGFONTW */
630 if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
631 pfe->lpLogFontParam->lfCharSet == plf->lfCharSet )
632 {
633 /* convert font metrics */
634 ENUMLOGFONTEXA logfont;
635 NEWTEXTMETRICEXA tmA;
636
637 pfe->dwFlags |= ENUM_CALLED;
638 if (!(pfe->dwFlags & ENUM_UNICODE))
639 {
640 FONT_EnumLogFontExWToA( (const ENUMLOGFONTEXW *)plf, &logfont);
641 FONT_NewTextMetricExWToA( (const NEWTEXTMETRICEXW *)ptm, &tmA );
642 plf = (LOGFONTW *)&logfont.elfLogFont;
643 ptm = (TEXTMETRICW *)&tmA;
644 }
645 GDI_ReleaseObj( pfe->hdc ); /* release the GDI lock */
646
647 ret = pfe->lpEnumFunc( plf, ptm, fType, pfe->lpData );
648
649 /* get the lock again and make sure the DC is still valid */
650 dc = DC_GetDCPtr( pfe->hdc );
651 if (!dc || dc != pfe->dc || dc->physDev != pfe->physDev)
652 {
653 if (dc) GDI_ReleaseObj( pfe->hdc );
654 pfe->hdc = 0; /* make sure we don't try to release it later on */
655 ret = 0;
656 }
657 }
658 return ret;
659 }
660
661 /***********************************************************************
662 * EnumFontFamiliesEx (GDI.613)
663 */
664 INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
665 FONTENUMPROC16 efproc, LPARAM lParam,
666 DWORD dwFlags)
667 {
668 fontEnum16 fe16;
669 INT16 ret = 1, ret2;
670 DC* dc = DC_GetDCPtr( HDC_32(hDC) );
671 NEWTEXTMETRICEX16 tm16;
672 ENUMLOGFONTEX16 lf16;
673 LOGFONTW lfW;
674 BOOL enum_gdi_fonts;
675
676 if (!dc) return 0;
677 FONT_LogFont16ToW(plf, &lfW);
678
679 fe16.hdc = HDC_32(hDC);
680 fe16.dc = dc;
681 fe16.physDev = dc->physDev;
682 fe16.lpLogFontParam = plf;
683 fe16.lpEnumFunc = efproc;
684 fe16.lpData = lParam;
685 fe16.lpTextMetric = &tm16;
686 fe16.lpLogFont = &lf16;
687 fe16.segTextMetric = MapLS( &tm16 );
688 fe16.segLogFont = MapLS( &lf16 );
689 fe16.dwFlags = 0;
690
691 enum_gdi_fonts = GetDeviceCaps(fe16.hdc, TEXTCAPS) & TC_VA_ABLE;
692
693 if (!dc->funcs->pEnumDeviceFonts && !enum_gdi_fonts)
694 {
695 ret = 0;
696 goto done;
697 }
698
699 if (enum_gdi_fonts)
700 ret = WineEngEnumFonts( &lfW, FONT_EnumInstance16, (LPARAM)&fe16 );
701 fe16.dwFlags &= ~ENUM_CALLED;
702 if (ret && dc->funcs->pEnumDeviceFonts) {
703 ret2 = dc->funcs->pEnumDeviceFonts( dc->physDev, &lfW, FONT_EnumInstance16, (LPARAM)&fe16 );
704 if(fe16.dwFlags & ENUM_CALLED) /* update ret iff a font gets enumed */
705 ret = ret2;
706 }
707 done:
708 UnMapLS( fe16.segTextMetric );
709 UnMapLS( fe16.segLogFont );
710 if (fe16.hdc) GDI_ReleaseObj( fe16.hdc );
711 return ret;
712 }
713
714 /***********************************************************************
715 * FONT_EnumFontFamiliesEx
716 */
717 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf,
718 FONTENUMPROCW efproc,
719 LPARAM lParam, DWORD dwUnicode)
720 {
721 INT ret = 1, ret2;
722 DC *dc = DC_GetDCPtr( hDC );
723 fontEnum32 fe32;
724 BOOL enum_gdi_fonts;
725
726 if (!dc) return 0;
727
728 TRACE("lfFaceName = %s lfCharset = %d\n", debugstr_w(plf->lfFaceName),
729 plf->lfCharSet);
730 fe32.lpLogFontParam = plf;
731 fe32.lpEnumFunc = efproc;
732 fe32.lpData = lParam;
733 fe32.dwFlags = dwUnicode;
734 fe32.hdc = hDC;
735 fe32.dc = dc;
736 fe32.physDev = dc->physDev;
737
738 enum_gdi_fonts = GetDeviceCaps(hDC, TEXTCAPS) & TC_VA_ABLE;
739
740 if (!dc->funcs->pEnumDeviceFonts && !enum_gdi_fonts)
741 {
742 ret = 0;
743 goto done;
744 }
745
746 if (enum_gdi_fonts)
747 ret = WineEngEnumFonts( plf, FONT_EnumInstance, (LPARAM)&fe32 );
748 fe32.dwFlags &= ~ENUM_CALLED;
749 if (ret && dc->funcs->pEnumDeviceFonts) {
750 ret2 = dc->funcs->pEnumDeviceFonts( dc->physDev, plf, FONT_EnumInstance, (LPARAM)&fe32 );
751 if(fe32.dwFlags & ENUM_CALLED) /* update ret iff a font gets enumed */
752 ret = ret2;
753 }
754 done:
755 if (fe32.hdc) GDI_ReleaseObj( fe32.hdc );
756 return ret;
757 }
758
759 /***********************************************************************
760 * EnumFontFamiliesExW (GDI32.@)
761 */
762 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
763 FONTENUMPROCW efproc,
764 LPARAM lParam, DWORD dwFlags )
765 {
766 return FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, ENUM_UNICODE );
767 }
768
769 /***********************************************************************
770 * EnumFontFamiliesExA (GDI32.@)
771 */
772 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
773 FONTENUMPROCA efproc,
774 LPARAM lParam, DWORD dwFlags)
775 {
776 LOGFONTW lfW;
777 FONT_LogFontAToW( plf, &lfW );
778
779 return FONT_EnumFontFamiliesEx( hDC, &lfW, (FONTENUMPROCW)efproc, lParam, 0);
780 }
781
782 /***********************************************************************
783 * EnumFontFamilies (GDI.330)
784 */
785 INT16 WINAPI EnumFontFamilies16( HDC16 hDC, LPCSTR lpFamily,
786 FONTENUMPROC16 efproc, LPARAM lpData )
787 {
788 LOGFONT16 lf;
789
790 lf.lfCharSet = DEFAULT_CHARSET;
791 if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
792 else lf.lfFaceName[0] = '\0';
793
794 return EnumFontFamiliesEx16( hDC, &lf, efproc, lpData, 0 );
795 }
796
797 /***********************************************************************
798 * EnumFontFamiliesA (GDI32.@)
799 */
800 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
801 FONTENUMPROCA efproc, LPARAM lpData )
802 {
803 LOGFONTA lf;
804
805 lf.lfCharSet = DEFAULT_CHARSET;
806 if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
807 else lf.lfFaceName[0] = lf.lfFaceName[1] = '\0';
808
809 return EnumFontFamiliesExA( hDC, &lf, efproc, lpData, 0 );
810 }
811
812 /***********************************************************************
813 * EnumFontFamiliesW (GDI32.@)
814 */
815 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
816 FONTENUMPROCW efproc, LPARAM lpData )
817 {
818 LOGFONTW lf;
819
820 lf.lfCharSet = DEFAULT_CHARSET;
821 if( lpFamily ) lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
822 else lf.lfFaceName[0] = 0;
823
824 return EnumFontFamiliesExW( hDC, &lf, efproc, lpData, 0 );
825 }
826
827 /***********************************************************************
828 * EnumFonts (GDI.70)
829 */
830 INT16 WINAPI EnumFonts16( HDC16 hDC, LPCSTR lpName, FONTENUMPROC16 efproc,
831 LPARAM lpData )
832 {
833 return EnumFontFamilies16( hDC, lpName, efproc, lpData );
834 }
835
836 /***********************************************************************
837 * EnumFontsA (GDI32.@)
838 */
839 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
840 LPARAM lpData )
841 {
842 return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
843 }
844
845 /***********************************************************************
846 * EnumFontsW (GDI32.@)
847 */
848 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
849 LPARAM lpData )
850 {
851 return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
852 }
853
854
855 /***********************************************************************
856 * GetTextCharacterExtra (GDI32.@)
857 */
858 INT WINAPI GetTextCharacterExtra( HDC hdc )
859 {
860 INT ret;
861 DC *dc = DC_GetDCPtr( hdc );
862 if (!dc) return 0x80000000;
863 ret = dc->charExtra;
864 GDI_ReleaseObj( hdc );
865 return ret;
866 }
867
868
869 /***********************************************************************
870 * SetTextCharacterExtra (GDI32.@)
871 */
872 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
873 {
874 INT prev;
875 DC * dc = DC_GetDCPtr( hdc );
876 if (!dc) return 0x80000000;
877 if (dc->funcs->pSetTextCharacterExtra)
878 prev = dc->funcs->pSetTextCharacterExtra( dc->physDev, extra );
879 else
880 {
881 prev = dc->charExtra;
882 dc->charExtra = extra;
883 }
884 GDI_ReleaseObj( hdc );
885 return prev;
886 }
887
888
889 /***********************************************************************
890 * SetTextJustification (GDI32.@)
891 */
892 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
893 {
894 BOOL ret = TRUE;
895 DC * dc = DC_GetDCPtr( hdc );
896 if (!dc) return FALSE;
897 if (dc->funcs->pSetTextJustification)
898 ret = dc->funcs->pSetTextJustification( dc->physDev, extra, breaks );
899 else
900 {
901 extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
902 if (!extra) breaks = 0;
903 if (breaks)
904 {
905 dc->breakExtra = extra / breaks;
906 dc->breakRem = extra - (breaks * dc->breakExtra);
907 }
908 else
909 {
910 dc->breakExtra = 0;
911 dc->breakRem = 0;
912 }
913 }
914 GDI_ReleaseObj( hdc );
915 return ret;
916 }
917
918
919 /***********************************************************************
920 * GetTextFaceA (GDI32.@)
921 */
922 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
923 {
924 INT res = GetTextFaceW(hdc, 0, NULL);
925 LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
926 GetTextFaceW( hdc, res, nameW );
927
928 if (name)
929 {
930 if (count && !WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, count, NULL, NULL))
931 name[count-1] = 0;
932 res = strlen(name);
933 }
934 else
935 res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
936 HeapFree( GetProcessHeap(), 0, nameW );
937 return res;
938 }
939
940 /***********************************************************************
941 * GetTextFaceW (GDI32.@)
942 */
943 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
944 {
945 FONTOBJ *font;
946 INT ret = 0;
947
948 DC * dc = DC_GetDCPtr( hdc );
949 if (!dc) return 0;
950
951 if(dc->gdiFont)
952 ret = WineEngGetTextFace(dc->gdiFont, count, name);
953 else if ((font = (FONTOBJ *) GDI_GetObjPtr( dc->hFont, FONT_MAGIC )))
954 {
955 if (name)
956 {
957 lstrcpynW( name, font->logfont.lfFaceName, count );
958 ret = strlenW(name);
959 }
960 else ret = strlenW(font->logfont.lfFaceName) + 1;
961 GDI_ReleaseObj( dc->hFont );
962 }
963 GDI_ReleaseObj( hdc );
964 return ret;
965 }
966
967
968 /***********************************************************************
969 * GetTextExtentPoint32A (GDI32.@)
970 */
971 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
972 LPSIZE size )
973 {
974 BOOL ret = FALSE;
975 INT wlen;
976 LPWSTR p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
977
978 if (p) {
979 ret = GetTextExtentPoint32W( hdc, p, wlen, size );
980 HeapFree( GetProcessHeap(), 0, p );
981 }
982
983 TRACE("(%p %s %d %p): returning %ld x %ld\n",
984 hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
985 return ret;
986 }
987
988
989 /***********************************************************************
990 * GetTextExtentPoint32W [GDI32.@]
991 *
992 * Computes width/height for a string.
993 *
994 * Computes width and height of the specified string.
995 *
996 * RETURNS
997 * Success: TRUE
998 * Failure: FALSE
999 */
1000 BOOL WINAPI GetTextExtentPoint32W(
1001 HDC hdc, /* [in] Handle of device context */
1002 LPCWSTR str, /* [in] Address of text string */
1003 INT count, /* [in] Number of characters in string */
1004 LPSIZE size) /* [out] Address of structure for string size */
1005 {
1006 BOOL ret = FALSE;
1007 DC * dc = DC_GetDCPtr( hdc );
1008 if (!dc) return FALSE;
1009
1010 if(dc->gdiFont)
1011 ret = WineEngGetTextExtentPoint(dc->gdiFont, str, count, size);
1012 else if(dc->funcs->pGetTextExtentPoint)
1013 ret = dc->funcs->pGetTextExtentPoint( dc->physDev, str, count, size );
1014
1015 if (ret)
1016 {
1017 size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1018 size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1019 size->cx += count * dc->charExtra + dc->breakRem;
1020 }
1021
1022 GDI_ReleaseObj( hdc );
1023
1024 TRACE("(%p %s %d %p): returning %ld x %ld\n",
1025 hdc, debugstr_wn (str, count), count, size, size->cx, size->cy );
1026 return ret;
1027 }
1028
1029 /***********************************************************************
1030 * GetTextExtentPointI [GDI32.@]
1031 *
1032 * Computes width and height of the array of glyph indices.
1033 *
1034 * RETURNS
1035 * Success: TRUE
1036 * Failure: FALSE
1037 */
1038 BOOL WINAPI GetTextExtentPointI(
1039 HDC hdc, /* [in] Handle of device context */
1040 const WORD *indices, /* [in] Address of glyph index array */
1041 INT count, /* [in] Number of glyphs in array */
1042 LPSIZE size) /* [out] Address of structure for string size */
1043 {
1044 BOOL ret = FALSE;
1045 DC * dc = DC_GetDCPtr( hdc );
1046 if (!dc) return FALSE;
1047
1048 if(dc->gdiFont) {
1049 ret = WineEngGetTextExtentPointI(dc->gdiFont, indices, count, size);
1050 size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1051 size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1052 size->cx += count * dc->charExtra;
1053 }
1054 else if(dc->funcs->pGetTextExtentPoint) {
1055 FIXME("calling GetTextExtentPoint\n");
1056 ret = dc->funcs->pGetTextExtentPoint( dc->physDev, (LPCWSTR)indices, count, size );
1057 }
1058
1059 GDI_ReleaseObj( hdc );
1060
1061 TRACE("(%p %p %d %p): returning %ld x %ld\n",
1062 hdc, indices, count, size, size->cx, size->cy );
1063 return ret;
1064 }
1065
1066
1067 /***********************************************************************
1068 * GetTextExtentPointA (GDI32.@)
1069 */
1070 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1071 LPSIZE size )
1072 {
1073 TRACE("not bug compatible.\n");
1074 return GetTextExtentPoint32A( hdc, str, count, size );
1075 }
1076
1077 /***********************************************************************
1078 * GetTextExtentPointW (GDI32.@)
1079 */
1080 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1081 LPSIZE size )
1082 {
1083 TRACE("not bug compatible.\n");
1084 return GetTextExtentPoint32W( hdc, str, count, size );
1085 }
1086
1087
1088 /***********************************************************************
1089 * GetTextExtentExPointA (GDI32.@)
1090 */
1091 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1092 INT maxExt, LPINT lpnFit,
1093 LPINT alpDx, LPSIZE size )
1094 {
1095 BOOL ret;
1096 INT wlen;
1097 LPWSTR p = FONT_mbtowc( hdc, str, count, &wlen, NULL);
1098 ret = GetTextExtentExPointW( hdc, p, wlen, maxExt, lpnFit, alpDx, size);
1099 if (lpnFit) *lpnFit = WideCharToMultiByte(CP_ACP,0,p,*lpnFit,NULL,0,NULL,NULL);
1100 HeapFree( GetProcessHeap(), 0, p );
1101 return ret;
1102 }
1103
1104
1105 /***********************************************************************
1106 * GetTextExtentExPointW (GDI32.@)
1107 *
1108 * Return the size of the string as it would be if it was output properly by
1109 * e.g. TextOut.
1110 *
1111 * This should include
1112 * - Intercharacter spacing
1113 * - justification spacing (not yet done)
1114 * - kerning? see below
1115 *
1116 * Kerning. Since kerning would be carried out by the rendering code it should
1117 * be done by the driver. However they don't support it yet. Also I am not
1118 * yet persuaded that (certainly under Win95) any kerning is actually done.
1119 *
1120 * str: According to MSDN this should be null-terminated. That is not true; a
1121 * null will not terminate it early.
1122 * size: Certainly under Win95 this appears buggy or weird if *lpnFit is less
1123 * than count. I have seen it be either the size of the full string or
1124 * 1 less than the size of the full string. I have not seen it bear any
1125 * resemblance to the portion that would fit.
1126 * lpnFit: What exactly is fitting? Stupidly, in my opinion, it includes the
1127 * trailing intercharacter spacing and any trailing justification.
1128 *
1129 * FIXME
1130 * Currently we do this by measuring each character etc. We should do it by
1131 * passing the request to the driver, perhaps by extending the
1132 * pGetTextExtentPoint function to take the alpDx argument. That would avoid
1133 * thinking about kerning issues and rounding issues in the justification.
1134 */
1135
1136 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
1137 INT maxExt, LPINT lpnFit,
1138 LPINT alpDx, LPSIZE size )
1139 {
1140 int index, nFit, extent;
1141 SIZE tSize;
1142 BOOL ret = FALSE;
1143
1144 TRACE("(%p, %s, %d)\n",hdc,debugstr_wn(str,count),maxExt);
1145
1146 size->cx = size->cy = nFit = extent = 0;
1147 for(index = 0; index < count; index++)
1148 {
1149 if(!GetTextExtentPoint32W( hdc, str, 1, &tSize )) goto done;
1150 /* GetTextExtentPoint includes intercharacter spacing. */
1151 /* FIXME - justification needs doing yet. Remember that the base
1152 * data will not be in logical coordinates.
1153 */
1154 extent += tSize.cx;
1155 if( !lpnFit || extent <= maxExt )
1156 /* It is allowed to be equal. */
1157 {
1158 nFit++;
1159 if( alpDx ) alpDx[index] = extent;
1160 }
1161 if( tSize.cy > size->cy ) size->cy = tSize.cy;
1162 str++;
1163 }
1164 size->cx = extent;
1165 if(lpnFit) *lpnFit = nFit;
1166 ret = TRUE;
1167
1168 TRACE("returning %d %ld x %ld\n",nFit,size->cx,size->cy);
1169
1170 done:
1171 return ret;
1172 }
1173
1174 /***********************************************************************
1175 * GetTextMetricsA (GDI32.@)
1176 */
1177 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1178 {
1179 TEXTMETRICW tm32;
1180
1181 if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1182 FONT_TextMetricWToA( &tm32, metrics );
1183 return TRUE;
1184 }
1185
1186 /***********************************************************************
1187 * GetTextMetricsW (GDI32.@)
1188 */
1189 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1190 {
1191 BOOL ret = FALSE;
1192 DC * dc = DC_GetDCPtr( hdc );
1193 if (!dc) return FALSE;
1194
1195 if (dc->gdiFont)
1196 ret = WineEngGetTextMetrics(dc->gdiFont, metrics);
1197 else if (dc->funcs->pGetTextMetrics)
1198 ret = dc->funcs->pGetTextMetrics( dc->physDev, metrics );
1199
1200 if (ret)
1201 {
1202 /* device layer returns values in device units
1203 * therefore we have to convert them to logical */
1204
1205 #define WDPTOLP(x) ((x<0)? \
1206 (-abs(INTERNAL_XDSTOWS(dc, (x)))): \
1207 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1208 #define HDPTOLP(y) ((y<0)? \
1209 (-abs(INTERNAL_YDSTOWS(dc, (y)))): \
1210 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1211
1212 metrics->tmHeight = HDPTOLP(metrics->tmHeight);
1213 metrics->tmAscent = HDPTOLP(metrics->tmAscent);
1214 metrics->tmDescent = HDPTOLP(metrics->tmDescent);
1215 metrics->tmInternalLeading = HDPTOLP(metrics->tmInternalLeading);
1216 metrics->tmExternalLeading = HDPTOLP(metrics->tmExternalLeading);
1217 metrics->tmAveCharWidth = WDPTOLP(metrics->tmAveCharWidth);
1218 metrics->tmMaxCharWidth = WDPTOLP(metrics->tmMaxCharWidth);
1219 metrics->tmOverhang = WDPTOLP(metrics->tmOverhang);
1220 ret = TRUE;
1221 #undef WDPTOLP
1222 #undef HDPTOLP
1223 TRACE("text metrics:\n"
1224 " Weight = %03li\t FirstChar = %i\t AveCharWidth = %li\n"
1225 " Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %li\n"
1226 " UnderLined = %01i\t DefaultChar = %i\t Overhang = %li\n"
1227 " StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1228 " PitchAndFamily = %02x\n"
1229 " --------------------\n"
1230 " InternalLeading = %li\n"
1231 " Ascent = %li\n"
1232 " Descent = %li\n"
1233 " Height = %li\n",
1234 metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1235 metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1236 metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1237 metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1238 metrics->tmPitchAndFamily,
1239 metrics->tmInternalLeading,
1240 metrics->tmAscent,
1241 metrics->tmDescent,
1242 metrics->tmHeight );
1243 }
1244 GDI_ReleaseObj( hdc );
1245 return ret;
1246 }
1247
1248
1249 /***********************************************************************
1250 * GetOutlineTextMetrics [GDI.308] Gets metrics for TrueType fonts.
1251 *
1252 * NOTES
1253 * lpOTM should be LPOUTLINETEXTMETRIC
1254 *
1255 * RETURNS
1256 * Success: Non-zero or size of required buffer
1257 * Failure: 0
1258 */
1259 UINT16 WINAPI GetOutlineTextMetrics16(
1260 HDC16 hdc, /* [in] Handle of device context */
1261 UINT16 cbData, /* [in] Size of metric data array */
1262 LPOUTLINETEXTMETRIC16 lpOTM) /* [out] Address of metric data array */
1263 {
1264 FIXME("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
1265 return 0;
1266 }
1267
1268
1269 /***********************************************************************
1270 * GetOutlineTextMetricsA (GDI32.@)
1271 * Gets metrics for TrueType fonts.
1272 *
1273 * NOTES
1274 * If the supplied buffer isn't big enough Windows partially fills it up to
1275 * its given length and returns that length.
1276 *
1277 * RETURNS
1278 * Success: Non-zero or size of required buffer
1279 * Failure: 0
1280 */
1281 UINT WINAPI GetOutlineTextMetricsA(
1282 HDC hdc, /* [in] Handle of device context */
1283 UINT cbData, /* [in] Size of metric data array */
1284 LPOUTLINETEXTMETRICA lpOTM) /* [out] Address of metric data array */
1285 {
1286 char buf[512], *ptr;
1287 UINT ret, needed;
1288 OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
1289 OUTLINETEXTMETRICA *output = lpOTM;
1290 INT left, len;
1291
1292 if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1293 return 0;
1294 if(ret > sizeof(buf))
1295 lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1296 GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1297
1298 needed = sizeof(OUTLINETEXTMETRICA);
1299 if(lpOTMW->otmpFamilyName)
1300 needed += WideCharToMultiByte(CP_ACP, 0,
1301 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1302 NULL, 0, NULL, NULL);
1303 if(lpOTMW->otmpFaceName)
1304 needed += WideCharToMultiByte(CP_ACP, 0,
1305 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1306 NULL, 0, NULL, NULL);
1307 if(lpOTMW->otmpStyleName)
1308 needed += WideCharToMultiByte(CP_ACP, 0,
1309 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1310 NULL, 0, NULL, NULL);
1311 if(lpOTMW->otmpFullName)
1312 needed += WideCharToMultiByte(CP_ACP, 0,
1313 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1314 NULL, 0, NULL, NULL);
1315
1316 if(!lpOTM) {
1317 ret = needed;
1318 goto end;
1319 }
1320
1321 TRACE("needed = %d\n", needed);
1322 if(needed > cbData)
1323 /* Since the supplied buffer isn't big enough, we'll alloc one
1324 that is and memcpy the first cbData bytes into the lpOTM at
1325 the end. */
1326 output = HeapAlloc(GetProcessHeap(), 0, needed);
1327
1328 ret = output->otmSize = min(needed, cbData);
1329 FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
1330 output->otmFiller = 0;
1331 output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1332 output->otmfsSelection = lpOTMW->otmfsSelection;
1333 output->otmfsType = lpOTMW->otmfsType;
1334 output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1335 output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1336 output->otmItalicAngle = lpOTMW->otmItalicAngle;
1337 output->otmEMSquare = lpOTMW->otmEMSquare;
1338 output->otmAscent = lpOTMW->otmAscent;
1339 output->otmDescent = lpOTMW->otmDescent;
1340 output->otmLineGap = lpOTMW->otmLineGap;
1341 output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1342 output->otmsXHeight = lpOTMW->otmsXHeight;
1343 output->otmrcFontBox = lpOTMW->otmrcFontBox;
1344 output->otmMacAscent = lpOTMW->otmMacAscent;
1345 output->otmMacDescent = lpOTMW->otmMacDescent;
1346 output->otmMacLineGap = lpOTMW->otmMacLineGap;
1347 output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1348 output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1349 output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
1350 output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
1351 output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
1352 output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1353 output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
1354 output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1355 output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
1356
1357
1358 ptr = (char*)(output + 1);
1359 left = needed - sizeof(*output);
1360
1361 if(lpOTMW->otmpFamilyName) {
1362 output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1363 len = WideCharToMultiByte(CP_ACP, 0,
1364 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1365 ptr, left, NULL, NULL);
1366 left -= len;
1367 ptr += len;
1368 } else
1369 output->otmpFamilyName = 0;
1370
1371 if(lpOTMW->otmpFaceName) {
1372 output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1373 len = WideCharToMultiByte(CP_ACP, 0,
1374 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1375 ptr, left, NULL, NULL);
1376 left -= len;
1377 ptr += len;
1378 } else
1379 output->otmpFaceName = 0;
1380
1381 if(lpOTMW->otmpStyleName) {
1382 output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1383 len = WideCharToMultiByte(CP_ACP, 0,
1384 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1385 ptr, left, NULL, NULL);
1386 left -= len;
1387 ptr += len;
1388 } else
1389 output->otmpStyleName = 0;
1390
1391 if(lpOTMW->otmpFullName) {
1392 output->otmpFullName = (LPSTR)(ptr - (char*)output);
1393 len = WideCharToMultiByte(CP_ACP, 0,
1394 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1395 ptr, left, NULL, NULL);
1396 left -= len;
1397 } else
1398 output->otmpFullName = 0;
1399
1400 assert(left == 0);
1401
1402 if(output != lpOTM) {
1403 memcpy(lpOTM, output, cbData);
1404 HeapFree(GetProcessHeap(), 0, output);
1405 }
1406
1407 end:
1408 if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1409 HeapFree(GetProcessHeap(), 0, lpOTMW);
1410
1411 return ret;
1412 }
1413
1414
1415 /***********************************************************************
1416 * GetOutlineTextMetricsW [GDI32.@]
1417 */
1418 UINT WINAPI GetOutlineTextMetricsW(
1419 HDC hdc, /* [in] Handle of device context */
1420 UINT cbData, /* [in] Size of metric data array */
1421 LPOUTLINETEXTMETRICW lpOTM) /* [out] Address of metric data array */
1422 {
1423 DC *dc = DC_GetDCPtr( hdc );
1424 OUTLINETEXTMETRICW *output = lpOTM;
1425 UINT ret;
1426
1427 TRACE("(%p,%d,%p)\n", hdc, cbData, lpOTM);
1428 if(!dc) return 0;
1429
1430 if(dc->gdiFont) {
1431 ret = WineEngGetOutlineTextMetrics(dc->gdiFont, cbData, output);
1432 if(lpOTM && ret) {
1433 if(ret > cbData) {
1434 output = HeapAlloc(GetProcessHeap(), 0, ret);
1435 WineEngGetOutlineTextMetrics(dc->gdiFont, ret, output);
1436 }
1437
1438 #define WDPTOLP(x) ((x<0)? \
1439 (-abs(INTERNAL_XDSTOWS(dc, (x)))): \
1440 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1441 #define HDPTOLP(y) ((y<0)? \
1442 (-abs(INTERNAL_YDSTOWS(dc, (y)))): \
1443 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1444
1445 output->otmTextMetrics.tmHeight = HDPTOLP(output->otmTextMetrics.tmHeight);
1446 output->otmTextMetrics.tmAscent = HDPTOLP(output->otmTextMetrics.tmAscent);
1447 output->otmTextMetrics.tmDescent = HDPTOLP(output->otmTextMetrics.tmDescent);
1448 output->otmTextMetrics.tmInternalLeading = HDPTOLP(output->otmTextMetrics.tmInternalLeading);
1449 output->otmTextMetrics.tmExternalLeading = HDPTOLP(output->otmTextMetrics.tmExternalLeading);
1450 output->otmTextMetrics.tmAveCharWidth = WDPTOLP(output->otmTextMetrics.tmAveCharWidth);
1451 output->otmTextMetrics.tmMaxCharWidth = WDPTOLP(output->otmTextMetrics.tmMaxCharWidth);
1452 output->otmTextMetrics.tmOverhang = WDPTOLP(output->otmTextMetrics.tmOverhang);
1453 output->otmAscent = HDPTOLP(output->otmAscent);
1454 output->otmDescent = HDPTOLP(output->otmDescent);
1455 output->otmLineGap = HDPTOLP(output->otmLineGap);
1456 output->otmsCapEmHeight = HDPTOLP(output->otmsCapEmHeight);
1457 output->otmsXHeight = HDPTOLP(output->otmsXHeight);
1458 output->otmrcFontBox.top = HDPTOLP(output->otmrcFontBox.top);
1459 output->otmrcFontBox.bottom = HDPTOLP(output->otmrcFontBox.bottom);
1460 output->otmrcFontBox.left = WDPTOLP(output->otmrcFontBox.left);
1461 output->otmrcFontBox.right = WDPTOLP(output->otmrcFontBox.right);
1462 output->otmMacAscent = HDPTOLP(output->otmMacAscent);
1463 output->otmMacDescent = HDPTOLP(output->otmMacDescent);
1464 output->otmMacLineGap = HDPTOLP(output->otmMacLineGap);
1465 output->otmptSubscriptSize.x = WDPTOLP(output->otmptSubscriptSize.x);
1466 output->otmptSubscriptSize.y = HDPTOLP(output->otmptSubscriptSize.y);
1467 output->otmptSubscriptOffset.x = WDPTOLP(output->otmptSubscriptOffset.x);
1468 output->otmptSubscriptOffset.y = HDPTOLP(output->otmptSubscriptOffset.y);
1469 output->otmptSuperscriptSize.x = WDPTOLP(output->otmptSuperscriptSize.x);
1470 output->otmptSuperscriptSize.y = HDPTOLP(output->otmptSuperscriptSize.y);
1471 output->otmptSuperscriptOffset.x = WDPTOLP(output->otmptSuperscriptOffset.x);
1472 output->otmptSuperscriptOffset.y = HDPTOLP(output->otmptSuperscriptOffset.y);
1473 output->otmsStrikeoutSize = HDPTOLP(output->otmsStrikeoutSize);
1474 output->otmsStrikeoutPosition = HDPTOLP(output->otmsStrikeoutPosition);
1475 output->otmsUnderscoreSize = HDPTOLP(output->otmsUnderscoreSize);
1476 output->otmsUnderscorePosition = HDPTOLP(output->otmsUnderscorePosition);
1477 #undef WDPTOLP
1478 #undef HDPTOLP
1479 if(output != lpOTM) {
1480 memcpy(lpOTM, output, cbData);
1481 HeapFree(GetProcessHeap(), 0, output);
1482 ret = cbData;
1483 }
1484 }
1485 }
1486
1487 else { /* This stuff was in GetOutlineTextMetricsA, I've moved it here
1488 but really this should just be a return 0. */
1489
1490 ret = sizeof(*lpOTM);
1491 if (lpOTM) {
1492 if(cbData < ret)
1493 ret = 0;
1494 else {
1495 memset(lpOTM, 0, ret);
1496 lpOTM->otmSize = sizeof(*lpOTM);
1497 GetTextMetricsW(hdc, &lpOTM->otmTextMetrics);
1498 /*
1499 Further fill of the structure not implemented,
1500 Needs real values for the structure members
1501 */
1502 }
1503 }
1504 }
1505 GDI_ReleaseObj(hdc);
1506 return ret;
1507 }
1508
1509
1510 /***********************************************************************
1511 * GetCharWidthW (GDI32.@)
1512 * GetCharWidth32W (GDI32.@)
1513 */
1514 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1515 LPINT buffer )
1516 {
1517 UINT i;
1518 BOOL ret = FALSE;
1519 DC * dc = DC_GetDCPtr( hdc );
1520 if (!dc) return FALSE;
1521
1522 if (dc->gdiFont)
1523 ret = WineEngGetCharWidth( dc->gdiFont, firstChar, lastChar, buffer );
1524 else if (dc->funcs->pGetCharWidth)
1525 ret = dc->funcs->pGetCharWidth( dc->physDev, firstChar, lastChar, buffer);
1526
1527 if (ret)
1528 {
1529 /* convert device units to logical */
1530 for( i = firstChar; i <= lastChar; i++, buffer++ )
1531 *buffer = INTERNAL_XDSTOWS(dc, *buffer);
1532 ret = TRUE;
1533 }
1534 GDI_ReleaseObj( hdc );
1535 return ret;
1536 }
1537
1538
1539 /***********************************************************************
1540 * GetCharWidthA (GDI32.@)
1541 * GetCharWidth32A (GDI32.@)
1542 */
1543 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1544 LPINT buffer )
1545 {
1546 INT i, wlen, count = (INT)(lastChar - firstChar + 1);
1547 LPSTR str;
1548 LPWSTR wstr;
1549 BOOL ret = TRUE;
1550
1551 if(count <= 0) return FALSE;
1552
1553 str = HeapAlloc(GetProcessHeap(), 0, count);
1554 for(i = 0; i < count; i++)
1555 str[i] = (BYTE)(firstChar + i);
1556
1557 wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1558
1559 for(i = 0; i < wlen; i++)
1560 {
1561 if(!GetCharWidth32W(hdc, wstr[i], wstr[i], buffer))
1562 {
1563 ret = FALSE;
1564 break;
1565 }
1566 buffer++;
1567 }
1568
1569 HeapFree(GetProcessHeap(), 0, str);
1570 HeapFree(GetProcessHeap(), 0, wstr);
1571
1572 return ret;
1573 }
1574
1575
1576 /* FIXME: all following APIs ******************************************/
1577
1578
1579 /***********************************************************************
1580 * SetMapperFlags (GDI32.@)
1581 */
1582 DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
1583 {
1584 DC *dc = DC_GetDCPtr( hDC );
1585 DWORD ret = 0;
1586 if(!dc) return 0;
1587 if(dc->funcs->pSetMapperFlags)
1588 ret = dc->funcs->pSetMapperFlags( dc->physDev, dwFlag );
1589 else
1590 FIXME("(%p, 0x%08lx): stub - harmless\n", hDC, dwFlag);
1591 GDI_ReleaseObj( hDC );
1592 return ret;
1593 }
1594
1595 /***********************************************************************
1596 * GetAspectRatioFilterEx (GDI.486)
1597 */
1598 BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
1599 {
1600 FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1601 return FALSE;
1602 }
1603
1604 /***********************************************************************
1605 * GetAspectRatioFilterEx (GDI32.@)
1606 */
1607 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
1608 {
1609 FIXME("(%p, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1610 return FALSE;
1611 }
1612
1613
1614 /***********************************************************************
1615 * GetCharABCWidthsA (GDI32.@)
1616 */
1617 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
1618 LPABC abc )
1619 {
1620 INT i, wlen, count = (INT)(lastChar - firstChar + 1);
1621 LPSTR str;
1622 LPWSTR wstr;
1623 BOOL ret = TRUE;
1624
1625 if(count <= 0) return FALSE;
1626
1627 str = HeapAlloc(GetProcessHeap(), 0, count);
1628 for(i = 0; i < count; i++)
1629 str[i] = (BYTE)(firstChar + i);
1630
1631 wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1632
1633 for(i = 0; i < wlen; i++)
1634 {
1635 if(!GetCharABCWidthsW(hdc, wstr[i], wstr[i], abc))
1636 {
1637 ret = FALSE;
1638 break;
1639 }
1640 abc++;
1641 }
1642
1643 HeapFree(GetProcessHeap(), 0, str);
1644 HeapFree(GetProcessHeap(), 0, wstr);
1645
1646 return ret;
1647 }
1648
1649
1650 /******************************************************************************
1651 * GetCharABCWidthsW [GDI32.@]
1652 *
1653 * Retrieves widths of characters in range.
1654 *
1655 * PARAMS
1656 * hdc [I] Handle of device context
1657 * firstChar [I] First character in range to query
1658 * lastChar [I] Last character in range to query
1659 * abc [O] Address of character-width structure
1660 *
1661 * NOTES
1662 * Only works with TrueType fonts
1663 *
1664 * RETURNS
1665 * Success: TRUE
1666 * Failure: FALSE
1667 */
1668 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
1669 LPABC abc )
1670 {
1671 DC *dc = DC_GetDCPtr(hdc);
1672 int i;
1673 BOOL ret = FALSE;
1674
1675 if(dc->gdiFont)
1676 ret = WineEngGetCharABCWidths( dc->gdiFont, firstChar, lastChar, abc );
1677 else
1678 FIXME(": stub\n");
1679
1680 if (ret)
1681 {
1682 /* convert device units to logical */
1683 for( i = firstChar; i <= lastChar; i++, abc++ ) {
1684 abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
1685 abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
1686 abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
1687 }
1688 ret = TRUE;
1689 }
1690
1691 GDI_ReleaseObj(hdc);
1692 return ret;
1693 }
1694
1695
1696 /***********************************************************************
1697 * GetGlyphOutline (GDI.309)
1698 */
1699 DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
1700 LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
1701 LPVOID lpBuffer, const MAT2 *lpmat2 )
1702 {
1703 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1704 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1705 return ~0UL; /* failure */
1706 }
1707
1708
1709 /***********************************************************************
1710 * GetGlyphOutlineA (GDI32.@)
1711 */
1712 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
1713 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1714 LPVOID lpBuffer, const MAT2 *lpmat2 )
1715 {
1716 LPWSTR p = NULL;
1717 DWORD ret;
1718 UINT c;
1719
1720 if(!(fuFormat & GGO_GLYPH_INDEX)) {
1721 p = FONT_mbtowc(hdc, (char*)&uChar, 1, NULL, NULL);
1722 c = p[0];
1723 } else
1724 c = uChar;
1725 ret = GetGlyphOutlineW(hdc, c, fuFormat, lpgm, cbBuffer, lpBuffer,
1726 lpmat2);
1727 if(p)
1728 HeapFree(GetProcessHeap(), 0, p);
1729 return ret;
1730 }
1731
1732 /***********************************************************************
1733 * GetGlyphOutlineW (GDI32.@)
1734 */
1735 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
1736 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1737 LPVOID lpBuffer, const MAT2 *lpmat2 )
1738 {
1739 DC *dc = DC_GetDCPtr(hdc);
1740 DWORD ret;
1741
1742 TRACE("(%p, %04x, %04x, %p, %ld, %p, %p)\n",
1743 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1744
1745 if(!dc) return GDI_ERROR;
1746
1747 if(dc->gdiFont)
1748 ret = WineEngGetGlyphOutline(dc->gdiFont, uChar, fuFormat, lpgm,
1749 cbBuffer, lpBuffer, lpmat2);
1750 else
1751 ret = GDI_ERROR;
1752
1753 GDI_ReleaseObj(hdc);
1754 return ret;
1755 }
1756
1757
1758 /***********************************************************************
1759 * CreateScalableFontResourceA (GDI32.@)
1760 */
1761 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
1762 LPCSTR lpszResourceFile,
1763 LPCSTR lpszFontFile,
1764 LPCSTR lpszCurrentPath )
1765 {
1766 HANDLE f;
1767
1768 /* fHidden=1 - only visible for the calling app, read-only, not
1769 * enumbered with EnumFonts/EnumFontFamilies
1770 * lpszCurrentPath can be NULL
1771 */
1772 FIXME("(%ld,%s,%s,%s): stub\n",
1773 fHidden, debugstr_a(lpszResourceFile), debugstr_a(lpszFontFile),
1774 debugstr_a(lpszCurrentPath) );
1775
1776 /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
1777 if ((f = CreateFileA(lpszResourceFile, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE) {
1778 CloseHandle(f);
1779 SetLastError(ERROR_FILE_EXISTS);
1780 return FALSE;
1781 }
1782 return FALSE; /* create failed */
1783 }
1784
1785 /***********************************************************************
1786 * CreateScalableFontResourceW (GDI32.@)
1787 */
1788 BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
1789 LPCWSTR lpszResourceFile,
1790 LPCWSTR lpszFontFile,
1791 LPCWSTR lpszCurrentPath )
1792 {
1793 FIXME("(%ld,%p,%p,%p): stub\n",
1794 fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1795 return FALSE; /* create failed */
1796 }
1797
1798
1799 /*************************************************************************
1800 * GetRasterizerCaps (GDI32.@)
1801 */
1802 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
1803 {
1804 lprs->nSize = sizeof(RASTERIZER_STATUS);
1805 lprs->wFlags = TT_AVAILABLE|TT_ENABLED;
1806 lprs->nLanguageID = 0;
1807 return TRUE;
1808 }
1809
1810
1811 /*************************************************************************
1812 * GetKerningPairsA (GDI32.@)
1813 */
1814 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
1815 LPKERNINGPAIR lpKerningPairs )
1816 {
1817 return GetKerningPairsW( hDC, cPairs, lpKerningPairs );
1818 }
1819
1820
1821 /*************************************************************************
1822 * GetKerningPairsW (GDI32.@)
1823 */
1824 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
1825 LPKERNINGPAIR lpKerningPairs )
1826 {
1827 int i;
1828 FIXME("(%p,%ld,%p): almost empty stub!\n", hDC, cPairs, lpKerningPairs);
1829 for (i = 0; i < cPairs; i++)
1830 lpKerningPairs[i].iKernAmount = 0;
1831 return 0;
1832 }
1833
1834 /*************************************************************************
1835 * TranslateCharsetInfo [GDI32.@]
1836 *
1837 * Fills a CHARSETINFO structure for a character set, code page, or
1838 * font. This allows making the correspondance between different labelings
1839 * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
1840 * of the same encoding.
1841 *
1842 * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
1843 * only one codepage should be set in *lpSrc.
1844 *
1845 * RETURNS
1846 * TRUE on success, FALSE on failure.
1847 *
1848 */
1849 BOOL WINAPI TranslateCharsetInfo(
1850 LPDWORD lpSrc, /* [in]
1851 if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
1852 if flags == TCI_SRCCHARSET: a character set value
1853 if flags == TCI_SRCCODEPAGE: a code page value
1854 */
1855 LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
1856 DWORD flags /* [in] determines interpretation of lpSrc */)
1857 {
1858 int index = 0;
1859 switch (flags) {
1860 case TCI_SRCFONTSIG:
1861 while (!(*lpSrc>>index & 0x0001) && index<MAXTCIINDEX) index++;
1862 break;
1863 case TCI_SRCCODEPAGE:
1864 while ((UINT) (lpSrc) != FONT_tci[index].ciACP && index < MAXTCIINDEX) index++;
1865 break;
1866 case TCI_SRCCHARSET:
1867 while ((UINT) (lpSrc) != FONT_tci[index].ciCharset && index < MAXTCIINDEX) index++;
1868 break;
1869 default:
1870 return FALSE;
1871 }
1872 if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
1873 memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
1874 return TRUE;
1875 }
1876
1877 /*************************************************************************
1878 * GetFontLanguageInfo (GDI32.@)
1879 */
1880 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
1881 {
1882 FONTSIGNATURE fontsig;
1883 static const DWORD GCP_DBCS_MASK=0x003F0000,
1884 GCP_DIACRITIC_MASK=0x00000000,
1885 FLI_GLYPHS_MASK=0x00000000,
1886 GCP_GLYPHSHAPE_MASK=0x00000040,
1887 GCP_KASHIDA_MASK=0x00000000,
1888 GCP_LIGATE_MASK=0x00000000,
1889 GCP_USEKERNING_MASK=0x00000000,
1890 GCP_REORDER_MASK=0x00000060;
1891
1892 DWORD result=0;
1893
1894 GetTextCharsetInfo( hdc, &fontsig, 0 );
1895 /* We detect each flag we return using a bitmask on the Codepage Bitfields */
1896
1897 if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
1898 result|=GCP_DBCS;
1899
1900 if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
1901 result|=GCP_DIACRITIC;
1902
1903 if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
1904 result|=FLI_GLYPHS;
1905
1906 if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
1907 result|=GCP_GLYPHSHAPE;
1908
1909 if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
1910 result|=GCP_KASHIDA;
1911
1912 if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
1913 result|=GCP_LIGATE;
1914
1915 if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
1916 result|=GCP_USEKERNING;
1917
1918 /* this might need a test for a HEBREW- or ARABIC_CHARSET as well */
1919 if( GetTextAlign( hdc) & TA_RTLREADING )
1920 if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
1921 result|=GCP_REORDER;
1922
1923 return result;
1924 }
1925
1926
1927 /*************************************************************************
1928 * GetFontData [GDI32.@]
1929 *
1930 * Retrieve data for TrueType font.
1931 *
1932 * RETURNS
1933 *
1934 * success: Number of bytes returned
1935 * failure: GDI_ERROR
1936 *
1937 * NOTES
1938 *
1939 * Calls SetLastError()
1940 *
1941 */
1942 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
1943 LPVOID buffer, DWORD length)
1944 {
1945 DC *dc = DC_GetDCPtr(hdc);
1946 DWORD ret = GDI_ERROR;
1947
1948 if(!dc) return GDI_ERROR;
1949
1950 if(dc->gdiFont)
1951 ret = WineEngGetFontData(dc->gdiFont, table, offset, buffer, length);
1952
1953 GDI_ReleaseObj(hdc);
1954 return ret;
1955 }
1956
1957 /*************************************************************************
1958 * GetGlyphIndicesA [GDI32.@]
1959 */
1960 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
1961 LPWORD pgi, DWORD flags)
1962 {
1963 DWORD ret;
1964 WCHAR *lpstrW;
1965 INT countW;
1966
1967 TRACE("(%p, %s, %d, %p, 0x%lx)\n",
1968 hdc, debugstr_an(lpstr, count), count, pgi, flags);
1969
1970 lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
1971 ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
1972 HeapFree(GetProcessHeap(), 0, lpstrW);
1973
1974 return ret;
1975 }
1976
1977 /*************************************************************************
1978 * GetGlyphIndicesW [GDI32.@]
1979 */
1980 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
1981 LPWORD pgi, DWORD flags)
1982 {
1983 DC *dc = DC_GetDCPtr(hdc);
1984 DWORD ret = GDI_ERROR;
1985
1986 TRACE("(%p, %s, %d, %p, 0x%lx)\n",
1987 hdc, debugstr_wn(lpstr, count), count, pgi, flags);
1988
1989 if(!dc) return GDI_ERROR;
1990
1991 if(dc->gdiFont)
1992 ret = WineEngGetGlyphIndices(dc->gdiFont, lpstr, count, pgi, flags);
1993
1994 GDI_ReleaseObj(hdc);
1995 return ret;
1996 }
1997
1998 /*************************************************************************
1999 * GetCharacterPlacementA [GDI32.@]
2000 *
2001 * NOTES:
2002 * the web browser control of ie4 calls this with dwFlags=0
2003 */
2004 DWORD WINAPI
2005 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
2006 INT nMaxExtent, GCP_RESULTSA *lpResults,
2007 DWORD dwFlags)
2008 {
2009 WCHAR *lpStringW;
2010 INT uCountW;
2011 GCP_RESULTSW resultsW;
2012 DWORD ret;
2013 UINT font_cp;
2014
2015 TRACE("%s, %d, %d, 0x%08lx\n",
2016 debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
2017
2018 /* both structs are equal in size */
2019 memcpy(&resultsW, lpResults, sizeof(resultsW));
2020
2021 lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
2022 if(lpResults->lpOutString)
2023 resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
2024
2025 ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
2026
2027 if(lpResults->lpOutString) {
2028 WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
2029 lpResults->lpOutString, uCount, NULL, NULL );
2030 }
2031
2032 HeapFree(GetProcessHeap(), 0, lpStringW);
2033 HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
2034
2035 return ret;
2036 }
2037
2038 /*************************************************************************
2039 * GetCharacterPlacementW [GDI32.@]
2040 *
2041 * Retrieve information about a string. This includes the width, reordering,
2042 * Glyphing and so on.
2043 *
2044 * RETURNS
2045 *
2046 * The width and height of the string if successful, 0 if failed.
2047 *
2048 * BUGS
2049 *
2050 * All flags except GCP_REORDER are not yet implemented.
2051 * Reordering is not 100% complient to the Windows BiDi method.
2052 * Caret positioning is not yet implemented for BiDi.
2053 * Classes are not yet implemented.
2054 *
2055 */
2056 DWORD WINAPI
2057 GetCharacterPlacementW(
2058 HDC hdc, /* [in] Device context for which the rendering is to be done */
2059 LPCWSTR lpString, /* [in] The string for which information is to be returned */
2060 INT uCount, /* [in] Number of WORDS in string. */
2061 INT nMaxExtent, /* [in] Maximum extent the string is to take (in HDC logical units) */
2062 GCP_RESULTSW *lpResults,/* [in/out] A pointer to a GCP_RESULTSW struct */
2063 DWORD dwFlags /* [in] Flags specifying how to process the string */
2064 )
2065 {
2066 DWORD ret=0;
2067 SIZE size;
2068 UINT i, nSet;
2069
2070 TRACE("%s, %d, %d, 0x%08lx\n",
2071 debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
2072
2073 TRACE("lStructSize=%ld, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
2074 "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
2075 lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
2076 lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
2077 lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
2078
2079 if(dwFlags&(~GCP_REORDER)) FIXME("flags 0x%08lx ignored\n", dwFlags);
2080 if(lpResults->lpClass) FIXME("classes not implemented\n");
2081 if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
2082 FIXME("Caret positions for complex scripts not implemented\n");
2083
2084 nSet = (UINT)uCount;
2085 if(nSet > lpResults->nGlyphs)
2086 nSet = lpResults->nGlyphs;
2087
2088 /* return number of initialized fields */
2089 lpResults->nGlyphs = nSet;
2090
2091 if((dwFlags&GCP_REORDER)==0 || !BidiAvail)
2092 {
2093 /* Treat the case where no special handling was requested in a fastpath way */
2094 /* copy will do if the GCP_REORDER flag is not set */
2095 if(lpResults->lpOutString)
2096 strncpyW( lpResults->lpOutString, lpString, nSet );
2097
2098 if(lpResults->lpOrder)
2099 {
2100 for(i = 0; i < nSet; i++)
2101 lpResults->lpOrder[i] = i;
2102 }
2103 } else
2104 {
2105 BIDI_Reorder( lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
2106 nSet, lpResults->lpOrder );
2107 }
2108
2109 /* FIXME: Will use the placement chars */
2110 if (lpResults->lpDx)
2111 {
2112 int c;
2113 for (i = 0; i < nSet; i++)
2114 {
2115 if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
2116 lpResults->lpDx[i]= c;
2117 }
2118 }
2119
2120 if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
2121 {
2122 int pos = 0;
2123
2124 lpResults->lpCaretPos[0] = 0;
2125 for (i = 1; i < nSet; i++)
2126 if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
2127 lpResults->lpCaretPos[i] = (pos += size.cx);
2128 }
2129
2130 if(lpResults->lpGlyphs)
2131 GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
2132
2133 if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
2134 ret = MAKELONG(size.cx, size.cy);
2135
2136 return ret;
2137 }
2138
2139 /*************************************************************************
2140 * GetCharABCWidthsFloatA [GDI32.@]
2141 */
2142 BOOL WINAPI GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar,
2143 LPABCFLOAT lpABCF)
2144 {
2145 FIXME_(gdi)("GetCharABCWidthsFloatA, stub\n");
2146 return 0;
2147 }
2148
2149 /*************************************************************************
2150 * GetCharABCWidthsFloatW [GDI32.@]
2151 */
2152 BOOL WINAPI GetCharABCWidthsFloatW(HDC hdc, UINT iFirstChar,
2153 UINT iLastChar, LPABCFLOAT lpABCF)
2154 {
2155 FIXME_(gdi)("GetCharABCWidthsFloatW, stub\n");
2156 return 0;
2157 }
2158
2159 /*************************************************************************
2160 * GetCharWidthFloatA [GDI32.@]
2161 */
2162 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
2163 UINT iLastChar, PFLOAT pxBuffer)
2164 {
2165 FIXME_(gdi)("GetCharWidthFloatA, stub\n");
2166 return 0;
2167 }
2168
2169 /*************************************************************************
2170 * GetCharWidthFloatW [GDI32.@]
2171 */
2172 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
2173 UINT iLastChar, PFLOAT pxBuffer)
2174 {
2175 FIXME_(gdi)("GetCharWidthFloatW, stub\n");
2176 return 0;
2177 }
2178
2179
2180 /***********************************************************************
2181 * *
2182 * Font Resource API *
2183 * *
2184 ***********************************************************************/
2185
2186 /***********************************************************************
2187 * AddFontResourceA (GDI32.@)
2188 */
2189 INT WINAPI AddFontResourceA( LPCSTR str )
2190 {
2191 return AddFontResourceExA( str, 0, NULL);
2192 }
2193
2194 /***********************************************************************
2195 * AddFontResourceW (GDI32.@)
2196 */
2197 INT WINAPI AddFontResourceW( LPCWSTR str )
2198 {
2199 return AddFontResourceExW(str, 0, NULL);
2200 }
2201
2202
2203 /***********************************************************************
2204 * AddFontResourceExA (GDI32.@)
2205 */
2206 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
2207 {
2208 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
2209 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2210 INT ret;
2211
2212 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
2213 ret = AddFontResourceExW(strW, fl, pdv);
2214 HeapFree(GetProcessHeap(), 0, strW);
2215 return ret;
2216 }
2217
2218 /***********************************************************************
2219 * AddFontResourceExW (GDI32.@)
2220 */
2221 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
2222 {
2223 return WineEngAddFontResourceEx(str, fl, pdv);
2224 }
2225
2226 /***********************************************************************
2227 * RemoveFontResourceA (GDI32.@)
2228 */
2229 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
2230 {
2231 return RemoveFontResourceExA(str, 0, 0);
2232 }
2233
2234 /***********************************************************************
2235 * RemoveFontResourceW (GDI32.@)
2236 */
2237 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
2238 {
2239 return RemoveFontResourceExW(str, 0, 0);
2240 }
2241
2242 /***********************************************************************
2243 * RemoveFontResourceExA (GDI32.@)
2244 */
2245 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
2246 {
2247 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
2248 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2249 INT ret;
2250
2251 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
2252 ret = RemoveFontResourceExW(strW, fl, pdv);
2253 HeapFree(GetProcessHeap(), 0, strW);
2254 return ret;
2255 }
2256
2257 /***********************************************************************
2258 * RemoveFontResourceExW (GDI32.@)
2259 */
2260 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
2261 {
2262 return WineEngRemoveFontResourceEx(str, fl, pdv);
2263 }
2264
2265 /***********************************************************************
2266 * GetTextCharset (GDI32.@)
2267 */
2268 UINT WINAPI GetTextCharset(HDC hdc)
2269 {
2270 /* MSDN docs say this is equivalent */
2271 return GetTextCharsetInfo(hdc, NULL, 0);
2272 }
2273
2274 /***********************************************************************
2275 * GetTextCharsetInfo (GDI32.@)
2276 */
2277 UINT WINAPI GetTextCharsetInfo(HDC hdc, LPFONTSIGNATURE fs, DWORD flags)
2278 {
2279 UINT ret = DEFAULT_CHARSET;
2280 DC *dc = DC_GetDCPtr(hdc);
2281
2282 if (!dc) goto done;
2283
2284 if (dc->gdiFont)
2285 ret = WineEngGetTextCharsetInfo(dc->gdiFont, fs, flags);
2286
2287 GDI_ReleaseObj(hdc);
2288
2289 done:
2290 if (ret == DEFAULT_CHARSET && fs)
2291 memset(fs, 0, sizeof(FONTSIGNATURE));
2292 return ret;
2293 }
Maarten's multimedia branch