]> git.saurik.com Git - wxWidgets.git/blobdiff - src/gtk/font.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ambiguous ctor call resolved
[wxWidgets.git] / src / gtk / font.cpp
diff --git a/src/gtk/font.cpp b/src/gtk/font.cpp
index c49f0d0448fc82c16464fbc530cff184d090dd14..7de3862b47820172e47a68f768db6542158ccfc7 100644 (file)
--- a/src/gtk/font.cpp
+++ b/src/gtk/font.cpp
@@ -13,13 +13,20 @@
 
 #include "wx/font.h"
 #include "wx/utils.h"
 
 #include "wx/font.h"
 #include "wx/utils.h"
+#include "wx/log.h"
+#include "wx/gdicmn.h"
+#include "wx/tokenzr.h"
 #include <strings.h>
 
 #include <strings.h>
 
+#include "gdk/gdk.h"
+
 //-----------------------------------------------------------------------------
 // local data
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 // local data
 //-----------------------------------------------------------------------------
 
+/*
 extern wxFontNameDirectory *wxTheFontNameDirectory;
 extern wxFontNameDirectory *wxTheFontNameDirectory;
+*/
 
 //-----------------------------------------------------------------------------
 // wxFont
 
 //-----------------------------------------------------------------------------
 // wxFont
@@ -37,7 +44,6 @@ public:
     int       m_pointSize;
     int       m_family, m_style, m_weight;
     bool      m_underlined;
     int       m_pointSize;
     int       m_family, m_style, m_weight;
     bool      m_underlined;
-    int       m_fontId;
     wxString  m_faceName;
 
     bool      m_byXFontName;
     wxString  m_faceName;
 
     bool      m_byXFontName;
@@ -54,7 +60,6 @@ wxFontRefData::wxFontRefData() : m_scaled_xfonts(wxKEY_INTEGER)
     m_style = wxNORMAL;
     m_weight = wxNORMAL;
     m_underlined = FALSE;
     m_style = wxNORMAL;
     m_weight = wxNORMAL;
     m_underlined = FALSE;
-    m_fontId = 0;
     m_font = (GdkFont *) NULL;
 }
 
     m_font = (GdkFont *) NULL;
 }
 
@@ -66,7 +71,6 @@ wxFontRefData::wxFontRefData( const wxFontRefData& data ) : m_scaled_xfonts(wxKE
     m_style = data.m_style;
     m_weight = data.m_weight;
     m_underlined = data.m_underlined;
     m_style = data.m_style;
     m_weight = data.m_weight;
     m_underlined = data.m_underlined;
-    m_fontId = data.m_fontId;
     m_faceName = data.m_faceName;
     m_font = (GdkFont *) NULL;
     if (data.m_font) m_font = gdk_font_ref( data.m_font );
     m_faceName = data.m_faceName;
     m_font = (GdkFont *) NULL;
     if (data.m_font) m_font = gdk_font_ref( data.m_font );
@@ -96,46 +100,81 @@ wxFont::wxFont()
     if (wxTheFontList) wxTheFontList->Append( this );
 }
 
     if (wxTheFontList) wxTheFontList->Append( this );
 }
 
-wxFont::wxFont( char *xFontName )
+wxFont::wxFont( GdkFont *font, char *xFontName )
 {
     if (!xFontName) return;
 
     m_refData = new wxFontRefData();
 
 {
     if (!xFontName) return;
 
     m_refData = new wxFontRefData();
 
-    M_FONTDATA->m_byXFontName = TRUE;
-    M_FONTDATA->m_font = gdk_font_load( xFontName );
+//  M_FONTDATA->m_byXFontName = TRUE;
+    M_FONTDATA->m_font = font;
+
+    wxString tmp;
+
+    wxString fontname( xFontName );
+    wxStringTokenizer tn( fontname, _T("-") );
+
+    tn.GetNextToken();                           // foundry
+
+    M_FONTDATA->m_faceName = tn.GetNextToken();  // courier
+
+    tmp = tn.GetNextToken().MakeUpper();
+    if (tmp == _T("BOLD")) M_FONTDATA->m_weight = wxBOLD;
+
+    tmp = tn.GetNextToken().MakeUpper();
+    if (tmp == _T("I")) M_FONTDATA->m_style = wxITALIC;
+    if (tmp == _T("O")) M_FONTDATA->m_style = wxITALIC;
+
+    tn.GetNextToken();                           // set width
+    tn.GetNextToken();                           // ?
+    tn.GetNextToken();                           // pixel size
+
+    tmp = tn.GetNextToken();                     // pointsize
+    int num =  wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
+    M_FONTDATA->m_pointSize = num / 10;
+
+    tn.GetNextToken();                           // x-res
+    tn.GetNextToken();                           // y-res
+
+    tmp = tn.GetNextToken().MakeUpper();
+    if (tmp == _T("M")) M_FONTDATA->m_family = wxMODERN;
+    else if (M_FONTDATA->m_faceName == _T("TIMES")) M_FONTDATA->m_family = wxROMAN;
+    else if (M_FONTDATA->m_faceName == _T("HELVETICA")) M_FONTDATA->m_family = wxSWISS;
+    else if (M_FONTDATA->m_faceName == _T("LUCIDATYPEWRITER")) M_FONTDATA->m_family = wxTELETYPE;
+    else if (M_FONTDATA->m_faceName == _T("LUCIDA")) M_FONTDATA->m_family = wxDECORATIVE;
+    else if (M_FONTDATA->m_faceName == _T("UTOPIA")) M_FONTDATA->m_family = wxSCRIPT;
 }
 
 }
 
