?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed setupapi dependencies.
[wine/multimedia.git] / objects / font.c
blob9b0bcfb3a6fec40b08008f0b023b643a03782aa0
1 /*
2 * GDI font objects
3 *
4 * Copyright 1993 Alexandre Julliard
5 * 1997 Alex Korobka
6 */
7
8 #include <stdlib.h>
9 #include <string.h>
10 #include "winerror.h"
11 #include "winnls.h"
12 #include "font.h"
13 #include "heap.h"
14 #include "metafile.h"
15 #include "options.h"
16 #include "debugtools.h"
17 #include "gdi.h"
18
19 DEFAULT_DEBUG_CHANNEL(font);
20 DECLARE_DEBUG_CHANNEL(gdi);
21
22 #define ENUM_UNICODE 0x00000001
23
24 typedef struct
25 {
26 LPLOGFONT16 lpLogFontParam;
27 FONTENUMPROCEX16 lpEnumFunc;
28 LPARAM lpData;
29
30 LPNEWTEXTMETRICEX16 lpTextMetric;
31 LPENUMLOGFONTEX16 lpLogFont;
32 SEGPTR segTextMetric;
33 SEGPTR segLogFont;
34 } fontEnum16;
35
36 typedef struct
37 {
38 LPLOGFONTW lpLogFontParam;
39 FONTENUMPROCEXW lpEnumFunc;
40 LPARAM lpData;
41
42 DWORD dwFlags;
43 } fontEnum32;
44
45 /*
46 * For TranslateCharsetInfo
47 */
48 #define FS(x) {{0,0,0,0},{0x1<<(x),0}}
49 #define MAXTCIINDEX 32
50 static CHARSETINFO FONT_tci[MAXTCIINDEX] = {
51 /* ANSI */
52 { ANSI_CHARSET, 1252, FS(0)},
53 { EASTEUROPE_CHARSET, 1250, FS(1)},
54 { RUSSIAN_CHARSET, 1251, FS(2)},
55 { GREEK_CHARSET, 1253, FS(3)},
56 { TURKISH_CHARSET, 1254, FS(4)},
57 { HEBREW_CHARSET, 1255, FS(5)},
58 { ARABIC_CHARSET, 1256, FS(6)},
59 { BALTIC_CHARSET, 1257, FS(7)},
60 /* reserved by ANSI */
61 { DEFAULT_CHARSET, 0, FS(0)},
62 { DEFAULT_CHARSET, 0, FS(0)},
63 { DEFAULT_CHARSET, 0, FS(0)},
64 { DEFAULT_CHARSET, 0, FS(0)},
65 { DEFAULT_CHARSET, 0, FS(0)},
66 { DEFAULT_CHARSET, 0, FS(0)},
67 { DEFAULT_CHARSET, 0, FS(0)},
68 { DEFAULT_CHARSET, 0, FS(0)},
69 /* ANSI and OEM */
70 { THAI_CHARSET, 874, FS(16)},
71 { SHIFTJIS_CHARSET, 932, FS(17)},
72 { GB2312_CHARSET, 936, FS(18)},
73 { HANGEUL_CHARSET, 949, FS(19)},
74 { CHINESEBIG5_CHARSET, 950, FS(20)},
75 { JOHAB_CHARSET, 1361, FS(21)},
76 /* reserved for alternate ANSI and OEM */
77 { DEFAULT_CHARSET, 0, FS(0)},
78 { DEFAULT_CHARSET, 0, FS(0)},
79 { DEFAULT_CHARSET, 0, FS(0)},
80 { DEFAULT_CHARSET, 0, FS(0)},
81 { DEFAULT_CHARSET, 0, FS(0)},
82 { DEFAULT_CHARSET, 0, FS(0)},
83 { DEFAULT_CHARSET, 0, FS(0)},
84 { DEFAULT_CHARSET, 0, FS(0)},
85 /* reserved for system */
86 { DEFAULT_CHARSET, 0, FS(0)},
87 { DEFAULT_CHARSET, 0, FS(0)},
88 };
89
90 /***********************************************************************
91 * LOGFONT conversion functions.
92 */
93 void FONT_LogFontATo16( const LOGFONTA* font32, LPLOGFONT16 font16 )
94 {
95 font16->lfHeight = font32->lfHeight;
96 font16->lfWidth = font32->lfWidth;
97 font16->lfEscapement = font32->lfEscapement;
98 font16->lfOrientation = font32->lfOrientation;
99 font16->lfWeight = font32->lfWeight;
100 font16->lfItalic = font32->lfItalic;
101 font16->lfUnderline = font32->lfUnderline;
102 font16->lfStrikeOut = font32->lfStrikeOut;
103 font16->lfCharSet = font32->lfCharSet;
104 font16->lfOutPrecision = font32->lfOutPrecision;
105 font16->lfClipPrecision = font32->lfClipPrecision;
106 font16->lfQuality = font32->lfQuality;
107 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
108 lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
109 }
110
111 void FONT_LogFontWTo16( const LOGFONTW* font32, LPLOGFONT16 font16 )
112 {
113 font16->lfHeight = font32->lfHeight;
114 font16->lfWidth = font32->lfWidth;
115 font16->lfEscapement = font32->lfEscapement;
116 font16->lfOrientation = font32->lfOrientation;
117 font16->lfWeight = font32->lfWeight;
118 font16->lfItalic = font32->lfItalic;
119 font16->lfUnderline = font32->lfUnderline;
120 font16->lfStrikeOut = font32->lfStrikeOut;
121 font16->lfCharSet = font32->lfCharSet;
122 font16->lfOutPrecision = font32->lfOutPrecision;
123 font16->lfClipPrecision = font32->lfClipPrecision;
124 font16->lfQuality = font32->lfQuality;
125 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
126 WideCharToMultiByte( CP_ACP, 0, font32->lfFaceName, -1,
127 font16->lfFaceName, LF_FACESIZE, NULL, NULL );
128 font16->lfFaceName[LF_FACESIZE-1] = 0;
129 }
130
131 void FONT_LogFont16ToA( const LOGFONT16 *font16, LPLOGFONTA font32 )
132 {
133 font32->lfHeight = font16->lfHeight;
134 font32->lfWidth = font16->lfWidth;
135 font32->lfEscapement = font16->lfEscapement;
136 font32->lfOrientation = font16->lfOrientation;
137 font32->lfWeight = font16->lfWeight;
138 font32->lfItalic = font16->lfItalic;
139 font32->lfUnderline = font16->lfUnderline;
140 font32->lfStrikeOut = font16->lfStrikeOut;
141 font32->lfCharSet = font16->lfCharSet;
142 font32->lfOutPrecision = font16->lfOutPrecision;
143 font32->lfClipPrecision = font16->lfClipPrecision;
144 font32->lfQuality = font16->lfQuality;
145 font32->lfPitchAndFamily = font16->lfPitchAndFamily;
146 lstrcpynA( font32->lfFaceName, font16->lfFaceName, LF_FACESIZE );
147 }
148
149 void FONT_LogFont16ToW( const LOGFONT16 *font16, LPLOGFONTW font32 )
150 {
151 font32->lfHeight = font16->lfHeight;
152 font32->lfWidth = font16->lfWidth;
153 font32->lfEscapement = font16->lfEscapement;
154 font32->lfOrientation = font16->lfOrientation;
155 font32->lfWeight = font16->lfWeight;
156 font32->lfItalic = font16->lfItalic;
157 font32->lfUnderline = font16->lfUnderline;
158 font32->lfStrikeOut = font16->lfStrikeOut;
159 font32->lfCharSet = font16->lfCharSet;
160 font32->lfOutPrecision = font16->lfOutPrecision;
161 font32->lfClipPrecision = font16->lfClipPrecision;
162 font32->lfQuality = font16->lfQuality;
163 font32->lfPitchAndFamily = font16->lfPitchAndFamily;
164 MultiByteToWideChar( CP_ACP, 0, font16->lfFaceName, -1, font32->lfFaceName, LF_FACESIZE );
165 font32->lfFaceName[LF_FACESIZE-1] = 0;
166 }
167
168 void FONT_LogFontAToW( const LOGFONTA *fontA, LPLOGFONTW fontW )
169 {
170 memcpy(fontW, fontA, sizeof(LOGFONTA) - LF_FACESIZE);
171 MultiByteToWideChar(CP_ACP, 0, fontA->lfFaceName, -1, fontW->lfFaceName,
172 LF_FACESIZE);
173 }
174
175 void FONT_LogFontWToA( const LOGFONTW *fontW, LPLOGFONTA fontA )
176 {
177 memcpy(fontA, fontW, sizeof(LOGFONTA) - LF_FACESIZE);
178 WideCharToMultiByte(CP_ACP, 0, fontW->lfFaceName, -1, fontA->lfFaceName,
179 LF_FACESIZE, NULL, NULL);
180 }
181
182 void FONT_EnumLogFontEx16ToA( const ENUMLOGFONTEX16 *font16, LPENUMLOGFONTEXA font32 )
183 {
184 FONT_LogFont16ToA( (LPLOGFONT16)font16, (LPLOGFONTA)font32);
185 lstrcpynA( font32->elfFullName, font16->elfFullName, LF_FULLFACESIZE );
186 lstrcpynA( font32->elfStyle, font16->elfStyle, LF_FACESIZE );
187 lstrcpynA( font32->elfScript, font16->elfScript, LF_FACESIZE );
188 }
189
190 void FONT_EnumLogFontEx16ToW( const ENUMLOGFONTEX16 *font16, LPENUMLOGFONTEXW font32 )
191 {
192 FONT_LogFont16ToW( (LPLOGFONT16)font16, (LPLOGFONTW)font32);
193
194 MultiByteToWideChar( CP_ACP, 0, font16->elfFullName, -1, font32->elfFullName, LF_FULLFACESIZE );
195 font32->elfFullName[LF_FULLFACESIZE-1] = 0;
196 MultiByteToWideChar( CP_ACP, 0, font16->elfStyle, -1, font32->elfStyle, LF_FACESIZE );
197 font32->elfStyle[LF_FACESIZE-1] = 0;
198 MultiByteToWideChar( CP_ACP, 0, font16->elfScript, -1, font32->elfScript, LF_FACESIZE );
199 font32->elfScript[LF_FACESIZE-1] = 0;
200 }
201
202 void FONT_EnumLogFontExWTo16( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEX16 font16 )
203 {
204 FONT_LogFontWTo16( (LPLOGFONTW)fontW, (LPLOGFONT16)font16);
205
206 WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
207 font16->elfFullName, LF_FULLFACESIZE, NULL, NULL );
208 font16->elfFullName[LF_FULLFACESIZE-1] = '\0';
209 WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
210 font16->elfStyle, LF_FACESIZE, NULL, NULL );
211 font16->elfStyle[LF_FACESIZE-1] = '\0';
212 WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
213 font16->elfScript, LF_FACESIZE, NULL, NULL );
214 font16->elfScript[LF_FACESIZE-1] = '\0';
215 }
216
217 void FONT_EnumLogFontExWToA( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEXA fontA )
218 {
219 FONT_LogFontWToA( (LPLOGFONTW)fontW, (LPLOGFONTA)fontA);
220
221 WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
222 fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL );
223 fontA->elfFullName[LF_FULLFACESIZE-1] = '\0';
224 WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
225 fontA->elfStyle, LF_FACESIZE, NULL, NULL );
226 fontA->elfStyle[LF_FACESIZE-1] = '\0';
227 WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
228 fontA->elfScript, LF_FACESIZE, NULL, NULL );
229 fontA->elfScript[LF_FACESIZE-1] = '\0';
230 }
231
232 /***********************************************************************
233 * TEXTMETRIC conversion functions.
234 */
235 void FONT_TextMetricATo16(const TEXTMETRICA *ptm32, LPTEXTMETRIC16 ptm16 )
236 {
237 ptm16->tmHeight = ptm32->tmHeight;
238 ptm16->tmAscent = ptm32->tmAscent;
239 ptm16->tmDescent = ptm32->tmDescent;
240 ptm16->tmInternalLeading = ptm32->tmInternalLeading;
241 ptm16->tmExternalLeading = ptm32->tmExternalLeading;
242 ptm16->tmAveCharWidth = ptm32->tmAveCharWidth;
243 ptm16->tmMaxCharWidth = ptm32->tmMaxCharWidth;
244 ptm16->tmWeight = ptm32->tmWeight;
245 ptm16->tmOverhang = ptm32->tmOverhang;
246 ptm16->tmDigitizedAspectX = ptm32->tmDigitizedAspectX;
247 ptm16->tmDigitizedAspectY = ptm32->tmDigitizedAspectY;
248 ptm16->tmFirstChar = ptm32->tmFirstChar;
249 ptm16->tmLastChar = ptm32->tmLastChar;
250 ptm16->tmDefaultChar = ptm32->tmDefaultChar;
251 ptm16->tmBreakChar = ptm32->tmBreakChar;
252 ptm16->tmItalic = ptm32->tmItalic;
253 ptm16->tmUnderlined = ptm32->tmUnderlined;
254 ptm16->tmStruckOut = ptm32->tmStruckOut;
255 ptm16->tmPitchAndFamily = ptm32->tmPitchAndFamily;
256 ptm16->tmCharSet = ptm32->tmCharSet;
257 }
258
259 void FONT_TextMetricWTo16(const TEXTMETRICW *ptm32, LPTEXTMETRIC16 ptm16 )
260 {
261 ptm16->tmHeight = ptm32->tmHeight;
262 ptm16->tmAscent = ptm32->tmAscent;
263 ptm16->tmDescent = ptm32->tmDescent;
264 ptm16->tmInternalLeading = ptm32->tmInternalLeading;
265 ptm16->tmExternalLeading = ptm32->tmExternalLeading;
266 ptm16->tmAveCharWidth = ptm32->tmAveCharWidth;
267 ptm16->tmMaxCharWidth = ptm32->tmMaxCharWidth;
268 ptm16->tmWeight = ptm32->tmWeight;
269 ptm16->tmOverhang = ptm32->tmOverhang;
270 ptm16->tmDigitizedAspectX = ptm32->tmDigitizedAspectX;
271 ptm16->tmDigitizedAspectY = ptm32->tmDigitizedAspectY;
272 ptm16->tmFirstChar = ptm32->tmFirstChar;
273 ptm16->tmLastChar = ptm32->tmLastChar;
274 ptm16->tmDefaultChar = ptm32->tmDefaultChar;
275 ptm16->tmBreakChar = ptm32->tmBreakChar;
276 ptm16->tmItalic = ptm32->tmItalic;
277 ptm16->tmUnderlined = ptm32->tmUnderlined;
278 ptm16->tmStruckOut = ptm32->tmStruckOut;
279 ptm16->tmPitchAndFamily = ptm32->tmPitchAndFamily;
280 ptm16->tmCharSet = ptm32->tmCharSet;
281 }
282
283 void FONT_TextMetric16ToA(const TEXTMETRIC16 *ptm16, LPTEXTMETRICA ptm32 )
284 {
285 ptm32->tmHeight = ptm16->tmHeight;
286 ptm32->tmAscent = ptm16->tmAscent;
287 ptm32->tmDescent = ptm16->tmDescent;
288 ptm32->tmInternalLeading = ptm16->tmInternalLeading;
289 ptm32->tmExternalLeading = ptm16->tmExternalLeading;
290 ptm32->tmAveCharWidth = ptm16->tmAveCharWidth;
291 ptm32->tmMaxCharWidth = ptm16->tmMaxCharWidth;
292 ptm32->tmWeight = ptm16->tmWeight;
293 ptm32->tmOverhang = ptm16->tmOverhang;
294 ptm32->tmDigitizedAspectX = ptm16->tmDigitizedAspectX;
295 ptm32->tmDigitizedAspectY = ptm16->tmDigitizedAspectY;
296 ptm32->tmFirstChar = ptm16->tmFirstChar;
297 ptm32->tmLastChar = ptm16->tmLastChar;
298 ptm32->tmDefaultChar = ptm16->tmDefaultChar;
299 ptm32->tmBreakChar = ptm16->tmBreakChar;
300 ptm32->tmItalic = ptm16->tmItalic;
301 ptm32->tmUnderlined = ptm16->tmUnderlined;
302 ptm32->tmStruckOut = ptm16->tmStruckOut;
303 ptm32->tmPitchAndFamily = ptm16->tmPitchAndFamily;
304 ptm32->tmCharSet = ptm16->tmCharSet;
305 }
306
307 void FONT_TextMetric16ToW(const TEXTMETRIC16 *ptm16, LPTEXTMETRICW ptm32 )
308 {
309 ptm32->tmHeight = ptm16->tmHeight;
310 ptm32->tmAscent = ptm16->tmAscent;
311 ptm32->tmDescent = ptm16->tmDescent;
312 ptm32->tmInternalLeading = ptm16->tmInternalLeading;
313 ptm32->tmExternalLeading = ptm16->tmExternalLeading;
314 ptm32->tmAveCharWidth = ptm16->tmAveCharWidth;
315 ptm32->tmMaxCharWidth = ptm16->tmMaxCharWidth;
316 ptm32->tmWeight = ptm16->tmWeight;
317 ptm32->tmOverhang = ptm16->tmOverhang;
318 ptm32->tmDigitizedAspectX = ptm16->tmDigitizedAspectX;
319 ptm32->tmDigitizedAspectY = ptm16->tmDigitizedAspectY;
320 ptm32->tmFirstChar = ptm16->tmFirstChar;
321 ptm32->tmLastChar = ptm16->tmLastChar;
322 ptm32->tmDefaultChar = ptm16->tmDefaultChar;
323 ptm32->tmBreakChar = ptm16->tmBreakChar;
324 ptm32->tmItalic = ptm16->tmItalic;
325 ptm32->tmUnderlined = ptm16->tmUnderlined;
326 ptm32->tmStruckOut = ptm16->tmStruckOut;
327 ptm32->tmPitchAndFamily = ptm16->tmPitchAndFamily;
328 ptm32->tmCharSet = ptm16->tmCharSet;
329 }
330
331 void FONT_TextMetricAToW(const TEXTMETRICA *ptm32A, LPTEXTMETRICW ptm32W )
332 {
333 ptm32W->tmHeight = ptm32A->tmHeight;
334 ptm32W->tmAscent = ptm32A->tmAscent;
335 ptm32W->tmDescent = ptm32A->tmDescent;
336 ptm32W->tmInternalLeading = ptm32A->tmInternalLeading;
337 ptm32W->tmExternalLeading = ptm32A->tmExternalLeading;
338 ptm32W->tmAveCharWidth = ptm32A->tmAveCharWidth;
339 ptm32W->tmMaxCharWidth = ptm32A->tmMaxCharWidth;
340 ptm32W->tmWeight = ptm32A->tmWeight;
341 ptm32W->tmOverhang = ptm32A->tmOverhang;
342 ptm32W->tmDigitizedAspectX = ptm32A->tmDigitizedAspectX;
343 ptm32W->tmDigitizedAspectY = ptm32A->tmDigitizedAspectY;
344 ptm32W->tmFirstChar = ptm32A->tmFirstChar;
345 ptm32W->tmLastChar = ptm32A->tmLastChar;
346 ptm32W->tmDefaultChar = ptm32A->tmDefaultChar;
347 ptm32W->tmBreakChar = ptm32A->tmBreakChar;
348 ptm32W->tmItalic = ptm32A->tmItalic;
349 ptm32W->tmUnderlined = ptm32A->tmUnderlined;
350 ptm32W->tmStruckOut = ptm32A->tmStruckOut;
351 ptm32W->tmPitchAndFamily = ptm32A->tmPitchAndFamily;
352 ptm32W->tmCharSet = ptm32A->tmCharSet;
353 }
354
355 void FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA )
356 {
357 ptmA->tmHeight = ptmW->tmHeight;
358 ptmA->tmAscent = ptmW->tmAscent;
359 ptmA->tmDescent = ptmW->tmDescent;
360 ptmA->tmInternalLeading = ptmW->tmInternalLeading;
361 ptmA->tmExternalLeading = ptmW->tmExternalLeading;
362 ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
363 ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
364 ptmA->tmWeight = ptmW->tmWeight;
365 ptmA->tmOverhang = ptmW->tmOverhang;
366 ptmA->tmDigitizedAspectX = ptmW->tmDigitizedAspectX;
367 ptmA->tmDigitizedAspectY = ptmW->tmDigitizedAspectY;
368 ptmA->tmFirstChar = ptmW->tmFirstChar;
369 ptmA->tmLastChar = ptmW->tmLastChar;
370 ptmA->tmDefaultChar = ptmW->tmDefaultChar;
371 ptmA->tmBreakChar = ptmW->tmBreakChar;
372 ptmA->tmItalic = ptmW->tmItalic;
373 ptmA->tmUnderlined = ptmW->tmUnderlined;
374 ptmA->tmStruckOut = ptmW->tmStruckOut;
375 ptmA->tmPitchAndFamily = ptmW->tmPitchAndFamily;
376 ptmA->tmCharSet = ptmW->tmCharSet;
377 }
378
379
380 void FONT_NewTextMetricExWTo16(const NEWTEXTMETRICEXW *ptmW, LPNEWTEXTMETRICEX16 ptm16 )
381 {
382 FONT_TextMetricWTo16((LPTEXTMETRICW)ptmW, (LPTEXTMETRIC16)ptm16);
383 ptm16->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
384 ptm16->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
385 ptm16->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
386 ptm16->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
387 memcpy(&ptm16->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
388 }
389
390 void FONT_NewTextMetricExWToA(const NEWTEXTMETRICEXW *ptmW, LPNEWTEXTMETRICEXA ptmA )
391 {
392 FONT_TextMetricWToA((LPTEXTMETRICW)ptmW, (LPTEXTMETRICA)ptmA);
393 ptmA->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
394 ptmA->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
395 ptmA->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
396 ptmA->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
397 memcpy(&ptmA->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
398 }
399
400 void FONT_NewTextMetricEx16ToW(const NEWTEXTMETRICEX16 *ptm16, LPNEWTEXTMETRICEXW ptmW )
401 {
402 FONT_TextMetric16ToW((LPTEXTMETRIC16)ptm16, (LPTEXTMETRICW)ptmW);
403 ptmW->ntmTm.ntmFlags = ptm16->ntmTm.ntmFlags;
404 ptmW->ntmTm.ntmSizeEM = ptm16->ntmTm.ntmSizeEM;
405 ptmW->ntmTm.ntmCellHeight = ptm16->ntmTm.ntmCellHeight;
406 ptmW->ntmTm.ntmAvgWidth = ptm16->ntmTm.ntmAvgWidth;
407 memcpy(&ptmW->ntmFontSig, &ptm16->ntmFontSig, sizeof(FONTSIGNATURE));
408 }
409
410
411 /***********************************************************************
412 * CreateFontIndirect16 (GDI.57)
413 */
414 HFONT16 WINAPI CreateFontIndirect16( const LOGFONT16 *plf16 )
415 {
416 LOGFONTW lfW;
417
418 if(plf16) {
419 FONT_LogFont16ToW( plf16, &lfW );
420 return CreateFontIndirectW( &lfW );
421 } else {
422 return CreateFontIndirectW( NULL );
423 }
424 }
425
426
427 /***********************************************************************
428 * CreateFontIndirectA (GDI32.@)
429 */
430 HFONT WINAPI CreateFontIndirectA( const LOGFONTA *plfA )
431 {
432 LOGFONTW lfW;
433
434 if (plfA) {
435 FONT_LogFontAToW( plfA, &lfW );
436 return CreateFontIndirectW( &lfW );
437 } else
438 return CreateFontIndirectW( NULL );
439
440 }
441
442 /***********************************************************************
443 * CreateFontIndirectW (GDI32.@)
444 */
445 HFONT WINAPI CreateFontIndirectW( const LOGFONTW *plf )
446 {
447 HFONT hFont = 0;
448
449 if (plf)
450 {
451 FONTOBJ* fontPtr;
452 if ((fontPtr = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC, &hFont )))
453 {
454 memcpy( &fontPtr->logfont, plf, sizeof(LOGFONTW) );
455
456 TRACE("(%ld %ld %ld %ld) '%s' %s %s => %04x\n",
457 plf->lfHeight, plf->lfWidth,
458 plf->lfEscapement, plf->lfOrientation,
459 debugstr_w(plf->lfFaceName),
460 plf->lfWeight > 400 ? "Bold" : "",
461 plf->lfItalic ? "Italic" : "", hFont);
462
463 if (plf->lfEscapement != plf->lfOrientation) {
464 /* this should really depend on whether GM_ADVANCED is set */
465 fontPtr->logfont.lfOrientation = fontPtr->logfont.lfEscapement;
466 WARN("orientation angle %f set to "
467 "escapement angle %f for new font %04x\n",
468 plf->lfOrientation/10., plf->lfEscapement/10., hFont);
469 }
470 GDI_ReleaseObj( hFont );
471 }
472 }
473 else WARN("(NULL) => NULL\n");
474
475 return hFont;
476 }
477
478 /***********************************************************************
479 * CreateFont16 (GDI.56)
480 */
481 HFONT16 WINAPI CreateFont16(INT16 height, INT16 width, INT16 esc, INT16 orient,
482 INT16 weight, BYTE italic, BYTE underline,
483 BYTE strikeout, BYTE charset, BYTE outpres,
484 BYTE clippres, BYTE quality, BYTE pitch,
485 LPCSTR name )
486 {
487 LOGFONT16 logfont;
488
489 logfont.lfHeight = height;
490 logfont.lfWidth = width;
491 logfont.lfEscapement = esc;
492 logfont.lfOrientation = orient;
493 logfont.lfWeight = weight;
494 logfont.lfItalic = italic;
495 logfont.lfUnderline = underline;
496 logfont.lfStrikeOut = strikeout;
497 logfont.lfCharSet = charset;
498 logfont.lfOutPrecision = outpres;
499 logfont.lfClipPrecision = clippres;
500 logfont.lfQuality = quality;
501 logfont.lfPitchAndFamily = pitch;
502
503 if (name)
504 lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
505 else
506 logfont.lfFaceName[0] = '\0';
507
508 return CreateFontIndirect16( &logfont );
509 }
510
511 /*************************************************************************
512 * CreateFontA (GDI32.@)
513 */
514 HFONT WINAPI CreateFontA( INT height, INT width, INT esc,
515 INT orient, INT weight, DWORD italic,
516 DWORD underline, DWORD strikeout, DWORD charset,
517 DWORD outpres, DWORD clippres, DWORD quality,
518 DWORD pitch, LPCSTR name )
519 {
520 LOGFONTA logfont;
521
522 logfont.lfHeight = height;
523 logfont.lfWidth = width;
524 logfont.lfEscapement = esc;
525 logfont.lfOrientation = orient;
526 logfont.lfWeight = weight;
527 logfont.lfItalic = italic;
528 logfont.lfUnderline = underline;
529 logfont.lfStrikeOut = strikeout;
530 logfont.lfCharSet = charset;
531 logfont.lfOutPrecision = outpres;
532 logfont.lfClipPrecision = clippres;
533 logfont.lfQuality = quality;
534 logfont.lfPitchAndFamily = pitch;
535
536 if (name)
537 lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
538 else
539 logfont.lfFaceName[0] = '\0';
540
541 return CreateFontIndirectA( &logfont );
542 }
543
544 /*************************************************************************
545 * CreateFontW (GDI32.@)
546 */
547 HFONT WINAPI CreateFontW( INT height, INT width, INT esc,
548 INT orient, INT weight, DWORD italic,
549 DWORD underline, DWORD strikeout, DWORD charset,
550 DWORD outpres, DWORD clippres, DWORD quality,
551 DWORD pitch, LPCWSTR name )
552 {
553 LOGFONTW logfont;
554
555 logfont.lfHeight = height;
556 logfont.lfWidth = width;
557 logfont.lfEscapement = esc;
558 logfont.lfOrientation = orient;
559 logfont.lfWeight = weight;
560 logfont.lfItalic = italic;
561 logfont.lfUnderline = underline;
562 logfont.lfStrikeOut = strikeout;
563 logfont.lfCharSet = charset;
564 logfont.lfOutPrecision = outpres;
565 logfont.lfClipPrecision = clippres;
566 logfont.lfQuality = quality;
567 logfont.lfPitchAndFamily = pitch;
568
569 if (name)
570 lstrcpynW(logfont.lfFaceName, name,
571 sizeof(logfont.lfFaceName) / sizeof(WCHAR));
572 else
573 logfont.lfFaceName[0] = '\0';
574
575 return CreateFontIndirectW( &logfont );
576 }
577
578
579 /***********************************************************************
580 * FONT_GetObject16
581 */
582 INT16 FONT_GetObject16( FONTOBJ * font, INT16 count, LPSTR buffer )
583 {
584 LOGFONT16 lf16;
585
586 FONT_LogFontWTo16( &font->logfont, &lf16 );
587
588 if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
589 memcpy( buffer, &lf16, count );
590 return count;
591 }
592
593 /***********************************************************************
594 * FONT_GetObjectA
595 */
596 INT FONT_GetObjectA( FONTOBJ *font, INT count, LPSTR buffer )
597 {
598 LOGFONTA lfA;
599
600 FONT_LogFontWToA( &font->logfont, &lfA );
601
602 if (count > sizeof(lfA)) count = sizeof(lfA);
603 memcpy( buffer, &lfA, count );
604 return count;
605 }
606 /***********************************************************************
607 * FONT_GetObjectW
608 */
609 INT FONT_GetObjectW( FONTOBJ *font, INT count, LPSTR buffer )
610 {
611 if (count > sizeof(LOGFONTW)) count = sizeof(LOGFONTW);
612 memcpy( buffer, &font->logfont, count );
613 return count;
614 }
615
616
617 /***********************************************************************
618 * FONT_EnumInstance16
619 *
620 * Called by the device driver layer to pass font info
621 * down to the application.
622 */
623 static INT FONT_EnumInstance16( LPENUMLOGFONTEXW plf, LPNEWTEXTMETRICEXW ptm,
624 DWORD fType, LPARAM lp )
625 {
626 #define pfe ((fontEnum16*)lp)
627 if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
628 pfe->lpLogFontParam->lfCharSet == plf->elfLogFont.lfCharSet )
629 {
630 FONT_EnumLogFontExWTo16(plf, pfe->lpLogFont);
631 FONT_NewTextMetricExWTo16(ptm, pfe->lpTextMetric);
632 return pfe->lpEnumFunc( pfe->segLogFont, pfe->segTextMetric,
633 (UINT16)fType, (LPARAM)(pfe->lpData) );
634 }
635 #undef pfe
636 return 1;
637 }
638
639 /***********************************************************************
640 * FONT_EnumInstance
641 */
642 static INT FONT_EnumInstance( LPENUMLOGFONTEXW plf, LPNEWTEXTMETRICEXW ptm,
643 DWORD fType, LPARAM lp )
644 {
645 /* lfCharSet is at the same offset in both LOGFONTA and LOGFONTW */
646
647 #define pfe ((fontEnum32*)lp)
648 if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
649 pfe->lpLogFontParam->lfCharSet == plf->elfLogFont.lfCharSet )
650 {
651 /* convert font metrics */
652
653 if( pfe->dwFlags & ENUM_UNICODE )
654 {
655 return pfe->lpEnumFunc( plf, ptm, fType, pfe->lpData );
656 }
657 else
658 {
659 ENUMLOGFONTEXA logfont;
660 NEWTEXTMETRICEXA tmA;
661
662 FONT_EnumLogFontExWToA( plf, &logfont);
663 FONT_NewTextMetricExWToA( ptm, &tmA );
664
665 return pfe->lpEnumFunc( (LPENUMLOGFONTEXW)&logfont,
666 (LPNEWTEXTMETRICEXW)&tmA, fType,
667 pfe->lpData );
668 }
669 }
670 #undef pfe
671 return 1;
672 }
673
674 /***********************************************************************
675 * EnumFontFamiliesEx16 (GDI.613)
676 */
677 INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
678 FONTENUMPROCEX16 efproc, LPARAM lParam,
679 DWORD dwFlags)
680 {
681 BOOL (*enum_func)(HDC,LPLOGFONTW,DEVICEFONTENUMPROC,LPARAM);
682 INT16 retVal = 0;
683 DC* dc = DC_GetDCPtr( hDC );
684
685 if (!dc) return 0;
686 enum_func = dc->funcs->pEnumDeviceFonts;
687 GDI_ReleaseObj( hDC );
688
689 if (enum_func)
690 {
691 LPNEWTEXTMETRICEX16 lptm16 = SEGPTR_ALLOC( sizeof(NEWTEXTMETRICEX16) );
692 if( lptm16 )
693 {
694 LPENUMLOGFONTEX16 lplf16 = SEGPTR_ALLOC( sizeof(ENUMLOGFONTEX16) );
695 if( lplf16 )
696 {
697 fontEnum16 fe16;
698 LOGFONTW lfW;
699 FONT_LogFont16ToW(plf, &lfW);
700
701 fe16.lpLogFontParam = plf;
702 fe16.lpEnumFunc = efproc;
703 fe16.lpData = lParam;
704
705 fe16.lpTextMetric = lptm16;
706 fe16.lpLogFont = lplf16;
707 fe16.segTextMetric = SEGPTR_GET(lptm16);
708 fe16.segLogFont = SEGPTR_GET(lplf16);
709
710 retVal = enum_func( hDC, &lfW, FONT_EnumInstance16,
711 (LPARAM)&fe16 );
712 SEGPTR_FREE(lplf16);
713 }
714 SEGPTR_FREE(lptm16);
715 }
716 }
717 return retVal;
718 }
719
720 /***********************************************************************
721 * FONT_EnumFontFamiliesEx
722 */
723 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf,
724 FONTENUMPROCEXW efproc,
725 LPARAM lParam, DWORD dwUnicode)
726 {
727 BOOL (*enum_func)(HDC,LPLOGFONTW,DEVICEFONTENUMPROC,LPARAM);
728 INT ret = 0;
729 DC *dc = DC_GetDCPtr( hDC );
730
731 if (!dc) return 0;
732 enum_func = dc->funcs->pEnumDeviceFonts;
733 GDI_ReleaseObj( hDC );
734
735 if (enum_func)
736 {
737 fontEnum32 fe32;
738
739 fe32.lpLogFontParam = plf;
740 fe32.lpEnumFunc = efproc;
741 fe32.lpData = lParam;
742
743 fe32.dwFlags = dwUnicode;
744
745 ret = enum_func( hDC, plf, FONT_EnumInstance, (LPARAM)&fe32 );
746 }
747 return ret;
748 }
749
750 /***********************************************************************
751 * EnumFontFamiliesExW (GDI32.@)
752 */
753 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
754 FONTENUMPROCEXW efproc,
755 LPARAM lParam, DWORD dwFlags )
756 {
757 return FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, ENUM_UNICODE );
758 }
759
760 /***********************************************************************
761 * EnumFontFamiliesExA (GDI32.@)
762 */
763 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
764 FONTENUMPROCEXA efproc,
765 LPARAM lParam, DWORD dwFlags)
766 {
767 LOGFONTW lfW;
768 FONT_LogFontAToW( plf, &lfW );
769
770 return FONT_EnumFontFamiliesEx( hDC, &lfW,
771 (FONTENUMPROCEXW)efproc, lParam, 0);
772 }
773
774 /***********************************************************************
775 * EnumFontFamilies16 (GDI.330)
776 */
777 INT16 WINAPI EnumFontFamilies16( HDC16 hDC, LPCSTR lpFamily,
778 FONTENUMPROC16 efproc, LPARAM lpData )
779 {
780 LOGFONT16 lf;
781
782 lf.lfCharSet = DEFAULT_CHARSET;
783 if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
784 else lf.lfFaceName[0] = '\0';
785
786 return EnumFontFamiliesEx16( hDC, &lf, (FONTENUMPROCEX16)efproc, lpData, 0 );
787 }
788
789 /***********************************************************************
790 * EnumFontFamiliesA (GDI32.@)
791 */
792 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
793 FONTENUMPROCA efproc, LPARAM lpData )
794 {
795 LOGFONTA lf;
796
797 lf.lfCharSet = DEFAULT_CHARSET;
798 if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
799 else lf.lfFaceName[0] = lf.lfFaceName[1] = '\0';
800
801 return EnumFontFamiliesExA( hDC, &lf, (FONTENUMPROCEXA)efproc, lpData, 0 );
802 }
803
804 /***********************************************************************
805 * EnumFontFamiliesW (GDI32.@)
806 */
807 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
808 FONTENUMPROCW efproc, LPARAM lpData )
809 {
810 LOGFONTW lf;
811
812 lf.lfCharSet = DEFAULT_CHARSET;
813 if( lpFamily ) lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
814 else lf.lfFaceName[0] = 0;
815
816 return EnumFontFamiliesExW( hDC, &lf, (FONTENUMPROCEXW)efproc, lpData, 0 );
817 }
818
819 /***********************************************************************
820 * EnumFonts16 (GDI.70)
821 */
822 INT16 WINAPI EnumFonts16( HDC16 hDC, LPCSTR lpName, FONTENUMPROC16 efproc,
823 LPARAM lpData )
824 {
825 return EnumFontFamilies16( hDC, lpName, (FONTENUMPROCEX16)efproc, lpData );
826 }
827
828 /***********************************************************************
829 * EnumFontsA (GDI32.@)
830 */
831 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
832 LPARAM lpData )
833 {
834 return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
835 }
836
837 /***********************************************************************
838 * EnumFontsW (GDI32.@)
839 */
840 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
841 LPARAM lpData )
842 {
843 return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
844 }
845
846
847 /***********************************************************************
848 * GetTextCharacterExtra16 (GDI.89)
849 */
850 INT16 WINAPI GetTextCharacterExtra16( HDC16 hdc )
851 {
852 return (INT16)GetTextCharacterExtra( hdc );
853 }
854
855
856 /***********************************************************************
857 * GetTextCharacterExtra (GDI32.@)
858 */
859 INT WINAPI GetTextCharacterExtra( HDC hdc )
860 {
861 INT ret;
862 DC *dc = DC_GetDCPtr( hdc );
863 if (!dc) return 0;
864 ret = abs( (dc->charExtra * dc->wndExtX + dc->vportExtX / 2)
865 / dc->vportExtX );
866 GDI_ReleaseObj( hdc );
867 return ret;
868 }
869
870
871 /***********************************************************************
872 * SetTextCharacterExtra16 (GDI.8)
873 */
874 INT16 WINAPI SetTextCharacterExtra16( HDC16 hdc, INT16 extra )
875 {
876 return (INT16)SetTextCharacterExtra( hdc, extra );
877 }
878
879
880 /***********************************************************************
881 * SetTextCharacterExtra (GDI32.@)
882 */
883 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
884 {
885 INT prev;
886 DC * dc = DC_GetDCPtr( hdc );
887 if (!dc) return 0;
888 if (dc->funcs->pSetTextCharacterExtra)
889 prev = dc->funcs->pSetTextCharacterExtra( dc, extra );
890 else
891 {
892 extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;
893 prev = (dc->charExtra * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
894 dc->charExtra = abs(extra);
895 }
896 GDI_ReleaseObj( hdc );
897 return prev;
898 }
899
900
901 /***********************************************************************
902 * SetTextJustification16 (GDI.10)
903 */
904 INT16 WINAPI SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
905 {
906 return SetTextJustification( hdc, extra, breaks );
907 }
908
909
910 /***********************************************************************
911 * SetTextJustification (GDI32.@)
912 */
913 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
914 {
915 BOOL ret = TRUE;
916 DC * dc = DC_GetDCPtr( hdc );
917 if (!dc) return FALSE;
918 if (dc->funcs->pSetTextJustification)
919 ret = dc->funcs->pSetTextJustification( dc, extra, breaks );
920 else
921 {
922 extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
923 if (!extra) breaks = 0;
924 dc->breakTotalExtra = extra;
925 dc->breakCount = breaks;
926 if (breaks)
927 {
928 dc->breakExtra = extra / breaks;
929 dc->breakRem = extra - (dc->breakCount * dc->breakExtra);
930 }
931 else
932 {
933 dc->breakExtra = 0;
934 dc->breakRem = 0;
935 }
936 }
937 GDI_ReleaseObj( hdc );
938 return ret;
939 }
940
941
942 /***********************************************************************
943 * GetTextFace16 (GDI.92)
944 */
945 INT16 WINAPI GetTextFace16( HDC16 hdc, INT16 count, LPSTR name )
946 {
947 return GetTextFaceA(hdc,count,name);
948 }
949
950 /***********************************************************************
951 * GetTextFaceA (GDI32.@)
952 */
953 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
954 {
955 INT res = GetTextFaceW(hdc, 0, NULL);
956 LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
957 GetTextFaceW( hdc, res, nameW );
958
959 if (name)
960 res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, count,
961 NULL, NULL);
962 else
963 res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
964 HeapFree( GetProcessHeap(), 0, nameW );
965 return res;
966 }
967
968 /***********************************************************************
969 * GetTextFaceW (GDI32.@)
970 */
971 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
972 {
973 FONTOBJ *font;
974 INT ret = 0;
975
976 DC * dc = DC_GetDCPtr( hdc );
977 if (!dc) return 0;
978
979 if ((font = (FONTOBJ *) GDI_GetObjPtr( dc->hFont, FONT_MAGIC )))
980 {
981 if (name)
982 {
983 lstrcpynW( name, font->logfont.lfFaceName, count );
984 ret = strlenW(name);
985 }
986 else ret = strlenW(font->logfont.lfFaceName) + 1;
987 GDI_ReleaseObj( dc->hFont );
988 }
989 GDI_ReleaseObj( hdc );
990 return ret;
991 }
992
993
994 /***********************************************************************
995 * GetTextExtent16 (GDI.91)
996 */
997 DWORD WINAPI GetTextExtent16( HDC16 hdc, LPCSTR str, INT16 count )
998 {
999 SIZE16 size;
1000 if (!GetTextExtentPoint16( hdc, str, count, &size )) return 0;
1001 return MAKELONG( size.cx, size.cy );
1002 }
1003
1004
1005 /***********************************************************************
1006 * GetTextExtentPoint16 (GDI.471)
1007 *
1008 * FIXME: Should this have a bug for compatibility?
1009 * Original Windows versions of GetTextExtentPoint{A,W} have documented
1010 * bugs (-> MSDN KB q147647.txt).
1011 */
1012 BOOL16 WINAPI GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count,
1013 LPSIZE16 size )
1014 {
1015 SIZE size32;
1016 BOOL ret;
1017 TRACE("%04x, %p (%s), %d, %p\n", hdc, str, debugstr_an(str, count), count, size);
1018 ret = GetTextExtentPoint32A( hdc, str, count, &size32 );
1019 size->cx = size32.cx;
1020 size->cy = size32.cy;
1021 return (BOOL16)ret;
1022 }
1023
1024
1025 /***********************************************************************
1026 * GetTextExtentPoint32A (GDI32.@)
1027 */
1028 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
1029 LPSIZE size )
1030 {
1031 BOOL ret = FALSE;
1032 UINT codepage = CP_ACP; /* FIXME: get codepage of font charset */
1033 DC * dc = DC_GetDCPtr( hdc );
1034
1035 if (!dc) return FALSE;
1036
1037 if (dc->funcs->pGetTextExtentPoint)
1038 {
1039 /* str may not be 0 terminated so we can't use HEAP_strdupWtoA.
1040 * So we use MultiByteToWideChar.
1041 */
1042 UINT wlen = MultiByteToWideChar(codepage,0,str,count,NULL,0);
1043 LPWSTR p = HeapAlloc( GetProcessHeap(), 0, wlen * sizeof(WCHAR) );
1044 if (p)
1045 {
1046 wlen = MultiByteToWideChar(codepage,0,str,count,p,wlen);
1047 ret = dc->funcs->pGetTextExtentPoint( dc, p, wlen, size );
1048 HeapFree( GetProcessHeap(), 0, p );
1049 }
1050 }
1051 GDI_ReleaseObj( hdc );
1052 TRACE("(%08x %s %d %p): returning %ld x %ld\n",
1053 hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
1054 return ret;
1055 }
1056
1057
1058 /***********************************************************************
1059 * GetTextExtentPoint32W [GDI32.@] Computes width/height for a string
1060 *
1061 * Computes width and height of the specified string.
1062 *
1063 * RETURNS
1064 * Success: TRUE
1065 * Failure: FALSE
1066 */
1067 BOOL WINAPI GetTextExtentPoint32W(
1068 HDC hdc, /* [in] Handle of device context */
1069 LPCWSTR str, /* [in] Address of text string */
1070 INT count, /* [in] Number of characters in string */
1071 LPSIZE size) /* [out] Address of structure for string size */
1072 {
1073 BOOL ret = FALSE;
1074 DC * dc = DC_GetDCPtr( hdc );
1075 if (dc)
1076 {
1077 if(dc->funcs->pGetTextExtentPoint)
1078 ret = dc->funcs->pGetTextExtentPoint( dc, str, count, size );
1079 GDI_ReleaseObj( hdc );
1080 }
1081 TRACE("(%08x %s %d %p): returning %ld x %ld\n",
1082 hdc, debugstr_wn (str, count), count, size, size->cx, size->cy );
1083 return ret;
1084 }
1085
1086
1087 /***********************************************************************
1088 * GetTextExtentPointA (GDI32.@)
1089 */
1090 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1091 LPSIZE size )
1092 {
1093 TRACE("not bug compatible.\n");
1094 return GetTextExtentPoint32A( hdc, str, count, size );
1095 }
1096
1097 /***********************************************************************
1098 * GetTextExtentPointW (GDI32.@)
1099 */
1100 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1101 LPSIZE size )
1102 {
1103 TRACE("not bug compatible.\n");
1104 return GetTextExtentPoint32W( hdc, str, count, size );
1105 }
1106
1107
1108 /***********************************************************************
1109 * GetTextExtentExPointA (GDI32.@)
1110 */
1111 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1112 INT maxExt, LPINT lpnFit,
1113 LPINT alpDx, LPSIZE size )
1114 {
1115 BOOL ret;
1116
1117 DWORD len = MultiByteToWideChar( CP_ACP, 0, str, count, NULL, 0 );
1118 LPWSTR p = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1119 MultiByteToWideChar( CP_ACP, 0, str, count, p, len );
1120 ret = GetTextExtentExPointW( hdc, p, len, maxExt, lpnFit, alpDx, size);
1121 HeapFree( GetProcessHeap(), 0, p );
1122 return ret;
1123 }
1124
1125
1126 /***********************************************************************
1127 * GetTextExtentExPointW (GDI32.@)
1128 */
1129
1130 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
1131 INT maxExt, LPINT lpnFit,
1132 LPINT alpDx, LPSIZE size )
1133 {
1134 int index, nFit, extent;
1135 SIZE tSize;
1136 BOOL ret = FALSE;
1137 DC * dc = DC_GetDCPtr( hdc );
1138 if (!dc) return FALSE;
1139
1140 if (!dc->funcs->pGetTextExtentPoint) goto done;
1141
1142 size->cx = size->cy = nFit = extent = 0;
1143 for(index = 0; index < count; index++)
1144 {
1145 if(!dc->funcs->pGetTextExtentPoint( dc, str, 1, &tSize )) goto done;
1146 if( extent+tSize.cx < maxExt )
1147 {
1148 extent+=tSize.cx;
1149 nFit++;
1150 str++;
1151 if( alpDx ) alpDx[index] = extent;
1152 if( tSize.cy > size->cy ) size->cy = tSize.cy;
1153 }
1154 else break;
1155 }
1156 size->cx = extent;
1157 if(lpnFit) *lpnFit = nFit;
1158 ret = TRUE;
1159
1160 TRACE("(%08x %s %d) returning %d %ld x %ld\n",
1161 hdc,debugstr_wn(str,count),maxExt,nFit, size->cx,size->cy);
1162
1163 done:
1164 GDI_ReleaseObj( hdc );
1165 return ret;
1166 }
1167
1168 /***********************************************************************
1169 * GetTextMetrics16 (GDI.93)
1170 */
1171 BOOL16 WINAPI GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
1172 {
1173 TEXTMETRICW tm32;
1174
1175 if (!GetTextMetricsW( (HDC)hdc, &tm32 )) return FALSE;
1176 FONT_TextMetricWTo16( &tm32, metrics );
1177 return TRUE;
1178 }
1179
1180
1181 /***********************************************************************
1182 * GetTextMetricsA (GDI32.@)
1183 */
1184 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1185 {
1186 TEXTMETRICW tm32;
1187
1188 if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1189 FONT_TextMetricWToA( &tm32, metrics );
1190 return TRUE;
1191 }
1192
1193 /***********************************************************************
1194 * GetTextMetricsW (GDI32.@)
1195 */
1196 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1197 {
1198 BOOL ret = FALSE;
1199 DC * dc = DC_GetDCPtr( hdc );
1200 if (!dc) return FALSE;
1201
1202 if (dc->funcs->pGetTextMetrics && dc->funcs->pGetTextMetrics( dc, metrics ))
1203 {
1204 /* device layer returns values in device units
1205 * therefore we have to convert them to logical */
1206
1207 #define WDPTOLP(x) ((x<0)? \
1208 (-abs((x)*dc->wndExtX/dc->vportExtX)): \
1209 (abs((x)*dc->wndExtX/dc->vportExtX)))
1210 #define HDPTOLP(y) ((y<0)? \
1211 (-abs((y)*dc->wndExtY/dc->vportExtY)): \
1212 (abs((y)*dc->wndExtY/dc->vportExtY)))
1213
1214 metrics->tmHeight = HDPTOLP(metrics->tmHeight);
1215 metrics->tmAscent = HDPTOLP(metrics->tmAscent);
1216 metrics->tmDescent = HDPTOLP(metrics->tmDescent);
1217 metrics->tmInternalLeading = HDPTOLP(metrics->tmInternalLeading);
1218 metrics->tmExternalLeading = HDPTOLP(metrics->tmExternalLeading);
1219 metrics->tmAveCharWidth = WDPTOLP(metrics->tmAveCharWidth);
1220 metrics->tmMaxCharWidth = WDPTOLP(metrics->tmMaxCharWidth);
1221 metrics->tmOverhang = WDPTOLP(metrics->tmOverhang);
1222 ret = TRUE;
1223
1224 TRACE("text metrics:\n"
1225 " Weight = %03li\t FirstChar = %i\t AveCharWidth = %li\n"
1226 " Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %li\n"
1227 " UnderLined = %01i\t DefaultChar = %i\t Overhang = %li\n"
1228 " StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1229 " PitchAndFamily = %02x\n"
1230 " --------------------\n"
1231 " InternalLeading = %li\n"
1232 " Ascent = %li\n"
1233 " Descent = %li\n"
1234 " Height = %li\n",
1235 metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1236 metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1237 metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1238 metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1239 metrics->tmPitchAndFamily,
1240 metrics->tmInternalLeading,
1241 metrics->tmAscent,
1242 metrics->tmDescent,
1243 metrics->tmHeight );
1244 }
1245 GDI_ReleaseObj( hdc );
1246 return ret;
1247 }
1248
1249
1250 /***********************************************************************
1251 * GetOutlineTextMetrics16 [GDI.308] Gets metrics for TrueType fonts.
1252 *
1253 * NOTES
1254 * lpOTM should be LPOUTLINETEXTMETRIC
1255 *
1256 * RETURNS
1257 * Success: Non-zero or size of required buffer
1258 * Failure: 0
1259 */
1260 UINT16 WINAPI GetOutlineTextMetrics16(
1261 HDC16 hdc, /* [in] Handle of device context */
1262 UINT16 cbData, /* [in] Size of metric data array */
1263 LPOUTLINETEXTMETRIC16 lpOTM) /* [out] Address of metric data array */
1264 {
1265 FIXME("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
1266 return 0;
1267 }
1268
1269
1270 /***********************************************************************
1271 * GetOutlineTextMetrics (GDI.207)
1272 * GetOutlineTextMetricsA (GDI32.@)
1273 * Gets metrics for TrueType fonts.
1274 *
1275 *
1276 * RETURNS
1277 * Success: Non-zero or size of required buffer
1278 * Failure: 0
1279 */
1280 UINT WINAPI GetOutlineTextMetricsA(
1281 HDC hdc, /* [in] Handle of device context */
1282 UINT cbData, /* [in] Size of metric data array */
1283 LPOUTLINETEXTMETRICA lpOTM) /* [out] Address of metric data array */
1284 {
1285
1286
1287 UINT rtn = FALSE;
1288 LPTEXTMETRICA lptxtMetr;
1289
1290
1291
1292 if (lpOTM == 0)
1293 {
1294
1295 lpOTM = (LPOUTLINETEXTMETRICA)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(OUTLINETEXTMETRICA));
1296 rtn = sizeof(OUTLINETEXTMETRICA);
1297 cbData = rtn;
1298 } else
1299 {
1300 cbData = sizeof(*lpOTM);
1301 rtn = cbData;
1302 };
1303
1304 lpOTM->otmSize = cbData;
1305
1306 lptxtMetr =HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TEXTMETRICA));
1307
1308 if (!GetTextMetricsA(hdc,lptxtMetr))
1309 {
1310 return 0;
1311 } else
1312 {
1313 memcpy(&(lpOTM->otmTextMetrics),lptxtMetr,sizeof(TEXTMETRICA));
1314 };
1315
1316 HeapFree(GetProcessHeap(),HEAP_ZERO_MEMORY,lptxtMetr);
1317
1318 lpOTM->otmFiller = 0;
1319
1320 lpOTM->otmPanoseNumber.bFamilyType = 0;
1321 lpOTM->otmPanoseNumber.bSerifStyle = 0;
1322 lpOTM->otmPanoseNumber.bWeight = 0;
1323 lpOTM->otmPanoseNumber.bProportion = 0;
1324 lpOTM->otmPanoseNumber.bContrast = 0;
1325 lpOTM->otmPanoseNumber.bStrokeVariation = 0;
1326 lpOTM->otmPanoseNumber.bArmStyle = 0;
1327 lpOTM->otmPanoseNumber.bLetterform = 0;
1328 lpOTM->otmPanoseNumber.bMidline = 0;
1329 lpOTM->otmPanoseNumber.bXHeight = 0;
1330
1331 lpOTM->otmfsSelection = 0;
1332 lpOTM->otmfsType = 0;
1333
1334 /*
1335 Further fill of the structure not implemented,
1336 Needs real values for the structure members
1337 */
1338
1339 return rtn;
1340 }
1341
1342 /***********************************************************************
1343 * GetOutlineTextMetricsW [GDI32.@]
1344 */
1345 UINT WINAPI GetOutlineTextMetricsW(
1346 HDC hdc, /* [in] Handle of device context */
1347 UINT cbData, /* [in] Size of metric data array */
1348 LPOUTLINETEXTMETRICW lpOTM) /* [out] Address of metric data array */
1349 {
1350 FIXME("(%d,%d,%p): stub\n", hdc, cbData, lpOTM);
1351 return 0;
1352 }
1353
1354 /***********************************************************************
1355 * GetCharWidth16 (GDI.350)
1356 * GetCharWidth16 (DISPLAY.350)
1357 */
1358 BOOL16 WINAPI GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
1359 LPINT16 buffer )
1360 {
1361 BOOL retVal = FALSE;
1362
1363 if( firstChar != lastChar )
1364 {
1365 LPINT buf32 = (LPINT)HeapAlloc(GetProcessHeap(), 0,
1366 sizeof(INT)*(1 + (lastChar - firstChar)));
1367 if( buf32 )
1368 {
1369 LPINT obuf32 = buf32;
1370 int i;
1371
1372 retVal = GetCharWidth32A(hdc, firstChar, lastChar, buf32);
1373 if (retVal)
1374 {
1375 for (i = firstChar; i <= lastChar; i++)
1376 *buffer++ = *buf32++;
1377 }
1378 HeapFree(GetProcessHeap(), 0, obuf32);
1379 }
1380 }
1381 else /* happens quite often to warrant a special treatment */
1382 {
1383 INT chWidth;
1384 retVal = GetCharWidth32A(hdc, firstChar, lastChar, &chWidth );
1385 *buffer = chWidth;
1386 }
1387 return retVal;
1388 }
1389
1390
1391 /***********************************************************************
1392 * GetCharWidth32A (GDI32.@)
1393 */
1394 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1395 LPINT buffer )
1396 {
1397 UINT i, extra;
1398 BOOL ret = FALSE;
1399 DC * dc = DC_GetDCPtr( hdc );
1400 if (!dc) return FALSE;
1401
1402 if (dc->funcs->pGetCharWidth && dc->funcs->pGetCharWidth( dc, firstChar, lastChar, buffer))
1403 {
1404 /* convert device units to logical */
1405
1406 extra = dc->vportExtX >> 1;
1407 for( i = firstChar; i <= lastChar; i++, buffer++ )
1408 *buffer = (*buffer * dc->wndExtX + extra) / dc->vportExtX;
1409 ret = TRUE;
1410 }
1411 GDI_ReleaseObj( hdc );
1412 return ret;
1413 }
1414
1415
1416 /***********************************************************************
1417 * GetCharWidth32W (GDI32.@)
1418 */
1419 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1420 LPINT buffer )
1421 {
1422 return GetCharWidth32A( hdc, firstChar, lastChar, buffer );
1423 }
1424
1425
1426 /* FIXME: all following APIs ******************************************/
1427
1428
1429 /***********************************************************************
1430 * SetMapperFlags16 (GDI.349)
1431 */
1432 DWORD WINAPI SetMapperFlags16( HDC16 hDC, DWORD dwFlag )
1433 {
1434 return SetMapperFlags( hDC, dwFlag );
1435 }
1436
1437
1438 /***********************************************************************
1439 * SetMapperFlags (GDI32.@)
1440 */
1441 DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
1442 {
1443 DC *dc = DC_GetDCPtr( hDC );
1444 DWORD ret = 0;
1445 if(!dc) return 0;
1446 if(dc->funcs->pSetMapperFlags)
1447 ret = dc->funcs->pSetMapperFlags( dc, dwFlag );
1448 else
1449 FIXME("(0x%04x, 0x%08lx): stub - harmless\n", hDC, dwFlag);
1450 GDI_ReleaseObj( hDC );
1451 return ret;
1452 }
1453
1454 /***********************************************************************
1455 * GetAspectRatioFilterEx16 (GDI.486)
1456 */
1457 BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
1458 {
1459 FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1460 return FALSE;
1461 }
1462
1463 /***********************************************************************
1464 * GetAspectRatioFilterEx (GDI32.@)
1465 */
1466 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
1467 {
1468 FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1469 return FALSE;
1470 }
1471
1472 /***********************************************************************
1473 * GetCharABCWidths16 (GDI.307)
1474 */
1475 BOOL16 WINAPI GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
1476 LPABC16 abc )
1477 {
1478 ABC abc32;
1479 if (!GetCharABCWidthsA( hdc, firstChar, lastChar, &abc32 )) return FALSE;
1480 abc->abcA = abc32.abcA;
1481 abc->abcB = abc32.abcB;
1482 abc->abcC = abc32.abcC;
1483 return TRUE;
1484 }
1485
1486
1487 /***********************************************************************
1488 * GetCharABCWidthsA (GDI32.@)
1489 */
1490 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
1491 LPABC abc )
1492 {
1493 return GetCharABCWidthsW( hdc, firstChar, lastChar, abc );
1494 }
1495
1496
1497 /******************************************************************************
1498 * GetCharABCWidthsW [GDI32.@] Retrieves widths of characters in range
1499 *
1500 * PARAMS
1501 * hdc [I] Handle of device context
1502 * firstChar [I] First character in range to query
1503 * lastChar [I] Last character in range to query
1504 * abc [O] Address of character-width structure
1505 *
1506 * NOTES
1507 * Only works with TrueType fonts
1508 *
1509 * RETURNS
1510 * Success: TRUE
1511 * Failure: FALSE
1512 */
1513 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
1514 LPABC abc )
1515 {
1516 /* No TrueType fonts in Wine so far */
1517 FIXME("(%04x,%04x,%04x,%p): stub\n", hdc, firstChar, lastChar, abc);
1518 return FALSE;
1519 }
1520
1521
1522 /***********************************************************************
1523 * GetGlyphOutline16 (GDI.309)
1524 */
1525 DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
1526 LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
1527 LPVOID lpBuffer, const MAT2 *lpmat2 )
1528 {
1529 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1530 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1531 return (DWORD)-1; /* failure */
1532 }
1533
1534
1535 /***********************************************************************
1536 * GetGlyphOutlineA (GDI32.@)
1537 */
1538 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
1539 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1540 LPVOID lpBuffer, const MAT2 *lpmat2 )
1541 {
1542 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1543 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1544 return (DWORD)-1; /* failure */
1545 }
1546
1547 /***********************************************************************
1548 * GetGlyphOutlineW (GDI32.@)
1549 */
1550 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
1551 LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1552 LPVOID lpBuffer, const MAT2 *lpmat2 )
1553 {
1554 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1555 hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1556 return (DWORD)-1; /* failure */
1557 }
1558
1559 /***********************************************************************
1560 * CreateScalableFontResource16 (GDI.310)
1561 */
1562 BOOL16 WINAPI CreateScalableFontResource16( UINT16 fHidden,
1563 LPCSTR lpszResourceFile,
1564 LPCSTR fontFile, LPCSTR path )
1565 {
1566 return CreateScalableFontResourceA( fHidden, lpszResourceFile,
1567 fontFile, path );
1568 }
1569
1570 /***********************************************************************
1571 * CreateScalableFontResourceA (GDI32.@)
1572 */
1573 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
1574 LPCSTR lpszResourceFile,
1575 LPCSTR lpszFontFile,
1576 LPCSTR lpszCurrentPath )
1577 {
1578 /* fHidden=1 - only visible for the calling app, read-only, not
1579 * enumbered with EnumFonts/EnumFontFamilies
1580 * lpszCurrentPath can be NULL
1581 */
1582 FIXME("(%ld,%s,%s,%s): stub\n",
1583 fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1584 return FALSE; /* create failed */
1585 }
1586
1587 /***********************************************************************
1588 * CreateScalableFontResourceW (GDI32.@)
1589 */
1590 BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
1591 LPCWSTR lpszResourceFile,
1592 LPCWSTR lpszFontFile,
1593 LPCWSTR lpszCurrentPath )
1594 {
1595 FIXME("(%ld,%p,%p,%p): stub\n",
1596 fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1597 return FALSE; /* create failed */
1598 }
1599
1600
1601 /*************************************************************************
1602 * GetRasterizerCaps16 (GDI.313)
1603 */
1604 BOOL16 WINAPI GetRasterizerCaps16( LPRASTERIZER_STATUS lprs, UINT16 cbNumBytes)
1605 {
1606 return GetRasterizerCaps( lprs, cbNumBytes );
1607 }
1608
1609
1610 /*************************************************************************
1611 * GetRasterizerCaps (GDI32.@)
1612 */
1613 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
1614 {
1615 lprs->nSize = sizeof(RASTERIZER_STATUS);
1616 lprs->wFlags = TT_AVAILABLE|TT_ENABLED;
1617 lprs->nLanguageID = 0;
1618 return TRUE;
1619 }
1620
1621
1622 /*************************************************************************
1623 * GetKerningPairs16 (GDI.332)
1624 */
1625 INT16 WINAPI GetKerningPairs16( HDC16 hDC, INT16 cPairs,
1626 LPKERNINGPAIR16 lpKerningPairs )
1627 {
1628 /* At this time kerning is ignored (set to 0) */
1629 int i;
1630 FIXME("(%x,%d,%p): almost empty stub!\n", hDC, cPairs, lpKerningPairs);
1631 for (i = 0; i < cPairs; i++)
1632 lpKerningPairs[i].iKernAmount = 0;
1633 return 0;
1634 }
1635
1636
1637
1638 /*************************************************************************
1639 * GetKerningPairsA (GDI32.@)
1640 */
1641 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
1642 LPKERNINGPAIR lpKerningPairs )
1643 {
1644 int i;
1645 FIXME("(%x,%ld,%p): almost empty stub!\n", hDC, cPairs, lpKerningPairs);
1646 for (i = 0; i < cPairs; i++)
1647 lpKerningPairs[i].iKernAmount = 0;
1648 return 0;
1649 }
1650
1651
1652 /*************************************************************************
1653 * GetKerningPairsW (GDI32.@)
1654 */
1655 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
1656 LPKERNINGPAIR lpKerningPairs )
1657 {
1658 return GetKerningPairsA( hDC, cPairs, lpKerningPairs );
1659 }
1660
1661 /*************************************************************************
1662 * TranslateCharsetInfo [GDI32.@]
1663 *
1664 * Fills a CHARSETINFO structure for a character set, code page, or
1665 * font. This allows making the correspondance between different labelings
1666 * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
1667 * of the same encoding.
1668 *
1669 * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
1670 * only one codepage should be set in *lpSrc.
1671 *
1672 * RETURNS
1673 * TRUE on success, FALSE on failure.
1674 *
1675 */
1676 BOOL WINAPI TranslateCharsetInfo(
1677 LPDWORD lpSrc, /* [in]
1678 if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
1679 if flags == TCI_SRCCHARSET: a character set value
1680 if flags == TCI_SRCCODEPAGE: a code page value
1681 */
1682 LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
1683 DWORD flags /* [in] determines interpretation of lpSrc */
1684 ) {
1685 int index = 0;
1686 switch (flags) {
1687 case TCI_SRCFONTSIG:
1688 while (!(*lpSrc>>index & 0x0001) && index<MAXTCIINDEX) index++;
1689 break;
1690 case TCI_SRCCODEPAGE:
1691 while ((UINT) (lpSrc) != FONT_tci[index].ciACP && index < MAXTCIINDEX) index++;
1692 break;
1693 case TCI_SRCCHARSET:
1694 while ((UINT) (lpSrc) != FONT_tci[index].ciCharset && index < MAXTCIINDEX) index++;
1695 break;
1696 default:
1697 return FALSE;
1698 }
1699 if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
1700 memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
1701 return TRUE;
1702 }
1703
1704 /*************************************************************************
1705 * GetFontLanguageInfo (GDI32.@)
1706 */
1707 DWORD WINAPI GetFontLanguageInfo(HDC hdc) {
1708 /* return value 0 is correct for most cases anyway */
1709 FIXME("(%x):stub!\n", hdc);
1710 return 0;
1711 }
1712
1713 /*************************************************************************
1714 * GetFontLanguageInfo (GDI.616)
1715 */
1716 DWORD WINAPI GetFontLanguageInfo16(HDC16 hdc) {
1717 /* return value 0 is correct for most cases anyway */
1718 FIXME("(%x):stub!\n",hdc);
1719 return 0;
1720 }
1721
1722 /*************************************************************************
1723 * GetFontData [GDI32.@] Retrieve data for TrueType font
1724 *
1725 * RETURNS
1726 *
1727 * success: Number of bytes returned
1728 * failure: GDI_ERROR
1729 *
1730 * NOTES
1731 *
1732 * Calls SetLastError()
1733 *
1734 * BUGS
1735 *
1736 * Unimplemented
1737 */
1738 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
1739 LPVOID buffer, DWORD length)
1740 {
1741 FIXME("(%x,%ld,%ld,%p,%ld): stub\n", hdc, table, offset, buffer, length);
1742 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1743 return GDI_ERROR;
1744 }
1745
1746 /*************************************************************************
1747 * GetFontData16 [GDI.311]
1748 *
1749 */
1750 DWORD WINAPI GetFontData16(HDC16 hdc, DWORD dwTable, DWORD dwOffset,
1751 LPVOID lpvBuffer, DWORD cbData)
1752 {
1753 return GetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
1754 }
1755
1756 /*************************************************************************
1757 * GetCharacterPlacementA [GDI32.@]
1758 *
1759 * NOTES:
1760 * the web browser control of ie4 calls this with dwFlags=0
1761 */
1762 DWORD WINAPI
1763 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
1764 INT nMaxExtent, GCP_RESULTSA *lpResults,
1765 DWORD dwFlags)
1766 {
1767 DWORD ret=0;
1768 SIZE size;
1769
1770 TRACE("%s 0x%08x 0x%08x 0x%08lx:stub!\n",
1771 debugstr_a(lpString), uCount, nMaxExtent, dwFlags);
1772
1773 TRACE("lpOrder=%p lpDx=%p lpCaretPos=%p lpClass=%p "
1774 "lpOutString=%p lpGlyphs=%p\n",
1775 lpResults->lpOrder, lpResults->lpDx, lpResults->lpCaretPos,
1776 lpResults->lpClass, lpResults->lpOutString, lpResults->lpGlyphs);
1777
1778 if(dwFlags) FIXME("flags 0x%08lx ignored\n", dwFlags);
1779 if(lpResults->lpOrder) FIXME("reordering not implemented\n");
1780 if(lpResults->lpCaretPos) FIXME("caret positions not implemented\n");
1781 if(lpResults->lpClass) FIXME("classes not implemented\n");
1782 if(lpResults->lpGlyphs) FIXME("glyphs not implemented\n");
1783
1784 /* copy will do if the GCP_REORDER flag is not set */
1785 if(lpResults->lpOutString)
1786 {
1787 lstrcpynA(lpResults->lpOutString, lpString, uCount);
1788 }
1789
1790 if (lpResults->lpDx)
1791 {
1792 int i, c;
1793 for (i=0; i<uCount;i++)
1794 {
1795 if (GetCharWidth32A(hdc, lpString[i], lpString[i], &c))
1796 lpResults->lpDx[i]= c;
1797 }
1798 }
1799
1800 if (GetTextExtentPoint32A(hdc, lpString, uCount, &size))
1801 ret = MAKELONG(size.cx, size.cy);
1802
1803 return ret;
1804 }
1805
1806 /*************************************************************************
1807 * GetCharacterPlacementW [GDI32.@]
1808 */
1809 DWORD WINAPI
1810 GetCharacterPlacementW(HDC hdc, LPCWSTR lpString, INT uCount,
1811 INT nMaxExtent, GCP_RESULTSW *lpResults,
1812 DWORD dwFlags)
1813 {
1814 /* return value 0 is correct for most cases anyway */
1815 FIXME(":stub!\n");
1816 return 0;
1817 }
1818
1819 /*************************************************************************
1820 * GetCharABCWidthsFloatA [GDI32.@]
1821 */
1822 BOOL WINAPI GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar,
1823 LPABCFLOAT lpABCF)
1824 {
1825 FIXME_(gdi)("GetCharABCWidthsFloatA, stub\n");
1826 return 0;
1827 }
1828
1829 /*************************************************************************
1830 * GetCharABCWidthsFloatW [GDI32.@]
1831 */
1832 BOOL WINAPI GetCharABCWidthsFloatW(HDC hdc, UINT iFirstChar,
1833 UINT iLastChar, LPABCFLOAT lpABCF)
1834 {
1835 FIXME_(gdi)("GetCharABCWidthsFloatW, stub\n");
1836 return 0;
1837 }
1838
1839 /*************************************************************************
1840 * GetCharWidthFloatA [GDI32.@]
1841 */
1842 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
1843 UINT iLastChar, PFLOAT pxBuffer)
1844 {
1845 FIXME_(gdi)("GetCharWidthFloatA, stub\n");
1846 return 0;
1847 }
1848
1849 /*************************************************************************
1850 * GetCharWidthFloatW [GDI32.@]
1851 */
1852 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
1853 UINT iLastChar, PFLOAT pxBuffer)
1854 {
1855 FIXME_(gdi)("GetCharWidthFloatW, stub\n");
1856 return 0;
1857 }
1858
1859
1860 /***********************************************************************
1861 * *
1862 * Font Resource API *
1863 * *
1864 ***********************************************************************/
1865 /***********************************************************************
1866 * AddFontResource16 (GDI.119)
1867 *
1868 * Can be either .FON, or .FNT, or .TTF, or .FOT font file.
1869 *
1870 * FIXME: Load header and find the best-matching font in the fontList;
1871 * fixup dfPoints if all metrics are identical, otherwise create
1872 * new fontAlias. When soft font support is ready this will
1873 * simply create a new fontResource ('filename' will go into
1874 * the pfr->resource field) with FR_SOFTFONT/FR_SOFTRESOURCE
1875 * flag set.
1876 */
1877 INT16 WINAPI AddFontResource16( LPCSTR filename )
1878 {
1879 return AddFontResourceA( filename );
1880 }
1881
1882
1883 /***********************************************************************
1884 * AddFontResourceA (GDI32.@)
1885 */
1886 INT WINAPI AddFontResourceA( LPCSTR str )
1887 {
1888 FIXME("(%s): stub! Read the Wine User Guide on how to install "
1889 "this font manually.\n", debugres_a(str));
1890 return 1;
1891 }
1892
1893
1894 /***********************************************************************
1895 * AddFontResourceW (GDI32.@)
1896 */
1897 INT WINAPI AddFontResourceW( LPCWSTR str )
1898 {
1899 FIXME("(%s): stub! Read the Wine User Guide on how to install "
1900 "this font manually.\n", debugres_w(str));
1901 return 1;
1902 }
1903
1904 /***********************************************************************
1905 * RemoveFontResource16 (GDI.136)
1906 */
1907 BOOL16 WINAPI RemoveFontResource16( LPCSTR str )
1908 {
1909 FIXME("(%s): stub\n", debugres_a(str));
1910 return TRUE;
1911 }
1912
1913
1914 /***********************************************************************
1915 * RemoveFontResourceA (GDI32.@)
1916 */
1917 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
1918 {
1919 /* This is how it should look like */
1920 /*
1921 fontResource** ppfr;
1922 BOOL32 retVal = FALSE;
1923
1924 EnterCriticalSection( &crtsc_fonts_X11 );
1925 for( ppfr = &fontList; *ppfr; ppfr = &(*ppfr)->next )
1926 if( !strcasecmp( (*ppfr)->lfFaceName, str ) )
1927 {
1928 if(((*ppfr)->fr_flags & (FR_SOFTFONT | FR_SOFTRESOURCE)) &&
1929 (*ppfr)->hOwnerProcess == GetCurrentProcess() )
1930 {
1931 if( (*ppfr)->fo_count )
1932 (*ppfr)->fr_flags |= FR_REMOVED;
1933 else
1934 XFONT_RemoveFontResource( ppfr );
1935 }
1936 retVal = TRUE;
1937 }
1938 LeaveCriticalSection( &crtsc_fonts_X11 );
1939 return retVal;
1940 */
1941 FIXME("(%s): stub\n", debugres_a(str));
1942 return TRUE;
1943 }
1944
1945
1946 /***********************************************************************
1947 * RemoveFontResourceW (GDI32.@)
1948 */
1949 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
1950 {
1951 FIXME("(%s): stub\n", debugres_w(str) );
1952 return TRUE;
1953 }
Maarten's multimedia branch