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