Autosyncing with Wine HEAD
[reactos.git] / reactos / dll / win32 / gdiplus / font.c
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "wingdi.h"
24 #include "winnls.h"
25 #include "winreg.h"
26 #include "wine/debug.h"
27 #include "wine/unicode.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL (gdiplus);
30
31 #include "objbase.h"
32
33 #include "gdiplus.h"
34 #include "gdiplus_private.h"
35
36 static const REAL mm_per_inch = 25.4;
37 static const REAL inch_per_point = 1.0/72.0;
38
39 static inline REAL get_dpi (void)
40 {
41 REAL dpi;
42 GpGraphics *graphics;
43 HDC hdc = GetDC(0);
44 GdipCreateFromHDC (hdc, &graphics);
45 GdipGetDpiX(graphics, &dpi);
46 GdipDeleteGraphics(graphics);
47 ReleaseDC (0, hdc);
48
49 return dpi;
50 }
51
52 static inline REAL point_to_pixel (REAL point)
53 {
54 return point * get_dpi() * inch_per_point;
55 }
56
57 static inline REAL inch_to_pixel (REAL inch)
58 {
59 return inch * get_dpi();
60 }
61
62 static inline REAL document_to_pixel (REAL doc)
63 {
64 return doc * (get_dpi() / 300.0); /* Per MSDN */
65 }
66
67 static inline REAL mm_to_pixel (REAL mm)
68 {
69 return mm * (get_dpi() / mm_per_inch);
70 }
71
72 /*******************************************************************************
73 * GdipCreateFont [GDIPLUS.@]
74 *
75 * Create a new font based off of a FontFamily
76 *
77 * PARAMS
78 * *fontFamily [I] Family to base the font off of
79 * emSize [I] Size of the font
80 * style [I] Bitwise OR of FontStyle enumeration
81 * unit [I] Unit emSize is measured in
82 * **font [I] the resulting Font object
83 *
84 * RETURNS
85 * SUCCESS: Ok
86 * FAILURE: InvalidParameter if fontfamily or font is NULL.
87 * FAILURE: FontFamilyNotFound if an invalid FontFamily is given
88 *
89 * NOTES
90 * UnitDisplay is unsupported.
91 * emSize is stored separately from lfHeight, to hold the fraction.
92 */
93 GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily *fontFamily,
94 REAL emSize, INT style, Unit unit, GpFont **font)
95 {
96 WCHAR facename[LF_FACESIZE];
97 LOGFONTW* lfw;
98 const TEXTMETRICW* tmw;
99 GpStatus stat;
100
101 if (!fontFamily || !fontFamily->FamilyName || !font)
102 return InvalidParameter;
103
104 TRACE("%p (%s), %f, %d, %d, %p\n", fontFamily,
105 debugstr_w(fontFamily->FamilyName), emSize, style, unit, font);
106
107 stat = GdipGetFamilyName (fontFamily, facename, 0);
108 if (stat != Ok) return stat;
109 *font = GdipAlloc(sizeof(GpFont));
110
111 tmw = &fontFamily->tmw;
112 lfw = &((*font)->lfw);
113 ZeroMemory(&(*lfw), sizeof(*lfw));
114
115 lfw->lfWeight = tmw->tmWeight;
116 lfw->lfItalic = tmw->tmItalic;
117 lfw->lfUnderline = tmw->tmUnderlined;
118 lfw->lfStrikeOut = tmw->tmStruckOut;
119 lfw->lfCharSet = tmw->tmCharSet;
120 lfw->lfPitchAndFamily = tmw->tmPitchAndFamily;
121 lstrcpynW((lfw->lfFaceName), facename, sizeof(WCHAR) * LF_FACESIZE);
122
123 switch (unit)
124 {
125 case UnitWorld:
126 /* FIXME: Figure out when World != Pixel */
127 lfw->lfHeight = emSize; break;
128 case UnitDisplay:
129 FIXME("Unknown behavior for UnitDisplay! Please report!\n");
130 /* FIXME: Figure out how this works...
131 * MSDN says that if "DISPLAY" is a monitor, then pixel should be
132 * used. That's not what I got. Tests on Windows revealed no output,
133 * and the tests in tests/font crash windows */
134 lfw->lfHeight = 0; break;
135 case UnitPixel:
136 lfw->lfHeight = emSize; break;
137 case UnitPoint:
138 lfw->lfHeight = point_to_pixel(emSize); break;
139 case UnitInch:
140 lfw->lfHeight = inch_to_pixel(emSize); break;
141 case UnitDocument:
142 lfw->lfHeight = document_to_pixel(emSize); break;
143 case UnitMillimeter:
144 lfw->lfHeight = mm_to_pixel(emSize); break;
145 }
146
147 lfw->lfHeight *= -1;
148
149 lfw->lfWeight = style & FontStyleBold ? 700 : 400;
150 lfw->lfItalic = style & FontStyleItalic;
151 lfw->lfUnderline = style & FontStyleUnderline;
152 lfw->lfStrikeOut = style & FontStyleStrikeout;
153
154 (*font)->unit = unit;
155 (*font)->emSize = emSize;
156
157 return Ok;
158 }
159
160 GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC hdc,
161 GDIPCONST LOGFONTW *logfont, GpFont **font)
162 {
163 HFONT hfont, oldfont;
164 TEXTMETRICW textmet;
165
166 if(!logfont || !font)
167 return InvalidParameter;
168
169 *font = GdipAlloc(sizeof(GpFont));
170 if(!*font) return OutOfMemory;
171
172 memcpy(&(*font)->lfw.lfFaceName, logfont->lfFaceName, LF_FACESIZE *
173 sizeof(WCHAR));
174 (*font)->lfw.lfHeight = logfont->lfHeight;
175 (*font)->lfw.lfItalic = logfont->lfItalic;
176 (*font)->lfw.lfUnderline = logfont->lfUnderline;
177 (*font)->lfw.lfStrikeOut = logfont->lfStrikeOut;
178
179 (*font)->emSize = logfont->lfHeight;
180 (*font)->unit = UnitPixel;
181
182 hfont = CreateFontIndirectW(&(*font)->lfw);
183 oldfont = SelectObject(hdc, hfont);
184 GetTextMetricsW(hdc, &textmet);
185
186 (*font)->lfw.lfHeight = -textmet.tmHeight;
187 (*font)->lfw.lfWeight = textmet.tmWeight;
188
189 SelectObject(hdc, oldfont);
190 DeleteObject(hfont);
191
192 return Ok;
193 }
194
195 GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC hdc,
196 GDIPCONST LOGFONTA *lfa, GpFont **font)
197 {
198 LOGFONTW lfw;
199
200 if(!lfa || !font)
201 return InvalidParameter;
202
203 memcpy(&lfw, lfa, FIELD_OFFSET(LOGFONTA,lfFaceName) );
204
205 if(!MultiByteToWideChar(CP_ACP, 0, lfa->lfFaceName, -1, lfw.lfFaceName, LF_FACESIZE))
206 return GenericError;
207
208 GdipCreateFontFromLogfontW(hdc, &lfw, font);
209
210 return Ok;
211 }
212
213 GpStatus WINGDIPAPI GdipDeleteFont(GpFont* font)
214 {
215 if(!font)
216 return InvalidParameter;
217
218 GdipFree(font);
219
220 return Ok;
221 }
222
223 GpStatus WINGDIPAPI GdipCreateFontFromDC(HDC hdc, GpFont **font)
224 {
225 HFONT hfont;
226 LOGFONTW lfw;
227
228 if(!font)
229 return InvalidParameter;
230
231 hfont = (HFONT)GetCurrentObject(hdc, OBJ_FONT);
232 if(!hfont)
233 return GenericError;
234
235 if(!GetObjectW(hfont, sizeof(LOGFONTW), &lfw))
236 return GenericError;
237
238 return GdipCreateFontFromLogfontW(hdc, &lfw, font);
239 }
240
241 /******************************************************************************
242 * GdipGetFontSize [GDIPLUS.@]
243 *
244 * Returns the size of the font in Units
245 *
246 * PARAMS
247 * *font [I] The font to retrieve size from
248 * *size [O] Pointer to hold retrieved value
249 *
250 * RETURNS
251 * SUCCESS: Ok
252 * FAILURE: InvalidParamter (font or size was NULL)
253 *
254 * NOTES
255 * Size returned is actually emSize -- not internal size used for drawing.
256 */
257 GpStatus WINGDIPAPI GdipGetFontSize(GpFont *font, REAL *size)
258 {
259 if (!(font && size)) return InvalidParameter;
260
261 *size = font->emSize;
262
263 return Ok;
264 }
265
266 /*******************************************************************************
267 * GdipGetFontUnit [GDIPLUS.@]
268 *
269 * PARAMS
270 * font [I] Font to retrieve from
271 * unit [O] Return value
272 *
273 * RETURNS
274 * FAILURE: font or unit was NULL
275 * OK: otherwise
276 */
277 GpStatus WINGDIPAPI GdipGetFontUnit(GpFont *font, Unit *unit)
278 {
279 if (!(font && unit)) return InvalidParameter;
280
281 *unit = font->unit;
282
283 return Ok;
284 }
285
286 /* FIXME: use graphics */
287 GpStatus WINGDIPAPI GdipGetLogFontW(GpFont *font, GpGraphics *graphics,
288 LOGFONTW *lfw)
289 {
290 if(!font || !graphics || !lfw)
291 return InvalidParameter;
292
293 *lfw = font->lfw;
294
295 return Ok;
296 }
297
298 GpStatus WINGDIPAPI GdipCloneFont(GpFont *font, GpFont **cloneFont)
299 {
300 if(!font || !cloneFont)
301 return InvalidParameter;
302
303 *cloneFont = GdipAlloc(sizeof(GpFont));
304 if(!*cloneFont) return OutOfMemory;
305
306 **cloneFont = *font;
307
308 return Ok;
309 }
310
311 /* Borrowed from GDI32 */
312 static INT CALLBACK is_font_installed_proc(const LOGFONTW *elf,
313 const TEXTMETRICW *ntm, DWORD type, LPARAM lParam)
314 {
315 return 0;
316 }
317
318 static BOOL is_font_installed(const WCHAR *name)
319 {
320 HDC hdc = GetDC(0);
321 BOOL ret = FALSE;
322
323 if(!EnumFontFamiliesW(hdc, name, is_font_installed_proc, 0))
324 ret = TRUE;
325
326 ReleaseDC(0, hdc);
327 return ret;
328 }
329
330 /*******************************************************************************
331 * GdipCreateFontFamilyFromName [GDIPLUS.@]
332 *
333 * Creates a font family object based on a supplied name
334 *
335 * PARAMS
336 * name [I] Name of the font
337 * fontCollection [I] What font collection (if any) the font belongs to (may be NULL)
338 * FontFamily [O] Pointer to the resulting FontFamily object
339 *
340 * RETURNS
341 * SUCCESS: Ok
342 * FAILURE: FamilyNotFound if the requested FontFamily does not exist on the system
343 * FAILURE: Invalid parameter if FontFamily or name is NULL
344 *
345 * NOTES
346 * If fontCollection is NULL then the object is not part of any collection
347 *
348 */
349
350 GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name,
351 GpFontCollection *fontCollection,
352 GpFontFamily **FontFamily)
353 {
354 GpFontFamily* ffamily;
355 HDC hdc;
356 HFONT hFont, hfont_old;
357 LOGFONTW lfw;
358
359 TRACE("%s, %p %p\n", debugstr_w(name), fontCollection, FontFamily);
360
361 if (!(name && FontFamily))
362 return InvalidParameter;
363 if (fontCollection)
364 FIXME("No support for FontCollections yet!\n");
365 if (!is_font_installed(name))
366 return FontFamilyNotFound;
367
368 ffamily = GdipAlloc(sizeof (GpFontFamily));
369 if (!ffamily) return OutOfMemory;
370
371 hdc = GetDC(0);
372 lstrcpynW(lfw.lfFaceName, name, sizeof(WCHAR) * LF_FACESIZE);
373 hFont = CreateFontIndirectW (&lfw);
374 hfont_old = SelectObject(hdc, hFont);
375
376 GetTextMetricsW(hdc, &ffamily->tmw);
377 DeleteObject(SelectObject(hdc, hfont_old));
378
379 ffamily->FamilyName = GdipAlloc(LF_FACESIZE * sizeof (WCHAR));
380 if (!ffamily->FamilyName)
381 {
382 GdipFree(ffamily);
383 ReleaseDC(0, hdc);
384 return OutOfMemory;
385 }
386
387 lstrcpynW(ffamily->FamilyName, name, sizeof(WCHAR) * LF_FACESIZE);
388
389 *FontFamily = ffamily;
390 ReleaseDC(0, hdc);
391
392 return Ok;
393 }
394
395 /*******************************************************************************
396 * GdipGetFamilyName [GDIPLUS.@]
397 *
398 * Returns the family name into name
399 *
400 * PARAMS
401 * *family [I] Family to retrieve from
402 * *name [O] WCHARS of the family name
403 * LANGID [I] charset
404 *
405 * RETURNS
406 * SUCCESS: Ok
407 * FAILURE: InvalidParameter if family is NULL
408 *
409 * NOTES
410 * If name is a NULL ptr, then both XP and Vista will crash (so we do as well)
411 */
412 GpStatus WINGDIPAPI GdipGetFamilyName (GDIPCONST GpFontFamily *family,
413 WCHAR *name, LANGID language)
414 {
415 if (family == NULL)
416 return InvalidParameter;
417
418 TRACE("%p, %p, %d\n", family, name, language);
419
420 if (language != LANG_NEUTRAL)
421 FIXME("No support for handling of multiple languages!\n");
422
423 lstrcpynW (name, family->FamilyName, LF_FACESIZE);
424
425 return Ok;
426 }
427
428
429 /*****************************************************************************
430 * GdipDeleteFontFamily [GDIPLUS.@]
431 *
432 * Removes the specified FontFamily
433 *
434 * PARAMS
435 * *FontFamily [I] The family to delete
436 *
437 * RETURNS
438 * SUCCESS: Ok
439 * FAILURE: InvalidParameter if FontFamily is NULL.
440 *
441 */
442 GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily *FontFamily)
443 {
444 if (!FontFamily)
445 return InvalidParameter;
446 TRACE("Deleting %p (%s)\n", FontFamily, debugstr_w(FontFamily->FamilyName));
447
448 GdipFree (FontFamily->FamilyName);
449 GdipFree (FontFamily);
450
451 return Ok;
452 }
453
454 /*****************************************************************************
455 * GdipGetGenericFontFamilyMonospace [GDIPLUS.@]
456 *
457 * Obtains a serif family (Courier New on Windows)
458 *
459 * PARAMS
460 * **nativeFamily [I] Where the font will be stored
461 *
462 * RETURNS
463 * InvalidParameter if nativeFamily is NULL.
464 * Ok otherwise.
465 */
466 GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily)
467 {
468 static const WCHAR CourierNew[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
469
470 if (nativeFamily == NULL) return InvalidParameter;
471
472 return GdipCreateFontFamilyFromName(CourierNew, NULL, nativeFamily);
473 }
474
475 /*****************************************************************************
476 * GdipGetGenericFontFamilySerif [GDIPLUS.@]
477 *
478 * Obtains a serif family (Times New Roman on Windows)
479 *
480 * PARAMS
481 * **nativeFamily [I] Where the font will be stored
482 *
483 * RETURNS
484 * InvalidParameter if nativeFamily is NULL.
485 * Ok otherwise.
486 */
487 GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily)
488 {
489 static const WCHAR TimesNewRoman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
490
491 if (nativeFamily == NULL) return InvalidParameter;
492
493 return GdipCreateFontFamilyFromName(TimesNewRoman, NULL, nativeFamily);
494 }
495
496 /*****************************************************************************
497 * GdipGetGenericFontFamilySansSerif [GDIPLUS.@]
498 *
499 * Obtains a serif family (Microsoft Sans Serif on Windows)
500 *
501 * PARAMS
502 * **nativeFamily [I] Where the font will be stored
503 *
504 * RETURNS
505 * InvalidParameter if nativeFamily is NULL.
506 * Ok otherwise.
507 */
508 GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily)
509 {
510 /* FIXME: On Windows this is called Microsoft Sans Serif, this shouldn't
511 * affect anything */
512 static const WCHAR MSSansSerif[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
513
514 if (nativeFamily == NULL) return InvalidParameter;
515
516 return GdipCreateFontFamilyFromName(MSSansSerif, NULL, nativeFamily);
517 }