Don't use "Cancel" button in the about dialog of the listctrl sample.

[wxWidgets.git] / src / common / fontcmn.cpp

diff --git a/src/common/fontcmn.cpp b/src/common/fontcmn.cpp
index b10870a927fc15f077d8508417f845b24c94a29f..52936bfbe16e094a8499ffeb7ff3a0befe2475b9 100644 (file)
--- a/src/common/fontcmn.cpp
+++ b/src/common/fontcmn.cpp
@@ -29,6 +29,7 @@
 #ifndef WX_PRECOMP
     #include "wx/dc.h"
     #include "wx/intl.h"
 #ifndef WX_PRECOMP
     #include "wx/dc.h"
     #include "wx/intl.h"

+    #include "wx/math.h"

     #include "wx/dcscreen.h"
     #include "wx/log.h"
     #include "wx/gdicmn.h"
     #include "wx/dcscreen.h"
     #include "wx/log.h"
     #include "wx/gdicmn.h"


@@ -57,13 +58,13 @@ extern const char *wxDumpFont(const wxFont *font)
     s.Printf(wxS("%s-%s-%s-%d-%d"),
              font->GetFaceName(),
              weight == wxFONTWEIGHT_NORMAL
     s.Printf(wxS("%s-%s-%s-%d-%d"),
              font->GetFaceName(),
              weight == wxFONTWEIGHT_NORMAL

-                ? _T("normal")
+                ? wxT("normal")

                 : weight == wxFONTWEIGHT_BOLD
                 : weight == wxFONTWEIGHT_BOLD

-                    ? _T("bold")
-                    : _T("light"),
+                    ? wxT("bold")
+                    : wxT("light"),

              font->GetStyle() == wxFONTSTYLE_NORMAL
              font->GetStyle() == wxFONTSTYLE_NORMAL

-                ? _T("regular")
-                : _T("italic"),
+                ? wxT("regular")
+                : wxT("italic"),

              font->GetPointSize(),
              font->GetEncoding());
 
              font->GetPointSize(),
              font->GetEncoding());
 


@@ -71,36 +72,63 @@ extern const char *wxDumpFont(const wxFont *font)
     return buf;
 }
 
     return buf;
 }
 

