]> git.saurik.com Git - wxWidgets.git/blobdiff - src/osx/carbon/font.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
adding wrapping possibility for native tlws
[wxWidgets.git] / src / osx / carbon / font.cpp
diff --git a/src/osx/carbon/font.cpp b/src/osx/carbon/font.cpp
index ba91fabee477db9011bcadba3d33ef9e28ba9efb..f53c0138caa0777ca6f728c09ccdb168b5dcc236 100644 (file)
--- a/src/osx/carbon/font.cpp
+++ b/src/osx/carbon/font.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        src/mac/carbon/font.cpp
+// Name:        src/osx/carbon/font.cpp
 // Purpose:     wxFont class
 // Author:      Stefan Csomor
 // Modified by:
 // Purpose:     wxFont class
 // Author:      Stefan Csomor
 // Modified by:
@@ -24,49 +24,35 @@
 #include "wx/fontutil.h"
 #include "wx/graphics.h"
 #include "wx/settings.h"
 #include "wx/fontutil.h"
 #include "wx/graphics.h"
 #include "wx/settings.h"
+#include "wx/tokenzr.h"
 
 
-#if wxOSX_USE_CARBON
-#include "wx/osx/uma.h"
-#else
 #include "wx/osx/private.h"
 #include "wx/osx/private.h"
-#endif
-
-#ifndef __DARWIN__
-#include <ATSUnicode.h>
-#endif
 
 #include <map>
 #include <string>
 
 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
 
 
 #include <map>
 #include <string>
 
 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
 
-
 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
 {
 public:
 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
 {
 public:
+
     wxFontRefData()
     {
     wxFontRefData()
     {
-        Init(10, wxDEFAULT, wxNORMAL, wxNORMAL,
-             false, wxT("applicationfont"), wxFONTENCODING_DEFAULT);
+        Init();
+        m_info.Init(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL,
+             false, wxEmptyString, wxFONTENCODING_DEFAULT);
     }
 
     }
 
-    wxFontRefData(const wxFontRefData& data)
-    {
-        Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
-             data.m_underlined, data.m_faceName, data.m_encoding);
-    }
+    wxFontRefData(const wxFontRefData& data);
 
 
-    wxFontRefData(int size,
-                  int family,
-                  int style,
-                  int weight,
-                  bool underlined,
-                  const wxString& faceName,
-                  wxFontEncoding encoding)
+    wxFontRefData( const wxNativeFontInfo& info ) : m_info(info)
     {
     {
-        Init(size, family, style, weight, underlined, faceName, encoding);
+        Init();
     }
 
     }
 
+    wxFontRefData(wxOSXSystemFont font, int size);
+
 #if wxOSX_USE_CORE_TEXT
     wxFontRefData( wxUint32 coreTextFontType );
     wxFontRefData( CTFontRef font );
 #if wxOSX_USE_CORE_TEXT
     wxFontRefData( wxUint32 coreTextFontType );
     wxFontRefData( CTFontRef font );
@@ -75,127 +61,149 @@ public:
 
     virtual ~wxFontRefData();
 
 
     virtual ~wxFontRefData();
 
-    void SetNoAntiAliasing( bool no = true ) { m_noAA = no; }
-
-    bool GetNoAntiAliasing() const { return m_noAA; }
-
     void SetPointSize( int size )
     {
     void SetPointSize( int size )
     {
-        m_pointSize = size;
-        MacInvalidateNativeFont();
+        if( GetPointSize() != size )
+        {
+            m_info.SetPointSize(size);
+            Free();
+        }
     }
 
     }
 
-    int GetPointSize() const { return m_pointSize; }
+    int GetPointSize() const { return m_info.GetPointSize(); }
 
 
-    void SetFamily( int family )
+    void SetFamily( wxFontFamily family )
     {
     {
-        m_family = family;
-        MacInvalidateNativeFont();
+        if ( m_info.m_family != family )
+        {
+            m_info.SetFamily( family );
+            Free();
+        }
     }
 
     }
 
+    wxFontFamily GetFamily() const { return m_info.GetFamily(); }
 
 
-    int GetFamily() const { return m_family; }
-
-    void SetStyle( int style )
+    void SetStyle( wxFontStyle style )
     {
     {
-        m_style = style;
-        MacInvalidateNativeFont();
+        if ( m_info.m_style != style )
+        {
+            m_info.SetStyle( style );
+            Free();
+        }
     }
 
 
     }
 
 
-    int GetStyle() const { return m_style; }
+    wxFontStyle GetStyle() const { return m_info.GetStyle(); }
 
 
-    void SetWeight( int weight )
+    void SetWeight( wxFontWeight weight )
     {
     {
-        m_weight = weight;
-        MacInvalidateNativeFont();
+        if ( m_info.m_weight != weight )
+        {
+            m_info.SetWeight( weight );
+            Free();
+        }
     }
 
 
     }
 
 
-    int GetWeight() const { return m_weight; }
+    wxFontWeight GetWeight() const { return m_info.GetWeight(); }
 
     void SetUnderlined( bool u )
     {
 
     void SetUnderlined( bool u )
     {
-        m_underlined = u;
-        MacInvalidateNativeFont();
+        if ( m_info.m_underlined != u )
+        {
+            m_info.SetUnderlined( u );
+            Free();
+        }
     }
 
     }
 
-    bool GetUnderlined() const { return m_underlined; }
+    bool GetUnderlined() const { return m_info.GetUnderlined(); }
 
     void SetFaceName( const wxString& facename )
     {
 
     void SetFaceName( const wxString& facename )
     {
-        m_faceName = facename;
-        MacInvalidateNativeFont();
+        if ( m_info.m_faceName != facename )
+        {
+            m_info.SetFaceName( facename );
+            Free();
+        }
     }
 
     }
 
-    const wxString& GetFaceName() const { return m_faceName; }
+    wxString GetFaceName() const { return m_info.GetFaceName(); }
 
     void SetEncoding( wxFontEncoding encoding )
     {
 
     void SetEncoding( wxFontEncoding encoding )
     {
-        m_encoding = encoding;
-        MacInvalidateNativeFont();
+        if ( m_info.m_encoding != encoding )
+        {
+            m_info.SetEncoding( encoding );
+            Free();
+        }
     }
 
     }
 
-    wxFontEncoding GetEncoding() const { return m_encoding; }
+    wxFontEncoding GetEncoding() const { return m_info.GetEncoding(); }
 
 
-    void MacInvalidateNativeFont();
+    void Free();
 
     void MacFindFont();
 
 protected:
     // common part of all ctors
 
     void MacFindFont();
 
 protected:
     // common part of all ctors
-    void Init(int size,
-              int family,
-              int style,
-              int weight,
-              bool underlined,
-              const wxString& faceName,
-              wxFontEncoding encoding);
-
+    void Init();
 #if wxOSX_USE_CORE_TEXT
 #if wxOSX_USE_CORE_TEXT
-    void Init( CTFontRef font );
+    // void Init( CTFontRef font );
 #endif
 #endif
-    // font characterstics
-    int             m_pointSize;
-    int             m_family;
-    int             m_style;
-    int             m_weight;
-    bool            m_underlined;
-    wxString        m_faceName;
-    wxFontEncoding  m_encoding;
-    bool            m_noAA;      // No anti-aliasing
-
 public:
 public:
-#if wxOSX_USE_ATSU_TEXT
-    FMFontFamily    m_macFontFamily;
-    FMFontSize      m_macFontSize;
-    FMFontStyle     m_macFontStyle;
-
-    // ATSU Font Information
-
-    // this is split into an ATSU font id that may
-    // contain some styles (special bold fonts etc) and
-    // these are the additional qd styles that are not
-    // included in the ATSU font id
-    ATSUFontID      m_macATSUFontID;
-    FMFontStyle     m_macATSUAdditionalQDStyles ;
-
-    // for true themeing support we must store the correct font
+    bool            m_fontValid;
+#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
+    // for true theming support we must store the correct font
     // information here, as this speeds up and optimizes rendering
     ThemeFontID     m_macThemeFontID ;
 #endif
 #if wxOSX_USE_CORE_TEXT
     wxCFRef<CTFontRef> m_ctFont;
     // information here, as this speeds up and optimizes rendering
     ThemeFontID     m_macThemeFontID ;
 #endif
 #if wxOSX_USE_CORE_TEXT
     wxCFRef<CTFontRef> m_ctFont;
-    wxCFRef<CTFontDescriptorRef> m_ctFontDescriptor;
 #endif
 #endif
-#if wxOSX_USE_CORE_TEXT || wxOSX_USE_ATSU_TEXT
+#if wxOSX_USE_ATSU_TEXT
+    void CreateATSUFont();
+
     ATSUStyle       m_macATSUStyle ;
     ATSUStyle       m_macATSUStyle ;
+#endif
+    wxCFRef<CGFontRef> m_cgFont;
+#if wxOSX_USE_COCOA
+    WX_NSFont       m_nsFont;
+#endif
+#if wxOSX_USE_IPHONE
+    WX_UIFont       m_uiFont;
 #endif
     wxNativeFontInfo  m_info;
 };
 
 #define M_FONTDATA ((wxFontRefData*)m_refData)
 
 #endif
     wxNativeFontInfo  m_info;
 };
 
 #define M_FONTDATA ((wxFontRefData*)m_refData)
 
