Avoid overflowing the wake up when handling events in Unix console apps.

[wxWidgets.git] / src / msw / fontenum.cpp

diff --git a/src/msw/fontenum.cpp b/src/msw/fontenum.cpp
index 8b9d993b14cc1ffe486b39887f3ff0870df2d868..3c936a11feee1f4946de40842ef53463f56eef89 100644 (file)
--- a/src/msw/fontenum.cpp
+++ b/src/msw/fontenum.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        msw/fontenum.cpp
+// Name:        src/msw/fontenum.cpp

 // Purpose:     wxFontEnumerator class for Windows
 // Author:      Julian Smart
 // Modified by: Vadim Zeitlin to add support for font encodings
 // Purpose:     wxFontEnumerator class for Windows
 // Author:      Julian Smart
 // Modified by: Vadim Zeitlin to add support for font encodings


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

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

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


@@ -28,28 +24,40 @@
   #pragma hdrstop
 #endif
 
   #pragma hdrstop
 #endif
 

+#if wxUSE_FONTENUM
+
+#include "wx/fontenum.h"
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

-  #include "wx/font.h"
+    #include "wx/gdicmn.h"
+    #include "wx/font.h"
+    #include "wx/dynarray.h"
+    #include "wx/msw/private.h"

 #endif
 
 #endif
 

-#include "wx/fontenum.h"
+#include "wx/encinfo.h"
+#include "wx/fontutil.h"

 #include "wx/fontmap.h"
 
 #include "wx/fontmap.h"
 

-#include "wx/msw/private.h"
-

 // ----------------------------------------------------------------------------
 // private classes
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // private classes
 // ----------------------------------------------------------------------------
 

+// the helper class which calls ::EnumFontFamilies() and whose OnFont() is
+// called from the callback passed to this function and, in its turn, calls the
+// appropariate wxFontEnumerator method

 class wxFontEnumeratorHelper
 {
 public:
     wxFontEnumeratorHelper(wxFontEnumerator *fontEnum);
 
     // control what exactly are we enumerating
 class wxFontEnumeratorHelper
 {
 public:
     wxFontEnumeratorHelper(wxFontEnumerator *fontEnum);
 
     // control what exactly are we enumerating

+        // we enumerate fonts with given enocding

     bool SetEncoding(wxFontEncoding encoding);
     bool SetEncoding(wxFontEncoding encoding);

-    void SetFixedOnly(bool fixedOnly)
-        { m_fixedOnly = fixedOnly; }
+        // we enumerate fixed-width fonts
+    void SetFixedOnly(bool fixedOnly) { m_fixedOnly = fixedOnly; }
+        // we enumerate the encodings available in this family
+    void SetFamily(const wxString& family);

 
     // call to start enumeration
     void DoEnumerate();
 
     // call to start enumeration
     void DoEnumerate();


@@ -67,16 +75,32 @@ private:
     // if not empty, enum only the fonts with this facename
     wxString m_facename;
 
     // if not empty, enum only the fonts with this facename
     wxString m_facename;
 

-    // if TRUE, enum only fixed fonts
+    // if not empty, enum only the fonts in this family
+    wxString m_family;
+
+    // if true, enum only fixed fonts

     bool m_fixedOnly;
     bool m_fixedOnly;

+
+    // if true, we enumerate the encodings, not fonts
+    bool m_enumEncodings;
+
+    // the list of charsets we already found while enumerating charsets
+    wxArrayInt m_charsets;
+
+    // the list of facenames we already found while enumerating facenames
+    wxArrayString m_facenames;
+
+    wxDECLARE_NO_COPY_CLASS(wxFontEnumeratorHelper);

 };
 
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 
 };
 
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 

+#ifndef __WXMICROWIN__

 int CALLBACK wxFontEnumeratorProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,
 int CALLBACK wxFontEnumeratorProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,

-                                  DWORD dwStyle, LONG lParam);
+                                  DWORD dwStyle, LPARAM lParam);
+#endif

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


