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