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