X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/655719367ac5e131d9642e5783f3ecf64d1a3385..15fa9a1f82dc8e17bc0dc0fc6d330f430650edfb:/src/common/fontcmn.cpp

diff --git a/src/common/fontcmn.cpp b/src/common/fontcmn.cpp
index 6b09c8298a..f0d3ccf9c4 100644
--- a/src/common/fontcmn.cpp
+++ b/src/common/fontcmn.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        common/fontcmn.cpp
+// Name:        src/common/fontcmn.cpp
 // Purpose:     implementation of wxFontBase methods
 // Author:      Vadim Zeitlin
 // Modified by:
@@ -17,31 +17,32 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "fontbase.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
-#ifndef WX_PRECOMP
 #include "wx/font.h"
-#include "wx/intl.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/dc.h"
+    #include "wx/intl.h"
+    #include "wx/dcscreen.h"
+    #include "wx/log.h"
 #endif // WX_PRECOMP
 
 #include "wx/gdicmn.h"
 
 #if defined(__WXMSW__)
-  #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
-  #include  "wx/msw/winundef.h"
+    #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
+    #include  "wx/msw/winundef.h"
 #endif
 
 #include "wx/fontutil.h" // for wxNativeFontInfo
 #include "wx/fontmap.h"
+#include "wx/fontenum.h"
 
 #include "wx/tokenzr.h"
 
@@ -49,6 +50,64 @@
 // implementation
 // ============================================================================
 
+// ----------------------------------------------------------------------------
+// helper functions
+// ----------------------------------------------------------------------------
+
+static void AdjustFontSize(wxFont& font, wxDC& dc, const wxSize& pixelSize)
+{
+    int currentSize = 0;
+    int largestGood = 0;
+    int smallestBad = 0;
+
+    bool initialGoodFound = false;
+    bool initialBadFound = false;
+
+    // NB: this assignment was separated from the variable definition
+    // in order to fix a gcc v3.3.3 compiler crash
+    currentSize = font.GetPointSize();
+    while (currentSize > 0)
+    {
+        dc.SetFont(font);
+
+        // if currentSize (in points) results in a font that is smaller
+        // than required by pixelSize it is considered a good size
+        if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
+                (!pixelSize.GetWidth() ||
+                 dc.GetCharWidth() <= pixelSize.GetWidth()))
+        {
+            largestGood = currentSize;
+            initialGoodFound = true;
+        }
+        else
+        {
+            smallestBad = currentSize;
+            initialBadFound = true;
+        }
+        if (!initialGoodFound)
+        {
+            currentSize /= 2;
+        }
+        else if (!initialBadFound)
+        {
+            currentSize *= 2;
+        }
+        else
+        {
+            int distance = smallestBad - largestGood;
+            if (distance == 1)
+                break;
+
+            currentSize = largestGood + distance / 2;
+        }
+
+        font.SetPointSize(currentSize);
+    }
+
+    if (currentSize != largestGood)
+        font.SetPointSize(largestGood);
+}
+
 // ----------------------------------------------------------------------------
 // wxFontBase
 // ----------------------------------------------------------------------------
@@ -83,31 +142,87 @@ wxFont *wxFontBase::New(int size,
     return new wxFont(size, family, style, weight, underlined, face, encoding);
 }
 
