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