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