-wxFont::wxFont( int pointSize, int family, int style, int weight, bool underlined = FALSE, 
-                const wxString& face = wxEmptyString )
+wxFont::wxFont( int pointSize, int family, int style, int weight, bool underlined, const wxString& face )
 {
     m_refData = new wxFontRefData();
 
 {
     m_refData = new wxFontRefData();
 
-    if (family == wxDEFAULT) family = wxSWISS;
-    M_FONTDATA->m_family = family;
-    
-    if (!face.IsEmpty())
-    {
-        M_FONTDATA->m_faceName = face;
-        M_FONTDATA->m_fontId = wxTheFontNameDirectory->FindOrCreateFontId( face, family );
-        M_FONTDATA->m_family  = wxTheFontNameDirectory->GetFamily( family );
-    }
+    if (family == wxDEFAULT)
+        M_FONTDATA->m_family = wxSWISS;
     else
     else
-    {
-        M_FONTDATA->m_fontId = family;
-        M_FONTDATA->m_family  = wxTheFontNameDirectory->GetFamily( family );
-    }
+        M_FONTDATA->m_family = family;
+
+    if (!face.IsEmpty()) M_FONTDATA->m_faceName = face;
+
+    if (style == wxDEFAULT)
+        M_FONTDATA->m_style = wxNORMAL;
+    else
+        M_FONTDATA->m_style = style;
+
+    if (weight == wxDEFAULT)
+        M_FONTDATA->m_weight = wxNORMAL;
+    else
+        M_FONTDATA->m_weight = weight;
+
+    if (pointSize == wxDEFAULT)
+        M_FONTDATA->m_pointSize = 12;
+    else
+        M_FONTDATA->m_pointSize = pointSize;
 
 
-    if (style == wxDEFAULT) style = wxNORMAL;
-    M_FONTDATA->m_style = style;
-    if (weight == wxDEFAULT) weight = wxNORMAL;
-    M_FONTDATA->m_weight = weight;
-    if (pointSize == wxDEFAULT) pointSize = 12;
-    M_FONTDATA->m_pointSize = pointSize;
     M_FONTDATA->m_underlined = underlined;
 
     if (wxTheFontList) wxTheFontList->Append( this );
     M_FONTDATA->m_underlined = underlined;
 
     if (wxTheFontList) wxTheFontList->Append( this );
-  
+
 }
 
 wxFont::wxFont( const wxFont& font )
 }
 
 wxFont::wxFont( const wxFont& font )
@@ -157,12 +196,12 @@ wxFont& wxFont::operator = ( const wxFont& font )
     return *this;
 }
 
     return *this;
 }
 
-bool wxFont::operator == ( const wxFont& font )
+bool wxFont::operator == ( const wxFont& font ) const
 {
     return m_refData == font.m_refData;
 }
 
 {
     return m_refData == font.m_refData;
 }
 
-bool wxFont::operator != ( const wxFont& font )
+bool wxFont::operator != ( const wxFont& font ) const
 {
     return m_refData != font.m_refData;
 }
 {
     return m_refData != font.m_refData;
 }