-/* static */
-wxFont *wxFontBase::New(int pointSize,
-                        wxFontFamily family,
-                        int flags,
-                        const wxString& face,
-                        wxFontEncoding encoding)
+static inline int flags2Style(int flags)
 {
-    return New
-           (
-                pointSize,
-                family,
-                flags & wxFONTFLAG_ITALIC
+    return flags & wxFONTFLAG_ITALIC
                     ? wxFONTSTYLE_ITALIC
                     : flags & wxFONTFLAG_SLANT
                         ? wxFONTSTYLE_SLANT
-                        : wxFONTSTYLE_NORMAL,
-                flags & wxFONTFLAG_LIGHT
+                        : wxFONTSTYLE_NORMAL;
+}
+
+static inline int flags2Weight(int flags)
+{
+    return flags & wxFONTFLAG_LIGHT
                     ? wxFONTWEIGHT_LIGHT
                     : flags & wxFONTFLAG_BOLD
                         ? wxFONTWEIGHT_BOLD
-                        : wxFONTWEIGHT_NORMAL,
-                (flags & wxFONTFLAG_UNDERLINED) != 0,
-                face,
-                encoding
-           );
+                        : wxFONTWEIGHT_NORMAL;
+}
+
+static inline bool flags2Underlined(int flags)
+{
+    return (flags & wxFONTFLAG_UNDERLINED) != 0;
+}
+
+/* static */
+wxFont *wxFontBase::New(int pointSize,
+                        wxFontFamily family,
+                        int flags,
+                        const wxString& face,
+                        wxFontEncoding encoding)
+{
+    return New(pointSize, family, flags2Style(flags), flags2Weight(flags),
+               flags2Underlined(flags), face, encoding);
+}
+
+/* static */
+wxFont *wxFontBase::New(const wxSize& pixelSize,
+                        int family,
+                        int style,
+                        int weight,
+                        bool underlined,
+                        const wxString& face,
+                        wxFontEncoding encoding)
+{
+#if defined(__WXMSW__)
+    return new wxFont(pixelSize, family, style, weight, underlined,
+                      face, encoding);
+#else
+    wxFont *self = New(10, family, style, weight, underlined, face, encoding);
+    wxScreenDC dc;
+    AdjustFontSize(*(wxFont *)self, dc, pixelSize);
+    return self;
+#endif
+}
+
+/* static */
+wxFont *wxFontBase::New(const wxSize& pixelSize,
+                        wxFontFamily family,
+                        int flags,
+                        const wxString& face,
+                        wxFontEncoding encoding)
+{
+    return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
+               flags2Underlined(flags), face, encoding);
+}
+
+wxSize wxFontBase::GetPixelSize() const
+{
+    wxScreenDC dc;
+    dc.SetFont(*(wxFont *)this);
+    return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
+}
+
+bool wxFontBase::IsUsingSizeInPixels() const
+{
+    return false;
+}
+
+void wxFontBase::SetPixelSize( const wxSize& pixelSize )
+{
+    wxScreenDC dc;
+    AdjustFontSize(*(wxFont *)this, dc, pixelSize);
 }
 
 /* static */
@@ -153,6 +268,11 @@ wxString wxFontBase::GetNativeFontInfoDesc() const
     if ( fontInfo )
     {
         fontDesc = fontInfo->ToString();
+        wxASSERT_MSG(!fontDesc.IsEmpty(), wxT("This should be a non-empty string!"));
+    }
+    else
+    {
+        wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
     }
 
     return fontDesc;
@@ -165,35 +285,40 @@ wxString wxFontBase::GetNativeFontInfoUserDesc() const
     if ( fontInfo )
     {
         fontDesc = fontInfo->ToUserString();
+        wxASSERT_MSG(!fontDesc.IsEmpty(), wxT("This should be a non-empty string!"));
+    }
+    else
+    {
+        wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
     }
 
     return fontDesc;
 }
 
-void wxFontBase::SetNativeFontInfo(const wxString& info)
+bool wxFontBase::SetNativeFontInfo(const wxString& info)
 {
     wxNativeFontInfo fontInfo;
     if ( !info.empty() && fontInfo.FromString(info) )
     {
         SetNativeFontInfo(fontInfo);
+        return true;
     }
+
+    UnRef();
+    return false;
 }
 
-void wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
+bool wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
 {
     wxNativeFontInfo fontInfo;
     if ( !info.empty() && fontInfo.FromUserString(info) )
     {
         SetNativeFontInfo(fontInfo);
+        return true;
     }
-}
-
-wxFont& wxFont::operator=(const wxFont& font)
-{
-    if ( this != &font )
-        Ref(font);
 
-    return (wxFont &)*this;
+    UnRef();
+    return false;
 }
 
 bool wxFontBase::operator==(const wxFont& font) const
@@ -208,7 +333,7 @@ bool wxFontBase::operator==(const wxFont& font) const
             GetStyle() == font.GetStyle() &&
             GetWeight() == font.GetWeight() &&
             GetUnderlined() == font.GetUnderlined() &&