+wxFontRefData::wxFontRefData(const wxFontRefData& data)
+{
+    Init();
+    m_info = data.m_info;
+    m_fontValid = data.m_fontValid;
+#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
+    m_macThemeFontID = data.m_macThemeFontID;
+#endif
+#if wxOSX_USE_CORE_TEXT
+    m_ctFont = data.m_ctFont;
+#endif
+    m_cgFont = data.m_cgFont;
+#if wxOSX_USE_ATSU_TEXT
+    if ( data.m_macATSUStyle != NULL )
+    {
+        ATSUCreateStyle(&m_macATSUStyle) ;
+        ATSUCopyAttributes(data.m_macATSUStyle, m_macATSUStyle);
+    }
+#endif
+#if wxOSX_USE_COCOA
+    m_nsFont = (NSFont*) wxMacCocoaRetain(data.m_nsFont);
+#endif
+#if wxOSX_USE_IPHONE
+    m_uiFont = (UIFont*) wxMacCocoaRetain(data.m_uiFont);
+#endif
+
+}
 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation
@@ -205,476 +213,335 @@ public:
 // wxFontRefData
 // ----------------------------------------------------------------------------
 
 // wxFontRefData
 // ----------------------------------------------------------------------------
 
-void wxFontRefData::Init(int pointSize,
-    int family,
-    int style,
-    int weight,
-    bool underlined,
-    const wxString& faceName,
-    wxFontEncoding encoding)
+void wxFontRefData::Init()
 {
 {
-    m_style = style;
-    m_pointSize = (pointSize == -1) ? wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT).GetPointSize() : pointSize;
-    m_family = family;
-    m_style = style;
-    m_weight = weight;
-    m_underlined = underlined;
-    m_faceName = faceName;
-    m_encoding = encoding;
-    m_noAA = false;
-#if wxOSX_USE_ATSU_TEXT
-    m_macFontFamily = 0 ;
-    m_macFontSize = 0;
-    m_macFontStyle = 0;
-    m_macATSUFontID = 0;
-    m_macATSUAdditionalQDStyles = 0 ;
+#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
     m_macThemeFontID = kThemeCurrentPortFont ;
 #endif
     m_macThemeFontID = kThemeCurrentPortFont ;
 #endif
-#if wxOSX_USE_CORE_TEXT || wxOSX_USE_ATSU_TEXT
+#if wxOSX_USE_ATSU_TEXT
     m_macATSUStyle = NULL ;
 #endif
     m_macATSUStyle = NULL ;
 #endif
+#if wxOSX_USE_COCOA
+    m_nsFont = NULL;
+#endif
+#if wxOSX_USE_IPHONE
+    m_uiFont = NULL;
+#endif
+    m_fontValid = false;
 }
 
 wxFontRefData::~wxFontRefData()
 {
 }
 
 wxFontRefData::~wxFontRefData()
 {
-#if wxOSX_USE_CORE_TEXT || wxOSX_USE_ATSU_TEXT
-    if ( m_macATSUStyle )
-    {
-        ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
-        m_macATSUStyle = NULL ;
-    }
-#endif
+    Free();
 }
 
 }
 
-void wxFontRefData::MacInvalidateNativeFont()
+void wxFontRefData::Free()
 {
 #if wxOSX_USE_CORE_TEXT
     m_ctFont.reset();
 {
 #if wxOSX_USE_CORE_TEXT
     m_ctFont.reset();
-    m_ctFontDescriptor.reset();
 #endif
 #endif
-#if wxOSX_USE_CORE_TEXT || wxOSX_USE_ATSU_TEXT
+    m_cgFont.reset();
+#if wxOSX_USE_ATSU_TEXT
+#if wxOSX_USE_CARBON
+    m_macThemeFontID = kThemeCurrentPortFont ;
+#endif
     if ( m_macATSUStyle )
     {
         ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
         m_macATSUStyle = NULL ;
     }
 #endif
     if ( m_macATSUStyle )
     {
         ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
         m_macATSUStyle = NULL ;
     }
 #endif
-}
-
-#if wxOSX_USE_CORE_TEXT
-
-/* from Core Text Manual Common Operations */
-
-static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
-{
-    CTFontDescriptorRef descriptor = NULL;
-    CFMutableDictionaryRef attributes;
-
-    assert(iFamilyName != NULL);
-    // Create a mutable dictionary to hold our attributes.
-    attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
-                                           &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
-    check(attributes != NULL);
-
-    if (attributes != NULL) {
-        // Add a family name to our attributes.
-        CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
-
-
-        if ( iTraits ) {
-            CFMutableDictionaryRef traits;
-            CFNumberRef symTraits;
-
-            // Create the traits dictionary.
-            symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
-                                       &iTraits);
-            check(symTraits != NULL);
-
-            if (symTraits != NULL) {
-                // Create a dictionary to hold our traits values.
-                traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
-                                                   &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
-                check(traits != NULL);
-
-                if (traits != NULL) {
-                    // Add the symbolic traits value to the traits dictionary.
-                    CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
-
-                    // Add the traits attribute to our attributes.
-                    CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
-                    CFRelease(traits);
-                }
-                CFRelease(symTraits);
-            }
-        }
-        // Create the font descriptor with our attributes
-        descriptor = CTFontDescriptorCreateWithAttributes(attributes);
-        check(descriptor != NULL);
-
-        CFRelease(attributes);
+#if wxOSX_USE_COCOA
+    if (m_nsFont != NULL)
+    {
+        wxMacCocoaRelease(m_nsFont);
+        m_nsFont = NULL;
     }
     }
-    // Return our font descriptor.
-    return descriptor ;
-}
-
-wxFontRefData::wxFontRefData( wxUint32 coreTextFontType )
-{
-    CTFontRef font = CTFontCreateUIFontForLanguage( coreTextFontType, 0.0, NULL ) ;
-    if ( CTFontGetSize(font) == 0 )
+#endif
+#if wxOSX_USE_IPHONE
+    if (m_uiFont != NULL)
     {
     {
-        CFRelease(font);
-        font = CTFontCreateUIFontForLanguage( coreTextFontType, 12.0, NULL );
+        wxMacCocoaRelease(m_uiFont);
+        m_uiFont = NULL;
     }
     }
-    Init( font );
+#endif
+    m_fontValid = false;
 }
 
 }
 
