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