include/wx/fontmap.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/fontmap.h
   3 // Purpose:     wxFontMapper class
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     04.11.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_FONTMAPPER_H_
  13 #define _WX_FONTMAPPER_H_
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 #if wxUSE_FONTMAP
  20
  21 #include "wx/fontenc.h"         // for wxFontEncoding
  22
  23 #if wxUSE_GUI
  24     #include "wx/fontutil.h"    // for wxNativeEncodingInfo
  25 #endif // wxUSE_GUI
  26
  27 #if wxUSE_CONFIG
  28     class WXDLLEXPORT wxConfigBase;
  29 #endif // wxUSE_CONFIG
  30
  31 class WXDLLEXPORT wxFontMapper;
  32
  33 #if wxUSE_GUI
  34     class WXDLLEXPORT wxWindow;
  35 #endif // wxUSE_GUI
  36
  37 // ============================================================================
  38 // wxFontMapper manages user-definable correspondence between wxWindows font
  39 // encodings and the fonts present on the machine.
  40 //
  41 // This is a singleton class, font mapper objects can only be accessed using
  42 // wxFontMapper::Get().
  43 // ============================================================================
  44
  45 // ----------------------------------------------------------------------------
  46 // wxFontMapperBase: this is a non-interactive class which just uses its built
  47 //                   in knowledge of the encodings equivalence
  48 // ----------------------------------------------------------------------------
  49
  50 class WXDLLEXPORT wxFontMapperBase
  51 {
  52 public:
  53     // constructtor and such
  54     // ---------------------
  55
  56     // default ctor
  57     wxFontMapperBase();
  58
  59     // virtual dtor for any base class
  60     virtual ~wxFontMapperBase();
  61
  62     // return instance of the wxFontMapper singleton
  63     static wxFontMapper *Get();
  64
  65     // set the sigleton to 'mapper' instance and return previous one
  66     static wxFontMapper *Set(wxFontMapper *mapper);
  67
  68
  69     // translates charset strings to encoding
  70     // --------------------------------------
  71
  72     // returns the encoding for the given charset (in the form of RFC 2046) or
  73     // wxFONTENCODING_SYSTEM if couldn't decode it
  74     //
  75     // interactive parameter is ignored in the base class, we behave as if it
  76     // were always false
  77     virtual wxFontEncoding CharsetToEncoding(const wxString& charset,
  78                                              bool interactive = true);
  79
  80
  81     // information about supported encodings
  82     // -------------------------------------
  83
  84     // get the number of font encodings we know about
  85     static size_t GetSupportedEncodingsCount();
  86
  87     // get the n-th supported encoding
  88     static wxFontEncoding GetEncoding(size_t n);
  89
  90     // return internal string identifier for the encoding (see also
  91     // GetEncodingDescription())
  92     static wxString GetEncodingName(wxFontEncoding encoding);
  93
  94     // return user-readable string describing the given encoding
  95     //
  96     // NB: hard-coded now, but might change later (read it from config?)
  97     static wxString GetEncodingDescription(wxFontEncoding encoding);
  98
  99
 100     // functions which allow to configure the config object used: by default,
 101     // the global one (from wxConfigBase::Get() will be used) and the default
 102     // root path for the config settings is the string returned by
 103     // GetDefaultConfigPath()
 104     // ----------------------------------------------------------------------
 105
 106 #if wxUSE_CONFIG
 107     // set the config object to use (may be NULL to use default)
 108     void SetConfig(wxConfigBase *config) { m_config = config; }
 109
 110     // set the root config path to use (should be an absolute path)
 111     void SetConfigPath(const wxString& prefix);
 112
 113     // return default config path
 114     static const wxChar *GetDefaultConfigPath();
 115 #endif // wxUSE_CONFIG
 116
 117
 118 protected:
 119 #if wxUSE_CONFIG
 120     // get the config object we're using -- if it wasn't set explicitly, this
 121     // function will use wxConfig::Get() to get the global one
 122     wxConfigBase *GetConfig();
 123
 124     // gets the root path for our settings -- if it wasn't set explicitly, use
 125     // GetDefaultConfigPath()
 126     const wxString& GetConfigPath();
 127
 128     // change to the given (relative) path in the config, return true if ok
 129     // (then GetConfig() will return something !NULL), false if no config
 130     // object
 131     //
 132     // caller should provide a pointer to the string variable which should be
 133     // later passed to RestorePath()
 134     bool ChangePath(const wxString& pathNew, wxString *pathOld);
 135
 136     // restore the config path after use
 137     void RestorePath(const wxString& pathOld);
 138
 139     // config object and path (in it) to use
 140     wxConfigBase *m_config;
 141     bool m_configIsDummy;
 142
 143     wxString m_configRootPath;
 144 #endif // wxUSE_CONFIG
 145
 146 private:
 147     // the global fontmapper object or NULL
 148     static wxFontMapper *sm_instance;
 149
 150     friend class wxFontMapperPathChanger;
 151
 152     DECLARE_NO_COPY_CLASS(wxFontMapperBase)
 153 };
 154
 155 // ----------------------------------------------------------------------------
 156 // wxFontMapper: interactive extension of wxFontMapperBase
 157 //
 158 // The default implementations of all functions will ask the user if they are
 159 // not capable of finding the answer themselves and store the answer in a
 160 // config file (configurable via SetConfigXXX functions). This behaviour may
 161 // be disabled by giving the value of false to "interactive" parameter.
 162 // However, the functions will always consult the config file to allow the
 163 // user-defined values override the default logic and there is no way to
 164 // disable this -- which shouldn't be ever needed because if "interactive" was
 165 // never true, the config file is never created anyhow.
 166 // ----------------------------------------------------------------------------
 167
 168 #if wxUSE_GUI
 169
 170 class WXDLLEXPORT wxFontMapper : public wxFontMapperBase
 171 {
 172 public:
 173     // default ctor
 174     wxFontMapper();
 175
 176     // virtual dtor for a base class
 177     virtual ~wxFontMapper();
 178
 179     // working with the encodings
 180     // --------------------------
 181
 182     // returns the encoding for the given charset (in the form of RFC 2046) or
 183     // wxFONTENCODING_SYSTEM if couldn't decode it
 184     virtual wxFontEncoding CharsetToEncoding(const wxString& charset,
 185                                              bool interactive = true);
 186
 187     // find an alternative for the given encoding (which is supposed to not be
 188     // available on this system). If successful, return true and fill info
 189     // structure with the parameters required to create the font, otherwise
 190     // return false
 191     virtual bool GetAltForEncoding(wxFontEncoding encoding,
 192                                    wxNativeEncodingInfo *info,
 193                                    const wxString& facename = wxEmptyString,
 194                                    bool interactive = true);
 195
 196     // version better suitable for 'public' use. Returns wxFontEcoding
 197     // that can be used it wxFont ctor
 198     bool GetAltForEncoding(wxFontEncoding encoding,
 199                            wxFontEncoding *alt_encoding,
 200                            const wxString& facename = wxEmptyString,
 201                            bool interactive = true);
 202
 203     // checks whether given encoding is available in given face or not.
 204     // If no facename is given,
 205     virtual bool IsEncodingAvailable(wxFontEncoding encoding,
 206                                      const wxString& facename = wxEmptyString);
 207
 208
 209     // configure the appearance of the dialogs we may popup
 210     // ----------------------------------------------------
 211
 212     // the parent window for modal dialogs
 213     void SetDialogParent(wxWindow *parent) { m_windowParent = parent; }
 214
 215     // the title for the dialogs (note that default is quite reasonable)
 216     void SetDialogTitle(const wxString& title) { m_titleDialog = title; }
 217
 218
 219 protected:
 220     // GetAltForEncoding() helper: tests for the existence of the given
 221     // encoding and saves the result in config if ok - this results in the
 222     // following (desired) behaviour: when an unknown/unavailable encoding is
 223     // requested for the first time, the user is asked about a replacement,
 224     // but if he doesn't choose any and the default logic finds one, it will
 225     // be saved in the config so that the user won't be asked about it any
 226     // more
 227     bool TestAltEncoding(const wxString& configEntry,
 228                          wxFontEncoding encReplacement,
 229                          wxNativeEncodingInfo *info);
 230
 231     // the title for our dialogs
 232     wxString m_titleDialog;
 233
 234     // the parent window for our dialogs
 235     wxWindow *m_windowParent;
 236
 237 private:
 238     DECLARE_NO_COPY_CLASS(wxFontMapper)
 239 };
 240
 241 #else // !wxUSE_GUI
 242
 243 class WXDLLEXPORT wxFontMapper : public wxFontMapperBase
 244 {
 245 };
 246
 247 #endif // wxUSE_GUI/!wxUSE_GUI
 248
 249 // ----------------------------------------------------------------------------
 250 // global variables
 251 // ----------------------------------------------------------------------------
 252
 253 // the default font mapper for wxWindows programs do NOT use! This is for
 254 // backward compatibility, use wxFontMapper::Get() instead
 255 #define wxTheFontMapper (wxFontMapper::Get())
 256
 257 #else // !wxUSE_FONTMAP
 258
 259 #if wxUSE_GUI
 260     // wxEncodingToCodepage (utils.cpp) needs wxGetNativeFontEncoding
 261     #include "wx/fontutil.h"
 262 #endif
 263
 264 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
 265
 266 #endif // _WX_FONTMAPPER_H_
 267