-wxFontRefData::wxFontRefData( CTFontRef font )
+wxFontRefData::wxFontRefData(wxOSXSystemFont font, int size)
 {
 {
-    Init( font );
-}
+    wxASSERT( font != wxOSX_SYSTEM_FONT_NONE );
+    Init();
 
 
-wxFontRefData::wxFontRefData( CTFontDescriptorRef fontdescriptor, int size )
-{
-    if ( size == 0 )
+#if wxOSX_USE_CORE_TEXT
+    if (  UMAGetSystemVersion() >= 0x1050 )
     {
     {
-        wxCFRef< CFNumberRef > value( (CFNumberRef) CTFontDescriptorCopyAttribute( fontdescriptor, kCTFontSizeAttribute ) );
-
-        float fsize;
-        if ( CFNumberGetValue( value , kCFNumberFloatType , &fsize ) )
+        CTFontUIFontType uifont = kCTFontSystemFontType;
+        switch( font )
+        {
+            case wxOSX_SYSTEM_FONT_NORMAL:
+                uifont = kCTFontSystemFontType;
+                break;
+            case wxOSX_SYSTEM_FONT_BOLD:
+                uifont = kCTFontEmphasizedSystemFontType;
+                break;
+            case wxOSX_SYSTEM_FONT_SMALL:
+                uifont = kCTFontSmallSystemFontType;
+                break;
+            case wxOSX_SYSTEM_FONT_SMALL_BOLD:
+                uifont = kCTFontSmallEmphasizedSystemFontType;
+                break;
+            case wxOSX_SYSTEM_FONT_MINI:
+                uifont = kCTFontMiniSystemFontType;
+                break;
+           case wxOSX_SYSTEM_FONT_MINI_BOLD:
+                uifont = kCTFontMiniEmphasizedSystemFontType;
+                break;
+            case wxOSX_SYSTEM_FONT_LABELS:
+                uifont = kCTFontLabelFontType;
+                break;
+           case wxOSX_SYSTEM_FONT_VIEWS:
+                uifont = kCTFontViewsFontType;
+                break;
+            default:
+                break;
+        }
+        m_ctFont.reset(CTFontCreateUIFontForLanguage( uifont, (CGFloat) size, NULL ));
+        wxCFRef<CTFontDescriptorRef> descr;
+        descr.reset( CTFontCopyFontDescriptor( m_ctFont ) );
+        m_info.Init(descr);
+    }
+#endif
+#if wxOSX_USE_ATSU_TEXT
+    {
+#if !wxOSX_USE_CARBON
+        // not needed outside
+        ThemeFontID m_macThemeFontID = kThemeSystemFont;
+#endif
+        switch( font )
         {
         {
-            size = (int) fsize + 0.5 ;
+            case wxOSX_SYSTEM_FONT_NORMAL:
+                m_macThemeFontID = kThemeSystemFont;
+                break;
+            case wxOSX_SYSTEM_FONT_BOLD:
+                m_macThemeFontID = kThemeEmphasizedSystemFont;
+                break;
+            case wxOSX_SYSTEM_FONT_SMALL:
+                m_macThemeFontID = kThemeSmallSystemFont;
+                break;
+            case wxOSX_SYSTEM_FONT_SMALL_BOLD:
+                m_macThemeFontID = kThemeSmallEmphasizedSystemFont;
+                break;
+            case wxOSX_SYSTEM_FONT_MINI:
+                m_macThemeFontID = kThemeMiniSystemFont;
+                break;
+           case wxOSX_SYSTEM_FONT_MINI_BOLD:
+                // bold not available under theming
+                m_macThemeFontID = kThemeMiniSystemFont;
+                break;
+            case wxOSX_SYSTEM_FONT_LABELS:
+                m_macThemeFontID = kThemeLabelFont;
+                break;
+           case wxOSX_SYSTEM_FONT_VIEWS:
+                m_macThemeFontID = kThemeViewsFont;
+                break;
+            default:
+                break;
         }
         }
+        if ( m_info.m_faceName.empty() )
+        {
+            Style style ;
+            FMFontSize fontSize;
+            Str255 qdFontName ;
+
+            GetThemeFont( m_macThemeFontID, GetApplicationScript(), qdFontName, &fontSize, &style );
+            if ( size != 0 )
+                fontSize = size;
+
+            wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
+            wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
+            bool underlined = false;
+
+            if ( style & bold )
+                fontweight = wxFONTWEIGHT_BOLD ;
+            else
+                fontweight = wxFONTWEIGHT_NORMAL ;
+            if ( style & italic )
+                fontstyle = wxFONTSTYLE_ITALIC ;
+            if ( style & underline )
+                underlined = true ;
+
+            m_info.Init(fontSize,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined,
+                wxMacMakeStringFromPascal( qdFontName ), wxFONTENCODING_DEFAULT);
+         }
     }
     }
-    Init( CTFontCreateWithFontDescriptor(fontdescriptor, size,NULL)  );
+#endif
+#if wxOSX_USE_COCOA
+    m_nsFont = wxFont::OSXCreateNSFont( font, &m_info );
+#endif
+#if wxOSX_USE_IPHONE
+    m_uiFont = wxFont::OSXCreateUIFont( font, &m_info );
+#endif
+    m_info.EnsureValid();
+#if wxOSX_USE_ATSU_TEXT
+    CreateATSUFont();
+#endif
+
+    m_fontValid = true;
 }
 
 }
 
-void wxFontRefData::Init( CTFontRef font )
+#if wxOSX_USE_ATSU_TEXT
+void wxFontRefData::CreateATSUFont()
 {
 {
-    Init(10, wxDEFAULT, wxNORMAL, wxNORMAL,
-         false, wxT("applicationfont"), wxFONTENCODING_DEFAULT);
+    // we try to get as much styles as possible into ATSU
 
 
-    m_ctFont.reset( font );
-}
+    OSStatus status = ::ATSUCreateStyle(&m_macATSUStyle);
+    wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
 
 
+    ATSUAttributeTag atsuTags[] =
+    {
+        kATSUFontTag ,
+        kATSUSizeTag ,
+        kATSUVerticalCharacterTag,
+        kATSUQDBoldfaceTag ,
+        kATSUQDItalicTag ,
+        kATSUQDUnderlineTag ,
+        kATSUQDCondensedTag ,
+        kATSUQDExtendedTag ,
+    };
+    ByteCount atsuSizes[WXSIZEOF(atsuTags)] =
+    {
+        sizeof( ATSUFontID ) ,
+        sizeof( Fixed ) ,
+        sizeof( ATSUVerticalCharacterType),
+        sizeof( Boolean ) ,
+        sizeof( Boolean ) ,
+        sizeof( Boolean ) ,
+        sizeof( Boolean ) ,
+        sizeof( Boolean ) ,
+    };
+
+    Boolean kTrue = true ;
+    Boolean kFalse = false ;
+
+    Fixed atsuSize = IntToFixed( m_info.m_pointSize );
+    ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
+    FMFontStyle addQDStyle = m_info.m_atsuAdditionalQDStyles;
+    ATSUAttributeValuePtr    atsuValues[WXSIZEOF(atsuTags)] =
+    {
+        &m_info.m_atsuFontID ,
+        &atsuSize ,
+        &kHorizontal,
+        (addQDStyle & bold) ? &kTrue : &kFalse ,
+        (addQDStyle & italic) ? &kTrue : &kFalse ,
+        (addQDStyle & underline) ? &kTrue : &kFalse ,
+        (addQDStyle & condense) ? &kTrue : &kFalse ,
+        (addQDStyle & extend) ? &kTrue : &kFalse ,
+    };
+
+    status = ::ATSUSetAttributes(
+                                 (ATSUStyle)m_macATSUStyle,
+                                 WXSIZEOF(atsuTags),
+                                 atsuTags, atsuSizes, atsuValues);
+
+    wxASSERT_MSG( status == noErr , wxString::Format(wxT("couldn't modify ATSU style. Status was %d"), (int) status).c_str() );
+
+    if ( m_cgFont.get() == NULL )
+    {
+        ATSFontRef fontRef = FMGetATSFontRefFromFont(m_info.m_atsuFontID);
+        m_cgFont.reset( CGFontCreateWithPlatformFont( &fontRef ) );
+    }
+}
 #endif
 
 #endif
 
