src/msw/fontenum.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/fontenum.cpp
   3 // Purpose:     wxFontEnumerator class for Windows
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin to add support for font encodings
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "fontenum.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28   #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_FONTMAP
  32
  33 #ifndef WX_PRECOMP
  34   #include "wx/font.h"
  35 #endif
  36
  37 #include "wx/fontutil.h"
  38 #include "wx/fontenum.h"
  39 #include "wx/fontmap.h"
  40
  41 #include "wx/msw/private.h"
  42
  43 // ----------------------------------------------------------------------------
  44 // private classes
  45 // ----------------------------------------------------------------------------
  46
  47 // the helper class which calls ::EnumFontFamilies() and whose OnFont() is
  48 // called from the callback passed to this function and, in its turn, calls the
  49 // appropariate wxFontEnumerator method
  50 class wxFontEnumeratorHelper
  51 {
  52 public:
  53     wxFontEnumeratorHelper(wxFontEnumerator *fontEnum);
  54
  55     // control what exactly are we enumerating
  56         // we enumerate fonts with given enocding
  57     bool SetEncoding(wxFontEncoding encoding);
  58         // we enumerate fixed-width fonts
  59     void SetFixedOnly(bool fixedOnly) { m_fixedOnly = fixedOnly; }
  60         // we enumerate the encodings available in this family
  61     void SetFamily(const wxString& family);
  62
  63     // call to start enumeration
  64     void DoEnumerate();
  65
  66     // called by our font enumeration proc
  67     bool OnFont(const LPLOGFONT lf, const LPTEXTMETRIC tm) const;
  68
  69 private:
  70     // the object we forward calls to OnFont() to
  71     wxFontEnumerator *m_fontEnum;
  72
  73     // if != -1, enum only fonts which have this encoding
  74     int m_charset;
  75
  76     // if not empty, enum only the fonts with this facename
  77     wxString m_facename;
  78
  79     // if not empty, enum only the fonts in this family
  80     wxString m_family;
  81
  82     // if TRUE, enum only fixed fonts
  83     bool m_fixedOnly;
  84
  85     // if TRUE, we enumerate the encodings, not fonts
  86     bool m_enumEncodings;
  87
  88     // the list of charsets we already found while enumerating charsets
  89     wxArrayInt m_charsets;
  90
  91     // the list of facenames we already found while enumerating facenames
  92     wxArrayString m_facenames;
  93
  94     DECLARE_NO_COPY_CLASS(wxFontEnumeratorHelper)
  95 };
  96
  97 // ----------------------------------------------------------------------------
  98 // private functions
  99 // ----------------------------------------------------------------------------
 100
 101 #ifndef __WXMICROWIN__
 102 int CALLBACK wxFontEnumeratorProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,
 103                                   DWORD dwStyle, LONG lParam);
 104 #endif
 105
 106 // ============================================================================
 107 // implementation
 108 // ============================================================================
 109
 110 // ----------------------------------------------------------------------------
 111 // wxFontEnumeratorHelper
 112 // ----------------------------------------------------------------------------
 113
 114 wxFontEnumeratorHelper::wxFontEnumeratorHelper(wxFontEnumerator *fontEnum)
 115 {
 116     m_fontEnum = fontEnum;
 117     m_charset = DEFAULT_CHARSET;
 118     m_fixedOnly = FALSE;
 119     m_enumEncodings = FALSE;
 120 }
 121
 122 void wxFontEnumeratorHelper::SetFamily(const wxString& family)
 123 {
 124     m_enumEncodings = TRUE;
 125     m_family = family;
 126 }
 127
 128 bool wxFontEnumeratorHelper::SetEncoding(wxFontEncoding encoding)
 129 {
 130     if ( encoding != wxFONTENCODING_SYSTEM )
 131     {
 132         wxNativeEncodingInfo info;
 133         if ( !wxGetNativeFontEncoding(encoding, &info) )
 134         {
 135 #if wxUSE_FONTMAP
 136             if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &info) )
 137 #endif // wxUSE_FONTMAP
 138             {
 139                 // no such encodings at all
 140                 return FALSE;
 141             }
 142         }
 143
 144         m_charset = info.charset;
 145         m_facename = info.facename;
 146     }
 147
 148     return TRUE;
 149 }
 150
 151 #if defined(__WXWINE__)
 152     #define wxFONTENUMPROC FONTENUMPROCEX
 153 #elif (defined(__GNUWIN32__) && !defined(__CYGWIN10__) && !wxCHECK_W32API_VERSION( 1, 1 ))
 154     #if wxUSE_NORLANDER_HEADERS
 155         #define wxFONTENUMPROC int(*)(const LOGFONT *, const TEXTMETRIC *, long unsigned int, LPARAM)
 156     #else
 157         #define wxFONTENUMPROC int(*)(ENUMLOGFONTEX *, NEWTEXTMETRICEX*, int, LPARAM)
 158     #endif
 159 #else
 160     #define wxFONTENUMPROC FONTENUMPROC
 161 #endif
 162
 163 void wxFontEnumeratorHelper::DoEnumerate()
 164 {
 165 #ifndef __WXMICROWIN__
 166     HDC hDC = ::GetDC(NULL);
 167
 168 #ifdef __WIN32__
 169     LOGFONT lf;
 170     lf.lfCharSet = m_charset;
 171     wxStrncpy(lf.lfFaceName, m_facename, WXSIZEOF(lf.lfFaceName));
 172     lf.lfPitchAndFamily = 0;
 173     ::EnumFontFamiliesEx(hDC, &lf, (wxFONTENUMPROC)wxFontEnumeratorProc,
 174                          (LPARAM)this, 0 /* reserved */) ;
 175 #else // Win16
 176     ::EnumFonts(hDC, (LPTSTR)NULL, (FONTENUMPROC)wxFontEnumeratorProc,
 177     #ifdef STRICT
 178                (LPARAM)
 179     #else
 180                (LPSTR)
 181     #endif
 182                this);
 183 #endif // Win32/16
 184
 185     ::ReleaseDC(NULL, hDC);
 186 #endif
 187 }
 188
 189 bool wxFontEnumeratorHelper::OnFont(const LPLOGFONT lf,
 190                                     const LPTEXTMETRIC tm) const
 191 {
 192     if ( m_enumEncodings )
 193     {
 194         // is this a new charset?
 195         int cs = lf->lfCharSet;
 196         if ( m_charsets.Index(cs) == wxNOT_FOUND )
 197         {
 198             wxConstCast(this, wxFontEnumeratorHelper)->m_charsets.Add(cs);
 199
 200             wxFontEncoding enc = wxGetFontEncFromCharSet(cs);
 201             return m_fontEnum->OnFontEncoding(lf->lfFaceName,
 202                                               wxFontMapper::GetEncodingName(enc));
 203         }
 204         else
 205         {
 206             // continue enumeration
 207             return TRUE;
 208         }
 209     }
 210
 211     if ( m_fixedOnly )
 212     {
 213         // check that it's a fixed pitch font (there is *no* error here, the
 214         // flag name is misleading!)
 215         if ( tm->tmPitchAndFamily & TMPF_FIXED_PITCH )
 216         {
 217             // not a fixed pitch font
 218             return TRUE;
 219         }
 220     }
 221
 222     if ( m_charset != DEFAULT_CHARSET )
 223     {
 224         // check that we have the right encoding
 225         if ( lf->lfCharSet != m_charset )
 226         {
 227             return TRUE;
 228         }
 229     }
 230     else // enumerating fonts in all charsets
 231     {
 232         // we can get the same facename twice or more in this case because it
 233         // may exist in several charsets but we only want to return one copy of
 234         // it (note that this can't happen for m_charset != DEFAULT_CHARSET)
 235         if ( m_facenames.Index(lf->lfFaceName) != wxNOT_FOUND )
 236         {
 237             // continue enumeration
 238             return TRUE;
 239         }
 240
 241         wxConstCast(this, wxFontEnumeratorHelper)->
 242             m_facenames.Add(lf->lfFaceName);
 243     }
 244
 245     return m_fontEnum->OnFacename(lf->lfFaceName);
 246 }
 247
 248 // ----------------------------------------------------------------------------
 249 // wxFontEnumerator
 250 // ----------------------------------------------------------------------------
 251
 252 bool wxFontEnumerator::EnumerateFacenames(wxFontEncoding encoding,
 253                                           bool fixedWidthOnly)
 254 {
 255     wxFontEnumeratorHelper fe(this);
 256     if ( fe.SetEncoding(encoding) )
 257     {
 258         fe.SetFixedOnly(fixedWidthOnly);
 259
 260         fe.DoEnumerate();
 261     }
 262     // else: no such fonts, unknown encoding
 263
 264     return TRUE;
 265 }
 266
 267 bool wxFontEnumerator::EnumerateEncodings(const wxString& family)
 268 {
 269     wxFontEnumeratorHelper fe(this);
 270     fe.SetFamily(family);
 271     fe.DoEnumerate();
 272
 273     return TRUE;
 274 }
 275
 276 // ----------------------------------------------------------------------------
 277 // Windows callbacks
 278 // ----------------------------------------------------------------------------
 279
 280 #ifndef __WXMICROWIN__
 281 int CALLBACK wxFontEnumeratorProc(LPLOGFONT lplf, LPTEXTMETRIC lptm,
 282                                   DWORD WXUNUSED(dwStyle), LONG lParam)
 283 {
 284
 285     // we used to process TrueType fonts only, but there doesn't seem to be any
 286     // reasons to restrict ourselves to them here
 287 #if 0
 288     // Get rid of any fonts that we don't want...
 289     if ( dwStyle != TRUETYPE_FONTTYPE )
 290     {
 291         // continue enumeration
 292         return TRUE;
 293     }
 294 #endif // 0
 295
 296     wxFontEnumeratorHelper *fontEnum = (wxFontEnumeratorHelper *)lParam;
 297
 298     return fontEnum->OnFont(lplf, lptm);
 299 }
 300 #endif
 301
 302 #endif // wxUSE_FONTMAP