]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/fontutil.cpp
fixed typo (missing comma) in MIME test
[wxWidgets.git] / src / unix / fontutil.cpp
index fa20c759858aa0cfe519ea0fb65e3294a08cb38f..7379c3aab2c98731f1fe07412867963af28a3c32 100644 (file)
 #endif // PCH
 
 #ifdef __X__
+    #ifdef __VMS__
+        #pragma message disable nosimpint
+    #endif
+
     #include <X11/Xlib.h>
 
+    #ifdef __VMS__
+        #pragma message enable nosimpint
+    #endif
+
     #include "wx/utils.h"       // for wxGetDisplay()
 #elif defined(__WXGTK__)
-    #include "gdk/gdk.h"
+    // we have to declare struct tm to avoid problems with first forward
+    // declaring it in C code (glib.h included from gdk.h does it) and then
+    // defining it when time.h is included from the headers below - this is
+    // known not to work at least with Sun CC 6.01
+    #include <time.h>
+
+    #include <gdk/gdk.h>
 #endif
 
 #include "wx/fontutil.h"
 #include "wx/fontmap.h"
 #include "wx/tokenzr.h"
+#include "wx/hash.h"
+#include "wx/module.h"
+
+// ----------------------------------------------------------------------------
+// private data
+// ----------------------------------------------------------------------------
+
+static wxHashTable *g_fontHash = (wxHashTable*) NULL;
 
 // ----------------------------------------------------------------------------
 // private functions
 
 // define the functions to create and destroy native fonts for this toolkit
 #ifdef __X__
-    static inline wxNativeFont wxLoadFont(const wxString& fontSpec)
+    wxNativeFont wxLoadFont(const wxString& fontSpec)
     {
         return XLoadQueryFont((Display *)wxGetDisplay(), fontSpec);
     }
 
-    static inline void wxFreeFont(wxNativeFont font)
+    inline void wxFreeFont(wxNativeFont font)
     {
         XFreeFont((Display *)wxGetDisplay(), (XFontStruct *)font);
     }
 #elif defined(__WXGTK__)
-    static inline wxNativeFont wxLoadFont(const wxString& fontSpec)
+    wxNativeFont wxLoadFont(const wxString& fontSpec)
     {
        return gdk_font_load( wxConvertWX2MB(fontSpec) );
     }
 
-    static inline void wxFreeFont(wxNativeFont font)
+    inline void wxFreeFont(wxNativeFont font)
     {
         gdk_font_unref(font);
     }
@@ -81,7 +103,8 @@ static wxNativeFont wxLoadQueryFont(int pointSize,
                                     bool underlined,
                                     const wxString& facename,
                                     const wxString& xregistry,
-                                    const wxString& xencoding);
+                                    const wxString& xencoding,
+                                    wxString* xFontName);
 
 // ============================================================================
 // implementation
