?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Where possible directly access the DC instead of using GetCurrentObject().
[wine.git] / dlls / gdi32 / font.c
blob0dad0243ecee9e2ac3fa0ca926e5976689c6f70a
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <limits.h>
27 #include <stdarg.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <assert.h>
31 #include "winerror.h"
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winnls.h"
35 #include "winternl.h"
36 #include "winreg.h"
37 #include "gdi_private.h"
38 #include "wine/exception.h"
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(font);
43
44 /* Device -> World size conversion */
45
46 /* Performs a device to world transformation on the specified width (which
47 * is in integer format).
48 */
49 static inline INT INTERNAL_XDSTOWS(DC *dc, INT width)
50 {
51 double floatWidth;
52
53 /* Perform operation with floating point */
54 floatWidth = (double)width * dc->xformVport2World.eM11;
55 /* Round to integers */
56 return GDI_ROUND(floatWidth);
57 }
58
59 /* Performs a device to world transformation on the specified size (which
60 * is in integer format).
61 */
62 static inline INT INTERNAL_YDSTOWS(DC *dc, INT height)
63 {
64 double floatHeight;
65
66 /* Perform operation with floating point */
67 floatHeight = (double)height * dc->xformVport2World.eM22;
68 /* Round to integers */
69 return GDI_ROUND(floatHeight);
70 }
71
72 /* scale width and height but don't mirror them */
73
74 static inline INT width_to_LP( DC *dc, INT width )
75 {
76 return GDI_ROUND( (double)width * fabs( dc->xformVport2World.eM11 ));
77 }
78
79 static inline INT height_to_LP( DC *dc, INT height )
80 {
81 return GDI_ROUND( (double)height * fabs( dc->xformVport2World.eM22 ));
82 }
83
84 static inline INT INTERNAL_YWSTODS(DC *dc, INT height)
85 {
86 POINT pt[2];
87 pt[0].x = pt[0].y = 0;
88 pt[1].x = 0;
89 pt[1].y = height;
90 lp_to_dp(dc, pt, 2);
91 return pt[1].y - pt[0].y;
92 }
93
94 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, HDC hdc );
95 static INT FONT_GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer );
96 static INT FONT_GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer );
97 static BOOL FONT_DeleteObject( HGDIOBJ handle );
98
99 static const struct gdi_obj_funcs font_funcs =
100 {
101 FONT_SelectObject, /* pSelectObject */
102 FONT_GetObjectA, /* pGetObjectA */
103 FONT_GetObjectW, /* pGetObjectW */
104 NULL, /* pUnrealizeObject */
105 FONT_DeleteObject /* pDeleteObject */
106 };
107
108 typedef struct
109 {
110 LOGFONTW logfont;
111 } FONTOBJ;
112
113 struct font_enum
114 {
115 LPLOGFONTW lpLogFontParam;
116 FONTENUMPROCW lpEnumFunc;
117 LPARAM lpData;
118 BOOL unicode;
119 HDC hdc;
120 INT retval;
121 };
122
123 /*
124 * For TranslateCharsetInfo
125 */
126 #define MAXTCIINDEX 32
127 static const CHARSETINFO FONT_tci[MAXTCIINDEX] = {
128 /* ANSI */
129 { ANSI_CHARSET, 1252, {{0,0,0,0},{FS_LATIN1,0}} },
130 { EASTEUROPE_CHARSET, 1250, {{0,0,0,0},{FS_LATIN2,0}} },
131 { RUSSIAN_CHARSET, 1251, {{0,0,0,0},{FS_CYRILLIC,0}} },
132 { GREEK_CHARSET, 1253, {{0,0,0,0},{FS_GREEK,0}} },
133 { TURKISH_CHARSET, 1254, {{0,0,0,0},{FS_TURKISH,0}} },
134 { HEBREW_CHARSET, 1255, {{0,0,0,0},{FS_HEBREW,0}} },
135 { ARABIC_CHARSET, 1256, {{0,0,0,0},{FS_ARABIC,0}} },
136 { BALTIC_CHARSET, 1257, {{0,0,0,0},{FS_BALTIC,0}} },
137 { VIETNAMESE_CHARSET, 1258, {{0,0,0,0},{FS_VIETNAMESE,0}} },
138 /* reserved by ANSI */
139 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
140 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
141 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
142 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
143 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
144 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
145 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
146 /* ANSI and OEM */
147 { THAI_CHARSET, 874, {{0,0,0,0},{FS_THAI,0}} },
148 { SHIFTJIS_CHARSET, 932, {{0,0,0,0},{FS_JISJAPAN,0}} },
149 { GB2312_CHARSET, 936, {{0,0,0,0},{FS_CHINESESIMP,0}} },
150 { HANGEUL_CHARSET, 949, {{0,0,0,0},{FS_WANSUNG,0}} },
151 { CHINESEBIG5_CHARSET, 950, {{0,0,0,0},{FS_CHINESETRAD,0}} },
152 { JOHAB_CHARSET, 1361, {{0,0,0,0},{FS_JOHAB,0}} },
153 /* reserved for alternate ANSI and OEM */
154 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
155 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
156 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
157 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
158 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
159 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
160 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
161 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
162 /* reserved for system */
163 { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
164 { SYMBOL_CHARSET, CP_SYMBOL, {{0,0,0,0},{FS_SYMBOL,0}} }
165 };
166
167 static void FONT_LogFontAToW( const LOGFONTA *fontA, LPLOGFONTW fontW )
168 {
169 memcpy(fontW, fontA, sizeof(LOGFONTA) - LF_FACESIZE);
170 MultiByteToWideChar(CP_ACP, 0, fontA->lfFaceName, -1, fontW->lfFaceName,
171 LF_FACESIZE);
172 fontW->lfFaceName[LF_FACESIZE-1] = 0;
173 }
174
175 static void FONT_LogFontWToA( const LOGFONTW *fontW, LPLOGFONTA fontA )
176 {
177 memcpy(fontA, fontW, sizeof(LOGFONTA) - LF_FACESIZE);
178 WideCharToMultiByte(CP_ACP, 0, fontW->lfFaceName, -1, fontA->lfFaceName,
179 LF_FACESIZE, NULL, NULL);
180 fontA->lfFaceName[LF_FACESIZE-1] = 0;
181 }
182
183 static void FONT_EnumLogFontExWToA( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEXA fontA )
184 {
185 FONT_LogFontWToA( &fontW->elfLogFont, &fontA->elfLogFont );
186
187 WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
188 (LPSTR) fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL );
189 fontA->elfFullName[LF_FULLFACESIZE-1] = '\0';
190 WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
191 (LPSTR) fontA->elfStyle, LF_FACESIZE, NULL, NULL );
192 fontA->elfStyle[LF_FACESIZE-1] = '\0';
193 WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
194 (LPSTR) fontA->elfScript, LF_FACESIZE, NULL, NULL );
195 fontA->elfScript[LF_FACESIZE-1] = '\0';
196 }
197
198 static void FONT_EnumLogFontExAToW( const ENUMLOGFONTEXA *fontA, LPENUMLOGFONTEXW fontW )
199 {
200 FONT_LogFontAToW( &fontA->elfLogFont, &fontW->elfLogFont );
201
202 MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfFullName, -1,
203 fontW->elfFullName, LF_FULLFACESIZE );
204 fontW->elfFullName[LF_FULLFACESIZE-1] = '\0';
205 MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfStyle, -1,
206 fontW->elfStyle, LF_FACESIZE );
207 fontW->elfStyle[LF_FACESIZE-1] = '\0';
208 MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfScript, -1,
209 fontW->elfScript, LF_FACESIZE );
210 fontW->elfScript[LF_FACESIZE-1] = '\0';
211 }
212
213 /***********************************************************************
214 * TEXTMETRIC conversion functions.
215 */
216 static void FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA )
217 {
218 ptmA->tmHeight = ptmW->tmHeight;
219 ptmA->tmAscent = ptmW->tmAscent;
220 ptmA->tmDescent = ptmW->tmDescent;
221 ptmA->tmInternalLeading = ptmW->tmInternalLeading;
222 ptmA->tmExternalLeading = ptmW->tmExternalLeading;
223 ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
224 ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
225 ptmA->tmWeight = ptmW->tmWeight;
226 ptmA->tmOverhang = ptmW->tmOverhang;
227 ptmA->tmDigitizedAspectX = ptmW->tmDigitizedAspectX;
228 ptmA->tmDigitizedAspectY = ptmW->tmDigitizedAspectY;
229 ptmA->tmFirstChar = min(ptmW->tmFirstChar, 255);
230 if (ptmW->tmCharSet == SYMBOL_CHARSET)
231 {
232 ptmA->tmFirstChar = 0x1e;
233 ptmA->tmLastChar = 0xff; /* win9x behaviour - we need the OS2 table data to calculate correctly */
234 }
235 else if (ptmW->tmPitchAndFamily & TMPF_TRUETYPE)
236 {
237 ptmA->tmFirstChar = ptmW->tmDefaultChar - 1;
238 ptmA->tmLastChar = min(ptmW->tmLastChar, 0xff);
239 }
240 else
241 {
242 ptmA->tmFirstChar = min(ptmW->tmFirstChar, 0xff);
243 ptmA->tmLastChar = min(ptmW->tmLastChar, 0xff);
244 }
245 ptmA->tmDefaultChar = ptmW->tmDefaultChar;
246 ptmA->tmBreakChar = ptmW->tmBreakChar;
247 ptmA->tmItalic = ptmW->tmItalic;
248 ptmA->tmUnderlined = ptmW->tmUnderlined;
249 ptmA->tmStruckOut = ptmW->tmStruckOut;
250 ptmA->tmPitchAndFamily = ptmW->tmPitchAndFamily;
251 ptmA->tmCharSet = ptmW->tmCharSet;
252 }
253
254
255 static void FONT_NewTextMetricExWToA(const NEWTEXTMETRICEXW *ptmW, NEWTEXTMETRICEXA *ptmA )
256 {
257 FONT_TextMetricWToA((const TEXTMETRICW *)ptmW, (LPTEXTMETRICA)ptmA);
258 ptmA->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
259 ptmA->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
260 ptmA->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
261 ptmA->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
262 memcpy(&ptmA->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
263 }
264
265 static DWORD get_key_value( HKEY key, const WCHAR *name, DWORD *value )
266 {
267 WCHAR buf[12];
268 DWORD count = sizeof(buf), type, err;
269
270 err = RegQueryValueExW( key, name, NULL, &type, (BYTE *)buf, &count );
271 if (!err)
272 {
273 if (type == REG_DWORD) memcpy( value, buf, sizeof(*value) );
274 else *value = atoiW( buf );
275 }
276 return err;
277 }
278
279 static UINT get_subpixel_orientation( HKEY key )
280 {
281 static const WCHAR smoothing_orientation[] = {'F','o','n','t','S','m','o','o','t','h','i','n','g',
282 'O','r','i','e','n','t','a','t','i','o','n',0};
283 DWORD orient;
284
285 /* FIXME: handle vertical orientations even though Windows doesn't */
286 if (get_key_value( key, smoothing_orientation, &orient )) return GGO_GRAY4_BITMAP;
287
288 switch (orient)
289 {
290 case 0: /* FE_FONTSMOOTHINGORIENTATIONBGR */
291 return WINE_GGO_HBGR_BITMAP;
292 case 1: /* FE_FONTSMOOTHINGORIENTATIONRGB */
293 return WINE_GGO_HRGB_BITMAP;
294 }
295 return GGO_GRAY4_BITMAP;
296 }
297
298 static UINT get_default_smoothing( HKEY key )
299 {
300 static const WCHAR smoothing[] = {'F','o','n','t','S','m','o','o','t','h','i','n','g',0};
301 static const WCHAR smoothing_type[] = {'F','o','n','t','S','m','o','o','t','h','i','n','g','T','y','p','e',0};
302 DWORD enabled, type;
303
304 if (get_key_value( key, smoothing, &enabled )) return 0;
305 if (!enabled) return GGO_BITMAP;
306
307 if (!get_key_value( key, smoothing_type, &type ) && type == 2 /* FE_FONTSMOOTHINGCLEARTYPE */)
308 return get_subpixel_orientation( key );
309
310 return GGO_GRAY4_BITMAP;
311 }
312
313 /* compute positions for text rendering, in device coords */
314 static BOOL get_char_positions( DC *dc, const WCHAR *str, INT count, INT *dx, SIZE *size )
315 {
316 TEXTMETRICW tm;
317 PHYSDEV dev;
318
319 size->cx = size->cy = 0;
320 if (!count) return TRUE;
321
322 dev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
323 dev->funcs->pGetTextMetrics( dev, &tm );
324
325 dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPoint );
326 if (!dev->funcs->pGetTextExtentExPoint( dev, str, count, dx )) return FALSE;
327
328 if (dc->breakExtra || dc->breakRem)
329 {
330 int i, space = 0, rem = dc->breakRem;
331
332 for (i = 0; i < count; i++)
333 {
334 if (str[i] == tm.tmBreakChar)
335 {
336 space += dc->breakExtra;
337 if (rem > 0)
338 {
339 space++;
340 rem--;
341 }
342 }
343 dx[i] += space;
344 }
345 }
346 size->cx = dx[count - 1];
347 size->cy = tm.tmHeight;
348 return TRUE;
349 }
350
351 /* compute positions for text rendering, in device coords */
352 static BOOL get_char_positions_indices( DC *dc, const WORD *indices, INT count, INT *dx, SIZE *size )
353 {
354 TEXTMETRICW tm;
355 PHYSDEV dev;
356
357 size->cx = size->cy = 0;
358 if (!count) return TRUE;
359
360 dev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
361 dev->funcs->pGetTextMetrics( dev, &tm );
362
363 dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPointI );
364 if (!dev->funcs->pGetTextExtentExPointI( dev, indices, count, dx )) return FALSE;
365
366 if (dc->breakExtra || dc->breakRem)
367 {
368 WORD space_index;
369 int i, space = 0, rem = dc->breakRem;
370
371 dev = GET_DC_PHYSDEV( dc, pGetGlyphIndices );
372 dev->funcs->pGetGlyphIndices( dev, &tm.tmBreakChar, 1, &space_index, 0 );
373
374 for (i = 0; i < count; i++)
375 {
376 if (indices[i] == space_index)
377 {
378 space += dc->breakExtra;
379 if (rem > 0)
380 {
381 space++;
382 rem--;
383 }
384 }
385 dx[i] += space;
386 }
387 }
388 size->cx = dx[count - 1];
389 size->cy = tm.tmHeight;
390 return TRUE;
391 }
392
393 /***********************************************************************
394 * GdiGetCodePage (GDI32.@)
395 */
396 DWORD WINAPI GdiGetCodePage( HDC hdc )
397 {
398 UINT cp = CP_ACP;
399 DC *dc = get_dc_ptr( hdc );
400
401 if (dc)
402 {
403 cp = dc->font_code_page;
404 release_dc_ptr( dc );
405 }
406 return cp;
407 }
408
409 /***********************************************************************
410 * get_text_charset_info
411 *
412 * Internal version of GetTextCharsetInfo() that takes a DC pointer.
413 */
414 static UINT get_text_charset_info(DC *dc, FONTSIGNATURE *fs, DWORD flags)
415 {
416 UINT ret = DEFAULT_CHARSET;
417 PHYSDEV dev;
418
419 dev = GET_DC_PHYSDEV( dc, pGetTextCharsetInfo );
420 ret = dev->funcs->pGetTextCharsetInfo( dev, fs, flags );
421
422 if (ret == DEFAULT_CHARSET && fs)
423 memset(fs, 0, sizeof(FONTSIGNATURE));
424 return ret;
425 }
426
427 /***********************************************************************
428 * GetTextCharsetInfo (GDI32.@)
429 */
430 UINT WINAPI GetTextCharsetInfo(HDC hdc, FONTSIGNATURE *fs, DWORD flags)
431 {
432 UINT ret = DEFAULT_CHARSET;
433 DC *dc = get_dc_ptr(hdc);
434
435 if (dc)
436 {
437 ret = get_text_charset_info( dc, fs, flags );
438 release_dc_ptr( dc );
439 }
440 return ret;
441 }
442
443 /***********************************************************************
444 * FONT_mbtowc
445 *
446 * Returns a Unicode translation of str using the charset of the
447 * currently selected font in hdc. If count is -1 then str is assumed
448 * to be '\0' terminated, otherwise it contains the number of bytes to
449 * convert. If plenW is non-NULL, on return it will point to the
450 * number of WCHARs that have been written. If pCP is non-NULL, on
451 * return it will point to the codepage used in the conversion. The
452 * caller should free the returned LPWSTR from the process heap
453 * itself.
454 */
455 static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
456 {
457 UINT cp;
458 INT lenW;
459 LPWSTR strW;
460
461 cp = GdiGetCodePage( hdc );
462
463 if(count == -1) count = strlen(str);
464 lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
465 strW = HeapAlloc(GetProcessHeap(), 0, lenW*sizeof(WCHAR));
466 MultiByteToWideChar(cp, 0, str, count, strW, lenW);
467 TRACE("mapped %s -> %s\n", debugstr_an(str, count), debugstr_wn(strW, lenW));
468 if(plenW) *plenW = lenW;
469 if(pCP) *pCP = cp;
470 return strW;
471 }
472
473 /***********************************************************************
474 * CreateFontIndirectExA (GDI32.@)
475 */
476 HFONT WINAPI CreateFontIndirectExA( const ENUMLOGFONTEXDVA *penumexA )
477 {
478 ENUMLOGFONTEXDVW enumexW;
479
480 if (!penumexA) return 0;
481
482 FONT_EnumLogFontExAToW( &penumexA->elfEnumLogfontEx, &enumexW.elfEnumLogfontEx );
483 enumexW.elfDesignVector = penumexA->elfDesignVector;
484 return CreateFontIndirectExW( &enumexW );
485 }
486
487 /***********************************************************************
488 * CreateFontIndirectExW (GDI32.@)
489 */
490 HFONT WINAPI CreateFontIndirectExW( const ENUMLOGFONTEXDVW *penumex )
491 {
492 HFONT hFont;
493 FONTOBJ *fontPtr;
494 const LOGFONTW *plf;
495
496 if (!penumex) return 0;
497
498 if (penumex->elfEnumLogfontEx.elfFullName[0] ||
499 penumex->elfEnumLogfontEx.elfStyle[0] ||
500 penumex->elfEnumLogfontEx.elfScript[0])
501 {
502 FIXME("some fields ignored. fullname=%s, style=%s, script=%s\n",
503 debugstr_w(penumex->elfEnumLogfontEx.elfFullName),
504 debugstr_w(penumex->elfEnumLogfontEx.elfStyle),
505 debugstr_w(penumex->elfEnumLogfontEx.elfScript));
506 }
507
508 plf = &penumex->elfEnumLogfontEx.elfLogFont;
509 if (!(fontPtr = HeapAlloc( GetProcessHeap(), 0, sizeof(*fontPtr) ))) return 0;
510
511 fontPtr->logfont = *plf;
512
513 if (!(hFont = alloc_gdi_handle( fontPtr, OBJ_FONT, &font_funcs )))
514 {
515 HeapFree( GetProcessHeap(), 0, fontPtr );
516 return 0;
517 }
518
519 TRACE("(%d %d %d %d %x %d %x %d %d) %s %s %s %s => %p\n",
520 plf->lfHeight, plf->lfWidth,
521 plf->lfEscapement, plf->lfOrientation,
522 plf->lfPitchAndFamily,
523 plf->lfOutPrecision, plf->lfClipPrecision,
524 plf->lfQuality, plf->lfCharSet,
525 debugstr_w(plf->lfFaceName),
526 plf->lfWeight > 400 ? "Bold" : "",
527 plf->lfItalic ? "Italic" : "",
528 plf->lfUnderline ? "Underline" : "", hFont);
529
530 return hFont;
531 }
532
533 /***********************************************************************
534 * CreateFontIndirectA (GDI32.@)
535 */
536 HFONT WINAPI CreateFontIndirectA( const LOGFONTA *plfA )
537 {
538 LOGFONTW lfW;
539
540 if (!plfA) return 0;
541
542 FONT_LogFontAToW( plfA, &lfW );
543 return CreateFontIndirectW( &lfW );
544 }
545
546 /***********************************************************************
547 * CreateFontIndirectW (GDI32.@)
548 */
549 HFONT WINAPI CreateFontIndirectW( const LOGFONTW *plf )
550 {
551 ENUMLOGFONTEXDVW exdv;
552
553 if (!plf) return 0;
554
555 exdv.elfEnumLogfontEx.elfLogFont = *plf;
556 exdv.elfEnumLogfontEx.elfFullName[0] = 0;
557 exdv.elfEnumLogfontEx.elfStyle[0] = 0;
558 exdv.elfEnumLogfontEx.elfScript[0] = 0;
559 return CreateFontIndirectExW( &exdv );
560 }
561
562 /*************************************************************************
563 * CreateFontA (GDI32.@)
564 */
565 HFONT WINAPI CreateFontA( INT height, INT width, INT esc,
566 INT orient, INT weight, DWORD italic,
567 DWORD underline, DWORD strikeout, DWORD charset,
568 DWORD outpres, DWORD clippres, DWORD quality,
569 DWORD pitch, LPCSTR name )
570 {
571 LOGFONTA logfont;
572
573 logfont.lfHeight = height;
574 logfont.lfWidth = width;
575 logfont.lfEscapement = esc;
576 logfont.lfOrientation = orient;
577 logfont.lfWeight = weight;
578 logfont.lfItalic = italic;
579 logfont.lfUnderline = underline;
580 logfont.lfStrikeOut = strikeout;
581 logfont.lfCharSet = charset;
582 logfont.lfOutPrecision = outpres;
583 logfont.lfClipPrecision = clippres;
584 logfont.lfQuality = quality;
585 logfont.lfPitchAndFamily = pitch;
586
587 if (name)
588 lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
589 else
590 logfont.lfFaceName[0] = '\0';
591
592 return CreateFontIndirectA( &logfont );
593 }
594
595 /*************************************************************************
596 * CreateFontW (GDI32.@)
597 */
598 HFONT WINAPI CreateFontW( INT height, INT width, INT esc,
599 INT orient, INT weight, DWORD italic,
600 DWORD underline, DWORD strikeout, DWORD charset,
601 DWORD outpres, DWORD clippres, DWORD quality,
602 DWORD pitch, LPCWSTR name )
603 {
604 LOGFONTW logfont;
605
606 logfont.lfHeight = height;
607 logfont.lfWidth = width;
608 logfont.lfEscapement = esc;
609 logfont.lfOrientation = orient;
610 logfont.lfWeight = weight;
611 logfont.lfItalic = italic;
612 logfont.lfUnderline = underline;
613 logfont.lfStrikeOut = strikeout;
614 logfont.lfCharSet = charset;
615 logfont.lfOutPrecision = outpres;
616 logfont.lfClipPrecision = clippres;
617 logfont.lfQuality = quality;
618 logfont.lfPitchAndFamily = pitch;
619
620 if (name)
621 lstrcpynW(logfont.lfFaceName, name,
622 sizeof(logfont.lfFaceName) / sizeof(WCHAR));
623 else
624 logfont.lfFaceName[0] = '\0';
625
626 return CreateFontIndirectW( &logfont );
627 }
628
629 #define ASSOC_CHARSET_OEM 1
630 #define ASSOC_CHARSET_ANSI 2
631 #define ASSOC_CHARSET_SYMBOL 4
632
633 static DWORD get_associated_charset_info(void)
634 {
635 static DWORD associated_charset = -1;
636
637 if (associated_charset == -1)
638 {
639 static const WCHAR assoc_charset_reg_keyW[] = {'S','y','s','t','e','m','\\',
640 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
641 'C','o','n','t','r','o','l','\\','F','o','n','t','A','s','s','o','c','\\',
642 'A','s','s','o','c','i','a','t','e','d',' ','C','h','a','r','s','e','t','\0'};
643 static const WCHAR ansiW[] = {'A','N','S','I','(','0','0',')','\0'};
644 static const WCHAR oemW[] = {'O','E','M','(','F','F',')','\0'};
645 static const WCHAR symbolW[] = {'S','Y','M','B','O','L','(','0','2',')','\0'};
646 static const WCHAR yesW[] = {'Y','E','S','\0'};
647 HKEY hkey;
648 WCHAR dataW[32];
649 DWORD type, data_len;
650
651 associated_charset = 0;
652
653 if (RegOpenKeyW(HKEY_LOCAL_MACHINE,
654 assoc_charset_reg_keyW, &hkey) != ERROR_SUCCESS)
655 return 0;
656
657 data_len = sizeof(dataW);
658 if (!RegQueryValueExW(hkey, ansiW, NULL, &type, (LPBYTE)dataW, &data_len) &&
659 type == REG_SZ && !strcmpiW(dataW, yesW))
660 associated_charset |= ASSOC_CHARSET_ANSI;
661
662 data_len = sizeof(dataW);
663 if (!RegQueryValueExW(hkey, oemW, NULL, &type, (LPBYTE)dataW, &data_len) &&
664 type == REG_SZ && !strcmpiW(dataW, yesW))
665 associated_charset |= ASSOC_CHARSET_OEM;
666
667 data_len = sizeof(dataW);
668 if (!RegQueryValueExW(hkey, symbolW, NULL, &type, (LPBYTE)dataW, &data_len) &&
669 type == REG_SZ && !strcmpiW(dataW, yesW))
670 associated_charset |= ASSOC_CHARSET_SYMBOL;
671
672 RegCloseKey(hkey);
673
674 TRACE("associated_charset = %d\n", associated_charset);
675 }
676
677 return associated_charset;
678 }
679
680 static void update_font_code_page( DC *dc, HANDLE font )
681 {
682 CHARSETINFO csi;
683 int charset = get_text_charset_info( dc, NULL, 0 );
684
685 if (charset == ANSI_CHARSET && get_associated_charset_info() & ASSOC_CHARSET_ANSI)
686 {
687 LOGFONTW lf;
688
689 GetObjectW( font, sizeof(lf), &lf );
690 if (!(lf.lfClipPrecision & CLIP_DFA_DISABLE))
691 charset = DEFAULT_CHARSET;
692 }
693
694 /* Hmm, nicely designed api this one! */
695 if (TranslateCharsetInfo( ULongToPtr(charset), &csi, TCI_SRCCHARSET) )
696 dc->font_code_page = csi.ciACP;
697 else {
698 switch(charset) {
699 case OEM_CHARSET:
700 dc->font_code_page = GetOEMCP();
701 break;
702 case DEFAULT_CHARSET:
703 dc->font_code_page = GetACP();
704 break;
705
706 case VISCII_CHARSET:
707 case TCVN_CHARSET:
708 case KOI8_CHARSET:
709 case ISO3_CHARSET:
710 case ISO4_CHARSET:
711 case ISO10_CHARSET:
712 case CELTIC_CHARSET:
713 /* FIXME: These have no place here, but because x11drv
714 enumerates fonts with these (made up) charsets some apps
715 might use them and then the FIXME below would become
716 annoying. Now we could pick the intended codepage for
717 each of these, but since it's broken anyway we'll just
718 use CP_ACP and hope it'll go away...
719 */
720 dc->font_code_page = CP_ACP;
721 break;
722
723 default:
724 FIXME("Can't find codepage for charset %d\n", charset);
725 dc->font_code_page = CP_ACP;
726 break;
727 }
728 }
729
730 TRACE("charset %d => cp %d\n", charset, dc->font_code_page);
731 }
732
733 /***********************************************************************
734 * FONT_SelectObject
735 */
736 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, HDC hdc )
737 {
738 HGDIOBJ ret = 0;
739 DC *dc = get_dc_ptr( hdc );
740 PHYSDEV physdev;
741 UINT aa_flags = 0;
742
743 if (!dc) return 0;
744
745 if (!GDI_inc_ref_count( handle ))
746 {
747 release_dc_ptr( dc );
748 return 0;
749 }
750
751 physdev = GET_DC_PHYSDEV( dc, pSelectFont );
752 if (physdev->funcs->pSelectFont( physdev, handle, &aa_flags ))
753 {
754 ret = dc->hFont;
755 dc->hFont = handle;
756 dc->aa_flags = aa_flags ? aa_flags : GGO_BITMAP;
757 update_font_code_page( dc, handle );
758 GDI_dec_ref_count( ret );
759 }
760 else GDI_dec_ref_count( handle );
761
762 release_dc_ptr( dc );
763 return ret;
764 }
765
766
767 /***********************************************************************
768 * FONT_GetObjectA
769 */
770 static INT FONT_GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer )
771 {
772 FONTOBJ *font = GDI_GetObjPtr( handle, OBJ_FONT );
773 LOGFONTA lfA;
774
775 if (!font) return 0;
776 if (buffer)
777 {
778 FONT_LogFontWToA( &font->logfont, &lfA );
779 if (count > sizeof(lfA)) count = sizeof(lfA);
780 memcpy( buffer, &lfA, count );
781 }
782 else count = sizeof(lfA);
783 GDI_ReleaseObj( handle );
784 return count;
785 }
786
787 /***********************************************************************
788 * FONT_GetObjectW
789 */
790 static INT FONT_GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer )
791 {
792 FONTOBJ *font = GDI_GetObjPtr( handle, OBJ_FONT );
793
794 if (!font) return 0;
795 if (buffer)
796 {
797 if (count > sizeof(LOGFONTW)) count = sizeof(LOGFONTW);
798 memcpy( buffer, &font->logfont, count );
799 }
800 else count = sizeof(LOGFONTW);
801 GDI_ReleaseObj( handle );
802 return count;
803 }
804
805
806 /***********************************************************************
807 * FONT_DeleteObject
808 */
809 static BOOL FONT_DeleteObject( HGDIOBJ handle )
810 {
811 FONTOBJ *obj;
812
813 if (!(obj = free_gdi_handle( handle ))) return FALSE;
814 return HeapFree( GetProcessHeap(), 0, obj );
815 }
816
817
818 /***********************************************************************
819 * nulldrv_SelectFont
820 */
821 HFONT nulldrv_SelectFont( PHYSDEV dev, HFONT font, UINT *aa_flags )
822 {
823 static const WCHAR desktopW[] = { 'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
824 'D','e','s','k','t','o','p',0 };
825 static int orientation = -1, smoothing = -1;
826 LOGFONTW lf;
827 HKEY key;
828
829 if (*aa_flags) return 0;
830
831 GetObjectW( font, sizeof(lf), &lf );
832 switch (lf.lfQuality)
833 {
834 case NONANTIALIASED_QUALITY:
835 *aa_flags = GGO_BITMAP;
836 break;
837 case ANTIALIASED_QUALITY:
838 *aa_flags = GGO_GRAY4_BITMAP;
839 break;
840 case CLEARTYPE_QUALITY:
841 case CLEARTYPE_NATURAL_QUALITY:
842 if (orientation == -1)
843 {
844 if (RegOpenKeyW( HKEY_CURRENT_USER, desktopW, &key )) break;
845 orientation = get_subpixel_orientation( key );
846 RegCloseKey( key );
847 }
848 *aa_flags = orientation;
849 break;
850 default:
851 if (smoothing == -1)
852 {
853 if (RegOpenKeyW( HKEY_CURRENT_USER, desktopW, &key )) break;
854 smoothing = get_default_smoothing( key );
855 RegCloseKey( key );
856 }
857 *aa_flags = smoothing;
858 break;
859 }
860 return 0;
861 }
862
863
864 /***********************************************************************
865 * FONT_EnumInstance
866 *
867 * Note: plf is really an ENUMLOGFONTEXW, and ptm is a NEWTEXTMETRICEXW.
868 * We have to use other types because of the FONTENUMPROCW definition.
869 */
870 static INT CALLBACK FONT_EnumInstance( const LOGFONTW *plf, const TEXTMETRICW *ptm,
871 DWORD fType, LPARAM lp )
872 {
873 struct font_enum *pfe = (struct font_enum *)lp;
874 INT ret = 1;
875
876 /* lfCharSet is at the same offset in both LOGFONTA and LOGFONTW */
877 if ((!pfe->lpLogFontParam ||
878 pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
879 pfe->lpLogFontParam->lfCharSet == plf->lfCharSet) &&
880 (!(fType & RASTER_FONTTYPE) || GetDeviceCaps(pfe->hdc, TEXTCAPS) & TC_RA_ABLE) )
881 {
882 /* convert font metrics */
883 ENUMLOGFONTEXA logfont;
884 NEWTEXTMETRICEXA tmA;
885
886 if (!pfe->unicode)
887 {
888 FONT_EnumLogFontExWToA( (const ENUMLOGFONTEXW *)plf, &logfont);
889 FONT_NewTextMetricExWToA( (const NEWTEXTMETRICEXW *)ptm, &tmA );
890 plf = (LOGFONTW *)&logfont.elfLogFont;
891 ptm = (TEXTMETRICW *)&tmA;
892 }
893 ret = pfe->lpEnumFunc( plf, ptm, fType, pfe->lpData );
894 pfe->retval = ret;
895 }
896 return ret;
897 }
898
899 /***********************************************************************
900 * FONT_EnumFontFamiliesEx
901 */
902 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf, FONTENUMPROCW efproc,
903 LPARAM lParam, BOOL unicode )
904 {
905 INT ret = 0;
906 DC *dc = get_dc_ptr( hDC );
907 struct font_enum fe;
908
909 if (dc)
910 {
911 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pEnumFonts );
912
913 if (plf) TRACE("lfFaceName = %s lfCharset = %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
914 fe.lpLogFontParam = plf;
915 fe.lpEnumFunc = efproc;
916 fe.lpData = lParam;
917 fe.unicode = unicode;
918 fe.hdc = hDC;
919 fe.retval = 1;
920 ret = physdev->funcs->pEnumFonts( physdev, plf, FONT_EnumInstance, (LPARAM)&fe );
921 release_dc_ptr( dc );
922 }
923 return ret ? fe.retval : 0;
924 }
925
926 /***********************************************************************
927 * EnumFontFamiliesExW (GDI32.@)
928 */
929 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
930 FONTENUMPROCW efproc,
931 LPARAM lParam, DWORD dwFlags )
932 {
933 return FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, TRUE );
934 }
935
936 /***********************************************************************
937 * EnumFontFamiliesExA (GDI32.@)
938 */
939 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
940 FONTENUMPROCA efproc,
941 LPARAM lParam, DWORD dwFlags)
942 {
943 LOGFONTW lfW, *plfW;
944
945 if (plf)
946 {
947 FONT_LogFontAToW( plf, &lfW );
948 plfW = &lfW;
949 }
950 else plfW = NULL;
951
952 return FONT_EnumFontFamiliesEx( hDC, plfW, (FONTENUMPROCW)efproc, lParam, FALSE );
953 }
954
955 /***********************************************************************
956 * EnumFontFamiliesA (GDI32.@)
957 */
958 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
959 FONTENUMPROCA efproc, LPARAM lpData )
960 {
961 LOGFONTA lf, *plf;
962
963 if (lpFamily)
964 {
965 if (!*lpFamily) return 1;
966 lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
967 lf.lfCharSet = DEFAULT_CHARSET;
968 lf.lfPitchAndFamily = 0;
969 plf = &lf;
970 }
971 else plf = NULL;
972
973 return EnumFontFamiliesExA( hDC, plf, efproc, lpData, 0 );
974 }
975
976 /***********************************************************************
977 * EnumFontFamiliesW (GDI32.@)
978 */
979 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
980 FONTENUMPROCW efproc, LPARAM lpData )
981 {
982 LOGFONTW lf, *plf;
983
984 if (lpFamily)
985 {
986 if (!*lpFamily) return 1;
987 lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
988 lf.lfCharSet = DEFAULT_CHARSET;
989 lf.lfPitchAndFamily = 0;
990 plf = &lf;
991 }
992 else plf = NULL;
993
994 return EnumFontFamiliesExW( hDC, plf, efproc, lpData, 0 );
995 }
996
997 /***********************************************************************
998 * EnumFontsA (GDI32.@)
999 */
1000 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
1001 LPARAM lpData )
1002 {
1003 return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
1004 }
1005
1006 /***********************************************************************
1007 * EnumFontsW (GDI32.@)
1008 */
1009 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
1010 LPARAM lpData )
1011 {
1012 return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
1013 }
1014
1015
1016 /***********************************************************************
1017 * GetTextCharacterExtra (GDI32.@)
1018 */
1019 INT WINAPI GetTextCharacterExtra( HDC hdc )
1020 {
1021 INT ret;
1022 DC *dc = get_dc_ptr( hdc );
1023 if (!dc) return 0x80000000;
1024 ret = dc->charExtra;
1025 release_dc_ptr( dc );
1026 return ret;
1027 }
1028
1029
1030 /***********************************************************************
1031 * SetTextCharacterExtra (GDI32.@)
1032 */
1033 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
1034 {
1035 INT ret = 0x80000000;
1036 DC * dc = get_dc_ptr( hdc );
1037
1038 if (dc)
1039 {
1040 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextCharacterExtra );
1041 extra = physdev->funcs->pSetTextCharacterExtra( physdev, extra );
1042 if (extra != 0x80000000)
1043 {
1044 ret = dc->charExtra;
1045 dc->charExtra = extra;
1046 }
1047 release_dc_ptr( dc );
1048 }
1049 return ret;
1050 }
1051
1052
1053 /***********************************************************************
1054 * SetTextJustification (GDI32.@)
1055 */
1056 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
1057 {
1058 BOOL ret;
1059 PHYSDEV physdev;
1060 DC * dc = get_dc_ptr( hdc );
1061
1062 if (!dc) return FALSE;
1063
1064 physdev = GET_DC_PHYSDEV( dc, pSetTextJustification );
1065 ret = physdev->funcs->pSetTextJustification( physdev, extra, breaks );
1066 if (ret)
1067 {
1068 extra = abs((extra * dc->vport_ext.cx + dc->wnd_ext.cx / 2) / dc->wnd_ext.cx);
1069 if (!extra) breaks = 0;
1070 if (breaks)
1071 {
1072 dc->breakExtra = extra / breaks;
1073 dc->breakRem = extra - (breaks * dc->breakExtra);
1074 }
1075 else
1076 {
1077 dc->breakExtra = 0;
1078 dc->breakRem = 0;
1079 }
1080 }
1081 release_dc_ptr( dc );
1082 return ret;
1083 }
1084
1085
1086 /***********************************************************************
1087 * GetTextFaceA (GDI32.@)
1088 */
1089 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
1090 {
1091 INT res = GetTextFaceW(hdc, 0, NULL);
1092 LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
1093 GetTextFaceW( hdc, res, nameW );
1094
1095 if (name)
1096 {
1097 if (count)
1098 {
1099 res = WideCharToMultiByte(CP_ACP, 0, nameW, -1, name, count, NULL, NULL);
1100 if (res == 0)
1101 res = count;
1102 name[count-1] = 0;
1103 /* GetTextFaceA does NOT include the nul byte in the return count. */
1104 res--;
1105 }
1106 else
1107 res = 0;
1108 }
1109 else
1110 res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
1111 HeapFree( GetProcessHeap(), 0, nameW );
1112 return res;
1113 }
1114
1115 /***********************************************************************
1116 * GetTextFaceW (GDI32.@)
1117 */
1118 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
1119 {
1120 PHYSDEV dev;
1121 INT ret;
1122
1123 DC * dc = get_dc_ptr( hdc );
1124 if (!dc) return 0;
1125
1126 dev = GET_DC_PHYSDEV( dc, pGetTextFace );
1127 ret = dev->funcs->pGetTextFace( dev, count, name );
1128 release_dc_ptr( dc );
1129 return ret;
1130 }
1131
1132
1133 /***********************************************************************
1134 * GetTextExtentPoint32A (GDI32.@)
1135 *
1136 * See GetTextExtentPoint32W.
1137 */
1138 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
1139 LPSIZE size )
1140 {
1141 BOOL ret = FALSE;
1142 INT wlen;
1143 LPWSTR p;
1144
1145 if (count < 0) return FALSE;
1146
1147 p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1148
1149 if (p)
1150 {
1151 ret = GetTextExtentPoint32W( hdc, p, wlen, size );
1152 HeapFree( GetProcessHeap(), 0, p );
1153 }
1154
1155 TRACE("(%p %s %d %p): returning %d x %d\n",
1156 hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
1157 return ret;
1158 }
1159
1160
1161 /***********************************************************************
1162 * GetTextExtentPoint32W [GDI32.@]
1163 *
1164 * Computes width/height for a string.
1165 *
1166 * Computes width and height of the specified string.
1167 *
1168 * RETURNS
1169 * Success: TRUE
1170 * Failure: FALSE
1171 */
1172 BOOL WINAPI GetTextExtentPoint32W(
1173 HDC hdc, /* [in] Handle of device context */
1174 LPCWSTR str, /* [in] Address of text string */
1175 INT count, /* [in] Number of characters in string */
1176 LPSIZE size) /* [out] Address of structure for string size */
1177 {
1178 return GetTextExtentExPointW(hdc, str, count, 0, NULL, NULL, size);
1179 }
1180
1181 /***********************************************************************
1182 * GetTextExtentExPointI [GDI32.@]
1183 *
1184 * Computes width and height of the array of glyph indices.
1185 *
1186 * PARAMS
1187 * hdc [I] Handle of device context.
1188 * indices [I] Glyph index array.
1189 * count [I] Number of glyphs in array.
1190 * max_ext [I] Maximum width in glyphs.
1191 * nfit [O] Maximum number of characters.
1192 * dxs [O] Partial string widths.
1193 * size [O] Returned string size.
1194 *
1195 * RETURNS
1196 * Success: TRUE
1197 * Failure: FALSE
1198 */
1199 BOOL WINAPI GetTextExtentExPointI( HDC hdc, const WORD *indices, INT count, INT max_ext,
1200 LPINT nfit, LPINT dxs, LPSIZE size )
1201 {
1202 DC *dc;
1203 int i;
1204 BOOL ret;
1205 INT buffer[256], *pos = dxs;
1206
1207 if (count < 0) return FALSE;
1208
1209 dc = get_dc_ptr( hdc );
1210 if (!dc) return FALSE;
1211
1212 if (!dxs)
1213 {
1214 pos = buffer;
1215 if (count > 256 && !(pos = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*pos) )))
1216 {
1217 release_dc_ptr( dc );
1218 return FALSE;
1219 }
1220 }
1221
1222 ret = get_char_positions_indices( dc, indices, count, pos, size );
1223 if (ret)
1224 {
1225 if (dxs || nfit)
1226 {
1227 for (i = 0; i < count; i++)
1228 {
1229 unsigned int dx = abs( INTERNAL_XDSTOWS( dc, pos[i] )) + (i + 1) * dc->charExtra;
1230 if (nfit && dx > (unsigned int)max_ext) break;
1231 if (dxs) dxs[i] = dx;
1232 }
1233 if (nfit) *nfit = i;
1234 }
1235
1236 size->cx = abs( INTERNAL_XDSTOWS( dc, size->cx )) + count * dc->charExtra;
1237 size->cy = abs( INTERNAL_YDSTOWS( dc, size->cy ));
1238 }
1239
1240 if (pos != buffer && pos != dxs) HeapFree( GetProcessHeap(), 0, pos );
1241 release_dc_ptr( dc );
1242
1243 TRACE("(%p %p %d %p): returning %d x %d\n",
1244 hdc, indices, count, size, size->cx, size->cy );
1245 return ret;
1246 }
1247
1248 /***********************************************************************
1249 * GetTextExtentPointI [GDI32.@]
1250 *
1251 * Computes width and height of the array of glyph indices.
1252 *
1253 * PARAMS
1254 * hdc [I] Handle of device context.
1255 * indices [I] Glyph index array.
1256 * count [I] Number of glyphs in array.
1257 * size [O] Returned string size.
1258 *
1259 * RETURNS
1260 * Success: TRUE
1261 * Failure: FALSE
1262 */
1263 BOOL WINAPI GetTextExtentPointI( HDC hdc, const WORD *indices, INT count, LPSIZE size )
1264 {
1265 return GetTextExtentExPointI( hdc, indices, count, 0, NULL, NULL, size );
1266 }
1267
1268
1269 /***********************************************************************
1270 * GetTextExtentPointA (GDI32.@)
1271 */
1272 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1273 LPSIZE size )
1274 {
1275 TRACE("not bug compatible.\n");
1276 return GetTextExtentPoint32A( hdc, str, count, size );
1277 }
1278
1279 /***********************************************************************
1280 * GetTextExtentPointW (GDI32.@)
1281 */
1282 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1283 LPSIZE size )
1284 {
1285 TRACE("not bug compatible.\n");
1286 return GetTextExtentPoint32W( hdc, str, count, size );
1287 }
1288
1289
1290 /***********************************************************************
1291 * GetTextExtentExPointA (GDI32.@)
1292 */
1293 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1294 INT maxExt, LPINT lpnFit,
1295 LPINT alpDx, LPSIZE size )
1296 {
1297 BOOL ret;
1298 INT wlen;
1299 INT *walpDx = NULL;
1300 LPWSTR p = NULL;
1301
1302 if (count < 0) return FALSE;
1303 if (maxExt < -1) return FALSE;
1304
1305 if (alpDx)
1306 {
1307 walpDx = HeapAlloc( GetProcessHeap(), 0, count * sizeof(INT) );
1308 if (!walpDx) return FALSE;
1309 }
1310
1311 p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1312 ret = GetTextExtentExPointW( hdc, p, wlen, maxExt, lpnFit, walpDx, size);
1313 if (walpDx)
1314 {
1315 INT n = lpnFit ? *lpnFit : wlen;
1316 INT i, j;
1317 for(i = 0, j = 0; i < n; i++, j++)
1318 {
1319 alpDx[j] = walpDx[i];
1320 if (IsDBCSLeadByte(str[j])) alpDx[++j] = walpDx[i];
1321 }
1322 }
1323 if (lpnFit) *lpnFit = WideCharToMultiByte(CP_ACP,0,p,*lpnFit,NULL,0,NULL,NULL);
1324 HeapFree( GetProcessHeap(), 0, p );
1325 HeapFree( GetProcessHeap(), 0, walpDx );
1326 return ret;
1327 }
1328
1329
1330 /***********************************************************************
1331 * GetTextExtentExPointW (GDI32.@)
1332 *
1333 * Return the size of the string as it would be if it was output properly by
1334 * e.g. TextOut.
1335 */
1336 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count, INT max_ext,
1337 LPINT nfit, LPINT dxs, LPSIZE size )
1338 {
1339 DC *dc;
1340 int i;
1341 BOOL ret;
1342 INT buffer[256], *pos = dxs;
1343
1344 if (count < 0) return FALSE;
1345
1346 dc = get_dc_ptr(hdc);
1347 if (!dc) return FALSE;
1348
1349 if (!dxs)
1350 {
1351 pos = buffer;
1352 if (count > 256 && !(pos = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*pos) )))
1353 {
1354 release_dc_ptr( dc );
1355 return FALSE;
1356 }
1357 }
1358
1359 ret = get_char_positions( dc, str, count, pos, size );
1360 if (ret)
1361 {
1362 if (dxs || nfit)
1363 {
1364 for (i = 0; i < count; i++)
1365 {
1366 unsigned int dx = abs( INTERNAL_XDSTOWS( dc, pos[i] )) + (i + 1) * dc->charExtra;
1367 if (nfit && dx > (unsigned int)max_ext) break;
1368 if (dxs) dxs[i] = dx;
1369 }
1370 if (nfit) *nfit = i;
1371 }
1372
1373 size->cx = abs( INTERNAL_XDSTOWS( dc, size->cx )) + count * dc->charExtra;
1374 size->cy = abs( INTERNAL_YDSTOWS( dc, size->cy ));
1375 }
1376
1377 if (pos != buffer && pos != dxs) HeapFree( GetProcessHeap(), 0, pos );
1378 release_dc_ptr( dc );
1379
1380 TRACE("(%p, %s, %d) returning %dx%d\n", hdc, debugstr_wn(str,count), max_ext, size->cx, size->cy );
1381 return ret;
1382 }
1383
1384 /***********************************************************************
1385 * GetTextMetricsA (GDI32.@)
1386 */
1387 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1388 {
1389 TEXTMETRICW tm32;
1390
1391 if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1392 FONT_TextMetricWToA( &tm32, metrics );
1393 return TRUE;
1394 }
1395
1396 /***********************************************************************
1397 * GetTextMetricsW (GDI32.@)
1398 */
1399 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1400 {
1401 PHYSDEV physdev;
1402 BOOL ret = FALSE;
1403 DC * dc = get_dc_ptr( hdc );
1404 if (!dc) return FALSE;
1405
1406 physdev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
1407 ret = physdev->funcs->pGetTextMetrics( physdev, metrics );
1408
1409 if (ret)
1410 {
1411 /* device layer returns values in device units
1412 * therefore we have to convert them to logical */
1413
1414 metrics->tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1415 metrics->tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1416 metrics->tmHeight = height_to_LP( dc, metrics->tmHeight );
1417 metrics->tmAscent = height_to_LP( dc, metrics->tmAscent );
1418 metrics->tmDescent = height_to_LP( dc, metrics->tmDescent );
1419 metrics->tmInternalLeading = height_to_LP( dc, metrics->tmInternalLeading );
1420 metrics->tmExternalLeading = height_to_LP( dc, metrics->tmExternalLeading );
1421 metrics->tmAveCharWidth = width_to_LP( dc, metrics->tmAveCharWidth );
1422 metrics->tmMaxCharWidth = width_to_LP( dc, metrics->tmMaxCharWidth );
1423 metrics->tmOverhang = width_to_LP( dc, metrics->tmOverhang );
1424 ret = TRUE;
1425
1426 TRACE("text metrics:\n"
1427 " Weight = %03i\t FirstChar = %i\t AveCharWidth = %i\n"
1428 " Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %i\n"
1429 " UnderLined = %01i\t DefaultChar = %i\t Overhang = %i\n"
1430 " StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1431 " PitchAndFamily = %02x\n"
1432 " --------------------\n"
1433 " InternalLeading = %i\n"
1434 " Ascent = %i\n"
1435 " Descent = %i\n"
1436 " Height = %i\n",
1437 metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1438 metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1439 metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1440 metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1441 metrics->tmPitchAndFamily,
1442 metrics->tmInternalLeading,
1443 metrics->tmAscent,
1444 metrics->tmDescent,
1445 metrics->tmHeight );
1446 }
1447 release_dc_ptr( dc );
1448 return ret;
1449 }
1450
1451
1452 /***********************************************************************
1453 * GetOutlineTextMetricsA (GDI32.@)
1454 * Gets metrics for TrueType fonts.
1455 *
1456 * NOTES
1457 * If the supplied buffer isn't big enough Windows partially fills it up to
1458 * its given length and returns that length.
1459 *
1460 * RETURNS
1461 * Success: Non-zero or size of required buffer
1462 * Failure: 0
1463 */
1464 UINT WINAPI GetOutlineTextMetricsA(
1465 HDC hdc, /* [in] Handle of device context */
1466 UINT cbData, /* [in] Size of metric data array */
1467 LPOUTLINETEXTMETRICA lpOTM) /* [out] Address of metric data array */
1468 {
1469 char buf[512], *ptr;
1470 UINT ret, needed;
1471 OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
1472 OUTLINETEXTMETRICA *output = lpOTM;
1473 INT left, len;
1474
1475 if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1476 return 0;
1477 if(ret > sizeof(buf))
1478 lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1479 GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1480
1481 needed = sizeof(OUTLINETEXTMETRICA);
1482 if(lpOTMW->otmpFamilyName)
1483 needed += WideCharToMultiByte(CP_ACP, 0,
1484 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1485 NULL, 0, NULL, NULL);
1486 if(lpOTMW->otmpFaceName)
1487 needed += WideCharToMultiByte(CP_ACP, 0,
1488 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1489 NULL, 0, NULL, NULL);
1490 if(lpOTMW->otmpStyleName)
1491 needed += WideCharToMultiByte(CP_ACP, 0,
1492 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1493 NULL, 0, NULL, NULL);
1494 if(lpOTMW->otmpFullName)
1495 needed += WideCharToMultiByte(CP_ACP, 0,
1496 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1497 NULL, 0, NULL, NULL);
1498
1499 if(!lpOTM) {
1500 ret = needed;
1501 goto end;
1502 }
1503
1504 TRACE("needed = %d\n", needed);
1505 if(needed > cbData)
1506 /* Since the supplied buffer isn't big enough, we'll alloc one
1507 that is and memcpy the first cbData bytes into the lpOTM at
1508 the end. */
1509 output = HeapAlloc(GetProcessHeap(), 0, needed);
1510
1511 ret = output->otmSize = min(needed, cbData);
1512 FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
1513 output->otmFiller = 0;
1514 output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1515 output->otmfsSelection = lpOTMW->otmfsSelection;
1516 output->otmfsType = lpOTMW->otmfsType;
1517 output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1518 output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1519 output->otmItalicAngle = lpOTMW->otmItalicAngle;
1520 output->otmEMSquare = lpOTMW->otmEMSquare;
1521 output->otmAscent = lpOTMW->otmAscent;
1522 output->otmDescent = lpOTMW->otmDescent;
1523 output->otmLineGap = lpOTMW->otmLineGap;
1524 output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1525 output->otmsXHeight = lpOTMW->otmsXHeight;
1526 output->otmrcFontBox = lpOTMW->otmrcFontBox;
1527 output->otmMacAscent = lpOTMW->otmMacAscent;
1528 output->otmMacDescent = lpOTMW->otmMacDescent;
1529 output->otmMacLineGap = lpOTMW->otmMacLineGap;
1530 output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1531 output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1532 output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
1533 output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
1534 output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
1535 output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1536 output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
1537 output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1538 output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
1539
1540
1541 ptr = (char*)(output + 1);
1542 left = needed - sizeof(*output);
1543
1544 if(lpOTMW->otmpFamilyName) {
1545 output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1546 len = WideCharToMultiByte(CP_ACP, 0,
1547 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1548 ptr, left, NULL, NULL);
1549 left -= len;
1550 ptr += len;
1551 } else
1552 output->otmpFamilyName = 0;
1553
1554 if(lpOTMW->otmpFaceName) {
1555 output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1556 len = WideCharToMultiByte(CP_ACP, 0,
1557 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1558 ptr, left, NULL, NULL);
1559 left -= len;
1560 ptr += len;
1561 } else
1562 output->otmpFaceName = 0;
1563
1564 if(lpOTMW->otmpStyleName) {
1565 output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1566 len = WideCharToMultiByte(CP_ACP, 0,
1567 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1568 ptr, left, NULL, NULL);
1569 left -= len;
1570 ptr += len;
1571 } else
1572 output->otmpStyleName = 0;
1573
1574 if(lpOTMW->otmpFullName) {
1575 output->otmpFullName = (LPSTR)(ptr - (char*)output);
1576 len = WideCharToMultiByte(CP_ACP, 0,
1577 (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1578 ptr, left, NULL, NULL);
1579 left -= len;
1580 } else
1581 output->otmpFullName = 0;
1582
1583 assert(left == 0);
1584
1585 if(output != lpOTM) {
1586 memcpy(lpOTM, output, cbData);
1587 HeapFree(GetProcessHeap(), 0, output);
1588
1589 /* check if the string offsets really fit into the provided size */
1590 /* FIXME: should we check string length as well? */
1591 /* make sure that we don't read/write beyond the provided buffer */
1592 if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFamilyName) + sizeof(LPSTR))
1593 {
1594 if ((UINT_PTR)lpOTM->otmpFamilyName >= lpOTM->otmSize)
1595 lpOTM->otmpFamilyName = 0; /* doesn't fit */
1596 }
1597
1598 /* make sure that we don't read/write beyond the provided buffer */
1599 if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFaceName) + sizeof(LPSTR))
1600 {
1601 if ((UINT_PTR)lpOTM->otmpFaceName >= lpOTM->otmSize)
1602 lpOTM->otmpFaceName = 0; /* doesn't fit */
1603 }
1604
1605 /* make sure that we don't read/write beyond the provided buffer */
1606 if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpStyleName) + sizeof(LPSTR))
1607 {
1608 if ((UINT_PTR)lpOTM->otmpStyleName >= lpOTM->otmSize)
1609 lpOTM->otmpStyleName = 0; /* doesn't fit */
1610 }
1611
1612 /* make sure that we don't read/write beyond the provided buffer */
1613 if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFullName) + sizeof(LPSTR))
1614 {
1615 if ((UINT_PTR)lpOTM->otmpFullName >= lpOTM->otmSize)
1616 lpOTM->otmpFullName = 0; /* doesn't fit */
1617 }
1618 }
1619
1620 end:
1621 if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1622 HeapFree(GetProcessHeap(), 0, lpOTMW);
1623
1624 return ret;
1625 }
1626
1627
1628 /***********************************************************************
1629 * GetOutlineTextMetricsW [GDI32.@]
1630 */
1631 UINT WINAPI GetOutlineTextMetricsW(
1632 HDC hdc, /* [in] Handle of device context */
1633 UINT cbData, /* [in] Size of metric data array */
1634 LPOUTLINETEXTMETRICW lpOTM) /* [out] Address of metric data array */
1635 {
1636 DC *dc = get_dc_ptr( hdc );
1637 OUTLINETEXTMETRICW *output = lpOTM;
1638 PHYSDEV dev;
1639 UINT ret;
1640
1641 TRACE("(%p,%d,%p)\n", hdc, cbData, lpOTM);
1642 if(!dc) return 0;
1643
1644 dev = GET_DC_PHYSDEV( dc, pGetOutlineTextMetrics );
1645 ret = dev->funcs->pGetOutlineTextMetrics( dev, cbData, output );
1646
1647 if (lpOTM && ret > cbData)
1648 {
1649 output = HeapAlloc(GetProcessHeap(), 0, ret);
1650 ret = dev->funcs->pGetOutlineTextMetrics( dev, ret, output );
1651 }
1652
1653 if (lpOTM && ret)
1654 {
1655 output->otmTextMetrics.tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1656 output->otmTextMetrics.tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1657 output->otmTextMetrics.tmHeight = height_to_LP( dc, output->otmTextMetrics.tmHeight );
1658 output->otmTextMetrics.tmAscent = height_to_LP( dc, output->otmTextMetrics.tmAscent );
1659 output->otmTextMetrics.tmDescent = height_to_LP( dc, output->otmTextMetrics.tmDescent );
1660 output->otmTextMetrics.tmInternalLeading = height_to_LP( dc, output->otmTextMetrics.tmInternalLeading );
1661 output->otmTextMetrics.tmExternalLeading = height_to_LP( dc, output->otmTextMetrics.tmExternalLeading );
1662 output->otmTextMetrics.tmAveCharWidth = width_to_LP( dc, output->otmTextMetrics.tmAveCharWidth );
1663 output->otmTextMetrics.tmMaxCharWidth = width_to_LP( dc, output->otmTextMetrics.tmMaxCharWidth );
1664 output->otmTextMetrics.tmOverhang = width_to_LP( dc, output->otmTextMetrics.tmOverhang );
1665 output->otmAscent = height_to_LP( dc, output->otmAscent);
1666 output->otmDescent = height_to_LP( dc, output->otmDescent);
1667 output->otmLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmLineGap));
1668 output->otmsCapEmHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsCapEmHeight));
1669 output->otmsXHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsXHeight));
1670 output->otmrcFontBox.top = height_to_LP( dc, output->otmrcFontBox.top);
1671 output->otmrcFontBox.bottom = height_to_LP( dc, output->otmrcFontBox.bottom);
1672 output->otmrcFontBox.left = width_to_LP( dc, output->otmrcFontBox.left);
1673 output->otmrcFontBox.right = width_to_LP( dc, output->otmrcFontBox.right);
1674 output->otmMacAscent = height_to_LP( dc, output->otmMacAscent);
1675 output->otmMacDescent = height_to_LP( dc, output->otmMacDescent);
1676 output->otmMacLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmMacLineGap));
1677 output->otmptSubscriptSize.x = width_to_LP( dc, output->otmptSubscriptSize.x);
1678 output->otmptSubscriptSize.y = height_to_LP( dc, output->otmptSubscriptSize.y);
1679 output->otmptSubscriptOffset.x = width_to_LP( dc, output->otmptSubscriptOffset.x);
1680 output->otmptSubscriptOffset.y = height_to_LP( dc, output->otmptSubscriptOffset.y);
1681 output->otmptSuperscriptSize.x = width_to_LP( dc, output->otmptSuperscriptSize.x);
1682 output->otmptSuperscriptSize.y = height_to_LP( dc, output->otmptSuperscriptSize.y);
1683 output->otmptSuperscriptOffset.x = width_to_LP( dc, output->otmptSuperscriptOffset.x);
1684 output->otmptSuperscriptOffset.y = height_to_LP( dc, output->otmptSuperscriptOffset.y);
1685 output->otmsStrikeoutSize = abs(INTERNAL_YDSTOWS(dc,output->otmsStrikeoutSize));
1686 output->otmsStrikeoutPosition = height_to_LP( dc, output->otmsStrikeoutPosition);
1687 output->otmsUnderscoreSize = height_to_LP( dc, output->otmsUnderscoreSize);
1688 output->otmsUnderscorePosition = height_to_LP( dc, output->otmsUnderscorePosition);
1689
1690 if(output != lpOTM)
1691 {
1692 memcpy(lpOTM, output, cbData);
1693 HeapFree(GetProcessHeap(), 0, output);
1694 ret = cbData;
1695 }
1696 }
1697 release_dc_ptr(dc);
1698 return ret;
1699 }
1700
1701 static LPSTR FONT_GetCharsByRangeA(HDC hdc, UINT firstChar, UINT lastChar, PINT pByteLen)
1702 {
1703 INT i, count = lastChar - firstChar + 1;
1704 UINT mbcp;
1705 UINT c;
1706 LPSTR str;
1707
1708 if (count <= 0)
1709 return NULL;
1710
1711 mbcp = GdiGetCodePage(hdc);
1712 switch (mbcp)
1713 {
1714 case 932:
1715 case 936:
1716 case 949:
1717 case 950:
1718 case 1361:
1719 if (lastChar > 0xffff)
1720 return NULL;
1721 if ((firstChar ^ lastChar) > 0xff)
1722 return NULL;
1723 break;
1724 default:
1725 if (lastChar > 0xff)
1726 return NULL;
1727 mbcp = 0;
1728 break;
1729 }
1730
1731 str = HeapAlloc(GetProcessHeap(), 0, count * 2 + 1);
1732 if (str == NULL)
1733 return NULL;
1734
1735 for(i = 0, c = firstChar; c <= lastChar; i++, c++)
1736 {
1737 if (mbcp) {
1738 if (c > 0xff)
1739 str[i++] = (BYTE)(c >> 8);
1740 if (c <= 0xff && IsDBCSLeadByteEx(mbcp, c))
1741 str[i] = 0x1f; /* FIXME: use default character */
1742 else
1743 str[i] = (BYTE)c;
1744 }
1745 else
1746 str[i] = (BYTE)c;
1747 }
1748 str[i] = '\0';
1749
1750 *pByteLen = i;
1751
1752 return str;
1753 }
1754
1755 /***********************************************************************
1756 * GetCharWidthW (GDI32.@)
1757 * GetCharWidth32W (GDI32.@)
1758 */
1759 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1760 LPINT buffer )
1761 {
1762 UINT i;
1763 BOOL ret;
1764 PHYSDEV dev;
1765 DC * dc = get_dc_ptr( hdc );
1766
1767 if (!dc) return FALSE;
1768
1769 dev = GET_DC_PHYSDEV( dc, pGetCharWidth );
1770 ret = dev->funcs->pGetCharWidth( dev, firstChar, lastChar, buffer );
1771
1772 if (ret)
1773 {
1774 /* convert device units to logical */
1775 for( i = firstChar; i <= lastChar; i++, buffer++ )
1776 *buffer = width_to_LP( dc, *buffer );
1777 }
1778 release_dc_ptr( dc );
1779 return ret;
1780 }
1781
1782
1783 /***********************************************************************
1784 * GetCharWidthA (GDI32.@)
1785 * GetCharWidth32A (GDI32.@)
1786 */
1787 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1788 LPINT buffer )
1789 {
1790 INT i, wlen;
1791 LPSTR str;
1792 LPWSTR wstr;
1793 BOOL ret = TRUE;
1794
1795 str = FONT_GetCharsByRangeA(hdc, firstChar, lastChar, &i);
1796 if(str == NULL)
1797 return FALSE;
1798
1799 wstr = FONT_mbtowc(hdc, str, i, &wlen, NULL);
1800
1801 for(i = 0; i < wlen; i++)
1802 {
1803 if(!GetCharWidth32W(hdc, wstr[i], wstr[i], buffer))
1804 {
1805 ret = FALSE;
1806 break;
1807 }
1808 buffer++;
1809 }
1810
1811 HeapFree(GetProcessHeap(), 0, str);
1812 HeapFree(GetProcessHeap(), 0, wstr);
1813
1814 return ret;
1815 }
1816
1817
1818 /* helper for nulldrv_ExtTextOut */
1819 static DWORD get_glyph_bitmap( HDC hdc, UINT index, UINT flags, UINT aa_flags,
1820 GLYPHMETRICS *metrics, struct gdi_image_bits *image )
1821 {
1822 static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
1823 UINT indices[3] = {0, 0, 0x20};
1824 unsigned int i;
1825 DWORD ret, size;
1826 int stride;
1827
1828 indices[0] = index;
1829 if (flags & ETO_GLYPH_INDEX) aa_flags |= GGO_GLYPH_INDEX;
1830
1831 for (i = 0; i < sizeof(indices) / sizeof(indices[0]); i++)
1832 {
1833 index = indices[i];
1834 ret = GetGlyphOutlineW( hdc, index, aa_flags, metrics, 0, NULL, &identity );
1835 if (ret != GDI_ERROR) break;
1836 }
1837
1838 if (ret == GDI_ERROR) return ERROR_NOT_FOUND;
1839 if (!image) return ERROR_SUCCESS;
1840
1841 image->ptr = NULL;
1842 image->free = NULL;
1843 if (!ret) /* empty glyph */
1844 {
1845 metrics->gmBlackBoxX = metrics->gmBlackBoxY = 0;
1846 return ERROR_SUCCESS;
1847 }
1848
1849 stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1850 size = metrics->gmBlackBoxY * stride;
1851
1852 if (!(image->ptr = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_OUTOFMEMORY;
1853 image->is_copy = TRUE;
1854 image->free = free_heap_bits;
1855
1856 ret = GetGlyphOutlineW( hdc, index, aa_flags, metrics, size, image->ptr, &identity );
1857 if (ret == GDI_ERROR)
1858 {
1859 HeapFree( GetProcessHeap(), 0, image->ptr );
1860 return ERROR_NOT_FOUND;
1861 }
1862 return ERROR_SUCCESS;
1863 }
1864
1865 /* helper for nulldrv_ExtTextOut */
1866 static RECT get_total_extents( HDC hdc, INT x, INT y, UINT flags, UINT aa_flags,
1867 LPCWSTR str, UINT count, const INT *dx )
1868 {
1869 UINT i;
1870 RECT rect, bounds;
1871
1872 reset_bounds( &bounds );
1873 for (i = 0; i < count; i++)
1874 {
1875 GLYPHMETRICS metrics;
1876
1877 if (get_glyph_bitmap( hdc, str[i], flags, aa_flags, &metrics, NULL )) continue;
1878
1879 rect.left = x + metrics.gmptGlyphOrigin.x;
1880 rect.top = y - metrics.gmptGlyphOrigin.y;
1881 rect.right = rect.left + metrics.gmBlackBoxX;
1882 rect.bottom = rect.top + metrics.gmBlackBoxY;
1883 add_bounds_rect( &bounds, &rect );
1884
1885 if (dx)
1886 {
1887 if (flags & ETO_PDY)
1888 {
1889 x += dx[ i * 2 ];
1890 y += dx[ i * 2 + 1];
1891 }
1892 else x += dx[ i ];
1893 }
1894 else
1895 {
1896 x += metrics.gmCellIncX;
1897 y += metrics.gmCellIncY;
1898 }
1899 }
1900 return bounds;
1901 }
1902
1903 /* helper for nulldrv_ExtTextOut */
1904 static void draw_glyph( DC *dc, INT origin_x, INT origin_y, const GLYPHMETRICS *metrics,
1905 const struct gdi_image_bits *image, const RECT *clip )
1906 {
1907 static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
1908 UINT i, count, max_count;
1909 LONG x, y;
1910 BYTE *ptr = image->ptr;
1911 int stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1912 POINT *pts;
1913 RECT rect, clipped_rect;
1914
1915 rect.left = origin_x + metrics->gmptGlyphOrigin.x;
1916 rect.top = origin_y - metrics->gmptGlyphOrigin.y;
1917 rect.right = rect.left + metrics->gmBlackBoxX;
1918 rect.bottom = rect.top + metrics->gmBlackBoxY;
1919 if (!clip) clipped_rect = rect;
1920 else if (!intersect_rect( &clipped_rect, &rect, clip )) return;
1921
1922 max_count = (metrics->gmBlackBoxX + 1) * metrics->gmBlackBoxY;
1923 pts = HeapAlloc( GetProcessHeap(), 0, max_count * sizeof(*pts) );
1924 if (!pts) return;
1925
1926 count = 0;
1927 ptr += (clipped_rect.top - rect.top) * stride;
1928 for (y = clipped_rect.top; y < clipped_rect.bottom; y++, ptr += stride)
1929 {
1930 for (x = clipped_rect.left - rect.left; x < clipped_rect.right - rect.left; x++)
1931 {
1932 while (x < clipped_rect.right - rect.left && !(ptr[x / 8] & masks[x % 8])) x++;
1933 pts[count].x = rect.left + x;
1934 while (x < clipped_rect.right - rect.left && (ptr[x / 8] & masks[x % 8])) x++;
1935 pts[count + 1].x = rect.left + x;
1936 if (pts[count + 1].x > pts[count].x)
1937 {
1938 pts[count].y = pts[count + 1].y = y;
1939 count += 2;
1940 }
1941 }
1942 }
1943 assert( count <= max_count );
1944 dp_to_lp( dc, pts, count );
1945 for (i = 0; i < count; i += 2) Polyline( dc->hSelf, pts + i, 2 );
1946 HeapFree( GetProcessHeap(), 0, pts );
1947 }
1948
1949 /***********************************************************************
1950 * nulldrv_ExtTextOut
1951 */
1952 BOOL nulldrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *rect,
1953 LPCWSTR str, UINT count, const INT *dx )
1954 {
1955 DC *dc = get_nulldrv_dc( dev );
1956 UINT i;
1957 DWORD err;
1958 HGDIOBJ orig;
1959 HPEN pen;
1960
1961 if (flags & ETO_OPAQUE)
1962 {
1963 RECT rc = *rect;
1964 HBRUSH brush = CreateSolidBrush( GetNearestColor( dev->hdc, GetBkColor(dev->hdc) ));
1965
1966 if (brush)
1967 {
1968 orig = SelectObject( dev->hdc, brush );
1969 dp_to_lp( dc, (POINT *)&rc, 2 );
1970 PatBlt( dev->hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
1971 SelectObject( dev->hdc, orig );
1972 DeleteObject( brush );
1973 }
1974 }
1975
1976 if (!count) return TRUE;
1977
1978 if (dc->aa_flags != GGO_BITMAP)
1979 {
1980 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1981 BITMAPINFO *info = (BITMAPINFO *)buffer;
1982 struct gdi_image_bits bits;
1983 struct bitblt_coords src, dst;
1984 PHYSDEV dst_dev;
1985 /* FIXME Subpixel modes */
1986 UINT aa_flags = GGO_GRAY4_BITMAP;
1987
1988 dst_dev = GET_DC_PHYSDEV( dc, pPutImage );
1989 src.visrect = get_total_extents( dev->hdc, x, y, flags, aa_flags, str, count, dx );
1990 if (flags & ETO_CLIPPED) intersect_rect( &src.visrect, &src.visrect, rect );
1991 if (!clip_visrect( dc, &src.visrect, &src.visrect )) return TRUE;
1992
1993 /* FIXME: check for ETO_OPAQUE and avoid GetImage */
1994 src.x = src.visrect.left;
1995 src.y = src.visrect.top;
1996 src.width = src.visrect.right - src.visrect.left;
1997 src.height = src.visrect.bottom - src.visrect.top;
1998 dst = src;
1999 if ((flags & ETO_OPAQUE) && (src.visrect.left >= rect->left) && (src.visrect.top >= rect->top) &&
2000 (src.visrect.right <= rect->right) && (src.visrect.bottom <= rect->bottom))
2001 {
2002 /* we can avoid the GetImage, just query the needed format */
2003 memset( &info->bmiHeader, 0, sizeof(info->bmiHeader) );
2004 info->bmiHeader.biSize = sizeof(info->bmiHeader);
2005 info->bmiHeader.biWidth = src.width;
2006 info->bmiHeader.biHeight = -src.height;
2007 err = dst_dev->funcs->pPutImage( dst_dev, 0, info, NULL, NULL, NULL, 0 );
2008 if (!err || err == ERROR_BAD_FORMAT)
2009 {
2010 /* make the source rectangle relative to the source bits */
2011 src.x = src.y = 0;
2012 src.visrect.left = src.visrect.top = 0;
2013 src.visrect.right = src.width;
2014 src.visrect.bottom = src.height;
2015
2016 bits.ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( info ));
2017 if (!bits.ptr) return ERROR_OUTOFMEMORY;
2018 bits.is_copy = TRUE;
2019 bits.free = free_heap_bits;
2020 err = ERROR_SUCCESS;
2021 }
2022 }
2023 else
2024 {
2025 PHYSDEV src_dev = GET_DC_PHYSDEV( dc, pGetImage );
2026 err = src_dev->funcs->pGetImage( src_dev, info, &bits, &src );
2027 if (!err && !bits.is_copy)
2028 {
2029 void *ptr = HeapAlloc( GetProcessHeap(), 0, get_dib_image_size( info ));
2030 if (!ptr)
2031 {
2032 if (bits.free) bits.free( &bits );
2033 return ERROR_OUTOFMEMORY;
2034 }
2035 memcpy( ptr, bits.ptr, get_dib_image_size( info ));
2036 if (bits.free) bits.free( &bits );
2037 bits.ptr = ptr;
2038 bits.is_copy = TRUE;
2039 bits.free = free_heap_bits;
2040 }
2041 }
2042 if (!err)
2043 {
2044 /* make x,y relative to the image bits */
2045 x += src.visrect.left - dst.visrect.left;
2046 y += src.visrect.top - dst.visrect.top;
2047 render_aa_text_bitmapinfo( dc, info, &bits, &src, x, y, flags,
2048 aa_flags, str, count, dx );
2049 err = dst_dev->funcs->pPutImage( dst_dev, 0, info, &bits, &src, &dst, SRCCOPY );
2050 if (bits.free) bits.free( &bits );
2051 return !err;
2052 }
2053 }
2054
2055 pen = CreatePen( PS_SOLID, 1, GetTextColor(dev->hdc) );
2056 orig = SelectObject( dev->hdc, pen );
2057
2058 for (i = 0; i < count; i++)
2059 {
2060 GLYPHMETRICS metrics;
2061 struct gdi_image_bits image;
2062
2063 err = get_glyph_bitmap( dev->hdc, str[i], flags, GGO_BITMAP, &metrics, &image );
2064 if (err) continue;
2065
2066 if (image.ptr) draw_glyph( dc, x, y, &metrics, &image, (flags & ETO_CLIPPED) ? rect : NULL );
2067 if (image.free) image.free( &image );
2068
2069 if (dx)
2070 {
2071 if (flags & ETO_PDY)
2072 {
2073 x += dx[ i * 2 ];
2074 y += dx[ i * 2 + 1];
2075 }
2076 else x += dx[ i ];
2077 }
2078 else
2079 {
2080 x += metrics.gmCellIncX;
2081 y += metrics.gmCellIncY;
2082 }
2083 }
2084
2085 SelectObject( dev->hdc, orig );
2086 DeleteObject( pen );
2087 return TRUE;
2088 }
2089
2090
2091 /***********************************************************************
2092 * ExtTextOutA (GDI32.@)
2093 *
2094 * See ExtTextOutW.
2095 */
2096 BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags,
2097 const RECT *lprect, LPCSTR str, UINT count, const INT *lpDx )
2098 {
2099 INT wlen;
2100 UINT codepage;
2101 LPWSTR p;
2102 BOOL ret;
2103 LPINT lpDxW = NULL;
2104
2105 if (flags & ETO_GLYPH_INDEX)
2106 return ExtTextOutW( hdc, x, y, flags, lprect, (LPCWSTR)str, count, lpDx );
2107
2108 p = FONT_mbtowc(hdc, str, count, &wlen, &codepage);
2109
2110 if (lpDx) {
2111 unsigned int i = 0, j = 0;
2112
2113 /* allocate enough for a ETO_PDY */
2114 lpDxW = HeapAlloc( GetProcessHeap(), 0, 2*wlen*sizeof(INT));
2115 while(i < count) {
2116 if(IsDBCSLeadByteEx(codepage, str[i]))
2117 {
2118 if(flags & ETO_PDY)
2119 {
2120 lpDxW[j++] = lpDx[i * 2] + lpDx[(i + 1) * 2];
2121 lpDxW[j++] = lpDx[i * 2 + 1] + lpDx[(i + 1) * 2 + 1];
2122 }
2123 else
2124 lpDxW[j++] = lpDx[i] + lpDx[i + 1];
2125 i = i + 2;
2126 }
2127 else
2128 {
2129 if(flags & ETO_PDY)
2130 {
2131 lpDxW[j++] = lpDx[i * 2];
2132 lpDxW[j++] = lpDx[i * 2 + 1];
2133 }
2134 else
2135 lpDxW[j++] = lpDx[i];
2136 i = i + 1;
2137 }
2138 }
2139 }
2140
2141 ret = ExtTextOutW( hdc, x, y, flags, lprect, p, wlen, lpDxW );
2142
2143 HeapFree( GetProcessHeap(), 0, p );
2144 HeapFree( GetProcessHeap(), 0, lpDxW );
2145 return ret;
2146 }
2147
2148 /***********************************************************************
2149 * get_line_width
2150 *
2151 * Scale the underline / strikeout line width.
2152 */
2153 static inline int get_line_width( DC *dc, int metric_size )
2154 {
2155 int width = abs( INTERNAL_YWSTODS( dc, metric_size ));
2156 if (width == 0) width = 1;
2157 if (metric_size < 0) width = -width;
2158 return width;
2159 }
2160
2161 /***********************************************************************
2162 * ExtTextOutW (GDI32.@)
2163 *
2164 * Draws text using the currently selected font, background color, and text color.
2165 *
2166 *
2167 * PARAMS
2168 * x,y [I] coordinates of string
2169 * flags [I]
2170 * ETO_GRAYED - undocumented on MSDN
2171 * ETO_OPAQUE - use background color for fill the rectangle
2172 * ETO_CLIPPED - clipping text to the rectangle
2173 * ETO_GLYPH_INDEX - Buffer is of glyph locations in fonts rather
2174 * than encoded characters. Implies ETO_IGNORELANGUAGE
2175 * ETO_RTLREADING - Paragraph is basically a right-to-left paragraph.
2176 * Affects BiDi ordering
2177 * ETO_IGNORELANGUAGE - Undocumented in MSDN - instructs ExtTextOut not to do BiDi reordering
2178 * ETO_PDY - unimplemented
2179 * ETO_NUMERICSLATIN - unimplemented always assumed -
2180 * do not translate numbers into locale representations
2181 * ETO_NUMERICSLOCAL - unimplemented - Numerals in Arabic/Farsi context should assume local form
2182 * lprect [I] dimensions for clipping or/and opaquing
2183 * str [I] text string
2184 * count [I] number of symbols in string
2185 * lpDx [I] optional parameter with distance between drawing characters
2186 *
2187 * RETURNS
2188 * Success: TRUE
2189 * Failure: FALSE
2190 */
2191 BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
2192 const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx )
2193 {
2194 BOOL ret = FALSE;
2195 LPWSTR reordered_str = (LPWSTR)str;
2196 WORD *glyphs = NULL;
2197 UINT align = GetTextAlign( hdc );
2198 DWORD layout = GetLayout( hdc );
2199 POINT pt;
2200 TEXTMETRICW tm;
2201 LOGFONTW lf;
2202 double cosEsc, sinEsc;
2203 INT char_extra;
2204 SIZE sz;
2205 RECT rc;
2206 POINT *deltas = NULL, width = {0, 0};
2207 DWORD type;
2208 DC * dc = get_dc_ptr( hdc );
2209 PHYSDEV physdev;
2210 INT breakRem;
2211 static int quietfixme = 0;
2212
2213 if (!dc) return FALSE;
2214
2215 breakRem = dc->breakRem;
2216
2217 if (quietfixme == 0 && flags & (ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN))
2218 {
2219 FIXME("flags ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN unimplemented\n");
2220 quietfixme = 1;
2221 }
2222
2223 update_dc( dc );
2224 physdev = GET_DC_PHYSDEV( dc, pExtTextOut );
2225 type = GetObjectType(hdc);
2226 if(type == OBJ_METADC || type == OBJ_ENHMETADC)
2227 {
2228 ret = physdev->funcs->pExtTextOut( physdev, x, y, flags, lprect, str, count, lpDx );
2229 release_dc_ptr( dc );
2230 return ret;
2231 }
2232
2233 if (flags & ETO_RTLREADING) align |= TA_RTLREADING;
2234 if (layout & LAYOUT_RTL)
2235 {
2236 if ((align & TA_CENTER) != TA_CENTER) align ^= TA_RIGHT;
2237 align ^= TA_RTLREADING;
2238 }
2239
2240 if( !(flags & (ETO_GLYPH_INDEX | ETO_IGNORELANGUAGE)) && count > 0 )
2241 {
2242 INT cGlyphs;
2243 reordered_str = HeapAlloc(GetProcessHeap(), 0, count*sizeof(WCHAR));
2244
2245 BIDI_Reorder( hdc, str, count, GCP_REORDER,
2246 (align & TA_RTLREADING) ? WINE_GCPW_FORCE_RTL : WINE_GCPW_FORCE_LTR,
2247 reordered_str, count, NULL, &glyphs, &cGlyphs);
2248
2249 flags |= ETO_IGNORELANGUAGE;
2250 if (glyphs)
2251 {
2252 flags |= ETO_GLYPH_INDEX;
2253 if (cGlyphs != count)
2254 count = cGlyphs;
2255 }
2256 }
2257 else if(flags & ETO_GLYPH_INDEX)
2258 glyphs = reordered_str;
2259
2260 TRACE("%p, %d, %d, %08x, %s, %s, %d, %p)\n", hdc, x, y, flags,
2261 wine_dbgstr_rect(lprect), debugstr_wn(str, count), count, lpDx);
2262 TRACE("align = %x bkmode = %x mapmode = %x\n", align, GetBkMode(hdc), GetMapMode(hdc));
2263
2264 if(align & TA_UPDATECP)
2265 {
2266 GetCurrentPositionEx( hdc, &pt );
2267 x = pt.x;
2268 y = pt.y;
2269 }
2270
2271 GetTextMetricsW(hdc, &tm);
2272 GetObjectW(dc->hFont, sizeof(lf), &lf);
2273
2274 if(!(tm.tmPitchAndFamily & TMPF_VECTOR)) /* Non-scalable fonts shouldn't be rotated */
2275 lf.lfEscapement = 0;
2276
2277 if ((dc->GraphicsMode == GM_COMPATIBLE) &&
2278 (dc->vport2WorldValid && dc->xformWorld2Vport.eM11 * dc->xformWorld2Vport.eM22 < 0))
2279 {
2280 lf.lfEscapement = -lf.lfEscapement;
2281 }
2282
2283 if(lf.lfEscapement != 0)
2284 {
2285 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
2286 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
2287 }
2288 else
2289 {
2290 cosEsc = 1;
2291 sinEsc = 0;
2292 }
2293
2294 if (lprect && (flags & (ETO_OPAQUE | ETO_CLIPPED)))
2295 {
2296 rc = *lprect;
2297 lp_to_dp(dc, (POINT*)&rc, 2);
2298 order_rect( &rc );
2299 if (flags & ETO_OPAQUE)
2300 physdev->funcs->pExtTextOut( physdev, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL );
2301 }
2302 else flags &= ~ETO_CLIPPED;
2303
2304 if(count == 0)
2305 {
2306 ret = TRUE;
2307 goto done;
2308 }
2309
2310 pt.x = x;
2311 pt.y = y;
2312 lp_to_dp(dc, &pt, 1);
2313 x = pt.x;
2314 y = pt.y;
2315
2316 char_extra = GetTextCharacterExtra(hdc);
2317 if (char_extra && lpDx && GetDeviceCaps( hdc, TECHNOLOGY ) == DT_RASPRINTER)
2318 char_extra = 0; /* Printer drivers don't add char_extra if lpDx is supplied */
2319
2320 if(char_extra || dc->breakExtra || breakRem || lpDx || lf.lfEscapement != 0)
2321 {
2322 UINT i;
2323 POINT total = {0, 0}, desired[2];
2324
2325 deltas = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*deltas));
2326 if (lpDx)
2327 {
2328 if (flags & ETO_PDY)
2329 {
2330 for (i = 0; i < count; i++)
2331 {
2332 deltas[i].x = lpDx[i * 2] + char_extra;
2333 deltas[i].y = -lpDx[i * 2 + 1];
2334 }
2335 }
2336 else
2337 {
2338 for (i = 0; i < count; i++)
2339 {
2340 deltas[i].x = lpDx[i] + char_extra;
2341 deltas[i].y = 0;
2342 }
2343 }
2344 }
2345 else
2346 {
2347 INT *dx = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*dx) );
2348
2349 if (flags & ETO_GLYPH_INDEX)
2350 GetTextExtentExPointI( hdc, glyphs, count, -1, NULL, dx, &sz );
2351 else
2352 GetTextExtentExPointW( hdc, reordered_str, count, -1, NULL, dx, &sz );
2353
2354 deltas[0].x = dx[0];
2355 deltas[0].y = 0;
2356 for (i = 1; i < count; i++)
2357 {
2358 deltas[i].x = dx[i] - dx[i - 1];
2359 deltas[i].y = 0;
2360 }
2361 HeapFree( GetProcessHeap(), 0, dx );
2362 }
2363
2364 for(i = 0; i < count; i++)
2365 {
2366 total.x += deltas[i].x;
2367 total.y += deltas[i].y;
2368
2369 desired[0].x = desired[0].y = 0;
2370
2371 desired[1].x = cosEsc * total.x + sinEsc * total.y;
2372 desired[1].y = -sinEsc * total.x + cosEsc * total.y;
2373
2374 lp_to_dp(dc, desired, 2);
2375 desired[1].x -= desired[0].x;
2376 desired[1].y -= desired[0].y;
2377
2378 if (dc->GraphicsMode == GM_COMPATIBLE)
2379 {
2380 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM11 < 0)
2381 desired[1].x = -desired[1].x;
2382 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM22 < 0)
2383 desired[1].y = -desired[1].y;
2384 }
2385
2386 deltas[i].x = desired[1].x - width.x;
2387 deltas[i].y = desired[1].y - width.y;
2388
2389 width = desired[1];
2390 }
2391 flags |= ETO_PDY;
2392 }
2393 else
2394 {
2395 POINT desired[2];
2396
2397 if(flags & ETO_GLYPH_INDEX)
2398 GetTextExtentPointI(hdc, glyphs, count, &sz);
2399 else
2400 GetTextExtentPointW(hdc, reordered_str, count, &sz);
2401 desired[0].x = desired[0].y = 0;
2402 desired[1].x = sz.cx;
2403 desired[1].y = 0;
2404 lp_to_dp(dc, desired, 2);
2405 desired[1].x -= desired[0].x;
2406 desired[1].y -= desired[0].y;
2407
2408 if (dc->GraphicsMode == GM_COMPATIBLE)
2409 {
2410 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM11 < 0)
2411 desired[1].x = -desired[1].x;
2412 if (dc->vport2WorldValid && dc->xformWorld2Vport.eM22 < 0)
2413 desired[1].y = -desired[1].y;
2414 }
2415 width = desired[1];
2416 }
2417
2418 tm.tmAscent = abs(INTERNAL_YWSTODS(dc, tm.tmAscent));
2419 tm.tmDescent = abs(INTERNAL_YWSTODS(dc, tm.tmDescent));
2420 switch( align & (TA_LEFT | TA_RIGHT | TA_CENTER) )
2421 {
2422 case TA_LEFT:
2423 if (align & TA_UPDATECP)
2424 {
2425 pt.x = x + width.x;
2426 pt.y = y + width.y;
2427 dp_to_lp(dc, &pt, 1);
2428 MoveToEx(hdc, pt.x, pt.y, NULL);
2429 }
2430 break;
2431
2432 case TA_CENTER:
2433 x -= width.x / 2;
2434 y -= width.y / 2;
2435 break;
2436
2437 case TA_RIGHT:
2438 x -= width.x;
2439 y -= width.y;
2440 if (align & TA_UPDATECP)
2441 {
2442 pt.x = x;
2443 pt.y = y;
2444 dp_to_lp(dc, &pt, 1);
2445 MoveToEx(hdc, pt.x, pt.y, NULL);
2446 }
2447 break;
2448 }
2449
2450 switch( align & (TA_TOP | TA_BOTTOM | TA_BASELINE) )
2451 {
2452 case TA_TOP:
2453 y += tm.tmAscent * cosEsc;
2454 x += tm.tmAscent * sinEsc;
2455 break;
2456
2457 case TA_BOTTOM:
2458 y -= tm.tmDescent * cosEsc;
2459 x -= tm.tmDescent * sinEsc;
2460 break;
2461
2462 case TA_BASELINE:
2463 break;
2464 }
2465
2466 if (GetBkMode(hdc) != TRANSPARENT)
2467 {
2468 if(!((flags & ETO_CLIPPED) && (flags & ETO_OPAQUE)))
2469 {
2470 if(!(flags & ETO_OPAQUE) || !lprect ||
2471 x < rc.left || x + width.x >= rc.right ||
2472 y - tm.tmAscent < rc.top || y + tm.tmDescent >= rc.bottom)
2473 {
2474 RECT text_box;
2475 text_box.left = x;
2476 text_box.right = x + width.x;
2477 text_box.top = y - tm.tmAscent;
2478 text_box.bottom = y + tm.tmDescent;
2479
2480 if (flags & ETO_CLIPPED) intersect_rect( &text_box, &text_box, &rc );
2481 if (!is_rect_empty( &text_box ))
2482 physdev->funcs->pExtTextOut( physdev, 0, 0, ETO_OPAQUE, &text_box, NULL, 0, NULL );
2483 }
2484 }
2485 }
2486
2487 ret = physdev->funcs->pExtTextOut( physdev, x, y, (flags & ~ETO_OPAQUE), &rc,
2488 glyphs ? glyphs : reordered_str, count, (INT*)deltas );
2489
2490 done:
2491 HeapFree(GetProcessHeap(), 0, deltas);
2492 if(glyphs != reordered_str)
2493 HeapFree(GetProcessHeap(), 0, glyphs);
2494 if(reordered_str != str)
2495 HeapFree(GetProcessHeap(), 0, reordered_str);
2496
2497 if (ret && (lf.lfUnderline || lf.lfStrikeOut))
2498 {
2499 int underlinePos, strikeoutPos;
2500 int underlineWidth, strikeoutWidth;
2501 UINT size = GetOutlineTextMetricsW(hdc, 0, NULL);
2502 OUTLINETEXTMETRICW* otm = NULL;
2503 POINT pts[5];
2504 HPEN hpen = SelectObject(hdc, GetStockObject(NULL_PEN));
2505 HBRUSH hbrush = CreateSolidBrush(GetTextColor(hdc));
2506
2507 hbrush = SelectObject(hdc, hbrush);
2508
2509 if(!size)
2510 {
2511 underlinePos = 0;
2512 underlineWidth = tm.tmAscent / 20 + 1;
2513 strikeoutPos = tm.tmAscent / 2;
2514 strikeoutWidth = underlineWidth;
2515 }
2516 else
2517 {
2518 otm = HeapAlloc(GetProcessHeap(), 0, size);
2519 GetOutlineTextMetricsW(hdc, size, otm);
2520 underlinePos = abs( INTERNAL_YWSTODS( dc, otm->otmsUnderscorePosition ));
2521 if (otm->otmsUnderscorePosition < 0) underlinePos = -underlinePos;
2522 underlineWidth = get_line_width( dc, otm->otmsUnderscoreSize );
2523 strikeoutPos = abs( INTERNAL_YWSTODS( dc, otm->otmsStrikeoutPosition ));
2524 if (otm->otmsStrikeoutPosition < 0) strikeoutPos = -strikeoutPos;
2525 strikeoutWidth = get_line_width( dc, otm->otmsStrikeoutSize );
2526 HeapFree(GetProcessHeap(), 0, otm);
2527 }
2528
2529
2530 if (lf.lfUnderline)
2531 {
2532 pts[0].x = x - (underlinePos + underlineWidth / 2) * sinEsc;
2533 pts[0].y = y - (underlinePos + underlineWidth / 2) * cosEsc;
2534 pts[1].x = x + width.x - (underlinePos + underlineWidth / 2) * sinEsc;
2535 pts[1].y = y + width.y - (underlinePos + underlineWidth / 2) * cosEsc;
2536 pts[2].x = pts[1].x + underlineWidth * sinEsc;
2537 pts[2].y = pts[1].y + underlineWidth * cosEsc;
2538 pts[3].x = pts[0].x + underlineWidth * sinEsc;
2539 pts[3].y = pts[0].y + underlineWidth * cosEsc;
2540 pts[4].x = pts[0].x;
2541 pts[4].y = pts[0].y;
2542 dp_to_lp(dc, pts, 5);
2543 Polygon(hdc, pts, 5);
2544 }
2545
2546 if (lf.lfStrikeOut)
2547 {
2548 pts[0].x = x - (strikeoutPos + strikeoutWidth / 2) * sinEsc;
2549 pts[0].y = y - (strikeoutPos + strikeoutWidth / 2) * cosEsc;
2550 pts[1].x = x + width.x - (strikeoutPos + strikeoutWidth / 2) * sinEsc;
2551 pts[1].y = y + width.y - (strikeoutPos + strikeoutWidth / 2) * cosEsc;
2552 pts[2].x = pts[1].x + strikeoutWidth * sinEsc;
2553 pts[2].y = pts[1].y + strikeoutWidth * cosEsc;
2554 pts[3].x = pts[0].x + strikeoutWidth * sinEsc;
2555 pts[3].y = pts[0].y + strikeoutWidth * cosEsc;
2556 pts[4].x = pts[0].x;
2557 pts[4].y = pts[0].y;
2558 dp_to_lp(dc, pts, 5);
2559 Polygon(hdc, pts, 5);
2560 }
2561
2562 SelectObject(hdc, hpen);
2563 hbrush = SelectObject(hdc, hbrush);
2564 DeleteObject(hbrush);
2565 }
2566
2567 release_dc_ptr( dc );
2568
2569 return ret;
2570 }
2571
2572
2573 /***********************************************************************
2574 * TextOutA (GDI32.@)
2575 */
2576 BOOL WINAPI TextOutA( HDC hdc, INT x, INT y, LPCSTR str, INT count )
2577 {
2578 return ExtTextOutA( hdc, x, y, 0, NULL, str, count, NULL );
2579 }
2580
2581
2582 /***********************************************************************
2583 * TextOutW (GDI32.@)
2584 */
2585 BOOL WINAPI TextOutW(HDC hdc, INT x, INT y, LPCWSTR str, INT count)
2586 {
2587 return ExtTextOutW( hdc, x, y, 0, NULL, str, count, NULL );
2588 }
2589
2590
2591 /***********************************************************************
2592 * PolyTextOutA (GDI32.@)
2593 *
2594 * See PolyTextOutW.
2595 */
2596 BOOL WINAPI PolyTextOutA( HDC hdc, const POLYTEXTA *pptxt, INT cStrings )
2597 {
2598 for (; cStrings>0; cStrings--, pptxt++)
2599 if (!ExtTextOutA( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2600 return FALSE;
2601 return TRUE;
2602 }
2603
2604
2605
2606 /***********************************************************************
2607 * PolyTextOutW (GDI32.@)
2608 *
2609 * Draw several Strings
2610 *
2611 * RETURNS
2612 * TRUE: Success.
2613 * FALSE: Failure.
2614 */
2615 BOOL WINAPI PolyTextOutW( HDC hdc, const POLYTEXTW *pptxt, INT cStrings )
2616 {
2617 for (; cStrings>0; cStrings--, pptxt++)
2618 if (!ExtTextOutW( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2619 return FALSE;
2620 return TRUE;
2621 }
2622
2623
2624 /***********************************************************************
2625 * SetMapperFlags (GDI32.@)
2626 */
2627 DWORD WINAPI SetMapperFlags( HDC hdc, DWORD flags )
2628 {
2629 DC *dc = get_dc_ptr( hdc );
2630 DWORD ret = GDI_ERROR;
2631
2632 if (dc)
2633 {
2634 PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetMapperFlags );
2635 flags = physdev->funcs->pSetMapperFlags( physdev, flags );
2636 if (flags != GDI_ERROR)
2637 {
2638 ret = dc->mapperFlags;
2639 dc->mapperFlags = flags;
2640 }
2641 release_dc_ptr( dc );
2642 }
2643 return ret;
2644 }
2645
2646 /***********************************************************************
2647 * GetAspectRatioFilterEx (GDI32.@)
2648 */
2649 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
2650 {
2651 FIXME("(%p, %p): -- Empty Stub !\n", hdc, pAspectRatio);
2652 return FALSE;
2653 }
2654
2655
2656 /***********************************************************************
2657 * GetCharABCWidthsA (GDI32.@)
2658 *
2659 * See GetCharABCWidthsW.
2660 */
2661 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
2662 LPABC abc )
2663 {
2664 INT i, wlen;
2665 LPSTR str;
2666 LPWSTR wstr;
2667 BOOL ret = TRUE;
2668
2669 str = FONT_GetCharsByRangeA(hdc, firstChar, lastChar, &i);
2670 if (str == NULL)
2671 return FALSE;
2672
2673 wstr = FONT_mbtowc(hdc, str, i, &wlen, NULL);
2674 if (wstr == NULL)
2675 {
2676 HeapFree(GetProcessHeap(), 0, str);
2677 return FALSE;
2678 }
2679
2680 for(i = 0; i < wlen; i++)
2681 {
2682 if(!GetCharABCWidthsW(hdc, wstr[i], wstr[i], abc))
2683 {
2684 ret = FALSE;
2685 break;
2686 }
2687 abc++;
2688 }
2689
2690 HeapFree(GetProcessHeap(), 0, str);
2691 HeapFree(GetProcessHeap(), 0, wstr);
2692
2693 return ret;
2694 }
2695
2696
2697 /******************************************************************************
2698 * GetCharABCWidthsW [GDI32.@]
2699 *
2700 * Retrieves widths of characters in range.
2701 *
2702 * PARAMS
2703 * hdc [I] Handle of device context
2704 * firstChar [I] First character in range to query
2705 * lastChar [I] Last character in range to query
2706 * abc [O] Address of character-width structure
2707 *
2708 * NOTES
2709 * Only works with TrueType fonts
2710 *
2711 * RETURNS
2712 * Success: TRUE
2713 * Failure: FALSE
2714 */
2715 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
2716 LPABC abc )
2717 {
2718 DC *dc = get_dc_ptr(hdc);
2719 PHYSDEV dev;
2720 unsigned int i;
2721 BOOL ret;
2722 TEXTMETRICW tm;
2723
2724 if (!dc) return FALSE;
2725
2726 if (!abc)
2727 {
2728 release_dc_ptr( dc );
2729 return FALSE;
2730 }
2731
2732 /* unlike GetCharABCWidthsFloatW, this one is supposed to fail on non-scalable fonts */
2733 dev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
2734 if (!dev->funcs->pGetTextMetrics( dev, &tm ) || !(tm.tmPitchAndFamily & TMPF_VECTOR))
2735 {
2736 release_dc_ptr( dc );
2737 return FALSE;
2738 }
2739
2740 dev = GET_DC_PHYSDEV( dc, pGetCharABCWidths );
2741 ret = dev->funcs->pGetCharABCWidths( dev, firstChar, lastChar, abc );
2742 if (ret)
2743 {
2744 /* convert device units to logical */
2745 for( i = firstChar; i <= lastChar; i++, abc++ ) {
2746 abc->abcA = width_to_LP(dc, abc->abcA);
2747 abc->abcB = width_to_LP(dc, abc->abcB);
2748 abc->abcC = width_to_LP(dc, abc->abcC);
2749 }
2750 }
2751
2752 release_dc_ptr( dc );
2753 return ret;
2754 }
2755
2756
2757 /******************************************************************************
2758 * GetCharABCWidthsI [GDI32.@]
2759 *
2760 * Retrieves widths of characters in range.
2761 *
2762 * PARAMS
2763 * hdc [I] Handle of device context
2764 * firstChar [I] First glyphs in range to query
2765 * count [I] Last glyphs in range to query
2766 * pgi [i] Array of glyphs to query
2767 * abc [O] Address of character-width structure
2768 *
2769 * NOTES
2770 * Only works with TrueType fonts
2771 *
2772 * RETURNS
2773 * Success: TRUE
2774 * Failure: FALSE
2775 */
2776 BOOL WINAPI GetCharABCWidthsI( HDC hdc, UINT firstChar, UINT count,
2777 LPWORD pgi, LPABC abc)
2778 {
2779 DC *dc = get_dc_ptr(hdc);
2780 PHYSDEV dev;
2781 unsigned int i;
2782 BOOL ret;
2783
2784 if (!dc) return FALSE;
2785
2786 if (!abc)
2787 {
2788 release_dc_ptr( dc );
2789 return FALSE;
2790 }
2791
2792 dev = GET_DC_PHYSDEV( dc, pGetCharABCWidthsI );
2793 ret = dev->funcs->pGetCharABCWidthsI( dev, firstChar, count, pgi, abc );
2794 if (ret)
2795 {
2796 /* convert device units to logical */
2797 for( i = 0; i < count; i++, abc++ ) {
2798 abc->abcA = width_to_LP(dc, abc->abcA);
2799 abc->abcB = width_to_LP(dc, abc->abcB);
2800 abc->abcC = width_to_LP(dc, abc->abcC);
2801 }
2802 }
2803
2804 release_dc_ptr( dc );
2805 return ret;
2806 }
2807
2808
2809 /***********************************************************************
2810 * GetGlyphOutlineA (GDI32.@)
2811 */
2812 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
2813 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2814 LPVOID lpBuffer, const MAT2 *lpmat2 )
2815 {
2816 if (!lpmat2) return GDI_ERROR;
2817
2818 if(!(fuFormat & GGO_GLYPH_INDEX)) {
2819 UINT cp;
2820 int len;
2821 char mbchs[2];
2822
2823 cp = GdiGetCodePage(hdc);
2824 if (IsDBCSLeadByteEx(cp, uChar >> 8)) {
2825 len = 2;
2826 mbchs[0] = (uChar & 0xff00) >> 8;
2827 mbchs[1] = (uChar & 0xff);
2828 } else {
2829 len = 1;
2830 mbchs[0] = (uChar & 0xff);
2831 }
2832 uChar = 0;
2833 MultiByteToWideChar(cp, 0, mbchs, len, (LPWSTR)&uChar, 1);
2834 }
2835
2836 return GetGlyphOutlineW(hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer,
2837 lpmat2);
2838 }
2839
2840 /***********************************************************************
2841 * GetGlyphOutlineW (GDI32.@)
2842 */
2843 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
2844 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2845 LPVOID lpBuffer, const MAT2 *lpmat2 )
2846 {
2847 DC *dc;
2848 DWORD ret;
2849 PHYSDEV dev;
2850
2851 TRACE("(%p, %04x, %04x, %p, %d, %p, %p)\n",
2852 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
2853
2854 if (!lpmat2) return GDI_ERROR;
2855
2856 dc = get_dc_ptr(hdc);
2857 if(!dc) return GDI_ERROR;
2858
2859 dev = GET_DC_PHYSDEV( dc, pGetGlyphOutline );
2860 ret = dev->funcs->pGetGlyphOutline( dev, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
2861 release_dc_ptr( dc );
2862 return ret;
2863 }
2864
2865
2866 /***********************************************************************
2867 * CreateScalableFontResourceA (GDI32.@)
2868 */
2869 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
2870 LPCSTR lpszResourceFile,
2871 LPCSTR lpszFontFile,
2872 LPCSTR lpszCurrentPath )
2873 {
2874 LPWSTR lpszResourceFileW = NULL;
2875 LPWSTR lpszFontFileW = NULL;
2876 LPWSTR lpszCurrentPathW = NULL;
2877 int len;
2878 BOOL ret;
2879
2880 if (lpszResourceFile)
2881 {
2882 len = MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, NULL, 0);
2883 lpszResourceFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2884 MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, lpszResourceFileW, len);
2885 }
2886
2887 if (lpszFontFile)
2888 {
2889 len = MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, NULL, 0);
2890 lpszFontFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2891 MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, lpszFontFileW, len);
2892 }
2893
2894 if (lpszCurrentPath)
2895 {
2896 len = MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, NULL, 0);
2897 lpszCurrentPathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2898 MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, lpszCurrentPathW, len);
2899 }
2900
2901 ret = CreateScalableFontResourceW(fHidden, lpszResourceFileW,
2902 lpszFontFileW, lpszCurrentPathW);
2903
2904 HeapFree(GetProcessHeap(), 0, lpszResourceFileW);
2905 HeapFree(GetProcessHeap(), 0, lpszFontFileW);
2906 HeapFree(GetProcessHeap(), 0, lpszCurrentPathW);
2907
2908 return ret;
2909 }
2910
2911 /***********************************************************************
2912 * CreateScalableFontResourceW (GDI32.@)
2913 */
2914 BOOL WINAPI CreateScalableFontResourceW( DWORD hidden, LPCWSTR resource_file,
2915 LPCWSTR font_file, LPCWSTR font_path )
2916 {
2917 TRACE("(%d, %s, %s, %s)\n", hidden, debugstr_w(resource_file),
2918 debugstr_w(font_file), debugstr_w(font_path) );
2919
2920 return WineEngCreateScalableFontResource( hidden, resource_file,
2921 font_file, font_path );
2922 }
2923
2924 /*************************************************************************
2925 * GetKerningPairsA (GDI32.@)
2926 */
2927 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
2928 LPKERNINGPAIR kern_pairA )
2929 {
2930 UINT cp;
2931 CPINFO cpi;
2932 DWORD i, total_kern_pairs, kern_pairs_copied = 0;
2933 KERNINGPAIR *kern_pairW;
2934
2935 if (!cPairs && kern_pairA)
2936 {
2937 SetLastError(ERROR_INVALID_PARAMETER);
2938 return 0;
2939 }
2940
2941 cp = GdiGetCodePage(hDC);
2942
2943 /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
2944 * to fail on an invalid character for CP_SYMBOL.
2945 */
2946 cpi.DefaultChar[0] = 0;
2947 if (cp != CP_SYMBOL && !GetCPInfo(cp, &cpi))
2948 {
2949 FIXME("Can't find codepage %u info\n", cp);
2950 return 0;
2951 }
2952
2953 total_kern_pairs = GetKerningPairsW(hDC, 0, NULL);
2954 if (!total_kern_pairs) return 0;
2955
2956 kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
2957 GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
2958
2959 for (i = 0; i < total_kern_pairs; i++)
2960 {
2961 char first, second;
2962
2963 if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
2964 continue;
2965
2966 if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
2967 continue;
2968
2969 if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
2970 continue;
2971
2972 if (kern_pairA)
2973 {
2974 if (kern_pairs_copied >= cPairs) break;
2975
2976 kern_pairA->wFirst = (BYTE)first;
2977 kern_pairA->wSecond = (BYTE)second;
2978 kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
2979 kern_pairA++;
2980 }
2981 kern_pairs_copied++;
2982 }
2983
2984 HeapFree(GetProcessHeap(), 0, kern_pairW);
2985
2986 return kern_pairs_copied;
2987 }
2988
2989 /*************************************************************************
2990 * GetKerningPairsW (GDI32.@)
2991 */
2992 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
2993 LPKERNINGPAIR lpKerningPairs )
2994 {
2995 DC *dc;
2996 DWORD ret;
2997 PHYSDEV dev;
2998
2999 TRACE("(%p,%d,%p)\n", hDC, cPairs, lpKerningPairs);
3000
3001 if (!cPairs && lpKerningPairs)
3002 {
3003 SetLastError(ERROR_INVALID_PARAMETER);
3004 return 0;
3005 }
3006
3007 dc = get_dc_ptr(hDC);
3008 if (!dc) return 0;
3009
3010 dev = GET_DC_PHYSDEV( dc, pGetKerningPairs );
3011 ret = dev->funcs->pGetKerningPairs( dev, cPairs, lpKerningPairs );
3012 release_dc_ptr( dc );
3013 return ret;
3014 }
3015
3016 /*************************************************************************
3017 * TranslateCharsetInfo [GDI32.@]
3018 *
3019 * Fills a CHARSETINFO structure for a character set, code page, or
3020 * font. This allows making the correspondence between different labels
3021 * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
3022 * of the same encoding.
3023 *
3024 * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
3025 * only one codepage should be set in *lpSrc.
3026 *
3027 * RETURNS
3028 * TRUE on success, FALSE on failure.
3029 *
3030 */
3031 BOOL WINAPI TranslateCharsetInfo(
3032 LPDWORD lpSrc, /* [in]
3033 if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
3034 if flags == TCI_SRCCHARSET: a character set value
3035 if flags == TCI_SRCCODEPAGE: a code page value
3036 */
3037 LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
3038 DWORD flags /* [in] determines interpretation of lpSrc */)
3039 {
3040 int index = 0;
3041 switch (flags) {
3042 case TCI_SRCFONTSIG:
3043 while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++;
3044 break;
3045 case TCI_SRCCODEPAGE:
3046 while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++;
3047 break;
3048 case TCI_SRCCHARSET:
3049 while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++;
3050 break;
3051 default:
3052 return FALSE;
3053 }
3054 if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
3055 *lpCs = FONT_tci[index];
3056 return TRUE;
3057 }
3058
3059 /*************************************************************************
3060 * GetFontLanguageInfo (GDI32.@)
3061 */
3062 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
3063 {
3064 FONTSIGNATURE fontsig;
3065 static const DWORD GCP_DBCS_MASK=FS_JISJAPAN|FS_CHINESESIMP|FS_WANSUNG|FS_CHINESETRAD|FS_JOHAB,
3066 GCP_DIACRITIC_MASK=0x00000000,
3067 FLI_GLYPHS_MASK=0x00000000,
3068 GCP_GLYPHSHAPE_MASK=FS_ARABIC,
3069 GCP_KASHIDA_MASK=0x00000000,
3070 GCP_LIGATE_MASK=0x00000000,
3071 GCP_REORDER_MASK=FS_HEBREW|FS_ARABIC;
3072
3073 DWORD result=0;
3074
3075 GetTextCharsetInfo( hdc, &fontsig, 0 );
3076 /* We detect each flag we return using a bitmask on the Codepage Bitfields */
3077
3078 if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
3079 result|=GCP_DBCS;
3080
3081 if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
3082 result|=GCP_DIACRITIC;
3083
3084 if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
3085 result|=FLI_GLYPHS;
3086
3087 if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
3088 result|=GCP_GLYPHSHAPE;
3089
3090 if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
3091 result|=GCP_KASHIDA;
3092
3093 if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
3094 result|=GCP_LIGATE;
3095
3096 if( GetKerningPairsW( hdc, 0, NULL ) )
3097 result|=GCP_USEKERNING;
3098
3099 /* this might need a test for a HEBREW- or ARABIC_CHARSET as well */
3100 if( GetTextAlign( hdc) & TA_RTLREADING )
3101 if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
3102 result|=GCP_REORDER;
3103
3104 return result;
3105 }
3106
3107
3108 /*************************************************************************
3109 * GetFontData [GDI32.@]
3110 *
3111 * Retrieve data for TrueType font.
3112 *
3113 * RETURNS
3114 *
3115 * success: Number of bytes returned
3116 * failure: GDI_ERROR
3117 *
3118 * NOTES
3119 *
3120 * Calls SetLastError()
3121 *
3122 */
3123 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
3124 LPVOID buffer, DWORD length)
3125 {
3126 DC *dc = get_dc_ptr(hdc);
3127 PHYSDEV dev;
3128 DWORD ret;
3129
3130 if(!dc) return GDI_ERROR;
3131
3132 dev = GET_DC_PHYSDEV( dc, pGetFontData );
3133 ret = dev->funcs->pGetFontData( dev, table, offset, buffer, length );
3134 release_dc_ptr( dc );
3135 return ret;
3136 }
3137
3138 /*************************************************************************
3139 * GetGlyphIndicesA [GDI32.@]
3140 */
3141 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
3142 LPWORD pgi, DWORD flags)
3143 {
3144 DWORD ret;
3145 WCHAR *lpstrW;
3146 INT countW;
3147
3148 TRACE("(%p, %s, %d, %p, 0x%x)\n",
3149 hdc, debugstr_an(lpstr, count), count, pgi, flags);
3150
3151 lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
3152 ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
3153 HeapFree(GetProcessHeap(), 0, lpstrW);
3154
3155 return ret;
3156 }
3157
3158 /*************************************************************************
3159 * GetGlyphIndicesW [GDI32.@]
3160 */
3161 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
3162 LPWORD pgi, DWORD flags)
3163 {
3164 DC *dc = get_dc_ptr(hdc);
3165 PHYSDEV dev;
3166 DWORD ret;
3167
3168 TRACE("(%p, %s, %d, %p, 0x%x)\n",
3169 hdc, debugstr_wn(lpstr, count), count, pgi, flags);
3170
3171 if(!dc) return GDI_ERROR;
3172
3173 dev = GET_DC_PHYSDEV( dc, pGetGlyphIndices );
3174 ret = dev->funcs->pGetGlyphIndices( dev, lpstr, count, pgi, flags );
3175 release_dc_ptr( dc );
3176 return ret;
3177 }
3178
3179 /*************************************************************************
3180 * GetCharacterPlacementA [GDI32.@]
3181 *
3182 * See GetCharacterPlacementW.
3183 *
3184 * NOTES:
3185 * the web browser control of ie4 calls this with dwFlags=0
3186 */
3187 DWORD WINAPI
3188 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
3189 INT nMaxExtent, GCP_RESULTSA *lpResults,
3190 DWORD dwFlags)
3191 {
3192 WCHAR *lpStringW;
3193 INT uCountW;
3194 GCP_RESULTSW resultsW;
3195 DWORD ret;
3196 UINT font_cp;
3197
3198 TRACE("%s, %d, %d, 0x%08x\n",
3199 debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
3200
3201 /* both structs are equal in size */
3202 memcpy(&resultsW, lpResults, sizeof(resultsW));
3203
3204 lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
3205 if(lpResults->lpOutString)
3206 resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
3207
3208 ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
3209
3210 lpResults->nGlyphs = resultsW.nGlyphs;
3211 lpResults->nMaxFit = resultsW.nMaxFit;
3212
3213 if(lpResults->lpOutString) {
3214 WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
3215 lpResults->lpOutString, uCount, NULL, NULL );
3216 }
3217
3218 HeapFree(GetProcessHeap(), 0, lpStringW);
3219 HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
3220
3221 return ret;
3222 }
3223
3224 /*************************************************************************
3225 * GetCharacterPlacementW [GDI32.@]
3226 *
3227 * Retrieve information about a string. This includes the width, reordering,
3228 * Glyphing and so on.
3229 *
3230 * RETURNS
3231 *
3232 * The width and height of the string if successful, 0 if failed.
3233 *
3234 * BUGS
3235 *
3236 * All flags except GCP_REORDER are not yet implemented.
3237 * Reordering is not 100% compliant to the Windows BiDi method.
3238 * Caret positioning is not yet implemented for BiDi.
3239 * Classes are not yet implemented.
3240 *
3241 */
3242 DWORD WINAPI
3243 GetCharacterPlacementW(
3244 HDC hdc, /* [in] Device context for which the rendering is to be done */
3245 LPCWSTR lpString, /* [in] The string for which information is to be returned */
3246 INT uCount, /* [in] Number of WORDS in string. */
3247 INT nMaxExtent, /* [in] Maximum extent the string is to take (in HDC logical units) */
3248 GCP_RESULTSW *lpResults, /* [in/out] A pointer to a GCP_RESULTSW struct */
3249 DWORD dwFlags /* [in] Flags specifying how to process the string */
3250 )
3251 {
3252 DWORD ret=0;
3253 SIZE size;
3254 UINT i, nSet;
3255
3256 TRACE("%s, %d, %d, 0x%08x\n",
3257 debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
3258
3259 TRACE("lStructSize=%d, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
3260 "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
3261 lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
3262 lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
3263 lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
3264
3265 if(dwFlags&(~GCP_REORDER))
3266 FIXME("flags 0x%08x ignored\n", dwFlags);
3267 if(lpResults->lpClass)
3268 FIXME("classes not implemented\n");
3269 if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
3270 FIXME("Caret positions for complex scripts not implemented\n");
3271
3272 nSet = (UINT)uCount;
3273 if(nSet > lpResults->nGlyphs)
3274 nSet = lpResults->nGlyphs;
3275
3276 /* return number of initialized fields */
3277 lpResults->nGlyphs = nSet;
3278
3279 if((dwFlags&GCP_REORDER)==0 )
3280 {
3281 /* Treat the case where no special handling was requested in a fastpath way */
3282 /* copy will do if the GCP_REORDER flag is not set */
3283 if(lpResults->lpOutString)
3284 memcpy( lpResults->lpOutString, lpString, nSet * sizeof(WCHAR));
3285
3286 if(lpResults->lpOrder)
3287 {
3288 for(i = 0; i < nSet; i++)
3289 lpResults->lpOrder[i] = i;
3290 }
3291 }
3292 else
3293 {
3294 BIDI_Reorder(NULL, lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
3295 nSet, lpResults->lpOrder, NULL, NULL );
3296 }
3297
3298 /* FIXME: Will use the placement chars */
3299 if (lpResults->lpDx)
3300 {
3301 int c;
3302 for (i = 0; i < nSet; i++)
3303 {
3304 if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
3305 lpResults->lpDx[i]= c;
3306 }
3307 }
3308
3309 if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
3310 {
3311 int pos = 0;
3312
3313 lpResults->lpCaretPos[0] = 0;
3314 for (i = 1; i < nSet; i++)
3315 if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
3316 lpResults->lpCaretPos[i] = (pos += size.cx);
3317 }
3318
3319 if(lpResults->lpGlyphs)
3320 GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
3321
3322 if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
3323 ret = MAKELONG(size.cx, size.cy);
3324
3325 return ret;
3326 }
3327
3328 /*************************************************************************
3329 * GetCharABCWidthsFloatA [GDI32.@]
3330 *
3331 * See GetCharABCWidthsFloatW.
3332 */
3333 BOOL WINAPI GetCharABCWidthsFloatA( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3334 {
3335 INT i, wlen;
3336 LPSTR str;
3337 LPWSTR wstr;
3338 BOOL ret = TRUE;
3339
3340 str = FONT_GetCharsByRangeA(hdc, first, last, &i);
3341 if (str == NULL)
3342 return FALSE;
3343
3344 wstr = FONT_mbtowc( hdc, str, i, &wlen, NULL );
3345
3346 for (i = 0; i < wlen; i++)
3347 {
3348 if (!GetCharABCWidthsFloatW( hdc, wstr[i], wstr[i], abcf ))
3349 {
3350 ret = FALSE;
3351 break;
3352 }
3353 abcf++;
3354 }
3355
3356 HeapFree( GetProcessHeap(), 0, str );
3357 HeapFree( GetProcessHeap(), 0, wstr );
3358
3359 return ret;
3360 }
3361
3362 /*************************************************************************
3363 * GetCharABCWidthsFloatW [GDI32.@]
3364 *
3365 * Retrieves widths of a range of characters.
3366 *
3367 * PARAMS
3368 * hdc [I] Handle to device context.
3369 * first [I] First character in range to query.
3370 * last [I] Last character in range to query.
3371 * abcf [O] Array of LPABCFLOAT structures.
3372 *
3373 * RETURNS
3374 * Success: TRUE
3375 * Failure: FALSE
3376 */
3377 BOOL WINAPI GetCharABCWidthsFloatW( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3378 {
3379 UINT i;
3380 ABC *abc;
3381 PHYSDEV dev;
3382 BOOL ret = FALSE;
3383 DC *dc = get_dc_ptr( hdc );
3384
3385 TRACE("%p, %d, %d, %p\n", hdc, first, last, abcf);
3386
3387 if (!dc) return FALSE;
3388
3389 if (!abcf) goto done;
3390 if (!(abc = HeapAlloc( GetProcessHeap(), 0, (last - first + 1) * sizeof(*abc) ))) goto done;
3391
3392 dev = GET_DC_PHYSDEV( dc, pGetCharABCWidths );
3393 ret = dev->funcs->pGetCharABCWidths( dev, first, last, abc );
3394 if (ret)
3395 {
3396 /* convert device units to logical */
3397 FLOAT scale = fabs( dc->xformVport2World.eM11 );
3398 for (i = first; i <= last; i++, abcf++)
3399 {
3400 abcf->abcfA = abc[i - first].abcA * scale;
3401 abcf->abcfB = abc[i - first].abcB * scale;
3402 abcf->abcfC = abc[i - first].abcC * scale;
3403 }
3404 }
3405 HeapFree( GetProcessHeap(), 0, abc );
3406
3407 done:
3408 release_dc_ptr( dc );
3409 return ret;
3410 }
3411
3412 /*************************************************************************
3413 * GetCharWidthFloatA [GDI32.@]
3414 */
3415 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
3416 UINT iLastChar, PFLOAT pxBuffer)
3417 {
3418 FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3419 return FALSE;
3420 }
3421
3422 /*************************************************************************
3423 * GetCharWidthFloatW [GDI32.@]
3424 */
3425 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
3426 UINT iLastChar, PFLOAT pxBuffer)
3427 {
3428 FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3429 return FALSE;
3430 }
3431
3432
3433 /***********************************************************************
3434 * *
3435 * Font Resource API *
3436 * *
3437 ***********************************************************************/
3438
3439 /***********************************************************************
3440 * AddFontResourceA (GDI32.@)
3441 */
3442 INT WINAPI AddFontResourceA( LPCSTR str )
3443 {
3444 return AddFontResourceExA( str, 0, NULL);
3445 }
3446
3447 /***********************************************************************
3448 * AddFontResourceW (GDI32.@)
3449 */
3450 INT WINAPI AddFontResourceW( LPCWSTR str )
3451 {
3452 return AddFontResourceExW(str, 0, NULL);
3453 }
3454
3455
3456 /***********************************************************************
3457 * AddFontResourceExA (GDI32.@)
3458 */
3459 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3460 {
3461 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3462 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3463 INT ret;
3464
3465 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3466 ret = AddFontResourceExW(strW, fl, pdv);
3467 HeapFree(GetProcessHeap(), 0, strW);
3468 return ret;
3469 }
3470
3471 static BOOL CALLBACK load_enumed_resource(HMODULE hModule, LPCWSTR type, LPWSTR name, LONG_PTR lParam)
3472 {
3473 HRSRC rsrc = FindResourceW(hModule, name, type);
3474 HGLOBAL hMem = LoadResource(hModule, rsrc);
3475 LPVOID *pMem = LockResource(hMem);
3476 int *num_total = (int *)lParam;
3477 DWORD num_in_res;
3478
3479 TRACE("Found resource %s - trying to load\n", wine_dbgstr_w(type));
3480 if (!AddFontMemResourceEx(pMem, SizeofResource(hModule, rsrc), NULL, &num_in_res))
3481 {
3482 ERR("Failed to load PE font resource mod=%p ptr=%p\n", hModule, hMem);
3483 return FALSE;
3484 }
3485
3486 *num_total += num_in_res;
3487 return TRUE;
3488 }
3489
3490 static void *map_file( const WCHAR *filename, LARGE_INTEGER *size )
3491 {
3492 HANDLE file, mapping;
3493 void *ptr;
3494
3495 file = CreateFileW( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
3496 if (file == INVALID_HANDLE_VALUE) return NULL;
3497
3498 if (!GetFileSizeEx( file, size ) || size->u.HighPart)
3499 {
3500 CloseHandle( file );
3501 return NULL;
3502 }
3503
3504 mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
3505 CloseHandle( file );
3506 if (!mapping) return NULL;
3507
3508 ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
3509 CloseHandle( mapping );
3510
3511 return ptr;
3512 }
3513
3514 static void *find_resource( BYTE *ptr, WORD type, DWORD rsrc_off, DWORD size, DWORD *len )
3515 {
3516 WORD align, type_id, count;
3517 DWORD res_off;
3518
3519 if (size < rsrc_off + 10) return NULL;
3520 align = *(WORD *)(ptr + rsrc_off);
3521 rsrc_off += 2;
3522 type_id = *(WORD *)(ptr + rsrc_off);
3523 while (type_id && type_id != type)
3524 {
3525 count = *(WORD *)(ptr + rsrc_off + 2);
3526 rsrc_off += 8 + count * 12;
3527 if (size < rsrc_off + 8) return NULL;
3528 type_id = *(WORD *)(ptr + rsrc_off);
3529 }
3530 if (!type_id) return NULL;
3531 count = *(WORD *)(ptr + rsrc_off + 2);
3532 if (size < rsrc_off + 8 + count * 12) return NULL;
3533 res_off = *(WORD *)(ptr + rsrc_off + 8) << align;
3534 *len = *(WORD *)(ptr + rsrc_off + 10) << align;
3535 if (size < res_off + *len) return NULL;
3536 return ptr + res_off;
3537 }
3538
3539 static WCHAR *get_scalable_filename( const WCHAR *res, BOOL *hidden )
3540 {
3541 LARGE_INTEGER size;
3542 BYTE *ptr = map_file( res, &size );
3543 const IMAGE_DOS_HEADER *dos;
3544 const IMAGE_OS2_HEADER *ne;
3545 WORD *fontdir;
3546 char *data;
3547 WCHAR *name = NULL;
3548 DWORD len;
3549
3550 if (!ptr) return NULL;
3551
3552 if (size.u.LowPart < sizeof( *dos )) goto fail;
3553 dos = (const IMAGE_DOS_HEADER *)ptr;
3554 if (dos->e_magic != IMAGE_DOS_SIGNATURE) goto fail;
3555 if (size.u.LowPart < dos->e_lfanew + sizeof( *ne )) goto fail;
3556 ne = (const IMAGE_OS2_HEADER *)(ptr + dos->e_lfanew);
3557
3558 fontdir = find_resource( ptr, 0x8007, dos->e_lfanew + ne->ne_rsrctab, size.u.LowPart, &len );
3559 if (!fontdir) goto fail;
3560 *hidden = (fontdir[35] & 0x80) != 0; /* fontdir->dfType */
3561
3562 data = find_resource( ptr, 0x80cc, dos->e_lfanew + ne->ne_rsrctab, size.u.LowPart, &len );
3563 if (!data) goto fail;
3564 if (!memchr( data, 0, len )) goto fail;
3565
3566 len = MultiByteToWideChar( CP_ACP, 0, data, -1, NULL, 0 );
3567 name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3568 if (name) MultiByteToWideChar( CP_ACP, 0, data, -1, name, len );
3569
3570 fail:
3571 UnmapViewOfFile( ptr );
3572 return name;
3573 }
3574
3575 /***********************************************************************
3576 * AddFontResourceExW (GDI32.@)
3577 */
3578 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3579 {
3580 int ret = WineEngAddFontResourceEx(str, fl, pdv);
3581 WCHAR *filename;
3582 BOOL hidden;
3583
3584 if (ret == 0)
3585 {
3586 /* FreeType <2.3.5 has problems reading resources wrapped in PE files. */
3587 HMODULE hModule = LoadLibraryExW(str, NULL, LOAD_LIBRARY_AS_DATAFILE);
3588 if (hModule != NULL)
3589 {
3590 int num_resources = 0;
3591 LPWSTR rt_font = (LPWSTR)((ULONG_PTR)8); /* we don't want to include winuser.h */
3592
3593 TRACE("WineEngAddFontResourceEx failed on PE file %s - trying to load resources manually\n",
3594 wine_dbgstr_w(str));
3595 if (EnumResourceNamesW(hModule, rt_font, load_enumed_resource, (LONG_PTR)&num_resources))
3596 ret = num_resources;
3597 FreeLibrary(hModule);
3598 }
3599 else if ((filename = get_scalable_filename( str, &hidden )) != NULL)
3600 {
3601 if (hidden) fl |= FR_PRIVATE | FR_NOT_ENUM;
3602 ret = WineEngAddFontResourceEx( filename, fl, pdv );
3603 HeapFree( GetProcessHeap(), 0, filename );
3604 }
3605 }
3606 return ret;
3607 }
3608
3609 /***********************************************************************
3610 * RemoveFontResourceA (GDI32.@)
3611 */
3612 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
3613 {
3614 return RemoveFontResourceExA(str, 0, 0);
3615 }
3616
3617 /***********************************************************************
3618 * RemoveFontResourceW (GDI32.@)
3619 */
3620 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
3621 {
3622 return RemoveFontResourceExW(str, 0, 0);
3623 }
3624
3625 /***********************************************************************
3626 * AddFontMemResourceEx (GDI32.@)
3627 */
3628 HANDLE WINAPI AddFontMemResourceEx( PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
3629 {
3630 HANDLE ret;
3631 DWORD num_fonts;
3632
3633 if (!pbFont || !cbFont || !pcFonts)
3634 {
3635 SetLastError(ERROR_INVALID_PARAMETER);
3636 return NULL;
3637 }
3638
3639 ret = WineEngAddFontMemResourceEx(pbFont, cbFont, pdv, &num_fonts);
3640 if (ret)
3641 {
3642 __TRY
3643 {
3644 *pcFonts = num_fonts;
3645 }
3646 __EXCEPT_PAGE_FAULT
3647 {
3648 WARN("page fault while writing to *pcFonts (%p)\n", pcFonts);
3649 RemoveFontMemResourceEx(ret);
3650 ret = 0;
3651 }
3652 __ENDTRY
3653 }
3654 return ret;
3655 }
3656
3657 /***********************************************************************
3658 * RemoveFontMemResourceEx (GDI32.@)
3659 */
3660 BOOL WINAPI RemoveFontMemResourceEx( HANDLE fh )
3661 {
3662 FIXME("(%p) stub\n", fh);
3663 return TRUE;
3664 }
3665
3666 /***********************************************************************
3667 * RemoveFontResourceExA (GDI32.@)
3668 */
3669 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3670 {
3671 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3672 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3673 INT ret;
3674
3675 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3676 ret = RemoveFontResourceExW(strW, fl, pdv);
3677 HeapFree(GetProcessHeap(), 0, strW);
3678 return ret;
3679 }
3680
3681 /***********************************************************************
3682 * RemoveFontResourceExW (GDI32.@)
3683 */
3684 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3685 {
3686 int ret = WineEngRemoveFontResourceEx( str, fl, pdv );
3687 WCHAR *filename;
3688 BOOL hidden;
3689
3690 if (ret == 0)
3691 {
3692 /* FreeType <2.3.5 has problems reading resources wrapped in PE files. */
3693 HMODULE hModule = LoadLibraryExW(str, NULL, LOAD_LIBRARY_AS_DATAFILE);
3694 if (hModule != NULL)
3695 {
3696 WARN("Can't unload resources from PE file %s\n", wine_dbgstr_w(str));
3697 FreeLibrary(hModule);
3698 }
3699 else if ((filename = get_scalable_filename( str, &hidden )) != NULL)
3700 {
3701 if (hidden) fl |= FR_PRIVATE | FR_NOT_ENUM;
3702 ret = WineEngRemoveFontResourceEx( filename, fl, pdv );
3703 HeapFree( GetProcessHeap(), 0, filename );
3704 }
3705 }
3706 return ret;
3707 }
3708
3709 /***********************************************************************
3710 * GetFontResourceInfoW (GDI32.@)
3711 */
3712 BOOL WINAPI GetFontResourceInfoW( LPCWSTR str, LPDWORD size, PVOID buffer, DWORD type )
3713 {
3714 FIXME("%s %p(%d) %p %d\n", debugstr_w(str), size, size ? *size : 0, buffer, type);
3715 return FALSE;
3716 }
3717
3718 /***********************************************************************
3719 * GetTextCharset (GDI32.@)
3720 */
3721 UINT WINAPI GetTextCharset(HDC hdc)
3722 {
3723 /* MSDN docs say this is equivalent */
3724 return GetTextCharsetInfo(hdc, NULL, 0);
3725 }
3726
3727 /***********************************************************************
3728 * GdiGetCharDimensions (GDI32.@)
3729 *
3730 * Gets the average width of the characters in the English alphabet.
3731 *
3732 * PARAMS
3733 * hdc [I] Handle to the device context to measure on.
3734 * lptm [O] Pointer to memory to store the text metrics into.
3735 * height [O] On exit, the maximum height of characters in the English alphabet.
3736 *
3737 * RETURNS
3738 * The average width of characters in the English alphabet.
3739 *
3740 * NOTES
3741 * This function is used by the dialog manager to get the size of a dialog
3742 * unit. It should also be used by other pieces of code that need to know
3743 * the size of a dialog unit in logical units without having access to the
3744 * window handle of the dialog.
3745 * Windows caches the font metrics from this function, but we don't and
3746 * there doesn't appear to be an immediate advantage to do so.
3747 *
3748 * SEE ALSO
3749 * GetTextExtentPointW, GetTextMetricsW, MapDialogRect.
3750 */
3751 LONG WINAPI GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height)
3752 {
3753 SIZE sz;
3754 static const WCHAR alphabet[] = {
3755 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
3756 'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
3757 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
3758
3759 if(lptm && !GetTextMetricsW(hdc, lptm)) return 0;
3760
3761 if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
3762
3763 if (height) *height = sz.cy;
3764 return (sz.cx / 26 + 1) / 2;
3765 }
3766
3767 BOOL WINAPI EnableEUDC(BOOL fEnableEUDC)
3768 {
3769 FIXME("(%d): stub\n", fEnableEUDC);
3770 return FALSE;
3771 }
3772
3773 /***********************************************************************
3774 * GetCharWidthI (GDI32.@)
3775 *
3776 * Retrieve widths of characters.
3777 *
3778 * PARAMS
3779 * hdc [I] Handle to a device context.
3780 * first [I] First glyph in range to query.
3781 * count [I] Number of glyph indices to query.
3782 * glyphs [I] Array of glyphs to query.
3783 * buffer [O] Buffer to receive character widths.
3784 *
3785 * NOTES
3786 * Only works with TrueType fonts.
3787 *
3788 * RETURNS
3789 * Success: TRUE
3790 * Failure: FALSE
3791 */
3792 BOOL WINAPI GetCharWidthI(HDC hdc, UINT first, UINT count, LPWORD glyphs, LPINT buffer)
3793 {
3794 ABC *abc;
3795 unsigned int i;
3796
3797 TRACE("(%p, %d, %d, %p, %p)\n", hdc, first, count, glyphs, buffer);
3798
3799 if (!(abc = HeapAlloc(GetProcessHeap(), 0, count * sizeof(ABC))))
3800 return FALSE;
3801
3802 if (!GetCharABCWidthsI(hdc, first, count, glyphs, abc))
3803 {
3804 HeapFree(GetProcessHeap(), 0, abc);
3805 return FALSE;
3806 }
3807
3808 for (i = 0; i < count; i++)
3809 buffer[i] = abc->abcA + abc->abcB + abc->abcC;
3810
3811 HeapFree(GetProcessHeap(), 0, abc);
3812 return TRUE;
3813 }
3814
3815 /***********************************************************************
3816 * GetFontUnicodeRanges (GDI32.@)
3817 *
3818 * Retrieve a list of supported Unicode characters in a font.
3819 *
3820 * PARAMS
3821 * hdc [I] Handle to a device context.
3822 * lpgs [O] GLYPHSET structure specifying supported character ranges.
3823 *
3824 * RETURNS
3825 * Success: Number of bytes written to the buffer pointed to by lpgs.
3826 * Failure: 0
3827 *
3828 */
3829 DWORD WINAPI GetFontUnicodeRanges(HDC hdc, LPGLYPHSET lpgs)
3830 {
3831 DWORD ret;
3832 PHYSDEV dev;
3833 DC *dc = get_dc_ptr(hdc);
3834
3835 TRACE("(%p, %p)\n", hdc, lpgs);
3836
3837 if (!dc) return 0;
3838
3839 dev = GET_DC_PHYSDEV( dc, pGetFontUnicodeRanges );
3840 ret = dev->funcs->pGetFontUnicodeRanges( dev, lpgs );
3841 release_dc_ptr(dc);
3842 return ret;
3843 }
3844
3845
3846 /*************************************************************
3847 * FontIsLinked (GDI32.@)
3848 */
3849 BOOL WINAPI FontIsLinked(HDC hdc)
3850 {
3851 DC *dc = get_dc_ptr(hdc);
3852 PHYSDEV dev;
3853 BOOL ret;
3854
3855 if (!dc) return FALSE;
3856 dev = GET_DC_PHYSDEV( dc, pFontIsLinked );
3857 ret = dev->funcs->pFontIsLinked( dev );
3858 release_dc_ptr(dc);
3859 TRACE("returning %d\n", ret);
3860 return ret;
3861 }
3862
3863 /*************************************************************
3864 * GetFontRealizationInfo (GDI32.@)
3865 */
3866 BOOL WINAPI GetFontRealizationInfo(HDC hdc, struct font_realization_info *info)
3867 {
3868 BOOL is_v0 = info->size == FIELD_OFFSET(struct font_realization_info, unk);
3869 PHYSDEV dev;
3870 BOOL ret;
3871 DC *dc;
3872
3873 if (info->size != sizeof(*info) && !is_v0)
3874 return FALSE;
3875
3876 dc = get_dc_ptr(hdc);
3877 if (!dc) return FALSE;
3878 dev = GET_DC_PHYSDEV( dc, pGetFontRealizationInfo );
3879 ret = dev->funcs->pGetFontRealizationInfo( dev, info );
3880 release_dc_ptr(dc);
3881 return ret;
3882 }
3883
3884 struct realization_info
3885 {
3886 DWORD flags; /* 1 for bitmap fonts, 3 for scalable fonts */
3887 DWORD cache_num; /* keeps incrementing - num of fonts that have been created allowing for caching?? */
3888 DWORD instance_id; /* identifies a realized font instance */
3889 };
3890
3891 /*************************************************************
3892 * GdiRealizationInfo (GDI32.@)
3893 *
3894 * Returns a structure that contains some font information.
3895 */
3896 BOOL WINAPI GdiRealizationInfo(HDC hdc, struct realization_info *info)
3897 {
3898 struct font_realization_info ri;
3899 BOOL ret;
3900
3901 ri.size = sizeof(ri);
3902 ret = GetFontRealizationInfo( hdc, &ri );
3903 if (ret)
3904 {
3905 info->flags = ri.flags;
3906 info->cache_num = ri.cache_num;
3907 info->instance_id = ri.instance_id;
3908 }
3909
3910 return ret;
3911 }
Windows API implementation