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