src/msw/utils.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/utils.cpp
   3 // Purpose:     Various utilities
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   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 #ifndef WX_PRECOMP
  28     #include "wx/utils.h"
  29     #include "wx/app.h"
  30     #include "wx/intl.h"
  31     #include "wx/log.h"
  32 #endif  //WX_PRECOMP
  33
  34 #include "wx/msw/registry.h"
  35 #include "wx/apptrait.h"
  36 #include "wx/dynlib.h"
  37 #include "wx/dynload.h"
  38 #include "wx/scopeguard.h"
  39 #include "wx/filename.h"
  40
  41 #include "wx/confbase.h"        // for wxExpandEnvVars()
  42
  43 #include "wx/msw/private.h"     // includes <windows.h>
  44 #include "wx/msw/private/hiddenwin.h"
  45 #include "wx/msw/missing.h"     // for CHARSET_HANGUL
  46
  47 #if defined(__CYGWIN__)
  48     //CYGWIN gives annoying warning about runtime stuff if we don't do this
  49 #   define USE_SYS_TYPES_FD_SET
  50 #   include <sys/types.h>
  51 #endif
  52
  53 // Doesn't work with Cygwin at present
  54 #if wxUSE_SOCKETS && (defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) || defined(__CYGWIN32__))
  55     // apparently we need to include winsock.h to get WSADATA and other stuff
  56     // used in wxGetFullHostName() with the old mingw32 versions
  57     #include <winsock.h>
  58 #endif
  59
  60 #if !defined(__GNUWIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
  61     #include <direct.h>
  62
  63     #include <dos.h>
  64 #endif  //GNUWIN32
  65
  66 #if defined(__CYGWIN__)
  67     #include <sys/unistd.h>
  68     #include <sys/stat.h>
  69     #include <sys/cygwin.h> // for cygwin_conv_path()
  70     // and cygwin_conv_to_full_win32_path()
  71     #include <cygwin/version.h>
  72 #endif  //GNUWIN32
  73
  74 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
  75                     // this (3.1 I believe) and how to test for it.
  76                     // If this works for Borland 4.0 as well, then no worries.
  77     #include <dir.h>
  78 #endif
  79
  80 // VZ: there is some code using NetXXX() functions to get the full user name:
  81 //     I don't think it's a good idea because they don't work under Win95 and
  82 //     seem to return the same as wxGetUserId() under NT. If you really want
  83 //     to use them, just #define USE_NET_API
  84 #undef USE_NET_API
  85
  86 #ifdef USE_NET_API
  87     #include <lm.h>
  88 #endif // USE_NET_API
  89
  90 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
  91     #ifndef __UNIX__
  92         #include <io.h>
  93     #endif
  94
  95     #ifndef __GNUWIN32__
  96         #include <shellapi.h>
  97     #endif
  98 #endif
  99
 100 #ifndef __WATCOMC__
 101     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
 102         #include <errno.h>
 103     #endif
 104 #endif
 105
 106 // For wxKillAllChildren
 107 #include <tlhelp32.h>
 108
 109 // ----------------------------------------------------------------------------
 110 // constants
 111 // ----------------------------------------------------------------------------
 112
 113 // In the WIN.INI file
 114 #if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)
 115 static const wxChar WX_SECTION[] = wxT("wxWindows");
 116 #endif
 117
 118 #if (!defined(USE_NET_API) && !defined(__WXWINCE__))
 119 static const wxChar eUSERNAME[]  = wxT("UserName");
 120 #endif
 121
 122 WXDLLIMPEXP_DATA_BASE(const wxChar *) wxUserResourceStr = wxT("TEXT");
 123
 124 // ============================================================================
 125 // implementation
 126 // ============================================================================
 127
 128 // ----------------------------------------------------------------------------
 129 // get host name and related
 130 // ----------------------------------------------------------------------------
 131
 132 // Get hostname only (without domain name)
 133 bool wxGetHostName(wxChar *buf, int maxSize)
 134 {
 135 #if defined(__WXWINCE__)
 136     // GetComputerName() is not supported but the name seems to be stored in
 137     // this location in the registry, at least for PPC2003 and WM5
 138     wxString hostName;
 139     wxRegKey regKey(wxRegKey::HKLM, wxT("Ident"));
 140     if ( !regKey.HasValue(wxT("Name")) ||
 141             !regKey.QueryValue(wxT("Name"), hostName) )
 142         return false;
 143
 144     wxStrlcpy(buf, hostName.wx_str(), maxSize);
 145 #else // !__WXWINCE__
 146     DWORD nSize = maxSize;
 147     if ( !::GetComputerName(buf, &nSize) )
 148     {
 149         wxLogLastError(wxT("GetComputerName"));
 150
 151         return false;
 152     }
 153 #endif // __WXWINCE__/!__WXWINCE__
 154
 155     return true;
 156 }
 157
 158 // get full hostname (with domain name if possible)
 159 bool wxGetFullHostName(wxChar *buf, int maxSize)
 160 {
 161 #if !defined( __WXMICROWIN__) && wxUSE_DYNLIB_CLASS && wxUSE_SOCKETS
 162     // TODO should use GetComputerNameEx() when available
 163
 164     // we don't want to always link with Winsock DLL as we might not use it at
 165     // all, so load it dynamically here if needed (and don't complain if it is
 166     // missing, we handle this)
 167     wxLogNull noLog;
 168
 169     wxDynamicLibrary dllWinsock(wxT("ws2_32.dll"), wxDL_VERBATIM);
 170     if ( dllWinsock.IsLoaded() )
 171     {
 172         typedef int (PASCAL *WSAStartup_t)(WORD, WSADATA *);
 173         typedef int (PASCAL *gethostname_t)(char *, int);
 174         typedef hostent* (PASCAL *gethostbyname_t)(const char *);
 175         typedef hostent* (PASCAL *gethostbyaddr_t)(const char *, int , int);
 176         typedef int (PASCAL *WSACleanup_t)(void);
 177
 178         #define LOAD_WINSOCK_FUNC(func)                                       \
 179             func ## _t                                                        \
 180                 pfn ## func = (func ## _t)dllWinsock.GetSymbol(wxT(#func))
 181
 182         LOAD_WINSOCK_FUNC(WSAStartup);
 183
 184         WSADATA wsa;
 185         if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
 186         {
 187             LOAD_WINSOCK_FUNC(gethostname);
 188
 189             wxString host;
 190             if ( pfngethostname )
 191             {
 192                 char bufA[256];
 193                 if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
 194                 {
 195                     // gethostname() won't usually include the DNS domain name,
 196                     // for this we need to work a bit more
 197                     if ( !strchr(bufA, '.') )
 198                     {
 199                         LOAD_WINSOCK_FUNC(gethostbyname);
 200
 201                         struct hostent *pHostEnt = pfngethostbyname
 202                                                     ? pfngethostbyname(bufA)
 203                                                     : NULL;
 204
 205                         if ( pHostEnt )
 206                         {
 207                             // Windows will use DNS internally now
 208                             LOAD_WINSOCK_FUNC(gethostbyaddr);
 209
 210                             pHostEnt = pfngethostbyaddr
 211                                         ? pfngethostbyaddr(pHostEnt->h_addr,
 212                                                            4, AF_INET)
 213                                         : NULL;
 214                         }
 215
 216                         if ( pHostEnt )
 217                         {
 218                             host = wxString::FromAscii(pHostEnt->h_name);
 219                         }
 220                     }
 221                 }
 222             }
 223
 224             LOAD_WINSOCK_FUNC(WSACleanup);
 225             if ( pfnWSACleanup )
 226                 pfnWSACleanup();
 227
 228
 229             if ( !host.empty() )
 230             {
 231                 wxStrlcpy(buf, host.c_str(), maxSize);
 232
 233                 return true;
 234             }
 235         }
 236     }
 237 #endif // !__WXMICROWIN__
 238
 239     return wxGetHostName(buf, maxSize);
 240 }
 241
 242 // Get user ID e.g. jacs
 243 bool wxGetUserId(wxChar *WXUNUSED_IN_WINCE(buf),
 244                  int WXUNUSED_IN_WINCE(maxSize))
 245 {
 246 #if defined(__WXWINCE__)
 247     // TODO-CE
 248     return false;
 249 #else
 250     DWORD nSize = maxSize;
 251     if ( ::GetUserName(buf, &nSize) == 0 )
 252     {
 253         // actually, it does happen on Win9x if the user didn't log on
 254         DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize);
 255         if ( res == 0 )
 256         {
 257             // not found
 258             return false;
 259         }
 260     }
 261
 262     return true;
 263 #endif
 264 }
 265
 266 // Get user name e.g. Julian Smart
 267 bool wxGetUserName(wxChar *buf, int maxSize)
 268 {
 269     wxCHECK_MSG( buf && ( maxSize > 0 ), false,
 270                     wxT("empty buffer in wxGetUserName") );
 271 #if defined(__WXWINCE__) && wxUSE_REGKEY
 272     wxLogNull noLog;
 273     wxRegKey key(wxRegKey::HKCU, wxT("ControlPanel\\Owner"));
 274     if(!key.Open(wxRegKey::Read))
 275         return false;
 276     wxString name;
 277     if(!key.QueryValue(wxT("Owner"),name))
 278         return false;
 279     wxStrlcpy(buf, name.c_str(), maxSize);
 280     return true;
 281 #elif defined(USE_NET_API)
 282     CHAR szUserName[256];
 283     if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
 284         return false;
 285
 286     // TODO how to get the domain name?
 287     CHAR *szDomain = "";
 288
 289     // the code is based on the MSDN example (also see KB article Q119670)
 290     WCHAR wszUserName[256];          // Unicode user name
 291     WCHAR wszDomain[256];
 292     LPBYTE ComputerName;
 293
 294     USER_INFO_2 *ui2;         // User structure
 295
 296     // Convert ANSI user name and domain to Unicode
 297     MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
 298             wszUserName, WXSIZEOF(wszUserName) );
 299     MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
 300             wszDomain, WXSIZEOF(wszDomain) );
 301
 302     // Get the computer name of a DC for the domain.
 303     if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
 304     {
 305         wxLogError(wxT("Cannot find domain controller"));
 306
 307         goto error;
 308     }
 309
 310     // Look up the user on the DC
 311     NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName,
 312             (LPWSTR)&wszUserName,
 313             2, // level - we want USER_INFO_2
 314             (LPBYTE *) &ui2 );
 315     switch ( status )
 316     {
 317         case NERR_Success:
 318             // ok
 319             break;
 320
 321         case NERR_InvalidComputer:
 322             wxLogError(wxT("Invalid domain controller name."));
 323
 324             goto error;
 325
 326         case NERR_UserNotFound:
 327             wxLogError(wxT("Invalid user name '%s'."), szUserName);
 328
 329             goto error;
 330
 331         default:
 332             wxLogSysError(wxT("Can't get information about user"));
 333
 334             goto error;
 335     }
 336
 337     // Convert the Unicode full name to ANSI
 338     WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
 339             buf, maxSize, NULL, NULL );
 340
 341     return true;
 342
 343 error:
 344     wxLogError(wxT("Couldn't look up full user name."));
 345
 346     return false;
 347 #else  // !USE_NET_API
 348     // Could use NIS, MS-Mail or other site specific programs
 349     // Use wxWidgets configuration data
 350     bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
 351     if ( !ok )
 352     {
 353         ok = wxGetUserId(buf, maxSize);
 354     }
 355
 356     if ( !ok )
 357     {
 358         wxStrlcpy(buf, wxT("Unknown User"), maxSize);
 359     }
 360
 361     return true;
 362 #endif // Win32/16
 363 }
 364
 365 const wxChar* wxGetHomeDir(wxString *pstr)
 366 {
 367     wxString& strDir = *pstr;
 368
 369     // first branch is for Cygwin
 370 #if defined(__UNIX__) && !defined(__WINE__)
 371     const wxChar *szHome = wxGetenv(wxT("HOME"));
 372     if ( szHome == NULL ) {
 373       // we're homeless...
 374       wxLogWarning(_("can't find user's HOME, using current directory."));
 375       strDir = wxT(".");
 376     }
 377     else
 378        strDir = szHome;
 379
 380     // add a trailing slash if needed
 381     if ( strDir.Last() != wxT('/') )
 382       strDir << wxT('/');
 383
 384     #ifdef __CYGWIN__
 385         // Cygwin returns unix type path but that does not work well
 386         static wxChar windowsPath[MAX_PATH];
 387         #if CYGWIN_VERSION_DLL_MAJOR >= 1007
 388             cygwin_conv_path(CCP_POSIX_TO_WIN_W, strDir, windowsPath, MAX_PATH);
 389         #else
 390             cygwin_conv_to_full_win32_path(strDir, windowsPath);
 391         #endif
 392         strDir = windowsPath;
 393     #endif
 394 #elif defined(__WXWINCE__)
 395     strDir = wxT("\\");
 396 #else
 397     strDir.clear();
 398
 399     // If we have a valid HOME directory, as is used on many machines that
 400     // have unix utilities on them, we should use that.
 401     const wxChar *szHome = wxGetenv(wxT("HOME"));
 402
 403     if ( szHome != NULL )
 404     {
 405         strDir = szHome;
 406     }
 407     else // no HOME, try HOMEDRIVE/PATH
 408     {
 409         szHome = wxGetenv(wxT("HOMEDRIVE"));
 410         if ( szHome != NULL )
 411             strDir << szHome;
 412         szHome = wxGetenv(wxT("HOMEPATH"));
 413
 414         if ( szHome != NULL )
 415         {
 416             strDir << szHome;
 417
 418             // the idea is that under NT these variables have default values
 419             // of "%systemdrive%:" and "\\". As we don't want to create our
 420             // config files in the root directory of the system drive, we will
 421             // create it in our program's dir. However, if the user took care
 422             // to set HOMEPATH to something other than "\\", we suppose that he
 423             // knows what he is doing and use the supplied value.
 424             if ( wxStrcmp(szHome, wxT("\\")) == 0 )
 425                 strDir.clear();
 426         }
 427     }
 428
 429     if ( strDir.empty() )
 430     {
 431         // If we have a valid USERPROFILE directory, as is the case in
 432         // Windows NT, 2000 and XP, we should use that as our home directory.
 433         szHome = wxGetenv(wxT("USERPROFILE"));
 434
 435         if ( szHome != NULL )
 436             strDir = szHome;
 437     }
 438
 439     if ( !strDir.empty() )
 440     {
 441         // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
 442         // value once again, it shouldn't hurt anyhow
 443         strDir = wxExpandEnvVars(strDir);
 444     }
 445     else // fall back to the program directory
 446     {
 447         // extract the directory component of the program file name
 448         wxFileName::SplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);
 449     }
 450 #endif  // UNIX/Win
 451
 452     return strDir.c_str();
 453 }
 454
 455 wxString wxGetUserHome(const wxString& user)
 456 {
 457     wxString home;
 458
 459     if ( user.empty() || user == wxGetUserId() )
 460         wxGetHomeDir(&home);
 461
 462     return home;
 463 }
 464
 465 bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
 466                     wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
 467                     wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))
 468 {
 469 #ifdef __WXWINCE__
 470     // TODO-CE
 471     return false;
 472 #else
 473     if ( path.empty() )
 474         return false;
 475
 476 // old w32api don't have ULARGE_INTEGER
 477 #if defined(__WIN32__) && \
 478     (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
 479     // GetDiskFreeSpaceEx() is not available under original Win95, check for
 480     // it
 481     typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
 482                                                 PULARGE_INTEGER,
 483                                                 PULARGE_INTEGER,
 484                                                 PULARGE_INTEGER);
 485
 486     GetDiskFreeSpaceEx_t
 487         pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
 488                               (
 489                                 ::GetModuleHandle(wxT("kernel32.dll")),
 490 #if wxUSE_UNICODE
 491                                 "GetDiskFreeSpaceExW"
 492 #else
 493                                 "GetDiskFreeSpaceExA"
 494 #endif
 495                               );
 496
 497     if ( pGetDiskFreeSpaceEx )
 498     {
 499         ULARGE_INTEGER bytesFree, bytesTotal;
 500
 501         // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
 502         if ( !pGetDiskFreeSpaceEx(path.t_str(),
 503                                   &bytesFree,
 504                                   &bytesTotal,
 505                                   NULL) )
 506         {
 507             wxLogLastError(wxT("GetDiskFreeSpaceEx"));
 508
 509             return false;
 510         }
 511
 512         // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
 513         // two 32 bit fields which may be or may be not named - try to make it
 514         // compile in all cases
 515 #if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
 516         #define UL(ul) ul.u
 517 #else // anon union
 518         #define UL(ul) ul
 519 #endif
 520         if ( pTotal )
 521         {
 522 #if wxUSE_LONGLONG
 523             *pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
 524 #else
 525             *pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
 526 #endif
 527         }
 528
 529         if ( pFree )
 530         {
 531 #if wxUSE_LONGLONG
 532             *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
 533 #else
 534             *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
 535 #endif
 536         }
 537     }
 538     else
 539 #endif // Win32
 540     {
 541         // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
 542         // should be used instead - but if it's not available, fall back on
 543         // GetDiskFreeSpace() nevertheless...
 544
 545         DWORD lSectorsPerCluster,
 546               lBytesPerSector,
 547               lNumberOfFreeClusters,
 548               lTotalNumberOfClusters;
 549
 550         // FIXME: this is wrong, we should extract the root drive from path
 551         //        instead, but this is the job for wxFileName...
 552         if ( !::GetDiskFreeSpace(path.t_str(),
 553                                  &lSectorsPerCluster,
 554                                  &lBytesPerSector,
 555                                  &lNumberOfFreeClusters,
 556                                  &lTotalNumberOfClusters) )
 557         {
 558             wxLogLastError(wxT("GetDiskFreeSpace"));
 559
 560             return false;
 561         }
 562
 563         wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;
 564         lBytesPerCluster *= lBytesPerSector;
 565
 566         if ( pTotal )
 567         {
 568             *pTotal = lBytesPerCluster;
 569             *pTotal *= lTotalNumberOfClusters;
 570         }
 571
 572         if ( pFree )
 573         {
 574             *pFree = lBytesPerCluster;
 575             *pFree *= lNumberOfFreeClusters;
 576         }
 577     }
 578
 579     return true;
 580 #endif
 581     // __WXWINCE__
 582 }
 583
 584 // ----------------------------------------------------------------------------
 585 // env vars
 586 // ----------------------------------------------------------------------------
 587
 588 bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var),
 589               wxString *WXUNUSED_IN_WINCE(value))
 590 {
 591 #ifdef __WXWINCE__
 592     // no environment variables under CE
 593     return false;
 594 #else // Win32
 595     // first get the size of the buffer
 596     DWORD dwRet = ::GetEnvironmentVariable(var.t_str(), NULL, 0);
 597     if ( !dwRet )
 598     {
 599         // this means that there is no such variable
 600         return false;
 601     }
 602
 603     if ( value )
 604     {
 605         (void)::GetEnvironmentVariable(var.t_str(),
 606                                        wxStringBuffer(*value, dwRet),
 607                                        dwRet);
 608     }
 609
 610     return true;
 611 #endif // WinCE/32
 612 }
 613
 614 bool wxDoSetEnv(const wxString& var, const wxChar *value)
 615 {
 616 #ifdef __WXWINCE__
 617     // no environment variables under CE
 618     wxUnusedVar(var);
 619     wxUnusedVar(value);
 620     return false;
 621 #else // !__WXWINCE__
 622     // update the CRT environment if possible as people expect getenv() to also
 623     // work and it is not affected by Win32 SetEnvironmentVariable() call (OTOH
 624     // the CRT does use Win32 call to update the process environment block so
 625     // there is no need to call it)
 626     //
 627     // TODO: add checks for the other compilers (and update wxSetEnv()
 628     //       documentation in interface/wx/utils.h accordingly)
 629 #if defined(__VISUALC__) || defined(__MINGW32__)
 630     // notice that Microsoft _putenv() has different semantics from POSIX
 631     // function with almost the same name: in particular it makes a copy of the
 632     // string instead of using it as part of environment so we can safely call
 633     // it here without going through all the troubles with wxSetEnvModule as in
 634     // src/unix/utilsunx.cpp
 635     wxString envstr = var;
 636     envstr += '=';
 637     if ( value )
 638         envstr += value;
 639     _tputenv(envstr.t_str());
 640 #else // other compiler
 641     if ( !::SetEnvironmentVariable(var.t_str(), value) )
 642     {
 643         wxLogLastError(wxT("SetEnvironmentVariable"));
 644
 645         return false;
 646     }
 647 #endif // compiler
 648
 649     return true;
 650 #endif // __WXWINCE__/!__WXWINCE__
 651 }
 652
 653 bool wxSetEnv(const wxString& variable, const wxString& value)
 654 {
 655     return wxDoSetEnv(variable, value.t_str());
 656 }
 657
 658 bool wxUnsetEnv(const wxString& variable)
 659 {
 660     return wxDoSetEnv(variable, NULL);
 661 }
 662
 663 // ----------------------------------------------------------------------------
 664 // process management
 665 // ----------------------------------------------------------------------------
 666
 667 // structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
 668 struct wxFindByPidParams
 669 {
 670     wxFindByPidParams() { hwnd = 0; pid = 0; }
 671
 672     // the HWND used to return the result
 673     HWND hwnd;
 674
 675     // the PID we're looking from
 676     DWORD pid;
 677
 678     wxDECLARE_NO_COPY_CLASS(wxFindByPidParams);
 679 };
 680
 681 // wxKill helper: EnumWindows() callback which is used to find the first (top
 682 // level) window belonging to the given process
 683 BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)
 684 {
 685     DWORD pid;
 686     (void)::GetWindowThreadProcessId(hwnd, &pid);
 687
 688     wxFindByPidParams *params = (wxFindByPidParams *)lParam;
 689     if ( pid == params->pid )
 690     {
 691         // remember the window we found
 692         params->hwnd = hwnd;
 693
 694         // return FALSE to stop the enumeration
 695         return FALSE;
 696     }
 697
 698     // continue enumeration
 699     return TRUE;
 700 }
 701
 702 int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc);
 703
 704 int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
 705 {
 706     if (flags & wxKILL_CHILDREN)
 707         wxKillAllChildren(pid, sig, krc);
 708
 709     // get the process handle to operate on
 710     DWORD dwAccess = PROCESS_QUERY_INFORMATION | SYNCHRONIZE;
 711     if ( sig == wxSIGKILL )
 712         dwAccess |= PROCESS_TERMINATE;
 713
 714     HANDLE hProcess = ::OpenProcess(dwAccess, FALSE, (DWORD)pid);
 715     if ( hProcess == NULL )
 716     {
 717         if ( krc )
 718         {
 719             // recognize wxKILL_ACCESS_DENIED as special because this doesn't
 720             // mean that the process doesn't exist and this is important for
 721             // wxProcess::Exists()
 722             *krc = ::GetLastError() == ERROR_ACCESS_DENIED
 723                         ? wxKILL_ACCESS_DENIED
 724                         : wxKILL_NO_PROCESS;
 725         }
 726
 727         return -1;
 728     }
 729
 730     wxON_BLOCK_EXIT1(::CloseHandle, hProcess);
 731
 732     // Default timeout for waiting for the process termination after killing
 733     // it. It should be long enough to allow the process to terminate even on a
 734     // busy system but short enough to avoid blocking the main thread for too
 735     // long.
 736     DWORD waitTimeout = 500; // ms
 737
 738     bool ok = true;
 739     switch ( sig )
 740     {
 741         case wxSIGKILL:
 742             // kill the process forcefully returning -1 as error code
 743             if ( !::TerminateProcess(hProcess, (UINT)-1) )
 744             {
 745                 wxLogSysError(_("Failed to kill process %d"), pid);
 746
 747                 if ( krc )
 748                 {
 749                     // this is not supposed to happen if we could open the
 750                     // process
 751                     *krc = wxKILL_ERROR;
 752                 }
 753
 754                 ok = false;
 755             }
 756             break;
 757
 758         case wxSIGNONE:
 759             // Opening the process handle may succeed for a process even if it
 760             // doesn't run any more (typically because open handles to it still
 761             // exist elsewhere, possibly in this process itself if we're
 762             // killing a child process) so we still need check if it hasn't
 763             // terminated yet but, unlike when killing it, we don't need to
 764             // wait for any time at all.
 765             waitTimeout = 0;
 766             break;
 767
 768         default:
 769             // any other signal means "terminate"
 770             {
 771                 wxFindByPidParams params;
 772                 params.pid = (DWORD)pid;
 773
 774                 // EnumWindows() has nice semantics: it returns 0 if it found
 775                 // something or if an error occurred and non zero if it
 776                 // enumerated all the window
 777                 if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
 778                 {
 779                     // did we find any window?
 780                     if ( params.hwnd )
 781                     {
 782                         // tell the app to close
 783                         //
 784                         // NB: this is the harshest way, the app won't have an
 785                         //     opportunity to save any files, for example, but
 786                         //     this is probably what we want here. If not we
 787                         //     can also use SendMesageTimeout(WM_CLOSE)
 788                         if ( !::PostMessage(params.hwnd, WM_QUIT, 0, 0) )
 789                         {
 790                             wxLogLastError(wxT("PostMessage(WM_QUIT)"));
 791                         }
 792                     }
 793                     else // it was an error then
 794                     {
 795                         wxLogLastError(wxT("EnumWindows"));
 796
 797                         ok = false;
 798                     }
 799                 }
 800                 else // no windows for this PID
 801                 {
 802                     if ( krc )
 803                         *krc = wxKILL_ERROR;
 804
 805                     ok = false;
 806                 }
 807             }
 808     }
 809
 810     // the return code
 811     if ( ok )
 812     {
 813         // as we wait for a short time, we can use just WaitForSingleObject()
 814         // and not MsgWaitForMultipleObjects()
 815         switch ( ::WaitForSingleObject(hProcess, waitTimeout) )
 816         {
 817             case WAIT_OBJECT_0:
 818                 // Process terminated: normally this indicates that we
 819                 // successfully killed it but when testing for the process
 820                 // existence, this means failure.
 821                 if ( sig == wxSIGNONE )
 822                 {
 823                     if ( krc )
 824                         *krc = wxKILL_NO_PROCESS;
 825
 826                     ok = false;
 827                 }
 828                 break;
 829
 830             default:
 831                 wxFAIL_MSG( wxT("unexpected WaitForSingleObject() return") );
 832                 // fall through
 833
 834             case WAIT_FAILED:
 835                 wxLogLastError(wxT("WaitForSingleObject"));
 836                 // fall through
 837
 838             case WAIT_TIMEOUT:
 839                 // Process didn't terminate: normally this is a failure but not
 840                 // when we're just testing for its existence.
 841                 if ( sig != wxSIGNONE )
 842                 {
 843                     if ( krc )
 844                         *krc = wxKILL_ERROR;
 845
 846                     ok = false;
 847                 }
 848                 break;
 849         }
 850     }
 851
 852
 853     // the return code is the same as from Unix kill(): 0 if killed
 854     // successfully or -1 on error
 855     if ( !ok )
 856         return -1;
 857
 858     if ( krc )
 859         *krc = wxKILL_OK;
 860
 861     return 0;
 862 }
 863
 864 typedef HANDLE (WINAPI *CreateToolhelp32Snapshot_t)(DWORD,DWORD);
 865 typedef BOOL (WINAPI *Process32_t)(HANDLE,LPPROCESSENTRY32);
 866
 867 CreateToolhelp32Snapshot_t lpfCreateToolhelp32Snapshot;
 868 Process32_t lpfProcess32First, lpfProcess32Next;
 869
 870 static void InitToolHelp32()
 871 {
 872     static bool s_initToolHelpDone = false;
 873
 874     if (s_initToolHelpDone)
 875         return;
 876
 877     s_initToolHelpDone = true;
 878
 879     lpfCreateToolhelp32Snapshot = NULL;
 880     lpfProcess32First = NULL;
 881     lpfProcess32Next = NULL;
 882
 883 #if wxUSE_DYNLIB_CLASS
 884
 885     wxDynamicLibrary dllKernel(wxT("kernel32.dll"), wxDL_VERBATIM);
 886
 887     // Get procedure addresses.
 888     // We are linking to these functions of Kernel32
 889     // explicitly, because otherwise a module using
 890     // this code would fail to load under Windows NT,
 891     // which does not have the Toolhelp32
 892     // functions in the Kernel 32.
 893     lpfCreateToolhelp32Snapshot =
 894         (CreateToolhelp32Snapshot_t)dllKernel.RawGetSymbol(wxT("CreateToolhelp32Snapshot"));
 895
 896     lpfProcess32First =
 897         (Process32_t)dllKernel.RawGetSymbol(wxT("Process32First"));
 898
 899     lpfProcess32Next =
 900         (Process32_t)dllKernel.RawGetSymbol(wxT("Process32Next"));
 901
 902 #endif // wxUSE_DYNLIB_CLASS
 903 }
 904
 905 // By John Skiff
 906 int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc)
 907 {
 908     InitToolHelp32();
 909
 910     if (krc)
 911         *krc = wxKILL_OK;
 912
 913     // If not implemented for this platform (e.g. NT 4.0), silently ignore
 914     if (!lpfCreateToolhelp32Snapshot || !lpfProcess32First || !lpfProcess32Next)
 915         return 0;
 916
 917     // Take a snapshot of all processes in the system.
 918     HANDLE hProcessSnap = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 919     if (hProcessSnap == INVALID_HANDLE_VALUE) {
 920         if (krc)
 921             *krc = wxKILL_ERROR;
 922         return -1;
 923     }
 924
 925     //Fill in the size of the structure before using it.
 926     PROCESSENTRY32 pe;
 927     wxZeroMemory(pe);
 928     pe.dwSize = sizeof(PROCESSENTRY32);
 929
 930     // Walk the snapshot of the processes, and for each process,
 931     // kill it if its parent is pid.
 932     if (!lpfProcess32First(hProcessSnap, &pe)) {
 933         // Can't get first process.
 934         if (krc)
 935             *krc = wxKILL_ERROR;
 936         CloseHandle (hProcessSnap);
 937         return -1;
 938     }
 939
 940     do {
 941         if (pe.th32ParentProcessID == (DWORD) pid) {
 942             if (wxKill(pe.th32ProcessID, sig, krc))
 943                 return -1;
 944         }
 945     } while (lpfProcess32Next (hProcessSnap, &pe));
 946
 947
 948     return 0;
 949 }
 950
 951 // Execute a program in an Interactive Shell
 952 bool wxShell(const wxString& command)
 953 {
 954     wxString cmd;
 955
 956 #ifdef __WXWINCE__
 957     cmd = command;
 958 #else
 959     wxChar *shell = wxGetenv(wxT("COMSPEC"));
 960     if ( !shell )
 961         shell = (wxChar*) wxT("\\COMMAND.COM");
 962
 963     if ( !command )
 964     {
 965         // just the shell
 966         cmd = shell;
 967     }
 968     else
 969     {
 970         // pass the command to execute to the command processor
 971         cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
 972     }
 973 #endif
 974
 975     return wxExecute(cmd, wxEXEC_SYNC) == 0;
 976 }
 977
 978 // Shutdown or reboot the PC
 979 bool wxShutdown(int WXUNUSED_IN_WINCE(flags))
 980 {
 981 #ifdef __WXWINCE__
 982     // TODO-CE
 983     return false;
 984 #elif defined(__WIN32__)
 985     bool bOK = true;
 986
 987     if ( wxGetOsVersion(NULL, NULL) == wxOS_WINDOWS_NT ) // if is NT or 2K
 988     {
 989         // Get a token for this process.
 990         HANDLE hToken;
 991         bOK = ::OpenProcessToken(GetCurrentProcess(),
 992                                  TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
 993                                  &hToken) != 0;
 994         if ( bOK )
 995         {
 996             TOKEN_PRIVILEGES tkp;
 997
 998             // Get the LUID for the shutdown privilege.
 999             bOK = ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
1000                                          &tkp.Privileges[0].Luid) != 0;
1001
1002             if ( bOK )
1003             {
1004                 tkp.PrivilegeCount = 1;  // one privilege to set
1005                 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1006
1007                 // Get the shutdown privilege for this process.
1008                 ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
1009                                         (PTOKEN_PRIVILEGES)NULL, 0);
1010
1011                 // Cannot test the return value of AdjustTokenPrivileges.
1012                 bOK = ::GetLastError() == ERROR_SUCCESS;
1013             }
1014
1015             ::CloseHandle(hToken);
1016         }
1017     }
1018
1019     if ( bOK )
1020     {
1021         UINT wFlags = 0;
1022         if ( flags & wxSHUTDOWN_FORCE )
1023         {
1024             wFlags = EWX_FORCE;
1025             flags &= ~wxSHUTDOWN_FORCE;
1026         }
1027
1028         switch ( flags )
1029         {
1030             case wxSHUTDOWN_POWEROFF:
1031                 wFlags |= EWX_POWEROFF;
1032                 break;
1033
1034             case wxSHUTDOWN_REBOOT:
1035                 wFlags |= EWX_REBOOT;
1036                 break;
1037
1038             case wxSHUTDOWN_LOGOFF:
1039                 wFlags |= EWX_LOGOFF;
1040                 break;
1041
1042             default:
1043                 wxFAIL_MSG( wxT("unknown wxShutdown() flag") );
1044                 return false;
1045         }
1046
1047         bOK = ::ExitWindowsEx(wFlags, 0) != 0;
1048     }
1049
1050     return bOK;
1051 #endif // WinCE/!WinCE
1052 }
1053
1054 // ----------------------------------------------------------------------------
1055 // misc
1056 // ----------------------------------------------------------------------------
1057
1058 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
1059 wxMemorySize wxGetFreeMemory()
1060 {
1061 #if defined(__WIN64__)
1062     MEMORYSTATUSEX memStatex;
1063     memStatex.dwLength = sizeof (memStatex);
1064     ::GlobalMemoryStatusEx (&memStatex);
1065     return (wxMemorySize)memStatex.ullAvailPhys;
1066 #else /* if defined(__WIN32__) */
1067     MEMORYSTATUS memStatus;
1068     memStatus.dwLength = sizeof(MEMORYSTATUS);
1069     ::GlobalMemoryStatus(&memStatus);
1070     return (wxMemorySize)memStatus.dwAvailPhys;
1071 #endif
1072 }
1073
1074 unsigned long wxGetProcessId()
1075 {
1076     return ::GetCurrentProcessId();
1077 }
1078
1079 // Emit a beeeeeep
1080 void wxBell()
1081 {
1082     ::MessageBeep((UINT)-1);        // default sound
1083 }
1084
1085 bool wxIsDebuggerRunning()
1086 {
1087 #if wxUSE_DYNLIB_CLASS
1088     // IsDebuggerPresent() is not available under Win95, so load it dynamically
1089     wxDynamicLibrary dll(wxT("kernel32.dll"), wxDL_VERBATIM);
1090
1091     typedef BOOL (WINAPI *IsDebuggerPresent_t)();
1092     if ( !dll.HasSymbol(wxT("IsDebuggerPresent")) )
1093     {
1094         // no way to know, assume no
1095         return false;
1096     }
1097
1098     return (*(IsDebuggerPresent_t)dll.GetSymbol(wxT("IsDebuggerPresent")))() != 0;
1099 #else
1100     return false;
1101 #endif
1102 }
1103
1104 // ----------------------------------------------------------------------------
1105 // working with MSW resources
1106 // ----------------------------------------------------------------------------
1107
1108 bool
1109 wxLoadUserResource(const void **outData,
1110                    size_t *outLen,
1111                    const wxString& resourceName,
1112                    const wxString& resourceType,
1113                    WXHINSTANCE instance)
1114 {
1115     wxCHECK_MSG( outData && outLen, false, "output pointers can't be NULL" );
1116
1117     HRSRC hResource = ::FindResource(instance,
1118                                      resourceName.t_str(),
1119                                      resourceType.t_str());
1120     if ( !hResource )
1121         return false;
1122
1123     HGLOBAL hData = ::LoadResource(instance, hResource);
1124     if ( !hData )
1125     {
1126         wxLogSysError(_("Failed to load resource \"%s\"."), resourceName);
1127         return false;
1128     }
1129
1130     *outData = ::LockResource(hData);
1131     if ( !*outData )
1132     {
1133         wxLogSysError(_("Failed to lock resource \"%s\"."), resourceName);
1134         return false;
1135     }
1136
1137     *outLen = ::SizeofResource(instance, hResource);
1138
1139     // Notice that we do not need to call neither UnlockResource() (which is
1140     // obsolete in Win32) nor GlobalFree() (resources are freed on process
1141     // termination only)
1142
1143     return true;
1144 }
1145
1146 char *
1147 wxLoadUserResource(const wxString& resourceName,
1148                    const wxString& resourceType,
1149                    int* pLen,
1150                    WXHINSTANCE instance)
1151 {
1152     const void *data;
1153     size_t len;
1154     if ( !wxLoadUserResource(&data, &len, resourceName, resourceType, instance) )
1155         return NULL;
1156
1157     char *s = new char[len + 1];
1158     memcpy(s, data, len);
1159     s[len] = '\0'; // NUL-terminate in case the resource itself wasn't
1160
1161     if (pLen)
1162       *pLen = len;
1163
1164     return s;
1165 }
1166
1167 // ----------------------------------------------------------------------------
1168 // OS version
1169 // ----------------------------------------------------------------------------
1170
1171 // check if we're running under a server or workstation Windows system: it
1172 // returns true or false with obvious meaning as well as -1 if the system type
1173 // couldn't be determined
1174 //
1175 // this function is currently private but we may want to expose it later if
1176 // it's really useful
1177 namespace
1178 {
1179
1180 int wxIsWindowsServer()
1181 {
1182 #ifdef VER_NT_WORKSTATION
1183     OSVERSIONINFOEX info;
1184     wxZeroMemory(info);
1185
1186     info.dwOSVersionInfoSize = sizeof(info);
1187     if ( ::GetVersionEx(reinterpret_cast<OSVERSIONINFO *>(&info)) )
1188     {
1189         switch ( info.wProductType )
1190         {
1191             case VER_NT_WORKSTATION:
1192                 return false;
1193
1194             case VER_NT_SERVER:
1195             case VER_NT_DOMAIN_CONTROLLER:
1196                 return true;
1197         }
1198     }
1199 #endif // VER_NT_WORKSTATION
1200
1201     return -1;
1202 }
1203
1204 } // anonymous namespace
1205
1206 wxString wxGetOsDescription()
1207 {
1208     wxString str;
1209
1210     OSVERSIONINFO info;
1211     wxZeroMemory(info);
1212
1213     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1214     if ( ::GetVersionEx(&info) )
1215     {
1216         switch ( info.dwPlatformId )
1217         {
1218 #ifdef VER_PLATFORM_WIN32_CE
1219             case VER_PLATFORM_WIN32_CE:
1220                 str.Printf(_("Windows CE (%d.%d)"),
1221                            info.dwMajorVersion,
1222                            info.dwMinorVersion);
1223                 break;
1224 #endif
1225             case VER_PLATFORM_WIN32s:
1226                 str = _("Win32s on Windows 3.1");
1227                 break;
1228
1229             case VER_PLATFORM_WIN32_WINDOWS:
1230                 switch (info.dwMinorVersion)
1231                 {
1232                     case 0:
1233                         if ( info.szCSDVersion[1] == 'B' ||
1234                              info.szCSDVersion[1] == 'C' )
1235                         {
1236                             str = _("Windows 95 OSR2");
1237                         }
1238                         else
1239                         {
1240                             str = _("Windows 95");
1241                         }
1242                         break;
1243                     case 10:
1244                         if ( info.szCSDVersion[1] == 'B' ||
1245                              info.szCSDVersion[1] == 'C' )
1246                         {
1247                             str = _("Windows 98 SE");
1248                         }
1249                         else
1250                         {
1251                             str = _("Windows 98");
1252                         }
1253                         break;
1254                     case 90:
1255                         str = _("Windows ME");
1256                         break;
1257                     default:
1258                         str.Printf(_("Windows 9x (%d.%d)"),
1259                                    info.dwMajorVersion,
1260                                    info.dwMinorVersion);
1261                         break;
1262                 }
1263                 if ( !wxIsEmpty(info.szCSDVersion) )
1264                 {
1265                     str << wxT(" (") << info.szCSDVersion << wxT(')');
1266                 }
1267                 break;
1268
1269             case VER_PLATFORM_WIN32_NT:
1270                 switch ( info.dwMajorVersion )
1271                 {
1272                     case 5:
1273                         switch ( info.dwMinorVersion )
1274                         {
1275                             case 0:
1276                                 str = _("Windows 2000");
1277                                 break;
1278
1279                             case 2:
1280                                 // we can't distinguish between XP 64 and 2003
1281                                 // as they both are 5.2, so examine the product
1282                                 // type to resolve this ambiguity
1283                                 if ( wxIsWindowsServer() == 1 )
1284                                 {
1285                                     str = _("Windows Server 2003");
1286                                     break;
1287                                 }
1288                                 //else: must be XP, fall through
1289
1290                             case 1:
1291                                 str = _("Windows XP");
1292                                 break;
1293                         }
1294                         break;
1295
1296                     case 6:
1297                         switch ( info.dwMinorVersion )
1298                         {
1299                             case 0:
1300                                 str = wxIsWindowsServer() == 1
1301                                         ? _("Windows Server 2008")
1302                                         : _("Windows Vista");
1303                                 break;
1304
1305                             case 1:
1306                                 str = wxIsWindowsServer() == 1
1307                                         ? _("Windows Server 2008 R2")
1308                                         : _("Windows 7");
1309                                 break;
1310                         }
1311                         break;
1312                 }
1313
1314                 if ( str.empty() )
1315                 {
1316                     str.Printf(_("Windows NT %lu.%lu"),
1317                                info.dwMajorVersion,
1318                                info.dwMinorVersion);
1319                 }
1320
1321                 str << wxT(" (")
1322                     << wxString::Format(_("build %lu"), info.dwBuildNumber);
1323                 if ( !wxIsEmpty(info.szCSDVersion) )
1324                 {
1325                     str << wxT(", ") << info.szCSDVersion;
1326                 }
1327                 str << wxT(')');
1328
1329                 if ( wxIsPlatform64Bit() )
1330                     str << _(", 64-bit edition");
1331                 break;
1332         }
1333     }
1334     else
1335     {
1336         wxFAIL_MSG( wxT("GetVersionEx() failed") ); // should never happen
1337     }
1338
1339     return str;
1340 }
1341
1342 bool wxIsPlatform64Bit()
1343 {
1344 #if defined(_WIN64)
1345     return true;  // 64-bit programs run only on Win64
1346 #elif wxUSE_DYNLIB_CLASS // Win32
1347     // 32-bit programs run on both 32-bit and 64-bit Windows so check
1348     typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *);
1349
1350     wxDynamicLibrary dllKernel32(wxT("kernel32.dll"));
1351     IsWow64Process_t pfnIsWow64Process =
1352         (IsWow64Process_t)dllKernel32.RawGetSymbol(wxT("IsWow64Process"));
1353
1354     BOOL wow64 = FALSE;
1355     if ( pfnIsWow64Process )
1356     {
1357         pfnIsWow64Process(::GetCurrentProcess(), &wow64);
1358     }
1359     //else: running under a system without Win64 support
1360
1361     return wow64 != FALSE;
1362 #else
1363     return false;
1364 #endif // Win64/Win32
1365 }
1366
1367 wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
1368 {
1369     static struct
1370     {
1371         // this may be false, true or -1 if we tried to initialize but failed
1372         int initialized;
1373
1374         wxOperatingSystemId os;
1375
1376         int verMaj,
1377             verMin;
1378     } s_version;
1379
1380     // query the OS info only once as it's not supposed to change
1381     if ( !s_version.initialized )
1382     {
1383         OSVERSIONINFO info;
1384         wxZeroMemory(info);
1385         info.dwOSVersionInfoSize = sizeof(info);
1386         if ( ::GetVersionEx(&info) )
1387         {
1388             s_version.initialized = true;
1389
1390 #if defined(__WXWINCE__)
1391             s_version.os = wxOS_WINDOWS_CE;
1392 #elif defined(__WXMICROWIN__)
1393             s_version.os = wxOS_WINDOWS_MICRO;
1394 #else // "normal" desktop Windows system, use run-time detection
1395             switch ( info.dwPlatformId )
1396             {
1397                 case VER_PLATFORM_WIN32_NT:
1398                     s_version.os = wxOS_WINDOWS_NT;
1399                     break;
1400
1401                 case VER_PLATFORM_WIN32_WINDOWS:
1402                     s_version.os = wxOS_WINDOWS_9X;
1403                     break;
1404             }
1405 #endif // Windows versions
1406
1407             s_version.verMaj = info.dwMajorVersion;
1408             s_version.verMin = info.dwMinorVersion;
1409         }
1410         else // GetVersionEx() failed
1411         {
1412             s_version.initialized = -1;
1413         }
1414     }
1415
1416     if ( s_version.initialized == 1 )
1417     {
1418         if ( verMaj )
1419             *verMaj = s_version.verMaj;
1420         if ( verMin )
1421             *verMin = s_version.verMin;
1422     }
1423
1424     // this works even if we were not initialized successfully as the initial
1425     // values of this field is 0 which is wxOS_UNKNOWN and exactly what we need
1426     return s_version.os;
1427 }
1428
1429 wxWinVersion wxGetWinVersion()
1430 {
1431     int verMaj,
1432         verMin;
1433     switch ( wxGetOsVersion(&verMaj, &verMin) )
1434     {
1435         case wxOS_WINDOWS_9X:
1436             if ( verMaj == 4 )
1437             {
1438                 switch ( verMin )
1439                 {
1440                     case 0:
1441                         return wxWinVersion_95;
1442
1443                     case 10:
1444                         return wxWinVersion_98;
1445
1446                     case 90:
1447                         return wxWinVersion_ME;
1448                 }
1449             }
1450             break;
1451
1452         case wxOS_WINDOWS_NT:
1453             switch ( verMaj )
1454             {
1455                 case 3:
1456                     return wxWinVersion_NT3;
1457
1458                 case 4:
1459                     return wxWinVersion_NT4;
1460
1461                 case 5:
1462                     switch ( verMin )
1463                     {
1464                         case 0:
1465                             return wxWinVersion_2000;
1466
1467                         case 1:
1468                             return wxWinVersion_XP;
1469
1470                         case 2:
1471                             return wxWinVersion_2003;
1472                     }
1473                     break;
1474
1475                 case 6:
1476                     return wxWinVersion_NT6;
1477             }
1478             break;
1479
1480         default:
1481             // Do nothing just to silence GCC warning
1482             break;
1483     }
1484
1485     return wxWinVersion_Unknown;
1486 }
1487
1488 // ----------------------------------------------------------------------------
1489 // sleep functions
1490 // ----------------------------------------------------------------------------
1491
1492 void wxMilliSleep(unsigned long milliseconds)
1493 {
1494     ::Sleep(milliseconds);
1495 }
1496
1497 void wxMicroSleep(unsigned long microseconds)
1498 {
1499     wxMilliSleep(microseconds/1000);
1500 }
1501
1502 void wxSleep(int nSecs)
1503 {
1504     wxMilliSleep(1000*nSecs);
1505 }
1506
1507 // ----------------------------------------------------------------------------
1508 // font encoding <-> Win32 codepage conversion functions
1509 // ----------------------------------------------------------------------------
1510
1511 extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
1512 {
1513     switch ( encoding )
1514     {
1515         // although this function is supposed to return an exact match, do do
1516         // some mappings here for the most common case of "standard" encoding
1517         case wxFONTENCODING_SYSTEM:
1518             return DEFAULT_CHARSET;
1519
1520         case wxFONTENCODING_ISO8859_1:
1521         case wxFONTENCODING_ISO8859_15:
1522         case wxFONTENCODING_CP1252:
1523             return ANSI_CHARSET;
1524
1525 #if !defined(__WXMICROWIN__)
1526         // The following four fonts are multi-byte charsets
1527         case wxFONTENCODING_CP932:
1528             return SHIFTJIS_CHARSET;
1529
1530         case wxFONTENCODING_CP936:
1531             return GB2312_CHARSET;
1532
1533 #ifndef __WXWINCE__
1534         case wxFONTENCODING_CP949:
1535             return HANGUL_CHARSET;
1536 #endif
1537
1538         case wxFONTENCODING_CP950:
1539             return CHINESEBIG5_CHARSET;
1540
1541         // The rest are single byte encodings
1542         case wxFONTENCODING_CP1250:
1543             return EASTEUROPE_CHARSET;
1544
1545         case wxFONTENCODING_CP1251:
1546             return RUSSIAN_CHARSET;
1547
1548         case wxFONTENCODING_CP1253:
1549             return GREEK_CHARSET;
1550
1551         case wxFONTENCODING_CP1254:
1552             return TURKISH_CHARSET;
1553
1554         case wxFONTENCODING_CP1255:
1555             return HEBREW_CHARSET;
1556
1557         case wxFONTENCODING_CP1256:
1558             return ARABIC_CHARSET;
1559
1560         case wxFONTENCODING_CP1257:
1561             return BALTIC_CHARSET;
1562
1563         case wxFONTENCODING_CP874:
1564             return THAI_CHARSET;
1565 #endif // !__WXMICROWIN__
1566
1567         case wxFONTENCODING_CP437:
1568             return OEM_CHARSET;
1569
1570         default:
1571             // no way to translate this encoding into a Windows charset
1572             return -1;
1573     }
1574 }
1575
1576 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1577 // looks up the vlaues in the registry and the new one which is more
1578 // politically correct and has more chances to work on other Windows versions
1579 // as well but the old version is still needed for !wxUSE_FONTMAP case
1580 #if wxUSE_FONTMAP
1581
1582 #include "wx/fontmap.h"
1583
1584 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
1585 {
1586     // There don't seem to be symbolic names for
1587     // these under Windows so I just copied the
1588     // values from MSDN.
1589
1590     unsigned int ret;
1591
1592     switch (encoding)
1593     {
1594         case wxFONTENCODING_ISO8859_1:      ret = 28591; break;
1595         case wxFONTENCODING_ISO8859_2:      ret = 28592; break;
1596         case wxFONTENCODING_ISO8859_3:      ret = 28593; break;
1597         case wxFONTENCODING_ISO8859_4:      ret = 28594; break;
1598         case wxFONTENCODING_ISO8859_5:      ret = 28595; break;
1599         case wxFONTENCODING_ISO8859_6:      ret = 28596; break;
1600         case wxFONTENCODING_ISO8859_7:      ret = 28597; break;
1601         case wxFONTENCODING_ISO8859_8:      ret = 28598; break;
1602         case wxFONTENCODING_ISO8859_9:      ret = 28599; break;
1603         case wxFONTENCODING_ISO8859_10:     ret = 28600; break;
1604         case wxFONTENCODING_ISO8859_11:     ret = 874; break;
1605         // case wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
1606         case wxFONTENCODING_ISO8859_13:     ret = 28603; break;
1607         // case wxFONTENCODING_ISO8859_14:     ret = 28604; break; // no correspondence on Windows
1608         case wxFONTENCODING_ISO8859_15:     ret = 28605; break;
1609
1610         case wxFONTENCODING_KOI8:           ret = 20866; break;
1611         case wxFONTENCODING_KOI8_U:         ret = 21866; break;
1612
1613         case wxFONTENCODING_CP437:          ret = 437; break;
1614         case wxFONTENCODING_CP850:          ret = 850; break;
1615         case wxFONTENCODING_CP852:          ret = 852; break;
1616         case wxFONTENCODING_CP855:          ret = 855; break;
1617         case wxFONTENCODING_CP866:          ret = 866; break;
1618         case wxFONTENCODING_CP874:          ret = 874; break;
1619         case wxFONTENCODING_CP932:          ret = 932; break;
1620         case wxFONTENCODING_CP936:          ret = 936; break;
1621         case wxFONTENCODING_CP949:          ret = 949; break;
1622         case wxFONTENCODING_CP950:          ret = 950; break;
1623         case wxFONTENCODING_CP1250:         ret = 1250; break;
1624         case wxFONTENCODING_CP1251:         ret = 1251; break;
1625         case wxFONTENCODING_CP1252:         ret = 1252; break;
1626         case wxFONTENCODING_CP1253:         ret = 1253; break;
1627         case wxFONTENCODING_CP1254:         ret = 1254; break;
1628         case wxFONTENCODING_CP1255:         ret = 1255; break;
1629         case wxFONTENCODING_CP1256:         ret = 1256; break;
1630         case wxFONTENCODING_CP1257:         ret = 1257; break;
1631
1632         case wxFONTENCODING_EUC_JP:         ret = 20932; break;
1633
1634         case wxFONTENCODING_MACROMAN:       ret = 10000; break;
1635         case wxFONTENCODING_MACJAPANESE:    ret = 10001; break;
1636         case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break;
1637         case wxFONTENCODING_MACKOREAN:      ret = 10003; break;
1638         case wxFONTENCODING_MACARABIC:      ret = 10004; break;
1639         case wxFONTENCODING_MACHEBREW:      ret = 10005; break;
1640         case wxFONTENCODING_MACGREEK:       ret = 10006; break;
1641         case wxFONTENCODING_MACCYRILLIC:    ret = 10007; break;
1642         case wxFONTENCODING_MACTHAI:        ret = 10021; break;
1643         case wxFONTENCODING_MACCHINESESIMP: ret = 10008; break;
1644         case wxFONTENCODING_MACCENTRALEUR:  ret = 10029; break;
1645         case wxFONTENCODING_MACCROATIAN:    ret = 10082; break;
1646         case wxFONTENCODING_MACICELANDIC:   ret = 10079; break;
1647         case wxFONTENCODING_MACROMANIAN:    ret = 10009; break;
1648
1649         case wxFONTENCODING_ISO2022_JP:     ret = 50222; break;
1650
1651         case wxFONTENCODING_UTF7:           ret = 65000; break;
1652         case wxFONTENCODING_UTF8:           ret = 65001; break;
1653
1654         default:                            return -1;
1655     }
1656
1657     if (::IsValidCodePage(ret) == 0)
1658         return -1;
1659
1660     CPINFO info;
1661     if (::GetCPInfo(ret, &info) == 0)
1662         return -1;
1663
1664     return (long) ret;
1665 }
1666
1667 extern long wxCharsetToCodepage(const char *name)
1668 {
1669     // first get the font encoding for this charset
1670     if ( !name )
1671         return -1;
1672
1673     wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);
1674     if ( enc == wxFONTENCODING_SYSTEM )
1675         return -1;
1676
1677     // the use the helper function
1678     return wxEncodingToCodepage(enc);
1679 }
1680
1681 #else // !wxUSE_FONTMAP
1682
1683 #include "wx/msw/registry.h"
1684
1685 // this should work if Internet Exploiter is installed
1686 extern long wxCharsetToCodepage(const char *name)
1687 {
1688     if (!name)
1689         return GetACP();
1690
1691     long CP = -1;
1692
1693 #if wxUSE_REGKEY
1694     wxString path(wxT("MIME\\Database\\Charset\\"));
1695     wxString cn(name);
1696
1697     // follow the alias loop
1698     for ( ;; )
1699     {
1700         wxRegKey key(wxRegKey::HKCR, path + cn);
1701
1702         if (!key.Exists())
1703             break;
1704
1705         // two cases: either there's an AliasForCharset string,
1706         // or there are Codepage and InternetEncoding dwords.
1707         // The InternetEncoding gives us the actual encoding,
1708         // the Codepage just says which Windows character set to
1709         // use when displaying the data.
1710         if (key.HasValue(wxT("InternetEncoding")) &&
1711             key.QueryValue(wxT("InternetEncoding"), &CP))
1712             break;
1713
1714         // no encoding, see if it's an alias
1715         if (!key.HasValue(wxT("AliasForCharset")) ||
1716             !key.QueryValue(wxT("AliasForCharset"), cn))
1717             break;
1718     }
1719 #endif // wxUSE_REGKEY
1720
1721     return CP;
1722 }
1723
1724 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1725
1726 extern "C" WXDLLIMPEXP_BASE HWND
1727 wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
1728 {
1729     wxCHECK_MSG( classname && pclassname && wndproc, NULL,
1730                     wxT("NULL parameter in wxCreateHiddenWindow") );
1731
1732     // register the class fi we need to first
1733     if ( *pclassname == NULL )
1734     {
1735         WNDCLASS wndclass;
1736         wxZeroMemory(wndclass);
1737
1738         wndclass.lpfnWndProc   = wndproc;
1739         wndclass.hInstance     = wxGetInstance();
1740         wndclass.lpszClassName = classname;
1741
1742         if ( !::RegisterClass(&wndclass) )
1743         {
1744             wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1745
1746             return NULL;
1747         }
1748
1749         *pclassname = classname;
1750     }
1751
1752     // next create the window
1753     HWND hwnd = ::CreateWindow
1754                   (
1755                     *pclassname,
1756                     NULL,
1757                     0, 0, 0, 0,
1758                     0,
1759                     (HWND) NULL,
1760                     (HMENU)NULL,
1761                     wxGetInstance(),
1762                     (LPVOID) NULL
1763                   );
1764
1765     if ( !hwnd )
1766     {
1767         wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
1768     }
1769
1770     return hwnd;
1771 }