?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix MultiByteToWideChar and WideCharToMultiByte when called with code
[wine/multimedia.git] / objects / font.c
blobb58d7f855e2e0220f1aa2cc55deb38cac1512c74
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 );
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 dc->breakTotalExtra = extra;
904 dc->breakCount = breaks;
905 if (breaks)
906 {
907 dc->breakExtra = extra / breaks;
908 dc->breakRem = extra - (dc->breakCount * dc->breakExtra);
909 }
910 else
911 {
912 dc->breakExtra = 0;
913 dc->breakRem = 0;
914 }
915 }
916 GDI_ReleaseObj( hdc );
917 return ret;
918 }
919
920
921 /***********************************************************************
922 * GetTextFaceA (GDI32.@)
923 */
924 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
925 {
926 INT res = GetTextFaceW(hdc, 0, NULL);
927 LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
928 GetTextFaceW( hdc, res, nameW );
929
930 if (name)
931 {
932 if (count && !WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, count, NULL, NULL))
933 name[count-1] = 0;
934 res = strlen(name);
935 }
936 else
937 res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
938 HeapFree( GetProcessHeap(), 0, nameW );
939 return res;
940 }
941
942 /***********************************************************************
943 * GetTextFaceW (GDI32.@)
944 */
945 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
946 {
947 FONTOBJ *font;
948 INT ret = 0;
949
950 DC * dc = DC_GetDCPtr( hdc );
951 if (!dc) return 0;
952
953 if(dc->gdiFont)
954 ret = WineEngGetTextFace(dc->gdiFont, count, name);
955 else if ((font = (FONTOBJ *) GDI_GetObjPtr( dc->hFont, FONT_MAGIC )))
956 {
957 if (name)
958 {
959 lstrcpynW( name, font->logfont.lfFaceName, count );
960 ret = strlenW(name);
961 }
962 else ret = strlenW(font->logfont.lfFaceName) + 1;
963 GDI_ReleaseObj( dc->hFont );
964 }
965 GDI_ReleaseObj( hdc );
966 return ret;
967 }
968
969
970 /***********************************************************************
971 * GetTextExtentPoint32A (GDI32.@)
972 */
973 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
974 LPSIZE size )
975 {
976 BOOL ret = FALSE;
977 INT wlen;
978 LPWSTR p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
979
980 if (p) {
981 ret = GetTextExtentPoint32W( hdc, p, wlen, size );
982 HeapFree( GetProcessHeap(), 0, p );
983 }
984
985 TRACE("(%p %s %d %p): returning %ld x %ld\n",
986 hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
987 return ret;
988 }
989
990
991 /***********************************************************************
992 * GetTextExtentPoint32W [GDI32.@] 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 size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1013 size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1014 size->cx += count * dc->charExtra;
1015 }
1016 else if(dc->funcs->pGetTextExtentPoint)
1017 ret = dc->funcs->pGetTextExtentPoint( dc->physDev, str, count, size );
1018
1019 GDI_ReleaseObj( hdc );
1020
1021 TRACE("(%p %s %d %p): returning %ld x %ld\n",
1022 hdc, debugstr_wn (str, count), count, size, size->cx, size->cy );
1023 return ret;
1024 }
1025
1026 /***********************************************************************
1027 * GetTextExtentPointI [GDI32.@]
1028 *
1029 * Computes width and height of the array of glyph indices.
1030 *
1031 * RETURNS
1032 * Success: TRUE
1033 * Failure: FALSE
1034 */
1035 BOOL WINAPI GetTextExtentPointI(
1036 HDC hdc, /* [in] Handle of device context */
1037 const WORD *indices, /* [in] Address of glyph index array */
1038 INT count, /* [in] Number of glyphs in array */
1039 LPSIZE size) /* [out] Address of structure for string size */
1040 {
1041 BOOL ret = FALSE;
1042 DC * dc = DC_GetDCPtr( hdc );
1043 if (!dc) return FALSE;
1044
1045 if(dc->gdiFont) {
1046 ret = WineEngGetTextExtentPointI(dc->gdiFont, indices, count, size);
1047 size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1048 size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1049 size->cx += count * dc->charExtra;
1050 }
1051 else if(dc->funcs->pGetTextExtentPoint) {
1052 FIXME("calling GetTextExtentPoint\n");
1053 ret = dc->funcs->pGetTextExtentPoint( dc->physDev, (LPCWSTR)indices, count, size );
1054 }
1055
1056 GDI_ReleaseObj( hdc );
1057
1058 TRACE("(%p %p %d %p): returning %ld x %ld\n",
1059 hdc, indices, count, size, size->cx, size->cy );
1060 return ret;
1061 }
1062
1063
1064 /***********************************************************************
1065 * GetTextExtentPointA (GDI32.@)
1066 */
1067 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1068 LPSIZE size )
1069 {
1070 TRACE("not bug compatible.\n");
1071 return GetTextExtentPoint32A( hdc, str, count, size );
1072 }
1073
1074 /***********************************************************************
1075 * GetTextExtentPointW (GDI32.@)
1076 */
1077 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1078 LPSIZE size )
1079 {
1080 TRACE("not bug compatible.\n");
1081 return GetTextExtentPoint32W( hdc, str, count, size );
1082 }
1083
1084
1085 /***********************************************************************
1086 * GetTextExtentExPointA (GDI32.@)
1087 */
1088 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1089 INT maxExt, LPINT lpnFit,
1090 LPINT alpDx, LPSIZE size )
1091 {
1092 BOOL ret;
1093 INT wlen;
1094 LPWSTR p = FONT_mbtowc( hdc, str, count, &wlen, NULL);
1095 ret = GetTextExtentExPointW( hdc, p, wlen, maxExt, lpnFit, alpDx, size);
1096 if (lpnFit) *lpnFit = WideCharToMultiByte(CP_ACP,0,p,*lpnFit,NULL,0,NULL,NULL);
1097 HeapFree( GetProcessHeap(), 0, p );
1098 return ret;
1099 }
1100
1101
1102 /***********************************************************************
1103 * GetTextExtentExPointW (GDI32.@)
1104 *
1105 * Return the size of the string as it would be if it was output properly by
1106 * e.g. TextOut.
1107 *
1108 * This should include
1109 * - Intercharacter spacing
1110 * - justification spacing (not yet done)
1111 * - kerning? see below
1112 *
1113 * Kerning. Since kerning would be carried out by the rendering code it should
1114 * be done by the driver. However they don't support it yet. Also I am not
1115 * yet persuaded that (certainly under Win95) any kerning is actually done.
1116 *
1117 * str: According to MSDN this should be null-terminated. That is not true; a
1118 * null will not terminate it early.
1119 * size: Certainly under Win95 this appears buggy or weird if *lpnFit is less
1120 * than count. I have seen it be either the size of the full string or
1121 * 1 less than the size of the full string. I have not seen it bear any
1122 * resemblance to the portion that would fit.
1123 * lpnFit: What exactly is fitting? Stupidly, in my opinion, it includes the
1124 * trailing intercharacter spacing and any trailing justification.
1125 *
1126 * FIXME
1127 * Currently we do this by measuring each character etc. We should do it by
1128 * passing the request to the driver, perhaps by extending the
1129 * pGetTextExtentPoint function to take the alpDx argument. That would avoid
1130 * thinking about kerning issues and rounding issues in the justification.
1131 */
1132
1133 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
1134 INT maxExt, LPINT lpnFit,
1135 LPINT alpDx, LPSIZE size )
1136 {
1137 int index, nFit, extent;
1138 SIZE tSize;
1139 BOOL ret = FALSE;
1140
1141 TRACE("(%p, %s, %d)\n",hdc,debugstr_wn(str,count),maxExt);
1142
1143 size->cx = size->cy = nFit = extent = 0;
1144 for(index = 0; index < count; index++)
1145 {
1146 if(!GetTextExtentPoint32W( hdc, str, 1, &tSize )) goto done;
1147 /* GetTextExtentPoint includes intercharacter spacing. */
1148 /* FIXME - justification needs doing yet. Remember that the base
1149 * data will not be in logical coordinates.
1150 */
1151 extent += tSize.cx;
1152 if( !lpnFit || extent <= maxExt )
1153 /* It is allowed to be equal. */
1154 {
1155 nFit++;
1156 if( alpDx ) alpDx[index] = extent;
1157 }
1158 if( tSize.cy > size->cy ) size->cy = tSize.cy;
1159 str++;
1160 }
1161 size->cx = extent;
1162 if(lpnFit) *lpnFit = nFit;
1163 ret = TRUE;
1164
1165 TRACE("returning %d %ld x %ld\n",nFit,size->cx,size->cy);
1166
1167 done:
1168 return ret;
1169 }
1170
1171 /***********************************************************************
1172 * GetTextMetricsA (GDI32.@)
1173 */
1174 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1175 {
1176 TEXTMETRICW tm32;
1177
1178 if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1179 FONT_TextMetricWToA( &tm32, metrics );
1180 return TRUE;
1181 }
1182
1183 /***********************************************************************
1184 * GetTextMetricsW (GDI32.@)
1185 */
1186 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1187 {
1188 BOOL ret = FALSE;
1189 DC * dc = DC_GetDCPtr( hdc );
1190 if (!dc) return FALSE;
1191
1192 if (dc->gdiFont)
1193 ret = WineEngGetTextMetrics(dc->gdiFont, metrics);
1194 else if (dc->funcs->pGetTextMetrics)
1195 ret = dc->funcs->pGetTextMetrics( dc->physDev, metrics );
1196
1197 if (ret)
1198 {
1199 /* device layer returns values in device units
1200 * therefore we have to convert them to logical */
1201
1202 #define WDPTOLP(x) ((x<0)? \
1203 (-abs(INTERNAL_XDSTOWS(dc, (x)))): \
1204 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1205 #define HDPTOLP(y) ((y<0)? \
1206 (-abs(INTERNAL_YDSTOWS(dc, (y)))): \
1207 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1208
1209 metrics->tmHeight = HDPTOLP(metrics->tmHeight);
1210 metrics->tmAscent = HDPTOLP(metrics->tmAscent);
1211 metrics->tmDescent = HDPTOLP(metrics->tmDescent);
1212 metrics->tmInternalLeading = HDPTOLP(metrics->tmInternalLeading);
1213 metrics->tmExternalLeading = HDPTOLP(metrics->tmExternalLeading);
1214 metrics->tmAveCharWidth = WDPTOLP(metrics->tmAveCharWidth);
1215 metrics->tmMaxCharWidth = WDPTOLP(metrics->tmMaxCharWidth);
1216 metrics->tmOverhang = WDPTOLP(metrics->tmOverhang);
1217 ret = TRUE;
1218 #undef WDPTOLP
1219 #undef HDPTOLP
1220 TRACE("text metrics:\n"
1221 " Weight = %03li\t FirstChar = %i\t AveCharWidth = %li\n"
1222 " Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %li\n"
1223 " UnderLined = %01i\t DefaultChar = %i\t Overhang = %li\n"
1224 " StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1225 " PitchAndFamily = %02x\n"
1226 " --------------------\n"
1227 " InternalLeading = %li\n"
1228 " Ascent = %li\n"
1229 " Descent = %li\n"
1230 " Height = %li\n",
1231 metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1232 metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1233 metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1234 metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1235 metrics->tmPitchAndFamily,
1236 metrics->tmInternalLeading,
1237 metrics->tmAscent,
1238 metrics->tmDescent,
1239 metrics->tmHeight );
1240 }
1241 GDI_ReleaseObj( hdc );
1242 return ret;
1243 }
1244
1245
1246 /***********************************************************************
1247 * GetOutlineTextMetrics [GDI.308] Gets metrics for TrueType fonts.
1248 *
1249 * NOTES
1250 * lpOTM should be LPOUTLINETEXTMETRIC
1251 *
1252 * RETURNS
1253 * Success: Non-zero or size of required buffer
1254 * Failure: 0
1255 */
1256 UINT16 WINAPI GetOutlineTextMetrics16(
1257 HDC16 hdc, /* [in] Handle of device context */
1258 UINT16 cbData, /* [in] Size of metric data array */
1259 LPOUTLINETEXTMETRIC16 lpOTM) /* [out] Address of metric data array */
1260 {
1261 FIXME("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
1262 return 0;
1263 }
1264
1265
1266 /***********************************************************************
1267 * GetOutlineTextMetricsA (GDI32.@)
1268 * Gets metrics for TrueType fonts.
1269 *
1270 * NOTES
1271 * If the supplied buffer isn't big enough Windows partially fills it up to
1272 * its given length and returns that length.
1273 *
1274 * RETURNS
1275 * Success: Non-zero or size of required buffer
1276 * Failure: 0
1277 */
1278 UINT WINAPI GetOutlineTextMetricsA(
1279 HDC hdc, /* [in] Handle of device context */
1280 UINT cbData, /* [in] Size of metric data array */
1281 LPOUTLINETEXTMETRICA lpOTM) /* [out] Address of metric data array */
1282 {
1283 char buf[512], *ptr;
1284 UINT ret, needed;
1285 OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
1286 OUTLINETEXTMETRICA *output = lpOTM;
1287 INT left, len;
1288
1289 if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1290 return 0;
1291 if(ret > sizeof(buf))
1292 lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1293 GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1294
1295 needed = sizeof(OUTLINETEXTMETRICA);
1296 if(lpOTMW->otmpFamilyName)
1297 needed += WideCharToMultiByte(CP_ACP, 0,
1298 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1299 NULL, 0, NULL, NULL);
1300 if(lpOTMW->otmpFaceName)
1301 needed += WideCharToMultiByte(CP_ACP, 0,
1302 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1303 NULL, 0, NULL, NULL);
1304 if(lpOTMW->otmpStyleName)
1305 needed += WideCharToMultiByte(CP_ACP, 0,
1306 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1307 NULL, 0, NULL, NULL);
1308 if(lpOTMW->otmpFullName)
1309 needed += WideCharToMultiByte(CP_ACP, 0,
1310 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1311 NULL, 0, NULL, NULL);
1312
1313 if(!lpOTM) {
1314 ret = needed;
1315 goto end;
1316 }
1317
1318 TRACE("needed = %d\n", needed);
1319 if(needed > cbData)
1320 /* Since the supplied buffer isn't big enough, we'll alloc one
1321 that is and memcpy the first cbData bytes into the lpOTM at
1322 the end. */
1323 output = HeapAlloc(GetProcessHeap(), 0, needed);
1324
1325 ret = output->otmSize = min(needed, cbData);
1326 FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
1327 output->otmFiller = 0;
1328 output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1329 output->otmfsSelection = lpOTMW->otmfsSelection;
1330 output->otmfsType = lpOTMW->otmfsType;
1331 output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1332 output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1333 output->otmItalicAngle = lpOTMW->otmItalicAngle;
1334 output->otmEMSquare = lpOTMW->otmEMSquare;
1335 output->otmAscent = lpOTMW->otmAscent;
1336 output->otmDescent = lpOTMW->otmDescent;
1337 output->otmLineGap = lpOTMW->otmLineGap;
1338 output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1339 output->otmsXHeight = lpOTMW->otmsXHeight;
1340 output->otmrcFontBox = lpOTMW->otmrcFontBox;
1341 output->otmMacAscent = lpOTMW->otmMacAscent;
1342 output->otmMacDescent = lpOTMW->otmMacDescent;
1343 output->otmMacLineGap = lpOTMW->otmMacLineGap;
1344 output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1345 output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1346 output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
1347 output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
1348 output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
1349 output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1350 output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
1351 output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1352 output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
1353
1354
1355 ptr = (char*)(output + 1);
1356 left = needed - sizeof(*output);
1357
1358 if(lpOTMW->otmpFamilyName) {
1359 output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1360 len = WideCharToMultiByte(CP_ACP, 0,
1361 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1362 ptr, left, NULL, NULL);
1363 left -= len;
1364 ptr += len;
1365 } else
1366 output->otmpFamilyName = 0;
1367
1368 if(lpOTMW->otmpFaceName) {
1369 output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1370 len = WideCharToMultiByte(CP_ACP, 0,
1371 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1372 ptr, left, NULL, NULL);
1373 left -= len;
1374 ptr += len;
1375 } else
1376 output->otmpFaceName = 0;
1377
1378 if(lpOTMW->otmpStyleName) {
1379 output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1380 len = WideCharToMultiByte(CP_ACP, 0,
1381 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1382 ptr, left, NULL, NULL);
1383 left -= len;
1384 ptr += len;
1385 } else
1386 output->otmpStyleName = 0;
1387
1388 if(lpOTMW->otmpFullName) {
1389 output->otmpFullName = (LPSTR)(ptr - (char*)output);
1390 len = WideCharToMultiByte(CP_ACP, 0,
1391 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1392 ptr, left, NULL, NULL);
1393 left -= len;
1394 } else
1395 output->otmpFullName = 0;
1396
1397 assert(left == 0);
1398
1399 if(output != lpOTM) {
1400 memcpy(lpOTM, output, cbData);
1401 HeapFree(GetProcessHeap(), 0, output);
1402 }
1403
1404 end:
1405 if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1406 HeapFree(GetProcessHeap(), 0, lpOTMW);
1407
1408 return ret;
1409 }
1410
1411
1412 /***********************************************************************
1413 * GetOutlineTextMetricsW [GDI32.@]
1414 */
1415 UINT WINAPI GetOutlineTextMetricsW(
1416 HDC hdc, /* [in] Handle of device context */
1417 UINT cbData, /* [in] Size of metric data array */
1418 LPOUTLINETEXTMETRICW lpOTM) /* [out] Address of metric data array */
1419 {
1420 DC *dc = DC_GetDCPtr( hdc );
1421 OUTLINETEXTMETRICW *output = lpOTM;
1422 UINT ret;
1423
1424 TRACE("(%p,%d,%p)\n", hdc, cbData, lpOTM);
1425 if(!dc) return 0;
1426
1427 if(dc->gdiFont) {
1428 ret = WineEngGetOutlineTextMetrics(dc->gdiFont, cbData, output);
1429 if(lpOTM && ret) {
1430 if(ret > cbData) {
1431 output = HeapAlloc(GetProcessHeap(), 0, ret);
1432 WineEngGetOutlineTextMetrics(dc->gdiFont, ret, output);
1433 }
1434
1435 #define WDPTOLP(x) ((x<0)? \
1436 (-abs(INTERNAL_XDSTOWS(dc, (x)))): \
1437 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1438 #define HDPTOLP(y) ((y<0)? \
1439 (-abs(INTERNAL_YDSTOWS(dc, (y)))): \
1440 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1441
1442 output->otmTextMetrics.tmHeight = HDPTOLP(output->otmTextMetrics.tmHeight);
1443 output->otmTextMetrics.tmAscent = HDPTOLP(output->otmTextMetrics.tmAscent);
1444 output->otmTextMetrics.tmDescent = HDPTOLP(output->otmTextMetrics.tmDescent);
1445 output->otmTextMetrics.tmInternalLeading = HDPTOLP(output->otmTextMetrics.tmInternalLeading);
1446 output->otmTextMetrics.tmExternalLeading = HDPTOLP(output->otmTextMetrics.tmExternalLeading);
1447 output->otmTextMetrics.tmAveCharWidth = WDPTOLP(output->otmTextMetrics.tmAveCharWidth);
1448 output->otmTextMetrics.tmMaxCharWidth = WDPTOLP(output->otmTextMetrics.tmMaxCharWidth);
1449 output->otmTextMetrics.tmOverhang = WDPTOLP(output->otmTextMetrics.tmOverhang);
1450 output->otmAscent = HDPTOLP(output->otmAscent);
1451 output->otmDescent = HDPTOLP(output->otmDescent);
1452 output->otmLineGap = HDPTOLP(output->otmLineGap);
1453 output->otmsCapEmHeight = HDPTOLP(output->otmsCapEmHeight);
1454 output->otmsXHeight = HDPTOLP(output->otmsXHeight);
1455 output->otmrcFontBox.top = HDPTOLP(output->otmrcFontBox.top);
1456 output->otmrcFontBox.bottom = HDPTOLP(output->otmrcFontBox.bottom);
1457 output->otmrcFontBox.left = WDPTOLP(output->otmrcFontBox.left);
1458 output->otmrcFontBox.right = WDPTOLP(output->otmrcFontBox.right);
1459 output->otmMacAscent = HDPTOLP(output->otmMacAscent);
1460 output->otmMacDescent = HDPTOLP(output->otmMacDescent);
1461 output->otmMacLineGap = HDPTOLP(output->otmMacLineGap);
1462 output->otmptSubscriptSize.x = WDPTOLP(output->otmptSubscriptSize.x);
1463 output->otmptSubscriptSize.y = HDPTOLP(output->otmptSubscriptSize.y);
1464 output->otmptSubscriptOffset.x = WDPTOLP(output->otmptSubscriptOffset.x);
1465 output->otmptSubscriptOffset.y = HDPTOLP(output->otmptSubscriptOffset.y);
1466 output->otmptSuperscriptSize.x = WDPTOLP(output->otmptSuperscriptSize.x);
1467 output->otmptSuperscriptSize.y = HDPTOLP(output->otmptSuperscriptSize.y);
1468 output->otmptSuperscriptOffset.x = WDPTOLP(output->otmptSuperscriptOffset.x);
1469 output->otmptSuperscriptOffset.y = HDPTOLP(output->otmptSuperscriptOffset.y);
1470 output->otmsStrikeoutSize = HDPTOLP(output->otmsStrikeoutSize);
1471 output->otmsStrikeoutPosition = HDPTOLP(output->otmsStrikeoutPosition);
1472 output->otmsUnderscoreSize = HDPTOLP(output->otmsUnderscoreSize);
1473 output->otmsUnderscorePosition = HDPTOLP(output->otmsUnderscorePosition);
1474 #undef WDPTOLP
1475 #undef HDPTOLP
1476 if(output != lpOTM) {
1477 memcpy(lpOTM, output, cbData);
1478 HeapFree(GetProcessHeap(), 0, output);
1479 ret = cbData;
1480 }
1481 }
1482 }
1483
1484 else { /* This stuff was in GetOutlineTextMetricsA, I've moved it here
1485 but really this should just be a return 0. */
1486
1487 ret = sizeof(*lpOTM);
1488 if (lpOTM) {
1489 if(cbData < ret)
1490 ret = 0;
1491 else {
1492 memset(lpOTM, 0, ret);
1493 lpOTM->otmSize = sizeof(*lpOTM);
1494 GetTextMetricsW(hdc, &lpOTM->otmTextMetrics);
1495 /*
1496 Further fill of the structure not implemented,
1497 Needs real values for the structure members
1498 */
1499 }
1500 }
1501 }
1502 GDI_ReleaseObj(hdc);
1503 return ret;
1504 }
1505
1506
1507 /***********************************************************************
1508 * GetCharWidthW (GDI32.@)
1509 * GetCharWidth32W (GDI32.@)
1510 */
1511 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1512 LPINT buffer )
1513 {
1514 UINT i;
1515 BOOL ret = FALSE;
1516 DC * dc = DC_GetDCPtr( hdc );
1517 if (!dc) return FALSE;
1518
1519 if (dc->gdiFont)
1520 ret = WineEngGetCharWidth( dc->gdiFont, firstChar, lastChar, buffer );
1521 else if (dc->funcs->pGetCharWidth)
1522 ret = dc->funcs->pGetCharWidth( dc->physDev, firstChar, lastChar, buffer);
1523
1524 if (ret)
1525 {
1526 /* convert device units to logical */
1527 for( i = firstChar; i <= lastChar; i++, buffer++ )
1528 *buffer = INTERNAL_XDSTOWS(dc, *buffer);
1529 ret = TRUE;
1530 }
1531 GDI_ReleaseObj( hdc );
1532 return ret;
1533 }
1534
1535
1536 /***********************************************************************
1537 * GetCharWidthA (GDI32.@)
1538 * GetCharWidth32A (GDI32.@)
1539 */
1540 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1541 LPINT buffer )
1542 {
1543 INT i, wlen, count = (INT)(lastChar - firstChar + 1);
1544 LPSTR str;
1545 LPWSTR wstr;
1546 BOOL ret = TRUE;
1547
1548 if(count <= 0) return FALSE;
1549
1550 str = HeapAlloc(GetProcessHeap(), 0, count);
1551 for(i = 0; i < count; i++)
1552 str[i] = (BYTE)(firstChar + i);
1553
1554 wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1555
1556 for(i = 0; i < wlen; i++)
1557 {
1558 if(!GetCharWidth32W(hdc, wstr[i], wstr[i], buffer))
1559 {
1560 ret = FALSE;
1561 break;
1562 }
1563 buffer++;
1564 }
1565
1566 HeapFree(GetProcessHeap(), 0, str);
1567 HeapFree(GetProcessHeap(), 0, wstr);
1568
1569 return ret;
1570 }
1571
1572
1573 /* FIXME: all following APIs ******************************************/
1574
1575
1576 /***********************************************************************
1577 * SetMapperFlags (GDI32.@)
1578 */
1579 DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
1580 {
1581 DC *dc = DC_GetDCPtr( hDC );
1582 DWORD ret = 0;
1583 if(!dc) return 0;
1584 if(dc->funcs->pSetMapperFlags)
1585 ret = dc->funcs->pSetMapperFlags( dc->physDev, dwFlag );
1586 else
1587 FIXME("(%p, 0x%08lx): stub - harmless\n", hDC, dwFlag);
1588 GDI_ReleaseObj( hDC );
1589 return ret;
1590 }
1591
1592 /***********************************************************************
1593 * GetAspectRatioFilterEx (GDI.486)
1594 */
1595 BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
1596 {
1597 FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1598 return FALSE;
1599 }
1600
1601 /***********************************************************************
1602 * GetAspectRatioFilterEx (GDI32.@)
1603 */
1604 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
1605 {
1606 FIXME("(%p, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1607 return FALSE;
1608 }
1609
1610
1611 /***********************************************************************
1612 * GetCharABCWidthsA (GDI32.@)
1613 */
1614 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
1615 LPABC abc )
1616 {
1617 INT i, wlen, count = (INT)(lastChar - firstChar + 1);
1618 LPSTR str;
1619 LPWSTR wstr;
1620 BOOL ret = TRUE;
1621
1622 if(count <= 0) return FALSE;
1623
1624 str = HeapAlloc(GetProcessHeap(), 0, count);
1625 for(i = 0; i < count; i++)
1626 str[i] = (BYTE)(firstChar + i);
1627
1628 wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1629
1630 for(i = 0; i < wlen; i++)
1631 {
1632 if(!GetCharABCWidthsW(hdc, wstr[i], wstr[i], abc))
1633 {
1634 ret = FALSE;
1635 break;
1636 }
1637 abc++;
1638 }
1639
1640 HeapFree(GetProcessHeap(), 0, str);
1641 HeapFree(GetProcessHeap(), 0, wstr);
1642
1643 return ret;
1644 }
1645
1646
1647 /******************************************************************************
1648 * GetCharABCWidthsW [GDI32.@] Retrieves widths of characters in range
1649 *
1650 * PARAMS
1651 * hdc [I] Handle of device context
1652 * firstChar [I] First character in range to query
1653 * lastChar [I] Last character in range to query
1654 * abc [O] Address of character-width structure
1655 *
1656 * NOTES
1657 * Only works with TrueType fonts
1658 *
1659 * RETURNS
1660 * Success: TRUE
1661 * Failure: FALSE
1662 */
1663 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
1664 LPABC abc )
1665 {
1666 DC *dc = DC_GetDCPtr(hdc);
1667 int i;
1668 GLYPHMETRICS gm;
1669 BOOL ret = FALSE;
1670
1671 if(dc->gdiFont) {
1672 for (i=firstChar;i<=lastChar;i++) {
1673 GetGlyphOutlineW(hdc, i, GGO_METRICS, &gm, 0, NULL, NULL);
1674 abc[i-firstChar].abcA = gm.gmptGlyphOrigin.x;
1675 abc[i-firstChar].abcB = gm.gmBlackBoxX;
1676 abc[i-firstChar].abcC = gm.gmCellIncX - gm.gmptGlyphOrigin.x - gm.gmBlackBoxX;
1677 }
1678 ret = TRUE;
1679 }
1680 GDI_ReleaseObj(hdc);
1681 return ret;
1682 }
1683
1684
1685 /***********************************************************************
1686 * GetGlyphOutline (GDI.309)
1687 */
1688 DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
1689 LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
1690 LPVOID lpBuffer, const MAT2 *lpmat2 )
1691 {
1692 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1693 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1694 return (DWORD)-1; /* failure */
1695 }
1696
1697
1698 /***********************************************************************
1699 * GetGlyphOutlineA (GDI32.@)
1700 */
1701 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
1702 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1703 LPVOID lpBuffer, const MAT2 *lpmat2 )
1704 {
1705 LPWSTR p = NULL;
1706 DWORD ret;
1707 UINT c;
1708
1709 if(!(fuFormat & GGO_GLYPH_INDEX)) {
1710 p = FONT_mbtowc(hdc, (char*)&uChar, 1, NULL, NULL);
1711 c = p[0];
1712 } else
1713 c = uChar;
1714 ret = GetGlyphOutlineW(hdc, c, fuFormat, lpgm, cbBuffer, lpBuffer,
1715 lpmat2);
1716 if(p)
1717 HeapFree(GetProcessHeap(), 0, p);
1718 return ret;
1719 }
1720
1721 /***********************************************************************
1722 * GetGlyphOutlineW (GDI32.@)
1723 */
1724 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
1725 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1726 LPVOID lpBuffer, const MAT2 *lpmat2 )
1727 {
1728 DC *dc = DC_GetDCPtr(hdc);
1729 DWORD ret;
1730
1731 TRACE("(%p, %04x, %04x, %p, %ld, %p, %p)\n",
1732 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1733
1734 if(!dc) return GDI_ERROR;
1735
1736 if(dc->gdiFont)
1737 ret = WineEngGetGlyphOutline(dc->gdiFont, uChar, fuFormat, lpgm,
1738 cbBuffer, lpBuffer, lpmat2);
1739 else
1740 ret = GDI_ERROR;
1741
1742 GDI_ReleaseObj(hdc);
1743 return ret;
1744 }
1745
1746
1747 /***********************************************************************
1748 * CreateScalableFontResourceA (GDI32.@)
1749 */
1750 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
1751 LPCSTR lpszResourceFile,
1752 LPCSTR lpszFontFile,
1753 LPCSTR lpszCurrentPath )
1754 {
1755 HANDLE f;
1756
1757 /* fHidden=1 - only visible for the calling app, read-only, not
1758 * enumbered with EnumFonts/EnumFontFamilies
1759 * lpszCurrentPath can be NULL
1760 */
1761 FIXME("(%ld,%s,%s,%s): stub\n",
1762 fHidden, debugstr_a(lpszResourceFile), debugstr_a(lpszFontFile),
1763 debugstr_a(lpszCurrentPath) );
1764
1765 /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
1766 if ((f = CreateFileA(lpszResourceFile, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE) {
1767 CloseHandle(f);
1768 SetLastError(ERROR_FILE_EXISTS);
1769 return FALSE;
1770 }
1771 return FALSE; /* create failed */
1772 }
1773
1774 /***********************************************************************
1775 * CreateScalableFontResourceW (GDI32.@)
1776 */
1777 BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
1778 LPCWSTR lpszResourceFile,
1779 LPCWSTR lpszFontFile,
1780 LPCWSTR lpszCurrentPath )
1781 {
1782 FIXME("(%ld,%p,%p,%p): stub\n",
1783 fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1784 return FALSE; /* create failed */
1785 }
1786
1787
1788 /*************************************************************************
1789 * GetRasterizerCaps (GDI32.@)
1790 */
1791 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
1792 {
1793 lprs->nSize = sizeof(RASTERIZER_STATUS);
1794 lprs->wFlags = TT_AVAILABLE|TT_ENABLED;
1795 lprs->nLanguageID = 0;
1796 return TRUE;
1797 }
1798
1799
1800 /*************************************************************************
1801 * GetKerningPairsA (GDI32.@)
1802 */
1803 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
1804 LPKERNINGPAIR lpKerningPairs )
1805 {
1806 return GetKerningPairsW( hDC, cPairs, lpKerningPairs );
1807 }
1808
1809
1810 /*************************************************************************
1811 * GetKerningPairsW (GDI32.@)
1812 */
1813 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
1814 LPKERNINGPAIR lpKerningPairs )
1815 {
1816 int i;
1817 FIXME("(%p,%ld,%p): almost empty stub!\n", hDC, cPairs, lpKerningPairs);
1818 for (i = 0; i < cPairs; i++)
1819 lpKerningPairs[i].iKernAmount = 0;
1820 return 0;
1821 }
1822
1823 /*************************************************************************
1824 * TranslateCharsetInfo [GDI32.@]
1825 *
1826 * Fills a CHARSETINFO structure for a character set, code page, or
1827 * font. This allows making the correspondance between different labelings
1828 * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
1829 * of the same encoding.
1830 *
1831 * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
1832 * only one codepage should be set in *lpSrc.
1833 *
1834 * RETURNS
1835 * TRUE on success, FALSE on failure.
1836 *
1837 */
1838 BOOL WINAPI TranslateCharsetInfo(
1839 LPDWORD lpSrc, /* [in]
1840 if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
1841 if flags == TCI_SRCCHARSET: a character set value
1842 if flags == TCI_SRCCODEPAGE: a code page value
1843 */
1844 LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
1845 DWORD flags /* [in] determines interpretation of lpSrc */
1846 ) {
1847 int index = 0;
1848 switch (flags) {
1849 case TCI_SRCFONTSIG:
1850 while (!(*lpSrc>>index & 0x0001) && index<MAXTCIINDEX) index++;
1851 break;
1852 case TCI_SRCCODEPAGE:
1853 while ((UINT) (lpSrc) != FONT_tci[index].ciACP && index < MAXTCIINDEX) index++;
1854 break;
1855 case TCI_SRCCHARSET:
1856 while ((UINT) (lpSrc) != FONT_tci[index].ciCharset && index < MAXTCIINDEX) index++;
1857 break;
1858 default:
1859 return FALSE;
1860 }
1861 if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
1862 memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
1863 return TRUE;
1864 }
1865
1866 /*************************************************************************
1867 * GetFontLanguageInfo (GDI32.@)
1868 */
1869 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
1870 {
1871 FONTSIGNATURE fontsig;
1872 static const DWORD GCP_DBCS_MASK=0x003F0000,
1873 GCP_DIACRITIC_MASK=0x00000000,
1874 FLI_GLYPHS_MASK=0x00000000,
1875 GCP_GLYPHSHAPE_MASK=0x00000040,
1876 GCP_KASHIDA_MASK=0x00000000,
1877 GCP_LIGATE_MASK=0x00000000,
1878 GCP_USEKERNING_MASK=0x00000000,
1879 GCP_REORDER_MASK=0x00000060;
1880
1881 DWORD result=0;
1882
1883 GetTextCharsetInfo( hdc, &fontsig, 0 );
1884 /* We detect each flag we return using a bitmask on the Codepage Bitfields */
1885
1886 if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
1887 result|=GCP_DBCS;
1888
1889 if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
1890 result|=GCP_DIACRITIC;
1891
1892 if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
1893 result|=FLI_GLYPHS;
1894
1895 if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
1896 result|=GCP_GLYPHSHAPE;
1897
1898 if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
1899 result|=GCP_KASHIDA;
1900
1901 if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
1902 result|=GCP_LIGATE;
1903
1904 if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
1905 result|=GCP_USEKERNING;
1906
1907 if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
1908 result|=GCP_REORDER;
1909
1910 return result;
1911 }
1912
1913
1914 /*************************************************************************
1915 * GetFontData [GDI32.@] Retrieve data for TrueType font
1916 *
1917 * RETURNS
1918 *
1919 * success: Number of bytes returned
1920 * failure: GDI_ERROR
1921 *
1922 * NOTES
1923 *
1924 * Calls SetLastError()
1925 *
1926 */
1927 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
1928 LPVOID buffer, DWORD length)
1929 {
1930 DC *dc = DC_GetDCPtr(hdc);
1931 DWORD ret = GDI_ERROR;
1932
1933 if(!dc) return GDI_ERROR;
1934
1935 if(dc->gdiFont)
1936 ret = WineEngGetFontData(dc->gdiFont, table, offset, buffer, length);
1937
1938 GDI_ReleaseObj(hdc);
1939 return ret;
1940 }
1941
1942 /*************************************************************************
1943 * GetGlyphIndicesA [GDI32.@]
1944 */
1945 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
1946 LPWORD pgi, DWORD flags)
1947 {
1948 DWORD ret;
1949 WCHAR *lpstrW;
1950 INT countW;
1951
1952 TRACE("(%p, %s, %d, %p, 0x%lx)\n",
1953 hdc, debugstr_an(lpstr, count), count, pgi, flags);
1954
1955 lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
1956 ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
1957 HeapFree(GetProcessHeap(), 0, lpstrW);
1958
1959 return ret;
1960 }
1961
1962 /*************************************************************************
1963 * GetGlyphIndicesW [GDI32.@]
1964 */
1965 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
1966 LPWORD pgi, DWORD flags)
1967 {
1968 DC *dc = DC_GetDCPtr(hdc);
1969 DWORD ret = GDI_ERROR;
1970
1971 TRACE("(%p, %s, %d, %p, 0x%lx)\n",
1972 hdc, debugstr_wn(lpstr, count), count, pgi, flags);
1973
1974 if(!dc) return GDI_ERROR;
1975
1976 if(dc->gdiFont)
1977 ret = WineEngGetGlyphIndices(dc->gdiFont, lpstr, count, pgi, flags);
1978
1979 GDI_ReleaseObj(hdc);
1980 return ret;
1981 }
1982
1983 /*************************************************************************
1984 * GetCharacterPlacementA [GDI32.@]
1985 *
1986 * NOTES:
1987 * the web browser control of ie4 calls this with dwFlags=0
1988 */
1989 DWORD WINAPI
1990 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
1991 INT nMaxExtent, GCP_RESULTSA *lpResults,
1992 DWORD dwFlags)
1993 {
1994 WCHAR *lpStringW;
1995 INT uCountW;
1996 GCP_RESULTSW resultsW;
1997 DWORD ret;
1998 UINT font_cp;
1999
2000 TRACE("%s, %d, %d, 0x%08lx\n",
2001 debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
2002
2003 /* both structs are equal in size */
2004 memcpy(&resultsW, lpResults, sizeof(resultsW));
2005
2006 lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
2007 if(lpResults->lpOutString)
2008 resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
2009
2010 ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
2011
2012 if(lpResults->lpOutString) {
2013 WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
2014 lpResults->lpOutString, uCount, NULL, NULL );
2015 }
2016
2017 HeapFree(GetProcessHeap(), 0, lpStringW);
2018 HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
2019
2020 return ret;
2021 }
2022
2023 /*************************************************************************
2024 * GetCharacterPlacementW [GDI32.@]
2025 *
2026 * Retrieve information about a string. This includes the width, reordering,
2027 * Glyphing and so on.
2028 *
2029 * RETURNS
2030 *
2031 * The width and height of the string if successful, 0 if failed.
2032 *
2033 * BUGS
2034 *
2035 * All flags except GCP_REORDER are not yet implemented.
2036 * Reordering is not 100% complient to the Windows BiDi method.
2037 * Caret positioning is not yet implemented for BiDi.
2038 * Classes are not yet implemented.
2039 *
2040 */
2041 DWORD WINAPI
2042 GetCharacterPlacementW(
2043 HDC hdc, /* [in] Device context for which the rendering is to be done */
2044 LPCWSTR lpString, /* [in] The string for which information is to be returned */
2045 INT uCount, /* [in] Number of WORDS in string. */
2046 INT nMaxExtent, /* [in] Maximum extent the string is to take (in HDC logical units) */
2047 GCP_RESULTSW *lpResults,/* [in/out] A pointer to a GCP_RESULTSW struct */
2048 DWORD dwFlags /* [in] Flags specifying how to process the string */
2049 )
2050 {
2051 DWORD ret=0;
2052 SIZE size;
2053 UINT i, nSet;
2054
2055 TRACE("%s, %d, %d, 0x%08lx\n",
2056 debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
2057
2058 TRACE("lStructSize=%ld, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
2059 "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
2060 lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
2061 lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
2062 lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
2063
2064 if(dwFlags&(~GCP_REORDER)) FIXME("flags 0x%08lx ignored\n", dwFlags);
2065 if(lpResults->lpClass) FIXME("classes not implemented\n");
2066 if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
2067 FIXME("Caret positions for complex scripts not implemented\n");
2068
2069 nSet = (UINT)uCount;
2070 if(nSet > lpResults->nGlyphs)
2071 nSet = lpResults->nGlyphs;
2072
2073 /* return number of initialized fields */
2074 lpResults->nGlyphs = nSet;
2075
2076 if((dwFlags&GCP_REORDER)==0 || !BidiAvail)
2077 {
2078 /* Treat the case where no special handling was requested in a fastpath way */
2079 /* copy will do if the GCP_REORDER flag is not set */
2080 if(lpResults->lpOutString)
2081 strncpyW( lpResults->lpOutString, lpString, nSet );
2082
2083 if(lpResults->lpOrder)
2084 {
2085 for(i = 0; i < nSet; i++)
2086 lpResults->lpOrder[i] = i;
2087 }
2088 } else
2089 {
2090 BIDI_Reorder( lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
2091 nSet, lpResults->lpOrder );
2092 }
2093
2094 /* FIXME: Will use the placement chars */
2095 if (lpResults->lpDx)
2096 {
2097 int c;
2098 for (i = 0; i < nSet; i++)
2099 {
2100 if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
2101 lpResults->lpDx[i]= c;
2102 }
2103 }
2104
2105 if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
2106 {
2107 int pos = 0;
2108
2109 lpResults->lpCaretPos[0] = 0;
2110 for (i = 1; i < nSet; i++)
2111 if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
2112 lpResults->lpCaretPos[i] = (pos += size.cx);
2113 }
2114
2115 if(lpResults->lpGlyphs)
2116 GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
2117
2118 if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
2119 ret = MAKELONG(size.cx, size.cy);
2120
2121 return ret;
2122 }
2123
2124 /*************************************************************************
2125 * GetCharABCWidthsFloatA [GDI32.@]
2126 */
2127 BOOL WINAPI GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar,
2128 LPABCFLOAT lpABCF)
2129 {
2130 FIXME_(gdi)("GetCharABCWidthsFloatA, stub\n");
2131 return 0;
2132 }
2133
2134 /*************************************************************************
2135 * GetCharABCWidthsFloatW [GDI32.@]
2136 */
2137 BOOL WINAPI GetCharABCWidthsFloatW(HDC hdc, UINT iFirstChar,
2138 UINT iLastChar, LPABCFLOAT lpABCF)
2139 {
2140 FIXME_(gdi)("GetCharABCWidthsFloatW, stub\n");
2141 return 0;
2142 }
2143
2144 /*************************************************************************
2145 * GetCharWidthFloatA [GDI32.@]
2146 */
2147 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
2148 UINT iLastChar, PFLOAT pxBuffer)
2149 {
2150 FIXME_(gdi)("GetCharWidthFloatA, stub\n");
2151 return 0;
2152 }
2153
2154 /*************************************************************************
2155 * GetCharWidthFloatW [GDI32.@]
2156 */
2157 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
2158 UINT iLastChar, PFLOAT pxBuffer)
2159 {
2160 FIXME_(gdi)("GetCharWidthFloatW, stub\n");
2161 return 0;
2162 }
2163
2164
2165 /***********************************************************************
2166 * *
2167 * Font Resource API *
2168 * *
2169 ***********************************************************************/
2170
2171 /***********************************************************************
2172 * AddFontResourceA (GDI32.@)
2173 */
2174 INT WINAPI AddFontResourceA( LPCSTR str )
2175 {
2176 return AddFontResourceExA( str, 0, NULL);
2177 }
2178
2179 /***********************************************************************
2180 * AddFontResourceW (GDI32.@)
2181 */
2182 INT WINAPI AddFontResourceW( LPCWSTR str )
2183 {
2184 return AddFontResourceExW(str, 0, NULL);
2185 }
2186
2187
2188 /***********************************************************************
2189 * AddFontResourceExA (GDI32.@)
2190 */
2191 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
2192 {
2193 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
2194 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2195 INT ret;
2196
2197 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
2198 ret = AddFontResourceExW(strW, fl, pdv);
2199 HeapFree(GetProcessHeap(), 0, strW);
2200 return ret;
2201 }
2202
2203 /***********************************************************************
2204 * AddFontResourceExW (GDI32.@)
2205 */
2206 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
2207 {
2208 return WineEngAddFontResourceEx(str, fl, pdv);
2209 }
2210
2211 /***********************************************************************
2212 * RemoveFontResourceA (GDI32.@)
2213 */
2214 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
2215 {
2216 return RemoveFontResourceExA(str, 0, 0);
2217 }
2218
2219 /***********************************************************************
2220 * RemoveFontResourceW (GDI32.@)
2221 */
2222 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
2223 {
2224 return RemoveFontResourceExW(str, 0, 0);
2225 }
2226
2227 /***********************************************************************
2228 * RemoveFontResourceExA (GDI32.@)
2229 */
2230 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
2231 {
2232 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
2233 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2234 INT ret;
2235
2236 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
2237 ret = RemoveFontResourceExW(strW, fl, pdv);
2238 HeapFree(GetProcessHeap(), 0, strW);
2239 return ret;
2240 }
2241
2242 /***********************************************************************
2243 * RemoveFontResourceExW (GDI32.@)
2244 */
2245 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
2246 {
2247 return WineEngRemoveFontResourceEx(str, fl, pdv);
2248 }
2249
2250 /***********************************************************************
2251 * GetTextCharset (GDI32.@)
2252 */
2253 UINT WINAPI GetTextCharset(HDC hdc)
2254 {
2255 /* MSDN docs say this is equivalent */
2256 return GetTextCharsetInfo(hdc, NULL, 0);
2257 }
2258
2259 /***********************************************************************
2260 * GetTextCharsetInfo (GDI32.@)
2261 */
2262 UINT WINAPI GetTextCharsetInfo(HDC hdc, LPFONTSIGNATURE fs, DWORD flags)
2263 {
2264 UINT ret = DEFAULT_CHARSET;
2265 DC *dc = DC_GetDCPtr(hdc);
2266
2267 if (!dc) goto done;
2268
2269 if (dc->gdiFont)
2270 ret = WineEngGetTextCharsetInfo(dc->gdiFont, fs, flags);
2271
2272 GDI_ReleaseObj(hdc);
2273
2274 done:
2275 if (ret == DEFAULT_CHARSET && fs)
2276 memset(fs, 0, sizeof(FONTSIGNATURE));
2277 return ret;
2278 }
Maarten's multimedia branch