@@ -174,98 +213,90 @@ bool wxFont::Ok() const
 
 int wxFont::GetPointSize() const
 {
 
 int wxFont::GetPointSize() const
 {
-    wxCHECK_MSG( Ok(), 0, "invalid font" );
+    wxCHECK_MSG( Ok(), 0, _T("invalid font") );
 
     return M_FONTDATA->m_pointSize;
 }
 
 wxString wxFont::GetFaceName() const
 {
 
     return M_FONTDATA->m_pointSize;
 }
 
 wxString wxFont::GetFaceName() const
 {
-    wxCHECK_MSG( Ok(), "", "invalid font" );
+    wxCHECK_MSG( Ok(), _T(""), _T("invalid font") );
 
 
-    wxString s = wxTheFontNameDirectory->GetFontName( M_FONTDATA->m_fontId );
-    return s;
+    return M_FONTDATA->m_faceName;
 }
 
 int wxFont::GetFamily() const
 {
 }
 
 int wxFont::GetFamily() const
 {
-    wxCHECK_MSG( Ok(), 0, "invalid font" );
+    wxCHECK_MSG( Ok(), 0, _T("invalid font") );
 
     return M_FONTDATA->m_family;
 }
 
 wxString wxFont::GetFamilyString() const
 {
 
     return M_FONTDATA->m_family;
 }
 
 wxString wxFont::GetFamilyString() const
 {
-    wxCHECK_MSG( Ok(), "wxDEFAULT", "invalid font" );
+    wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
 
     switch (M_FONTDATA->m_family)
     {
 
     switch (M_FONTDATA->m_family)
     {
-        case wxDECORATIVE:   return wxString("wxDECORATIVE");
-        case wxROMAN:        return wxString("wxROMAN");
-        case wxSCRIPT:       return wxString("wxSCRIPT");
-        case wxSWISS:        return wxString("wxSWISS");
-        case wxMODERN:       return wxString("wxMODERN");
-        case wxTELETYPE:     return wxString("wxTELETYPE");
-        default:             return "wxDEFAULT";
+        case wxDECORATIVE:   return wxString(_T("wxDECORATIVE"));
+        case wxROMAN:        return wxString(_T("wxROMAN"));
+        case wxSCRIPT:       return wxString(_T("wxSCRIPT"));
+        case wxSWISS:        return wxString(_T("wxSWISS"));
+        case wxMODERN:       return wxString(_T("wxMODERN"));
+        case wxTELETYPE:     return wxString(_T("wxTELETYPE"));
+        default:             return _T("wxDEFAULT");
     }
 
     return "wxDEFAULT";
 }
 
     }
 
     return "wxDEFAULT";
 }
 
-int wxFont::GetFontId() const
-{
-    wxCHECK_MSG( Ok(), 0, "invalid font" );
-
-    return M_FONTDATA->m_fontId; // stub
-}
-
 int wxFont::GetStyle() const
 {
 int wxFont::GetStyle() const
 {
-    wxCHECK_MSG( Ok(), 0, "invalid font" );
+    wxCHECK_MSG( Ok(), 0, _T("invalid font") );
 
     return M_FONTDATA->m_style;
 }
 
 wxString wxFont::GetStyleString() const
 {
 
     return M_FONTDATA->m_style;
 }
 
 wxString wxFont::GetStyleString() const
 {
-    wxCHECK_MSG( Ok(), "wxDEFAULT", "invalid font" );
+    wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
 
     switch (M_FONTDATA->m_style)
     {
 
     switch (M_FONTDATA->m_style)
     {
-        case wxNORMAL:   return wxString("wxNORMAL");
-        case wxSLANT:    return wxString("wxSLANT");
-        case wxITALIC:   return wxString("wxITALIC");
-        default:         return wxString("wxDEFAULT");
+        case wxNORMAL:   return wxString(_T("wxNORMAL"));
+        case wxSLANT:    return wxString(_T("wxSLANT"));
+        case wxITALIC:   return wxString(_T("wxITALIC"));
+        default:         return wxString(_T("wxDEFAULT"));
     }
 
     }
 
-    return wxString("wxDEFAULT");
+    return wxString(_T("wxDEFAULT"));
 }
 
 int wxFont::GetWeight() const
 {
 }
 
 int wxFont::GetWeight() const
 {
-    wxCHECK_MSG( Ok(), 0, "invalid font" );
+    wxCHECK_MSG( Ok(), 0, _T("invalid font") );
 
     return M_FONTDATA->m_weight;
 }
 
 wxString wxFont::GetWeightString() const
 {
 
     return M_FONTDATA->m_weight;
 }
 
 wxString wxFont::GetWeightString() const
 {
-    wxCHECK_MSG( Ok(), "wxDEFAULT", "invalid font" );
+    wxCHECK_MSG( Ok(), _T("wxDEFAULT"), _T("invalid font") );
 
     switch (M_FONTDATA->m_weight)
     {
 
     switch (M_FONTDATA->m_weight)
     {
-        case wxNORMAL:   return wxString("wxNORMAL");
-        case wxBOLD:     return wxString("wxBOLD");
-        case wxLIGHT:    return wxString("wxLIGHT");
-        default:         return wxString("wxDEFAULT");
+        case wxNORMAL:   return wxString(_T("wxNORMAL"));
+        case wxBOLD:     return wxString(_T("wxBOLD"));
+        case wxLIGHT:    return wxString(_T("wxLIGHT"));
+        default:         return wxString(_T("wxDEFAULT"));
     }
 
     }
 
-    return wxString("wxDEFAULT");
+    return wxString(_T("wxDEFAULT"));
 }
 
 bool wxFont::GetUnderlined() const
 {
 }
 
 bool wxFont::GetUnderlined() const
 {
-    wxCHECK_MSG( Ok(), FALSE, "invalid font" );
+    wxCHECK_MSG( Ok(), FALSE, _T("invalid font") );
 
     return M_FONTDATA->m_underlined;
 }
 
     return M_FONTDATA->m_underlined;
 }
