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

Contents of /trunk/3rdparty/wxWidgets/src/common/platinfo.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: 9043 byte(s)
committing r3113 initial commit again...
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/platinfo.cpp
3 // Purpose: implements wxPlatformInfo class
4 // Author: Francesco Montorsi
5 // Modified by:
6 // Created: 07.07.2006 (based on wxToolkitInfo)
7 // RCS-ID: $Id: platinfo.cpp 44078 2006-12-30 21:46:22Z SN $
8 // Copyright: (c) 2006 Francesco Montorsi
9 // License: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // for compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/platinfo.h"
28
29 #ifndef WX_PRECOMP
30 #include "wx/app.h"
31 #include "wx/utils.h"
32 #endif //WX_PRECOMP
33
34 #include "wx/apptrait.h"
35
36 // global object
37 // VERY IMPORTANT: do not use the default constructor since it would
38 // try to init the wxPlatformInfo instance using
39 // gs_platInfo itself!
40 static wxPlatformInfo gs_platInfo(wxPORT_UNKNOWN);
41
42 // ----------------------------------------------------------------------------
43 // constants
44 // ----------------------------------------------------------------------------
45
46 static const wxChar* const wxOperatingSystemIdNames[] =
47 {
48 _T("Apple Mac OS"),
49 _T("Apple Mac OS X"),
50
51 _T("Microsoft Windows 9X"),
52 _T("Microsoft Windows NT"),
53 _T("Microsoft Windows Micro"),
54 _T("Microsoft Windows CE"),
55
56 _T("Linux"),
57 _T("FreeBSD"),
58 _T("OpenBSD"),
59 _T("NetBSD"),
60
61 _T("SunOS"),
62 _T("AIX"),
63 _T("HPUX"),
64
65 _T("Other Unix"),
66 _T("Other Unix"),
67
68 _T("DOS"),
69 _T("OS/2")
70 };
71
72 static const wxChar* const wxPortIdNames[] =
73 {
74 _T("wxBase"),
75 _T("wxMSW"),
76 _T("wxMotif"),
77 _T("wxGTK"),
78 _T("wxMGL"),
79 _T("wxX11"),
80 _T("wxOS2"),
81 _T("wxMac"),
82 _T("wxCocoa"),
83 _T("wxWinCE"),
84 _T("wxPalmOS"),
85 _T("wxDFB")
86 };
87
88 static const wxChar* const wxArchitectureNames[] =
89 {
90 _T("32 bit"),
91 _T("64 bit")
92 };
93
94 static const wxChar* const wxEndiannessNames[] =
95 {
96 _T("Big endian"),
97 _T("Little endian"),
98 _T("PDP endian")
99 };
100
101 // ----------------------------------------------------------------------------
102 // local functions
103 // ----------------------------------------------------------------------------
104
105 // returns log in base 2 of the value, this maps the enum values to the
106 // corresponding indices
107 static unsigned wxGetIndexFromEnumValue(int value)
108 {
109 wxCHECK_MSG( value, (unsigned)-1, _T("invalid enum value") );
110
111 int n = 0;
112 while ( !(value & 1) )
113 {
114 value >>= 1;
115 n++;
116 }
117
118 wxASSERT_MSG( value == 1, _T("more than one bit set in enum value") );
119
120 return n;
121 }
122
123 // ----------------------------------------------------------------------------
124 // wxPlatformInfo
125 // ----------------------------------------------------------------------------
126
127 wxPlatformInfo::wxPlatformInfo()
128 {
129 // just copy platform info for currently running platform
130 *this = Get();
131 }
132
133 wxPlatformInfo::wxPlatformInfo(wxPortId pid, int tkMajor, int tkMinor,
134 wxOperatingSystemId id, int osMajor, int osMinor,
135 wxArchitecture arch,
136 wxEndianness endian,
137 bool usingUniversal)
138 {
139 m_tkVersionMajor = tkMajor;
140 m_tkVersionMinor = tkMinor;
141 m_port = pid;
142 m_usingUniversal = usingUniversal;
143
144 m_os = id;
145 m_osVersionMajor = osMajor;
146 m_osVersionMinor = osMinor;
147
148 m_endian = endian;
149 m_arch = arch;
150 }
151
152 bool wxPlatformInfo::operator==(const wxPlatformInfo &t) const
153 {
154 return m_tkVersionMajor == t.m_tkVersionMajor &&
155 m_tkVersionMinor == t.m_tkVersionMinor &&
156 m_osVersionMajor == t.m_osVersionMajor &&
157 m_osVersionMinor == t.m_osVersionMinor &&
158 m_os == t.m_os &&
159 m_port == t.m_port &&
160 m_usingUniversal == t.m_usingUniversal &&
161 m_arch == t.m_arch &&
162 m_endian == t.m_endian;
163 }
164
165 void wxPlatformInfo::InitForCurrentPlatform()
166 {
167 // autodetect all informations
168 const wxAppTraits * const traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
169 if ( !traits )
170 {
171 wxFAIL_MSG( _T("failed to initialize wxPlatformInfo") );
172
173 m_port = wxPORT_UNKNOWN;
174 m_usingUniversal = false;
175 m_tkVersionMajor =
176 m_tkVersionMinor = 0;
177 }
178 else
179 {
180 m_port = traits->GetToolkitVersion(&m_tkVersionMajor, &m_tkVersionMinor);
181 m_usingUniversal = traits->IsUsingUniversalWidgets();
182 }
183
184 m_os = wxGetOsVersion(&m_osVersionMajor, &m_osVersionMinor);
185 m_endian = wxIsPlatformLittleEndian() ? wxENDIAN_LITTLE : wxENDIAN_BIG;
186 m_arch = wxIsPlatform64Bit() ? wxARCH_64 : wxARCH_32;
187 }
188
189 /* static */
190 const wxPlatformInfo& wxPlatformInfo::Get()
191 {
192 static bool initialized = false;
193 if ( !initialized )
194 {
195 gs_platInfo.InitForCurrentPlatform();
196 initialized = true;
197 }
198
199 return gs_platInfo;
200 }
201
202
203
204 // ----------------------------------------------------------------------------
205 // wxPlatformInfo - enum -> string conversions
206 // ----------------------------------------------------------------------------
207
208 wxString wxPlatformInfo::GetOperatingSystemFamilyName(wxOperatingSystemId os)
209 {
210 const wxChar* string = _T("Unknown");
211 if ( os & wxOS_MAC )
212 string = _T("Macintosh");
213 else if ( os & wxOS_WINDOWS )
214 string = _T("Windows");
215 else if ( os & wxOS_UNIX )
216 string = _T("Unix");
217 else if ( os == wxOS_DOS )
218 string = _T("DOS");
219 else if ( os == wxOS_OS2 )
220 string = _T("OS/2");
221
222 return string;
223 }
224
225 wxString wxPlatformInfo::GetOperatingSystemIdName(wxOperatingSystemId os)
226 {
227 const unsigned idx = wxGetIndexFromEnumValue(os);
228
229 wxCHECK_MSG( idx < WXSIZEOF(wxOperatingSystemIdNames), wxEmptyString,
230 _T("invalid OS id") );
231
232 return wxOperatingSystemIdNames[idx];
233 }
234
235 wxString wxPlatformInfo::GetPortIdName(wxPortId port, bool usingUniversal)
236 {
237 const unsigned idx = wxGetIndexFromEnumValue(port);
238
239 wxCHECK_MSG( idx < WXSIZEOF(wxPortIdNames), wxEmptyString,
240 _T("invalid port id") );
241
242 wxString ret = wxPortIdNames[idx];
243
244 if ( usingUniversal )
245 ret += wxT("/wxUniversal");
246
247 return ret;
248 }
249
250 wxString wxPlatformInfo::GetPortIdShortName(wxPortId port, bool usingUniversal)
251 {
252 const unsigned idx = wxGetIndexFromEnumValue(port);
253
254 wxCHECK_MSG( idx < WXSIZEOF(wxPortIdNames), wxEmptyString,
255 _T("invalid port id") );
256
257 wxString ret = wxPortIdNames[idx];
258 ret = ret.Mid(2).Lower(); // remove 'wx' prefix
259
260 if ( usingUniversal )
261 ret += wxT("univ");
262
263 return ret;
264 }
265
266 wxString wxPlatformInfo::GetArchName(wxArchitecture arch)
267 {
268 wxCOMPILE_TIME_ASSERT( WXSIZEOF(wxArchitectureNames) == wxARCH_MAX,
269 wxArchitectureNamesMismatch );
270
271 return wxArchitectureNames[arch];
272 }
273
274 wxString wxPlatformInfo::GetEndiannessName(wxEndianness end)
275 {
276 wxCOMPILE_TIME_ASSERT( WXSIZEOF(wxEndiannessNames) == wxENDIAN_MAX,
277 wxEndiannessNamesMismatch );
278
279 return wxEndiannessNames[end];
280 }
281
282
283 // ----------------------------------------------------------------------------
284 // wxPlatformInfo - string -> enum conversions
285 // ----------------------------------------------------------------------------
286
287 wxOperatingSystemId wxPlatformInfo::GetOperatingSystemId(const wxString &str)
288 {
289 for ( size_t i = 0; i < WXSIZEOF(wxOperatingSystemIdNames); i++ )
290 {
291 if ( wxString(wxOperatingSystemIdNames[i]).CmpNoCase(str) == 0 )
292 return (wxOperatingSystemId)(1 << i);
293 }
294
295 return wxOS_UNKNOWN;
296 }
297
298 wxPortId wxPlatformInfo::GetPortId(const wxString &str)
299 {
300 // recognize both short and long port names
301 for ( size_t i = 0; i < WXSIZEOF(wxPortIdNames); i++ )
302 {
303 wxPortId current = (wxPortId)(1 << i);
304
305 if ( wxString(wxPortIdNames[i]).CmpNoCase(str) == 0 ||
306 GetPortIdShortName(current, true).CmpNoCase(str) == 0 ||
307 GetPortIdShortName(current, false).CmpNoCase(str) == 0 )
308 return current;
309 }
310
311 return wxPORT_UNKNOWN;
312 }
313
314 wxArchitecture wxPlatformInfo::GetArch(const wxString &arch)
315 {
316 if ( arch.Contains(wxT("32")) )
317 return wxARCH_32;
318
319 if ( arch.Contains(wxT("64")) )
320 return wxARCH_64;
321
322 return wxARCH_INVALID;
323 }
324
325 wxEndianness wxPlatformInfo::GetEndianness(const wxString& end)
326 {
327 wxString endl(end.Lower());
328 if ( end.StartsWith(wxT("little")) )
329 return wxENDIAN_LITTLE;
330
331 if ( end.StartsWith(wxT("big")) )
332 return wxENDIAN_BIG;
333
334 return wxENDIAN_INVALID;
335 }
336

  ViewVC Help
Powered by ViewVC 1.1.22