-            GetFaceName() == font.GetFaceName() &&
+            GetFaceName().IsSameAs(font.GetFaceName(), false) &&
             GetEncoding() == font.GetEncoding()
            );
 }
@@ -260,10 +385,41 @@ wxString wxFontBase::GetWeightString() const
     }
 }
 
+bool wxFontBase::SetFaceName(const wxString &facename)
+{
+    if (!wxFontEnumerator::IsValidFacename(facename))
+    {
+        UnRef();        // make Ok() return false
+        return false;
+    }
+
+    return true;
+}
+
+
 // ----------------------------------------------------------------------------
 // wxNativeFontInfo
 // ----------------------------------------------------------------------------
 
+// Up to now, there are no native implementations of this function:
+void wxNativeFontInfo::SetFaceName(const wxArrayString &facenames)
+{
+    for (size_t i=0; i < facenames.GetCount(); i++)
+    {
+        if (wxFontEnumerator::IsValidFacename(facenames[i]))
+        {
+            SetFaceName(facenames[i]);
+            return;
+        }
+    }
+
+    // set the first valid facename we can find on this system
+    wxString validfacename = wxFontEnumerator::GetFacenames().Item(0);
+    wxLogTrace(wxT("font"), wxT("Falling back to '%s'"), validfacename.c_str());
+    SetFaceName(validfacename);
+}
+
+
 #ifdef wxNO_NATIVE_FONTINFO
 
 // These are the generic forms of FromString()/ToString.
@@ -284,42 +440,42 @@ bool wxNativeFontInfo::FromString(const wxString& s)
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
-        return FALSE;
+        return false;
     pointSize = (int)l;
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
-        return FALSE;
+        return false;
     family = (wxFontFamily)l;
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
-        return FALSE;
+        return false;
     style = (wxFontStyle)l;
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
-        return FALSE;
+        return false;
     weight = (wxFontWeight)l;
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
-        return FALSE;
+        return false;
     underlined = l != 0;
 
     faceName = tokenizer.GetNextToken();
 
 #ifndef __WXMAC__
     if( !faceName )
-        return FALSE;
+        return false;
 #endif
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
-        return FALSE;
+        return false;
     encoding = (wxFontEncoding)l;
 
-    return TRUE;
+    return true;
 }
 
 wxString wxNativeFontInfo::ToString() const
@@ -345,7 +501,7 @@ void wxNativeFontInfo::Init()
     family = wxFONTFAMILY_DEFAULT;
     style = wxFONTSTYLE_NORMAL;
     weight = wxFONTWEIGHT_NORMAL;
-    underlined = FALSE;
+    underlined = false;
     faceName.clear();
     encoding = wxFONTENCODING_DEFAULT;
 }
@@ -405,9 +561,10 @@ void wxNativeFontInfo::SetUnderlined(bool underlined_)
     underlined = underlined_;
 }
 
-void wxNativeFontInfo::SetFaceName(wxString facename_)
+bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
 {
     faceName = facename_;
+    return true;
 }
 
 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
@@ -437,7 +594,7 @@ wxString wxNativeFontInfo::ToUserString() const
     // but what else can we do?
     if ( GetUnderlined() )
     {
-        desc << _("underlined ");
+        desc << _("underlined");
     }
 
     switch ( GetWeight() )
@@ -450,11 +607,11 @@ wxString wxNativeFontInfo::ToUserString() const
             break;
 
         case wxFONTWEIGHT_LIGHT:
-            desc << _("light ");
+            desc << _(" light");
             break;
 
         case wxFONTWEIGHT_BOLD:
-            desc << _("bold ");
+            desc << _(" bold");
             break;
     }
 
@@ -470,7 +627,7 @@ wxString wxNativeFontInfo::ToUserString() const
             // we don't distinguish between the two for now anyhow...
         case wxFONTSTYLE_ITALIC:
         case wxFONTSTYLE_SLANT:
-            desc << _("italic");
+            desc << _(" italic");
             break;
     }
 
