4 * Copyright 1993 Alexandre Julliard
16 #include "debugtools.h"
19 DEFAULT_DEBUG_CHANNEL(font
);
20 DECLARE_DEBUG_CHANNEL(gdi
);
22 #define ENUM_UNICODE 0x00000001
26 LPLOGFONT16 lpLogFontParam
;
27 FONTENUMPROCEX16 lpEnumFunc
;
30 LPNEWTEXTMETRICEX16 lpTextMetric
;
31 LPENUMLOGFONTEX16 lpLogFont
;
38 LPLOGFONTW lpLogFontParam
;
39 FONTENUMPROCEXW lpEnumFunc
;
46 * For TranslateCharsetInfo
48 #define FS(x) {{0,0,0,0},{0x1<<(x),0}}
49 #define MAXTCIINDEX 32
50 static CHARSETINFO FONT_tci
[MAXTCIINDEX
] = {
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)},
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)},
90 /***********************************************************************
91 * LOGFONT conversion functions.
93 void FONT_LogFontATo16( const LOGFONTA
* font32
, LPLOGFONT16 font16
)
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
);
111 void FONT_LogFontWTo16( const LOGFONTW
* font32
, LPLOGFONT16 font16
)
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;
131 void FONT_LogFont16ToA( const LOGFONT16
*font16
, LPLOGFONTA font32
)
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
);
149 void FONT_LogFont16ToW( const LOGFONT16
*font16
, LPLOGFONTW font32
)
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;
168 void FONT_LogFontAToW( const LOGFONTA
*fontA
, LPLOGFONTW fontW
)
170 memcpy(fontW
, fontA
, sizeof(LOGFONTA
) - LF_FACESIZE
);
171 MultiByteToWideChar(CP_ACP
, 0, fontA
->lfFaceName
, -1, fontW
->lfFaceName
,
175 void FONT_LogFontWToA( const LOGFONTW
*fontW
, LPLOGFONTA fontA
)
177 memcpy(fontA
, fontW
, sizeof(LOGFONTA
) - LF_FACESIZE
);
178 WideCharToMultiByte(CP_ACP
, 0, fontW
->lfFaceName
, -1, fontA
->lfFaceName
,
179 LF_FACESIZE
, NULL
, NULL
);
182 void FONT_EnumLogFontEx16ToA( const ENUMLOGFONTEX16
*font16
, LPENUMLOGFONTEXA font32
)
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
);
190 void FONT_EnumLogFontEx16ToW( const ENUMLOGFONTEX16
*font16
, LPENUMLOGFONTEXW font32
)
192 FONT_LogFont16ToW( (LPLOGFONT16
)font16
, (LPLOGFONTW
)font32
);
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;
202 void FONT_EnumLogFontExWTo16( const ENUMLOGFONTEXW
*fontW
, LPENUMLOGFONTEX16 font16
)
204 FONT_LogFontWTo16( (LPLOGFONTW
)fontW
, (LPLOGFONT16
)font16
);
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';
217 void FONT_EnumLogFontExWToA( const ENUMLOGFONTEXW
*fontW
, LPENUMLOGFONTEXA fontA
)
219 FONT_LogFontWToA( (LPLOGFONTW
)fontW
, (LPLOGFONTA
)fontA
);
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';
232 /***********************************************************************
233 * TEXTMETRIC conversion functions.
235 void FONT_TextMetricATo16(const TEXTMETRICA
*ptm32
, LPTEXTMETRIC16 ptm16
)
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
;
259 void FONT_TextMetricWTo16(const TEXTMETRICW
*ptm32
, LPTEXTMETRIC16 ptm16
)
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
;
283 void FONT_TextMetric16ToA(const TEXTMETRIC16
*ptm16
, LPTEXTMETRICA ptm32
)
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
;
307 void FONT_TextMetric16ToW(const TEXTMETRIC16
*ptm16
, LPTEXTMETRICW ptm32
)
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
;
331 void FONT_TextMetricAToW(const TEXTMETRICA
*ptm32A
, LPTEXTMETRICW ptm32W
)
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
;
355 void FONT_TextMetricWToA(const TEXTMETRICW
*ptmW
, LPTEXTMETRICA ptmA
)
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
;
380 void FONT_NewTextMetricExWTo16(const NEWTEXTMETRICEXW
*ptmW
, LPNEWTEXTMETRICEX16 ptm16
)
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
));
390 void FONT_NewTextMetricExWToA(const NEWTEXTMETRICEXW
*ptmW
, LPNEWTEXTMETRICEXA ptmA
)
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
));
400 void FONT_NewTextMetricEx16ToW(const NEWTEXTMETRICEX16
*ptm16
, LPNEWTEXTMETRICEXW ptmW
)
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
));
411 /***********************************************************************
412 * CreateFontIndirect16 (GDI.57)
414 HFONT16 WINAPI
CreateFontIndirect16( const LOGFONT16
*plf16
)
419 FONT_LogFont16ToW( plf16
, &lfW
);
420 return CreateFontIndirectW( &lfW
);
422 return CreateFontIndirectW( NULL
);
427 /***********************************************************************
428 * CreateFontIndirectA (GDI32.@)
430 HFONT WINAPI
CreateFontIndirectA( const LOGFONTA
*plfA
)
435 FONT_LogFontAToW( plfA
, &lfW
);
436 return CreateFontIndirectW( &lfW
);
438 return CreateFontIndirectW( NULL
);
442 /***********************************************************************
443 * CreateFontIndirectW (GDI32.@)
445 HFONT WINAPI
CreateFontIndirectW( const LOGFONTW
*plf
)
452 if ((fontPtr
= GDI_AllocObject( sizeof(FONTOBJ
), FONT_MAGIC
, &hFont
)))
454 memcpy( &fontPtr
->logfont
, plf
, sizeof(LOGFONTW
) );
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
);
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
);
470 GDI_ReleaseObj( hFont
);
473 else WARN("(NULL) => NULL\n");
478 /***********************************************************************
479 * CreateFont16 (GDI.56)
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
,
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
;
504 lstrcpynA(logfont
.lfFaceName
,name
,sizeof(logfont
.lfFaceName
));
506 logfont
.lfFaceName
[0] = '\0';
508 return CreateFontIndirect16( &logfont
);
511 /*************************************************************************
512 * CreateFontA (GDI32.@)
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
)
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
;
537 lstrcpynA(logfont
.lfFaceName
,name
,sizeof(logfont
.lfFaceName
));
539 logfont
.lfFaceName
[0] = '\0';
541 return CreateFontIndirectA( &logfont
);
544 /*************************************************************************
545 * CreateFontW (GDI32.@)
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
)
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
;
570 lstrcpynW(logfont
.lfFaceName
, name
,
571 sizeof(logfont
.lfFaceName
) / sizeof(WCHAR
));
573 logfont
.lfFaceName
[0] = '\0';
575 return CreateFontIndirectW( &logfont
);
579 /***********************************************************************
582 INT16
FONT_GetObject16( FONTOBJ
* font
, INT16 count
, LPSTR buffer
)
586 FONT_LogFontWTo16( &font
->logfont
, &lf16
);
588 if (count
> sizeof(LOGFONT16
)) count
= sizeof(LOGFONT16
);
589 memcpy( buffer
, &lf16
, count
);
593 /***********************************************************************
596 INT
FONT_GetObjectA( FONTOBJ
*font
, INT count
, LPSTR buffer
)
600 FONT_LogFontWToA( &font
->logfont
, &lfA
);
602 if (count
> sizeof(lfA
)) count
= sizeof(lfA
);
603 memcpy( buffer
, &lfA
, count
);
606 /***********************************************************************
609 INT
FONT_GetObjectW( FONTOBJ
*font
, INT count
, LPSTR buffer
)
611 if (count
> sizeof(LOGFONTW
)) count
= sizeof(LOGFONTW
);
612 memcpy( buffer
, &font
->logfont
, count
);
617 /***********************************************************************
618 * FONT_EnumInstance16
620 * Called by the device driver layer to pass font info
621 * down to the application.
623 static INT
FONT_EnumInstance16( LPENUMLOGFONTEXW plf
, LPNEWTEXTMETRICEXW ptm
,
624 DWORD fType
, LPARAM lp
)
626 #define pfe ((fontEnum16*)lp)
627 if( pfe
->lpLogFontParam
->lfCharSet
== DEFAULT_CHARSET
||
628 pfe
->lpLogFontParam
->lfCharSet
== plf
->elfLogFont
.lfCharSet
)
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
) );
639 /***********************************************************************
642 static INT
FONT_EnumInstance( LPENUMLOGFONTEXW plf
, LPNEWTEXTMETRICEXW ptm
,
643 DWORD fType
, LPARAM lp
)
645 /* lfCharSet is at the same offset in both LOGFONTA and LOGFONTW */
647 #define pfe ((fontEnum32*)lp)
648 if( pfe
->lpLogFontParam
->lfCharSet
== DEFAULT_CHARSET
||
649 pfe
->lpLogFontParam
->lfCharSet
== plf
->elfLogFont
.lfCharSet
)
651 /* convert font metrics */
653 if( pfe
->dwFlags
& ENUM_UNICODE
)
655 return pfe
->lpEnumFunc( plf
, ptm
, fType
, pfe
->lpData
);
659 ENUMLOGFONTEXA logfont
;
660 NEWTEXTMETRICEXA tmA
;
662 FONT_EnumLogFontExWToA( plf
, &logfont
);
663 FONT_NewTextMetricExWToA( ptm
, &tmA
);
665 return pfe
->lpEnumFunc( (LPENUMLOGFONTEXW
)&logfont
,
666 (LPNEWTEXTMETRICEXW
)&tmA
, fType
,
674 /***********************************************************************
675 * EnumFontFamiliesEx16 (GDI.613)
677 INT16 WINAPI
EnumFontFamiliesEx16( HDC16 hDC
, LPLOGFONT16 plf
,
678 FONTENUMPROCEX16 efproc
, LPARAM lParam
,
681 BOOL (*enum_func
)(HDC
,LPLOGFONTW
,DEVICEFONTENUMPROC
,LPARAM
);
683 DC
* dc
= DC_GetDCPtr( hDC
);
686 enum_func
= dc
->funcs
->pEnumDeviceFonts
;
687 GDI_ReleaseObj( hDC
);
691 LPNEWTEXTMETRICEX16 lptm16
= SEGPTR_ALLOC( sizeof(NEWTEXTMETRICEX16
) );
694 LPENUMLOGFONTEX16 lplf16
= SEGPTR_ALLOC( sizeof(ENUMLOGFONTEX16
) );
699 FONT_LogFont16ToW(plf
, &lfW
);
701 fe16
.lpLogFontParam
= plf
;
702 fe16
.lpEnumFunc
= efproc
;
703 fe16
.lpData
= lParam
;
705 fe16
.lpTextMetric
= lptm16
;
706 fe16
.lpLogFont
= lplf16
;
707 fe16
.segTextMetric
= SEGPTR_GET(lptm16
);
708 fe16
.segLogFont
= SEGPTR_GET(lplf16
);
710 retVal
= enum_func( hDC
, &lfW
, FONT_EnumInstance16
,
720 /***********************************************************************
721 * FONT_EnumFontFamiliesEx
723 static INT
FONT_EnumFontFamiliesEx( HDC hDC
, LPLOGFONTW plf
,
724 FONTENUMPROCEXW efproc
,
725 LPARAM lParam
, DWORD dwUnicode
)
727 BOOL (*enum_func
)(HDC
,LPLOGFONTW
,DEVICEFONTENUMPROC
,LPARAM
);
729 DC
*dc
= DC_GetDCPtr( hDC
);
732 enum_func
= dc
->funcs
->pEnumDeviceFonts
;
733 GDI_ReleaseObj( hDC
);
739 fe32
.lpLogFontParam
= plf
;
740 fe32
.lpEnumFunc
= efproc
;
741 fe32
.lpData
= lParam
;
743 fe32
.dwFlags
= dwUnicode
;
745 ret
= enum_func( hDC
, plf
, FONT_EnumInstance
, (LPARAM
)&fe32
);
750 /***********************************************************************
751 * EnumFontFamiliesExW (GDI32.@)
753 INT WINAPI
EnumFontFamiliesExW( HDC hDC
, LPLOGFONTW plf
,
754 FONTENUMPROCEXW efproc
,
755 LPARAM lParam
, DWORD dwFlags
)
757 return FONT_EnumFontFamiliesEx( hDC
, plf
, efproc
, lParam
, ENUM_UNICODE
);
760 /***********************************************************************
761 * EnumFontFamiliesExA (GDI32.@)
763 INT WINAPI
EnumFontFamiliesExA( HDC hDC
, LPLOGFONTA plf
,
764 FONTENUMPROCEXA efproc
,
765 LPARAM lParam
, DWORD dwFlags
)
768 FONT_LogFontAToW( plf
, &lfW
);
770 return FONT_EnumFontFamiliesEx( hDC
, &lfW
,
771 (FONTENUMPROCEXW
)efproc
, lParam
, 0);
774 /***********************************************************************
775 * EnumFontFamilies16 (GDI.330)
777 INT16 WINAPI
EnumFontFamilies16( HDC16 hDC
, LPCSTR lpFamily
,
778 FONTENUMPROC16 efproc
, LPARAM lpData
)
782 lf
.lfCharSet
= DEFAULT_CHARSET
;
783 if( lpFamily
) lstrcpynA( lf
.lfFaceName
, lpFamily
, LF_FACESIZE
);
784 else lf
.lfFaceName
[0] = '\0';
786 return EnumFontFamiliesEx16( hDC
, &lf
, (FONTENUMPROCEX16
)efproc
, lpData
, 0 );
789 /***********************************************************************
790 * EnumFontFamiliesA (GDI32.@)
792 INT WINAPI
EnumFontFamiliesA( HDC hDC
, LPCSTR lpFamily
,
793 FONTENUMPROCA efproc
, LPARAM lpData
)
797 lf
.lfCharSet
= DEFAULT_CHARSET
;
798 if( lpFamily
) lstrcpynA( lf
.lfFaceName
, lpFamily
, LF_FACESIZE
);
799 else lf
.lfFaceName
[0] = lf
.lfFaceName
[1] = '\0';
801 return EnumFontFamiliesExA( hDC
, &lf
, (FONTENUMPROCEXA
)efproc
, lpData
, 0 );
804 /***********************************************************************
805 * EnumFontFamiliesW (GDI32.@)
807 INT WINAPI
EnumFontFamiliesW( HDC hDC
, LPCWSTR lpFamily
,
808 FONTENUMPROCW efproc
, LPARAM lpData
)
812 lf
.lfCharSet
= DEFAULT_CHARSET
;
813 if( lpFamily
) lstrcpynW( lf
.lfFaceName
, lpFamily
, LF_FACESIZE
);
814 else lf
.lfFaceName
[0] = 0;
816 return EnumFontFamiliesExW( hDC
, &lf
, (FONTENUMPROCEXW
)efproc
, lpData
, 0 );
819 /***********************************************************************
820 * EnumFonts16 (GDI.70)
822 INT16 WINAPI
EnumFonts16( HDC16 hDC
, LPCSTR lpName
, FONTENUMPROC16 efproc
,
825 return EnumFontFamilies16( hDC
, lpName
, (FONTENUMPROCEX16
)efproc
, lpData
);
828 /***********************************************************************
829 * EnumFontsA (GDI32.@)
831 INT WINAPI
EnumFontsA( HDC hDC
, LPCSTR lpName
, FONTENUMPROCA efproc
,
834 return EnumFontFamiliesA( hDC
, lpName
, efproc
, lpData
);
837 /***********************************************************************
838 * EnumFontsW (GDI32.@)
840 INT WINAPI
EnumFontsW( HDC hDC
, LPCWSTR lpName
, FONTENUMPROCW efproc
,
843 return EnumFontFamiliesW( hDC
, lpName
, efproc
, lpData
);
847 /***********************************************************************
848 * GetTextCharacterExtra16 (GDI.89)
850 INT16 WINAPI
GetTextCharacterExtra16( HDC16 hdc
)
852 return (INT16
)GetTextCharacterExtra( hdc
);
856 /***********************************************************************
857 * GetTextCharacterExtra (GDI32.@)
859 INT WINAPI
GetTextCharacterExtra( HDC hdc
)
862 DC
*dc
= DC_GetDCPtr( hdc
);
864 ret
= abs( (dc
->charExtra
* dc
->wndExtX
+ dc
->vportExtX
/ 2)
866 GDI_ReleaseObj( hdc
);
871 /***********************************************************************
872 * SetTextCharacterExtra16 (GDI.8)
874 INT16 WINAPI
SetTextCharacterExtra16( HDC16 hdc
, INT16 extra
)
876 return (INT16
)SetTextCharacterExtra( hdc
, extra
);
880 /***********************************************************************
881 * SetTextCharacterExtra (GDI32.@)
883 INT WINAPI
SetTextCharacterExtra( HDC hdc
, INT extra
)
886 DC
* dc
= DC_GetDCPtr( hdc
);
888 if (dc
->funcs
->pSetTextCharacterExtra
)
889 prev
= dc
->funcs
->pSetTextCharacterExtra( dc
, extra
);
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
);
896 GDI_ReleaseObj( hdc
);
901 /***********************************************************************
902 * SetTextJustification16 (GDI.10)
904 INT16 WINAPI
SetTextJustification16( HDC16 hdc
, INT16 extra
, INT16 breaks
)
906 return SetTextJustification( hdc
, extra
, breaks
);
910 /***********************************************************************
911 * SetTextJustification (GDI32.@)
913 BOOL WINAPI
SetTextJustification( HDC hdc
, INT extra
, INT breaks
)
916 DC
* dc
= DC_GetDCPtr( hdc
);
917 if (!dc
) return FALSE
;
918 if (dc
->funcs
->pSetTextJustification
)
919 ret
= dc
->funcs
->pSetTextJustification( dc
, extra
, breaks
);
922 extra
= abs((extra
* dc
->vportExtX
+ dc
->wndExtX
/ 2) / dc
->wndExtX
);
923 if (!extra
) breaks
= 0;
924 dc
->breakTotalExtra
= extra
;
925 dc
->breakCount
= breaks
;
928 dc
->breakExtra
= extra
/ breaks
;
929 dc
->breakRem
= extra
- (dc
->breakCount
* dc
->breakExtra
);
937 GDI_ReleaseObj( hdc
);
942 /***********************************************************************
943 * GetTextFace16 (GDI.92)
945 INT16 WINAPI
GetTextFace16( HDC16 hdc
, INT16 count
, LPSTR name
)
947 return GetTextFaceA(hdc
,count
,name
);
950 /***********************************************************************
951 * GetTextFaceA (GDI32.@)
953 INT WINAPI
GetTextFaceA( HDC hdc
, INT count
, LPSTR name
)
955 INT res
= GetTextFaceW(hdc
, 0, NULL
);
956 LPWSTR nameW
= HeapAlloc( GetProcessHeap(), 0, res
* 2 );
957 GetTextFaceW( hdc
, res
, nameW
);
960 res
= WideCharToMultiByte( CP_ACP
, 0, nameW
, -1, name
, count
,
963 res
= WideCharToMultiByte( CP_ACP
, 0, nameW
, -1, NULL
, 0, NULL
, NULL
);
964 HeapFree( GetProcessHeap(), 0, nameW
);
968 /***********************************************************************
969 * GetTextFaceW (GDI32.@)
971 INT WINAPI
GetTextFaceW( HDC hdc
, INT count
, LPWSTR name
)
976 DC
* dc
= DC_GetDCPtr( hdc
);
979 if ((font
= (FONTOBJ
*) GDI_GetObjPtr( dc
->hFont
, FONT_MAGIC
)))
983 lstrcpynW( name
, font
->logfont
.lfFaceName
, count
);
986 else ret
= strlenW(font
->logfont
.lfFaceName
) + 1;
987 GDI_ReleaseObj( dc
->hFont
);
989 GDI_ReleaseObj( hdc
);
994 /***********************************************************************
995 * GetTextExtent16 (GDI.91)
997 DWORD WINAPI
GetTextExtent16( HDC16 hdc
, LPCSTR str
, INT16 count
)
1000 if (!GetTextExtentPoint16( hdc
, str
, count
, &size
)) return 0;
1001 return MAKELONG( size
.cx
, size
.cy
);
1005 /***********************************************************************
1006 * GetTextExtentPoint16 (GDI.471)
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).
1012 BOOL16 WINAPI
GetTextExtentPoint16( HDC16 hdc
, LPCSTR str
, INT16 count
,
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
;
1025 /***********************************************************************
1026 * GetTextExtentPoint32A (GDI32.@)
1028 BOOL WINAPI
GetTextExtentPoint32A( HDC hdc
, LPCSTR str
, INT count
,
1032 UINT codepage
= CP_ACP
; /* FIXME: get codepage of font charset */
1033 DC
* dc
= DC_GetDCPtr( hdc
);
1035 if (!dc
) return FALSE
;
1037 if (dc
->funcs
->pGetTextExtentPoint
)
1039 /* str may not be 0 terminated so we can't use HEAP_strdupWtoA.
1040 * So we use MultiByteToWideChar.
1042 UINT wlen
= MultiByteToWideChar(codepage
,0,str
,count
,NULL
,0);
1043 LPWSTR p
= HeapAlloc( GetProcessHeap(), 0, wlen
* sizeof(WCHAR
) );
1046 wlen
= MultiByteToWideChar(codepage
,0,str
,count
,p
,wlen
);
1047 ret
= dc
->funcs
->pGetTextExtentPoint( dc
, p
, wlen
, size
);
1048 HeapFree( GetProcessHeap(), 0, p
);
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
);
1058 /***********************************************************************
1059 * GetTextExtentPoint32W [GDI32.@] Computes width/height for a string
1061 * Computes width and height of the specified string.
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 */
1074 DC
* dc
= DC_GetDCPtr( hdc
);
1077 if(dc
->funcs
->pGetTextExtentPoint
)
1078 ret
= dc
->funcs
->pGetTextExtentPoint( dc
, str
, count
, size
);
1079 GDI_ReleaseObj( hdc
);
1081 TRACE("(%08x %s %d %p): returning %ld x %ld\n",
1082 hdc
, debugstr_wn (str
, count
), count
, size
, size
->cx
, size
->cy
);
1087 /***********************************************************************
1088 * GetTextExtentPointA (GDI32.@)
1090 BOOL WINAPI
GetTextExtentPointA( HDC hdc
, LPCSTR str
, INT count
,
1093 TRACE("not bug compatible.\n");
1094 return GetTextExtentPoint32A( hdc
, str
, count
, size
);
1097 /***********************************************************************
1098 * GetTextExtentPointW (GDI32.@)
1100 BOOL WINAPI
GetTextExtentPointW( HDC hdc
, LPCWSTR str
, INT count
,
1103 TRACE("not bug compatible.\n");
1104 return GetTextExtentPoint32W( hdc
, str
, count
, size
);
1108 /***********************************************************************
1109 * GetTextExtentExPointA (GDI32.@)
1111 BOOL WINAPI
GetTextExtentExPointA( HDC hdc
, LPCSTR str
, INT count
,
1112 INT maxExt
, LPINT lpnFit
,
1113 LPINT alpDx
, LPSIZE size
)
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
);
1126 /***********************************************************************
1127 * GetTextExtentExPointW (GDI32.@)
1130 BOOL WINAPI
GetTextExtentExPointW( HDC hdc
, LPCWSTR str
, INT count
,
1131 INT maxExt
, LPINT lpnFit
,
1132 LPINT alpDx
, LPSIZE size
)
1134 int index
, nFit
, extent
;
1137 DC
* dc
= DC_GetDCPtr( hdc
);
1138 if (!dc
) return FALSE
;
1140 if (!dc
->funcs
->pGetTextExtentPoint
) goto done
;
1142 size
->cx
= size
->cy
= nFit
= extent
= 0;
1143 for(index
= 0; index
< count
; index
++)
1145 if(!dc
->funcs
->pGetTextExtentPoint( dc
, str
, 1, &tSize
)) goto done
;
1146 if( extent
+tSize
.cx
< maxExt
)
1151 if( alpDx
) alpDx
[index
] = extent
;
1152 if( tSize
.cy
> size
->cy
) size
->cy
= tSize
.cy
;
1160 TRACE("(%08x %s %d) returning %d %ld x %ld\n",
1161 hdc
,debugstr_wn(str
,count
),maxExt
,nFit
, size
->cx
,size
->cy
);
1164 GDI_ReleaseObj( hdc
);
1168 /***********************************************************************
1169 * GetTextMetrics16 (GDI.93)
1171 BOOL16 WINAPI
GetTextMetrics16( HDC16 hdc
, TEXTMETRIC16
*metrics
)
1175 if (!GetTextMetricsW( (HDC
)hdc
, &tm32
)) return FALSE
;
1176 FONT_TextMetricWTo16( &tm32
, metrics
);
1181 /***********************************************************************
1182 * GetTextMetricsA (GDI32.@)
1184 BOOL WINAPI
GetTextMetricsA( HDC hdc
, TEXTMETRICA
*metrics
)
1188 if (!GetTextMetricsW( hdc
, &tm32
)) return FALSE
;
1189 FONT_TextMetricWToA( &tm32
, metrics
);
1193 /***********************************************************************
1194 * GetTextMetricsW (GDI32.@)
1196 BOOL WINAPI
GetTextMetricsW( HDC hdc
, TEXTMETRICW
*metrics
)
1199 DC
* dc
= DC_GetDCPtr( hdc
);
1200 if (!dc
) return FALSE
;
1202 if (dc
->funcs
->pGetTextMetrics
&& dc
->funcs
->pGetTextMetrics( dc
, metrics
))
1204 /* device layer returns values in device units
1205 * therefore we have to convert them to logical */
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)))
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
);
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"
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
,
1243 metrics
->tmHeight
);
1245 GDI_ReleaseObj( hdc
);
1250 /***********************************************************************
1251 * GetOutlineTextMetrics16 [GDI.308] Gets metrics for TrueType fonts.
1254 * lpOTM should be LPOUTLINETEXTMETRIC
1257 * Success: Non-zero or size of required buffer
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 */
1265 FIXME("(%04x,%04x,%p): stub\n", hdc
,cbData
,lpOTM
);
1270 /***********************************************************************
1271 * GetOutlineTextMetrics (GDI.207)
1272 * GetOutlineTextMetricsA (GDI32.@)
1273 * Gets metrics for TrueType fonts.
1277 * Success: Non-zero or size of required buffer
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 */
1288 LPTEXTMETRICA lptxtMetr
;
1295 lpOTM
= (LPOUTLINETEXTMETRICA
)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(OUTLINETEXTMETRICA
));
1296 rtn
= sizeof(OUTLINETEXTMETRICA
);
1300 cbData
= sizeof(*lpOTM
);
1304 lpOTM
->otmSize
= cbData
;
1306 lptxtMetr
=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(TEXTMETRICA
));
1308 if (!GetTextMetricsA(hdc
,lptxtMetr
))
1313 memcpy(&(lpOTM
->otmTextMetrics
),lptxtMetr
,sizeof(TEXTMETRICA
));
1316 HeapFree(GetProcessHeap(),HEAP_ZERO_MEMORY
,lptxtMetr
);
1318 lpOTM
->otmFiller
= 0;
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;
1331 lpOTM
->otmfsSelection
= 0;
1332 lpOTM
->otmfsType
= 0;
1335 Further fill of the structure not implemented,
1336 Needs real values for the structure members
1342 /***********************************************************************
1343 * GetOutlineTextMetricsW [GDI32.@]
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 */
1350 FIXME("(%d,%d,%p): stub\n", hdc
, cbData
, lpOTM
);
1354 /***********************************************************************
1355 * GetCharWidth16 (GDI.350)
1356 * GetCharWidth16 (DISPLAY.350)
1358 BOOL16 WINAPI
GetCharWidth16( HDC16 hdc
, UINT16 firstChar
, UINT16 lastChar
,
1361 BOOL retVal
= FALSE
;
1363 if( firstChar
!= lastChar
)
1365 LPINT buf32
= (LPINT
)HeapAlloc(GetProcessHeap(), 0,
1366 sizeof(INT
)*(1 + (lastChar
- firstChar
)));
1369 LPINT obuf32
= buf32
;
1372 retVal
= GetCharWidth32A(hdc
, firstChar
, lastChar
, buf32
);
1375 for (i
= firstChar
; i
<= lastChar
; i
++)
1376 *buffer
++ = *buf32
++;
1378 HeapFree(GetProcessHeap(), 0, obuf32
);
1381 else /* happens quite often to warrant a special treatment */
1384 retVal
= GetCharWidth32A(hdc
, firstChar
, lastChar
, &chWidth
);
1391 /***********************************************************************
1392 * GetCharWidth32A (GDI32.@)
1394 BOOL WINAPI
GetCharWidth32A( HDC hdc
, UINT firstChar
, UINT lastChar
,
1399 DC
* dc
= DC_GetDCPtr( hdc
);
1400 if (!dc
) return FALSE
;
1402 if (dc
->funcs
->pGetCharWidth
&& dc
->funcs
->pGetCharWidth( dc
, firstChar
, lastChar
, buffer
))
1404 /* convert device units to logical */
1406 extra
= dc
->vportExtX
>> 1;
1407 for( i
= firstChar
; i
<= lastChar
; i
++, buffer
++ )
1408 *buffer
= (*buffer
* dc
->wndExtX
+ extra
) / dc
->vportExtX
;
1411 GDI_ReleaseObj( hdc
);
1416 /***********************************************************************
1417 * GetCharWidth32W (GDI32.@)
1419 BOOL WINAPI
GetCharWidth32W( HDC hdc
, UINT firstChar
, UINT lastChar
,
1422 return GetCharWidth32A( hdc
, firstChar
, lastChar
, buffer
);
1426 /* FIXME: all following APIs ******************************************/
1429 /***********************************************************************
1430 * SetMapperFlags16 (GDI.349)
1432 DWORD WINAPI
SetMapperFlags16( HDC16 hDC
, DWORD dwFlag
)
1434 return SetMapperFlags( hDC
, dwFlag
);
1438 /***********************************************************************
1439 * SetMapperFlags (GDI32.@)
1441 DWORD WINAPI
SetMapperFlags( HDC hDC
, DWORD dwFlag
)
1443 DC
*dc
= DC_GetDCPtr( hDC
);
1446 if(dc
->funcs
->pSetMapperFlags
)
1447 ret
= dc
->funcs
->pSetMapperFlags( dc
, dwFlag
);
1449 FIXME("(0x%04x, 0x%08lx): stub - harmless\n", hDC
, dwFlag
);
1450 GDI_ReleaseObj( hDC
);
1454 /***********************************************************************
1455 * GetAspectRatioFilterEx16 (GDI.486)
1457 BOOL16 WINAPI
GetAspectRatioFilterEx16( HDC16 hdc
, LPSIZE16 pAspectRatio
)
1459 FIXME("(%04x, %p): -- Empty Stub !\n", hdc
, pAspectRatio
);
1463 /***********************************************************************
1464 * GetAspectRatioFilterEx (GDI32.@)
1466 BOOL WINAPI
GetAspectRatioFilterEx( HDC hdc
, LPSIZE pAspectRatio
)
1468 FIXME("(%04x, %p): -- Empty Stub !\n", hdc
, pAspectRatio
);
1472 /***********************************************************************
1473 * GetCharABCWidths16 (GDI.307)
1475 BOOL16 WINAPI
GetCharABCWidths16( HDC16 hdc
, UINT16 firstChar
, UINT16 lastChar
,
1479 if (!GetCharABCWidthsA( hdc
, firstChar
, lastChar
, &abc32
)) return FALSE
;
1480 abc
->abcA
= abc32
.abcA
;
1481 abc
->abcB
= abc32
.abcB
;
1482 abc
->abcC
= abc32
.abcC
;
1487 /***********************************************************************
1488 * GetCharABCWidthsA (GDI32.@)
1490 BOOL WINAPI
GetCharABCWidthsA(HDC hdc
, UINT firstChar
, UINT lastChar
,
1493 return GetCharABCWidthsW( hdc
, firstChar
, lastChar
, abc
);
1497 /******************************************************************************
1498 * GetCharABCWidthsW [GDI32.@] Retrieves widths of characters in range
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
1507 * Only works with TrueType fonts
1513 BOOL WINAPI
GetCharABCWidthsW( HDC hdc
, UINT firstChar
, UINT lastChar
,
1516 /* No TrueType fonts in Wine so far */
1517 FIXME("(%04x,%04x,%04x,%p): stub\n", hdc
, firstChar
, lastChar
, abc
);
1522 /***********************************************************************
1523 * GetGlyphOutline16 (GDI.309)
1525 DWORD WINAPI
GetGlyphOutline16( HDC16 hdc
, UINT16 uChar
, UINT16 fuFormat
,
1526 LPGLYPHMETRICS16 lpgm
, DWORD cbBuffer
,
1527 LPVOID lpBuffer
, const MAT2
*lpmat2
)
1529 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1530 hdc
, uChar
, fuFormat
, lpgm
, cbBuffer
, lpBuffer
, lpmat2
);
1531 return (DWORD
)-1; /* failure */
1535 /***********************************************************************
1536 * GetGlyphOutlineA (GDI32.@)
1538 DWORD WINAPI
GetGlyphOutlineA( HDC hdc
, UINT uChar
, UINT fuFormat
,
1539 LPGLYPHMETRICS lpgm
, DWORD cbBuffer
,
1540 LPVOID lpBuffer
, const MAT2
*lpmat2
)
1542 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1543 hdc
, uChar
, fuFormat
, lpgm
, cbBuffer
, lpBuffer
, lpmat2
);
1544 return (DWORD
)-1; /* failure */
1547 /***********************************************************************
1548 * GetGlyphOutlineW (GDI32.@)
1550 DWORD WINAPI
GetGlyphOutlineW( HDC hdc
, UINT uChar
, UINT fuFormat
,
1551 LPGLYPHMETRICS lpgm
, DWORD cbBuffer
,
1552 LPVOID lpBuffer
, const MAT2
*lpmat2
)
1554 FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1555 hdc
, uChar
, fuFormat
, lpgm
, cbBuffer
, lpBuffer
, lpmat2
);
1556 return (DWORD
)-1; /* failure */
1559 /***********************************************************************
1560 * CreateScalableFontResource16 (GDI.310)
1562 BOOL16 WINAPI
CreateScalableFontResource16( UINT16 fHidden
,
1563 LPCSTR lpszResourceFile
,
1564 LPCSTR fontFile
, LPCSTR path
)
1566 return CreateScalableFontResourceA( fHidden
, lpszResourceFile
,
1570 /***********************************************************************
1571 * CreateScalableFontResourceA (GDI32.@)
1573 BOOL WINAPI
CreateScalableFontResourceA( DWORD fHidden
,
1574 LPCSTR lpszResourceFile
,
1575 LPCSTR lpszFontFile
,
1576 LPCSTR lpszCurrentPath
)
1578 /* fHidden=1 - only visible for the calling app, read-only, not
1579 * enumbered with EnumFonts/EnumFontFamilies
1580 * lpszCurrentPath can be NULL
1582 FIXME("(%ld,%s,%s,%s): stub\n",
1583 fHidden
, lpszResourceFile
, lpszFontFile
, lpszCurrentPath
);
1584 return FALSE
; /* create failed */
1587 /***********************************************************************
1588 * CreateScalableFontResourceW (GDI32.@)
1590 BOOL WINAPI
CreateScalableFontResourceW( DWORD fHidden
,
1591 LPCWSTR lpszResourceFile
,
1592 LPCWSTR lpszFontFile
,
1593 LPCWSTR lpszCurrentPath
)
1595 FIXME("(%ld,%p,%p,%p): stub\n",
1596 fHidden
, lpszResourceFile
, lpszFontFile
, lpszCurrentPath
);
1597 return FALSE
; /* create failed */
1601 /*************************************************************************
1602 * GetRasterizerCaps16 (GDI.313)
1604 BOOL16 WINAPI
GetRasterizerCaps16( LPRASTERIZER_STATUS lprs
, UINT16 cbNumBytes
)
1606 return GetRasterizerCaps( lprs
, cbNumBytes
);
1610 /*************************************************************************
1611 * GetRasterizerCaps (GDI32.@)
1613 BOOL WINAPI
GetRasterizerCaps( LPRASTERIZER_STATUS lprs
, UINT cbNumBytes
)
1615 lprs
->nSize
= sizeof(RASTERIZER_STATUS
);
1616 lprs
->wFlags
= TT_AVAILABLE
|TT_ENABLED
;
1617 lprs
->nLanguageID
= 0;
1622 /*************************************************************************
1623 * GetKerningPairs16 (GDI.332)
1625 INT16 WINAPI
GetKerningPairs16( HDC16 hDC
, INT16 cPairs
,
1626 LPKERNINGPAIR16 lpKerningPairs
)
1628 /* At this time kerning is ignored (set to 0) */
1630 FIXME("(%x,%d,%p): almost empty stub!\n", hDC
, cPairs
, lpKerningPairs
);
1631 for (i
= 0; i
< cPairs
; i
++)
1632 lpKerningPairs
[i
].iKernAmount
= 0;
1638 /*************************************************************************
1639 * GetKerningPairsA (GDI32.@)
1641 DWORD WINAPI
GetKerningPairsA( HDC hDC
, DWORD cPairs
,
1642 LPKERNINGPAIR lpKerningPairs
)
1645 FIXME("(%x,%ld,%p): almost empty stub!\n", hDC
, cPairs
, lpKerningPairs
);
1646 for (i
= 0; i
< cPairs
; i
++)
1647 lpKerningPairs
[i
].iKernAmount
= 0;
1652 /*************************************************************************
1653 * GetKerningPairsW (GDI32.@)
1655 DWORD WINAPI
GetKerningPairsW( HDC hDC
, DWORD cPairs
,
1656 LPKERNINGPAIR lpKerningPairs
)
1658 return GetKerningPairsA( hDC
, cPairs
, lpKerningPairs
);
1661 /*************************************************************************
1662 * TranslateCharsetInfo [GDI32.@]
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.
1669 * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
1670 * only one codepage should be set in *lpSrc.
1673 * TRUE on success, FALSE on failure.
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
1682 LPCHARSETINFO lpCs
, /* [out] structure to receive charset information */
1683 DWORD flags
/* [in] determines interpretation of lpSrc */
1687 case TCI_SRCFONTSIG
:
1688 while (!(*lpSrc
>>index
& 0x0001) && index
<MAXTCIINDEX
) index
++;
1690 case TCI_SRCCODEPAGE
:
1691 while ((UINT
) (lpSrc
) != FONT_tci
[index
].ciACP
&& index
< MAXTCIINDEX
) index
++;
1693 case TCI_SRCCHARSET
:
1694 while ((UINT
) (lpSrc
) != FONT_tci
[index
].ciCharset
&& index
< MAXTCIINDEX
) index
++;
1699 if (index
>= MAXTCIINDEX
|| FONT_tci
[index
].ciCharset
== DEFAULT_CHARSET
) return FALSE
;
1700 memcpy(lpCs
, &FONT_tci
[index
], sizeof(CHARSETINFO
));
1704 /*************************************************************************
1705 * GetFontLanguageInfo (GDI32.@)
1707 DWORD WINAPI
GetFontLanguageInfo(HDC hdc
) {
1708 /* return value 0 is correct for most cases anyway */
1709 FIXME("(%x):stub!\n", hdc
);
1713 /*************************************************************************
1714 * GetFontLanguageInfo (GDI.616)
1716 DWORD WINAPI
GetFontLanguageInfo16(HDC16 hdc
) {
1717 /* return value 0 is correct for most cases anyway */
1718 FIXME("(%x):stub!\n",hdc
);
1722 /*************************************************************************
1723 * GetFontData [GDI32.@] Retrieve data for TrueType font
1727 * success: Number of bytes returned
1728 * failure: GDI_ERROR
1732 * Calls SetLastError()
1738 DWORD WINAPI
GetFontData(HDC hdc
, DWORD table
, DWORD offset
,
1739 LPVOID buffer
, DWORD length
)
1741 FIXME("(%x,%ld,%ld,%p,%ld): stub\n", hdc
, table
, offset
, buffer
, length
);
1742 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
1746 /*************************************************************************
1747 * GetFontData16 [GDI.311]
1750 DWORD WINAPI
GetFontData16(HDC16 hdc
, DWORD dwTable
, DWORD dwOffset
,
1751 LPVOID lpvBuffer
, DWORD cbData
)
1753 return GetFontData(hdc
, dwTable
, dwOffset
, lpvBuffer
, cbData
);
1756 /*************************************************************************
1757 * GetCharacterPlacementA [GDI32.@]
1760 * the web browser control of ie4 calls this with dwFlags=0
1763 GetCharacterPlacementA(HDC hdc
, LPCSTR lpString
, INT uCount
,
1764 INT nMaxExtent
, GCP_RESULTSA
*lpResults
,
1770 TRACE("%s 0x%08x 0x%08x 0x%08lx:stub!\n",
1771 debugstr_a(lpString
), uCount
, nMaxExtent
, dwFlags
);
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
);
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");
1784 /* copy will do if the GCP_REORDER flag is not set */
1785 if(lpResults
->lpOutString
)
1787 lstrcpynA(lpResults
->lpOutString
, lpString
, uCount
);
1790 if (lpResults
->lpDx
)
1793 for (i
=0; i
<uCount
;i
++)
1795 if (GetCharWidth32A(hdc
, lpString
[i
], lpString
[i
], &c
))
1796 lpResults
->lpDx
[i
]= c
;
1800 if (GetTextExtentPoint32A(hdc
, lpString
, uCount
, &size
))
1801 ret
= MAKELONG(size
.cx
, size
.cy
);
1806 /*************************************************************************
1807 * GetCharacterPlacementW [GDI32.@]
1810 GetCharacterPlacementW(HDC hdc
, LPCWSTR lpString
, INT uCount
,
1811 INT nMaxExtent
, GCP_RESULTSW
*lpResults
,
1814 /* return value 0 is correct for most cases anyway */
1819 /*************************************************************************
1820 * GetCharABCWidthsFloatA [GDI32.@]
1822 BOOL WINAPI
GetCharABCWidthsFloatA(HDC hdc
, UINT iFirstChar
, UINT iLastChar
,
1825 FIXME_(gdi
)("GetCharABCWidthsFloatA, stub\n");
1829 /*************************************************************************
1830 * GetCharABCWidthsFloatW [GDI32.@]
1832 BOOL WINAPI
GetCharABCWidthsFloatW(HDC hdc
, UINT iFirstChar
,
1833 UINT iLastChar
, LPABCFLOAT lpABCF
)
1835 FIXME_(gdi
)("GetCharABCWidthsFloatW, stub\n");
1839 /*************************************************************************
1840 * GetCharWidthFloatA [GDI32.@]
1842 BOOL WINAPI
GetCharWidthFloatA(HDC hdc
, UINT iFirstChar
,
1843 UINT iLastChar
, PFLOAT pxBuffer
)
1845 FIXME_(gdi
)("GetCharWidthFloatA, stub\n");
1849 /*************************************************************************
1850 * GetCharWidthFloatW [GDI32.@]
1852 BOOL WINAPI
GetCharWidthFloatW(HDC hdc
, UINT iFirstChar
,
1853 UINT iLastChar
, PFLOAT pxBuffer
)
1855 FIXME_(gdi
)("GetCharWidthFloatW, stub\n");
1860 /***********************************************************************
1862 * Font Resource API *
1864 ***********************************************************************/
1865 /***********************************************************************
1866 * AddFontResource16 (GDI.119)
1868 * Can be either .FON, or .FNT, or .TTF, or .FOT font file.
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
1877 INT16 WINAPI
AddFontResource16( LPCSTR filename
)
1879 return AddFontResourceA( filename
);
1883 /***********************************************************************
1884 * AddFontResourceA (GDI32.@)
1886 INT WINAPI
AddFontResourceA( LPCSTR str
)
1888 FIXME("(%s): stub! Read the Wine User Guide on how to install "
1889 "this font manually.\n", debugres_a(str
));
1894 /***********************************************************************
1895 * AddFontResourceW (GDI32.@)
1897 INT WINAPI
AddFontResourceW( LPCWSTR str
)
1899 FIXME("(%s): stub! Read the Wine User Guide on how to install "
1900 "this font manually.\n", debugres_w(str
));
1904 /***********************************************************************
1905 * RemoveFontResource16 (GDI.136)
1907 BOOL16 WINAPI
RemoveFontResource16( LPCSTR str
)
1909 FIXME("(%s): stub\n", debugres_a(str
));
1914 /***********************************************************************
1915 * RemoveFontResourceA (GDI32.@)
1917 BOOL WINAPI
RemoveFontResourceA( LPCSTR str
)
1919 /* This is how it should look like */
1921 fontResource** ppfr;
1922 BOOL32 retVal = FALSE;
1924 EnterCriticalSection( &crtsc_fonts_X11 );
1925 for( ppfr = &fontList; *ppfr; ppfr = &(*ppfr)->next )
1926 if( !strcasecmp( (*ppfr)->lfFaceName, str ) )
1928 if(((*ppfr)->fr_flags & (FR_SOFTFONT | FR_SOFTRESOURCE)) &&
1929 (*ppfr)->hOwnerProcess == GetCurrentProcess() )
1931 if( (*ppfr)->fo_count )
1932 (*ppfr)->fr_flags |= FR_REMOVED;
1934 XFONT_RemoveFontResource( ppfr );
1938 LeaveCriticalSection( &crtsc_fonts_X11 );
1941 FIXME("(%s): stub\n", debugres_a(str
));
1946 /***********************************************************************
1947 * RemoveFontResourceW (GDI32.@)
1949 BOOL WINAPI
RemoveFontResourceW( LPCWSTR str
)
1951 FIXME("(%s): stub\n", debugres_w(str
) );