src/common/platinfo.cpp

   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$
   8 // Copyright:   (c) 2006 Francesco Montorsi
   9 // Licence:     wxWindows licence
  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     wxT("Apple Mac OS"),
  49     wxT("Apple Mac OS X"),
  50
  51     wxT("Microsoft Windows 9X"),
  52     wxT("Microsoft Windows NT"),
  53     wxT("Microsoft Windows Micro"),
  54     wxT("Microsoft Windows CE"),
  55
  56     wxT("Linux"),
  57     wxT("FreeBSD"),
  58     wxT("OpenBSD"),
  59     wxT("NetBSD"),
  60
  61     wxT("SunOS"),
  62     wxT("AIX"),
  63     wxT("HPUX"),
  64
  65     wxT("Other Unix"),
  66     wxT("Other Unix"),
  67
  68     wxT("DOS"),
  69     wxT("OS/2"),
  70
  71     wxT("PalmOS"),
  72     wxT("PalmOS(Over Linux)"),
  73 };
  74
  75 static const wxChar* const wxPortIdNames[] =
  76 {
  77     wxT("wxBase"),
  78     wxT("wxMSW"),
  79     wxT("wxMotif"),
  80     wxT("wxGTK"),
  81     wxT("wxMGL"),
  82     wxT("wxX11"),
  83     wxT("wxOS2"),
  84     wxT("wxMac"),
  85     wxT("wxCocoa"),
  86     wxT("wxWinCE"),
  87     wxT("wxPalmOS"),
  88     wxT("wxDFB")
  89 };
  90
  91 static const wxChar* const wxArchitectureNames[] =
  92 {
  93     wxT("32 bit"),
  94     wxT("64 bit")
  95 };
  96
  97 static const wxChar* const wxEndiannessNames[] =
  98 {
  99     wxT("Big endian"),
 100     wxT("Little endian"),
 101     wxT("PDP endian")
 102 };
 103
 104 // ----------------------------------------------------------------------------
 105 // local functions
 106 // ----------------------------------------------------------------------------
 107
 108 // returns the logarithm in base 2 of 'value'; this maps the enum values to the
 109 // corresponding indexes of the string arrays above
 110 static unsigned wxGetIndexFromEnumValue(int value)
 111 {
 112     wxCHECK_MSG( value, (unsigned)-1, wxT("invalid enum value") );
 113
 114     int n = 0;
 115     while ( !(value & 1) )
 116     {
 117         value >>= 1;
 118         n++;
 119     }
 120
 121     wxASSERT_MSG( value == 1, wxT("more than one bit set in enum value") );
 122
 123     return n;
 124 }
 125
 126 // ----------------------------------------------------------------------------
 127 // wxPlatformInfo
 128 // ----------------------------------------------------------------------------
 129
 130 wxPlatformInfo::wxPlatformInfo()
 131 {
 132     // just copy platform info for currently running platform
 133     *this = Get();
 134 }
 135
 136 wxPlatformInfo::wxPlatformInfo(wxPortId pid, int tkMajor, int tkMinor,
 137                                wxOperatingSystemId id, int osMajor, int osMinor,
 138                                wxArchitecture arch,
 139                                wxEndianness endian,
 140                                bool usingUniversal)
 141 {
 142     m_tkVersionMajor = tkMajor;
 143     m_tkVersionMinor = tkMinor;
 144     m_port = pid;
 145     m_usingUniversal = usingUniversal;
 146
 147     m_os = id;
 148     m_osVersionMajor = osMajor;
 149     m_osVersionMinor = osMinor;
 150
 151     m_endian = endian;
 152     m_arch = arch;
 153 }
 154
 155 bool wxPlatformInfo::operator==(const wxPlatformInfo &t) const
 156 {
 157     return m_tkVersionMajor == t.m_tkVersionMajor &&
 158            m_tkVersionMinor == t.m_tkVersionMinor &&
 159            m_osVersionMajor == t.m_osVersionMajor &&
 160            m_osVersionMinor == t.m_osVersionMinor &&
 161            m_os == t.m_os &&
 162            m_osDesc == t.m_osDesc &&
 163            m_ldi == t.m_ldi &&
 164            m_desktopEnv == t.m_desktopEnv &&
 165            m_port == t.m_port &&
 166            m_usingUniversal == t.m_usingUniversal &&
 167            m_arch == t.m_arch &&
 168            m_endian == t.m_endian;
 169 }
 170
 171 void wxPlatformInfo::InitForCurrentPlatform()
 172 {
 173     // autodetect all informations
 174     const wxAppTraits * const traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
 175     if ( !traits )
 176     {
 177         wxFAIL_MSG( wxT("failed to initialize wxPlatformInfo") );
 178
 179         m_port = wxPORT_UNKNOWN;
 180         m_usingUniversal = false;
 181         m_tkVersionMajor =
 182                 m_tkVersionMinor = 0;
 183     }
 184     else
 185     {
 186         m_port = traits->GetToolkitVersion(&m_tkVersionMajor, &m_tkVersionMinor);
 187         m_usingUniversal = traits->IsUsingUniversalWidgets();
 188         m_desktopEnv = traits->GetDesktopEnvironment();
 189     }
 190
 191     m_os = wxGetOsVersion(&m_osVersionMajor, &m_osVersionMinor);
 192     m_osDesc = wxGetOsDescription();
 193     m_endian = wxIsPlatformLittleEndian() ? wxENDIAN_LITTLE : wxENDIAN_BIG;
 194     m_arch = wxIsPlatform64Bit() ? wxARCH_64 : wxARCH_32;
 195
 196 #ifdef __LINUX__
 197     m_ldi = wxGetLinuxDistributionInfo();
 198 #endif
 199     // else: leave m_ldi empty
 200 }
 201
 202 /* static */
 203 const wxPlatformInfo& wxPlatformInfo::Get()
 204 {
 205     static bool initialized = false;
 206     if ( !initialized )
 207     {
 208         gs_platInfo.InitForCurrentPlatform();
 209         initialized = true;
 210     }
 211
 212     return gs_platInfo;
 213 }
 214
 215 /* static */
 216 wxString wxPlatformInfo::GetOperatingSystemDirectory()
 217 {
 218     return wxGetOSDirectory();
 219 }
 220
 221
 222
 223 // ----------------------------------------------------------------------------
 224 // wxPlatformInfo - enum -> string conversions
 225 // ----------------------------------------------------------------------------
 226
 227 wxString wxPlatformInfo::GetOperatingSystemFamilyName(wxOperatingSystemId os)
 228 {
 229     const wxChar* string = wxT("Unknown");
 230     if ( os & wxOS_MAC )
 231         string = wxT("Macintosh");
 232     else if ( os & wxOS_WINDOWS )
 233         string = wxT("Windows");
 234     else if ( os & wxOS_UNIX )
 235         string = wxT("Unix");
 236     else if ( os == wxOS_DOS )
 237         string = wxT("DOS");
 238     else if ( os == wxOS_OS2 )
 239         string = wxT("OS/2");
 240
 241     return string;
 242 }
 243
 244 wxString wxPlatformInfo::GetOperatingSystemIdName(wxOperatingSystemId os)
 245 {
 246     const unsigned idx = wxGetIndexFromEnumValue(os);
 247
 248     wxCHECK_MSG( idx < WXSIZEOF(wxOperatingSystemIdNames), wxEmptyString,
 249                  wxT("invalid OS id") );
 250
 251     return wxOperatingSystemIdNames[idx];
 252 }
 253
 254 wxString wxPlatformInfo::GetPortIdName(wxPortId port, bool usingUniversal)
 255 {
 256     const unsigned idx = wxGetIndexFromEnumValue(port);
 257
 258     wxCHECK_MSG( idx < WXSIZEOF(wxPortIdNames), wxEmptyString,
 259                  wxT("invalid port id") );
 260
 261     wxString ret = wxPortIdNames[idx];
 262
 263     if ( usingUniversal )
 264         ret += wxT("/wxUniversal");
 265
 266     return ret;
 267 }
 268
 269 wxString wxPlatformInfo::GetPortIdShortName(wxPortId port, bool usingUniversal)
 270 {
 271     const unsigned idx = wxGetIndexFromEnumValue(port);
 272
 273     wxCHECK_MSG( idx < WXSIZEOF(wxPortIdNames), wxEmptyString,
 274                  wxT("invalid port id") );
 275
 276     wxString ret = wxPortIdNames[idx];
 277     ret = ret.Mid(2).Lower();       // remove 'wx' prefix
 278
 279     if ( usingUniversal )
 280         ret += wxT("univ");
 281
 282     return ret;
 283 }
 284
 285 wxString wxPlatformInfo::GetArchName(wxArchitecture arch)
 286 {
 287     wxCOMPILE_TIME_ASSERT( WXSIZEOF(wxArchitectureNames) == wxARCH_MAX,
 288                            wxArchitectureNamesMismatch );
 289
 290     return wxArchitectureNames[arch];
 291 }
 292
 293 wxString wxPlatformInfo::GetEndiannessName(wxEndianness end)
 294 {
 295     wxCOMPILE_TIME_ASSERT( WXSIZEOF(wxEndiannessNames) == wxENDIAN_MAX,
 296                            wxEndiannessNamesMismatch );
 297
 298     return wxEndiannessNames[end];
 299 }
 300
 301
 302 // ----------------------------------------------------------------------------
 303 // wxPlatformInfo - string -> enum conversions
 304 // ----------------------------------------------------------------------------
 305
 306 wxOperatingSystemId wxPlatformInfo::GetOperatingSystemId(const wxString &str)
 307 {
 308     for ( size_t i = 0; i < WXSIZEOF(wxOperatingSystemIdNames); i++ )
 309     {
 310         if ( wxString(wxOperatingSystemIdNames[i]).CmpNoCase(str) == 0 )
 311             return (wxOperatingSystemId)(1 << i);
 312     }
 313
 314     return wxOS_UNKNOWN;
 315 }
 316
 317 wxPortId wxPlatformInfo::GetPortId(const wxString &str)
 318 {
 319     // recognize both short and long port names
 320     for ( size_t i = 0; i < WXSIZEOF(wxPortIdNames); i++ )
 321     {
 322         wxPortId current = (wxPortId)(1 << i);
 323
 324         if ( wxString(wxPortIdNames[i]).CmpNoCase(str) == 0 ||
 325              GetPortIdShortName(current, true).CmpNoCase(str) == 0 ||
 326              GetPortIdShortName(current, false).CmpNoCase(str) == 0 )
 327             return current;
 328     }
 329
 330     return wxPORT_UNKNOWN;
 331 }
 332
 333 wxArchitecture wxPlatformInfo::GetArch(const wxString &arch)
 334 {
 335     if ( arch.Contains(wxT("32")) )
 336         return wxARCH_32;
 337
 338     if ( arch.Contains(wxT("64")) )
 339         return wxARCH_64;
 340
 341     return wxARCH_INVALID;
 342 }
 343
 344 wxEndianness wxPlatformInfo::GetEndianness(const wxString& end)
 345 {
 346     const wxString endl(end.Lower());
 347     if ( endl.StartsWith(wxT("little")) )
 348         return wxENDIAN_LITTLE;
 349
 350     if ( endl.StartsWith(wxT("big")) )
 351         return wxENDIAN_BIG;
 352
 353     return wxENDIAN_INVALID;
 354 }
 355