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