Add another test for the insertion point position after SetValue().

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

diff --git a/src/common/fontcmn.cpp b/src/common/fontcmn.cpp
index 9fcb7d694f0c163d1f04da97898c1f4fe7a80410..27154e9953bb4354188639921f12e658568366cb 100644 (file)
--- a/src/common/fontcmn.cpp
+++ b/src/common/fontcmn.cpp
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        common/fontcmn.cpp
+// Name:        src/common/fontcmn.cpp

 // Purpose:     implementation of wxFontBase methods
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     20.09.99
 // RCS-ID:      $Id$
 // Purpose:     implementation of wxFontBase methods
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     20.09.99
 // RCS-ID:      $Id$

-// Copyright:   (c) wxWindows team
-// Licence:     wxWindows license
+// Copyright:   (c) wxWidgets team
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -17,43 +17,118 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-#pragma implementation "fontbase.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

-#ifndef WX_PRECOMP

 #include "wx/font.h"
 #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"
+    #include "wx/gdicmn.h"

 #endif // WX_PRECOMP
 
 #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"
+#endif
+

 #include "wx/fontutil.h" // for wxNativeFontInfo
 #include "wx/fontmap.h"
 #include "wx/fontutil.h" // for wxNativeFontInfo
 #include "wx/fontmap.h"

+#include "wx/fontenum.h"

 
 #include "wx/tokenzr.h"
 
 
 #include "wx/tokenzr.h"
 

+// debugger helper: this function can be called from a debugger to show what
+// the date really is
+extern const char *wxDumpFont(const wxFont *font)
+{
+    static char buf[256];
+
+    const wxFontWeight weight = font->GetWeight();
+
+    wxString s;
+    s.Printf(wxS("%s-%s-%s-%d-%d"),
+             font->GetFaceName(),
+             weight == wxFONTWEIGHT_NORMAL
+                ? wxT("normal")
+                : weight == wxFONTWEIGHT_BOLD
+                    ? wxT("bold")
+                    : wxT("light"),
+             font->GetStyle() == wxFONTSTYLE_NORMAL
+                ? wxT("regular")
+                : wxT("italic"),
+             font->GetPointSize(),
+             font->GetEncoding());
+
+    wxStrlcpy(buf, s.mb_str(), WXSIZEOF(buf));
+    return buf;
+}
+

 // ============================================================================
 // implementation
 // ============================================================================
 
 // ============================================================================
 // implementation
 // ============================================================================
 

+// ----------------------------------------------------------------------------
+// helper functions
+// ----------------------------------------------------------------------------
+
+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;
+}
+
+static inline bool flags2Underlined(int flags)
+{
+    return (flags & wxFONTFLAG_UNDERLINED) != 0;
+}
+

 // ----------------------------------------------------------------------------
 // wxFontBase
 // ----------------------------------------------------------------------------
 
 wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
 
 // ----------------------------------------------------------------------------
 // wxFontBase
 // ----------------------------------------------------------------------------
 
 wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
 

+/* static */
+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,
+                 wxT("can't set default encoding to wxFONTENCODING_DEFAULT") );
+
+    ms_encodingDefault = encoding;
+}
+
+wxFontBase::~wxFontBase()
+{
+    // this destructor is required for Darwin
+}
+

 /* static */
 wxFont *wxFontBase::New(int size,
 /* static */
 wxFont *wxFontBase::New(int size,

-                        int family,
-                        int style,
-                        int weight,
+                        wxFontFamily family,
+                        wxFontStyle style,
+                        wxFontWeight weight,

                         bool underlined,
                         const wxString& face,
                         wxFontEncoding encoding)
                         bool underlined,
                         const wxString& face,
                         wxFontEncoding encoding)


@@ -61,6 +136,41 @@ wxFont *wxFontBase::New(int size,
     return new wxFont(size, family, style, weight, underlined, face, encoding);
 }
 
     return new wxFont(size, family, style, weight, underlined, face, encoding);
 }
 

