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