@@ -92,10 +115,17 @@ static wxNativeFont wxLoadQueryFont(int pointSize,
 // ----------------------------------------------------------------------------
 
 // convert to/from the string representation: format is
-//      registry-encoding[-facename]
+//      encodingid;registry;encoding[;facename]
 bool wxNativeEncodingInfo::FromString(const wxString& s)
 {
-    wxStringTokenizer tokenizer(s, _T("-"));
+    // use ";", not "-" because it may be part of encoding name
+    wxStringTokenizer tokenizer(s, _T(";"));
+
+    wxString encid = tokenizer.GetNextToken();
+    long enc;
+    if ( !encid.ToLong(&enc) )
+        return FALSE;
+    encoding = (wxFontEncoding)enc;
 
     xregistry = tokenizer.GetNextToken();
     if ( !xregistry )
@@ -114,15 +144,163 @@ bool wxNativeEncodingInfo::FromString(const wxString& s)
 wxString wxNativeEncodingInfo::ToString() const
 {
     wxString s;
-    s << xregistry << _T('-') << xencoding;
+    s << (long)encoding << _T(';') << xregistry << _T(';') << xencoding;
     if ( !!facename )
     {
-        s << _T('-') << facename;
+        s << _T(';') << facename;
     }
 
     return s;
 }
 
+// ----------------------------------------------------------------------------
+// wxNativeFontInfo
+// ----------------------------------------------------------------------------
+
+void wxNativeFontInfo::Init()
+{
+    m_isDefault = TRUE;
+}
+
+bool wxNativeFontInfo::FromString(const wxString& s)
+{
+    wxStringTokenizer tokenizer(s, _T(";"));
+
+    // check the version
+    wxString token = tokenizer.GetNextToken();
+    if ( token != _T('0') )
+        return FALSE;
+
+    xFontName = tokenizer.GetNextToken();
+
+    // this should be the end
+    if ( tokenizer.HasMoreTokens() )
+        return FALSE;
+
+    return FromXFontName(xFontName);
+}
+
+wxString wxNativeFontInfo::ToString() const
+{
+    // 0 is the version
+    return wxString::Format(_T("%d;%s"), 0, GetXFontName().c_str());
+}
+
+bool wxNativeFontInfo::FromUserString(const wxString& s)
+{
+    return FromXFontName(s);
+}
+
+wxString wxNativeFontInfo::ToUserString() const
+{
+    return GetXFontName();
+}
+
+bool wxNativeFontInfo::HasElements() const
+{
+    // we suppose that the foundry is never empty, so if it is it means that we
+    // had never parsed the XLFD
+    return !fontElements[0].empty();
+}
+
+wxString wxNativeFontInfo::GetXFontComponent(wxXLFDField field) const
+{
+    wxCHECK_MSG( field < wxXLFD_MAX, _T(""), _T("invalid XLFD field") );
+
+    if ( !HasElements() )
+    {
+        // const_cast
+        if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
+            return _T("");
+    }
+
+    return fontElements[field];
+}
+
+bool wxNativeFontInfo::FromXFontName(const wxString& fontname)
+{
+    // TODO: we should be able to handle the font aliases here, but how?
+    wxStringTokenizer tokenizer(fontname, _T("-"));
+
+    // skip the leading, usually empty field (font name registry)
+    if ( !tokenizer.HasMoreTokens() )
+        return FALSE;
+
+    (void)tokenizer.GetNextToken();
+
+    for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ )
+    {
+        if ( !tokenizer.HasMoreTokens() )
+        {
+            // not enough elements in the XLFD - or maybe an alias
+            return FALSE;
+        }
+
+        fontElements[n] = tokenizer.GetNextToken();
+    }
+
+    // this should be all
+    return !tokenizer.HasMoreTokens();
+}
+
+wxString wxNativeFontInfo::GetXFontName() const
+{
+    if ( xFontName.empty() )
+    {
+        for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ )
+        {
+            // replace the non specified elements with '*' except for the
+            // additional style which is usually just omitted
+            wxString elt = fontElements[n];
+            if ( elt.empty() && n != wxXLFD_ADDSTYLE )
+            {
+                elt = _T('*');
+            }
+
+            // const_cast
+            ((wxNativeFontInfo *)this)->xFontName << _T('-') << elt;
+        }
+    }
+
+    return xFontName;
+}
+
+void
+wxNativeFontInfo::SetXFontComponent(wxXLFDField field, const wxString& value)
+{
+    wxCHECK_RET( field < wxXLFD_MAX, _T("invalid XLFD field") );
+
+    // this class should be initialized with a valid font spec first and only
+    // then the fields may be modified!
+    wxASSERT_MSG( !IsDefault(), _T("can't modify an uninitialized XLFD") );
+
+    if ( !HasElements() )
+    {
+        // const_cast
+        if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
+        {
+            wxFAIL_MSG( _T("can't set font element for invalid XLFD") );
+
+            return;
+        }
+    }
+
+    fontElements[field] = value;
+
+    // invalidate the XFLD, it doesn't correspond to the font elements any more
+    xFontName.clear();
+}
+
+void wxNativeFontInfo::SetXFontName(const wxString& xFontName_)
+{
+    // invalidate the font elements, GetXFontComponent() will reparse the XLFD
+    fontElements[0].clear();
+
+    xFontName = xFontName_;
+
+    m_isDefault = FALSE;
+}
+
 // ----------------------------------------------------------------------------
 // common functions
 // ----------------------------------------------------------------------------
@@ -150,6 +328,7 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding,
         case wxFONTENCODING_ISO8859_9:
         case wxFONTENCODING_ISO8859_10:
         case wxFONTENCODING_ISO8859_11:
+        case wxFONTENCODING_ISO8859_12:
         case wxFONTENCODING_ISO8859_13:
         case wxFONTENCODING_ISO8859_14:
         case wxFONTENCODING_ISO8859_15:
@@ -160,10 +339,15 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding,
             }
             break;
 
+        case wxFONTENCODING_UTF8:
+            info->xregistry = wxT("iso10646");
+            info->xencoding = wxT("*");
+            break;
+
         case wxFONTENCODING_KOI8:
             info->xregistry = wxT("koi8");
 
-            // we don't make distinction between koi8-r and koi8-u (so far)
+            // we don't make distinction between koi8-r, koi8-u and koi8-ru (so far)
             info->xencoding = wxT("*");
             break;
 
@@ -192,6 +376,8 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding,
             return FALSE;
     }
 
+    info->encoding = encoding;
+
     return TRUE;
 }
 
@@ -216,7 +402,8 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize,
                                     int weight,
                                     bool underlined,
                                     const wxString &facename,
-                                    wxFontEncoding encoding)
+                                    wxFontEncoding encoding,
+                                    wxString* xFontName)
 {
     if ( encoding == wxFONTENCODING_DEFAULT )
     {
@@ -237,7 +424,9 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize,
         if ( !wxGetNativeFontEncoding(encoding, &info) ||
              !wxTestFontEncoding(info) )
         {
+#if wxUSE_FONTMAP
             if ( !wxTheFontMapper->GetAltForEncoding(encoding, &info) )
+#endif // wxUSE_FONTMAP
             {
                 // unspported encoding - replace it with the default
                 //
@@ -248,11 +437,43 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize,
             }
         }
     }
-    
+
     // OK, we have the correct xregistry/xencoding in info structure
-    wxNativeFont font = wxLoadQueryFont( pointSize, family, style, weight,
-                                         underlined, facename,
-                                         info.xregistry, info.xencoding );
+    wxNativeFont font = 0;
+
+    // if we already have the X font name, try to use it
+    if( xFontName && !xFontName->IsEmpty() )
+    {
+        //
+        //  Make sure point size is correct for scale factor.
+        //
+        wxStringTokenizer tokenizer(*xFontName, _T("-"), wxTOKEN_RET_DELIMS);
+        wxString newFontName;
+
+        for(int i = 0; i < 8; i++)
+          newFontName += tokenizer.NextToken();
+
+        (void) tokenizer.NextToken();
+
+        newFontName += wxString::Format("%d-", pointSize);
+
+        while(tokenizer.HasMoreTokens())
+          newFontName += tokenizer.GetNextToken();
+
+        font = wxLoadFont(newFontName);
+
+        if(font)
+          *xFontName = newFontName;
+    }
+
+    // try to load exactly the font requested first
+    if( !font )
+    {
+        font = wxLoadQueryFont( pointSize, family, style, weight,
+                                underlined, facename,
+                                info.xregistry, info.xencoding,
+                                xFontName );
+    }
 
     if ( !font )
     {
@@ -266,14 +487,16 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize,
         for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 )
         {
             font = wxLoadQueryFont(i, family, style, weight, underlined,
-                                   facename, info.xregistry, info.xencoding);
+                                   facename, info.xregistry, info.xencoding,
+                                   xFontName);
         }
 
         // Search for larger size (approx.)
         for ( i = pointSize + 10; !font && i <= max_size; i += 10 )
         {
             font = wxLoadQueryFont(i, family, style, weight, underlined,
-                                   facename, info.xregistry, info.xencoding);
+                                   facename, info.xregistry, info.xencoding,
+                                   xFontName);
         }
 
         // Try default family
@@ -281,23 +504,53 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize,
         {
             font = wxLoadQueryFont(pointSize, wxDEFAULT, style, weight,
                                    underlined, facename,
-                                   info.xregistry, info.xencoding );
+                                   info.xregistry, info.xencoding,
+                                   xFontName );
         }
 
-        // Bogus font I
+        // ignore size, family, style and weight but try to find font with the
+        // given facename and encoding
         if ( !font )
         {
             font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
                                    underlined, facename,
-                                   info.xregistry, info.xencoding);
-        }
+                                   info.xregistry, info.xencoding,
+                                   xFontName);
 