+/* static */
+wxFont *wxFontBase::New(const wxSize& pixelSize,
+                        wxFontFamily family,
+                        wxFontStyle style,
+                        wxFontWeight weight,
+                        bool underlined,
+                        const wxString& face,
+                        wxFontEncoding encoding)
+{
+    return new wxFont(pixelSize, family, style, weight, underlined,
+                      face, encoding);
+}
+
+/* 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,
+                        wxFontFamily family,
+                        int flags,
+                        const wxString& face,
+                        wxFontEncoding encoding)
+{
+    return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
+               flags2Underlined(flags), face, encoding);
+}
+

 /* static */
 wxFont *wxFontBase::New(const wxNativeFontInfo& info)
 {
 /* static */
 wxFont *wxFontBase::New(const wxNativeFontInfo& info)
 {


@@ -77,26 +187,87 @@ wxFont *wxFontBase::New(const wxString& strNativeFontDesc)
     return New(fontInfo);
 }
 
     return New(fontInfo);
 }
 

-wxNativeFontInfo *wxFontBase::GetNativeFontInfo() const
+bool wxFontBase::IsFixedWidth() const

 {
 {

-#ifdef wxNO_NATIVE_FONTINFO
-    wxNativeFontInfo *fontInfo = new wxNativeFontInfo();
+    return GetFamily() == wxFONTFAMILY_TELETYPE;
+}

 
 

-    fontInfo->SetPointSize(GetPointSize());
-    fontInfo->SetFamily(GetFamily());
-    fontInfo->SetStyle((wxFontStyle)GetStyle());
-    fontInfo->SetWeight((wxFontWeight)GetWeight());
-    fontInfo->SetUnderlined(GetUnderlined());
-    fontInfo->SetFaceName(GetFaceName());
-    fontInfo->SetEncoding(GetEncoding());
+wxSize wxFontBase::GetPixelSize() const
+{
+    wxScreenDC dc;
+    dc.SetFont(*(wxFont *)this);
+    return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
+}

 
 

-    return fontInfo;
-#else
-    return (wxNativeFontInfo *)NULL;
-#endif
+bool wxFontBase::IsUsingSizeInPixels() const
+{
+    return false;
+}
+
+void wxFontBase::SetPixelSize( const wxSize& pixelSize )
+{
+    wxCHECK_RET( pixelSize.GetWidth() >= 0 && pixelSize.GetHeight() > 0,
+                 "Negative values for the pixel size or zero pixel height are not allowed" );
+
+    wxScreenDC dc;
+
+    // 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;
+
+    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
+    int currentSize = GetPointSize();
+    while (currentSize > 0)
+    {
+        dc.SetFont(*static_cast<wxFont*>(this));
+
+        // if currentSize (in points) results in a font that is smaller
+        // than required by pixelSize it is considered a good size
+        // NOTE: the pixel size width may be zero
+        if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
+                (pixelSize.GetWidth() == 0 ||
+                 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;
+        }
+
+        SetPointSize(currentSize);
+    }
+
+    if (currentSize != largestGood)
+        SetPointSize(largestGood);

 }
 
 }
 

-void wxFontBase::SetNativeFontInfo(const wxNativeFontInfo& info)
+void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)

 {
 #ifdef wxNO_NATIVE_FONTINFO
     SetPointSize(info.pointSize);
 {
 #ifdef wxNO_NATIVE_FONTINFO
     SetPointSize(info.pointSize);


@@ -113,12 +284,18 @@ void wxFontBase::SetNativeFontInfo(const wxNativeFontInfo& info)
 
 wxString wxFontBase::GetNativeFontInfoDesc() const
 {
 
 wxString wxFontBase::GetNativeFontInfoDesc() const
 {

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

     wxString fontDesc;
     wxString fontDesc;

-    wxNativeFontInfo *fontInfo = GetNativeFontInfo();
+    const wxNativeFontInfo *fontInfo = GetNativeFontInfo();

     if ( fontInfo )
     {
         fontDesc = fontInfo->ToString();
     if ( fontInfo )
     {
         fontDesc = fontInfo->ToString();

-        delete fontInfo;
+        wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
+    }
+    else
+    {
+        wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));

     }
 
     return fontDesc;
     }
 
     return fontDesc;


@@ -126,111 +303,208 @@ wxString wxFontBase::GetNativeFontInfoDesc() const
 
 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 {
 
 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 {

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

     wxString fontDesc;
     wxString fontDesc;

-    wxNativeFontInfo *fontInfo = GetNativeFontInfo();
+    const wxNativeFontInfo *fontInfo = GetNativeFontInfo();

     if ( fontInfo )
     {
         fontDesc = fontInfo->ToUserString();
     if ( fontInfo )
     {
         fontDesc = fontInfo->ToUserString();

-        delete fontInfo;
+        wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
+    }
+    else
+    {
+        wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));

     }
 
     return fontDesc;
 }
 
     }
 
     return fontDesc;
 }
 

