?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shell32: Add explorer toolbar bitmaps.
[wine/hramrach.git] / dlls / gdi32 / font.c
blob7862565ea5b5f6823e81aa1a11c869df215e0c07
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 = 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 static int quietfixme = 0;
1652
1653 if (!dc) return FALSE;
1654
1655 breakRem = dc->breakRem;
1656
1657 if (quietfixme == 0 && flags & (ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN | ETO_PDY))
1658 {
1659 FIXME("flags ETO_NUMERICSLOCAL | ETO_NUMERICSLATIN | ETO_PDY unimplemented\n");
1660 quietfixme = 1;
1661 }
1662 if (!dc->funcs->pExtTextOut && !PATH_IsPathOpen(dc->path))
1663 {
1664 release_dc_ptr( dc );
1665 return ret;
1666 }
1667
1668 update_dc( dc );
1669 type = GetObjectType(hdc);
1670 if(type == OBJ_METADC || type == OBJ_ENHMETADC)
1671 {
1672 ret = dc->funcs->pExtTextOut(dc->physDev, x, y, flags, lprect, str, count, lpDx);
1673 release_dc_ptr( dc );
1674 return ret;
1675 }
1676
1677 if (!lprect)
1678 flags &= ~ETO_CLIPPED;
1679
1680 if( !(flags & (ETO_GLYPH_INDEX | ETO_IGNORELANGUAGE)) && count > 0 )
1681 {
1682 reordered_str = HeapAlloc(GetProcessHeap(), 0, count*sizeof(WCHAR));
1683
1684 BIDI_Reorder( str, count, GCP_REORDER,
1685 ((flags&ETO_RTLREADING)!=0 || (GetTextAlign(hdc)&TA_RTLREADING)!=0)?
1686 WINE_GCPW_FORCE_RTL:WINE_GCPW_FORCE_LTR,
1687 reordered_str, count, NULL );
1688
1689 flags |= ETO_IGNORELANGUAGE;
1690 }
1691
1692 TRACE("%p, %d, %d, %08x, %p, %s, %d, %p)\n", hdc, x, y, flags,
1693 lprect, debugstr_wn(str, count), count, lpDx);
1694
1695 if(flags & ETO_GLYPH_INDEX)
1696 glyphs = reordered_str;
1697
1698 if(lprect)
1699 TRACE("rect: %d,%d - %d,%d\n", lprect->left, lprect->top, lprect->right,
1700 lprect->bottom);
1701 TRACE("align = %x bkmode = %x mapmode = %x\n", align, GetBkMode(hdc), GetMapMode(hdc));
1702
1703 if(align & TA_UPDATECP)
1704 {
1705 GetCurrentPositionEx( hdc, &pt );
1706 x = pt.x;
1707 y = pt.y;
1708 }
1709
1710 GetTextMetricsW(hdc, &tm);
1711 GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
1712
1713 if(!(tm.tmPitchAndFamily & TMPF_VECTOR)) /* Non-scalable fonts shouldn't be rotated */
1714 lf.lfEscapement = 0;
1715
1716 if(lf.lfEscapement != 0)
1717 {
1718 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1719 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1720 }
1721 else
1722 {
1723 cosEsc = 1;
1724 sinEsc = 0;
1725 }
1726
1727 if(flags & (ETO_CLIPPED | ETO_OPAQUE))
1728 {
1729 if(!lprect)
1730 {
1731 if(flags & ETO_GLYPH_INDEX)
1732 GetTextExtentPointI(hdc, glyphs, count, &sz);
1733 else
1734 GetTextExtentPointW(hdc, reordered_str, count, &sz);
1735
1736 done_extents = TRUE;
1737 rc.left = x;
1738 rc.top = y;
1739 rc.right = x + sz.cx;
1740 rc.bottom = y + sz.cy;
1741 }
1742 else
1743 {
1744 rc = *lprect;
1745 }
1746
1747 LPtoDP(hdc, (POINT*)&rc, 2);
1748
1749 if(rc.left > rc.right) {INT tmp = rc.left; rc.left = rc.right; rc.right = tmp;}
1750 if(rc.top > rc.bottom) {INT tmp = rc.top; rc.top = rc.bottom; rc.bottom = tmp;}
1751 }
1752
1753 if ((flags & ETO_OPAQUE) && !PATH_IsPathOpen(dc->path))
1754 dc->funcs->pExtTextOut(dc->physDev, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
1755
1756 if(count == 0)
1757 {
1758 ret = TRUE;
1759 goto done;
1760 }
1761
1762 pt.x = x;
1763 pt.y = y;
1764 LPtoDP(hdc, &pt, 1);
1765 x = pt.x;
1766 y = pt.y;
1767
1768 char_extra = GetTextCharacterExtra(hdc);
1769 if(char_extra || dc->breakExtra || breakRem || lpDx || lf.lfEscapement != 0)
1770 {
1771 UINT i;
1772 SIZE tmpsz;
1773 deltas = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
1774 for(i = 0; i < count; i++)
1775 {
1776 if(lpDx && (flags & ETO_PDY))
1777 deltas[i] = lpDx[i*2] + char_extra;
1778 else if(lpDx)
1779 deltas[i] = lpDx[i] + char_extra;
1780 else
1781 {
1782 if(flags & ETO_GLYPH_INDEX)
1783 GetTextExtentPointI(hdc, glyphs + i, 1, &tmpsz);
1784 else
1785 GetTextExtentPointW(hdc, reordered_str + i, 1, &tmpsz);
1786
1787 deltas[i] = tmpsz.cx;
1788 }
1789
1790 if (!(flags & ETO_GLYPH_INDEX) && (dc->breakExtra || breakRem) && reordered_str[i] == tm.tmBreakChar)
1791 {
1792 deltas[i] = deltas[i] + dc->breakExtra;
1793 if (breakRem > 0)
1794 {
1795 breakRem--;
1796 deltas[i]++;
1797 }
1798 }
1799 deltas[i] = INTERNAL_XWSTODS(dc, deltas[i]);
1800 width += deltas[i];
1801 }
1802 }
1803 else
1804 {
1805 if(!done_extents)
1806 {
1807 if(flags & ETO_GLYPH_INDEX)
1808 GetTextExtentPointI(hdc, glyphs, count, &sz);
1809 else
1810 GetTextExtentPointW(hdc, reordered_str, count, &sz);
1811 done_extents = TRUE;
1812 }
1813 width = INTERNAL_XWSTODS(dc, sz.cx);
1814 }
1815 xwidth = width * cosEsc;
1816 ywidth = width * sinEsc;
1817
1818 tm.tmAscent = abs(INTERNAL_YWSTODS(dc, tm.tmAscent));
1819 tm.tmDescent = abs(INTERNAL_YWSTODS(dc, tm.tmDescent));
1820 switch( align & (TA_LEFT | TA_RIGHT | TA_CENTER) )
1821 {
1822 case TA_LEFT:
1823 if (align & TA_UPDATECP)
1824 {
1825 pt.x = x + xwidth;
1826 pt.y = y - ywidth;
1827 DPtoLP(hdc, &pt, 1);
1828 MoveToEx(hdc, pt.x, pt.y, NULL);
1829 }
1830 break;
1831
1832 case TA_CENTER:
1833 x -= xwidth / 2;
1834 y += ywidth / 2;
1835 break;
1836
1837 case TA_RIGHT:
1838 x -= xwidth;
1839 y += ywidth;
1840 if (align & TA_UPDATECP)
1841 {
1842 pt.x = x;
1843 pt.y = y;
1844 DPtoLP(hdc, &pt, 1);
1845 MoveToEx(hdc, pt.x, pt.y, NULL);
1846 }
1847 break;
1848 }
1849
1850 switch( align & (TA_TOP | TA_BOTTOM | TA_BASELINE) )
1851 {
1852 case TA_TOP:
1853 y += tm.tmAscent * cosEsc;
1854 x += tm.tmAscent * sinEsc;
1855 break;
1856
1857 case TA_BOTTOM:
1858 y -= tm.tmDescent * cosEsc;
1859 x -= tm.tmDescent * sinEsc;
1860 break;
1861
1862 case TA_BASELINE:
1863 break;
1864 }
1865
1866 if (GetBkMode(hdc) != TRANSPARENT && !PATH_IsPathOpen(dc->path))
1867 {
1868 if(!((flags & ETO_CLIPPED) && (flags & ETO_OPAQUE)))
1869 {
1870 if(!(flags & ETO_OPAQUE) || x < rc.left || x + width >= rc.right ||
1871 y - tm.tmAscent < rc.top || y + tm.tmDescent >= rc.bottom)
1872 {
1873 RECT rc;
1874 rc.left = x;
1875 rc.right = x + width;
1876 rc.top = y - tm.tmAscent;
1877 rc.bottom = y + tm.tmDescent;
1878 dc->funcs->pExtTextOut(dc->physDev, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
1879 }
1880 }
1881 }
1882
1883 if(FontIsLinked(hdc) && !(flags & ETO_GLYPH_INDEX))
1884 {
1885 HFONT orig_font = dc->hFont, cur_font;
1886 UINT glyph;
1887 INT span = 0, *offsets = NULL;
1888 unsigned int i;
1889
1890 glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WORD));
1891 for(i = 0; i < count; i++)
1892 {
1893 WineEngGetLinkedHFont(dc, reordered_str[i], &cur_font, &glyph);
1894 if(cur_font != dc->hFont)
1895 {
1896 if(!offsets)
1897 {
1898 unsigned int j;
1899 offsets = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*deltas));
1900 offsets[0] = 0;
1901 if(!deltas)
1902 {
1903 SIZE tmpsz;
1904 for(j = 1; j < count; j++)
1905 {
1906 GetTextExtentPointW(hdc, reordered_str + j - 1, 1, &tmpsz);
1907 offsets[j] = offsets[j-1] + INTERNAL_XWSTODS(dc, tmpsz.cx);
1908 }
1909 }
1910 else
1911 {
1912 for(j = 1; j < count; j++)
1913 offsets[j] = offsets[j-1] + deltas[j];
1914 }
1915 }
1916 if(span)
1917 {
1918 if (PATH_IsPathOpen(dc->path))
1919 ret = PATH_ExtTextOut(dc, x + offsets[i - span] * cosEsc, y - offsets[i - span] * sinEsc,
1920 (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc,
1921 glyphs, span, deltas ? deltas + i - span : NULL);
1922 else
1923 dc->funcs->pExtTextOut(dc->physDev, x + offsets[i - span] * cosEsc, y - offsets[i - span] * sinEsc,
1924 (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc,
1925 glyphs, span, deltas ? deltas + i - span : NULL);
1926 span = 0;
1927 }
1928 SelectObject(hdc, cur_font);
1929 }
1930 glyphs[span++] = glyph;
1931
1932 if(i == count - 1)
1933 {
1934 if (PATH_IsPathOpen(dc->path))
1935 ret = PATH_ExtTextOut(dc, x + (offsets ? offsets[count - span] * cosEsc : 0),
1936 y - (offsets ? offsets[count - span] * sinEsc : 0),
1937 (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc,
1938 glyphs, span, deltas ? deltas + count - span : NULL);
1939 else
1940 ret = dc->funcs->pExtTextOut(dc->physDev, x + (offsets ? offsets[count - span] * cosEsc : 0),
1941 y - (offsets ? offsets[count - span] * sinEsc : 0),
1942 (flags & ~ETO_OPAQUE) | ETO_GLYPH_INDEX, &rc,
1943 glyphs, span, deltas ? deltas + count - span : NULL);
1944 SelectObject(hdc, orig_font);
1945 HeapFree(GetProcessHeap(), 0, offsets);
1946 }
1947 }
1948 }
1949 else
1950 {
1951 if(!(flags & ETO_GLYPH_INDEX) && dc->gdiFont)
1952 {
1953 glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WORD));
1954 GetGlyphIndicesW(hdc, reordered_str, count, glyphs, 0);
1955 flags |= ETO_GLYPH_INDEX;
1956 }
1957
1958 if (PATH_IsPathOpen(dc->path))
1959 ret = PATH_ExtTextOut(dc, x, y, (flags & ~ETO_OPAQUE), &rc,
1960 glyphs ? glyphs : reordered_str, count, deltas);
1961 else
1962 ret = dc->funcs->pExtTextOut(dc->physDev, x, y, (flags & ~ETO_OPAQUE), &rc,
1963 glyphs ? glyphs : reordered_str, count, deltas);
1964 }
1965
1966 done:
1967 HeapFree(GetProcessHeap(), 0, deltas);
1968 if(glyphs != reordered_str)
1969 HeapFree(GetProcessHeap(), 0, glyphs);
1970 if(reordered_str != str)
1971 HeapFree(GetProcessHeap(), 0, reordered_str);
1972
1973 release_dc_ptr( dc );
1974
1975 if (ret && (lf.lfUnderline || lf.lfStrikeOut))
1976 {
1977 int underlinePos, strikeoutPos;
1978 int underlineWidth, strikeoutWidth;
1979 UINT size = GetOutlineTextMetricsW(hdc, 0, NULL);
1980 OUTLINETEXTMETRICW* otm = NULL;
1981
1982 if(!size)
1983 {
1984 underlinePos = 0;
1985 underlineWidth = tm.tmAscent / 20 + 1;
1986 strikeoutPos = tm.tmAscent / 2;
1987 strikeoutWidth = underlineWidth;
1988 }
1989 else
1990 {
1991 otm = HeapAlloc(GetProcessHeap(), 0, size);
1992 GetOutlineTextMetricsW(hdc, size, otm);
1993 underlinePos = otm->otmsUnderscorePosition;
1994 underlineWidth = otm->otmsUnderscoreSize;
1995 strikeoutPos = otm->otmsStrikeoutPosition;
1996 strikeoutWidth = otm->otmsStrikeoutSize;
1997 HeapFree(GetProcessHeap(), 0, otm);
1998 }
1999
2000 if (PATH_IsPathOpen(dc->path))
2001 {
2002 POINT pts[5];
2003 HPEN hpen;
2004 HBRUSH hbrush = CreateSolidBrush(GetTextColor(hdc));
2005
2006 hbrush = SelectObject(hdc, hbrush);
2007 hpen = SelectObject(hdc, GetStockObject(NULL_PEN));
2008
2009 if (lf.lfUnderline)
2010 {
2011 pts[0].x = x - underlinePos * sinEsc;
2012 pts[0].y = y - underlinePos * cosEsc;
2013 pts[1].x = x + xwidth - underlinePos * sinEsc;
2014 pts[1].y = y - ywidth - underlinePos * cosEsc;
2015 pts[2].x = pts[1].x + underlineWidth * sinEsc;
2016 pts[2].y = pts[1].y + underlineWidth * cosEsc;
2017 pts[3].x = pts[0].x + underlineWidth * sinEsc;
2018 pts[3].y = pts[0].y + underlineWidth * cosEsc;
2019 pts[4].x = pts[0].x;
2020 pts[4].y = pts[0].y;
2021 DPtoLP(hdc, pts, 5);
2022 Polygon(hdc, pts, 5);
2023 }
2024
2025 if (lf.lfStrikeOut)
2026 {
2027 pts[0].x = x - strikeoutPos * sinEsc;
2028 pts[0].y = y - strikeoutPos * cosEsc;
2029 pts[1].x = x + xwidth - strikeoutPos * sinEsc;
2030 pts[1].y = y - ywidth - strikeoutPos * cosEsc;
2031 pts[2].x = pts[1].x + strikeoutWidth * sinEsc;
2032 pts[2].y = pts[1].y + strikeoutWidth * cosEsc;
2033 pts[3].x = pts[0].x + strikeoutWidth * sinEsc;
2034 pts[3].y = pts[0].y + strikeoutWidth * cosEsc;
2035 pts[4].x = pts[0].x;
2036 pts[4].y = pts[0].y;
2037 DPtoLP(hdc, pts, 5);
2038 Polygon(hdc, pts, 5);
2039 }
2040
2041 SelectObject(hdc, hpen);
2042 hbrush = SelectObject(hdc, hbrush);
2043 DeleteObject(hbrush);
2044 }
2045 else
2046 {
2047 POINT pts[2], oldpt;
2048 HPEN hpen;
2049
2050 if (lf.lfUnderline)
2051 {
2052 hpen = CreatePen(PS_SOLID, underlineWidth, GetTextColor(hdc));
2053 hpen = SelectObject(hdc, hpen);
2054 pts[0].x = x;
2055 pts[0].y = y;
2056 pts[1].x = x + xwidth;
2057 pts[1].y = y - ywidth;
2058 DPtoLP(hdc, pts, 2);
2059 MoveToEx(hdc, pts[0].x - underlinePos * sinEsc, pts[0].y - underlinePos * cosEsc, &oldpt);
2060 LineTo(hdc, pts[1].x - underlinePos * sinEsc, pts[1].y - underlinePos * cosEsc);
2061 MoveToEx(hdc, oldpt.x, oldpt.y, NULL);
2062 DeleteObject(SelectObject(hdc, hpen));
2063 }
2064
2065 if (lf.lfStrikeOut)
2066 {
2067 hpen = CreatePen(PS_SOLID, strikeoutWidth, GetTextColor(hdc));
2068 hpen = SelectObject(hdc, hpen);
2069 pts[0].x = x;
2070 pts[0].y = y;
2071 pts[1].x = x + xwidth;
2072 pts[1].y = y - ywidth;
2073 DPtoLP(hdc, pts, 2);
2074 MoveToEx(hdc, pts[0].x - strikeoutPos * sinEsc, pts[0].y - strikeoutPos * cosEsc, &oldpt);
2075 LineTo(hdc, pts[1].x - strikeoutPos * sinEsc, pts[1].y - strikeoutPos * cosEsc);
2076 MoveToEx(hdc, oldpt.x, oldpt.y, NULL);
2077 DeleteObject(SelectObject(hdc, hpen));
2078 }
2079 }
2080 }
2081
2082 return ret;
2083 }
2084
2085
2086 /***********************************************************************
2087 * TextOutA (GDI32.@)
2088 */
2089 BOOL WINAPI TextOutA( HDC hdc, INT x, INT y, LPCSTR str, INT count )
2090 {
2091 return ExtTextOutA( hdc, x, y, 0, NULL, str, count, NULL );
2092 }
2093
2094
2095 /***********************************************************************
2096 * TextOutW (GDI32.@)
2097 */
2098 BOOL WINAPI TextOutW(HDC hdc, INT x, INT y, LPCWSTR str, INT count)
2099 {
2100 return ExtTextOutW( hdc, x, y, 0, NULL, str, count, NULL );
2101 }
2102
2103
2104 /***********************************************************************
2105 * PolyTextOutA (GDI32.@)
2106 *
2107 * See PolyTextOutW.
2108 */
2109 BOOL WINAPI PolyTextOutA( HDC hdc, const POLYTEXTA *pptxt, INT cStrings )
2110 {
2111 for (; cStrings>0; cStrings--, pptxt++)
2112 if (!ExtTextOutA( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2113 return FALSE;
2114 return TRUE;
2115 }
2116
2117
2118
2119 /***********************************************************************
2120 * PolyTextOutW (GDI32.@)
2121 *
2122 * Draw several Strings
2123 *
2124 * RETURNS
2125 * TRUE: Success.
2126 * FALSE: Failure.
2127 */
2128 BOOL WINAPI PolyTextOutW( HDC hdc, const POLYTEXTW *pptxt, INT cStrings )
2129 {
2130 for (; cStrings>0; cStrings--, pptxt++)
2131 if (!ExtTextOutW( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
2132 return FALSE;
2133 return TRUE;
2134 }
2135
2136
2137 /* FIXME: all following APIs ******************************************/
2138
2139
2140 /***********************************************************************
2141 * SetMapperFlags (GDI32.@)
2142 */
2143 DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
2144 {
2145 DC *dc = get_dc_ptr( hDC );
2146 DWORD ret = 0;
2147 if(!dc) return 0;
2148 if(dc->funcs->pSetMapperFlags)
2149 {
2150 ret = dc->funcs->pSetMapperFlags( dc->physDev, dwFlag );
2151 /* FIXME: ret is just a success flag, we should return a proper value */
2152 }
2153 else
2154 FIXME("(%p, 0x%08x): stub - harmless\n", hDC, dwFlag);
2155 release_dc_ptr( dc );
2156 return ret;
2157 }
2158
2159 /***********************************************************************
2160 * GetAspectRatioFilterEx (GDI32.@)
2161 */
2162 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
2163 {
2164 FIXME("(%p, %p): -- Empty Stub !\n", hdc, pAspectRatio);
2165 return FALSE;
2166 }
2167
2168
2169 /***********************************************************************
2170 * GetCharABCWidthsA (GDI32.@)
2171 *
2172 * See GetCharABCWidthsW.
2173 */
2174 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
2175 LPABC abc )
2176 {
2177 INT i, wlen, count = (INT)(lastChar - firstChar + 1);
2178 LPSTR str;
2179 LPWSTR wstr;
2180 BOOL ret = TRUE;
2181
2182 if(count <= 0) return FALSE;
2183
2184 str = HeapAlloc(GetProcessHeap(), 0, count);
2185 for(i = 0; i < count; i++)
2186 str[i] = (BYTE)(firstChar + i);
2187
2188 wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
2189
2190 for(i = 0; i < wlen; i++)
2191 {
2192 if(!GetCharABCWidthsW(hdc, wstr[i], wstr[i], abc))
2193 {
2194 ret = FALSE;
2195 break;
2196 }
2197 abc++;
2198 }
2199
2200 HeapFree(GetProcessHeap(), 0, str);
2201 HeapFree(GetProcessHeap(), 0, wstr);
2202
2203 return ret;
2204 }
2205
2206
2207 /******************************************************************************
2208 * GetCharABCWidthsW [GDI32.@]
2209 *
2210 * Retrieves widths of characters in range.
2211 *
2212 * PARAMS
2213 * hdc [I] Handle of device context
2214 * firstChar [I] First character in range to query
2215 * lastChar [I] Last character in range to query
2216 * abc [O] Address of character-width structure
2217 *
2218 * NOTES
2219 * Only works with TrueType fonts
2220 *
2221 * RETURNS
2222 * Success: TRUE
2223 * Failure: FALSE
2224 */
2225 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
2226 LPABC abc )
2227 {
2228 DC *dc = get_dc_ptr(hdc);
2229 unsigned int i;
2230 BOOL ret = FALSE;
2231
2232 if (!dc) return FALSE;
2233
2234 if (!abc)
2235 {
2236 release_dc_ptr( dc );
2237 return FALSE;
2238 }
2239
2240 if(dc->gdiFont)
2241 ret = WineEngGetCharABCWidths( dc->gdiFont, firstChar, lastChar, abc );
2242 else
2243 FIXME(": stub\n");
2244
2245 if (ret)
2246 {
2247 /* convert device units to logical */
2248 for( i = firstChar; i <= lastChar; i++, abc++ ) {
2249 abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
2250 abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
2251 abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
2252 }
2253 ret = TRUE;
2254 }
2255
2256 release_dc_ptr( dc );
2257 return ret;
2258 }
2259
2260
2261 /******************************************************************************
2262 * GetCharABCWidthsI [GDI32.@]
2263 *
2264 * Retrieves widths of characters in range.
2265 *
2266 * PARAMS
2267 * hdc [I] Handle of device context
2268 * firstChar [I] First glyphs in range to query
2269 * count [I] Last glyphs in range to query
2270 * pgi [i] Array of glyphs to query
2271 * abc [O] Address of character-width structure
2272 *
2273 * NOTES
2274 * Only works with TrueType fonts
2275 *
2276 * RETURNS
2277 * Success: TRUE
2278 * Failure: FALSE
2279 */
2280 BOOL WINAPI GetCharABCWidthsI( HDC hdc, UINT firstChar, UINT count,
2281 LPWORD pgi, LPABC abc)
2282 {
2283 DC *dc = get_dc_ptr(hdc);
2284 unsigned int i;
2285 BOOL ret = FALSE;
2286
2287 if (!dc) return FALSE;
2288
2289 if (!abc)
2290 {
2291 release_dc_ptr( dc );
2292 return FALSE;
2293 }
2294
2295 if(dc->gdiFont)
2296 ret = WineEngGetCharABCWidthsI( dc->gdiFont, firstChar, count, pgi, abc );
2297 else
2298 FIXME(": stub\n");
2299
2300 if (ret)
2301 {
2302 /* convert device units to logical */
2303 for( i = 0; i < count; i++, abc++ ) {
2304 abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
2305 abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
2306 abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
2307 }
2308 ret = TRUE;
2309 }
2310
2311 release_dc_ptr( dc );
2312 return ret;
2313 }
2314
2315
2316 /***********************************************************************
2317 * GetGlyphOutlineA (GDI32.@)
2318 */
2319 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
2320 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2321 LPVOID lpBuffer, const MAT2 *lpmat2 )
2322 {
2323 LPWSTR p = NULL;
2324 DWORD ret;
2325 UINT c;
2326
2327 if(!(fuFormat & GGO_GLYPH_INDEX)) {
2328 int len;
2329 char mbchs[2];
2330 if(uChar > 0xff) { /* but, 2 bytes character only */
2331 len = 2;
2332 mbchs[0] = (uChar & 0xff00) >> 8;
2333 mbchs[1] = (uChar & 0xff);
2334 } else {
2335 len = 1;
2336 mbchs[0] = (uChar & 0xff);
2337 }
2338 p = FONT_mbtowc(hdc, mbchs, len, NULL, NULL);
2339 c = p[0];
2340 } else
2341 c = uChar;
2342 ret = GetGlyphOutlineW(hdc, c, fuFormat, lpgm, cbBuffer, lpBuffer,
2343 lpmat2);
2344 HeapFree(GetProcessHeap(), 0, p);
2345 return ret;
2346 }
2347
2348 /***********************************************************************
2349 * GetGlyphOutlineW (GDI32.@)
2350 */
2351 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
2352 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
2353 LPVOID lpBuffer, const MAT2 *lpmat2 )
2354 {
2355 DC *dc = get_dc_ptr(hdc);
2356 DWORD ret;
2357
2358 TRACE("(%p, %04x, %04x, %p, %d, %p, %p)\n",
2359 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
2360
2361 if(!dc) return GDI_ERROR;
2362
2363 if(dc->gdiFont)
2364 ret = WineEngGetGlyphOutline(dc->gdiFont, uChar, fuFormat, lpgm,
2365 cbBuffer, lpBuffer, lpmat2);
2366 else
2367 ret = GDI_ERROR;
2368
2369 release_dc_ptr( dc );
2370 return ret;
2371 }
2372
2373
2374 /***********************************************************************
2375 * CreateScalableFontResourceA (GDI32.@)
2376 */
2377 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
2378 LPCSTR lpszResourceFile,
2379 LPCSTR lpszFontFile,
2380 LPCSTR lpszCurrentPath )
2381 {
2382 LPWSTR lpszResourceFileW = NULL;
2383 LPWSTR lpszFontFileW = NULL;
2384 LPWSTR lpszCurrentPathW = NULL;
2385 int len;
2386 BOOL ret;
2387
2388 if (lpszResourceFile)
2389 {
2390 len = MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, NULL, 0);
2391 lpszResourceFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2392 MultiByteToWideChar(CP_ACP, 0, lpszResourceFile, -1, lpszResourceFileW, len);
2393 }
2394
2395 if (lpszFontFile)
2396 {
2397 len = MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, NULL, 0);
2398 lpszFontFileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2399 MultiByteToWideChar(CP_ACP, 0, lpszFontFile, -1, lpszFontFileW, len);
2400 }
2401
2402 if (lpszCurrentPath)
2403 {
2404 len = MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, NULL, 0);
2405 lpszCurrentPathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2406 MultiByteToWideChar(CP_ACP, 0, lpszCurrentPath, -1, lpszCurrentPathW, len);
2407 }
2408
2409 ret = CreateScalableFontResourceW(fHidden, lpszResourceFileW,
2410 lpszFontFileW, lpszCurrentPathW);
2411
2412 HeapFree(GetProcessHeap(), 0, lpszResourceFileW);
2413 HeapFree(GetProcessHeap(), 0, lpszFontFileW);
2414 HeapFree(GetProcessHeap(), 0, lpszCurrentPathW);
2415
2416 return ret;
2417 }
2418
2419 /***********************************************************************
2420 * CreateScalableFontResourceW (GDI32.@)
2421 */
2422 BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
2423 LPCWSTR lpszResourceFile,
2424 LPCWSTR lpszFontFile,
2425 LPCWSTR lpszCurrentPath )
2426 {
2427 HANDLE f;
2428 FIXME("(%d,%s,%s,%s): stub\n",
2429 fHidden, debugstr_w(lpszResourceFile), debugstr_w(lpszFontFile),
2430 debugstr_w(lpszCurrentPath) );
2431
2432 /* fHidden=1 - only visible for the calling app, read-only, not
2433 * enumerated with EnumFonts/EnumFontFamilies
2434 * lpszCurrentPath can be NULL
2435 */
2436
2437 /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
2438 if ((f = CreateFileW(lpszResourceFile, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE) {
2439 CloseHandle(f);
2440 SetLastError(ERROR_FILE_EXISTS);
2441 return FALSE;
2442 }
2443 return FALSE; /* create failed */
2444 }
2445
2446 /*************************************************************************
2447 * GetKerningPairsA (GDI32.@)
2448 */
2449 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
2450 LPKERNINGPAIR kern_pairA )
2451 {
2452 INT charset;
2453 CHARSETINFO csi;
2454 CPINFO cpi;
2455 DWORD i, total_kern_pairs, kern_pairs_copied = 0;
2456 KERNINGPAIR *kern_pairW;
2457
2458 if (!cPairs && kern_pairA)
2459 {
2460 SetLastError(ERROR_INVALID_PARAMETER);
2461 return 0;
2462 }
2463
2464 charset = GetTextCharset(hDC);
2465 if (!TranslateCharsetInfo(ULongToPtr(charset), &csi, TCI_SRCCHARSET))
2466 {
2467 FIXME("Can't find codepage for charset %d\n", charset);
2468 return 0;
2469 }
2470 /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
2471 * to fail on an invalid character for CP_SYMBOL.
2472 */
2473 cpi.DefaultChar[0] = 0;
2474 if (csi.ciACP != CP_SYMBOL && !GetCPInfo(csi.ciACP, &cpi))
2475 {
2476 FIXME("Can't find codepage %u info\n", csi.ciACP);
2477 return 0;
2478 }
2479 TRACE("charset %d => codepage %u\n", charset, csi.ciACP);
2480
2481 total_kern_pairs = GetKerningPairsW(hDC, 0, NULL);
2482 if (!total_kern_pairs) return 0;
2483
2484 kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
2485 GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
2486
2487 for (i = 0; i < total_kern_pairs; i++)
2488 {
2489 char first, second;
2490
2491 if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
2492 continue;
2493
2494 if (!WideCharToMultiByte(csi.ciACP, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
2495 continue;
2496
2497 if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
2498 continue;
2499
2500 if (kern_pairA)
2501 {
2502 if (kern_pairs_copied >= cPairs) break;
2503
2504 kern_pairA->wFirst = (BYTE)first;
2505 kern_pairA->wSecond = (BYTE)second;
2506 kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
2507 kern_pairA++;
2508 }
2509 kern_pairs_copied++;
2510 }
2511
2512 HeapFree(GetProcessHeap(), 0, kern_pairW);
2513
2514 return kern_pairs_copied;
2515 }
2516
2517 /*************************************************************************
2518 * GetKerningPairsW (GDI32.@)
2519 */
2520 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
2521 LPKERNINGPAIR lpKerningPairs )
2522 {
2523 DC *dc;
2524 DWORD ret = 0;
2525
2526 TRACE("(%p,%d,%p)\n", hDC, cPairs, lpKerningPairs);
2527
2528 if (!cPairs && lpKerningPairs)
2529 {
2530 SetLastError(ERROR_INVALID_PARAMETER);
2531 return 0;
2532 }
2533
2534 dc = get_dc_ptr(hDC);
2535 if (!dc) return 0;
2536
2537 if (dc->gdiFont)
2538 ret = WineEngGetKerningPairs(dc->gdiFont, cPairs, lpKerningPairs);
2539
2540 release_dc_ptr( dc );
2541 return ret;
2542 }
2543
2544 /*************************************************************************
2545 * TranslateCharsetInfo [GDI32.@]
2546 *
2547 * Fills a CHARSETINFO structure for a character set, code page, or
2548 * font. This allows making the correspondence between different labels
2549 * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
2550 * of the same encoding.
2551 *
2552 * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
2553 * only one codepage should be set in *lpSrc.
2554 *
2555 * RETURNS
2556 * TRUE on success, FALSE on failure.
2557 *
2558 */
2559 BOOL WINAPI TranslateCharsetInfo(
2560 LPDWORD lpSrc, /* [in]
2561 if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
2562 if flags == TCI_SRCCHARSET: a character set value
2563 if flags == TCI_SRCCODEPAGE: a code page value
2564 */
2565 LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
2566 DWORD flags /* [in] determines interpretation of lpSrc */)
2567 {
2568 int index = 0;
2569 switch (flags) {
2570 case TCI_SRCFONTSIG:
2571 while (!(*lpSrc>>index & 0x0001) && index<MAXTCIINDEX) index++;
2572 break;
2573 case TCI_SRCCODEPAGE:
2574 while (PtrToUlong(lpSrc) != FONT_tci[index].ciACP && index < MAXTCIINDEX) index++;
2575 break;
2576 case TCI_SRCCHARSET:
2577 while (PtrToUlong(lpSrc) != FONT_tci[index].ciCharset && index < MAXTCIINDEX) index++;
2578 break;
2579 default:
2580 return FALSE;
2581 }
2582 if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
2583 *lpCs = FONT_tci[index];
2584 return TRUE;
2585 }
2586
2587 /*************************************************************************
2588 * GetFontLanguageInfo (GDI32.@)
2589 */
2590 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
2591 {
2592 FONTSIGNATURE fontsig;
2593 static const DWORD GCP_DBCS_MASK=0x003F0000,
2594 GCP_DIACRITIC_MASK=0x00000000,
2595 FLI_GLYPHS_MASK=0x00000000,
2596 GCP_GLYPHSHAPE_MASK=0x00000040,
2597 GCP_KASHIDA_MASK=0x00000000,
2598 GCP_LIGATE_MASK=0x00000000,
2599 GCP_USEKERNING_MASK=0x00000000,
2600 GCP_REORDER_MASK=0x00000060;
2601
2602 DWORD result=0;
2603
2604 GetTextCharsetInfo( hdc, &fontsig, 0 );
2605 /* We detect each flag we return using a bitmask on the Codepage Bitfields */
2606
2607 if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
2608 result|=GCP_DBCS;
2609
2610 if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
2611 result|=GCP_DIACRITIC;
2612
2613 if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
2614 result|=FLI_GLYPHS;
2615
2616 if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
2617 result|=GCP_GLYPHSHAPE;
2618
2619 if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
2620 result|=GCP_KASHIDA;
2621
2622 if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
2623 result|=GCP_LIGATE;
2624
2625 if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
2626 result|=GCP_USEKERNING;
2627
2628 /* this might need a test for a HEBREW- or ARABIC_CHARSET as well */
2629 if( GetTextAlign( hdc) & TA_RTLREADING )
2630 if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
2631 result|=GCP_REORDER;
2632
2633 return result;
2634 }
2635
2636
2637 /*************************************************************************
2638 * GetFontData [GDI32.@]
2639 *
2640 * Retrieve data for TrueType font.
2641 *
2642 * RETURNS
2643 *
2644 * success: Number of bytes returned
2645 * failure: GDI_ERROR
2646 *
2647 * NOTES
2648 *
2649 * Calls SetLastError()
2650 *
2651 */
2652 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
2653 LPVOID buffer, DWORD length)
2654 {
2655 DC *dc = get_dc_ptr(hdc);
2656 DWORD ret = GDI_ERROR;
2657
2658 if(!dc) return GDI_ERROR;
2659
2660 if(dc->gdiFont)
2661 ret = WineEngGetFontData(dc->gdiFont, table, offset, buffer, length);
2662
2663 release_dc_ptr( dc );
2664 return ret;
2665 }
2666
2667 /*************************************************************************
2668 * GetGlyphIndicesA [GDI32.@]
2669 */
2670 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
2671 LPWORD pgi, DWORD flags)
2672 {
2673 DWORD ret;
2674 WCHAR *lpstrW;
2675 INT countW;
2676
2677 TRACE("(%p, %s, %d, %p, 0x%x)\n",
2678 hdc, debugstr_an(lpstr, count), count, pgi, flags);
2679
2680 lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
2681 ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
2682 HeapFree(GetProcessHeap(), 0, lpstrW);
2683
2684 return ret;
2685 }
2686
2687 /*************************************************************************
2688 * GetGlyphIndicesW [GDI32.@]
2689 */
2690 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
2691 LPWORD pgi, DWORD flags)
2692 {
2693 DC *dc = get_dc_ptr(hdc);
2694 DWORD ret = GDI_ERROR;
2695
2696 TRACE("(%p, %s, %d, %p, 0x%x)\n",
2697 hdc, debugstr_wn(lpstr, count), count, pgi, flags);
2698
2699 if(!dc) return GDI_ERROR;
2700
2701 if(dc->gdiFont)
2702 ret = WineEngGetGlyphIndices(dc->gdiFont, lpstr, count, pgi, flags);
2703
2704 release_dc_ptr( dc );
2705 return ret;
2706 }
2707
2708 /*************************************************************************
2709 * GetCharacterPlacementA [GDI32.@]
2710 *
2711 * See GetCharacterPlacementW.
2712 *
2713 * NOTES:
2714 * the web browser control of ie4 calls this with dwFlags=0
2715 */
2716 DWORD WINAPI
2717 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
2718 INT nMaxExtent, GCP_RESULTSA *lpResults,
2719 DWORD dwFlags)
2720 {
2721 WCHAR *lpStringW;
2722 INT uCountW;
2723 GCP_RESULTSW resultsW;
2724 DWORD ret;
2725 UINT font_cp;
2726
2727 TRACE("%s, %d, %d, 0x%08x\n",
2728 debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
2729
2730 /* both structs are equal in size */
2731 memcpy(&resultsW, lpResults, sizeof(resultsW));
2732
2733 lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
2734 if(lpResults->lpOutString)
2735 resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
2736
2737 ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
2738
2739 lpResults->nGlyphs = resultsW.nGlyphs;
2740 lpResults->nMaxFit = resultsW.nMaxFit;
2741
2742 if(lpResults->lpOutString) {
2743 WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
2744 lpResults->lpOutString, uCount, NULL, NULL );
2745 }
2746
2747 HeapFree(GetProcessHeap(), 0, lpStringW);
2748 HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
2749
2750 return ret;
2751 }
2752
2753 /*************************************************************************
2754 * GetCharacterPlacementW [GDI32.@]
2755 *
2756 * Retrieve information about a string. This includes the width, reordering,
2757 * Glyphing and so on.
2758 *
2759 * RETURNS
2760 *
2761 * The width and height of the string if successful, 0 if failed.
2762 *
2763 * BUGS
2764 *
2765 * All flags except GCP_REORDER are not yet implemented.
2766 * Reordering is not 100% compliant to the Windows BiDi method.
2767 * Caret positioning is not yet implemented for BiDi.
2768 * Classes are not yet implemented.
2769 *
2770 */
2771 DWORD WINAPI
2772 GetCharacterPlacementW(
2773 HDC hdc, /* [in] Device context for which the rendering is to be done */
2774 LPCWSTR lpString, /* [in] The string for which information is to be returned */
2775 INT uCount, /* [in] Number of WORDS in string. */
2776 INT nMaxExtent, /* [in] Maximum extent the string is to take (in HDC logical units) */
2777 GCP_RESULTSW *lpResults,/* [in/out] A pointer to a GCP_RESULTSW struct */
2778 DWORD dwFlags /* [in] Flags specifying how to process the string */
2779 )
2780 {
2781 DWORD ret=0;
2782 SIZE size;
2783 UINT i, nSet;
2784
2785 TRACE("%s, %d, %d, 0x%08x\n",
2786 debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
2787
2788 TRACE("lStructSize=%d, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
2789 "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
2790 lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
2791 lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
2792 lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
2793
2794 if(dwFlags&(~GCP_REORDER)) FIXME("flags 0x%08x ignored\n", dwFlags);
2795 if(lpResults->lpClass) FIXME("classes not implemented\n");
2796 if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
2797 FIXME("Caret positions for complex scripts not implemented\n");
2798
2799 nSet = (UINT)uCount;
2800 if(nSet > lpResults->nGlyphs)
2801 nSet = lpResults->nGlyphs;
2802
2803 /* return number of initialized fields */
2804 lpResults->nGlyphs = nSet;
2805
2806 if((dwFlags&GCP_REORDER)==0 )
2807 {
2808 /* Treat the case where no special handling was requested in a fastpath way */
2809 /* copy will do if the GCP_REORDER flag is not set */
2810 if(lpResults->lpOutString)
2811 memcpy( lpResults->lpOutString, lpString, nSet * sizeof(WCHAR));
2812
2813 if(lpResults->lpOrder)
2814 {
2815 for(i = 0; i < nSet; i++)
2816 lpResults->lpOrder[i] = i;
2817 }
2818 } else
2819 {
2820 BIDI_Reorder( lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
2821 nSet, lpResults->lpOrder );
2822 }
2823
2824 /* FIXME: Will use the placement chars */
2825 if (lpResults->lpDx)
2826 {
2827 int c;
2828 for (i = 0; i < nSet; i++)
2829 {
2830 if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
2831 lpResults->lpDx[i]= c;
2832 }
2833 }
2834
2835 if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
2836 {
2837 int pos = 0;
2838
2839 lpResults->lpCaretPos[0] = 0;
2840 for (i = 1; i < nSet; i++)
2841 if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
2842 lpResults->lpCaretPos[i] = (pos += size.cx);
2843 }
2844
2845 if(lpResults->lpGlyphs)
2846 GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
2847
2848 if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
2849 ret = MAKELONG(size.cx, size.cy);
2850
2851 return ret;
2852 }
2853
2854 /*************************************************************************
2855 * GetCharABCWidthsFloatA [GDI32.@]
2856 *
2857 * See GetCharABCWidthsFloatW.
2858 */
2859 BOOL WINAPI GetCharABCWidthsFloatA( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
2860 {
2861 INT i, wlen, count = (INT)(last - first + 1);
2862 LPSTR str;
2863 LPWSTR wstr;
2864 BOOL ret = TRUE;
2865
2866 if (count <= 0) return FALSE;
2867
2868 str = HeapAlloc(GetProcessHeap(), 0, count);
2869
2870 for(i = 0; i < count; i++)
2871 str[i] = (BYTE)(first + i);
2872
2873 wstr = FONT_mbtowc( hdc, str, count, &wlen, NULL );
2874
2875 for (i = 0; i < wlen; i++)
2876 {
2877 if (!GetCharABCWidthsFloatW( hdc, wstr[i], wstr[i], abcf ))
2878 {
2879 ret = FALSE;
2880 break;
2881 }
2882 abcf++;
2883 }
2884
2885 HeapFree( GetProcessHeap(), 0, str );
2886 HeapFree( GetProcessHeap(), 0, wstr );
2887
2888 return ret;
2889 }
2890
2891 /*************************************************************************
2892 * GetCharABCWidthsFloatW [GDI32.@]
2893 *
2894 * Retrieves widths of a range of characters.
2895 *
2896 * PARAMS
2897 * hdc [I] Handle to device context.
2898 * first [I] First character in range to query.
2899 * last [I] Last character in range to query.
2900 * abcf [O] Array of LPABCFLOAT structures.
2901 *
2902 * RETURNS
2903 * Success: TRUE
2904 * Failure: FALSE
2905 *
2906 * BUGS
2907 * Only works with TrueType fonts. It also doesn't return real
2908 * floats but converted integers because it's implemented on
2909 * top of GetCharABCWidthsW.
2910 */
2911 BOOL WINAPI GetCharABCWidthsFloatW( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
2912 {
2913 ABC *abc, *abc_base;
2914 unsigned int i, size = sizeof(ABC) * (last - first + 1);
2915 BOOL ret;
2916
2917 TRACE("%p, %d, %d, %p - partial stub\n", hdc, first, last, abcf);
2918
2919 abc = abc_base = HeapAlloc( GetProcessHeap(), 0, size );
2920 if (!abc) return FALSE;
2921
2922 ret = GetCharABCWidthsW( hdc, first, last, abc );
2923 if (ret)
2924 {
2925 for (i = first; i <= last; i++, abc++, abcf++)
2926 {
2927 abcf->abcfA = abc->abcA;
2928 abcf->abcfB = abc->abcB;
2929 abcf->abcfC = abc->abcC;
2930 }
2931 }
2932 HeapFree( GetProcessHeap(), 0, abc_base );
2933 return ret;
2934 }
2935
2936 /*************************************************************************
2937 * GetCharWidthFloatA [GDI32.@]
2938 */
2939 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
2940 UINT iLastChar, PFLOAT pxBuffer)
2941 {
2942 FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
2943 return 0;
2944 }
2945
2946 /*************************************************************************
2947 * GetCharWidthFloatW [GDI32.@]
2948 */
2949 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
2950 UINT iLastChar, PFLOAT pxBuffer)
2951 {
2952 FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
2953 return 0;
2954 }
2955
2956
2957 /***********************************************************************
2958 * *
2959 * Font Resource API *
2960 * *
2961 ***********************************************************************/
2962
2963 /***********************************************************************
2964 * AddFontResourceA (GDI32.@)
2965 */
2966 INT WINAPI AddFontResourceA( LPCSTR str )
2967 {
2968 return AddFontResourceExA( str, 0, NULL);
2969 }
2970
2971 /***********************************************************************
2972 * AddFontResourceW (GDI32.@)
2973 */
2974 INT WINAPI AddFontResourceW( LPCWSTR str )
2975 {
2976 return AddFontResourceExW(str, 0, NULL);
2977 }
2978
2979
2980 /***********************************************************************
2981 * AddFontResourceExA (GDI32.@)
2982 */
2983 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
2984 {
2985 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
2986 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2987 INT ret;
2988
2989 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
2990 ret = AddFontResourceExW(strW, fl, pdv);
2991 HeapFree(GetProcessHeap(), 0, strW);
2992 return ret;
2993 }
2994
2995 static BOOL CALLBACK load_enumed_resource(HMODULE hModule, LPCWSTR type, LPWSTR name, LONG_PTR lParam)
2996 {
2997 HRSRC rsrc = FindResourceW(hModule, name, type);
2998 HGLOBAL hMem = LoadResource(hModule, rsrc);
2999 LPVOID *pMem = LockResource(hMem);
3000 int *num_total = (int *)lParam;
3001 DWORD num_in_res;
3002
3003 TRACE("Found resource %s - trying to load\n", wine_dbgstr_w(type));
3004 if (!AddFontMemResourceEx(pMem, SizeofResource(hModule, rsrc), NULL, &num_in_res))
3005 {
3006 ERR("Failed to load PE font resource mod=%p ptr=%p\n", hModule, hMem);
3007 return FALSE;
3008 }
3009
3010 *num_total += num_in_res;
3011 return TRUE;
3012 }
3013
3014 /***********************************************************************
3015 * AddFontResourceExW (GDI32.@)
3016 */
3017 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3018 {
3019 int ret = WineEngAddFontResourceEx(str, fl, pdv);
3020 if (ret == 0)
3021 {
3022 /* FreeType <2.3.5 has problems reading resources wrapped in PE files. */
3023 HMODULE hModule = LoadLibraryExW(str, NULL, LOAD_LIBRARY_AS_DATAFILE);
3024 if (hModule != NULL)
3025 {
3026 int num_resources = 0;
3027 LPWSTR rt_font = (LPWSTR)((ULONG_PTR)8); /* we don't want to include winuser.h */
3028
3029 TRACE("WineEndAddFontResourceEx failed on PE file %s - trying to load resources manually\n",
3030 wine_dbgstr_w(str));
3031 if (EnumResourceNamesW(hModule, rt_font, load_enumed_resource, (LONG_PTR)&num_resources))
3032 ret = num_resources;
3033 FreeLibrary(hModule);
3034 }
3035 }
3036 return ret;
3037 }
3038
3039 /***********************************************************************
3040 * RemoveFontResourceA (GDI32.@)
3041 */
3042 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
3043 {
3044 return RemoveFontResourceExA(str, 0, 0);
3045 }
3046
3047 /***********************************************************************
3048 * RemoveFontResourceW (GDI32.@)
3049 */
3050 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
3051 {
3052 return RemoveFontResourceExW(str, 0, 0);
3053 }
3054
3055 /***********************************************************************
3056 * AddFontMemResourceEx (GDI32.@)
3057 */
3058 HANDLE WINAPI AddFontMemResourceEx( PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
3059 {
3060 return WineEngAddFontMemResourceEx(pbFont, cbFont, pdv, pcFonts);
3061 }
3062
3063 /***********************************************************************
3064 * RemoveFontMemResourceEx (GDI32.@)
3065 */
3066 BOOL WINAPI RemoveFontMemResourceEx( HANDLE fh )
3067 {
3068 FIXME("(%p) stub\n", fh);
3069 return TRUE;
3070 }
3071
3072 /***********************************************************************
3073 * RemoveFontResourceExA (GDI32.@)
3074 */
3075 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3076 {
3077 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3078 LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3079 INT ret;
3080
3081 MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3082 ret = RemoveFontResourceExW(strW, fl, pdv);
3083 HeapFree(GetProcessHeap(), 0, strW);
3084 return ret;
3085 }
3086
3087 /***********************************************************************
3088 * RemoveFontResourceExW (GDI32.@)
3089 */
3090 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3091 {
3092 return WineEngRemoveFontResourceEx(str, fl, pdv);
3093 }
3094
3095 /***********************************************************************
3096 * GetTextCharset (GDI32.@)
3097 */
3098 UINT WINAPI GetTextCharset(HDC hdc)
3099 {
3100 /* MSDN docs say this is equivalent */
3101 return GetTextCharsetInfo(hdc, NULL, 0);
3102 }
3103
3104 /***********************************************************************
3105 * GetTextCharsetInfo (GDI32.@)
3106 */
3107 UINT WINAPI GetTextCharsetInfo(HDC hdc, LPFONTSIGNATURE fs, DWORD flags)
3108 {
3109 UINT ret = DEFAULT_CHARSET;
3110 DC *dc = get_dc_ptr(hdc);
3111
3112 if (dc)
3113 {
3114 if (dc->gdiFont)
3115 ret = WineEngGetTextCharsetInfo(dc->gdiFont, fs, flags);
3116
3117 release_dc_ptr( dc );
3118 }
3119
3120 if (ret == DEFAULT_CHARSET && fs)
3121 memset(fs, 0, sizeof(FONTSIGNATURE));
3122 return ret;
3123 }
3124
3125 /***********************************************************************
3126 * GdiGetCharDimensions (GDI32.@)
3127 *
3128 * Gets the average width of the characters in the English alphabet.
3129 *
3130 * PARAMS
3131 * hdc [I] Handle to the device context to measure on.
3132 * lptm [O] Pointer to memory to store the text metrics into.
3133 * height [O] On exit, the maximum height of characters in the English alphabet.
3134 *
3135 * RETURNS
3136 * The average width of characters in the English alphabet.
3137 *
3138 * NOTES
3139 * This function is used by the dialog manager to get the size of a dialog
3140 * unit. It should also be used by other pieces of code that need to know
3141 * the size of a dialog unit in logical units without having access to the
3142 * window handle of the dialog.
3143 * Windows caches the font metrics from this function, but we don't and
3144 * there doesn't appear to be an immediate advantage to do so.
3145 *
3146 * SEE ALSO
3147 * GetTextExtentPointW, GetTextMetricsW, MapDialogRect.
3148 */
3149 LONG WINAPI GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height)
3150 {
3151 SIZE sz;
3152 static const WCHAR alphabet[] = {
3153 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
3154 'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
3155 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
3156
3157 if(lptm && !GetTextMetricsW(hdc, lptm)) return 0;
3158
3159 if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
3160
3161 if (height) *height = sz.cy;
3162 return (sz.cx / 26 + 1) / 2;
3163 }
3164
3165 BOOL WINAPI EnableEUDC(BOOL fEnableEUDC)
3166 {
3167 FIXME("(%d): stub\n", fEnableEUDC);
3168 return FALSE;
3169 }
3170
3171 /***********************************************************************
3172 * GetCharWidthI (GDI32.@)
3173 *
3174 * Retrieve widths of characters.
3175 *
3176 * PARAMS
3177 * hdc [I] Handle to a device context.
3178 * first [I] First glyph in range to query.
3179 * count [I] Number of glyph indices to query.
3180 * glyphs [I] Array of glyphs to query.
3181 * buffer [O] Buffer to receive character widths.
3182 *
3183 * NOTES
3184 * Only works with TrueType fonts.
3185 *
3186 * RETURNS
3187 * Success: TRUE
3188 * Failure: FALSE
3189 */
3190 BOOL WINAPI GetCharWidthI(HDC hdc, UINT first, UINT count, LPWORD glyphs, LPINT buffer)
3191 {
3192 ABC *abc;
3193 unsigned int i;
3194
3195 TRACE("(%p, %d, %d, %p, %p)\n", hdc, first, count, glyphs, buffer);
3196
3197 if (!(abc = HeapAlloc(GetProcessHeap(), 0, count * sizeof(ABC))))
3198 return FALSE;
3199
3200 if (!GetCharABCWidthsI(hdc, first, count, glyphs, abc))
3201 {
3202 HeapFree(GetProcessHeap(), 0, abc);
3203 return FALSE;
3204 }
3205
3206 for (i = 0; i < count; i++)
3207 buffer[i] = abc->abcA + abc->abcB + abc->abcC;
3208
3209 HeapFree(GetProcessHeap(), 0, abc);
3210 return TRUE;
3211 }
3212
3213 /***********************************************************************
3214 * GetFontUnicodeRanges (GDI32.@)
3215 *
3216 * Retrieve a list of supported Unicode characters in a font.
3217 *
3218 * PARAMS
3219 * hdc [I] Handle to a device context.
3220 * lpgs [O] GLYPHSET structure specifying supported character ranges.
3221 *
3222 * RETURNS
3223 * Success: Number of bytes written to the buffer pointed to by lpgs.
3224 * Failure: 0
3225 *
3226 */
3227 DWORD WINAPI GetFontUnicodeRanges(HDC hdc, LPGLYPHSET lpgs)
3228 {
3229 DWORD ret = 0;
3230 DC *dc = get_dc_ptr(hdc);
3231
3232 TRACE("(%p, %p)\n", hdc, lpgs);
3233
3234 if (!dc) return 0;
3235
3236 if (dc->gdiFont) ret = WineEngGetFontUnicodeRanges(dc->gdiFont, lpgs);
3237 release_dc_ptr(dc);
3238 return ret;
3239 }
3240
3241
3242 /*************************************************************
3243 * FontIsLinked (GDI32.@)
3244 */
3245 BOOL WINAPI FontIsLinked(HDC hdc)
3246 {
3247 DC *dc = get_dc_ptr(hdc);
3248 BOOL ret = FALSE;
3249
3250 if (!dc) return FALSE;
3251 if (dc->gdiFont) ret = WineEngFontIsLinked(dc->gdiFont);
3252 release_dc_ptr(dc);
3253 TRACE("returning %d\n", ret);
3254 return ret;
3255 }
3256
3257 /*************************************************************
3258 * GdiRealizationInfo (GDI32.@)
3259 *
3260 * Returns a structure that contains some font information.
3261 */
3262 BOOL WINAPI GdiRealizationInfo(HDC hdc, realization_info_t *info)
3263 {
3264 DC *dc = get_dc_ptr(hdc);
3265 BOOL ret = FALSE;
3266
3267 if (!dc) return FALSE;
3268 if (dc->gdiFont) ret = WineEngRealizationInfo(dc->gdiFont, info);
3269 release_dc_ptr(dc);
3270
3271 return ret;
3272 }
an attempt at megring old patches into wine