-// ============================================================================
-// implementation
-// ============================================================================
-

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-// helper functions
+// XTI

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-static inline int flags2Style(int flags)
-{
-    return flags & wxFONTFLAG_ITALIC
-                    ? wxFONTSTYLE_ITALIC
-                    : flags & wxFONTFLAG_SLANT
-                        ? wxFONTSTYLE_SLANT
-                        : wxFONTSTYLE_NORMAL;
-}
-
-static inline int flags2Weight(int flags)
-{
-    return flags & wxFONTFLAG_LIGHT
-                    ? wxFONTWEIGHT_LIGHT
-                    : flags & wxFONTFLAG_BOLD
-                        ? wxFONTWEIGHT_BOLD
-                        : wxFONTWEIGHT_NORMAL;
-}
+wxBEGIN_ENUM( wxFontFamily )
+wxENUM_MEMBER( wxFONTFAMILY_DEFAULT )
+wxENUM_MEMBER( wxFONTFAMILY_DECORATIVE )
+wxENUM_MEMBER( wxFONTFAMILY_ROMAN )
+wxENUM_MEMBER( wxFONTFAMILY_SCRIPT )
+wxENUM_MEMBER( wxFONTFAMILY_SWISS )
+wxENUM_MEMBER( wxFONTFAMILY_MODERN )
+wxENUM_MEMBER( wxFONTFAMILY_TELETYPE )
+wxEND_ENUM( wxFontFamily )
+
+wxBEGIN_ENUM( wxFontStyle )
+wxENUM_MEMBER( wxFONTSTYLE_NORMAL )
+wxENUM_MEMBER( wxFONTSTYLE_ITALIC )
+wxENUM_MEMBER( wxFONTSTYLE_SLANT )
+wxEND_ENUM( wxFontStyle )
+
+wxBEGIN_ENUM( wxFontWeight )
+wxENUM_MEMBER( wxFONTWEIGHT_NORMAL )
+wxENUM_MEMBER( wxFONTWEIGHT_LIGHT )
+wxENUM_MEMBER( wxFONTWEIGHT_BOLD )
+wxEND_ENUM( wxFontWeight )
+
+wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI(wxFont, wxGDIObject, "wx/font.h")
+
+//WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxFont>)
+
+wxBEGIN_PROPERTIES_TABLE(wxFont)
+wxPROPERTY( Size,int, SetPointSize, GetPointSize, 12, 0 /*flags*/, \
+           wxT("Helpstring"), wxT("group"))
+wxPROPERTY( Family, wxFontFamily , SetFamily, GetFamily, (wxFontFamily)wxDEFAULT, \
+           0 /*flags*/, wxT("Helpstring"), wxT("group")) // wxFontFamily
+wxPROPERTY( Style, wxFontStyle, SetStyle, GetStyle, (wxFontStyle)wxNORMAL, 0 /*flags*/, \
+           wxT("Helpstring"), wxT("group")) // wxFontStyle
+wxPROPERTY( Weight, wxFontWeight, SetWeight, GetWeight, (wxFontWeight)wxNORMAL, 0 /*flags*/, \
+           wxT("Helpstring"), wxT("group")) // wxFontWeight
+wxPROPERTY( Underlined, bool, SetUnderlined, GetUnderlined, false, 0 /*flags*/, \
+           wxT("Helpstring"), wxT("group"))
+wxPROPERTY( Strikethrough, bool, SetStrikethrough, GetStrikethrough, false, 0, \
+                   wxT("Helpstring"), wxT("group"))
+wxPROPERTY( Face, wxString, SetFaceName, GetFaceName, wxEMPTY_PARAMETER_VALUE, \
+           0 /*flags*/, wxT("Helpstring"), wxT("group"))
+wxPROPERTY( Encoding, wxFontEncoding, SetEncoding, GetEncoding, \
+           wxFONTENCODING_DEFAULT, 0 /*flags*/, wxT("Helpstring"), wxT("group"))
+wxEND_PROPERTIES_TABLE()
+
+wxCONSTRUCTOR_6( wxFont, int, Size, wxFontFamily, Family, wxFontStyle, Style, wxFontWeight, Weight, \
+                bool, Underlined, wxString, Face )
+
+wxEMPTY_HANDLERS_TABLE(wxFont)

 
 

-static inline bool flags2Underlined(int flags)
-{
-    return (flags & wxFONTFLAG_UNDERLINED) != 0;
-}
+// ============================================================================
+// implementation
+// ============================================================================

 
 // ----------------------------------------------------------------------------
 // wxFontBase
 
 // ----------------------------------------------------------------------------
 // wxFontBase


@@ -114,7 +142,7 @@ void wxFontBase::SetDefaultEncoding(wxFontEncoding encoding)
     // GetDefaultEncoding() should return something != wxFONTENCODING_DEFAULT
     // and, besides, using this value here doesn't make any sense
     wxCHECK_RET( encoding != wxFONTENCODING_DEFAULT,
     // GetDefaultEncoding() should return something != wxFONTENCODING_DEFAULT
     // and, besides, using this value here doesn't make any sense
     wxCHECK_RET( encoding != wxFONTENCODING_DEFAULT,

-                 _T("can't set default encoding to wxFONTENCODING_DEFAULT") );
+                 wxT("can't set default encoding to wxFONTENCODING_DEFAULT") );

 
     ms_encodingDefault = encoding;
 }
 
     ms_encodingDefault = encoding;
 }


@@ -156,8 +184,11 @@ wxFont *wxFontBase::New(int pointSize,
                         const wxString& face,
                         wxFontEncoding encoding)
 {
                         const wxString& face,
                         wxFontEncoding encoding)
 {

-    return New(pointSize, family, flags2Style(flags), flags2Weight(flags),
-               flags2Underlined(flags), face, encoding);
+    return New(pointSize, family,
+               GetStyleFromFlags(flags),
+               GetWeightFromFlags(flags),
+               GetUnderlinedFromFlags(flags),
+               face, encoding);

 }
 
 /* static */
 }
 
 /* static */