+static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
+static const CGAffineTransform kSlantTransform = CGAffineTransformMake( 1, 0, tan(DegToRad(11)), 1, 0, 0 );
+
 void wxFontRefData::MacFindFont()
 {
 void wxFontRefData::MacFindFont()
 {
+    if ( m_fontValid )
+        return;
+
+    wxCHECK_RET( m_info.m_pointSize > 0, wxT("Point size should not be zero.") );
+
+    m_info.EnsureValid();
 
 #if wxOSX_USE_CORE_TEXT
     if (  UMAGetSystemVersion() >= 0x1050 )
     {
 
 #if wxOSX_USE_CORE_TEXT
     if (  UMAGetSystemVersion() >= 0x1050 )
     {
-        if ( m_faceName.empty() && m_family == wxDEFAULT )
-        {
-            m_ctFont.reset(CTFontCreateUIFontForLanguage( kCTFontSystemFontType, 0.0, NULL ));
-        }
+         CTFontSymbolicTraits traits = 0;
 
 
-        if ( m_ctFont )
-        {
-            wxCFStringRef name( CTFontCopyFamilyName( m_ctFont ) );
-            m_faceName = name.AsString();
-            m_pointSize = CTFontGetSize(m_ctFont) ;
-            CTFontSymbolicTraits traits = CTFontGetSymbolicTraits( m_ctFont );
-            if ( traits & kCTFontItalicTrait )
-                m_style = wxITALIC;
-            if (  traits & kCTFontBoldTrait )
-                m_weight = wxBOLD ;
-            if ( !m_ctFontDescriptor.get() )
-                m_ctFontDescriptor.reset( CTFontCopyFontDescriptor( m_ctFont ) );
-        }
-        else
-        {
-            if ( m_faceName.empty() )
-            {
-                switch ( m_family )
-                {
-                    case wxSCRIPT :
-                    case wxROMAN :
-                    case wxDECORATIVE :
-                        m_faceName = wxT("Times");
-                        break ;
-
-                    case wxSWISS :
-                        m_faceName =  wxT("Helvetica");
-                        break ;
-
-                    case wxMODERN :
-                    case wxTELETYPE:
-                        m_faceName =  wxT("Courier");
-                        break ;
-
-                    default:
-                        m_faceName =  wxT("Times");
-                        break ;
-                }
-            }
+        if (m_info.m_weight == wxFONTWEIGHT_BOLD)
+            traits |= kCTFontBoldTrait;
+        if (m_info.m_style == wxFONTSTYLE_ITALIC || m_info.m_style == wxFONTSTYLE_SLANT)
+            traits |= kCTFontItalicTrait;
 
 
-            
-            CTFontSymbolicTraits traits = 0;
-
-            if (m_weight == wxBOLD)
-                traits |= kCTFontBoldTrait;
-            if (m_style == wxITALIC || m_style == wxSLANT)
-                traits |= kCTFontItalicTrait;
-     
-// use font descriptor caching
-#if 0
-            wxString lookupname = wxString::Format( "%s_%ld", m_faceName.c_str(), traits );
-            
-            static std::map< std::wstring , wxCFRef< CTFontDescriptorRef > > fontdescriptorcache ;
-            
-            m_ctFontDescriptor = fontdescriptorcache[ std::wstring(lookupname.wc_str()) ];
-            if ( !m_ctFontDescriptor )
-            {
-                wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
-                m_ctFontDescriptor.reset( wxMacCreateCTFontDescriptor( cf, traits ) );
-                fontdescriptorcache[ std::wstring(lookupname.wc_str()) ] = m_ctFontDescriptor;
-            }
-#else
-            wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
-            m_ctFontDescriptor.reset( wxMacCreateCTFontDescriptor( cf, traits ) );
-#endif
-            
-// use font caching
-#if 0
-            wxString lookupnameWithSize = wxString::Format( "%s_%ld_%ld", m_faceName.c_str(), traits, m_pointSize );
-            
-            static std::map< std::wstring , wxCFRef< CTFontRef > > fontcache ;
-            m_ctFont = fontcache[ std::wstring(lookupnameWithSize.wc_str()) ];
-            if ( !m_ctFont )
-            {
-                m_ctFont.reset( CTFontCreateWithFontDescriptor( m_ctFontDescriptor, m_pointSize, NULL ) );
-                fontcache[ std::wstring(lookupnameWithSize.wc_str()) ] = m_ctFont;
-            }
-#else
-            m_ctFont.reset( CTFontCreateWithFontDescriptor( m_ctFontDescriptor, m_pointSize, NULL ) );
-#endif
-            if ( /* (CTFontGetSymbolicTraits( m_ctFont ) & 0x03) !=*/ traits )
-            {
-                CTFontRef font = CTFontCreateWithName( cf, m_pointSize,  NULL );
-                CTFontRef font2 = CTFontCreateCopyWithSymbolicTraits( font, m_pointSize, NULL, traits, 0x03 );
-                CFRelease(font);
-                m_ctFont.reset( font2 );
-                if ( (CTFontGetSymbolicTraits( m_ctFont ) & 0x03) != traits )
-                {
-                    wxMessageBox( wxString::Format( "expected %d but got %d traits" , traits, (CTFontGetSymbolicTraits( m_ctFont ) & 0x03) ) );
-                }
-            }
-        }
-#if wxOSX_USE_ATSU_TEXT
-        OSStatus status = noErr;
-        CTFontDescriptorRef desc = m_ctFontDescriptor ;
-        ATSFontRef atsfont = CTFontGetPlatformFont( m_ctFont, &desc );
-        FMFont fmfont = FMGetFontFromATSFontRef( atsfont );
-        ATSUAttributeTag atsuTags[] =
-        {
-            kATSUFontTag ,
-            kATSUSizeTag ,
-            kATSUVerticalCharacterTag,
-            kATSUQDBoldfaceTag ,
-            kATSUQDItalicTag ,
-            kATSUQDUnderlineTag ,
-        };
-        ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
-        {
-            sizeof( ATSUFontID ) ,
-            sizeof( Fixed ) ,
-            sizeof( ATSUVerticalCharacterType),
-            sizeof( Boolean ) ,
-            sizeof( Boolean ) ,
-            sizeof( Boolean ) ,
-        };
-        Boolean kTrue = true ;
-        Boolean kFalse = false ;
-
-        Fixed atsuSize = IntToFixed( m_pointSize );
-        ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
-        ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
-        {
-            &fmfont ,
-            &atsuSize ,
-            &kHorizontal,
-            (m_weight == wxBOLD) ? &kTrue : &kFalse ,
-            (m_style == wxITALIC || m_style == wxSLANT) ? &kTrue : &kFalse ,
-            (m_underlined) ? &kTrue : &kFalse ,
-        };
-
-        if ( m_macATSUStyle )
-        {
-            ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
-            m_macATSUStyle = NULL ;
-        }
-        status = ::ATSUCreateStyle((ATSUStyle *)&m_macATSUStyle);
-        wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
-        status = ::ATSUSetAttributes(
-                                     (ATSUStyle)m_macATSUStyle,
-                                     sizeof(atsuTags) / sizeof(ATSUAttributeTag) ,
-                                     atsuTags, atsuSizes, atsuValues);
-#endif
-    }
-#endif
-#if wxOSX_USE_ATSU_TEXT
-    {
-        OSStatus status = noErr;
-        Str255 qdFontName ;
-        if ( m_macThemeFontID != kThemeCurrentPortFont )
-        {
-            Style style ;
-            GetThemeFont( m_macThemeFontID, GetApplicationScript(), qdFontName, &m_macFontSize, &style );
-            if ( m_macFontSize == 0 )
-                m_macFontSize = 12;
-            m_macFontStyle = style ;
-            m_faceName = wxMacMakeStringFromPascal( qdFontName );
-            if ( m_macFontStyle & bold )
-                m_weight = wxBOLD ;
-            else
-                m_weight = wxNORMAL ;
-            if ( m_macFontStyle & italic )
-                m_style = wxITALIC ;
-            if ( m_macFontStyle & underline )
-                m_underlined = true ;
-            m_pointSize = m_macFontSize ;
-            m_macFontFamily = FMGetFontFamilyFromName( qdFontName );
-        }
-        else
+        // use font caching
+        wxString lookupnameWithSize = wxString::Format( "%s_%ld_%ld", m_info.m_faceName.c_str(), traits, m_info.m_pointSize );
+
+        static std::map< std::wstring , wxCFRef< CTFontRef > > fontcache ;
+        m_ctFont = fontcache[ std::wstring(lookupnameWithSize.wc_str()) ];
+        if ( !m_ctFont )
         {
         {
-            if ( m_faceName.empty() )
+            m_ctFont.reset(CTFontCreateWithName( wxCFStringRef(m_info.m_faceName), m_info.m_pointSize , NULL ));
+            if ( m_ctFont.get() == NULL )
             {
             {
-                if ( m_family == wxDEFAULT )
-                {
-                    m_macFontFamily = GetAppFont();
-                    FMGetFontFamilyName(m_macFontFamily,qdFontName);
-                    m_faceName = wxMacMakeStringFromPascal( qdFontName );
-                }
-                else
-                {
-                    switch ( m_family )
-                    {
-                        case wxSCRIPT :
-                        case wxROMAN :
-                        case wxDECORATIVE :
-                            m_faceName = wxT("Times");
-                            break ;
-
-                        case wxSWISS :
-                            m_faceName =  wxT("Helvetica");
-                            break ;
-
-                        case wxMODERN :
-                        case wxTELETYPE:
-                            m_faceName =  wxT("Courier");
-                            break ;
-
-                        default:
-                            m_faceName =  wxT("Times");
-                            break ;
-                    }
-                    wxMacStringToPascal( m_faceName , qdFontName );
-                    m_macFontFamily = FMGetFontFamilyFromName( qdFontName );
-                    if ( m_macFontFamily == kInvalidFontFamily )
-                    {
-                        wxLogDebug( wxT("ATSFontFamilyFindFromName failed for %s"), m_faceName.c_str() );
-                        m_macFontFamily = GetAppFont();
-                    }
-                }
+                // TODO try fallbacks according to font type
+                m_ctFont.reset(CTFontCreateUIFontForLanguage( kCTFontSystemFontType, m_info.m_pointSize , NULL ));
             }
             else
             {
             }
             else
             {
-                if ( m_faceName == wxT("systemfont") )
-                    m_macFontFamily = GetSysFont();
-                else if ( m_faceName == wxT("applicationfont") )
-                    m_macFontFamily = GetAppFont();
-                else
+                if ( traits != 0 )
                 {
                 {
-                    wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
-                    ATSFontFamilyRef atsfamily = ATSFontFamilyFindFromName( cf , kATSOptionFlagsDefault );
-                    if ( atsfamily == (ATSFontFamilyRef) -1 )
+                    // attempt native font variant, if not available, fallback to italic emulation mode and remove bold
+                    CTFontRef fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, NULL, traits, traits );
+                    if ( fontWithTraits == NULL )
                     {
                     {
-                        wxLogDebug( wxT("ATSFontFamilyFindFromName failed for ") + m_faceName );
-                        m_macFontFamily = GetAppFont();
+                        CTFontSymbolicTraits remainingTraits = traits;
+                        const CGAffineTransform* remainingTransform = NULL;
+                        
+                        if( remainingTraits & kCTFontItalicTrait )
+                        {
+                            remainingTraits &= ~kCTFontItalicTrait;
+                            remainingTransform = &kSlantTransform;
+                            if ( remainingTraits & kCTFontBoldTrait )
+                            {
+                                // first try an emulated oblique with an existing bold font
+                                fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, remainingTransform, remainingTraits, remainingTraits );
+                                if ( fontWithTraits == NULL )
+                                {
+                                    // give in on the bold, try native oblique
+                                    fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, NULL, kCTFontItalicTrait, kCTFontItalicTrait );
+                                }
+                            }
+                        }
+                        
+                        if ( fontWithTraits == NULL )
+                        {
+                            fontWithTraits = CTFontCreateWithName( wxCFStringRef(m_info.m_faceName), m_info.m_pointSize, remainingTransform );
+                        }
+                            
                     }
                     }
-                    else
-                        m_macFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
+                    if ( fontWithTraits != NULL )
+                        m_ctFont.reset(fontWithTraits);
                 }
             }
                 }
             }
-
-            m_macFontStyle = 0;
-            if (m_weight == wxBOLD)
-                m_macFontStyle |= bold;
-            if (m_style == wxITALIC || m_style == wxSLANT)
-                m_macFontStyle |= italic;
-            if (m_underlined)
-                m_macFontStyle |= underline;
-            m_macFontSize = m_pointSize ;
-        }
-
-        // we try to get as much styles as possible into ATSU
-
-
-        // ATSUFontID and FMFont are equivalent
-        FMFontStyle intrinsicStyle = 0 ;
-        status = FMGetFontFromFontFamilyInstance( m_macFontFamily , m_macFontStyle , &m_macATSUFontID , &intrinsicStyle);
-        wxASSERT_MSG( status == noErr , wxT("couldn't get an ATSUFont from font family") );
-        m_macATSUAdditionalQDStyles = m_macFontStyle & (~intrinsicStyle );
-
-        if ( m_macATSUStyle )
-        {
-            ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
-            m_macATSUStyle = NULL ;
         }
         }
-
-        status = ::ATSUCreateStyle((ATSUStyle *)&m_macATSUStyle);
-        wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
-
-        ATSUAttributeTag atsuTags[] =
-        {
-            kATSUFontTag ,
-            kATSUSizeTag ,
-            kATSUVerticalCharacterTag,
-            kATSUQDBoldfaceTag ,
-            kATSUQDItalicTag ,
-            kATSUQDUnderlineTag ,
-            kATSUQDCondensedTag ,
-            kATSUQDExtendedTag ,
-        };
-        ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
-        {
-            sizeof( ATSUFontID ) ,
-            sizeof( Fixed ) ,
-            sizeof( ATSUVerticalCharacterType),
-            sizeof( Boolean ) ,
-            sizeof( Boolean ) ,
-            sizeof( Boolean ) ,
-            sizeof( Boolean ) ,
-            sizeof( Boolean ) ,
-        };
-
-        Boolean kTrue = true ;
-        Boolean kFalse = false ;
-
-        Fixed atsuSize = IntToFixed( m_macFontSize );
-        ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
-        ATSUAttributeValuePtr    atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
-        {
-            &m_macATSUFontID ,
-            &atsuSize ,
-            &kHorizontal,
-            (m_macATSUAdditionalQDStyles & bold) ? &kTrue : &kFalse ,
-            (m_macATSUAdditionalQDStyles & italic) ? &kTrue : &kFalse ,
-            (m_macATSUAdditionalQDStyles & underline) ? &kTrue : &kFalse ,
-            (m_macATSUAdditionalQDStyles & condense) ? &kTrue : &kFalse ,
-            (m_macATSUAdditionalQDStyles & extend) ? &kTrue : &kFalse ,
-        };
-
-        status = ::ATSUSetAttributes(
-                                     (ATSUStyle)m_macATSUStyle,
-                                     sizeof(atsuTags) / sizeof(ATSUAttributeTag) ,
-                                     atsuTags, atsuSizes, atsuValues);
-
-        wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") );
-        return;
+        
+        m_cgFont.reset(CTFontCopyGraphicsFont(m_ctFont, NULL));
     }
     }
