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