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