1. moved fontenum.cpp to unix because implementation is common to X and GTK+

(had to add wxGetDisplay() to wxGTK)
2. implemented EnumerateEncodings() - now only if we could do something useful
   with this...
3. added makefile for the console sample


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4187 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

distrib/msw/tmake/filelist.txt

@@ -284,6 +284,7 @@ xpmhand.cpp	M
 gsocket.c	M	S
 
 dialup.cpp	U
+fontenum.cpp	U
 threadpsx.cpp	U
 utilsunx.cpp	U	B
 gsocket.c	U
@@ -371,7 +372,6 @@ dcscreen.cpp	X
 dialog.cpp	X
 filedlg.cpp	X
 font.cpp	X
-fontenum.cpp	X
 frame.cpp	X
 gauge.cpp	X
 gdiobj.cpp	X

include/wx/fontenum.h

@@ -22,7 +22,7 @@
 // fonts with given attributes
 // ----------------------------------------------------------------------------
 
-class wxFontEnumerator
+class WXDLLEXPORT wxFontEnumerator
 {
 public:
     // start enumerating font families - will result in OnFontFamily() being

include/wx/utils.h

@@ -342,11 +342,15 @@ WXDLLEXPORT void wxRedirectIOToConsole();
 // Display and colorss (X only)
 // ----------------------------------------------------------------------------
 
+#ifdef __WXGTK__
+    void *wxGetDisplay();
+#endif
+
 #ifdef __X__
     WXDisplay *wxGetDisplay();
     bool wxSetDisplay(const wxString& display_name);
     wxString wxGetDisplayName();
-#endif
+#endif // X or GTK+
 
 #ifdef __X__
 

samples/console/Makefile.in

@@ -0,0 +1,21 @@
+#
+# File:		makefile.unx
+# Author:	Julian Smart
+# Created:	1998
+# Updated:	
+# Copyright:	(c) 1998 Julian Smart
+#
+# "%W% %G%"
+#
+# Makefile for console example (UNIX).
+
+top_srcdir = @top_srcdir@
+top_builddir = ../..
+program_dir = samples/console
+
+PROGRAM=console
+
+OBJECTS=$(PROGRAM).o
+
+include ../../src/makeprog.env
+

samples/font/font.cpp

@@ -86,6 +86,7 @@ public:
         { DoEnumerateFamilies(FALSE); }
     void OnEnumerateFixedFamilies(wxCommandEvent& WXUNUSED(event))
         { DoEnumerateFamilies(TRUE); }
+    void OnEnumerateEncodings(wxCommandEvent& event);
 
 protected:
     void DoEnumerateFamilies(bool fixedWidthOnly);
@@ -129,6 +130,7 @@ enum
     Font_Create,
     Font_EnumFamilies,
     Font_EnumFixedFamilies,
+    Font_EnumEncodings,
     Font_Max
 };
 
@@ -146,6 +148,7 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
     EVT_MENU(Font_Create, MyFrame::OnCreateFont)
     EVT_MENU(Font_EnumFamilies, MyFrame::OnEnumerateFamilies)
     EVT_MENU(Font_EnumFixedFamilies, MyFrame::OnEnumerateFixedFamilies)
+    EVT_MENU(Font_EnumEncodings, MyFrame::OnEnumerateEncodings)
 END_EVENT_TABLE()
 
 // Create a new application object: this macro will allow wxWindows to create
@@ -201,9 +204,11 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
     menuFont->Append(Font_Create, "&Create font...\tCtrl-C",
                      "Create a custom font");
     menuFont->AppendSeparator();
-    menuFont->Append(Font_EnumFamilies, "&Enumerate font families\tCtrl-E");
+    menuFont->Append(Font_EnumFamilies, "Enumerate font &families\tCtrl-F");
     menuFont->Append(Font_EnumFixedFamilies,
-                     "&Enumerate fixed font families\tCtrl-F");
+                     "Enumerate f&ixed font families\tCtrl-I");
+    menuFont->Append(Font_EnumEncodings,
+                     "Enumerate &encodings\tCtrl-E");
 
     // now append the freshly created menu to the menu bar...
     wxMenuBar *menuBar = new wxMenuBar;
@@ -222,6 +227,38 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
 
 
 // event handlers
