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