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 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 NEWTEXTMETRICW* tmw;
  99     GpStatus stat;
 100
 101     if (!fontFamily || !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, 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     (*font)->height = tmw->ntmSizeEM;
 157     (*font)->line_spacing = tmw->tmAscent + tmw->tmDescent + tmw->tmExternalLeading;
 158
 159     return Ok;
 160 }
 161
 162 /*******************************************************************************
 163  * GdipCreateFontFromLogfontW [GDIPLUS.@]
 164  */
 165 GpStatus WINGDIPAPI GdipCreateFontFromLogfontW(HDC hdc,
 166     GDIPCONST LOGFONTW *logfont, GpFont **font)
 167 {
 168     HFONT hfont, oldfont;
 169     TEXTMETRICW textmet;
 170
 171     TRACE("(%p, %p, %p)\n", hdc, logfont, font);
 172
 173     if(!logfont || !font)
 174         return InvalidParameter;
 175
 176     if (logfont->lfFaceName[0] == 0)
 177         return NotTrueTypeFont;
 178
 179     *font = GdipAlloc(sizeof(GpFont));
 180     if(!*font)  return OutOfMemory;
 181
 182     memcpy((*font)->lfw.lfFaceName, logfont->lfFaceName, LF_FACESIZE *
 183            sizeof(WCHAR));
 184     (*font)->lfw.lfHeight = logfont->lfHeight;
 185     (*font)->lfw.lfItalic = logfont->lfItalic;
 186     (*font)->lfw.lfUnderline = logfont->lfUnderline;
 187     (*font)->lfw.lfStrikeOut = logfont->lfStrikeOut;
 188
 189     (*font)->emSize = logfont->lfHeight;
 190     (*font)->unit = UnitPixel;
 191
 192     hfont = CreateFontIndirectW(&(*font)->lfw);
 193     oldfont = SelectObject(hdc, hfont);
 194     GetTextMetricsW(hdc, &textmet);
 195
 196     (*font)->lfw.lfHeight = -textmet.tmHeight;
 197     (*font)->lfw.lfWeight = textmet.tmWeight;
 198     (*font)->lfw.lfCharSet = textmet.tmCharSet;
 199
 200     (*font)->height = 1; /* FIXME: need NEWTEXTMETRIC.ntmSizeEM here */
 201     (*font)->line_spacing = textmet.tmAscent + textmet.tmDescent + textmet.tmExternalLeading;
 202
 203     SelectObject(hdc, oldfont);
 204     DeleteObject(hfont);
 205
 206     return Ok;
 207 }
 208
 209 /*******************************************************************************
 210  * GdipCreateFontFromLogfontA [GDIPLUS.@]
 211  */
 212 GpStatus WINGDIPAPI GdipCreateFontFromLogfontA(HDC hdc,
 213     GDIPCONST LOGFONTA *lfa, GpFont **font)
 214 {
 215     LOGFONTW lfw;
 216
 217     TRACE("(%p, %p, %p)\n", hdc, lfa, font);
 218
 219     if(!lfa || !font)
 220         return InvalidParameter;
 221
 222     memcpy(&lfw, lfa, FIELD_OFFSET(LOGFONTA,lfFaceName) );
 223
 224     if(!MultiByteToWideChar(CP_ACP, 0, lfa->lfFaceName, -1, lfw.lfFaceName, LF_FACESIZE))
 225         return GenericError;
 226
 227     return GdipCreateFontFromLogfontW(hdc, &lfw, font);
 228 }
 229
 230 /*******************************************************************************
 231  * GdipDeleteFont [GDIPLUS.@]
 232  */
 233 GpStatus WINGDIPAPI GdipDeleteFont(GpFont* font)
 234 {
 235     TRACE("(%p)\n", font);
 236
 237     if(!font)
 238         return InvalidParameter;
 239
 240     GdipFree(font);
 241
 242     return Ok;
 243 }
 244
 245 /*******************************************************************************
 246  * GdipCreateFontFromDC [GDIPLUS.@]
 247  */
 248 GpStatus WINGDIPAPI GdipCreateFontFromDC(HDC hdc, GpFont **font)
 249 {
 250     HFONT hfont;
 251     LOGFONTW lfw;
 252
 253     TRACE("(%p, %p)\n", hdc, font);
 254
 255     if(!font)
 256         return InvalidParameter;
 257
 258     hfont = GetCurrentObject(hdc, OBJ_FONT);
 259     if(!hfont)
 260         return GenericError;
 261
 262     if(!GetObjectW(hfont, sizeof(LOGFONTW), &lfw))
 263         return GenericError;
 264
 265     return GdipCreateFontFromLogfontW(hdc, &lfw, font);
 266 }
 267
 268 /*******************************************************************************
 269  * GdipGetFamily [GDIPLUS.@]
 270  *
 271  * Returns the FontFamily for the specified Font
 272  *
 273  * PARAMS
 274  *  font    [I] Font to request from
 275  *  family  [O] Resulting FontFamily object
 276  *
 277  * RETURNS
 278  *  SUCCESS: Ok
 279  *  FAILURE: An element of GpStatus
 280  */
 281 GpStatus WINGDIPAPI GdipGetFamily(GpFont *font, GpFontFamily **family)
 282 {
 283     TRACE("%p %p\n", font, family);
 284
 285     if (!(font && family))
 286         return InvalidParameter;
 287
 288     return GdipCreateFontFamilyFromName(font->lfw.lfFaceName, NULL, family);
 289 }
 290
 291 /******************************************************************************
 292  * GdipGetFontSize [GDIPLUS.@]
 293  *
 294  * Returns the size of the font in Units
 295  *
 296  * PARAMS
 297  *  *font       [I] The font to retrieve size from
 298  *  *size       [O] Pointer to hold retrieved value
 299  *
 300  * RETURNS
 301  *  SUCCESS: Ok
 302  *  FAILURE: InvalidParameter (font or size was NULL)
 303  *
 304  * NOTES
 305  *  Size returned is actually emSize -- not internal size used for drawing.
 306  */
 307 GpStatus WINGDIPAPI GdipGetFontSize(GpFont *font, REAL *size)
 308 {
 309     TRACE("(%p, %p)\n", font, size);
 310
 311     if (!(font && size)) return InvalidParameter;
 312
 313     *size = font->emSize;
 314
 315     return Ok;
 316 }
 317
 318 /*******************************************************************************
 319  * GdipGetFontStyle [GDIPLUS.@]
 320  *
 321  * Gets the font's style, returned in bitwise OR of FontStyle enumeration
 322  *
 323  * PARAMS
 324  *  font    [I] font to request from
 325  *  style   [O] resulting pointer to a FontStyle enumeration
 326  *
 327  * RETURNS
 328  *  SUCCESS: Ok
 329  *  FAILURE: InvalidParameter
 330  */
 331 GpStatus WINGDIPAPI GdipGetFontStyle(GpFont *font, INT *style)
 332 {
 333     TRACE("%p %p\n", font, style);
 334
 335     if (!(font && style))
 336         return InvalidParameter;
 337
 338     if (font->lfw.lfWeight > 400)
 339         *style = FontStyleBold;
 340     else
 341         *style = 0;
 342     if (font->lfw.lfItalic)
 343         *style |= FontStyleItalic;
 344     if (font->lfw.lfUnderline)
 345         *style |= FontStyleUnderline;
 346     if (font->lfw.lfStrikeOut)
 347         *style |= FontStyleStrikeout;
 348
 349     return Ok;
 350 }
 351
 352 /*******************************************************************************
 353  * GdipGetFontUnit  [GDIPLUS.@]
 354  *
 355  * PARAMS
 356  *  font    [I] Font to retrieve from
 357  *  unit    [O] Return value
 358  *
 359  * RETURNS
 360  *  FAILURE: font or unit was NULL
 361  *  OK: otherwise
 362  */
 363 GpStatus WINGDIPAPI GdipGetFontUnit(GpFont *font, Unit *unit)
 364 {
 365     TRACE("(%p, %p)\n", font, unit);
 366
 367     if (!(font && unit)) return InvalidParameter;
 368
 369     *unit = font->unit;
 370
 371     return Ok;
 372 }
 373
 374 /*******************************************************************************
 375  * GdipGetLogFontA [GDIPLUS.@]
 376  */
 377 GpStatus WINGDIPAPI GdipGetLogFontA(GpFont *font, GpGraphics *graphics,
 378     LOGFONTA *lfa)
 379 {
 380     GpStatus status;
 381     LOGFONTW lfw;
 382
 383     TRACE("(%p, %p, %p)\n", font, graphics, lfa);
 384
 385     status = GdipGetLogFontW(font, graphics, &lfw);
 386     if(status != Ok)
 387         return status;
 388
 389     memcpy(lfa, &lfw, FIELD_OFFSET(LOGFONTA,lfFaceName) );
 390
 391     if(!WideCharToMultiByte(CP_ACP, 0, lfw.lfFaceName, -1, lfa->lfFaceName, LF_FACESIZE, NULL, NULL))
 392         return GenericError;
 393
 394     return Ok;
 395 }
 396
 397 /*******************************************************************************
 398  * GdipGetLogFontW [GDIPLUS.@]
 399  */
 400 GpStatus WINGDIPAPI GdipGetLogFontW(GpFont *font, GpGraphics *graphics,
 401     LOGFONTW *lfw)
 402 {
 403     TRACE("(%p, %p, %p)\n", font, graphics, lfw);
 404
 405     /* FIXME: use graphics */
 406     if(!font || !graphics || !lfw)
 407         return InvalidParameter;
 408
 409     *lfw = font->lfw;
 410
 411     return Ok;
 412 }
 413
 414 /*******************************************************************************
 415  * GdipCloneFont [GDIPLUS.@]
 416  */
 417 GpStatus WINGDIPAPI GdipCloneFont(GpFont *font, GpFont **cloneFont)
 418 {
 419     TRACE("(%p, %p)\n", font, cloneFont);
 420
 421     if(!font || !cloneFont)
 422         return InvalidParameter;
 423
 424     *cloneFont = GdipAlloc(sizeof(GpFont));
 425     if(!*cloneFont)    return OutOfMemory;
 426
 427     **cloneFont = *font;
 428
 429     return Ok;
 430 }
 431
 432 /*******************************************************************************
 433  * GdipGetFontHeight [GDIPLUS.@]
 434  * PARAMS
 435  *  font        [I] Font to retrieve height from
 436  *  graphics    [I] The current graphics context
 437  *  height      [O] Resulting height
 438  * RETURNS
 439  *  SUCCESS: Ok
 440  *  FAILURE: Another element of GpStatus
 441  *
 442  * NOTES
 443  *  Forwards to GdipGetFontHeightGivenDPI
 444  */
 445 GpStatus WINGDIPAPI GdipGetFontHeight(GDIPCONST GpFont *font,
 446         GDIPCONST GpGraphics *graphics, REAL *height)
 447 {
 448     REAL dpi;
 449
 450     TRACE("%p %p %p\n", font, graphics, height);
 451
 452     dpi = GetDeviceCaps(graphics->hdc, LOGPIXELSY);
 453
 454     return GdipGetFontHeightGivenDPI(font, dpi, height);
 455 }
 456
 457 /*******************************************************************************
 458  * GdipGetFontHeightGivenDPI [GDIPLUS.@]
 459  * PARAMS
 460  *  font        [I] Font to retrieve DPI from
 461  *  dpi         [I] DPI to assume
 462  *  height      [O] Return value
 463  *
 464  * RETURNS
 465  *  SUCCESS: Ok
 466  *  FAILURE: InvalidParameter if font or height is NULL
 467  *
 468  * NOTES
 469  *  According to MSDN, the result is (lineSpacing)*(fontSize / emHeight)*dpi
 470  *  (for anything other than unit Pixel)
 471  */
 472 GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height)
 473 {
 474     REAL font_height;
 475
 476     TRACE("%p (%s), %f, %p\n", font,
 477             debugstr_w(font->lfw.lfFaceName), dpi, height);
 478
 479     if (!(font && height)) return InvalidParameter;
 480
 481     font_height = font->line_spacing * (font->emSize / font->height);
 482
 483     switch (font->unit)
 484     {
 485         case UnitPixel:
 486             *height = font_height;
 487             break;
 488         case UnitPoint:
 489             *height = font_height * dpi * inch_per_point;
 490             break;
 491         case UnitInch:
 492             *height = font_height * dpi;
 493             break;
 494         case UnitDocument:
 495             *height = font_height * (dpi / 300.0);
 496             break;
 497         case UnitMillimeter:
 498             *height = font_height * (dpi / mm_per_inch);
 499             break;
 500         default:
 501             FIXME("Unhandled unit type: %d\n", font->unit);
 502             return NotImplemented;
 503     }
 504
 505     return Ok;
 506 }
 507
 508 /***********************************************************************
 509  * Borrowed from GDI32:
 510  *
 511  * Elf is really an ENUMLOGFONTEXW, and ntm is a NEWTEXTMETRICEXW.
 512  *     We have to use other types because of the FONTENUMPROCW definition.
 513  */
 514 static INT CALLBACK is_font_installed_proc(const LOGFONTW *elf,
 515                             const TEXTMETRICW *ntm, DWORD type, LPARAM lParam)
 516 {
 517     if (!ntm)
 518     {
 519         return 1;
 520     }
 521
 522     *(NEWTEXTMETRICW*)lParam = *(const NEWTEXTMETRICW*)ntm;
 523
 524     return 0;
 525 }
 526
 527 static BOOL find_installed_font(const WCHAR *name, NEWTEXTMETRICW *ntm)
 528 {
 529     HDC hdc = GetDC(0);
 530     BOOL ret = FALSE;
 531
 532     if(!EnumFontFamiliesW(hdc, name, is_font_installed_proc, (LPARAM)ntm))
 533         ret = TRUE;
 534
 535     ReleaseDC(0, hdc);
 536     return ret;
 537 }
 538
 539 /*******************************************************************************
 540  * GdipCreateFontFamilyFromName [GDIPLUS.@]
 541  *
 542  * Creates a font family object based on a supplied name
 543  *
 544  * PARAMS
 545  *  name               [I] Name of the font
 546  *  fontCollection     [I] What font collection (if any) the font belongs to (may be NULL)
 547  *  FontFamily         [O] Pointer to the resulting FontFamily object
 548  *
 549  * RETURNS
 550  *  SUCCESS: Ok
 551  *  FAILURE: FamilyNotFound if the requested FontFamily does not exist on the system
 552  *  FAILURE: Invalid parameter if FontFamily or name is NULL
 553  *
 554  * NOTES
 555  *   If fontCollection is NULL then the object is not part of any collection
 556  *
 557  */
 558
 559 GpStatus WINGDIPAPI GdipCreateFontFamilyFromName(GDIPCONST WCHAR *name,
 560                                         GpFontCollection *fontCollection,
 561                                         GpFontFamily **FontFamily)
 562 {
 563     GpFontFamily* ffamily;
 564     NEWTEXTMETRICW ntm;
 565
 566     TRACE("%s, %p %p\n", debugstr_w(name), fontCollection, FontFamily);
 567
 568     if (!(name && FontFamily))
 569         return InvalidParameter;
 570     if (fontCollection)
 571         FIXME("No support for FontCollections yet!\n");
 572
 573     if (!find_installed_font(name, &ntm))
 574         return FontFamilyNotFound;
 575
 576     ffamily = GdipAlloc(sizeof (GpFontFamily));
 577     if (!ffamily) return OutOfMemory;
 578
 579     ffamily->tmw = ntm;
 580     lstrcpynW(ffamily->FamilyName, name, LF_FACESIZE);
 581
 582     *FontFamily = ffamily;
 583
 584     return Ok;
 585 }
 586
 587 /*******************************************************************************
 588  * GdipCloneFontFamily [GDIPLUS.@]
 589  *
 590  * Creates a deep copy of a Font Family object
 591  *
 592  * PARAMS
 593  *  FontFamily          [I] Font to clone
 594  *  clonedFontFamily    [O] The resulting cloned font
 595  *
 596  * RETURNS
 597  *  SUCCESS: Ok
 598  */
 599 GpStatus WINGDIPAPI GdipCloneFontFamily(GpFontFamily* FontFamily, GpFontFamily** clonedFontFamily)
 600 {
 601     if (!(FontFamily && clonedFontFamily)) return InvalidParameter;
 602
 603     TRACE("stub: %p (%s), %p\n", FontFamily,
 604             debugstr_w(FontFamily->FamilyName), clonedFontFamily);
 605
 606     *clonedFontFamily = GdipAlloc(sizeof(GpFontFamily));
 607     if (!*clonedFontFamily) return OutOfMemory;
 608
 609     (*clonedFontFamily)->tmw = FontFamily->tmw;
 610     lstrcpyW((*clonedFontFamily)->FamilyName, FontFamily->FamilyName);
 611
 612     return Ok;
 613 }
 614
 615 /*******************************************************************************
 616  * GdipGetFamilyName [GDIPLUS.@]
 617  *
 618  * Returns the family name into name
 619  *
 620  * PARAMS
 621  *  *family     [I] Family to retrieve from
 622  *  *name       [O] WCHARS of the family name
 623  *  LANGID      [I] charset
 624  *
 625  * RETURNS
 626  *  SUCCESS: Ok
 627  *  FAILURE: InvalidParameter if family is NULL
 628  *
 629  * NOTES
 630  *   If name is a NULL ptr, then both XP and Vista will crash (so we do as well)
 631  */
 632 GpStatus WINGDIPAPI GdipGetFamilyName (GDIPCONST GpFontFamily *family,
 633                                        WCHAR *name, LANGID language)
 634 {
 635     if (family == NULL)
 636          return InvalidParameter;
 637
 638     TRACE("%p, %p, %d\n", family, name, language);
 639
 640     if (language != LANG_NEUTRAL)
 641         FIXME("No support for handling of multiple languages!\n");
 642
 643     lstrcpynW (name, family->FamilyName, LF_FACESIZE);
 644
 645     return Ok;
 646 }
 647
 648
 649 /*****************************************************************************
 650  * GdipDeleteFontFamily [GDIPLUS.@]
 651  *
 652  * Removes the specified FontFamily
 653  *
 654  * PARAMS
 655  *  *FontFamily         [I] The family to delete
 656  *
 657  * RETURNS
 658  *  SUCCESS: Ok
 659  *  FAILURE: InvalidParameter if FontFamily is NULL.
 660  *
 661  */
 662 GpStatus WINGDIPAPI GdipDeleteFontFamily(GpFontFamily *FontFamily)
 663 {
 664     if (!FontFamily)
 665         return InvalidParameter;
 666     TRACE("Deleting %p (%s)\n", FontFamily, debugstr_w(FontFamily->FamilyName));
 667
 668     GdipFree (FontFamily);
 669
 670     return Ok;
 671 }
 672
 673 GpStatus WINGDIPAPI GdipGetCellAscent(GDIPCONST GpFontFamily *family,
 674         INT style, UINT16* CellAscent)
 675 {
 676     if (!(family && CellAscent)) return InvalidParameter;
 677
 678     *CellAscent = family->tmw.tmAscent;
 679
 680     return Ok;
 681 }
 682
 683 GpStatus WINGDIPAPI GdipGetCellDescent(GDIPCONST GpFontFamily *family,
 684         INT style, UINT16* CellDescent)
 685 {
 686     TRACE("(%p, %d, %p)\n", family, style, CellDescent);
 687
 688     if (!(family && CellDescent)) return InvalidParameter;
 689
 690     *CellDescent = family->tmw.tmDescent;
 691
 692     return Ok;
 693 }
 694
 695 /*******************************************************************************
 696  * GdipGetEmHeight [GDIPLUS.@]
 697  *
 698  * Gets the height of the specified family in EmHeights
 699  *
 700  * PARAMS
 701  *  family      [I] Family to retrieve from
 702  *  style       [I] (optional) style
 703  *  EmHeight    [O] return value
 704  *
 705  * RETURNS
 706  *  SUCCESS: Ok
 707  *  FAILURE: InvalidParameter
 708  */
 709 GpStatus WINGDIPAPI GdipGetEmHeight(GDIPCONST GpFontFamily *family, INT style, UINT16* EmHeight)
 710 {
 711     if (!(family && EmHeight)) return InvalidParameter;
 712
 713     TRACE("%p (%s), %d, %p\n", family, debugstr_w(family->FamilyName), style, EmHeight);
 714
 715     *EmHeight = family->tmw.ntmSizeEM;
 716
 717     return Ok;
 718 }
 719
 720
 721 /*******************************************************************************
 722  * GdipGetLineSpacing [GDIPLUS.@]
 723  *
 724  * Returns the line spacing in design units
 725  *
 726  * PARAMS
 727  *  family      [I] Family to retrieve from
 728  *  style       [I] (Optional) font style
 729  *  LineSpacing [O] Return value
 730  *
 731  * RETURNS
 732  *  SUCCESS: Ok
 733  *  FAILURE: InvalidParameter (family or LineSpacing was NULL)
 734  */
 735 GpStatus WINGDIPAPI GdipGetLineSpacing(GDIPCONST GpFontFamily *family,
 736         INT style, UINT16* LineSpacing)
 737 {
 738     TRACE("%p, %d, %p\n", family, style, LineSpacing);
 739
 740     if (!(family && LineSpacing))
 741         return InvalidParameter;
 742
 743     if (style) FIXME("ignoring style\n");
 744
 745     *LineSpacing = family->tmw.tmAscent + family->tmw.tmDescent + family->tmw.tmExternalLeading;
 746
 747     return Ok;
 748 }
 749
 750 GpStatus WINGDIPAPI GdipIsStyleAvailable(GDIPCONST GpFontFamily* family,
 751         INT style, BOOL* IsStyleAvailable)
 752 {
 753     FIXME("%p %d %p stub!\n", family, style, IsStyleAvailable);
 754
 755     if (!(family && IsStyleAvailable))
 756         return InvalidParameter;
 757
 758     return NotImplemented;
 759 }
 760
 761 /*****************************************************************************
 762  * GdipGetGenericFontFamilyMonospace [GDIPLUS.@]
 763  *
 764  * Obtains a serif family (Courier New on Windows)
 765  *
 766  * PARAMS
 767  *  **nativeFamily         [I] Where the font will be stored
 768  *
 769  * RETURNS
 770  *  InvalidParameter if nativeFamily is NULL.
 771  *  Ok otherwise.
 772  */
 773 GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace(GpFontFamily **nativeFamily)
 774 {
 775     static const WCHAR CourierNew[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
 776
 777     if (nativeFamily == NULL) return InvalidParameter;
 778
 779     return GdipCreateFontFamilyFromName(CourierNew, NULL, nativeFamily);
 780 }
 781
 782 /*****************************************************************************
 783  * GdipGetGenericFontFamilySerif [GDIPLUS.@]
 784  *
 785  * Obtains a serif family (Times New Roman on Windows)
 786  *
 787  * PARAMS
 788  *  **nativeFamily         [I] Where the font will be stored
 789  *
 790  * RETURNS
 791  *  InvalidParameter if nativeFamily is NULL.
 792  *  Ok otherwise.
 793  */
 794 GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif(GpFontFamily **nativeFamily)
 795 {
 796     static const WCHAR TimesNewRoman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
 797
 798     TRACE("(%p)\n", nativeFamily);
 799
 800     if (nativeFamily == NULL) return InvalidParameter;
 801
 802     return GdipCreateFontFamilyFromName(TimesNewRoman, NULL, nativeFamily);
 803 }
 804
 805 /*****************************************************************************
 806  * GdipGetGenericFontFamilySansSerif [GDIPLUS.@]
 807  *
 808  * Obtains a serif family (Microsoft Sans Serif on Windows)
 809  *
 810  * PARAMS
 811  *  **nativeFamily         [I] Where the font will be stored
 812  *
 813  * RETURNS
 814  *  InvalidParameter if nativeFamily is NULL.
 815  *  Ok otherwise.
 816  */
 817 GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif(GpFontFamily **nativeFamily)
 818 {
 819     /* FIXME: On Windows this is called Microsoft Sans Serif, this shouldn't
 820      * affect anything */
 821     static const WCHAR MSSansSerif[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
 822
 823     TRACE("(%p)\n", nativeFamily);
 824
 825     if (nativeFamily == NULL) return InvalidParameter;
 826
 827     return GdipCreateFontFamilyFromName(MSSansSerif, NULL, nativeFamily);
 828 }
 829
 830 /*****************************************************************************
 831  * GdipGetGenericFontFamilySansSerif [GDIPLUS.@]
 832  */
 833 GpStatus WINGDIPAPI GdipNewPrivateFontCollection(GpFontCollection** fontCollection)
 834 {
 835     TRACE("%p\n", fontCollection);
 836
 837     if (!fontCollection)
 838         return InvalidParameter;
 839
 840     *fontCollection = GdipAlloc(sizeof(GpFontCollection));
 841     if (!*fontCollection) return OutOfMemory;
 842
 843     (*fontCollection)->FontFamilies = NULL;
 844     (*fontCollection)->count = 0;
 845     return Ok;
 846 }
 847
 848 /*****************************************************************************
 849  * GdipDeletePrivateFontCollection [GDIPLUS.@]
 850  */
 851 GpStatus WINGDIPAPI GdipDeletePrivateFontCollection(GpFontCollection **fontCollection)
 852 {
 853     INT i;
 854
 855     TRACE("%p\n", fontCollection);
 856
 857     if (!fontCollection)
 858         return InvalidParameter;
 859
 860     for (i = 0; i < (*fontCollection)->count; i++) GdipFree((*fontCollection)->FontFamilies[i]);
 861     GdipFree(*fontCollection);
 862
 863     return Ok;
 864 }
 865
 866 /*****************************************************************************
 867  * GdipPrivateAddFontFile [GDIPLUS.@]
 868  */
 869 GpStatus WINGDIPAPI GdipPrivateAddFontFile(GpFontCollection* fontCollection,
 870         GDIPCONST WCHAR* filename)
 871 {
 872     FIXME("stub: %p, %s\n", fontCollection, debugstr_w(filename));
 873
 874     if (!(fontCollection && filename))
 875         return InvalidParameter;
 876
 877     return NotImplemented;
 878 }
 879
 880 /*****************************************************************************
 881  * GdipPrivateAddMemoryFont [GDIPLUS.@]
 882  */
 883 GpStatus WINGDIPAPI GdipPrivateAddMemoryFont(GpFontCollection* fontCollection,
 884         GDIPCONST void* memory, INT length)
 885 {
 886     FIXME("%p, %p, %d\n", fontCollection, memory, length);
 887
 888     if (!(fontCollection && memory && length))
 889         return InvalidParameter;
 890
 891     return Ok;
 892 }
 893
 894 /*****************************************************************************
 895  * GdipGetFontCollectionFamilyCount [GDIPLUS.@]
 896  */
 897 GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount(
 898         GpFontCollection* fontCollection, INT* numFound)
 899 {
 900     TRACE("%p, %p\n", fontCollection, numFound);
 901
 902     if (!(fontCollection && numFound))
 903         return InvalidParameter;
 904
 905     *numFound = fontCollection->count;
 906     return Ok;
 907 }
 908
 909 /*****************************************************************************
 910  * GdipGetFontCollectionFamilyList [GDIPLUS.@]
 911  */
 912 GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList(
 913         GpFontCollection* fontCollection, INT numSought,
 914         GpFontFamily* gpfamilies[], INT* numFound)
 915 {
 916     INT i;
 917
 918     TRACE("%p, %d, %p, %p\n", fontCollection, numSought, gpfamilies, numFound);
 919
 920     if (!(fontCollection && gpfamilies && numFound))
 921         return InvalidParameter;
 922
 923     for (i = 0; i < numSought && i < fontCollection->count; i++)
 924     {
 925         gpfamilies[i] = fontCollection->FontFamilies[i];
 926     }
 927     *numFound = i;
 928     return Ok;
 929 }
 930
 931 GpStatus WINGDIPAPI GdipNewInstalledFontCollection(
 932         GpFontCollection** fontCollection)
 933 {
 934     FIXME("stub: %p\n",fontCollection);
 935
 936     if (!fontCollection)
 937         return InvalidParameter;
 938
 939     return NotImplemented;
 940 }