| 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 && wxUSE_FILECONFIG |
| 28 | class WXDLLIMPEXP_FWD_BASE wxConfigBase; |
| 29 | #endif // wxUSE_CONFIG |
| 30 | |
| 31 | class WXDLLIMPEXP_FWD_CORE wxFontMapper; |
| 32 | |
| 33 | #if wxUSE_GUI |
| 34 | class WXDLLIMPEXP_FWD_CORE wxWindow; |
| 35 | #endif // wxUSE_GUI |
| 36 | |
| 37 | // ============================================================================ |
| 38 | // wxFontMapper manages user-definable correspondence between wxWidgets 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 WXDLLIMPEXP_BASE wxFontMapperBase |
| 51 | { |
| 52 | public: |
| 53 | // constructor 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 | // wxBase code only cares that it's a wxFontMapperBase |
| 64 | // In wxBase, wxFontMapper is only forward declared |
| 65 | // so one cannot implicitly cast from it to wxFontMapperBase. |
| 66 | static wxFontMapperBase *Get(); |
| 67 | |
| 68 | // set the singleton to 'mapper' instance and return previous one |
| 69 | static wxFontMapper *Set(wxFontMapper *mapper); |
| 70 | |
| 71 | // delete the existing font mapper if any |
| 72 | static void Reset(); |
| 73 | |
| 74 | |
| 75 | // translates charset strings to encoding |
| 76 | // -------------------------------------- |
| 77 | |
| 78 | // returns the encoding for the given charset (in the form of RFC 2046) or |
| 79 | // wxFONTENCODING_SYSTEM if couldn't decode it |
| 80 | // |
| 81 | // interactive parameter is ignored in the base class, we behave as if it |
| 82 | // were always false |
| 83 | virtual wxFontEncoding CharsetToEncoding(const wxString& charset, |
| 84 | bool interactive = true); |
| 85 | |
| 86 | // information about supported encodings |
| 87 | // ------------------------------------- |
| 88 | |
| 89 | // get the number of font encodings we know about |
| 90 | static size_t GetSupportedEncodingsCount(); |
| 91 | |
| 92 | // get the n-th supported encoding |
| 93 | static wxFontEncoding GetEncoding(size_t n); |
| 94 | |
| 95 | // return canonical name of this encoding (this is a short string, |
| 96 | // GetEncodingDescription() returns a longer one) |
| 97 | static wxString GetEncodingName(wxFontEncoding encoding); |
| 98 | |
| 99 | // return a list of all names of this encoding (see GetEncodingName) |
| 100 | static const wxChar** GetAllEncodingNames(wxFontEncoding encoding); |
| 101 | |
| 102 | // return user-readable string describing the given encoding |
| 103 | // |
| 104 | // NB: hard-coded now, but might change later (read it from config?) |
| 105 | static wxString GetEncodingDescription(wxFontEncoding encoding); |
| 106 | |
| 107 | // find the encoding corresponding to the given name, inverse of |
| 108 | // GetEncodingName() and less general than CharsetToEncoding() |
| 109 | // |
| 110 | // returns wxFONTENCODING_MAX if the name is not a supported encoding |
| 111 | static wxFontEncoding GetEncodingFromName(const wxString& name); |
| 112 | |
| 113 | |
| 114 | // functions which allow to configure the config object used: by default, |
| 115 | // the global one (from wxConfigBase::Get() will be used) and the default |
| 116 | // root path for the config settings is the string returned by |
| 117 | // GetDefaultConfigPath() |
| 118 | // ---------------------------------------------------------------------- |
| 119 | |
| 120 | #if wxUSE_CONFIG && wxUSE_FILECONFIG |
| 121 | // set the root config path to use (should be an absolute path) |
| 122 | void SetConfigPath(const wxString& prefix); |
| 123 | |
| 124 | // return default config path |
| 125 | static const wxString& GetDefaultConfigPath(); |
| 126 | #endif // wxUSE_CONFIG |
| 127 | |
| 128 | |
| 129 | // returns true for the base class and false for a "real" font mapper object |
| 130 | // (implementation-only) |
| 131 | virtual bool IsDummy() { return true; } |
| 132 | |
| 133 | protected: |
| 134 | #if wxUSE_CONFIG && wxUSE_FILECONFIG |
| 135 | // get the config object we're using -- either the global config object |
| 136 | // or a wxMemoryConfig object created by this class otherwise |
| 137 | wxConfigBase *GetConfig(); |
| 138 | |
| 139 | // gets the root path for our settings -- if it wasn't set explicitly, use |
| 140 | // GetDefaultConfigPath() |
| 141 | const wxString& GetConfigPath(); |
| 142 | |
| 143 | // change to the given (relative) path in the config, return true if ok |
| 144 | // (then GetConfig() will return something !NULL), false if no config |
| 145 | // object |
| 146 | // |
| 147 | // caller should provide a pointer to the string variable which should be |
| 148 | // later passed to RestorePath() |
| 149 | bool ChangePath(const wxString& pathNew, wxString *pathOld); |
| 150 | |
| 151 | // restore the config path after use |
| 152 | void RestorePath(const wxString& pathOld); |
| 153 | |
| 154 | // config object and path (in it) to use |
| 155 | wxConfigBase *m_configDummy; |
| 156 | |
| 157 | wxString m_configRootPath; |
| 158 | #endif // wxUSE_CONFIG |
| 159 | |
| 160 | // the real implementation of the base class version of CharsetToEncoding() |
| 161 | // |
| 162 | // returns wxFONTENCODING_UNKNOWN if encoding is unknown and we shouldn't |
| 163 | // ask the user about it, wxFONTENCODING_SYSTEM if it is unknown but we |
| 164 | // should/could ask the user |
| 165 | int NonInteractiveCharsetToEncoding(const wxString& charset); |
| 166 | |
| 167 | private: |
| 168 | // the global fontmapper object or NULL |
| 169 | static wxFontMapper *sm_instance; |
| 170 | |
| 171 | friend class wxFontMapperPathChanger; |
| 172 | |
| 173 | wxDECLARE_NO_COPY_CLASS(wxFontMapperBase); |
| 174 | }; |
| 175 | |
| 176 | // ---------------------------------------------------------------------------- |
| 177 | // wxFontMapper: interactive extension of wxFontMapperBase |
| 178 | // |
| 179 | // The default implementations of all functions will ask the user if they are |
| 180 | // not capable of finding the answer themselves and store the answer in a |
| 181 | // config file (configurable via SetConfigXXX functions). This behaviour may |
| 182 | // be disabled by giving the value of false to "interactive" parameter. |
| 183 | // However, the functions will always consult the config file to allow the |
| 184 | // user-defined values override the default logic and there is no way to |
| 185 | // disable this -- which shouldn't be ever needed because if "interactive" was |
| 186 | // never true, the config file is never created anyhow. |
| 187 | // ---------------------------------------------------------------------------- |
| 188 | |
| 189 | #if wxUSE_GUI |
| 190 | |
| 191 | class WXDLLIMPEXP_CORE wxFontMapper : public wxFontMapperBase |
| 192 | { |
| 193 | public: |
| 194 | // default ctor |
| 195 | wxFontMapper(); |
| 196 | |
| 197 | // virtual dtor for a base class |
| 198 | virtual ~wxFontMapper(); |
| 199 | |
| 200 | // working with the encodings |
| 201 | // -------------------------- |
| 202 | |
| 203 | // returns the encoding for the given charset (in the form of RFC 2046) or |
| 204 | // wxFONTENCODING_SYSTEM if couldn't decode it |
| 205 | virtual wxFontEncoding CharsetToEncoding(const wxString& charset, |
| 206 | bool interactive = true); |
| 207 | |
| 208 | // find an alternative for the given encoding (which is supposed to not be |
| 209 | // available on this system). If successful, return true and fill info |
| 210 | // structure with the parameters required to create the font, otherwise |
| 211 | // return false |
| 212 | virtual bool GetAltForEncoding(wxFontEncoding encoding, |
| 213 | wxNativeEncodingInfo *info, |
| 214 | const wxString& facename = wxEmptyString, |
| 215 | bool interactive = true); |
| 216 | |
| 217 | // version better suitable for 'public' use. Returns wxFontEcoding |
| 218 | // that can be used it wxFont ctor |
| 219 | bool GetAltForEncoding(wxFontEncoding encoding, |
| 220 | wxFontEncoding *alt_encoding, |
| 221 | const wxString& facename = wxEmptyString, |
| 222 | bool interactive = true); |
| 223 | |
| 224 | // checks whether given encoding is available in given face or not. |
| 225 | // |
| 226 | // if no facename is given (default), return true if it's available in any |
| 227 | // facename at alll. |
| 228 | virtual bool IsEncodingAvailable(wxFontEncoding encoding, |
| 229 | const wxString& facename = wxEmptyString); |
| 230 | |
| 231 | |
| 232 | // configure the appearance of the dialogs we may popup |
| 233 | // ---------------------------------------------------- |
| 234 | |
| 235 | // the parent window for modal dialogs |
| 236 | void SetDialogParent(wxWindow *parent) { m_windowParent = parent; } |
| 237 | |
| 238 | // the title for the dialogs (note that default is quite reasonable) |
| 239 | void SetDialogTitle(const wxString& title) { m_titleDialog = title; } |
| 240 | |
| 241 | // GUI code needs to know it's a wxFontMapper because there |
| 242 | // are additional methods in the subclass. |
| 243 | static wxFontMapper *Get(); |
| 244 | |
| 245 | // pseudo-RTTI since we aren't a wxObject. |
| 246 | virtual bool IsDummy() { return false; } |
| 247 | |
| 248 | protected: |
| 249 | // GetAltForEncoding() helper: tests for the existence of the given |
| 250 | // encoding and saves the result in config if ok - this results in the |
| 251 | // following (desired) behaviour: when an unknown/unavailable encoding is |
| 252 | // requested for the first time, the user is asked about a replacement, |
| 253 | // but if he doesn't choose any and the default logic finds one, it will |
| 254 | // be saved in the config so that the user won't be asked about it any |
| 255 | // more |
| 256 | bool TestAltEncoding(const wxString& configEntry, |
| 257 | wxFontEncoding encReplacement, |
| 258 | wxNativeEncodingInfo *info); |
| 259 | |
| 260 | // the title for our dialogs |
| 261 | wxString m_titleDialog; |
| 262 | |
| 263 | // the parent window for our dialogs |
| 264 | wxWindow *m_windowParent; |
| 265 | |
| 266 | private: |
| 267 | wxDECLARE_NO_COPY_CLASS(wxFontMapper); |
| 268 | }; |
| 269 | |
| 270 | #endif // wxUSE_GUI |
| 271 | |
| 272 | // ---------------------------------------------------------------------------- |
| 273 | // global variables |
| 274 | // ---------------------------------------------------------------------------- |
| 275 | |
| 276 | // the default font mapper for wxWidgets programs do NOT use! This is for |
| 277 | // backward compatibility, use wxFontMapper::Get() instead |
| 278 | #define wxTheFontMapper (wxFontMapper::Get()) |
| 279 | |
| 280 | #else // !wxUSE_FONTMAP |
| 281 | |
| 282 | #if wxUSE_GUI |
| 283 | // wxEncodingToCodepage (utils.cpp) needs wxGetNativeFontEncoding |
| 284 | #include "wx/fontutil.h" |
| 285 | #endif |
| 286 | |
| 287 | #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP |
| 288 | |
| 289 | #endif // _WX_FONTMAPPER_H_ |
| 290 | |