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