@@ -89,60 +113,100 @@ int CALLBACK wxFontEnumeratorProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,
 wxFontEnumeratorHelper::wxFontEnumeratorHelper(wxFontEnumerator *fontEnum)
 {
     m_fontEnum = fontEnum;
 wxFontEnumeratorHelper::wxFontEnumeratorHelper(wxFontEnumerator *fontEnum)
 {
     m_fontEnum = fontEnum;

-    m_charset = -1;
-    m_fixedOnly = FALSE;
+    m_charset = DEFAULT_CHARSET;
+    m_fixedOnly = false;
+    m_enumEncodings = false;
+}
+
+void wxFontEnumeratorHelper::SetFamily(const wxString& family)
+{
+    m_enumEncodings = true;
+    m_family = family;

 }
 
 bool wxFontEnumeratorHelper::SetEncoding(wxFontEncoding encoding)
 {
 }
 
 bool wxFontEnumeratorHelper::SetEncoding(wxFontEncoding encoding)
 {

-    wxNativeEncodingInfo info;
-    if ( !wxGetNativeFontEncoding(encoding, &info) )
+    if ( encoding != wxFONTENCODING_SYSTEM )

     {
     {

-        if ( !wxTheFontMapper->GetAltForEncoding(encoding, &info) )
+        wxNativeEncodingInfo info;
+        if ( !wxGetNativeFontEncoding(encoding, &info) )

         {
         {

-            // no such encodings at all
-            return FALSE;
+#if wxUSE_FONTMAP
+            if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &info) )
+#endif // wxUSE_FONTMAP
+            {
+                // no such encodings at all
+                return false;
+            }

         }
         }

+
+        m_charset = info.charset;
+        m_facename = info.facename;

     }
     }

-    m_charset = info.charset;
-    m_facename = info.facename;

 
 

-    return TRUE;
+    return true;

 }
 
 }
 

-#if defined(__GNUWIN32__) && !defined(__MINGW32__)
+#if defined(__GNUWIN32__) && !defined(__CYGWIN10__) && !wxCHECK_W32API_VERSION( 1, 1 ) && !wxUSE_NORLANDER_HEADERS

     #define wxFONTENUMPROC int(*)(ENUMLOGFONTEX *, NEWTEXTMETRICEX*, int, LPARAM)
 #else
     #define wxFONTENUMPROC int(*)(ENUMLOGFONTEX *, NEWTEXTMETRICEX*, int, LPARAM)
 #else