+
+#endif
+#if wxOSX_USE_ATSU_TEXT
+    CreateATSUFont();
 #endif
 #endif
+#if wxOSX_USE_COCOA
+    m_nsFont = wxFont::OSXCreateNSFont( &m_info );
+#endif
+#if wxOSX_USE_IPHONE
+    m_uiFont = wxFont::OSXCreateUIFont( &m_info );
+#endif
+    m_fontValid = true;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -683,9 +550,17 @@ void wxFontRefData::MacFindFont()
 
 bool wxFont::Create(const wxNativeFontInfo& info)
 {
 
 bool wxFont::Create(const wxNativeFontInfo& info)
 {
-    return Create(
-        info.pointSize, info.family, info.style, info.weight,
-        info.underlined, info.faceName, info.encoding );
+    UnRef();
+
+    m_refData = new wxFontRefData( info );
+    RealizeResource();
+
+    return true;
+}
+
+wxFont::wxFont(wxOSXSystemFont font)
+{
+    m_refData = new wxFontRefData( font, 0 );
 }
 
 wxFont::wxFont(const wxString& fontdesc)
 }
 
 wxFont::wxFont(const wxString& fontdesc)
@@ -696,76 +571,67 @@ wxFont::wxFont(const wxString& fontdesc)
 }
 
 bool wxFont::Create(int pointSize,
 }
 
 bool wxFont::Create(int pointSize,
-    int family,
-    int style,
-    int weight,
-    bool underlined,
-    const wxString& faceName,
-    wxFontEncoding encoding)
+                    wxFontFamily family,
+                    wxFontStyle style,
+                    wxFontWeight weight,
+                    bool underlined,
+                    const wxString& faceNameParam,
+                    wxFontEncoding encoding)
 {
     UnRef();
 
 {
     UnRef();
 
-    m_refData = new wxFontRefData(
-        pointSize, family, style, weight,
+    wxString faceName = faceNameParam;
+
+    if ( faceName.empty() )
+    {
+        switch ( family )
+        {
+            case wxFONTFAMILY_DEFAULT :
+                faceName = wxT("Lucida Grande");
+                break;
+
+            case wxFONTFAMILY_SCRIPT :
+            case wxFONTFAMILY_ROMAN :
+            case wxFONTFAMILY_DECORATIVE :
+                faceName = wxT("Times");
+                break ;
+
+            case wxFONTFAMILY_SWISS :
+                faceName =  wxT("Helvetica");
+                break ;
+
+            case wxFONTFAMILY_MODERN :
+            case wxFONTFAMILY_TELETYPE:
+                faceName =  wxT("Courier");
+                 break ;
+
+            default:
+                faceName =  wxT("Times");
+                break ;
+        }
+    }
+
+    wxNativeFontInfo info;
+
+    info.Init(pointSize, family, style, weight,
         underlined, faceName, encoding);
 
         underlined, faceName, encoding);
 
-    RealizeResource();
+    m_refData = new wxFontRefData(info);
 
     return true;
 }
 
 
     return true;
 }
 
