src/cocoa/font.mm

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/cocoa/font.mm
   3 // Purpose:     wxFont class
   4 // Author:      AUTHOR
   5 // Modified by:
   6 // Created:     ??/??/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) AUTHOR
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 /*! @file   font.mm
  13     @disucssion
  14     Cocoa has three classes which interact to form the font system:
  15
  16     NSFont: Represents a specific font (e.g. Times-Bold) at a specific size
  17     with specific attributes.  That is, it's basically like this class.
  18     Notably, it doesn't hold an underlined flag, so this class does.
  19     Available on all OS X versions.
  20
  21     NSFontManager: Fairly broad controller class which ties together the
  22     model (NSFont) with the view (NSFontPanel).  We are ignoring NSFontPanel
  23     in this discussion.  NSFontManager is actually a little broader than just
  24     a controller though.  It's also the traditional way of mutating fonts
  25     and asking for a font with a certain family and certain attributes.
  26     For example, you can use NSFont's factor methods to create a font named
  27     @"Times-Roman" then use NSFontManager to imbue attributes like italic and
  28     bold.  You might do this if, for instance, you already have times at the
  29     Roman weight but want to make it bold.
  30
  31     Alternatively, you can use NSFontManager to ask for a font in the @"Times"
  32     family with the bold attribute.
  33
  34     NSFontManager is available on all OS X versions.
  35
  36     NSFontDescriptor: Added in OS X 10.3.  Prior to this there was no specific
  37     class to represent all of the attributes of a font.  Instead, a regular
  38     NSDictionary was used with a set of well-defined keys.  Unfortunately,
  39     there was no method accepting the attributes dictionary, only a method
  40     to retrieve it from an NSFont.  That meant that in order to create
  41     a new font by imbueing certain attributes like Bold one would need
  42     to use the specific method in NSFontManager to do so.
  43
  44     The NSFontDescriptor class, on the other hand, has factory methods which
  45     can create a new font descriptor with an attributes dictionary as well
  46     as mutate (by copy) an existing font descriptor using attributes from
  47     an attributes dictionary.
  48
  49     In theory, most of what can be done using NSFontDescriptor can just as
  50     well be done without it.  NSFontDescriptor is basically just a shell
  51     around an NSMutableDictionary with well-defined keys.
  52
  53
  54     Getting back to the broad overview, font matching is one of the weaker points
  55     in Cocoa's API and NSFontDescriptor is the easier to use solution.
  56
  57     That said, it's not impossible to implement font matching without it. For instance,
  58     if you have a family name and want to list available variants (e.g. Bold, italic,
  59     underlined) then you can ask NSFontManager for availableMembersOfFontFamily:.
  60
  61     The problem is that you can either match on family name or on font attributes
  62     but not on both.  To match both you have to do one then the other.
  63     NSFontDescriptor allows you to get a list of fonts matching both a family name
  64     and a particular set of attributes.  Furthermore, the attributes instead of
  65     being flags as in NSFontManager are instead well-defined keys in a dictionary.
  66
  67     The only way to get that behaviour without NSFontManager is to pare down the
  68     list as much as possible using the classic NSFontManager methods and then
  69     to instantiate each font in the list and match on each font's afmDictionary.
  70
  71     A reasonable guess is that that's probably more or less exactly what
  72     NSFontDescriptor does internally.
  73  */
  74 #include "wx/wxprec.h"
  75
  76 #include "wx/font.h"
  77
  78 #ifndef WX_PRECOMP
  79     #include "wx/string.h"
  80     #include "wx/gdicmn.h"
  81 #endif
  82
  83 #include "wx/fontutil.h"
  84 #include "wx/encinfo.h"
  85
  86 #include "wx/cocoa/string.h"
  87 #include "wx/cocoa/private/fontfactory.h"
  88 #include "wx/cocoa/autorelease.h"
  89
  90 #include <AppKit/NSFont.h>
  91 #include <AppKit/NSFontManager.h>
  92
  93 // Helper methods for NSFont/wxNativeFontInfo
  94 static NSFont* GetNSFontForNativeFontInfo(const wxNativeFontInfo &info);
  95 static void UpdateNativeFontInfoWithNSFont(wxNativeFontInfo &info, NSFont *cocoaNSFont);
  96 static wxNativeFontInfo MakeNativeFontInfoForNSFont(NSFont *cocoaNSFont, bool underlined = false);
  97 static wxNativeFontInfo MakeNativeFontInfo(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding);
  98
  99 /*! @discussion
 100     Due to 2.8 ABI compatibility concerns we probably don't want to change wxNativeFontInfo
 101     although this may be unfounded because this class is supposed to be internal as is
 102     wxNativeFontInfo so anyone who subclassed it or created one without going through
 103     wxFont should expect what they get (i.e. horrible breakage)
 104     There's a concern that wxFontRefData was in the public header when 2.8 shipped so
 105     it's possible that someone did subclass it to get better font behaviour.
 106
 107     For right now, the plan is to write it strictly ABI compatible with 2.8 and eventually
 108     to enhance it in trunk to accurately represent font attributes as Cocoa sees them.
 109
 110     I'd like to let at least one 2.8 release go out the door and get feedback as to whether
 111     this is going to be a problem or not.  If so, we'll keep it strictly ABI compatible.
 112     If not, we'll update it.
 113  */
 114 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
 115 {
 116     friend class WXDLLIMPEXP_FWD_CORE wxFont;
 117 public:
 118     wxFontRefData()
 119     :   m_cocoaNSFont(nil)
 120     ,   m_info(MakeNativeFontInfo(10, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
 121              wxT("Geneva"), wxFONTENCODING_DEFAULT))
 122     {
 123         CreateNSFontAndUpdateInfo();
 124     }
 125
 126     wxFontRefData(const wxFontRefData& data)
 127     :   wxGDIRefData()
 128     ,   m_cocoaNSFont([data.m_cocoaNSFont retain])
 129     ,   m_info(data.m_info)
 130     {
 131     }
 132
 133     wxFontRefData(NSFont *cocoaNSFont, bool underlined)
 134     :   wxGDIRefData()
 135     ,   m_cocoaNSFont([cocoaNSFont retain])
 136     ,   m_info(MakeNativeFontInfoForNSFont(m_cocoaNSFont, underlined))
 137     {
 138     }
 139
 140     wxFontRefData(const wxNativeFontInfo& info)
 141     :   wxGDIRefData()
 142     ,   m_cocoaNSFont(nil)
 143     ,   m_info(info)
 144     {
 145         CreateNSFontAndUpdateInfo();
 146     }
 147
 148     wxFontRefData(int size,
 149                   wxFontFamily family,
 150                   wxFontStyle style,
 151                   wxFontWeight weight,
 152                   bool underlined,
 153                   const wxString& faceName,
 154                   wxFontEncoding encoding)
 155     :   m_cocoaNSFont(nil)
 156     ,   m_info(MakeNativeFontInfo(size, family, style, weight, underlined, faceName, encoding))
 157     {
 158         CreateNSFontAndUpdateInfo();
 159     }
 160
 161     virtual ~wxFontRefData();
 162 protected:
 163     /*! @abstract   common part of some ctors
 164         @discussion
 165         This is a leftover of sorts from the old stub code.
 166         FIXME: Remove from trunk
 167      */
 168     void Init(int size,
 169               wxFontFamily family,
 170               wxFontStyle style,
 171               wxFontWeight weight,
 172               bool underlined,
 173               const wxString& faceName,
 174               wxFontEncoding encoding);
 175
 176     /*! @discussion
 177         Uses the native font info to create an NSFont and then updates that info with
 178         the attributes of the font.  This is necessary because, for example, a font
 179         can be created with an empty faceName in which case some concrete typeface must
 180         be chosen.
 181         We choose to handle this by first initializing the wxNativeFontInfo with the
 182         properties as given by the user and then creating the NSFont and updating
 183         the wxNativeFontInfo to match the NSFont.
 184      */
 185     void CreateNSFontAndUpdateInfo()
 186     {
 187         wxAutoNSAutoreleasePool pool;
 188         [m_cocoaNSFont release];
 189         m_cocoaNSFont = [GetNSFontForNativeFontInfo(m_info) retain];
 190         UpdateNativeFontInfoWithNSFont(m_info, m_cocoaNSFont);
 191     }
 192
 193     // font characterstics
 194     NSFont *m_cocoaNSFont;
 195     wxNativeFontInfo m_info;
 196
 197 public:
 198 };
 199
 200 NSString *GetFamilyName(wxFontFamily family)
 201 {
 202     switch(family)
 203     {
 204     case wxFONTFAMILY_DEFAULT:
 205     default:
 206         return @"Times";
 207     case wxFONTFAMILY_DECORATIVE:
 208     case wxFONTFAMILY_ROMAN:
 209     case wxFONTFAMILY_SCRIPT:
 210         return @"Times";
 211     case wxFONTFAMILY_SWISS:
 212         return @"Lucida Grande";
 213     case wxFONTFAMILY_MODERN:
 214     case wxFONTFAMILY_TELETYPE:
 215         return @"Monaco";
 216     };
 217 }
 218 // Returns an NSFont given the native font info
 219 // NOTE: It is not considered alloc'd (i.e. this is a get method not an alloc/new method)
 220 static NSFont* GetNSFontForNativeFontInfo(const wxNativeFontInfo &info)
 221 {
 222     if(!info.faceName.empty())
 223     {
 224         NSFont *font = [NSFont fontWithName:wxNSStringWithWxString(info.faceName) size:info.pointSize];
 225         // TODO: use NSFontManager to mix in the weights and whatnot
 226         if(font != nil)
 227             return font;
 228         // To err or not to err?
 229     }
 230     // No font with that face name or no face name
 231
 232     NSFontTraitMask cocoaTraits = 0;
 233     int cocoaWeight = 5;
 234     NSFont *font = [[NSFontManager sharedFontManager] fontWithFamily:GetFamilyName(info.family) traits:cocoaTraits weight:cocoaWeight size:info.pointSize];
 235     return font;
 236 }
 237
 238 /*! @discussion
 239     Updates all fields of @a info except for underlined which is not a property of NSFont.
 240  */
 241 static void UpdateNativeFontInfoWithNSFont(wxNativeFontInfo &info, NSFont *cocoaNSFont)
 242 {
 243     info.pointSize = [cocoaNSFont pointSize];
 244
 245     // FIXME: We could maybe improve on this?
 246     info.family = wxFONTFAMILY_DEFAULT;
 247
 248     // FIXME: italicAngle might indicate a slanted rather than truly italic font?
 249     info.style = [cocoaNSFont italicAngle] == 0.0?wxFONTSTYLE_NORMAL:wxFONTSTYLE_ITALIC;
 250
 251     int cocoaWeight = [[NSFontManager sharedFontManager] weightOfFont:cocoaNSFont];
 252     if(cocoaWeight < 5)
 253         info.weight = wxFONTWEIGHT_LIGHT;
 254     else if(cocoaWeight < 9)
 255         info.weight = wxFONTWEIGHT_NORMAL;
 256     else
 257         info.weight = wxFONTWEIGHT_BOLD;
 258
 259     // FIXME: Is this right?  I think so.
 260     info.faceName = wxStringWithNSString([cocoaNSFont fontName]);
 261
 262     // TODO: Translate NSStringEncoding to wxFontEncoding
 263     info.encoding = wxFONTENCODING_SYSTEM;
 264 }
 265
 266 /*! @discussion
 267     Creates a new generic wxNativeFontInfo from an NSFont and an underlined flag.
 268     Uses UpdateNativeFontInfoWithNSFont to do the work and sets the underlined field
 269     of wxNativeFontInfo to the @a underlined argument.
 270  */
 271 static wxNativeFontInfo MakeNativeFontInfoForNSFont(NSFont *cocoaNSFont, bool underlined)
 272 {
 273     wxNativeFontInfo info;
 274     UpdateNativeFontInfoWithNSFont(info, cocoaNSFont);
 275
 276     // NSFont are never underlined.. that's a function of the drawing system
 277     info.underlined = underlined;
 278
 279     return info;
 280 }
 281
 282 //#include "_font_test_2_8_abi_compat.h"
 283
 284 static wxNativeFontInfo MakeNativeFontInfo(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
 285 {
 286     wxNativeFontInfo m_info; // NOTE: not an i-var despite name
 287     m_info.pointSize = size;
 288     m_info.family = static_cast<wxFontFamily>(family);
 289     m_info.style = static_cast<wxFontStyle>(style);
 290     m_info.weight = static_cast<wxFontWeight>(weight);
 291     m_info.underlined = underlined;
 292     m_info.faceName = faceName;
 293     m_info.encoding = encoding;
 294     return m_info;
 295 }
 296
 297 void wxFontRefData::Init(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
 298 {
 299     m_info = MakeNativeFontInfo(size, family, style, weight, underlined, faceName, encoding);
 300 }
 301
 302 wxFontRefData::~wxFontRefData()
 303 {
 304     [m_cocoaNSFont release];
 305     m_cocoaNSFont = nil;
 306     // TODO: delete font data
 307 }
 308
 309 #define M_FONTDATA ((wxFontRefData*)m_refData)
 310
 311 wxFont wxCocoaFontFactory::InstanceForNSFont(WX_NSFont cocoaFont, bool underlined)
 312 {
 313     return wxFont(new wxFontRefData(cocoaFont, underlined));
 314 }
 315
 316 bool wxFont::Create(wxFontRefData *refData)
 317 {
 318     UnRef();
 319     m_refData = refData;
 320
 321     return m_refData != NULL;
 322 }
 323
 324 bool wxFont::Create(const wxNativeFontInfo& nativeFontInfo)
 325 {
 326     UnRef();
 327     m_refData = new wxFontRefData(nativeFontInfo);
 328
 329     return true;
 330 }
 331
 332 wxGDIRefData *wxFont::CreateGDIRefData() const
 333 {
 334     return new wxFontRefData;
 335 }
 336
 337 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
 338 {
 339     return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
 340 }
 341
 342 void wxFont::SetEncoding(wxFontEncoding)
 343 {
 344 }
 345
 346 wxFontEncoding wxFont::GetEncoding() const
 347 {
 348     return wxFontEncoding();
 349 }
 350
 351 int wxFont::GetPointSize() const
 352 {
 353     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 354     return M_FONTDATA->m_info.pointSize;
 355 }
 356
 357 bool wxFont::GetUnderlined() const
 358 {
 359     if(M_FONTDATA)
 360         return M_FONTDATA->m_info.underlined;
 361     else
 362         return false;
 363 }
 364
 365 wxFontStyle wxFont::GetStyle() const
 366 {
 367     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 368     return M_FONTDATA->m_info.style;
 369 }
 370
 371 wxFontFamily wxFont::DoGetFamily() const
 372 {
 373     return M_FONTDATA->m_info.family;
 374 }
 375
 376 wxFontWeight wxFont::GetWeight() const
 377 {
 378     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 379     return M_FONTDATA->m_info.weight;
 380 }
 381
 382 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
 383 {
 384     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 385     return &M_FONTDATA->m_info;
 386 }
 387
 388 bool wxFont::Create(int pointSize, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
 389 {
 390     UnRef();
 391     m_refData = new wxFontRefData(pointSize, family, style, weight, underlined, faceName, encoding);
 392
 393     RealizeResource();
 394
 395     return true;
 396 }
 397
 398 wxFont::~wxFont()
 399 {
 400 }
 401
 402 bool wxFont::RealizeResource()
 403 {
 404     // TODO: create the font (if there is a native font object)
 405     return false;
 406 }
 407
 408 void wxFont::SetPointSize(int pointSize)
 409 {
 410     AllocExclusive();
 411
 412     M_FONTDATA->m_info.pointSize = pointSize;
 413
 414     RealizeResource();
 415 }
 416
 417 void wxFont::SetFamily(wxFontFamily family)
 418 {
 419     AllocExclusive();
 420
 421     M_FONTDATA->m_info.family = static_cast<wxFontFamily>(family);
 422
 423     RealizeResource();
 424 }
 425
 426 void wxFont::SetStyle(wxFontStyle style)
 427 {
 428     AllocExclusive();
 429
 430     M_FONTDATA->m_info.style = static_cast<wxFontStyle>(style);
 431
 432     RealizeResource();
 433 }
 434
 435 void wxFont::SetWeight(wxFontWeight weight)
 436 {
 437     AllocExclusive();
 438
 439     M_FONTDATA->m_info.weight = static_cast<wxFontWeight>(weight);
 440
 441     RealizeResource();
 442 }
 443
 444 bool wxFont::SetFaceName(const wxString& faceName)
 445 {
 446     AllocExclusive();
 447
 448     M_FONTDATA->m_info.faceName = faceName;
 449
 450     RealizeResource();
 451
 452     return wxFontBase::SetFaceName(faceName);
 453 }
 454
 455 void wxFont::SetUnderlined(bool underlined)
 456 {
 457     AllocExclusive();
 458
 459     M_FONTDATA->m_info.underlined = underlined;
 460
 461     RealizeResource();
 462 }
 463
 464 /* New font system */
 465 wxString wxFont::GetFaceName() const
 466 {
 467     wxString str;
 468     if (M_FONTDATA)
 469         str = M_FONTDATA->m_info.faceName;
 470     return str;
 471 }
 472
 473 // vim:sts=4:sw=4:et