@@ -167,8 +198,11 @@ wxFont *wxFontBase::New(const wxSize& pixelSize,
                         const wxString& face,
                         wxFontEncoding encoding)
 {
                         const wxString& face,
                         wxFontEncoding encoding)
 {

-    return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
-               flags2Underlined(flags), face, encoding);
+    return New(pixelSize, family,
+               GetStyleFromFlags(flags),
+               GetWeightFromFlags(flags),
+               GetUnderlinedFromFlags(flags),
+               face, encoding);

 }
 
 /* static */
 }
 
 /* static */


@@ -214,7 +248,7 @@ void wxFontBase::SetPixelSize( const wxSize& pixelSize )
     // NOTE: this algorithm for adjusting the font size is used by all
     //       implementations of wxFont except under wxMSW and wxGTK where
     //       native support to font creation using pixel-size is provided.
     // NOTE: this algorithm for adjusting the font size is used by all
     //       implementations of wxFont except under wxMSW and wxGTK where
     //       native support to font creation using pixel-size is provided.

-    
+

     int largestGood = 0;
     int smallestBad = 0;
 
     int largestGood = 0;
     int smallestBad = 0;
 


@@ -275,6 +309,7 @@ void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
     SetStyle(info.style);
     SetWeight(info.weight);
     SetUnderlined(info.underlined);
     SetStyle(info.style);
     SetWeight(info.weight);
     SetUnderlined(info.underlined);

+    SetStrikethrough(info.strikethrough);

     SetFaceName(info.faceName);
     SetEncoding(info.encoding);
 #else
     SetFaceName(info.faceName);
     SetEncoding(info.encoding);
 #else


@@ -284,6 +319,8 @@ void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
 
 wxString wxFontBase::GetNativeFontInfoDesc() const
 {
 
 wxString wxFontBase::GetNativeFontInfoDesc() const
 {

+    wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
+

     wxString fontDesc;
     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
     if ( fontInfo )
     wxString fontDesc;
     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
     if ( fontInfo )


@@ -301,6 +338,8 @@ wxString wxFontBase::GetNativeFontInfoDesc() const
 
 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 {
 
 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 {

+    wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
+

     wxString fontDesc;
     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
     if ( fontInfo )
     wxString fontDesc;
     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
     if ( fontInfo )


@@ -358,11 +397,26 @@ bool wxFontBase::operator==(const wxFont& font) const
             GetStyle() == font.GetStyle() &&
             GetWeight() == font.GetWeight() &&
             GetUnderlined() == font.GetUnderlined() &&
             GetStyle() == font.GetStyle() &&
             GetWeight() == font.GetWeight() &&
             GetUnderlined() == font.GetUnderlined() &&

+            GetStrikethrough() == font.GetStrikethrough() &&

             GetFaceName().IsSameAs(font.GetFaceName(), false) &&
             GetEncoding() == font.GetEncoding()
            );
 }
 
             GetFaceName().IsSameAs(font.GetFaceName(), false) &&
             GetEncoding() == font.GetEncoding()
            );
 }
 

+wxFontFamily wxFontBase::GetFamily() const
+{
+    wxCHECK_MSG( IsOk(), wxFONTFAMILY_UNKNOWN, wxS("invalid font") );
+
+    // Don't return wxFONTFAMILY_UNKNOWN from here because it prevents the code
+    // like wxFont(size, wxNORMAL_FONT->GetFamily(), ...) from working (see
+    // #12330). This is really just a hack but it allows to keep compatibility
+    // and doesn't really have any bad drawbacks so do this until someone comes
+    // up with a better idea.
+    const wxFontFamily family = DoGetFamily();
+
+    return family == wxFONTFAMILY_UNKNOWN ? wxFONTFAMILY_DEFAULT : family;
+}
+

 wxString wxFontBase::GetFamilyString() const
 {
     wxCHECK_MSG( IsOk(), "wxFONTFAMILY_DEFAULT", "invalid font" );
 wxString wxFontBase::GetFamilyString() const
 {
     wxCHECK_MSG( IsOk(), "wxFONTFAMILY_DEFAULT", "invalid font" );


@@ -421,6 +475,93 @@ bool wxFontBase::SetFaceName(const wxString& facename)
     return true;
 }
 
     return true;
 }
 