-#if wxOSX_USE_CORE_TEXT
+wxFont::~wxFont()
+{
+}
 
 
-bool wxFont::MacCreateFromUIFont(wxUint32 ctFontType )
+void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info)
 {
     UnRef();
 
 {
     UnRef();
 
-    m_refData = new wxFontRefData(ctFontType);
-    RealizeResource();
-
-    return true;
-}
-
-bool wxFont::MacCreateFromCTFontDescriptor( const void * ctFontDescriptor , int size )
-{
-    UnRef();
-
-    m_refData = new wxFontRefData((CTFontDescriptorRef)ctFontDescriptor, size);;
-    RealizeResource();
-
-    return true;
-}
-
-
-#endif
-
-bool wxFont::MacCreateFromThemeFont(wxUint16 themeFontID)
-{
-#if wxOSX_USE_CORE_TEXT
-    if ( UMAGetSystemVersion() >= 0x1050)
-    {
-        return MacCreateFromUIFont(HIThemeGetUIFontType(themeFontID));
-    }
-#endif
-#if wxOSX_USE_ATSU_TEXT
-    {
-        UnRef();
-
-        m_refData = new wxFontRefData(
-                                      12, wxDEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL,
-                                      false, wxEmptyString, wxFONTENCODING_DEFAULT );
-
-        M_FONTDATA->m_macThemeFontID = themeFontID ;
-        RealizeResource();
-        return true;
-    }
-#endif
-    return false;
+    m_refData = new wxFontRefData( info);
 }
 
 }
 
-wxFont::~wxFont()
-{
-}
 
 bool wxFont::RealizeResource()
 {
 
 bool wxFont::RealizeResource()
 {
@@ -776,26 +642,9 @@ bool wxFont::RealizeResource()
 
 void wxFont::SetEncoding(wxFontEncoding encoding)
 {
 
 void wxFont::SetEncoding(wxFontEncoding encoding)
 {
-    Unshare();
+    AllocExclusive();
 
     M_FONTDATA->SetEncoding( encoding );
 
     M_FONTDATA->SetEncoding( encoding );
-
-    RealizeResource();
-}
-
-void wxFont::Unshare()
-{
-    // Don't change shared data
-    if (!m_refData)
-    {
-        m_refData = new wxFontRefData();
-    }
-    else
-    {
-        wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
-        UnRef();
-        m_refData = ref;
-    }
 }
 
 wxGDIRefData *wxFont::CreateGDIRefData() const
 }
 
 wxGDIRefData *wxFont::CreateGDIRefData() const
@@ -805,7 +654,7 @@ wxGDIRefData *wxFont::CreateGDIRefData() const
 
 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
 {
 
 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
 {
-    return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
+    return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
 }
 
 void wxFont::SetPointSize(int pointSize)
 }
 
 void wxFont::SetPointSize(int pointSize)
@@ -813,67 +662,46 @@ void wxFont::SetPointSize(int pointSize)
     if ( M_FONTDATA->GetPointSize() == pointSize )
         return;
 
     if ( M_FONTDATA->GetPointSize() == pointSize )
         return;
 
-    Unshare();
+    AllocExclusive();
 
     M_FONTDATA->SetPointSize( pointSize );
 
     M_FONTDATA->SetPointSize( pointSize );
-
-    RealizeResource();
 }
 
 }
 
-void wxFont::SetFamily(int family)
+void wxFont::SetFamily(wxFontFamily family)
 {
 {
-    Unshare();
+    AllocExclusive();
 
     M_FONTDATA->SetFamily( family );
 
     M_FONTDATA->SetFamily( family );
-
-    RealizeResource();
 }
 
 }
 
-void wxFont::SetStyle(int style)
+void wxFont::SetStyle(wxFontStyle style)
 {
 {
-    Unshare();
+    AllocExclusive();
 
     M_FONTDATA->SetStyle( style );
 
     M_FONTDATA->SetStyle( style );
-
-    RealizeResource();
 }
 
 }
 
-void wxFont::SetWeight(int weight)
+void wxFont::SetWeight(wxFontWeight weight)
 {
 {
-    Unshare();
+    AllocExclusive();
 
     M_FONTDATA->SetWeight( weight );
 
     M_FONTDATA->SetWeight( weight );
-
-    RealizeResource();
 }
 
 bool wxFont::SetFaceName(const wxString& faceName)
 {
 }
 
 bool wxFont::SetFaceName(const wxString& faceName)
 {
-    Unshare();
+    AllocExclusive();
 
     M_FONTDATA->SetFaceName( faceName );
 
 
     M_FONTDATA->SetFaceName( faceName );
 
-    RealizeResource();
-
     return wxFontBase::SetFaceName(faceName);
 }
 
 void wxFont::SetUnderlined(bool underlined)
 {
     return wxFontBase::SetFaceName(faceName);
 }
 
 void wxFont::SetUnderlined(bool underlined)
 {
-    Unshare();
+    AllocExclusive();
 
     M_FONTDATA->SetUnderlined( underlined );
 
     M_FONTDATA->SetUnderlined( underlined );
-
-    RealizeResource();
-}
-
-void wxFont::SetNoAntiAliasing( bool no )
-{
-    Unshare();
-
-    M_FONTDATA->SetNoAntiAliasing( no );
-
-    RealizeResource();
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -904,23 +732,23 @@ wxSize wxFont::GetPixelSize() const
 #endif
 }
 
 #endif
 }
 
-int wxFont::GetFamily() const
+wxFontFamily wxFont::GetFamily() const
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+    wxCHECK_MSG( M_FONTDATA != NULL , wxFONTFAMILY_MAX, wxT("invalid font") );
 
     return M_FONTDATA->GetFamily();
 }
 
 
     return M_FONTDATA->GetFamily();
 }
 
-int wxFont::GetStyle() const
+wxFontStyle wxFont::GetStyle() const
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+    wxCHECK_MSG( M_FONTDATA != NULL , wxFONTSTYLE_MAX, wxT("invalid font") );
 
     return M_FONTDATA->GetStyle() ;
 }
 
 
     return M_FONTDATA->GetStyle() ;
 }
 