+void MyFrame::OnEnumerateEncodings(wxCommandEvent& WXUNUSED(event))
+{
+    class MyEncodingEnumerator : public wxFontEnumerator
+    {
+    public:
+        MyEncodingEnumerator() { m_n = 0; }
+
+        const wxString& GetText() const { return m_text; }
+
+    protected:
+        virtual bool OnFontEncoding(const wxString& family,
+                                    const wxString& encoding)
+        {
+            wxString text;
+            text.Printf("Encoding %d: %s (available in family '%s')\n",
+                         ++m_n, encoding.c_str(), family.c_str());
+            m_text += text;
+
+            return TRUE;
+        }
+
+    private:
+        size_t m_n;
+
+        wxString m_text;
+    } fontEnumerator;
+
+    fontEnumerator.EnumerateEncodings();
+
+    wxLogMessage("Enumerating all available encodings:\n%s",
+                 fontEnumerator.GetText().c_str());
+}
 
 void MyFrame::DoEnumerateFamilies(bool fixedWidthOnly)
 {
@@ -230,21 +267,29 @@ void MyFrame::DoEnumerateFamilies(bool fixedWidthOnly)
     public:
         MyFontEnumerator() { m_n = 0; }
 
+        const wxString& GetText() const { return m_text; }
+
     protected:
         virtual bool OnFontFamily(const wxString& family)
         {
-            wxLogMessage("Font family %d: %s\n", ++m_n, family.c_str());
+            wxString text;
+            text.Printf("Font family %d: %s\n", ++m_n, family.c_str());
+            m_text += text;
 
             return TRUE;
         }
 
     private:
         size_t m_n;
+
+        wxString m_text;
     } fontEnumerator;
 
-    wxLogMessage("Enumerating %s font families:",
-                 fixedWidthOnly ? "fixed width" : "all");
     fontEnumerator.EnumerateFamilies(fixedWidthOnly);
+
+    wxLogMessage("Enumerating %s font families:\n%s",
+                 fixedWidthOnly ? "fixed width" : "all",
+                 fontEnumerator.GetText().c_str());
 }
 
 void MyFrame::OnCreateFont(wxCommandEvent& WXUNUSED(event))

samples/minimal/minimal.cpp

@@ -70,8 +70,6 @@ public:
     void OnQuit(wxCommandEvent& event);
     void OnAbout(wxCommandEvent& event);
 
-    void OnPaint(wxPaintEvent& event);
-
 private:
     // any class wishing to process wxWindows events must use this macro
     DECLARE_EVENT_TABLE()
@@ -191,4 +189,3 @@ void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 
     wxMessageBox(msg, "About Minimal", wxOK | wxICON_INFORMATION, this);
 }
-

src/gtk/utilsgtk.cpp

@@ -69,6 +69,11 @@ bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
 // display characterstics
 // ----------------------------------------------------------------------------
 