@@ -274,13 +305,13 @@ void wxFont::Unshare()
 {
     if (!m_refData)
     {
 {
     if (!m_refData)
     {
-       m_refData = new wxFontRefData();
+        m_refData = new wxFontRefData();
     }
     else
     {
     }
     else
     {
-       wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
-       UnRef();
-       m_refData = ref;
+        wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
+        UnRef();
+        m_refData = ref;
     }
 }
 
     }
 }
 
@@ -330,22 +361,21 @@ void wxFont::SetUnderlined(bool underlined)
 // get internal representation of font
 //-----------------------------------------------------------------------------
 
 // get internal representation of font
 //-----------------------------------------------------------------------------
 
-// local help function
-static GdkFont *wxLoadQueryNearestFont(int point_size, int fontid,
-        int style, int weight,
-        bool underlined);
+static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight,
+                                        bool underlined, const wxString &facename );
 
 
-GdkFont *wxFont::GetInternalFont(float scale) const
+GdkFont *wxFont::GetInternalFont( float scale ) const
 {
     if (!Ok())
     {
 {
     if (!Ok())
     {
-        wxFAIL_MSG( "invalid font" );
+        wxFAIL_MSG( _T("invalid font") );
         return (GdkFont*) NULL;
     }
 
         return (GdkFont*) NULL;
     }
 
+    /* short cut if the special X font constructor has been used */
     if (M_FONTDATA->m_byXFontName) return M_FONTDATA->m_font;
 
     if (M_FONTDATA->m_byXFontName) return M_FONTDATA->m_font;
 
-    long int_scale = long(scale * 100.0 + 0.5); // key for fontlist
+    long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */
     int point_scale = (M_FONTDATA->m_pointSize * 10 * int_scale) / 100;
     GdkFont *font = (GdkFont *) NULL;
 
     int point_scale = (M_FONTDATA->m_pointSize * 10 * int_scale) / 100;
     GdkFont *font = (GdkFont *) NULL;
 
@@ -356,13 +386,7 @@ GdkFont *wxFont::GetInternalFont(float scale) const
     }
     else
     {
     }
     else
     {
-        /*
-           if (int_scale == 100) printf( "int_scale.\n" );
-           if (M_FONTDATA->m_style == wxSWISS) printf( "swiss.\n" );
-           if (M_FONTDATA->m_pointSize == 12) printf( "12.\n" );
-           if (M_FONTDATA->m_weight == wxNORMAL) printf( "normal.\n" );
-           if (M_FONTDATA->m_underlined == FALSE) printf( "false.\n" );
-         */
+/*
         if ((int_scale == 100) &&
                 (M_FONTDATA->m_family == wxSWISS) &&
                 (M_FONTDATA->m_style == wxNORMAL) &&
         if ((int_scale == 100) &&
                 (M_FONTDATA->m_family == wxSWISS) &&
                 (M_FONTDATA->m_style == wxNORMAL) &&
@@ -373,15 +397,19 @@ GdkFont *wxFont::GetInternalFont(float scale) const
             font = gdk_font_load( "-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*" );
         }
         else
             font = gdk_font_load( "-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*" );
         }
         else
+*/
         {
         {
-            font = wxLoadQueryNearestFont( point_scale, M_FONTDATA->m_fontId, M_FONTDATA->m_style,
-                    M_FONTDATA->m_weight, M_FONTDATA->m_underlined );
+            font = wxLoadQueryNearestFont( point_scale, M_FONTDATA->m_family, M_FONTDATA->m_style,
+                    M_FONTDATA->m_weight, M_FONTDATA->m_underlined, M_FONTDATA->m_faceName );
         }
         M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
     }
         }
         M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
     }
+
     if (!font)
     if (!font)
-        printf("could not load any font");
-    //    wxError("could not load any font", "wxFont");
+    {
+        wxLogError(_T("could not load any font"));
+    }
+
     return font;
 }
 
     return font;
 }
 
@@ -389,51 +417,91 @@ GdkFont *wxFont::GetInternalFont(float scale) const
 // local utilities to find a X font
 //-----------------------------------------------------------------------------
 
 // local utilities to find a X font
 //-----------------------------------------------------------------------------
 
