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