/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/fontmgrcmn.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/fontmgrcmn.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 2 months ago) by william
File size: 8857 byte(s)
committing r3113 initial commit again...
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/fontmgrcmn.cpp
3 // Purpose: font management for ports that don't have their own
4 // Author: Vaclav Slavik
5 // Created: 2006-11-18
6 // RCS-ID: $Id: fontmgrcmn.cpp 54757 2008-07-21 17:34:48Z VZ $
7 // Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
8 // (c) 2006 REA Elektronik GmbH
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #include "wx/private/fontmgr.h"
20
21 #include "wx/listimpl.cpp"
22 #include "wx/hashmap.h"
23
24 WX_DECLARE_LIST(wxFontInstance, wxFontInstanceList);
25 WX_DEFINE_LIST(wxFontInstanceList)
26 WX_DEFINE_LIST(wxFontBundleList)
27
28 WX_DECLARE_HASH_MAP(wxString, wxFontBundle*,
29 wxStringHash, wxStringEqual,
30 wxFontBundleHashBase);
31 // in STL build, hash class is typedef to a template, so it can't be forward
32 // declared, as we do; solve it by having a dummy class:
33 class wxFontBundleHash : public wxFontBundleHashBase
34 {
35 };
36
37 // ============================================================================
38 // implementation
39 // ============================================================================
40
41 // ----------------------------------------------------------------------------
42 // wxFontFaceBase
43 // ----------------------------------------------------------------------------
44
45 wxFontFaceBase::wxFontFaceBase()
46 : m_refCnt(0)
47 {
48 m_instances = new wxFontInstanceList;
49 m_instances->DeleteContents(true);
50 }
51
52 wxFontFaceBase::~wxFontFaceBase()
53 {
54 delete m_instances;
55 }
56
57 void wxFontFaceBase::Acquire()
58 {
59 m_refCnt++;
60 }
61
62 void wxFontFaceBase::Release()
63 {
64 if ( --m_refCnt == 0 )
65 {
66 m_instances->Clear();
67 }
68 }
69
70 wxFontInstance *wxFontFaceBase::GetFontInstance(float ptSize, bool aa)
71 {
72 wxASSERT_MSG( m_refCnt > 0, _T("font library not loaded!") );
73
74 for ( wxFontInstanceList::const_iterator i = m_instances->begin();
75 i != m_instances->end(); ++i )
76 {
77 if ( (*i)->GetPointSize() == ptSize && (*i)->IsAntiAliased() == aa )
78 return *i;
79 }
80
81 wxFontInstance *i = CreateFontInstance(ptSize, aa);
82 m_instances->Append(i);
83 return i;
84 }
85
86 // ----------------------------------------------------------------------------
87 // wxFontBundleBase
88 // ----------------------------------------------------------------------------
89
90 wxFontBundleBase::wxFontBundleBase()
91 {
92 for (int i = 0; i < FaceType_Max; i++)
93 m_faces[i] = NULL;
94 }
95
96 wxFontBundleBase::~wxFontBundleBase()
97 {
98 for (int i = 0; i < FaceType_Max; i++)
99 delete m_faces[i];
100 }
101
102 wxFontFace *wxFontBundleBase::GetFace(FaceType type) const
103 {
104 wxFontFace *f = m_faces[type];
105
106 wxCHECK_MSG( f, NULL, _T("no such face in font bundle") );
107
108 f->Acquire();
109
110 return f;
111 }
112
113 wxFontFace *
114 wxFontBundleBase::GetFaceForFont(const wxFontMgrFontRefData& font) const
115 {
116 wxASSERT_MSG( font.GetFaceName().empty() || font.GetFaceName() == GetName(),
117 _T("calling GetFaceForFont for incompatible font") );
118
119 int type = FaceType_Regular;
120
121 if ( font.GetWeight() == wxBOLD )
122 type |= FaceType_Bold;
123
124 // FIXME -- this should read "if ( font->GetStyle() == wxITALIC )",
125 // but since MGL neither DFB supports slant, we try to display it with
126 // italic face (better than nothing...)
127 if ( font.GetStyle() == wxITALIC || font.GetStyle() == wxSLANT )
128 {
129 if ( HasFace((FaceType)(type | FaceType_Italic)) )
130 type |= FaceType_Italic;
131 }
132
133 if ( !HasFace((FaceType)type) )
134 {
135 for (int i = 0; i < FaceType_Max; i++)
136 {
137 if ( HasFace((FaceType)i) )
138 return GetFace((FaceType)i);
139 }
140
141 wxFAIL_MSG( _T("no face") );
142 return NULL;
143 }
144
145 return GetFace((FaceType)type);
146 }
147
148 // ----------------------------------------------------------------------------
149 // wxFontsManagerBase
150 // ----------------------------------------------------------------------------
151
152 wxFontsManager *wxFontsManagerBase::ms_instance = NULL;
153
154 wxFontsManagerBase::wxFontsManagerBase()
155 {
156 m_hash = new wxFontBundleHash();
157 m_list = new wxFontBundleList;
158 m_list->DeleteContents(true);
159 }
160
161 wxFontsManagerBase::~wxFontsManagerBase()
162 {
163 delete m_hash;
164 delete m_list;
165 }
166
167 /* static */
168 wxFontsManager *wxFontsManagerBase::Get()
169 {
170 if ( !ms_instance )
171 ms_instance = new wxFontsManager();
172 return ms_instance;
173 }
174
175 /* static */
176 void wxFontsManagerBase::CleanUp()
177 {
178 wxDELETE(ms_instance);
179 }
180
181 wxFontBundle *wxFontsManagerBase::GetBundle(const wxString& name) const
182 {
183 return (*m_hash)[name.Lower()];
184 }
185
186 wxFontBundle *
187 wxFontsManagerBase::GetBundleForFont(const wxFontMgrFontRefData& font) const
188 {
189 wxFontBundle *bundle = NULL;
190
191 wxString facename = font.GetFaceName();
192 if ( !facename.empty() )
193 bundle = GetBundle(facename);
194
195 if ( !bundle )
196 {
197 facename = GetDefaultFacename((wxFontFamily)font.GetFamily());
198 if ( !facename.empty() )
199 bundle = GetBundle(facename);
200 }
201
202 if ( !bundle )
203 {
204 if ( m_list->GetFirst() )
205 bundle = m_list->GetFirst()->GetData();
206 else
207 wxFAIL_MSG(wxT("Fatal error, no fonts available!"));
208 }
209
210 return bundle;
211 }
212
213 void wxFontsManagerBase::AddBundle(wxFontBundle *bundle)
214 {
215 (*m_hash)[bundle->GetName().Lower()] = bundle;
216 m_list->Append(bundle);
217 }
218
219
220 // ----------------------------------------------------------------------------
221 // wxFontMgrFontRefData
222 // ----------------------------------------------------------------------------
223
224 wxFontMgrFontRefData::wxFontMgrFontRefData(int size,
225 int family,
226 int style,
227 int weight,
228 bool underlined,
229 const wxString& faceName,
230 wxFontEncoding encoding)
231 {
232 if ( family == wxDEFAULT )
233 family = wxSWISS;
234 if ( style == wxDEFAULT )
235 style = wxNORMAL;
236 if ( weight == wxDEFAULT )
237 weight = wxNORMAL;
238 if ( size == wxDEFAULT )
239 size = 12;
240
241 m_info.family = (wxFontFamily)family;
242 m_info.faceName = faceName;
243 m_info.style = (wxFontStyle)style;
244 m_info.weight = (wxFontWeight)weight;
245 m_info.pointSize = size;
246 m_info.underlined = underlined;
247 m_info.encoding = encoding;
248
249 m_noAA = false;
250
251 m_fontFace = NULL;
252 m_fontBundle = NULL;
253 m_fontValid = false;
254 }
255
256 wxFontMgrFontRefData::wxFontMgrFontRefData(const wxFontMgrFontRefData& data)
257 {
258 m_info = data.m_info;
259 m_noAA = data.m_noAA;
260
261 m_fontFace = data.m_fontFace;
262 m_fontBundle = data.m_fontBundle;
263 m_fontValid = data.m_fontValid;
264 if ( m_fontFace )
265 m_fontFace->Acquire();
266 }
267
268 wxFontMgrFontRefData::~wxFontMgrFontRefData()
269 {
270 if ( m_fontFace )
271 m_fontFace->Release();
272 }
273
274 wxFontBundle *wxFontMgrFontRefData::GetFontBundle() const
275 {
276 wxConstCast(this, wxFontMgrFontRefData)->EnsureValidFont();
277 return m_fontBundle;
278 }
279
280 wxFontInstance *
281 wxFontMgrFontRefData::GetFontInstance(float scale, bool antialiased) const
282 {
283 wxConstCast(this, wxFontMgrFontRefData)->EnsureValidFont();
284 return m_fontFace->GetFontInstance(m_info.pointSize * scale,
285 antialiased && !m_noAA);
286 }
287
288 void wxFontMgrFontRefData::SetPointSize(int pointSize)
289 {
290 m_info.pointSize = pointSize;
291 m_fontValid = false;
292 }
293
294 void wxFontMgrFontRefData::SetFamily(int family)
295 {
296 m_info.family = (wxFontFamily)family;
297 m_fontValid = false;
298 }
299
300 void wxFontMgrFontRefData::SetStyle(int style)
301 {
302 m_info.style = (wxFontStyle)style;
303 m_fontValid = false;
304 }
305
306 void wxFontMgrFontRefData::SetWeight(int weight)
307 {
308 m_info.weight = (wxFontWeight)weight;
309 m_fontValid = false;
310 }
311
312 void wxFontMgrFontRefData::SetFaceName(const wxString& faceName)
313 {
314 m_info.faceName = faceName;
315 m_fontValid = false;
316 }
317
318 void wxFontMgrFontRefData::SetUnderlined(bool underlined)
319 {
320 m_info.underlined = underlined;
321 m_fontValid = false;
322 }
323
324 void wxFontMgrFontRefData::SetEncoding(wxFontEncoding encoding)
325 {
326 m_info.encoding = encoding;
327 m_fontValid = false;
328 }
329
330 void wxFontMgrFontRefData::SetNoAntiAliasing(bool no)
331 {
332 m_noAA = no;
333 }
334
335
336 void wxFontMgrFontRefData::EnsureValidFont()
337 {
338 if ( !m_fontValid )
339 {
340 wxFontFace *old = m_fontFace;
341
342 m_fontBundle = wxFontsManager::Get()->GetBundleForFont(*this);
343 m_fontFace = m_fontBundle->GetFaceForFont(*this);
344
345 if ( old )
346 old->Release();
347 }
348 }

  ViewVC Help
Powered by ViewVC 1.1.22