+void wxFontBase::SetSymbolicSize(wxFontSymbolicSize size)
+{
+    SetSymbolicSizeRelativeTo(size, wxNORMAL_FONT->GetPointSize());
+}
+
+/* static */
+int wxFontBase::AdjustToSymbolicSize(wxFontSymbolicSize size, int base)
+{
+    // Using a fixed factor (1.2, from CSS2) is a bad idea as explained at
+    // http://www.w3.org/TR/CSS21/fonts.html#font-size-props so use the values
+    // from http://style.cleverchimp.com/font_size_intervals/altintervals.html
+    // instead.
+    static const float factors[] = { 0.60f, 0.75f, 0.89f, 1.f, 1.2f, 1.5f, 2.f };
+
+    wxCOMPILE_TIME_ASSERT
+    (
+        WXSIZEOF(factors) == wxFONTSIZE_XX_LARGE - wxFONTSIZE_XX_SMALL + 1,
+        WrongFontSizeFactorsSize
+    );
+
+    return wxRound(factors[size - wxFONTSIZE_XX_SMALL]*base);
+}
+
+wxFont& wxFont::MakeBold()
+{
+    SetWeight(wxFONTWEIGHT_BOLD);
+    return *this;
+}
+
+wxFont wxFont::Bold() const
+{
+    wxFont font(*this);
+    font.MakeBold();
+    return font;
+}
+
+wxFont& wxFont::MakeItalic()
+{
+    SetStyle(wxFONTSTYLE_ITALIC);
+    return *this;
+}
+
+wxFont wxFont::Italic() const
+{
+    wxFont font(*this);
+    font.MakeItalic();
+    return font;
+}
+
+wxFont& wxFont::MakeUnderlined()
+{
+    SetUnderlined(true);
+    return *this;
+}
+
+wxFont wxFont::Underlined() const
+{
+    wxFont font(*this);
+    font.MakeUnderlined();
+    return font;
+}
+
+wxFont wxFont::Strikethrough() const
+{
+    wxFont font(*this);
+    font.MakeStrikethrough();
+    return font;
+}
+
+wxFont& wxFont::MakeStrikethrough()
+{
+    SetStrikethrough(true);
+    return *this;
+}
+
+wxFont& wxFont::Scale(float x)
+{
+    SetPointSize(int(x*GetPointSize() + 0.5));
+    return *this;
+}
+
+wxFont wxFont::Scaled(float x) const
+{
+    wxFont font(*this);
+    font.Scale(x);
+    return font;
+}

 
 // ----------------------------------------------------------------------------
 // wxNativeFontInfo
 
 // ----------------------------------------------------------------------------
 // wxNativeFontInfo


@@ -453,19 +594,22 @@ void wxNativeFontInfo::SetFaceName(const wxArrayString& facenames)
 
 // These are the generic forms of FromString()/ToString.
 //
 
 // These are the generic forms of FromString()/ToString.
 //