-    #define wxFONTENUMPROC FONTENUMEXPROC
+    #define wxFONTENUMPROC FONTENUMPROC

 #endif
 
 void wxFontEnumeratorHelper::DoEnumerate()
 {
 #endif
 
 void wxFontEnumeratorHelper::DoEnumerate()
 {

+#ifndef __WXMICROWIN__

     HDC hDC = ::GetDC(NULL);
 
     HDC hDC = ::GetDC(NULL);
 

-#ifdef __WIN32__
+#ifdef __WXWINCE__
+    ::EnumFontFamilies(hDC,
+                       m_facename.empty() ? NULL : m_facename.wx_str(),
+                       (wxFONTENUMPROC)wxFontEnumeratorProc,
+                       (LPARAM)this) ;
+#else // __WIN32__

     LOGFONT lf;
     LOGFONT lf;

-    lf.lfCharSet = m_charset;
-    wxStrncpy(lf.lfFaceName, m_facename, WXSIZEOF(lf.lfFaceName));
+    lf.lfCharSet = (BYTE)m_charset;
+    wxStrlcpy(lf.lfFaceName, m_facename.c_str(), WXSIZEOF(lf.lfFaceName));

     lf.lfPitchAndFamily = 0;
     ::EnumFontFamiliesEx(hDC, &lf, (wxFONTENUMPROC)wxFontEnumeratorProc,
                          (LPARAM)this, 0 /* reserved */) ;
     lf.lfPitchAndFamily = 0;
     ::EnumFontFamiliesEx(hDC, &lf, (wxFONTENUMPROC)wxFontEnumeratorProc,
                          (LPARAM)this, 0 /* reserved */) ;

-#else // Win16
-    ::EnumFonts(hDC, (LPTSTR)NULL, (FONTENUMPROC)wxFontEnumeratorProc,
-    #ifdef STRICT
-               (LPARAM)
-    #else
-               (LPSTR)
-    #endif
-               this);
-#endif // Win32/16
+#endif // Win32/CE

 
     ::ReleaseDC(NULL, hDC);
 
     ::ReleaseDC(NULL, hDC);

+#endif

 }
 
 bool wxFontEnumeratorHelper::OnFont(const LPLOGFONT lf,
                                     const LPTEXTMETRIC tm) const
 {
 }
 
 bool wxFontEnumeratorHelper::OnFont(const LPLOGFONT lf,
                                     const LPTEXTMETRIC tm) const
 {

+    if ( m_enumEncodings )
+    {
+        // is this a new charset?
+        int cs = lf->lfCharSet;
+        if ( m_charsets.Index(cs) == wxNOT_FOUND )
+        {
+            wxConstCast(this, wxFontEnumeratorHelper)->m_charsets.Add(cs);
+
+#if wxUSE_FONTMAP
+            wxFontEncoding enc = wxGetFontEncFromCharSet(cs);
+            return m_fontEnum->OnFontEncoding(lf->lfFaceName,
+                                              wxFontMapper::GetEncodingName(enc));
+#else // !wxUSE_FONTMAP
+            // Just use some unique and, hopefully, understandable, name.
+            return m_fontEnum->OnFontEncoding
+                               (
+                                lf->lfFaceName,
+                                wxString::Format(wxS("Code page %d"), cs)
+                               );
+#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
+        }
+        else
+        {
+            // continue enumeration
+            return true;
+        }
+    }
+

     if ( m_fixedOnly )
     {
         // check that it's a fixed pitch font (there is *no* error here, the
     if ( m_fixedOnly )
     {
         // check that it's a fixed pitch font (there is *no* error here, the


@@ -150,18 +214,32 @@ bool wxFontEnumeratorHelper::OnFont(const LPLOGFONT lf,
         if ( tm->tmPitchAndFamily & TMPF_FIXED_PITCH )
         {
             // not a fixed pitch font
         if ( tm->tmPitchAndFamily & TMPF_FIXED_PITCH )
         {
             // not a fixed pitch font

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 

-    if ( m_charset != -1 )
+    if ( m_charset != DEFAULT_CHARSET )

     {
         // check that we have the right encoding
         if ( lf->lfCharSet != m_charset )
         {
     {
         // check that we have the right encoding
         if ( lf->lfCharSet != m_charset )
         {

-            return TRUE;
+            return true;

         }
     }
         }
     }

+    else // enumerating fonts in all charsets
+    {
+        // we can get the same facename twice or more in this case because it
+        // may exist in several charsets but we only want to return one copy of
+        // it (note that this can't happen for m_charset != DEFAULT_CHARSET)
+        if ( m_facenames.Index(lf->lfFaceName) != wxNOT_FOUND )
+        {
+            // continue enumeration
+            return true;
+        }
+
+        wxConstCast(this, wxFontEnumeratorHelper)->
+            m_facenames.Add(lf->lfFaceName);
+    }

 
     return m_fontEnum->OnFacename(lf->lfFaceName);
 }
 
     return m_fontEnum->OnFacename(lf->lfFaceName);
 }


@@ -182,32 +260,42 @@ bool wxFontEnumerator::EnumerateFacenames(wxFontEncoding encoding,
     }
     // else: no such fonts, unknown encoding
 
     }
     // else: no such fonts, unknown encoding
 

-    return TRUE;
+    return true;

 }
 
 bool wxFontEnumerator::EnumerateEncodings(const wxString& family)
 {
 }
 
 bool wxFontEnumerator::EnumerateEncodings(const wxString& family)
 {

-    wxFAIL_MSG(wxT("TODO"));
+    wxFontEnumeratorHelper fe(this);
+    fe.SetFamily(family);
+    fe.DoEnumerate();

 
 

-    return TRUE;
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 // Windows callbacks
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // Windows callbacks
 // ----------------------------------------------------------------------------
 

+#ifndef __WXMICROWIN__

 int CALLBACK wxFontEnumeratorProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,
 int CALLBACK wxFontEnumeratorProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,

-                                  DWORD dwStyle, LONG lParam)
+                                  DWORD WXUNUSED(dwStyle), LPARAM lParam)

 {
 {

+
+    // we used to process TrueType fonts only, but there doesn't seem to be any
+    // reasons to restrict ourselves to them here
+#if 0

     // Get rid of any fonts that we don't want...
     if ( dwStyle != TRUETYPE_FONTTYPE )
     {
         // continue enumeration
         return TRUE;
     }
     // Get rid of any fonts that we don't want...
     if ( dwStyle != TRUETYPE_FONTTYPE )
     {
         // continue enumeration
         return TRUE;
     }

+#endif // 0

 
     wxFontEnumeratorHelper *fontEnum = (wxFontEnumeratorHelper *)lParam;
 
     return fontEnum->OnFont(lplf, lptm);
 }
 
     wxFontEnumeratorHelper *fontEnum = (wxFontEnumeratorHelper *)lParam;
 
     return fontEnum->OnFont(lplf, lptm);
 }

+#endif

 
 

+#endif // wxUSE_FONTENUM