]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/fontcmn.cpp
Add the possibility to disable invisible wxDataViewCtrl items.
[wxWidgets.git] / src / common / fontcmn.cpp
index 3b8b7fd80e12d07c0f09229b2b197f222a6326e5..27154e9953bb4354188639921f12e658568366cb 100644 (file)
@@ -57,13 +57,13 @@ extern const char *wxDumpFont(const wxFont *font)
     s.Printf(wxS("%s-%s-%s-%d-%d"),
              font->GetFaceName(),
              weight == wxFONTWEIGHT_NORMAL
-                ? _T("normal")
+                ? wxT("normal")
                 : weight == wxFONTWEIGHT_BOLD
-                    ? _T("bold")
-                    : _T("light"),
+                    ? wxT("bold")
+                    : wxT("light"),
              font->GetStyle() == wxFONTSTYLE_NORMAL
-                ? _T("regular")
-                : _T("italic"),
+                ? wxT("regular")
+                : wxT("italic"),
              font->GetPointSize(),
              font->GetEncoding());
 
@@ -114,7 +114,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,
-                 _T("can't set default encoding to wxFONTENCODING_DEFAULT") );
+                 wxT("can't set default encoding to wxFONTENCODING_DEFAULT") );
 
     ms_encodingDefault = encoding;
 }
@@ -214,7 +214,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.
-    
+
     int largestGood = 0;
     int smallestBad = 0;
 
@@ -284,6 +284,8 @@ void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
 
 wxString wxFontBase::GetNativeFontInfoDesc() const
 {
+    wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
+
     wxString fontDesc;
     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
     if ( fontInfo )
@@ -301,6 +303,8 @@ wxString wxFontBase::GetNativeFontInfoDesc() const
 
 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 {
+    wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
+
     wxString fontDesc;
     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
     if ( fontInfo )
@@ -363,6 +367,20 @@ bool wxFontBase::operator==(const wxFont& font) const
            );
 }
 
+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" );
@@ -375,6 +393,7 @@ wxString wxFontBase::GetFamilyString() const
         case wxFONTFAMILY_SWISS:        return "wxFONTFAMILY_SWISS";
         case wxFONTFAMILY_MODERN:       return "wxFONTFAMILY_MODERN";
         case wxFONTFAMILY_TELETYPE:     return "wxFONTFAMILY_TELETYPE";
+        case wxFONTFAMILY_UNKNOWN:      return "wxFONTFAMILY_UNKNOWN";
         default:                        return "wxFONTFAMILY_DEFAULT";
     }
 }
@@ -420,6 +439,44 @@ bool wxFontBase::SetFaceName(const wxString& facename)
     return true;
 }
 
