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