-static GdkFont *wxLoadQueryFont(int point_size, int fontid, int style,
-        int weight, bool WXUNUSED(underlined))
+static GdkFont*wxLoadQueryFont( int pointSize, int family, int style, int weight,
+                                bool WXUNUSED(underlined), const wxString &facename )
 {
 {
-    char buffer[512];
-    char *name = wxTheFontNameDirectory->GetScreenName( fontid, weight, style );
+    wxChar *xfamily = (wxChar*) NULL;
+    wxChar *xstyle = (wxChar*) NULL;
+    wxChar *xweight = (wxChar*) NULL;
+
+    switch (family)
+    {
+        case wxDECORATIVE: xfamily = _T("lucida"); break;
+        case wxROMAN:      xfamily = _T("times");  break;
+        case wxMODERN:     xfamily = _T("courier"); break;
+        case wxSWISS:      xfamily = _T("helvetica"); break;
+        case wxTELETYPE:   xfamily = _T("lucidatypewriter"); break;
+        case wxSCRIPT:     xfamily = _T("utopia"); break;
+        default:           xfamily = _T("*");
+    }
+
+    if (!facename.IsEmpty())
+    {
+        wxSprintf( wxBuffer, _T("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), facename.c_str() );
+        GdkFont *test = gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) );
+        if (test)
+        {
+            gdk_font_unref( test );
+            xfamily = WXSTRINGCAST facename;
+        }
+    }
+
+    switch (style)
+    {
+        case wxITALIC:     xstyle = _T("i"); break;
+        case wxSLANT:      xstyle = _T("o"); break;
+        case wxNORMAL:     xstyle = _T("r"); break;
+        default:           xstyle = _T("*"); break;
+    }
+    switch (weight)
+    {
+        case wxBOLD:       xweight = _T("bold"); break;
+        case wxLIGHT:
+        case wxNORMAL:     xweight = _T("medium"); break;
+        default:           xweight = _T("*"); break;
+    }
 
 
-    if (!name)
-        name = "-*-*-*-*-*-*-*-%d-*-*-*-*-*-*";
-    sprintf(buffer, name, point_size);
+    wxSprintf( wxBuffer, _T("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-*-*"),
+        xfamily, xweight, xstyle, pointSize);
 
 
-    return gdk_font_load( buffer );
+    return gdk_font_load( wxConvCurrent->cWX2MB(wxBuffer) );
 }
 
 }
 
-static GdkFont *wxLoadQueryNearestFont(int point_size, int fontid,
-        int style, int weight,
-        bool underlined)
+static GdkFont *wxLoadQueryNearestFont( int point_size, int family, int style, int weight,
+                                        bool underlined, const wxString &facename )
 {
 {
-    GdkFont *font;
+    GdkFont *font = wxLoadQueryFont( point_size, family, style, weight, underlined, facename );
 
 
-    font = wxLoadQueryFont( point_size, fontid, style, weight, underlined );
-
-    if (!font) {
-        // search up and down by stepsize 10
+    if (!font)
+    {
+        /* search up and down by stepsize 10 */
         int max_size = point_size + 20 * (1 + (point_size/180));
         int min_size = point_size - 20 * (1 + (point_size/180));
         int max_size = point_size + 20 * (1 + (point_size/180));
         int min_size = point_size - 20 * (1 + (point_size/180));
+
         int i;
 
         int i;
 
-        // Search for smaller size (approx.)
+        /* Search for smaller size (approx.) */
         for (i=point_size-10; !font && i >= 10 && i >= min_size; i -= 10)
         for (i=point_size-10; !font && i >= 10 && i >= min_size; i -= 10)
-            font = wxLoadQueryFont(i, fontid, style, weight, underlined);
-        // Search for larger size (approx.)
+            font = wxLoadQueryFont(i, family, style, weight, underlined, facename );
+
+        /* Search for larger size (approx.) */
         for (i=point_size+10; !font && i <= max_size; i += 10)
         for (i=point_size+10; !font && i <= max_size; i += 10)
-            font = wxLoadQueryFont(i, fontid, style, weight, underlined);
-        // Try default family
-        if (!font && fontid != wxDEFAULT)
-            font = wxLoadQueryFont(point_size, wxDEFAULT, style,
-                    weight, underlined);
-        // Bogus font
+            font = wxLoadQueryFont( i, family, style, weight, underlined, facename );
+
+        /* Try default family */
+        if (!font && family != wxDEFAULT)
+            font = wxLoadQueryFont( point_size, wxDEFAULT, style, weight, underlined, facename );
+
+        /* Bogus font */
         if (!font)
         if (!font)
-            font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
-                    underlined);
+            font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL, underlined, facename );
     }
     }
+
     return font;
 }
 
     return font;
 }
 
