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