-// convert to/from the string representation: format is
-//      version;pointsize;family;style;weight;underlined;facename;encoding
+// convert to/from the string representation: the general format is
+// "version;the rest..." with currently defined versions being:
+//
+//      0;pointsize;family;style;weight;underlined;facename;encoding
+//      1;pointsize;family;style;weight;underlined;strikethrough;facename;encoding

 
 bool wxNativeFontInfo::FromString(const wxString& s)
 {
     long l;
 
 bool wxNativeFontInfo::FromString(const wxString& s)
 {
     long l;

+    unsigned long version;

 
 

-    wxStringTokenizer tokenizer(s, _T(";"));
+    wxStringTokenizer tokenizer(s, wxT(";"));

 
     wxString token = tokenizer.GetNextToken();
 
     wxString token = tokenizer.GetNextToken();

-    //
-    //  Ignore the version for now
-    //
+    if ( !token.ToULong(&version) || version > 1 )
+        return false;

 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )


@@ -492,6 +636,14 @@ bool wxNativeFontInfo::FromString(const wxString& s)
         return false;
     underlined = l != 0;
 
         return false;
     underlined = l != 0;
 

+    if ( version == 1 )
+    {
+        token = tokenizer.GetNextToken();
+        if ( !token.ToLong(&l) )
+            return false;
+        strikethrough = l != 0;
+    }
+

     faceName = tokenizer.GetNextToken();
 
 #ifndef __WXMAC__
     faceName = tokenizer.GetNextToken();
 
 #ifndef __WXMAC__


@@ -511,13 +663,14 @@ wxString wxNativeFontInfo::ToString() const
 {
     wxString s;
 
 {
     wxString s;
 

-    s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
-             0,                                 // version
+    s.Printf(wxT("%d;%d;%d;%d;%d;%d;%d;%s;%d"),
+             1,                                 // version

              pointSize,
              family,
              (int)style,
              (int)weight,
              underlined,
              pointSize,
              family,
              (int)style,
              (int)weight,
              underlined,

+             strikethrough,

              faceName.GetData(),
              (int)encoding);
 
              faceName.GetData(),
              (int)encoding);
 


@@ -531,6 +684,7 @@ void wxNativeFontInfo::Init()
     style = wxFONTSTYLE_NORMAL;
     weight = wxFONTWEIGHT_NORMAL;
     underlined = false;
     style = wxFONTSTYLE_NORMAL;
     weight = wxFONTWEIGHT_NORMAL;
     underlined = false;

+    strikethrough = false;

     faceName.clear();
     encoding = wxFONTENCODING_DEFAULT;
 }
     faceName.clear();
     encoding = wxFONTENCODING_DEFAULT;
 }


@@ -555,6 +709,11 @@ bool wxNativeFontInfo::GetUnderlined() const
     return underlined;
 }
 
     return underlined;
 }
 

+bool wxNativeFontInfo::GetStrikethrough() const
+{
+    return strikethrough;
+}
+

 wxString wxNativeFontInfo::GetFaceName() const
 {
     return faceName;
 wxString wxNativeFontInfo::GetFaceName() const
 {
     return faceName;


@@ -590,6 +749,11 @@ void wxNativeFontInfo::SetUnderlined(bool underlined_)
     underlined = underlined_;
 }
 
     underlined = underlined_;
 }
 

+void wxNativeFontInfo::SetStrikethrough(bool strikethrough_)
+{
+    strikethrough = strikethrough_;
+}
+

 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
 {
     faceName = facename_;
 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
 {
     faceName = facename_;


@@ -626,10 +790,15 @@ wxString wxNativeFontInfo::ToUserString() const
         desc << _("underlined");
     }
 
         desc << _("underlined");
     }
 