+/*
+
 //-----------------------------------------------------------------------------
 // face names and index functions
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // face names and index functions
 //-----------------------------------------------------------------------------
@@ -514,7 +582,8 @@ static char *font_defaults[] = {
     "ScreenItalic", "i",
     "ScreenSlant", "o",
 
     "ScreenItalic", "i",
     "ScreenSlant", "o",
 
-    "ScreenDefaultBase", "misc-fixed",
+    "ScreenDefaultBase", "*-times",
+
     "ScreenRomanBase", "*-times",
     "ScreenDecorativeBase", "*-helvetica",
     "ScreenModernBase", "*-courier",
     "ScreenRomanBase", "*-times",
     "ScreenDecorativeBase", "*-helvetica",
     "ScreenModernBase", "*-courier",
@@ -547,7 +616,8 @@ enum {wxSTYLE_NORMAL,  wxSTYLE_ITALIC, wxSTYLE_SLANT,  wxNUM_STYLES};
 
 static int WCoordinate(int w)
 {
 
 static int WCoordinate(int w)
 {
-    switch (w) {
+    switch (w)
+    {
         case wxBOLD:   return wxWEIGHT_BOLD;
         case wxLIGHT:  return wxWEIGHT_LIGHT;
         case wxNORMAL:
         case wxBOLD:   return wxWEIGHT_BOLD;
         case wxLIGHT:  return wxWEIGHT_LIGHT;
         case wxNORMAL:
@@ -557,7 +627,8 @@ static int WCoordinate(int w)
 
 static int SCoordinate(int s)
 {
 
 static int SCoordinate(int s)
 {
-    switch (s) {
+    switch (s)
+    {
         case wxITALIC: return wxSTYLE_ITALIC;
         case wxSLANT:  return wxSTYLE_SLANT;
         case wxNORMAL:
         case wxITALIC: return wxSTYLE_ITALIC;
         case wxSLANT:  return wxSTYLE_SLANT;
         case wxNORMAL:
@@ -569,7 +640,8 @@ static int SCoordinate(int s)
 // wxSuffixMap
 //-----------------------------------------------------------------------------
 
 // wxSuffixMap
 //-----------------------------------------------------------------------------
 
-class wxSuffixMap {
+class wxSuffixMap
+{
 public:
     ~wxSuffixMap();
 
 public:
     ~wxSuffixMap();
 
@@ -582,10 +654,6 @@ public:
     void Initialize(const char *, const char *);
 };
 
     void Initialize(const char *, const char *);
 };
 
-//#if !USE_RESOURCES
-#define wxGetResource(a, b, c) 0
-//#endif
-
 static void SearchResource(const char *prefix, const char **names, int count, char **v)
 {
     int k, i, j;
 static void SearchResource(const char *prefix, const char **names, int count, char **v)
 {
     int k, i, j;
@@ -596,20 +664,32 @@ static void SearchResource(const char *prefix, const char **names, int count, ch
     *v = (char *) NULL;
     internal = (char *) NULL;
 
     *v = (char *) NULL;
     internal = (char *) NULL;
 
-    for (i = 0; i < k; i++) {
+    for (i = 0; i < k; i++)
+    {
         strcpy(resource, prefix);
         strcpy(resource, prefix);
-        for (j = 0; j < count; j++) {
+        for (j = 0; j < count; j++)
+        {
+            // upon failure to find a matching fontname
+            //   in the default fonts above, we substitute more
+            //   and more values by _ so that at last ScreenMyFontBoldNormal
+            //   would turn into Screen___ and this will then get
+            //   converted to -${ScreenDefaultBase}${ScreenStdSuffix}
+
             if (!(i & (1 << j)))
                 strcat(resource, names[j]);
             else
                 strcat(resource, "_");
         }
             if (!(i & (1 << j)))
                 strcat(resource, names[j]);
             else
                 strcat(resource, "_");
         }
-        if (wxGetResource(wxAPP_CLASS, (char *)resource, v))
-            return;
-        if (!internal) {
+
+        // we previously search the Xt-resources here
+
+        if (!internal)
+        {
             defaults = font_defaults;
             defaults = font_defaults;
-            while (*defaults) {
-                if (!strcmp(*defaults, resource)) {
+            while (*defaults)
+            {
+                if (!strcmp(*defaults, resource))
+                {
                     internal = defaults[1];
                     break;
                 }
                     internal = defaults[1];
                     break;
                 }
@@ -617,8 +697,27 @@ static void SearchResource(const char *prefix, const char **names, int count, ch
             }
         }
     }
             }
         }
     }
+
     if (internal)
     if (internal)
-        *v = copystring(internal);
+    {
+        if ((strcmp(internal,"-${ScreenDefaultBase}${ScreenStdSuffix}") == 0) &&
+            (strcmp(names[0], "Default") != 0))
+        {
+            // we did not find any font name in the standard list.
+            //   this can (hopefully does) mean that someone supplied
+            //   the facename in the wxFont constructor so we insert
+            //   it here
+
+            strcpy( resource,"-*-" );                  // any producer
+            strcat( resource, names[0] );              // facename
+            strcat( resource, "${ScreenStdSuffix}" );  // add size params later on
+            *v = copystring(resource);
+        }
+        else
+        {
+            *v = copystring(internal);
+        }
+    }
 }
 
 wxSuffixMap::~wxSuffixMap()
 }
 
 wxSuffixMap::~wxSuffixMap()
@@ -627,7 +726,8 @@ wxSuffixMap::~wxSuffixMap()
 
     for (k = 0; k < wxNUM_WEIGHTS; ++k)
         for (j = 0; j < wxNUM_STYLES; ++j)
 
     for (k = 0; k < wxNUM_WEIGHTS; ++k)
         for (j = 0; j < wxNUM_STYLES; ++j)
-            if (map[k][j]) {
+            if (map[k][j])
+            {
                 delete[] map[k][j];
                 map[k][j] = (char *) NULL;
             }
                 delete[] map[k][j];
                 map[k][j] = (char *) NULL;
             }
@@ -640,15 +740,19 @@ void wxSuffixMap::Initialize(const char *resname, const char *devresname)
     int i, j, k;
     const char *names[3];
 
     int i, j, k;
     const char *names[3];
 
-    for (k = 0; k < wxNUM_WEIGHTS; k++) {
-        switch (k) {
+    for (k = 0; k < wxNUM_WEIGHTS; k++)
+    {
+        switch (k)
+        {
             case wxWEIGHT_NORMAL: weight = "Medium"; break;
             case wxWEIGHT_LIGHT:  weight = "Light"; break;
             case wxWEIGHT_BOLD:
             case wxWEIGHT_NORMAL: weight = "Medium"; break;
             case wxWEIGHT_LIGHT:  weight = "Light"; break;
             case wxWEIGHT_BOLD:
-            default:          weight = "Bold";
+            default:              weight = "Bold";
         }
         }
-        for (j = 0; j < wxNUM_STYLES; j++) {
-            switch (j) {
+        for (j = 0; j < wxNUM_STYLES; j++)
+        {
+            switch (j)
+            {
                 case wxSTYLE_NORMAL: style = "Straight"; break;
                 case wxSTYLE_ITALIC: style = "Italic"; break;
                 case wxSTYLE_SLANT:
                 case wxSTYLE_NORMAL: style = "Straight"; break;
                 case wxSTYLE_ITALIC: style = "Italic"; break;
                 case wxSTYLE_SLANT:
@@ -660,17 +764,21 @@ void wxSuffixMap::Initialize(const char *resname, const char *devresname)
 
             SearchResource(devresname, names, 3, &v);
 
 
             SearchResource(devresname, names, 3, &v);
 
-            /* Expand macros in the found string: */
+            // Expand macros in the found string:
 found:
             int len, closer = 0, startpos = 0;
 
             len = (v ? strlen(v) : 0);
 found:
             int len, closer = 0, startpos = 0;
 
             len = (v ? strlen(v) : 0);