-        // Bogus font II
-        if ( !font )
-        {
-            font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
-                                   underlined, wxEmptyString,
-                                   info.xregistry, info.xencoding);
+            // ignore family as well
+            if ( !font )
+            {
+                font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
+                                       underlined, wxEmptyString,
+                                       info.xregistry, info.xencoding,
+                                       xFontName);
+
+                // if it still failed, try to get the font of any size but
+                // with the requested encoding: this can happen if the
+                // encoding is only available in one size which happens to be
+                // different from 120
+                if ( !font )
+                {
+                    font = wxLoadQueryFont(-1, wxDEFAULT, wxNORMAL, wxNORMAL,
+                                           FALSE, wxEmptyString,
+                                           info.xregistry, info.xencoding,
+                                           xFontName);
+
+                    // this should never happen as we had tested for it in the
+                    // very beginning, but if it does, do return something non
+                    // NULL or we'd crash in wxFont code
+                    if ( !font )
+                    {
+                        wxFAIL_MSG( _T("this encoding should be available!") );
+
+                        font = wxLoadQueryFont(-1,
+                                               wxDEFAULT, wxNORMAL, wxNORMAL,
+                                               FALSE, wxEmptyString,
+                                               _T("*"), _T("*"),
+                                               xFontName);
+                    }
+                }
+            }
         }
     }
 
@@ -318,7 +571,15 @@ static bool wxTestFontSpec(const wxString& fontspec)
         return TRUE;
     }
 