+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.SetStyle(wxFONTSTYLE_ITALIC);
+    return font;
+}
+
+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
@@ -459,7 +516,7 @@ bool wxNativeFontInfo::FromString(const wxString& s)
 {
     long l;
 
-    wxStringTokenizer tokenizer(s, _T(";"));
+    wxStringTokenizer tokenizer(s, wxT(";"));
 
     wxString token = tokenizer.GetNextToken();
     //
@@ -510,7 +567,7 @@ wxString wxNativeFontInfo::ToString() const
 {
     wxString s;
 
-    s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
+    s.Printf(wxT("%d;%d;%d;%d;%d;%d;%s;%d"),
              0,                                 // version
              pointSize,
              family,
@@ -628,7 +685,7 @@ wxString wxNativeFontInfo::ToUserString() const
     switch ( GetWeight() )
     {
         default:
-            wxFAIL_MSG( _T("unknown font weight") );
+            wxFAIL_MSG( wxT("unknown font weight") );
             // fall through
 
         case wxFONTWEIGHT_NORMAL:
@@ -646,7 +703,7 @@ wxString wxNativeFontInfo::ToUserString() const
     switch ( GetStyle() )
     {
         default:
-            wxFAIL_MSG( _T("unknown font style") );
+            wxFAIL_MSG( wxT("unknown font style") );
             // fall through
 
         case wxFONTSTYLE_NORMAL:
@@ -662,20 +719,74 @@ wxString wxNativeFontInfo::ToUserString() const
     wxString face = GetFaceName();
     if ( !face.empty() )
     {
-        desc << _T(' ') << face;
+        if (face.Contains(' ') || face.Contains(';') || face.Contains(','))
+        {
+            face.Replace("'", "");
+                // eventually remove quote characters: most systems do not
+                // allow them in a facename anyway so this usually does nothing
+
+            // make it possible for FromUserString() function to understand
+            // that the different words which compose this facename are
+            // not different adjectives or other data but rather all parts
+            // of the facename
+            desc << wxT(" '") << face << _("'");
+        }
+        else
+            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() )
     {
-        desc << _T(' ') << size;
+        desc << wxT(' ') << size;
     }
 
 #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
 
@@ -687,10 +798,13 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
     // reset to the default state
     Init();
 
+    // ToUserString() will quote the facename if it contains spaces, commas
+    // or semicolons: we must be able to understand that quoted text is
+    // a single token:
+    wxString toparse(s);
+
     // parse a more or less free form string
-    //
-    // TODO: we should handle at least the quoted facenames
-    wxStringTokenizer tokenizer(s, _T(";, "), wxTOKEN_STRTOK);
+    wxStringTokenizer tokenizer(toparse, wxT(";, "), wxTOKEN_STRTOK);
 
     wxString face;
     unsigned long size;
@@ -698,6 +812,7 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
 #if wxUSE_FONTMAP
     bool encodingfound = false;
 #endif
+    bool insideQuotes = false;
 
     while ( tokenizer.HasMoreTokens() )
     {
@@ -705,23 +820,51 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
 
         // normalize it
         token.Trim(true).Trim(false).MakeLower();
+        if (insideQuotes)
+        {
+            if (token.StartsWith("'") ||
+                token.EndsWith("'"))
+            {
+                insideQuotes = false;
+
+                // add this last token to the facename:
+                face += " " + token;
+
+                // normalize facename:
+                face = face.Trim(true).Trim(false);
+                face.Replace("'", "");
+
+                continue;
+            }
+        }
+        else
+        {
+            if (token.StartsWith("'"))
+                insideQuotes = true;
+        }
 
         // look for the known tokens
-        if ( token == _T("underlined") || token == _("underlined") )
+        if ( insideQuotes )
+        {
+            // only the facename may be quoted:
+            face += " " + token;
+            continue;
+        }
+        if ( token == wxT("underlined") || token == _("underlined") )
         {
             SetUnderlined(true);
         }
-        else if ( token == _T("light") || token == _("light") )
+        else if ( token == wxT("light") || token == _("light") )
         {
             SetWeight(wxFONTWEIGHT_LIGHT);
             weightfound = true;
         }
-        else if ( token == _T("bold") || token == _("bold") )
+        else if ( token == wxT("bold") || token == _("bold") )
         {
             SetWeight(wxFONTWEIGHT_BOLD);
             weightfound = true;
         }
-        else if ( token == _T("italic") || token == _("italic") )
+        else if ( token == wxT("italic") || token == _("italic") )
         {
             SetStyle(wxFONTSTYLE_ITALIC);
         }
@@ -748,7 +891,7 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
                 // assume it is the face name
             if ( !face.empty() )
             {
-                face += _T(' ');
+                face += wxT(' ');
             }
 
             face += token;
@@ -766,10 +909,32 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
         // 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
             //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
             //     call here wxFontEnumerator::IsValidFacename
-            if (
+            else if (
 #if wxUSE_FONTENUM
                     !wxFontEnumerator::IsValidFacename(face) ||
 #endif // wxUSE_FONTENUM
@@ -827,7 +992,7 @@ wxString wxToString(const 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() )
     {