-            for (i = 0; i < len; i++) {
-                if (v[i] == '$' && ((v[i+1] == '[') || (v[i+1] == '{'))) {
+            for (i = 0; i < len; i++)
+            {
+                if (v[i] == '$' && ((v[i+1] == '[') || (v[i+1] == '{')))
+                {
                     startpos = i;
                     closer   = (v[i+1] == '[') ? ']' : '}';
                     ++i;
                     startpos = i;
                     closer   = (v[i+1] == '[') ? ']' : '}';
                     ++i;
-                } else if (v[i] == closer) {
+                }
+                else if (v[i] == closer)
+                {
                     int newstrlen;
                     const char *r = (char *) NULL; bool delete_r = FALSE;
                     char *name;
                     int newstrlen;
                     const char *r = (char *) NULL; bool delete_r = FALSE;
                     char *name;
@@ -678,7 +786,8 @@ found:
                     name = v + startpos + 2;
                     v[i] = 0;
 
                     name = v + startpos + 2;
                     v[i] = 0;
 
-                    if (closer == '}') {
+                    if (closer == '}')
+                    {
                         int i, count, len;
                         char **names;
 
                         int i, count, len;
                         char **names;
 
@@ -691,7 +800,8 @@ found:
                         names = new char*[count];
                         names[0] = name;
                         for (i = 0, count = 1; i < len; i++)
                         names = new char*[count];
                         names[0] = name;
                         for (i = 0, count = 1; i < len; i++)
-                            if (name[i] == ',') {
+                            if (name[i] == ',')
+                            {
                                 names[count++] = name + i + 1;
                                 name[i] = 0;
                             }
                                 names[count++] = name + i + 1;
                                 name[i] = 0;
                             }
@@ -700,12 +810,13 @@ found:
                         delete_r = (r != 0);
                         delete[] names;
 
                         delete_r = (r != 0);
                         delete[] names;
 
-                        if (!r) {
+                        if (!r)
+                        {
                             for (i = 0; i < len; i++)
                                 if (!name[i])
                                     name[i] = ',';
                             r = "";
                             for (i = 0; i < len; i++)
                                 if (!name[i])
                                     name[i] = ',';
                             r = "";
-                            printf("Bad resource name \"%s\" in font lookup\n", name);
+                            wxLogError( "Bad resource name in font lookup." );
                         }
                     } else if (!strcmp(name, "weight")) {
                         r = weight;
                         }
                     } else if (!strcmp(name, "weight")) {
                         r = weight;
@@ -715,7 +826,7 @@ found:
                         r = resname;
                     } else {
                         r = "";
                         r = resname;
                     } else {
                         r = "";
-                        printf("Bad font macro name \"%s\"\n", name);
+                        wxLogError( "Bad font macro name." );
                     }
 
                     // add r to v
                     }
 
                     // add r to v
@@ -732,7 +843,7 @@ found:
                     goto found;
                 }
             }
                     goto found;
                 }
             }
