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