-int wxFont::GetWeight() const
+wxFontWeight wxFont::GetWeight() const
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+    wxCHECK_MSG( M_FONTDATA != NULL , wxFONTWEIGHT_MAX, wxT("invalid font") );
 
     return M_FONTDATA->GetWeight();
 }
 
     return M_FONTDATA->GetWeight();
 }
@@ -946,91 +774,503 @@ wxFontEncoding wxFont::GetEncoding() const
     return M_FONTDATA->GetEncoding() ;
 }
 
     return M_FONTDATA->GetEncoding() ;
 }
 
-bool wxFont::GetNoAntiAliasing() const
+#if wxOSX_USE_ATSU_TEXT && wxOSX_USE_CARBON
+
+short wxFont::MacGetFontNum() const
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
+    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
 
-    return M_FONTDATA->GetNoAntiAliasing();
-}
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
 
 
-#if wxOSX_USE_ATSU_TEXT
+    return M_FONTDATA->m_info.m_qdFontFamily;
+}
 
 
-short wxFont::MacGetFontNum() const
+wxByte wxFont::MacGetFontStyle() const
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
-    return M_FONTDATA->m_macFontFamily;
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
+
+    return M_FONTDATA->m_info.m_qdFontStyle;
 }
 
 }
 
-short wxFont::MacGetFontSize() const
+wxUint16 wxFont::MacGetThemeFontID() const
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
-    return M_FONTDATA->m_macFontSize;
+    return M_FONTDATA->m_macThemeFontID;
 }
 
 }
 
-wxByte wxFont::MacGetFontStyle() const
+#endif
+
+#if wxOSX_USE_ATSU_TEXT
+void * wxFont::MacGetATSUStyle() const
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+    wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
+
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
 
 
-    return M_FONTDATA->m_macFontStyle;
+    return M_FONTDATA->m_macATSUStyle;
 }
 
 }
 
+#if WXWIN_COMPATIBILITY_2_8
 wxUint32 wxFont::MacGetATSUFontID() const
 {
 wxUint32 wxFont::MacGetATSUFontID() const
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+    wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
 
 
-    return M_FONTDATA->m_macATSUFontID;
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
+
+    return M_FONTDATA->m_info.m_atsuFontID;
 }
 
 wxUint32 wxFont::MacGetATSUAdditionalQDStyles() const
 }
 
 wxUint32 wxFont::MacGetATSUAdditionalQDStyles() const
+{
+    wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
+
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
+
+    return M_FONTDATA->m_info.m_atsuAdditionalQDStyles;
+}
+#endif
+
+#endif
+
+#if wxOSX_USE_CORE_TEXT
+
+CTFontRef wxFont::OSXGetCTFont() const
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
-    return M_FONTDATA->m_macATSUAdditionalQDStyles;
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
+
+    return (CTFontRef)(M_FONTDATA->m_ctFont);
 }
 
 }
 
-wxUint16 wxFont::MacGetThemeFontID() const
+#endif
+
+#if wxOSX_USE_COCOA_OR_CARBON
+
+CGFontRef wxFont::OSXGetCGFont() const
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
 {
     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 
-    return M_FONTDATA->m_macThemeFontID;
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
+
+    return (M_FONTDATA->m_cgFont);
 }
 }
+
 #endif
 
 #endif
 
-#if wxOSX_USE_CORE_TEXT || wxOSX_USE_ATSU_TEXT
-void * wxFont::MacGetATSUStyle() const
+
+#if wxOSX_USE_COCOA
+
+NSFont* wxFont::OSXGetNSFont() const
+{
+    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
+
+    return (M_FONTDATA->m_nsFont);
+}
+
+#endif
+
+const wxNativeFontInfo * wxFont::GetNativeFontInfo() const
 {
     wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
 {
     wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
+    wxCHECK_MSG( Ok(), NULL, wxT("invalid font") );
 
 
-    return M_FONTDATA->m_macATSUStyle;
+    // cast away constness otherwise lazy font resolution is not possible
+    const_cast<wxFont *>(this)->RealizeResource();
+
+    // M_FONTDATA->m_info.InitFromFont(*this);
+
+    return &(M_FONTDATA->m_info);
 }
 }
+
+// ----------------------------------------------------------------------------
+// wxNativeFontInfo
+// ----------------------------------------------------------------------------
+
+#if 0 // wxOSX_USE_CORE_TEXT
+
+/* from Core Text Manual Common Operations */
+
+static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
+{
+    CTFontDescriptorRef descriptor = NULL;
+    CFMutableDictionaryRef attributes;
+
+    wxASSERT(iFamilyName != NULL);
+    // Create a mutable dictionary to hold our attributes.
+    attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                           &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+    wxASSERT(attributes != NULL);
+
+    if (attributes != NULL) {
+        // Add a family name to our attributes.
+        CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
+
+
+        if ( iTraits ) {
+            CFMutableDictionaryRef traits;
+            CFNumberRef symTraits;
+
+            // Create the traits dictionary.
+            symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
+                                       &iTraits);
+            wxASSERT(symTraits != NULL);
+
+            if (symTraits != NULL) {
+                // Create a dictionary to hold our traits values.
+                traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                                   &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+                wxASSERT(traits != NULL);
+
+                if (traits != NULL) {
+                    // Add the symbolic traits value to the traits dictionary.
+                    CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
+
+                    // Add the traits attribute to our attributes.
+                    CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
+                    CFRelease(traits);
+                }
+                CFRelease(symTraits);
+            }
+        }
+        // Create the font descriptor with our attributes
+        descriptor = CTFontDescriptorCreateWithAttributes(attributes);
+        wxASSERT(descriptor != NULL);
+
+        CFRelease(attributes);
+    }
+    // Return our font descriptor.
+    return descriptor ;
+}
+
+#endif
+
+void wxNativeFontInfo::Init()
+{
+#if wxOSX_USE_ATSU_TEXT
+    m_atsuFontID = 0 ;
+    m_atsuAdditionalQDStyles = 0;
+    m_atsuFontValid = false;
+#if wxOSX_USE_CARBON
+    m_qdFontStyle = 0;
+    m_qdFontFamily = 0;
+#endif
 #endif
 #endif
+    m_pointSize = 0;
+    m_family = wxFONTFAMILY_DEFAULT;
+    m_style = wxFONTSTYLE_NORMAL;
+    m_weight = wxFONTWEIGHT_NORMAL;
+    m_underlined = false;
+    m_faceName.clear();
+    m_encoding = wxFont::GetDefaultEncoding();
+    m_descriptorValid = false;
+}
 
 #if wxOSX_USE_CORE_TEXT
 
 #if wxOSX_USE_CORE_TEXT
