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