winmm: Update Dutch translation.
[wine] / dlls / 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 GpFontCollection installedFontCollection = {0};
40
41 static inline REAL get_dpi (void)
42 {
43     REAL dpi;
44     GpGraphics *graphics;
45     HDC hdc = GetDC(0);
46     GdipCreateFromHDC (hdc, &graphics);
47     GdipGetDpiX(graphics, &dpi);
48     GdipDeleteGraphics(graphics);
49     ReleaseDC (0, hdc);
50
51     return dpi;
52 }
53
54 static inline REAL point_to_pixel (REAL point)
55 {
56     return point * get_dpi() * inch_per_point;
57 }
58
59 static inline REAL inch_to_pixel (REAL inch)
60 {
61     return inch * get_dpi();
62 }
63
64 static inline REAL document_to_pixel (REAL doc)
65 {
66     return doc * (get_dpi() / 300.0); /* Per MSDN */
67 }
68
69 static inline REAL mm_to_pixel (REAL mm)
70 {
71     return mm * (get_dpi() / mm_per_inch);
72 }
73
74 /*******************************************************************************
75  * GdipCreateFont [GDIPLUS.@]
76  *
77  * Create a new font based off of a FontFamily
78  *
79  * PARAMS
80  *  *fontFamily     [I] Family to base the font off of
81  *  emSize          [I] Size of the font
82  *  style           [I] Bitwise OR of FontStyle enumeration
83  *  unit            [I] Unit emSize is measured in
84  *  **font          [I] the resulting Font object
85  *
86  * RETURNS
87  *  SUCCESS: Ok
88  *  FAILURE: InvalidParameter if fontfamily or font is NULL.
89  *  FAILURE: FontFamilyNotFound if an invalid FontFamily is given
90  *
91  * NOTES
92  *  UnitDisplay is unsupported.
93  *  emSize is stored separately from lfHeight, to hold the fraction.
94  */
95 GpStatus WINGDIPAPI GdipCreateFont(GDIPCONST GpFontFamily *fontFamily,
96                         REAL emSize, INT style, Unit unit, GpFont **font)
97 {
98     WCHAR facename[LF_FACESIZE];
99     LOGFONTW* lfw;
100     const NEWTEXTMETRICW* tmw;
101     GpStatus stat;
102
103     if (!fontFamily || !font)
104         return InvalidParameter;
105
106     TRACE("%p (%s), %f, %d, %d, %p\n", fontFamily,
107             debugstr_w(fontFamily->FamilyName), emSize, style, unit, font);
108
109     stat = GdipGetFamilyName (fontFamily, facename, 0);
110     if (stat != Ok) return stat;
111     *font = GdipAlloc(sizeof(GpFont));
112
113     tmw = &fontFamily->tmw;
114     lfw = &((*font)->lfw);
115     ZeroMemory(&(*lfw), sizeof(*lfw));
116
117     lfw->lfWeight = tmw->tmWeight;
118     lfw->lfItalic = tmw->tmItalic;
119     lfw->lfUnderline = tmw->tmUnderlined;
120     lfw->lfStrikeOut = tmw->tmStruckOut;
121     lfw->lfCharSet = tmw->tmCharSet;
122     lfw->lfPitchAndFamily = tmw->tmPitchAndFamily;
123     lstrcpynW(lfw->lfFaceName, facename, LF_FACESIZE);
124
125     switch (unit)
126     {
127         case UnitWorld:
128             /* FIXME: Figure out when World != Pixel */
129             lfw->lfHeight = emSize; break;
130         case UnitDisplay:
131             FIXME("Unknown behavior for UnitDisplay! Please report!\n");
132             /* FIXME: Figure out how this works...
133              * MSDN says that if "DISPLAY" is a monitor, then pixel should be
134              * used. That's not what I got. Tests on Windows revealed no output,
135              * and the tests in tests/font crash windows */
136             lfw->lfHeight = 0; break;
137         case UnitPixel:
138             lfw->lfHeight = emSize; break;
139         case UnitPoint:
140             lfw->lfHeight = point_to_pixel(emSize); break;
141         case UnitInch:
142             lfw->lfHeight = inch_to_pixel(emSize); break;
143         case UnitDocument:
144             lfw->lfHeight = document_to_pixel(emSize); break;
145         case UnitMillimeter:
146             lfw->lfHeight = mm_to_pixel(emSize); break;
147     }
148
149     lfw->lfHeight *= -1;
150
151     lfw->lfWeight = style & FontStyleBold ? 700 : 400;
152     lfw->lfItalic = style & FontStyleItalic;
153     lfw->lfUnderline = style & FontStyleUnderline;
154     lfw->lfStrikeOut = style & FontStyleStrikeout;
155
156     (*font)->unit = unit;
157     (*font)->emSize = emSize;
158     (*font)->height = tmw->ntmSizeEM;
159     (*font)->line_spacing = tmw->tmAscent + tmw->tmDescent + tmw->tmExternalLeading;
160
161     TRACE("<-- %p\n", *font);
162
163     return Ok;
164 }
165
166 /*******************************************************************************
167  * GdipCreateFontFromLogfontW [GDIPLUS.@]
168  */
169 GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC hdc,
170     GDIPCONST LOGFONTW *logfont, GpFont **font)
171 {
172     HFONT hfont, oldfont;
173     TEXTMETRICW textmet;
174
175     TRACE("(%p, %p, %p)\n", hdc, logfont, font);
176
177     if(!logfont || !font)
178         return InvalidParameter;
179
180     if (logfont->lfFaceName[0] == 0)
181         return NotTrueTypeFont;
182
183     *font = GdipAlloc(sizeof(GpFont));
184     if(!*font)  return OutOfMemory;
185
186     memcpy((*font)->lfw.lfFaceName, logfont->lfFaceName, LF_FACESIZE *
187            sizeof(WCHAR));
188     (*font)->lfw.lfHeight = logfont->lfHeight;
189     (*font)->lfw.lfItalic = logfont->lfItalic;
190     (*font)->lfw.lfUnderline = logfont->lfUnderline;
191     (*font)->lfw.lfStrikeOut = logfont->lfStrikeOut;
192
193     (*font)->emSize = logfont->lfHeight;
194     (*font)->unit = UnitPixel;
195
196     hfont = CreateFontIndirectW(&(*font)->lfw);
197     oldfont = SelectObject(hdc, hfont);
198     GetTextMetricsW(hdc, &textmet);
199
200     (*font)->lfw.lfHeight = -(textmet.tmHeight-textmet.tmInternalLeading);
201     (*font)->lfw.lfWeight = textmet.tmWeight;
202     (*font)->lfw.lfCharSet = textmet.tmCharSet;
203
204     (*font)->height = 1; /* FIXME: need NEWTEXTMETRIC.ntmSizeEM here */
205     (*font)->line_spacing = textmet.tmAscent + textmet.tmDescent + textmet.tmExternalLeading;
206
207     SelectObject(hdc, oldfont);
208     DeleteObject(hfont);
209
210     TRACE("<-- %p\n", *font);
211
212     return Ok;
213 }
214
215 /*******************************************************************************
216  * GdipCreateFontFromLogfontA [GDIPLUS.@]
217  */
218 GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC hdc,
219     GDIPCONST LOGFONTA *lfa, GpFont **font)
220 {
221     LOGFONTW lfw;
222
223     TRACE("(%p, %p, %p)\n", hdc, lfa, font);
224
225     if(!lfa || !font)
226         return InvalidParameter;
227
228     memcpy(&lfw, lfa, FIELD_OFFSET(LOGFONTA,lfFaceName) );
229
230     if(!MultiByteToWideChar(CP_ACP, 0, lfa->lfFaceName, -1, lfw.lfFaceName, LF_FACESIZE))
231         return GenericError;
232
233     return GdipCreateFontFromLogfontW(hdc, &lfw, font);
234 }
235
236 /*******************************************************************************
237  * GdipDeleteFont [GDIPLUS.@]
238  */
239 GpStatus WINGDIPAPI GdipDeleteFont(GpFont* font)
240 {
241     TRACE("(%p)\n", font);
242
243     if(!font)
244         return InvalidParameter;
245
246     GdipFree(font);
247
248     return Ok;
249 }
250
251 /*******************************************************************************
252  * GdipCreateFontFromDC [GDIPLUS.@]
253  */
254 GpStatus WINGDIPAPI GdipCreateFontFromDC(HDC hdc, GpFont **font)
255 {
256     HFONT hfont;
257     LOGFONTW lfw;
258
259     TRACE("(%p, %p)\n", hdc, font);
260
261     if(!font)
262         return InvalidParameter;
263
264     hfont = GetCurrentObject(hdc, OBJ_FONT);
265     if(!hfont)
266         return GenericError;
267
268     if(!GetObjectW(hfont, sizeof(LOGFONTW), &lfw))
269         return GenericError;
270
271     return GdipCreateFontFromLogfontW(hdc, &lfw, font);
272 }
273
274 /*******************************************************************************
275  * GdipGetFamily [GDIPLUS.@]
276  *
277  * Returns the FontFamily for the specified Font
278  *
279  * PARAMS
280  *  font    [I] Font to request from
281  *  family  [O] Resulting FontFamily object
282  *
283  * RETURNS
284  *  SUCCESS: Ok
285  *  FAILURE: An element of GpStatus
286  */
287 GpStatus WINGDIPAPI GdipGetFamily(GpFont *font, GpFontFamily **family)
288 {
289     TRACE("%p %p\n", font, family);
290
291     if (!(font && family))
292         return InvalidParameter;
293
294     return GdipCreateFontFamilyFromName(font->lfw.lfFaceName, NULL, family);
295 }
296
297 /******************************************************************************
298  * GdipGetFontSize [GDIPLUS.@]
299  *
300  * Returns the size of the font in Units
301  *
302  * PARAMS
303  *  *font       [I] The font to retrieve size from
304  *  *size       [O] Pointer to hold retrieved value
305  *
306  * RETURNS
307  *  SUCCESS: Ok
308  *  FAILURE: InvalidParameter (font or size was NULL)
309  *
310  * NOTES
311  *  Size returned is actually emSize -- not internal size used for drawing.
312  */
313 GpStatus WINGDIPAPI GdipGetFontSize(GpFont *font, REAL *size)
314 {
315     TRACE("(%p, %p)\n", font, size);
316
317     if (!(font && size)) return InvalidParameter;
318
319     *size = font->emSize;
320
321     return Ok;
322 }
323
324 /*******************************************************************************
325  * GdipGetFontStyle [GDIPLUS.@]
326  *
327  * Gets the font's style, returned in bitwise OR of FontStyle enumeration
328  *
329  * PARAMS
330  *  font    [I] font to request from
331  *  style   [O] resulting pointer to a FontStyle enumeration
332  *
333  * RETURNS
334  *  SUCCESS: Ok
335  *  FAILURE: InvalidParameter
336  */
337 GpStatus WINGDIPAPI GdipGetFontStyle(GpFont *font, INT *style)
338 {
339     TRACE("%p %p\n", font, style);
340
341     if (!(font && style))
342         return InvalidParameter;
343
344     if (font->lfw.lfWeight > 400)
345         *style = FontStyleBold;
346     else
347         *style = 0;
348     if (font->lfw.lfItalic)
349         *style |= FontStyleItalic;
350     if (font->lfw.lfUnderline)
351         *style |= FontStyleUnderline;
352     if (font->lfw.lfStrikeOut)
353         *style |= FontStyleStrikeout;
354
355     return Ok;
356 }
357
358 /*******************************************************************************
359  * GdipGetFontUnit  [GDIPLUS.@]
360  *
361  * PARAMS
362  *  font    [I] Font to retrieve from
363  *  unit    [O] Return value
364  *
365  * RETURNS
366  *  FAILURE: font or unit was NULL
367  *  OK: otherwise
368  */
369 GpStatus WINGDIPAPI GdipGetFontUnit(GpFont *font, Unit *unit)
370 {
371     TRACE("(%p, %p)\n", font, unit);
372
373     if (!(font && unit)) return InvalidParameter;
374
375     *unit = font->unit;
376
377     return Ok;
378 }
379
380 /*******************************************************************************
381  * GdipGetLogFontA [GDIPLUS.@]
382  */
383 GpStatus WINGDIPAPI GdipGetLogFontA(GpFont *font, GpGraphics *graphics,
384     LOGFONTA *lfa)
385 {
386     GpStatus status;
387     LOGFONTW lfw;
388
389     TRACE("(%p, %p, %p)\n", font, graphics, lfa);
390
391     status = GdipGetLogFontW(font, graphics, &lfw);
392     if(status != Ok)
393         return status;
394
395     memcpy(lfa, &lfw, FIELD_OFFSET(LOGFONTA,lfFaceName) );
396
397     if(!WideCharToMultiByte(CP_ACP, 0, lfw.lfFaceName, -1, lfa->lfFaceName, LF_FACESIZE, NULL, NULL))
398         return GenericError;
399
400     return Ok;
401 }
402
403 /*******************************************************************************
404  * GdipGetLogFontW [GDIPLUS.@]
405  */
406 GpStatus WINGDIPAPI GdipGetLogFontW(GpFont *font, GpGraphics *graphics,
407     LOGFONTW *lfw)
408 {
409     TRACE("(%p, %p, %p)\n", font, graphics, lfw);
410
411     /* FIXME: use graphics */
412     if(!font || !graphics || !lfw)
413         return InvalidParameter;
414
415     *lfw = font->lfw;
416
417     return Ok;
418 }
419
420 /*******************************************************************************
421  * GdipCloneFont [GDIPLUS.@]
422  */
423 GpStatus WINGDIPAPI GdipCloneFont(GpFont *font, GpFont **cloneFont)
424 {
425     TRACE("(%p, %p)\n", font, cloneFont);
426
427     if(!font || !cloneFont)
428         return InvalidParameter;
429
430     *cloneFont = GdipAlloc(sizeof(GpFont));
431     if(!*cloneFont)    return OutOfMemory;
432
433     **cloneFont = *font;
434
435     return Ok;
436 }
437
438 /*******************************************************************************
439  * GdipGetFontHeight [GDIPLUS.@]
440  * PARAMS
441  *  font        [I] Font to retrieve height from
442  *  graphics    [I] The current graphics context
443  *  height      [O] Resulting height
444  * RETURNS
445  *  SUCCESS: Ok
446  *  FAILURE: Another element of GpStatus
447  *
448  * NOTES
449  *  Forwards to GdipGetFontHeightGivenDPI
450  */
451 GpStatus WINGDIPAPI GdipGetFontHeight(GDIPCONST GpFont *font,
452         GDIPCONST GpGraphics *graphics, REAL *height)
453 {
454     REAL dpi;
455
456     TRACE("%p %p %p\n", font, graphics, height);
457
458     dpi = GetDeviceCaps(graphics->hdc, LOGPIXELSY);
459
460     return GdipGetFontHeightGivenDPI(font, dpi, height);
461 }
462
463 /*******************************************************************************
464  * GdipGetFontHeightGivenDPI [GDIPLUS.@]
465  * PARAMS
466  *  font        [I] Font to retrieve DPI from
467  *  dpi         [I] DPI to assume
468  *  height      [O] Return value
469  *
470  * RETURNS
471  *  SUCCESS: Ok
472  *  FAILURE: InvalidParameter if font or height is NULL
473  *
474  * NOTES
475  *  According to MSDN, the result is (lineSpacing)*(fontSize / emHeight)*dpi
476  *  (for anything other than unit Pixel)
477  */
478 GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height)
479 {
480     REAL font_height;
481
482     TRACE("%p (%s), %f, %p\n", font,
483             debugstr_w(font->lfw.lfFaceName), dpi, height);
484
485     if (!(font && height)) return InvalidParameter;
486
487     font_height = font->line_spacing * (font->emSize / font->height);
488
489     switch (font->unit)
490     {
491         case UnitPixel:
492         case UnitWorld:
493             *height = font_height;
494             break;
495         case UnitPoint:
496             *height = font_height * dpi * inch_per_point;
497             break;
498         case UnitInch:
499             *height = font_height * dpi;
500             break;
501         case UnitDocument:
502             *height = font_height * (dpi / 300.0);
503             break;
504         case UnitMillimeter:
505             *height = font_height * (dpi / mm_per_inch);
506             break;
507         default:
508             FIXME("Unhandled unit type: %d\n", font->unit);
509             return NotImplemented;
510     }
511
512     return Ok;
513 }
514
515 /***********************************************************************
516  * Borrowed from GDI32:
517  *
518  * Elf is really an ENUMLOGFONTEXW, and ntm is a NEWTEXTMETRICEXW.
519  *     We have to use other types because of the FONTENUMPROCW definition.
520  */
521 static INT CALLBACK is_font_installed_proc(const LOGFONTW *elf,
522                             const TEXTMETRICW *ntm, DWORD type, LPARAM lParam)
523 {
524     if (!ntm || type == RASTER_FONTTYPE)
525     {
526         return 1;
527     }
528
529     *(NEWTEXTMETRICW*)lParam = *(const NEWTEXTMETRICW*)ntm;
530
531     return 0;
532 }
533
534 static BOOL find_installed_font(const WCHAR *name, NEWTEXTMETRICW *ntm)
535 {
536     HDC hdc = GetDC(0);
537     BOOL ret = FALSE;
538
539     if(!EnumFontFamiliesW(hdc, name, is_font_installed_proc, (LPARAM)ntm))
540         ret = TRUE;
541
542     ReleaseDC(0, hdc);
543     return ret;
544 }
545
546 /*******************************************************************************
547  * GdipCreateFontFamilyFromName [GDIPLUS.@]
548  *
549  * Creates a font family object based on a supplied name
550  *
551  * PARAMS
552  *  name               [I] Name of the font
553  *  fontCollection     [I] What font collection (if any) the font belongs to (may be NULL)
554  *  FontFamily         [O] Pointer to the resulting FontFamily object
555  *
556  * RETURNS
557  *  SUCCESS: Ok
558  *  FAILURE: FamilyNotFound if the requested FontFamily does not exist on the system
559  *  FAILURE: Invalid parameter if FontFamily or name is NULL
560  *
561  * NOTES
562  *   If fontCollection is NULL then the object is not part of any collection
563  *
564  */
565
566 GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name,
567                                         GpFontCollection *fontCollection,
568                                         GpFontFamily **FontFamily)
569 {
570     GpFontFamily* ffamily;
571     NEWTEXTMETRICW ntm;
572
573     TRACE("%s, %p %p\n", debugstr_w(name), fontCollection, FontFamily);
574
575     if (!(name && FontFamily))
576         return InvalidParameter;
577     if (fontCollection)
578         FIXME("No support for FontCollections yet!\n");
579
580     if (!find_installed_font(name, &ntm))
581         return FontFamilyNotFound;
582
583     ffamily = GdipAlloc(sizeof (GpFontFamily));
584     if (!ffamily) return OutOfMemory;
585
586     ffamily->tmw = ntm;
587     lstrcpynW(ffamily->FamilyName, name, LF_FACESIZE);
588
589     *FontFamily = ffamily;
590
591     TRACE("<-- %p\n", ffamily);
592
593     return Ok;
594 }
595
596 /*******************************************************************************
597  * GdipCloneFontFamily [GDIPLUS.@]
598  *
599  * Creates a deep copy of a Font Family object
600  *
601  * PARAMS
602  *  FontFamily          [I] Font to clone
603  *  clonedFontFamily    [O] The resulting cloned font
604  *
605  * RETURNS
606  *  SUCCESS: Ok
607  */
608 GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily* FontFamily, GpFontFamily** clonedFontFamily)
609 {
610     if (!(FontFamily && clonedFontFamily)) return InvalidParameter;
611
612     TRACE("stub: %p (%s), %p\n", FontFamily,
613             debugstr_w(FontFamily->FamilyName), clonedFontFamily);
614
615     *clonedFontFamily = GdipAlloc(sizeof(GpFontFamily));
616     if (!*clonedFontFamily) return OutOfMemory;
617
618     (*clonedFontFamily)->tmw = FontFamily->tmw;
619     lstrcpyW((*clonedFontFamily)->FamilyName, FontFamily->FamilyName);
620
621     TRACE("<-- %p\n", *clonedFontFamily);
622
623     return Ok;
624 }
625
626 /*******************************************************************************
627  * GdipGetFamilyName [GDIPLUS.@]
628  *
629  * Returns the family name into name
630  *
631  * PARAMS
632  *  *family     [I] Family to retrieve from
633  *  *name       [O] WCHARS of the family name
634  *  LANGID      [I] charset
635  *
636  * RETURNS
637  *  SUCCESS: Ok
638  *  FAILURE: InvalidParameter if family is NULL
639  *
640  * NOTES
641  *   If name is a NULL ptr, then both XP and Vista will crash (so we do as well)
642  */
643 GpStatus WINGDIPAPI GdipGetFamilyName (GDIPCONST GpFontFamily *family,
644                                        WCHAR *name, LANGID language)
645 {
646     static int lang_fixme;
647
648     if (family == NULL)
649          return InvalidParameter;
650
651     TRACE("%p, %p, %d\n", family, name, language);
652
653     if (language != LANG_NEUTRAL && !lang_fixme++)
654         FIXME("No support for handling of multiple languages!\n");
655
656     lstrcpynW (name, family->FamilyName, LF_FACESIZE);
657
658     return Ok;
659 }
660
661
662 /*****************************************************************************
663  * GdipDeleteFontFamily [GDIPLUS.@]
664  *
665  * Removes the specified FontFamily
666  *
667  * PARAMS
668  *  *FontFamily         [I] The family to delete
669  *
670  * RETURNS
671  *  SUCCESS: Ok
672  *  FAILURE: InvalidParameter if FontFamily is NULL.
673  *
674  */
675 GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily *FontFamily)
676 {
677     if (!FontFamily)
678         return InvalidParameter;
679     TRACE("Deleting %p (%s)\n", FontFamily, debugstr_w(FontFamily->FamilyName));
680
681     GdipFree (FontFamily);
682
683     return Ok;
684 }
685
686 GpStatus WINGDIPAPI GdipGetCellAscent(GDIPCONST GpFontFamily *family,
687         INT style, UINT16* CellAscent)
688 {
689     if (!(family && CellAscent)) return InvalidParameter;
690
691     *CellAscent = family->tmw.tmAscent;
692
693     return Ok;
694 }
695
696 GpStatus WINGDIPAPI GdipGetCellDescent(GDIPCONST GpFontFamily *family,
697         INT style, UINT16* CellDescent)
698 {
699     TRACE("(%p, %d, %p)\n", family, style, CellDescent);
700
701     if (!(family && CellDescent)) return InvalidParameter;
702
703     *CellDescent = family->tmw.tmDescent;
704
705     return Ok;
706 }
707
708 /*******************************************************************************
709  * GdipGetEmHeight [GDIPLUS.@]
710  *
711  * Gets the height of the specified family in EmHeights
712  *
713  * PARAMS
714  *  family      [I] Family to retrieve from
715  *  style       [I] (optional) style
716  *  EmHeight    [O] return value
717  *
718  * RETURNS
719  *  SUCCESS: Ok
720  *  FAILURE: InvalidParameter
721  */
722 GpStatus WINGDIPAPI GdipGetEmHeight(GDIPCONST GpFontFamily *family, INT style, UINT16* EmHeight)
723 {
724     if (!(family && EmHeight)) return InvalidParameter;
725
726     TRACE("%p (%s), %d, %p\n", family, debugstr_w(family->FamilyName), style, EmHeight);
727
728     *EmHeight = family->tmw.ntmSizeEM;
729
730     return Ok;
731 }
732
733
734 /*******************************************************************************
735  * GdipGetLineSpacing [GDIPLUS.@]
736  *
737  * Returns the line spacing in design units
738  *
739  * PARAMS
740  *  family      [I] Family to retrieve from
741  *  style       [I] (Optional) font style
742  *  LineSpacing [O] Return value
743  *
744  * RETURNS
745  *  SUCCESS: Ok
746  *  FAILURE: InvalidParameter (family or LineSpacing was NULL)
747  */
748 GpStatus WINGDIPAPI GdipGetLineSpacing(GDIPCONST GpFontFamily *family,
749         INT style, UINT16* LineSpacing)
750 {
751     TRACE("%p, %d, %p\n", family, style, LineSpacing);
752
753     if (!(family && LineSpacing))
754         return InvalidParameter;
755
756     if (style) FIXME("ignoring style\n");
757
758     *LineSpacing = family->tmw.tmAscent + family->tmw.tmDescent + family->tmw.tmExternalLeading;
759
760     return Ok;
761 }
762
763 GpStatus WINGDIPAPI GdipIsStyleAvailable(GDIPCONST GpFontFamily* family,
764         INT style, BOOL* IsStyleAvailable)
765 {
766     FIXME("%p %d %p stub!\n", family, style, IsStyleAvailable);
767
768     if (!(family && IsStyleAvailable))
769         return InvalidParameter;
770
771     return NotImplemented;
772 }
773
774 /*****************************************************************************
775  * GdipGetGenericFontFamilyMonospace [GDIPLUS.@]
776  *
777  * Obtains a serif family (Courier New on Windows)
778  *
779  * PARAMS
780  *  **nativeFamily         [I] Where the font will be stored
781  *
782  * RETURNS
783  *  InvalidParameter if nativeFamily is NULL.
784  *  Ok otherwise.
785  */
786 GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily)
787 {
788     static const WCHAR CourierNew[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
789
790     if (nativeFamily == NULL) return InvalidParameter;
791
792     return GdipCreateFontFamilyFromName(CourierNew, NULL, nativeFamily);
793 }
794
795 /*****************************************************************************
796  * GdipGetGenericFontFamilySerif [GDIPLUS.@]
797  *
798  * Obtains a serif family (Times New Roman on Windows)
799  *
800  * PARAMS
801  *  **nativeFamily         [I] Where the font will be stored
802  *
803  * RETURNS
804  *  InvalidParameter if nativeFamily is NULL.
805  *  Ok otherwise.
806  */
807 GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily)
808 {
809     static const WCHAR TimesNewRoman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
810
811     TRACE("(%p)\n", nativeFamily);
812
813     if (nativeFamily == NULL) return InvalidParameter;
814
815     return GdipCreateFontFamilyFromName(TimesNewRoman, NULL, nativeFamily);
816 }
817
818 /*****************************************************************************
819  * GdipGetGenericFontFamilySansSerif [GDIPLUS.@]
820  *
821  * Obtains a serif family (Microsoft Sans Serif on Windows)
822  *
823  * PARAMS
824  *  **nativeFamily         [I] Where the font will be stored
825  *
826  * RETURNS
827  *  InvalidParameter if nativeFamily is NULL.
828  *  Ok otherwise.
829  */
830 GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily)
831 {
832     GpStatus stat;
833     static const WCHAR MicrosoftSansSerif[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
834     static const WCHAR Tahoma[] = {'T','a','h','o','m','a','\0'};
835
836     TRACE("(%p)\n", nativeFamily);
837
838     if (nativeFamily == NULL) return InvalidParameter;
839
840     stat = GdipCreateFontFamilyFromName(MicrosoftSansSerif, NULL, nativeFamily);
841
842     if (stat == FontFamilyNotFound)
843         /* FIXME: Microsoft Sans Serif is not installed on Wine. */
844         stat = GdipCreateFontFamilyFromName(Tahoma, NULL, nativeFamily);
845
846     return stat;
847 }
848
849 /*****************************************************************************
850  * GdipGetGenericFontFamilySansSerif [GDIPLUS.@]
851  */
852 GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection** fontCollection)
853 {
854     TRACE("%p\n", fontCollection);
855
856     if (!fontCollection)
857         return InvalidParameter;
858
859     *fontCollection = GdipAlloc(sizeof(GpFontCollection));
860     if (!*fontCollection) return OutOfMemory;
861
862     (*fontCollection)->FontFamilies = NULL;
863     (*fontCollection)->count = 0;
864     (*fontCollection)->allocated = 0;
865
866     TRACE("<-- %p\n", *fontCollection);
867
868     return Ok;
869 }
870
871 /*****************************************************************************
872  * GdipDeletePrivateFontCollection [GDIPLUS.@]
873  */
874 GpStatus WINGDIPAPI GdipDeletePrivateFontCollection(GpFontCollection **fontCollection)
875 {
876     INT i;
877
878     TRACE("%p\n", fontCollection);
879
880     if (!fontCollection)
881         return InvalidParameter;
882
883     for (i = 0; i < (*fontCollection)->count; i++) GdipFree((*fontCollection)->FontFamilies[i]);
884     GdipFree(*fontCollection);
885
886     return Ok;
887 }
888
889 /*****************************************************************************
890  * GdipPrivateAddFontFile [GDIPLUS.@]
891  */
892 GpStatus WINGDIPAPI GdipPrivateAddFontFile(GpFontCollection* fontCollection,
893         GDIPCONST WCHAR* filename)
894 {
895     FIXME("stub: %p, %s\n", fontCollection, debugstr_w(filename));
896
897     if (!(fontCollection && filename))
898         return InvalidParameter;
899
900     return NotImplemented;
901 }
902
903 /*****************************************************************************
904  * GdipPrivateAddMemoryFont [GDIPLUS.@]
905  */
906 GpStatus WINGDIPAPI GdipPrivateAddMemoryFont(GpFontCollection* fontCollection,
907         GDIPCONST void* memory, INT length)
908 {
909     FIXME("%p, %p, %d\n", fontCollection, memory, length);
910
911     if (!(fontCollection && memory && length))
912         return InvalidParameter;
913
914     return Ok;
915 }
916
917 /*****************************************************************************
918  * GdipGetFontCollectionFamilyCount [GDIPLUS.@]
919  */
920 GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount(
921         GpFontCollection* fontCollection, INT* numFound)
922 {
923     TRACE("%p, %p\n", fontCollection, numFound);
924
925     if (!(fontCollection && numFound))
926         return InvalidParameter;
927
928     *numFound = fontCollection->count;
929     return Ok;
930 }
931
932 /*****************************************************************************
933  * GdipGetFontCollectionFamilyList [GDIPLUS.@]
934  */
935 GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList(
936         GpFontCollection* fontCollection, INT numSought,
937         GpFontFamily* gpfamilies[], INT* numFound)
938 {
939     INT i;
940
941     TRACE("%p, %d, %p, %p\n", fontCollection, numSought, gpfamilies, numFound);
942
943     if (!(fontCollection && gpfamilies && numFound))
944         return InvalidParameter;
945
946     for (i = 0; i < numSought && i < fontCollection->count; i++)
947     {
948         gpfamilies[i] = fontCollection->FontFamilies[i];
949     }
950     *numFound = i;
951     return Ok;
952 }
953
954 void free_installed_fonts(void)
955 {
956     while (installedFontCollection.count)
957         GdipDeleteFontFamily(installedFontCollection.FontFamilies[--installedFontCollection.count]);
958     HeapFree(GetProcessHeap(), 0, installedFontCollection.FontFamilies);
959     installedFontCollection.FontFamilies = NULL;
960     installedFontCollection.allocated = 0;
961 }
962
963 static INT CALLBACK add_font_proc(const LOGFONTW *lfw, const TEXTMETRICW *ntm,
964         DWORD type, LPARAM lParam)
965 {
966     GpFontCollection* fonts = (GpFontCollection*)lParam;
967     int i;
968
969     if (type == RASTER_FONTTYPE)
970         return 1;
971
972     /* skip duplicates */
973     for (i=0; i<fonts->count; i++)
974         if (strcmpiW(lfw->lfFaceName, fonts->FontFamilies[i]->FamilyName) == 0)
975             return 1;
976
977     if (fonts->allocated == fonts->count)
978     {
979         INT new_alloc_count = fonts->allocated+50;
980         GpFontFamily** new_family_list = HeapAlloc(GetProcessHeap(), 0, new_alloc_count*sizeof(void*));
981
982         if (!new_family_list)
983             return 0;
984
985         memcpy(new_family_list, fonts->FontFamilies, fonts->count*sizeof(void*));
986         HeapFree(GetProcessHeap(), 0, fonts->FontFamilies);
987         fonts->FontFamilies = new_family_list;
988         fonts->allocated = new_alloc_count;
989     }
990
991     if (GdipCreateFontFamilyFromName(lfw->lfFaceName, NULL, &fonts->FontFamilies[fonts->count]) == Ok)
992         fonts->count++;
993     else
994         return 0;
995
996     return 1;
997 }
998
999 GpStatus WINGDIPAPI GdipNewInstalledFontCollection(
1000         GpFontCollection** fontCollection)
1001 {
1002     TRACE("(%p)\n",fontCollection);
1003
1004     if (!fontCollection)
1005         return InvalidParameter;
1006
1007     if (installedFontCollection.count == 0)
1008     {
1009         HDC hdc;
1010         LOGFONTW lfw;
1011
1012         hdc = GetDC(0);
1013
1014         lfw.lfCharSet = DEFAULT_CHARSET;
1015         lfw.lfFaceName[0] = 0;
1016         lfw.lfPitchAndFamily = 0;
1017
1018         if (!EnumFontFamiliesExW(hdc, &lfw, add_font_proc, (LPARAM)&installedFontCollection, 0))
1019         {
1020             free_installed_fonts();
1021             ReleaseDC(0, hdc);
1022             return OutOfMemory;
1023         }
1024
1025         ReleaseDC(0, hdc);
1026     }
1027
1028     *fontCollection = &installedFontCollection;
1029
1030     return Ok;
1031 }