-void wxFontBase::SetNativeFontInfo(const wxString& info)
+bool wxFontBase::SetNativeFontInfo(const wxString& info)

 {
     wxNativeFontInfo fontInfo;
     if ( !info.empty() && fontInfo.FromString(info) )
     {
         SetNativeFontInfo(fontInfo);
 {
     wxNativeFontInfo fontInfo;
     if ( !info.empty() && fontInfo.FromString(info) )
     {
         SetNativeFontInfo(fontInfo);

+        return true;

     }
     }

+
+    return false;

 }
 
 }
 

-void wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
+bool wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)

 {
     wxNativeFontInfo fontInfo;
     if ( !info.empty() && fontInfo.FromUserString(info) )
     {
         SetNativeFontInfo(fontInfo);
 {
     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;
+    return false;

 }
 
 bool wxFontBase::operator==(const wxFont& font) const
 {
     // either it is the same font, i.e. they share the same common data or they
     // have different ref datas but still describe the same font
 }
 
 bool wxFontBase::operator==(const wxFont& font) const
 {
     // either it is the same font, i.e. they share the same common data or they
     // have different ref datas but still describe the same font

-    return GetFontData() == font.GetFontData() ||
+    return IsSameAs(font) ||

            (
            (

-            Ok() == font.Ok() &&
+            IsOk() == font.IsOk() &&

             GetPointSize() == font.GetPointSize() &&
             GetPointSize() == font.GetPointSize() &&

+            // in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
+            // operator==() resulting in infinite recursion so we can't use it
+            // in that port
+#if !defined(__WXGTK__) || defined(__WXGTK20__)
+            GetPixelSize() == font.GetPixelSize() &&
+#endif

             GetFamily() == font.GetFamily() &&
             GetStyle() == font.GetStyle() &&
             GetWeight() == font.GetWeight() &&
             GetUnderlined() == font.GetUnderlined() &&
             GetFamily() == font.GetFamily() &&
             GetStyle() == font.GetStyle() &&
             GetWeight() == font.GetWeight() &&
             GetUnderlined() == font.GetUnderlined() &&

-            GetFaceName() == font.GetFaceName() &&
+            GetFaceName().IsSameAs(font.GetFaceName(), false) &&

             GetEncoding() == font.GetEncoding()
            );
 }
 
             GetEncoding() == font.GetEncoding()
            );
 }
 

-bool wxFontBase::operator!=(const wxFont& font) const
+wxFontFamily wxFontBase::GetFamily() const

 {
 {

-    return !(*this == font);
+    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
 {
 }
 
 wxString wxFontBase::GetFamilyString() const
 {

-    wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
+    wxCHECK_MSG( IsOk(), "wxFONTFAMILY_DEFAULT", "invalid font" );

 
     switch ( GetFamily() )
     {
 
     switch ( GetFamily() )
     {

-        case wxDECORATIVE:   return wxT("wxDECORATIVE");
-        case wxROMAN:        return wxT("wxROMAN");
-        case wxSCRIPT:       return wxT("wxSCRIPT");
-        case wxSWISS:        return wxT("wxSWISS");
-        case wxMODERN:       return wxT("wxMODERN");
-        case wxTELETYPE:     return wxT("wxTELETYPE");
-        default:             return wxT("wxDEFAULT");
+        case wxFONTFAMILY_DECORATIVE:   return "wxFONTFAMILY_DECORATIVE";
+        case wxFONTFAMILY_ROMAN:        return "wxFONTFAMILY_ROMAN";
+        case wxFONTFAMILY_SCRIPT:       return "wxFONTFAMILY_SCRIPT";
+        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";

     }
 }
 
 wxString wxFontBase::GetStyleString() const
 {
     }
 }
 
 wxString wxFontBase::GetStyleString() const
 {

-    wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
+    wxCHECK_MSG( IsOk(), "wxFONTSTYLE_DEFAULT", "invalid font" );

 
     switch ( GetStyle() )
     {
 
     switch ( GetStyle() )
     {

-        case wxNORMAL:   return wxT("wxNORMAL");
-        case wxSLANT:    return wxT("wxSLANT");
-        case wxITALIC:   return wxT("wxITALIC");
-        default:         return wxT("wxDEFAULT");
+        case wxFONTSTYLE_NORMAL:   return "wxFONTSTYLE_NORMAL";
+        case wxFONTSTYLE_SLANT:    return "wxFONTSTYLE_SLANT";
+        case wxFONTSTYLE_ITALIC:   return "wxFONTSTYLE_ITALIC";
+        default:                   return "wxFONTSTYLE_DEFAULT";

     }
 }
 
 wxString wxFontBase::GetWeightString() const
 {
     }
 }
 
 wxString wxFontBase::GetWeightString() const
 {

-    wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
+    wxCHECK_MSG( IsOk(), "wxFONTWEIGHT_DEFAULT", "invalid font" );

 
     switch ( GetWeight() )
     {
 
     switch ( GetWeight() )
     {

-        case wxNORMAL:   return wxT("wxNORMAL");
-        case wxBOLD:     return wxT("wxBOLD");
-        case wxLIGHT:    return wxT("wxLIGHT");
-        default:         return wxT("wxDEFAULT");
+        case wxFONTWEIGHT_NORMAL:   return "wxFONTWEIGHT_NORMAL";
+        case wxFONTWEIGHT_BOLD:     return "wxFONTWEIGHT_BOLD";
+        case wxFONTWEIGHT_LIGHT:    return "wxFONTWEIGHT_LIGHT";
+        default:                    return "wxFONTWEIGHT_DEFAULT";
+    }
+}
+
+bool wxFontBase::SetFaceName(const wxString& facename)
+{
+#if wxUSE_FONTENUM
+    if (!wxFontEnumerator::IsValidFacename(facename))
+    {
+        UnRef();        // make IsOk() return false
+        return false;

     }
     }

+#else // !wxUSE_FONTENUM
+    wxUnusedVar(facename);
+#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
+
+    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
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxNativeFontInfo
 // ----------------------------------------------------------------------------
 

+// Up to now, there are no native implementations of this function:
+void wxNativeFontInfo::SetFaceName(const wxArrayString& facenames)
+{
+#if wxUSE_FONTENUM
+    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);
+#else // !wxUSE_FONTENUM
+    SetFaceName(facenames[0]);
+#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
+}
+
+

 #ifdef wxNO_NATIVE_FONTINFO
 
 // These are the generic forms of FromString()/ToString.
 #ifdef wxNO_NATIVE_FONTINFO
 
 // These are the generic forms of FromString()/ToString.


@@ -242,7 +516,7 @@ bool wxNativeFontInfo::FromString(const wxString& s)
 {
     long l;
 
 {
     long l;
 

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

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


@@ -251,46 +525,49 @@ bool wxNativeFontInfo::FromString(const wxString& s)
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )
 
     token = tokenizer.GetNextToken();
     if ( !token.ToLong(&l) )

-        return FALSE;
+        return false;

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

-        return FALSE;
-    family = (int)l;
+        return false;
+    family = (wxFontFamily)l;

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

-        return FALSE;
+        return false;

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

-        return FALSE;
+        return false;

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

-        return FALSE;
+        return false;

     underlined = l != 0;
 
     faceName = tokenizer.GetNextToken();
     underlined = l != 0;
 
     faceName = tokenizer.GetNextToken();

+
+#ifndef __WXMAC__

     if( !faceName )
     if( !faceName )

-        return FALSE;
+        return false;
+#endif

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

-        return FALSE;
+        return false;

     encoding = (wxFontEncoding)l;
 
     encoding = (wxFontEncoding)l;
 

-    return TRUE;
+    return true;

 }
 
 wxString wxNativeFontInfo::ToString() const
 {
     wxString s;
 
 }
 
 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,
              0,                                 // version
              pointSize,
              family,


@@ -305,11 +582,11 @@ wxString wxNativeFontInfo::ToString() const
 
 void wxNativeFontInfo::Init()
 {
 
 void wxNativeFontInfo::Init()
 {

-    pointSize = wxNORMAL_FONT->GetPointSize();
+    pointSize = 0;

     family = wxFONTFAMILY_DEFAULT;
     style = wxFONTSTYLE_NORMAL;
     weight = wxFONTWEIGHT_NORMAL;
     family = wxFONTFAMILY_DEFAULT;
     style = wxFONTSTYLE_NORMAL;
     weight = wxFONTWEIGHT_NORMAL;

-    underlined = FALSE;
+    underlined = false;

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


@@ -369,9 +646,10 @@ void wxNativeFontInfo::SetUnderlined(bool underlined_)
     underlined = underlined_;
 }
 
     underlined = underlined_;
 }
 

-void wxNativeFontInfo::SetFaceName(wxString facename_)
+bool wxNativeFontInfo::SetFaceName(const wxString& facename_)

 {
 {

-    facename = facename_;
+    faceName = facename_;
+    return true;

 }
 
 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
 }
 
 void wxNativeFontInfo::SetFamily(wxFontFamily family_)


@@ -391,7 +669,7 @@ void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
 // format there anyhow (but there is a well-defined standard for X11 fonts used
 // by wxGTK and wxMotif)
 
 // format there anyhow (but there is a well-defined standard for X11 fonts used
 // by wxGTK and wxMotif)
 

-#if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__)
+#if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined (__WXPM__) || defined(__WXOSX__)

 
 wxString wxNativeFontInfo::ToUserString() const
 {
 
 wxString wxNativeFontInfo::ToUserString() const
 {


@@ -401,31 +679,31 @@ wxString wxNativeFontInfo::ToUserString() const
     // but what else can we do?
     if ( GetUnderlined() )
     {
     // but what else can we do?
     if ( GetUnderlined() )
     {

-        desc << _("underlined ");
+        desc << _("underlined");

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

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

             // fall through
 
         case wxFONTWEIGHT_NORMAL:
             break;
 
         case wxFONTWEIGHT_LIGHT:
             // fall through
 
         case wxFONTWEIGHT_NORMAL:
             break;
 
         case wxFONTWEIGHT_LIGHT:

-            desc << _("light ");
+            desc << _(" light");

             break;
 
         case wxFONTWEIGHT_BOLD:
             break;
 
         case wxFONTWEIGHT_BOLD:

-            desc << _("bold ");
+            desc << _(" bold");

             break;
     }
 
     switch ( GetStyle() )
     {
         default:
             break;
     }
 
     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:


@@ -434,29 +712,85 @@ wxString wxNativeFontInfo::ToUserString() const
             // we don't distinguish between the two for now anyhow...
         case wxFONTSTYLE_ITALIC:
         case wxFONTSTYLE_SLANT:
             // we don't distinguish between the two for now anyhow...
         case wxFONTSTYLE_ITALIC:
         case wxFONTSTYLE_SLANT:

-            desc << _("italic");
+            desc << _(" italic");

             break;
     }
 
     wxString face = GetFaceName();
     if ( !face.empty() )
     {
             break;
     }
 
     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() )
     {
     }
 
     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 )
     {
     wxFontEncoding enc = GetEncoding();
     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
     {

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

     }
     }

+#endif // wxUSE_FONTMAP

 
 

-    return desc;
+    return desc.Strip(wxString::both).MakeLower();

 }
 
 bool wxNativeFontInfo::FromUserString(const wxString& s)
 }
 
 bool wxNativeFontInfo::FromUserString(const wxString& s)


@@ -464,59 +798,110 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
     // reset to the default state
     Init();
 
     // 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
     // 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;
 
     wxString face;
     unsigned long size;

-    wxFontEncoding encoding;
+    bool weightfound = false, pointsizefound = false;
+#if wxUSE_FONTMAP
+    bool encodingfound = false;
+#endif
+    bool insideQuotes = false;

 
     while ( tokenizer.HasMoreTokens() )
     {
         wxString token = tokenizer.GetNextToken();
 
         // normalize it
 
     while ( tokenizer.HasMoreTokens() )
     {
         wxString token = tokenizer.GetNextToken();
 
         // normalize it

-        token.Trim(TRUE).Trim(FALSE).MakeLower();
+        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
 
         // look for the known tokens

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

         {
         {

-            SetUnderlined(TRUE);
+            // only the facename may be quoted:
+            face += " " + token;
+            continue;

         }
         }

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

         {
             SetWeight(wxFONTWEIGHT_LIGHT);
         {
             SetWeight(wxFONTWEIGHT_LIGHT);

+            weightfound = true;

         }
         }

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

         {
             SetWeight(wxFONTWEIGHT_BOLD);
         {
             SetWeight(wxFONTWEIGHT_BOLD);

+            weightfound = true;

         }
         }

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

         {
             SetStyle(wxFONTSTYLE_ITALIC);
         }
         else if ( token.ToULong(&size) )
         {
             SetPointSize(size);
         {
             SetStyle(wxFONTSTYLE_ITALIC);
         }
         else if ( token.ToULong(&size) )
         {
             SetPointSize(size);

+            pointsizefound = true;

         }
         }

-        else if ( (encoding = wxTheFontMapper->CharsetToEncoding(token, FALSE))
-                    != wxFONTENCODING_DEFAULT )
+        else
+        {
+#if wxUSE_FONTMAP
+            // 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);
         {
             SetEncoding(encoding);

+                encodingfound = true;

         }
         }

-        else // assume it is the face name
+            else

         {
         {

+#endif // wxUSE_FONTMAP
+
+                // assume it is the face name

             if ( !face.empty() )
             {
             if ( !face.empty() )
             {

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

             }
 
             face += token;
 
             // skip the code which resets face below
             continue;
             }
 
             face += token;
 
             // 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
         }
 
         // if we had had the facename, we shouldn't continue appending tokens


@@ -524,7 +909,40 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
         // bar")
         if ( !face.empty() )
         {
         // bar")
         if ( !face.empty() )
         {

-            SetFaceName(face);
+            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
+            else if (
+#if wxUSE_FONTENUM
+                    !wxFontEnumerator::IsValidFacename(face) ||
+#endif // wxUSE_FONTENUM
+                    !SetFaceName(face) )
+            {
+                SetFaceName(wxNORMAL_FONT->GetFaceName());
+            }
+

             face.clear();
         }
     }
             face.clear();
         }
     }


@@ -532,11 +950,57 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
     // we might not have flushed it inside the loop
     if ( !face.empty() )
     {
     // 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 (
+#if wxUSE_FONTENUM
+                !wxFontEnumerator::IsValidFacename(face) ||
+#endif // wxUSE_FONTENUM
+                !SetFaceName(face) )
+            {
+                SetFaceName(wxNORMAL_FONT->GetFaceName());
+            }
+    }
+
+    // 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
+
+
+// wxFont <-> wxString utilities, used by wxConfig
+wxString wxToString(const wxFontBase& font)
+{
+    return font.IsOk() ? font.GetNativeFontInfoDesc()
+                       : wxString();
+}
+
+bool wxFromString(const wxString& str, wxFontBase *font)
+{
+    wxCHECK_MSG( font, false, wxT("NULL output parameter") );
+
+    if ( str.empty() )
+    {
+        *font = wxNullFont;
+        return true;

     }
 
     }
 

-    return TRUE;
+    return font->SetNativeFontInfo(str);

 }
 
 }
 

-#endif // generic or wxMSW