-    wxNativeFont test = wxLoadFont(fontspec);
+    wxNativeFont test = (wxNativeFont) g_fontHash->Get( fontspec );
+    if (test)
+    {
+        return TRUE;
+    }
+
+    test = wxLoadFont(fontspec);
+    g_fontHash->Put( fontspec, (wxObject*) test );
+
     if ( test )
     {
         wxFreeFont(test);
@@ -338,7 +599,8 @@ static wxNativeFont wxLoadQueryFont(int pointSize,
                                     bool WXUNUSED(underlined),
                                     const wxString& facename,
                                     const wxString& xregistry,
-                                    const wxString& xencoding)
+                                    const wxString& xencoding,
+                                    wxString* xFontName)
 {
     wxString xfamily;
     switch (family)
@@ -351,7 +613,77 @@ static wxNativeFont wxLoadQueryFont(int pointSize,
         case wxSCRIPT:     xfamily = wxT("utopia"); break;
         default:           xfamily = wxT("*");
     }
+#if wxUSE_NANOX
+    int xweight;
+    switch (weight)
+    {
+         case wxBOLD:
+             {
+                 xweight = MWLF_WEIGHT_BOLD;
+                 break;
+             }
+        case wxLIGHT:
+             {
+                 xweight = MWLF_WEIGHT_LIGHT;
+                 break;
+             }
+         case wxNORMAL:
+             {
+                 xweight = MWLF_WEIGHT_NORMAL;
+                 break;
+             }
 
+     default:
+             {
+                 xweight = MWLF_WEIGHT_DEFAULT;
+                 break;
+             }
+    }
+    GR_SCREEN_INFO screenInfo;
+    GrGetScreenInfo(& screenInfo);
+
+    int yPixelsPerCM = screenInfo.ydpcm;
+
+    // A point is 1/72 of an inch.
+    // An inch is 2.541 cm.
+    // So pixelHeight = (pointSize / 72) (inches) * 2.541 (for cm) * yPixelsPerCM (for pixels)
+    // In fact pointSize is 10 * the normal point size so
+    // divide by 10.
+
+    int pixelHeight = (int) ( (((float)pointSize) / 720.0) * 2.541 * (float) yPixelsPerCM * fudgeFactor) ;
+
+    // An alternative: assume that the screen is 72 dpi.
+    //int pixelHeight = (int) (((float)pointSize / 720.0) * 72.0) ;
+    //int pixelHeight = (int) ((float)pointSize / 10.0) ;
+    
+    GR_LOGFONT logFont;
+    logFont.lfHeight = pixelHeight;
+    logFont.lfWidth = 0;
+    logFont.lfEscapement = 0;
+    logFont.lfOrientation = 0;
+    logFont.lfWeight = xweight;
+    logFont.lfItalic = (style == wxNORMAL ? 0 : 1) ;
+    logFont.lfUnderline = 0;
+    logFont.lfStrikeOut = 0;
+    logFont.lfCharSet = MWLF_CHARSET_DEFAULT; // TODO: select appropriate one
+    logFont.lfOutPrecision = MWLF_TYPE_DEFAULT;
+    logFont.lfClipPrecision = 0; // Not used
+    logFont.lfRoman = (family == wxROMAN ? 1 : 0) ;
+    logFont.lfSerif = (family == wxSWISS ? 0 : 1) ;
+    logFont.lfSansSerif = !logFont.lfSerif ;
+    logFont.lfModern = (family == wxMODERN ? 1 : 0) ;
+    logFont.lfProportional = (family == wxTELETYPE ? 0 : 1) ;
+    logFont.lfOblique = 0;
+    logFont.lfSmallCaps = 0;
+    logFont.lfPitch = 0; // 0 = default
+    strcpy(logFont.lfFaceName, facename.c_str());
+
+    XFontStruct* fontInfo = (XFontStruct*) malloc(sizeof(XFontStruct));
+    fontInfo->fid = GrCreateFont((GR_CHAR*) facename.c_str(), pixelHeight, & logFont);
+    GrGetFontInfo(fontInfo->fid, & fontInfo->info);
+    return (wxNativeFont) fontInfo;
+    
+#else
     wxString fontSpec;
     if (!facename.IsEmpty())
     {
@@ -368,10 +700,47 @@ static wxNativeFont wxLoadQueryFont(int pointSize,
     wxString xstyle;
     switch (style)
     {
-        case wxITALIC:     xstyle = wxT("i"); break;
-        case wxSLANT:      xstyle = wxT("o"); break;
-        case wxNORMAL:     xstyle = wxT("r"); break;
-        default:           xstyle = wxT("*"); break;
+        case wxSLANT:
+            fontSpec.Printf(wxT("-*-%s-*-o-*-*-*-*-*-*-*-*-*-*"),
+                    xfamily.c_str());
+            if ( wxTestFontSpec(fontSpec) )
+            {
+                xstyle = wxT("o");
+                break;
+            }
+            // fall through - try wxITALIC now
+
+        case wxITALIC:
+            fontSpec.Printf(wxT("-*-%s-*-i-*-*-*-*-*-*-*-*-*-*"),
+                    xfamily.c_str());
+            if ( wxTestFontSpec(fontSpec) )
+            {
+                xstyle = wxT("i");
+            }
+            else if ( style == wxITALIC ) // and not wxSLANT
+            {
+                // try wxSLANT
+                fontSpec.Printf(wxT("-*-%s-*-o-*-*-*-*-*-*-*-*-*-*"),
+                        xfamily.c_str());
+                if ( wxTestFontSpec(fontSpec) )
+                {
+                    xstyle = wxT("o");
+                }
+                else
+                {
+                    // no italic, no slant - leave default
+                    xstyle = wxT("*");
+                }
+            }
+            break;
+
+        default:
+            wxFAIL_MSG(_T("unknown font style"));
+            // fall back to normal
+
+        case wxNORMAL:
+            xstyle = wxT("r");
+            break;
     }
 
     wxString xweight;
@@ -470,11 +839,56 @@ static wxNativeFont wxLoadQueryFont(int pointSize,
         default:           xweight = wxT("*"); break;
     }
 
+    // if pointSize is -1, don't specify any
+    wxString sizeSpec;
+    if ( fontSpec == -1 )
+    {
+        sizeSpec = _T('*');
+    }
+    else
+    {
+        sizeSpec.Printf(_T("%d"), pointSize);
+    }
+
     // construct the X font spec from our data
-    fontSpec.Printf(wxT("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-%s-%s"),
+    fontSpec.Printf(wxT("-*-%s-%s-%s-normal-*-*-%s-*-*-*-*-%s-%s"),
                     xfamily.c_str(), xweight.c_str(), xstyle.c_str(),
-                    pointSize, xregistry.c_str(), xencoding.c_str());
+                    sizeSpec.c_str(), xregistry.c_str(), xencoding.c_str());
+
+    if( xFontName )
+        *xFontName = fontSpec;
 
     return wxLoadFont(fontSpec);
+#endif
+    // wxUSE_NANOX
 }
 
+// ----------------------------------------------------------------------------
+// wxFontModule
+// ----------------------------------------------------------------------------
+
+class wxFontModule : public wxModule
+{
+public:
+    bool OnInit();
+    void OnExit();
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxFontModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxFontModule, wxModule)
+
+bool wxFontModule::OnInit()
+{
+    g_fontHash = new wxHashTable( wxKEY_STRING );
+
+    return TRUE;
+}
+
+void wxFontModule::OnExit()
+{
+    delete g_fontHash;
+
+    g_fontHash = (wxHashTable *)NULL;
+}