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