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