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