/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/fontmap.h
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/fontmap.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 5 months ago) by william
File MIME type: text/plain
File size: 10814 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
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: fontmap.h 49563 2007-10-31 20:46:21Z VZ $
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 // 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 // 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 wxChar *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 DECLARE_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 DECLARE_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

  ViewVC Help
Powered by ViewVC 1.1.22