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