+    if ( GetStrikethrough() )
+    {
+        desc << _("strikethrough");
+    }
+

     switch ( GetWeight() )
     {
         default:
     switch ( GetWeight() )
     {
         default:

-            wxFAIL_MSG( _T("unknown font weight") );
+            wxFAIL_MSG( wxT("unknown font weight") );

             // fall through
 
         case wxFONTWEIGHT_NORMAL:
             // fall through
 
         case wxFONTWEIGHT_NORMAL:


@@ -647,7 +816,7 @@ wxString wxNativeFontInfo::ToUserString() const
     switch ( GetStyle() )
     {
         default:
     switch ( GetStyle() )
     {
         default:

-            wxFAIL_MSG( _T("unknown font style") );
+            wxFAIL_MSG( wxT("unknown font style") );

             // fall through
 
         case wxFONTSTYLE_NORMAL:
             // fall through
 
         case wxFONTSTYLE_NORMAL:


@@ -673,23 +842,64 @@ wxString wxNativeFontInfo::ToUserString() const
             // that the different words which compose this facename are
             // not different adjectives or other data but rather all parts
             // of the facename
             // that the different words which compose this facename are
             // not different adjectives or other data but rather all parts
             // of the facename

-            desc << _T(" '") << face << _("'");
+            desc << wxT(" '") << face << _("'");

         }
         else
         }
         else

-            desc << _T(' ') << face;
+            desc << wxT(' ') << face;
+    }
+    else // no face name specified
+    {
+        // use the family
+        wxString familyStr;
+        switch ( GetFamily() )
+        {
+            case wxFONTFAMILY_DECORATIVE:
+                familyStr = "decorative";
+                break;
+
+            case wxFONTFAMILY_ROMAN:
+                familyStr = "roman";
+                break;
+
+            case wxFONTFAMILY_SCRIPT:
+                familyStr = "script";
+                break;
+
+            case wxFONTFAMILY_SWISS:
+                familyStr = "swiss";
+                break;
+
+            case wxFONTFAMILY_MODERN:
+                familyStr = "modern";
+                break;
+
+            case wxFONTFAMILY_TELETYPE:
+                familyStr = "teletype";
+                break;
+
+            case wxFONTFAMILY_DEFAULT:
+            case wxFONTFAMILY_UNKNOWN:
+                break;
+
+            default:
+                wxFAIL_MSG( "unknown font family" );
+        }
+
+        if ( !familyStr.empty() )
+            desc << " '" << familyStr << " family'";

     }
 
     int size = GetPointSize();
     if ( size != wxNORMAL_FONT->GetPointSize() )
     {
     }
 
     int size = GetPointSize();
     if ( size != wxNORMAL_FONT->GetPointSize() )
     {

-        desc << _T(' ') << size;
+        desc << wxT(' ') << size;

     }
 
 #if wxUSE_FONTMAP
     wxFontEncoding enc = GetEncoding();
     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
     {
     }
 
 #if wxUSE_FONTMAP
     wxFontEncoding enc = GetEncoding();
     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
     {

-        desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
+        desc << wxT(' ') << wxFontMapper::GetEncodingName(enc);

     }
 #endif // wxUSE_FONTMAP
 
     }
 #endif // wxUSE_FONTMAP
 


@@ -705,16 +915,9 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
     // or semicolons: we must be able to understand that quoted text is
     // a single token:
     wxString toparse(s);
     // or semicolons: we must be able to understand that quoted text is
     // a single token:
     wxString toparse(s);

-    /*
-    wxString::iterator i = toparse.find("'");
-    if (i != wxString::npos)
-    {
-        for (; *i != '\'' && *i != toparse.end(); i++)
-            ;
-    }*/

 
     // parse a more or less free form string
 
     // parse a more or less free form string

-    wxStringTokenizer tokenizer(toparse, _T(";, "), wxTOKEN_STRTOK);
+    wxStringTokenizer tokenizer(toparse, wxT(";, "), wxTOKEN_STRTOK);

 
     wxString face;
     unsigned long size;
 
     wxString face;
     unsigned long size;