+void *wxGetDisplay()
+{
+    return gdk_display;
+}
+
 void wxDisplaySize( int *width, int *height )
 {
     if (width) *width = gdk_screen_width();

src/gtk1/utilsgtk.cpp

@@ -69,6 +69,11 @@ bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
 // display characterstics
 // ----------------------------------------------------------------------------
 
+void *wxGetDisplay()
+{
+    return gdk_display;
+}
+
 void wxDisplaySize( int *width, int *height )
 {
     if (width) *width = gdk_screen_width();

src/unix/fontenum.cpp

@@ -0,0 +1,220 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        src/unix/fontenum.cpp
+// Purpose:     wxFontEnumerator class for X11/GDK
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     01.10.99
+// RCS-ID:      $Id$
+// Copyright:   (c) Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "fontenum.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/dynarray.h"
+#include "wx/string.h"
+#include "wx/utils.h"
+
+#include "wx/fontenum.h"
+
+#include <X11/Xlib.h>
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+// create the list of all fonts with the given spacing
+static char **CreateFontList(wxChar spacing, int *nFonts);
+
+// extract all font families from the given font list and call our
+// OnFontFamily() for each of them
+static bool ProcessFamiliesFromFontList(wxFontEnumerator *This,
+                                        char **fonts,
+                                        int nFonts);
+
+
+// ----------------------------------------------------------------------------
+// private types
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// helpers
+// ----------------------------------------------------------------------------
+
+static char **CreateFontList(wxChar spacing, int *nFonts)
+{
+    wxString pattern;
+    pattern.Printf(wxT("-*-*-*-*-*-*-*-*-*-*-%c-*-*-*"), spacing);
+
+    // get the list of all fonts
+    return XListFonts((Display *)wxGetDisplay(), pattern, 32767, nFonts);
+}
+
+static bool ProcessFamiliesFromFontList(wxFontEnumerator *This,
+                                        char **fonts,
+                                        int nFonts)
+{
+    // extract the list of (unique) font families
+    wxSortedArrayString families;
+    for ( int n = 0; n < nFonts; n++ )
+    {
+        char *font = fonts[n];
+        if ( !wxString(font).Matches("-*-*-*-*-*-*-*-*-*-*-*-*-*-*") )
+        {
+            // it's not a full font name (probably an alias)
+            continue;
+        }
+        
+        char *dash = strchr(font + 1, '-');
+        char *family = dash + 1;
+        dash = strchr(family, '-');
+        *dash = '\0'; // !NULL because Matches() above succeeded
+
+        if ( families.Index(family) == wxNOT_FOUND )
+        {
+            if ( !This->OnFontFamily(family) )
+            {
+                // stop enumerating
+                return FALSE;
+            }
+
+            families.Add(family);
+        }
+        //else: already seen
+    }
+
+    return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// wxFontEnumerator
+// ----------------------------------------------------------------------------
+
+bool wxFontEnumerator::EnumerateFamilies(bool fixedWidthOnly)
+{
+    int nFonts;
+    char **fonts;
+
+    if ( fixedWidthOnly )
+    {
+        bool cont = TRUE;
+        fonts = CreateFontList(wxT('m'), &nFonts);
+        if ( fonts )
+        {
+            cont = ProcessFamiliesFromFontList(this, fonts, nFonts);
+
+            XFreeFontNames(fonts);
+        }
+
+        if ( !cont )
+        {
+            return TRUE;
+        }
+
+        fonts = CreateFontList(wxT('c'), &nFonts);
+        if ( !fonts )
+        {
+            return TRUE;
+        }
+    }
+    else
+    {
+        fonts = CreateFontList(wxT('*'), &nFonts);
+
+        if ( !fonts )
+        {
+            wxFAIL_MSG(wxT("No fonts at all on this system?"));
+
+            return FALSE;
+        }
+    }
+
+    (void)ProcessFamiliesFromFontList(this, fonts, nFonts);
+
+    XFreeFontNames(fonts);
+
+    return TRUE;
+}
+
+bool wxFontEnumerator::EnumerateEncodings(const wxString& family)
+{
+    wxString pattern;
+    pattern.Printf(wxT("-*-%s-*-*-*-*-*-*-*-*-*-*-*-*"),
+                   family.IsEmpty() ? wxT("*") : family.c_str());
+
+    // get the list of all fonts
+    int nFonts;
+    char **fonts = XListFonts((Display *)wxGetDisplay(), pattern,
+                              32767, &nFonts);
+
+    if ( !fonts )
+    {
+        // unknown family?
+        return FALSE;
+    }
+
+    // extract the list of (unique) encodings
+    wxSortedArrayString encodings;
+    for ( int n = 0; n < nFonts; n++ )
+    {
+        char *font = fonts[n];
+        if ( !wxString(font).Matches("-*-*-*-*-*-*-*-*-*-*-*-*-*-*") )
+        {
+            // it's not a full font name (probably an alias)
+            continue;
+        }
+
+        // extract the family
+        char *dash = strchr(font + 1, '-');
+        char *familyFont = dash + 1;
+        dash = strchr(familyFont, '-');
+        *dash = '\0'; // !NULL because Matches() above succeeded
+
+        if ( !family.IsEmpty() && (family != familyFont) )
+        {
+            // family doesn't match
+            continue;
+        }
+
+        // now extract the registry/encoding
+        char *p = dash + 1; // just after the dash after family
+        dash = strrchr(p, '-');
+
+        wxString registry(dash + 1);
+        *dash = '\0';
+
+        dash = strrchr(p, '-');
+        wxString encoding(dash + 1);
+
+        encoding << wxT('-') << registry;
+        if ( encodings.Index(encoding) == wxNOT_FOUND )
+        {
+            if ( !OnFontEncoding(familyFont, encoding) )
+            {
+                break;
+            }
+
+            encodings.Add(encoding);
+        }
+        //else: already had this one
+    }
+
+    XFreeFontNames(fonts);
+
+    return TRUE;
+}