-            /* We have a final value: */
+            // We have a final value:
             map[k][j] = v;
         }
     }
             map[k][j] = v;
         }
     }
@@ -742,7 +853,7 @@ found:
 // wxFontNameItem
 //-----------------------------------------------------------------------------
 
 // wxFontNameItem
 //-----------------------------------------------------------------------------
 
-class wxFontNameItem : public wxObject 
+class wxFontNameItem : public wxObject
 {
     DECLARE_DYNAMIC_CLASS(wxFontNameItem)
 public:
 {
     DECLARE_DYNAMIC_CLASS(wxFontNameItem)
 public:
@@ -811,7 +922,7 @@ wxFontNameDirectory::~wxFontNameDirectory()
     // Cleanup wxFontNameItems allocated
     table->BeginFind();
     wxNode *node = table->Next();
     // Cleanup wxFontNameItems allocated
     table->BeginFind();
     wxNode *node = table->Next();
-    while (node) 
+    while (node)
     {
         wxFontNameItem *item = (wxFontNameItem*)node->Data();
         delete item;
     {
         wxFontNameItem *item = (wxFontNameItem*)node->Data();
         delete item;
@@ -842,7 +953,8 @@ void wxFontNameDirectory::Initialize(int fontid, int family, const char *resname
 
     sprintf(resource, "Family%s", resname);
     SearchResource((const char *)resource, (const char **) NULL, 0, (char **)&fam);
 
     sprintf(resource, "Family%s", resname);
     SearchResource((const char *)resource, (const char **) NULL, 0, (char **)&fam);
-    if (fam) 
+
+    if (fam)
     {
         if      (!strcmp(fam, "Default"))    family = wxDEFAULT;
         else if (!strcmp(fam, "Roman"))        family = wxROMAN;
     {
         if      (!strcmp(fam, "Default"))    family = wxDEFAULT;
         else if (!strcmp(fam, "Roman"))        family = wxROMAN;
@@ -862,7 +974,7 @@ int wxFontNameDirectory::FindOrCreateFontId(const char *name, int family)
 
     // font exists -> return id
     if ( (id = GetFontId(name)) ) return id;
 
     // font exists -> return id
     if ( (id = GetFontId(name)) ) return id;
-    
+
     // create new font
     Initialize(id=GetNewFontId(), family, name);
     return id;
     // create new font
     Initialize(id=GetNewFontId(), family, name);
     return id;
@@ -873,7 +985,7 @@ char *wxFontNameDirectory::GetScreenName(int fontid, int weight, int style)
     wxFontNameItem *item = (wxFontNameItem*)table->Get(fontid); // find font
     if (item)
         return item->GetScreenName(weight, style);
     wxFontNameItem *item = (wxFontNameItem*)table->Get(fontid); // find font
     if (item)
         return item->GetScreenName(weight, style);
-       
+
     // font does not exist
     return (char *) NULL;
 }
     // font does not exist
     return (char *) NULL;
 }
@@ -883,7 +995,7 @@ char *wxFontNameDirectory::GetPostScriptName(int fontid, int weight, int style)
     wxFontNameItem *item = (wxFontNameItem*)table->Get(fontid); // find font
     if (item)
         return item->GetPostScriptName(weight, style);
     wxFontNameItem *item = (wxFontNameItem*)table->Get(fontid); // find font
     if (item)
         return item->GetPostScriptName(weight, style);
-       
+
     // font does not exist
     return (char *) NULL;
 }
     // font does not exist
     return (char *) NULL;
 }
@@ -902,7 +1014,7 @@ char *wxFontNameDirectory::GetFontName(int fontid)
     wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid); // find font
     if (item)
         return item->GetName();
     wxFontNameItem *item = (wxFontNameItem *)table->Get(fontid); // find font
     if (item)
         return item->GetName();
-       
+
     // font does not exist
     return (char *) NULL;
 }
     // font does not exist
     return (char *) NULL;
 }
@@ -913,13 +1025,13 @@ int wxFontNameDirectory::GetFontId(const char *name)
 
     table->BeginFind();
 
 
     table->BeginFind();
 
-    while ( (node = table->Next()) ) 
+    while ( (node = table->Next()) )
     {
         wxFontNameItem *item = (wxFontNameItem*)node->Data();
         if (!strcmp(name, item->name))
             return item->id;
     }
     {
         wxFontNameItem *item = (wxFontNameItem*)node->Data();
         if (!strcmp(name, item->name))
             return item->id;
     }
-    
+
     // font does not exist
     return 0;
 }
     // font does not exist
     return 0;
 }
@@ -930,7 +1042,9 @@ int wxFontNameDirectory::GetFamily(int fontid)
 
     if (item)
         return item->family;
 
     if (item)
         return item->family;
-       
+
     // font does not exist
     return wxDEFAULT;
 }
     // font does not exist
     return wxDEFAULT;
 }
+
+*/
wxWidgets (Impactor)