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