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