@@ -732,7 +935,7 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
         token.Trim(true).Trim(false).MakeLower();
         if (insideQuotes)
         {
         token.Trim(true).Trim(false).MakeLower();
         if (insideQuotes)
         {

-            if (token.StartsWith("'") || 
+            if (token.StartsWith("'") ||

                 token.EndsWith("'"))
             {
                 insideQuotes = false;
                 token.EndsWith("'"))
             {
                 insideQuotes = false;


@@ -760,21 +963,25 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
             face += " " + token;
             continue;
         }
             face += " " + token;
             continue;
         }

-        if ( token == _T("underlined") || token == _("underlined") )
+        if ( token == wxT("underlined") || token == _("underlined") )

         {
             SetUnderlined(true);
         }
         {
             SetUnderlined(true);
         }

-        else if ( token == _T("light") || token == _("light") )
+        else if ( token == wxT("strikethrough") || token == _("strikethrough") )
+        {
+            SetStrikethrough(true);
+        }
+        else if ( token == wxT("light") || token == _("light") )

         {
             SetWeight(wxFONTWEIGHT_LIGHT);
             weightfound = true;
         }
         {
             SetWeight(wxFONTWEIGHT_LIGHT);
             weightfound = true;
         }

-        else if ( token == _T("bold") || token == _("bold") )
+        else if ( token == wxT("bold") || token == _("bold") )

         {
             SetWeight(wxFONTWEIGHT_BOLD);
             weightfound = true;
         }
         {
             SetWeight(wxFONTWEIGHT_BOLD);
             weightfound = true;
         }

-        else if ( token == _T("italic") || token == _("italic") )
+        else if ( token == wxT("italic") || token == _("italic") )

         {
             SetStyle(wxFONTSTYLE_ITALIC);
         }
         {
             SetStyle(wxFONTSTYLE_ITALIC);
         }


@@ -801,7 +1008,7 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
                 // assume it is the face name
             if ( !face.empty() )
             {
                 // assume it is the face name
             if ( !face.empty() )
             {

-                face += _T(' ');
+                face += wxT(' ');

             }
 
             face += token;
             }
 
             face += token;


@@ -819,10 +1026,32 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
         // bar")
         if ( !face.empty() )
         {
         // bar")
         if ( !face.empty() )
         {

+            wxString familyStr;
+            if ( face.EndsWith(" family", &familyStr) )
+            {
+                // it's not a facename but rather a font family
+                wxFontFamily family;
+                if ( familyStr == "decorative" )
+                    family = wxFONTFAMILY_DECORATIVE;
+                else if ( familyStr == "roman" )
+                    family = wxFONTFAMILY_ROMAN;
+                else if ( familyStr == "script" )
+                    family = wxFONTFAMILY_SCRIPT;
+                else if ( familyStr == "swiss" )
+                    family = wxFONTFAMILY_SWISS;
+                else if ( familyStr == "modern" )
+                    family = wxFONTFAMILY_MODERN;
+                else if ( familyStr == "teletype" )
+                    family = wxFONTFAMILY_TELETYPE;
+                else
+                    return false;
+
+                SetFamily(family);
+            }

             // NB: the check on the facename is implemented in wxFontBase::SetFaceName
             // NB: the check on the facename is implemented in wxFontBase::SetFaceName

-            //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
+            //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitly

             //     call here wxFontEnumerator::IsValidFacename
             //     call here wxFontEnumerator::IsValidFacename

-            if (
+            else if (

 #if wxUSE_FONTENUM
                     !wxFontEnumerator::IsValidFacename(face) ||
 #endif // wxUSE_FONTENUM
 #if wxUSE_FONTENUM
                     !wxFontEnumerator::IsValidFacename(face) ||
 #endif // wxUSE_FONTENUM


@@ -839,7 +1068,7 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
     if ( !face.empty() )
     {
         // NB: the check on the facename is implemented in wxFontBase::SetFaceName
     if ( !face.empty() )
     {
         // NB: the check on the facename is implemented in wxFontBase::SetFaceName

-        //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
+        //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitly

         //     call here wxFontEnumerator::IsValidFacename
         if (
 #if wxUSE_FONTENUM
         //     call here wxFontEnumerator::IsValidFacename
         if (
 #if wxUSE_FONTENUM


@@ -880,7 +1109,7 @@ wxString wxToString(const wxFontBase& font)
 
 bool wxFromString(const wxString& str, wxFontBase *font)
 {
 
 bool wxFromString(const wxString& str, wxFontBase *font)
 {

-    wxCHECK_MSG( font, false, _T("NULL output parameter") );
+    wxCHECK_MSG( font, false, wxT("NULL output parameter") );

 
     if ( str.empty() )
     {
 
     if ( str.empty() )
     {