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