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