@@ -490,11 +647,11 @@ wxString wxNativeFontInfo::ToUserString() const
     wxFontEncoding enc = GetEncoding();
     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
     {
-        desc << _T(' ') << wxFontMapper::Get()->GetEncodingName(enc);
+        desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
     }
 #endif // wxUSE_FONTMAP
 
-    return desc;
+    return desc.Strip(wxString::both).MakeLower();
 }
 
 bool wxNativeFontInfo::FromUserString(const wxString& s)
@@ -509,30 +666,29 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
 
     wxString face;
     unsigned long size;
-
-#if wxUSE_FONTMAP
-    wxFontEncoding encoding;
-#endif // wxUSE_FONTMAP
+    bool weightfound = false, pointsizefound = false, encodingfound = false;
 
     while ( tokenizer.HasMoreTokens() )
     {
         wxString token = tokenizer.GetNextToken();
 
         // normalize it
-        token.Trim(TRUE).Trim(FALSE).MakeLower();
+        token.Trim(true).Trim(false).MakeLower();
 
         // look for the known tokens
         if ( token == _T("underlined") || token == _("underlined") )
         {
-            SetUnderlined(TRUE);
+            SetUnderlined(true);
         }
         else if ( token == _T("light") || token == _("light") )
         {
             SetWeight(wxFONTWEIGHT_LIGHT);
+            weightfound = true;
         }
         else if ( token == _T("bold") || token == _("bold") )
         {
             SetWeight(wxFONTWEIGHT_BOLD);
+            weightfound = true;
         }
         else if ( token == _T("italic") || token == _("italic") )
         {
@@ -541,16 +697,24 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
         else if ( token.ToULong(&size) )
         {
             SetPointSize(size);
+            pointsizefound = true;
         }
+        else
+        {
 #if wxUSE_FONTMAP
-        else if ( (encoding = wxFontMapper::Get()->CharsetToEncoding(token, FALSE))
-                    != wxFONTENCODING_DEFAULT )
+            // try to interpret this as an encoding
+            wxFontEncoding encoding = wxFontMapper::Get()->CharsetToEncoding(token, false);
+            if ( encoding != wxFONTENCODING_DEFAULT &&
+                 encoding != wxFONTENCODING_SYSTEM )    // returned when the recognition failed
         {
             SetEncoding(encoding);
+                encodingfound = true;
         }
-#endif // wxUSE_FONTMAP
-        else // assume it is the face name
+            else
         {
+#endif // wxUSE_FONTMAP
+
+                // assume it is the face name
             if ( !face.empty() )
             {
                 face += _T(' ');
@@ -560,6 +724,10 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
 
             // skip the code which resets face below
             continue;
+
+#if wxUSE_FONTMAP
+        }
+#endif // wxUSE_FONTMAP
         }
 
         // if we had had the facename, we shouldn't continue appending tokens
@@ -567,7 +735,12 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
         // bar")
         if ( !face.empty() )
         {
-            SetFaceName(face);
+            // 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 (!wxFontEnumerator::IsValidFacename(face) ||
+                !SetFaceName(face))
+                SetFaceName(wxNORMAL_FONT->GetFaceName());
             face.clear();
         }
     }
@@ -575,11 +748,29 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
     // we might not have flushed it inside the loop
     if ( !face.empty() )
     {
-        SetFaceName(face);
+        // 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 (!wxFontEnumerator::IsValidFacename(face) ||
+            !SetFaceName(face))
+            SetFaceName(wxNORMAL_FONT->GetFaceName());
     }
 
-    return TRUE;
+    // set point size to default value if size was not given
+    if ( !pointsizefound )
+        SetPointSize(wxNORMAL_FONT->GetPointSize());
+
+    // set font weight to default value if weight was not given
+    if ( !weightfound )
+        SetWeight(wxFONTWEIGHT_NORMAL);
+
+#if wxUSE_FONTMAP
+    // set font encoding to default value if encoding was not given
+    if ( !encodingfound )
+        SetEncoding(wxFONTENCODING_SYSTEM);
+#endif // wxUSE_FONTMAP
+
+    return true;
 }
 
 #endif // generic or wxMSW or wxOS2
-