+void wxNativeFontInfo::Init(CTFontDescriptorRef descr)
+{
+    Init();
+
+    wxCFRef< CFNumberRef > sizevalue( (CFNumberRef) CTFontDescriptorCopyAttribute( descr, kCTFontSizeAttribute ) );
+    float fsize;
+    if ( CFNumberGetValue( sizevalue , kCFNumberFloatType , &fsize ) )
+        m_pointSize = (int)( fsize + 0.5 );
 
 
-const void * wxFont::MacGetCTFont() const
+    wxCFRef< CFDictionaryRef > traitsvalue( (CFDictionaryRef) CTFontDescriptorCopyAttribute( descr, kCTFontTraitsAttribute ) );
+    CTFontSymbolicTraits traits;
+    if ( CFNumberGetValue((CFNumberRef) CFDictionaryGetValue(traitsvalue,kCTFontSymbolicTrait),kCFNumberIntType,&traits) )
+    {
+        if ( traits & kCTFontItalicTrait )
+            m_style = wxFONTSTYLE_ITALIC;
+        if (  traits & kCTFontBoldTrait )
+            m_weight = wxFONTWEIGHT_BOLD ;
+    }
+
+    wxCFStringRef familyName( (CFStringRef) CTFontDescriptorCopyAttribute(descr, kCTFontFamilyNameAttribute));
+    m_faceName = familyName.AsString();
+}
+#endif
+
+void wxNativeFontInfo::EnsureValid()
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+    if ( m_descriptorValid )
+        return;
 
 
-    return (CTFontRef)(M_FONTDATA->m_ctFont);
+#if wxOSX_USE_ATSU_TEXT
+    if ( !m_atsuFontValid )
+    {
+#if !wxOSX_USE_CARBON
+        // not needed outside
+        wxInt16 m_qdFontFamily;
+        wxInt16 m_qdFontStyle;
+#endif
+        wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
+        ATSFontFamilyRef atsfamily = ATSFontFamilyFindFromName( cf , kATSOptionFlagsDefault );
+        if ( atsfamily == (ATSFontFamilyRef) -1 )
+        {
+            wxLogDebug( wxT("ATSFontFamilyFindFromName failed for ") + m_faceName );
+            m_qdFontFamily = GetAppFont();
+        }
+        else
+        {
+            m_qdFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
+        }
+
+        m_qdFontStyle = 0;
+        if (m_weight == wxFONTWEIGHT_BOLD)
+            m_qdFontStyle |= bold;
+        if (m_style == wxFONTSTYLE_ITALIC || m_style == wxFONTSTYLE_SLANT)
+            m_qdFontStyle |= italic;
+        if (m_underlined)
+            m_qdFontStyle |= underline;
+
+
+        // we try to get as much styles as possible into ATSU
+
+        // ATSUFontID and FMFont are equivalent
+        FMFontStyle intrinsicStyle = 0 ;
+        OSStatus status = FMGetFontFromFontFamilyInstance( m_qdFontFamily , m_qdFontStyle , (FMFont*)&m_atsuFontID , &intrinsicStyle);
+        if ( status != noErr )
+        {
+            wxFAIL_MSG( wxT("couldn't get an ATSUFont from font family") );
+        }
+        m_atsuAdditionalQDStyles = m_qdFontStyle & (~intrinsicStyle );
+        m_atsuFontValid = true;
+    }
+#endif
+    m_descriptorValid = true;
 }
 
 }
 
-const void * wxFont::MacGetCTFontDescriptor() const
+void wxNativeFontInfo::Init(const wxNativeFontInfo& info)
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
+    Init();
+#if wxOSX_USE_ATSU_TEXT
+    m_atsuFontValid = info.m_atsuFontValid;
+    m_atsuFontID = info.m_atsuFontID ;
+    m_atsuAdditionalQDStyles = info.m_atsuAdditionalQDStyles;
+#if wxOSX_USE_CARBON
+    m_qdFontFamily = info.m_qdFontFamily;
+    m_qdFontStyle = info.m_qdFontStyle;
+#endif
+#endif
+    m_pointSize = info.m_pointSize;
+    m_family = info.m_family;
+    m_style = info.m_style;
+    m_weight = info.m_weight;
+    m_underlined = info.m_underlined;
+    m_faceName = info.m_faceName;
+    m_encoding = info.m_encoding;
+    m_descriptorValid = info.m_descriptorValid;
+}
+
+void wxNativeFontInfo::Init(int size,
+                  wxFontFamily family,
+                  wxFontStyle style,
+                  wxFontWeight weight,
+                  bool underlined,
+                  const wxString& faceName,
+                  wxFontEncoding encoding)
+{
+    Init();
+    m_pointSize = size;
+    m_family = family;
+    m_style = style;
+    m_weight = weight;
+    m_underlined = underlined;
+    m_faceName = faceName;
+    if ( encoding == wxFONTENCODING_DEFAULT )
+        encoding = wxFont::GetDefaultEncoding();
+    m_encoding = encoding;
 
 
-    return (CTFontDescriptorRef)(M_FONTDATA->m_ctFontDescriptor);
 }
 
 }
 
+void wxNativeFontInfo::Free()
+{
+#if wxOSX_USE_ATSU_TEXT
+    m_atsuFontID = 0 ;
+    m_atsuAdditionalQDStyles = 0;
+    m_atsuFontValid = false;
 #endif
 #endif
+    m_descriptorValid = false;
+}
 
 
-const wxNativeFontInfo * wxFont::GetNativeFontInfo() const
+bool wxNativeFontInfo::FromString(const wxString& s)
 {
 {
-    wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
-    wxCHECK_MSG( Ok(), NULL, wxT("invalid font") );
+    long l;
 
 
-    M_FONTDATA->m_info.InitFromFont(*this);
+    wxStringTokenizer tokenizer(s, wxT(";"));
 
 
-    return &(M_FONTDATA->m_info);
+    wxString token = tokenizer.GetNextToken();
+    //
+    //  Ignore the version for now
+    //
+
+    token = tokenizer.GetNextToken();
+    if ( !token.ToLong(&l) )
+        return false;
+    m_pointSize = (int)l;
+
+    token = tokenizer.GetNextToken();
+    if ( !token.ToLong(&l) )
+        return false;
+    m_family = (wxFontFamily)l;
+
+    token = tokenizer.GetNextToken();
+    if ( !token.ToLong(&l) )
+        return false;
+    m_style = (wxFontStyle)l;
+
+    token = tokenizer.GetNextToken();
+    if ( !token.ToLong(&l) )
+        return false;
+    m_weight = (wxFontWeight)l;
+
+    token = tokenizer.GetNextToken();
+    if ( !token.ToLong(&l) )
+        return false;
+    m_underlined = l != 0;
+
+    m_faceName = tokenizer.GetNextToken();
+
+#ifndef __WXMAC__
+    if( !faceName )
+        return false;
+#endif
+
+    token = tokenizer.GetNextToken();
+    if ( !token.ToLong(&l) )
+        return false;
+    m_encoding = (wxFontEncoding)l;
+
+    return true;
+}
+
+wxString wxNativeFontInfo::ToString() const
+{
+    wxString s;
+
+    s.Printf(wxT("%d;%d;%d;%d;%d;%d;%s;%d"),
+             0,                                 // version
+             m_pointSize,
+             m_family,
+             (int)m_style,
+             (int)m_weight,
+             m_underlined,
+             m_faceName.GetData(),
+             (int)m_encoding);
+
+    return s;
+}
+
+int wxNativeFontInfo::GetPointSize() const
+{
+    return m_pointSize;
+}
+
+wxFontStyle wxNativeFontInfo::GetStyle() const
+{
+    return m_style;
+}
+
+wxFontWeight wxNativeFontInfo::GetWeight() const
+{
+    return m_weight;
+}
+
+bool wxNativeFontInfo::GetUnderlined() const
+{
+    return m_underlined;
+}
+
+wxString wxNativeFontInfo::GetFaceName() const
+{
+    return m_faceName;
+}
+
+wxFontFamily wxNativeFontInfo::GetFamily() const
+{
+    return m_family;
+}
+
+wxFontEncoding wxNativeFontInfo::GetEncoding() const
+{
+    return m_encoding;
+}
+
+// changing the font descriptor
+
+void wxNativeFontInfo::SetPointSize(int pointsize)
+{
+    if ( m_pointSize != pointsize )
+    {
+        m_pointSize = pointsize;
+        Free();
+    }
+}
+
+void wxNativeFontInfo::SetStyle(wxFontStyle style_)
+{
+    if ( m_style != style_ )
+    {
+        m_style = style_;
+        Free();
+    }
+}
+
+void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
+{
+    if ( m_weight != weight_ )
+    {
+        m_weight = weight_;
+        Free();
+    }
+}
+
+void wxNativeFontInfo::SetUnderlined(bool underlined_)
+{
+    if ( m_underlined != underlined_ )
+    {
+        m_underlined = underlined_;
+        Free();
+    }
+}
+
+bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
+{
+    if ( m_faceName != facename_ )
+    {
+        m_faceName = facename_;
+        Free();
+    }
+    return true;
+}
+
+void wxNativeFontInfo::SetFamily(wxFontFamily family_)
+{
+    if ( m_family != family_ )
+    {
+        m_family = family_;
+        Free();
+    }
+}
+
+void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
+{
+    if ( encoding_ == wxFONTENCODING_DEFAULT )
+        encoding_ = wxFont::GetDefaultEncoding();
+    m_encoding = encoding_;
+    // not reflected in native descriptors
 }
 }
wxWidgets (Impactor)