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.t_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 bool wxIsDebuggerRunning()
1080 {
1081 #if wxUSE_DYNLIB_CLASS
1082     // IsDebuggerPresent() is not available under Win95, so load it dynamically
1083     wxDynamicLibrary dll(wxT("kernel32.dll"), wxDL_VERBATIM);
1084
1085     typedef BOOL (WINAPI *IsDebuggerPresent_t)();
1086     if ( !dll.HasSymbol(wxT("IsDebuggerPresent")) )
1087     {
1088         // no way to know, assume no
1089         return false;
1090     }
1091
1092     return (*(IsDebuggerPresent_t)dll.GetSymbol(wxT("IsDebuggerPresent")))() != 0;
1093 #else
1094     return false;
1095 #endif
1096 }
1097
1098 // ----------------------------------------------------------------------------
1099 // working with MSW resources
1100 // ----------------------------------------------------------------------------
1101
1102 bool
1103 wxLoadUserResource(const void **outData,
1104                    size_t *outLen,
1105                    const wxString& resourceName,
1106                    const wxString& resourceType,
1107                    WXHINSTANCE instance)
1108 {
1109     wxCHECK_MSG( outData && outLen, false, "output pointers can't be NULL" );
1110
1111     HRSRC hResource = ::FindResource(instance,
1112                                      resourceName.t_str(),
1113                                      resourceType.t_str());
1114     if ( !hResource )
1115         return false;
1116
1117     HGLOBAL hData = ::LoadResource(instance, hResource);
1118     if ( !hData )
1119     {
1120         wxLogSysError(_("Failed to load resource \"%s\"."), resourceName);
1121         return false;
1122     }
1123
1124     *outData = ::LockResource(hData);
1125     if ( !*outData )
1126     {
1127         wxLogSysError(_("Failed to lock resource \"%s\"."), resourceName);
1128         return false;
1129     }
1130
1131     *outLen = ::SizeofResource(instance, hResource);
1132
1133     // Notice that we do not need to call neither UnlockResource() (which is
1134     // obsolete in Win32) nor GlobalFree() (resources are freed on process
1135     // termination only)
1136
1137     return true;
1138 }
1139
1140 char *
1141 wxLoadUserResource(const wxString& resourceName,
1142                    const wxString& resourceType,
1143                    int* pLen,
1144                    WXHINSTANCE instance)
1145 {
1146     const void *data;
1147     size_t len;
1148     if ( !wxLoadUserResource(&data, &len, resourceName, resourceType, instance) )
1149         return NULL;
1150
1151     char *s = new char[len + 1];
1152     memcpy(s, data, len);
1153     s[len] = '\0'; // NUL-terminate in case the resource itself wasn't
1154
1155     if (pLen)
1156       *pLen = len;
1157
1158     return s;
1159 }
1160
1161 // ----------------------------------------------------------------------------
1162 // OS version
1163 // ----------------------------------------------------------------------------
1164
1165 // check if we're running under a server or workstation Windows system: it
1166 // returns true or false with obvious meaning as well as -1 if the system type
1167 // couldn't be determined
1168 //
1169 // this function is currently private but we may want to expose it later if
1170 // it's really useful
1171 namespace
1172 {
1173
1174 int wxIsWindowsServer()
1175 {
1176 #ifdef VER_NT_WORKSTATION
1177     OSVERSIONINFOEX info;
1178     wxZeroMemory(info);
1179
1180     info.dwOSVersionInfoSize = sizeof(info);
1181     if ( ::GetVersionEx(reinterpret_cast<OSVERSIONINFO *>(&info)) )
1182     {
1183         switch ( info.wProductType )
1184         {
1185             case VER_NT_WORKSTATION:
1186                 return false;
1187
1188             case VER_NT_SERVER:
1189             case VER_NT_DOMAIN_CONTROLLER:
1190                 return true;
1191         }
1192     }
1193 #endif // VER_NT_WORKSTATION
1194
1195     return -1;
1196 }
1197
1198 } // anonymous namespace
1199
1200 wxString wxGetOsDescription()
1201 {
1202     wxString str;
1203
1204     OSVERSIONINFO info;
1205     wxZeroMemory(info);
1206
1207     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1208     if ( ::GetVersionEx(&info) )
1209     {
1210         switch ( info.dwPlatformId )
1211         {
1212 #ifdef VER_PLATFORM_WIN32_CE
1213             case VER_PLATFORM_WIN32_CE:
1214                 str.Printf(_("Windows CE (%d.%d)"),
1215                            info.dwMajorVersion,
1216                            info.dwMinorVersion);
1217                 break;
1218 #endif
1219             case VER_PLATFORM_WIN32s:
1220                 str = _("Win32s on Windows 3.1");
1221                 break;
1222
1223             case VER_PLATFORM_WIN32_WINDOWS:
1224                 switch (info.dwMinorVersion)
1225                 {
1226                     case 0:
1227                         if ( info.szCSDVersion[1] == 'B' ||
1228                              info.szCSDVersion[1] == 'C' )
1229                         {
1230                             str = _("Windows 95 OSR2");
1231                         }
1232                         else
1233                         {
1234                             str = _("Windows 95");
1235                         }
1236                         break;
1237                     case 10:
1238                         if ( info.szCSDVersion[1] == 'B' ||
1239                              info.szCSDVersion[1] == 'C' )
1240                         {
1241                             str = _("Windows 98 SE");
1242                         }
1243                         else
1244                         {
1245                             str = _("Windows 98");
1246                         }
1247                         break;
1248                     case 90:
1249                         str = _("Windows ME");
1250                         break;
1251                     default:
1252                         str.Printf(_("Windows 9x (%d.%d)"),
1253                                    info.dwMajorVersion,
1254                                    info.dwMinorVersion);
1255                         break;
1256                 }
1257                 if ( !wxIsEmpty(info.szCSDVersion) )
1258                 {
1259                     str << wxT(" (") << info.szCSDVersion << wxT(')');
1260                 }
1261                 break;
1262
1263             case VER_PLATFORM_WIN32_NT:
1264                 switch ( info.dwMajorVersion )
1265                 {
1266                     case 5:
1267                         switch ( info.dwMinorVersion )
1268                         {
1269                             case 0:
1270                                 str = _("Windows 2000");
1271                                 break;
1272
1273                             case 2:
1274                                 // we can't distinguish between XP 64 and 2003
1275                                 // as they both are 5.2, so examine the product
1276                                 // type to resolve this ambiguity
1277                                 if ( wxIsWindowsServer() == 1 )
1278                                 {
1279                                     str = _("Windows Server 2003");
1280                                     break;
1281                                 }
1282                                 //else: must be XP, fall through
1283
1284                             case 1:
1285                                 str = _("Windows XP");
1286                                 break;
1287                         }
1288                         break;
1289
1290                     case 6:
1291                         switch ( info.dwMinorVersion )
1292                         {
1293                             case 0:
1294                                 str = wxIsWindowsServer() == 1
1295                                         ? _("Windows Server 2008")
1296                                         : _("Windows Vista");
1297                                 break;
1298
1299                             case 1:
1300                                 str = wxIsWindowsServer() == 1
1301                                         ? _("Windows Server 2008 R2")
1302                                         : _("Windows 7");
1303                                 break;
1304                         }
1305                         break;
1306                 }
1307
1308                 if ( str.empty() )
1309                 {
1310                     str.Printf(_("Windows NT %lu.%lu"),
1311                                info.dwMajorVersion,
1312                                info.dwMinorVersion);
1313                 }
1314
1315                 str << wxT(" (")
1316                     << wxString::Format(_("build %lu"), info.dwBuildNumber);
1317                 if ( !wxIsEmpty(info.szCSDVersion) )
1318                 {
1319                     str << wxT(", ") << info.szCSDVersion;
1320                 }
1321                 str << wxT(')');
1322
1323                 if ( wxIsPlatform64Bit() )
1324                     str << _(", 64-bit edition");
1325                 break;
1326         }
1327     }
1328     else
1329     {
1330         wxFAIL_MSG( wxT("GetVersionEx() failed") ); // should never happen
1331     }
1332
1333     return str;
1334 }
1335
1336 bool wxIsPlatform64Bit()
1337 {
1338 #if defined(_WIN64)
1339     return true;  // 64-bit programs run only on Win64
1340 #elif wxUSE_DYNLIB_CLASS // Win32
1341     // 32-bit programs run on both 32-bit and 64-bit Windows so check
1342     typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *);
1343
1344     wxDynamicLibrary dllKernel32(wxT("kernel32.dll"));
1345     IsWow64Process_t pfnIsWow64Process =
1346         (IsWow64Process_t)dllKernel32.RawGetSymbol(wxT("IsWow64Process"));
1347
1348     BOOL wow64 = FALSE;
1349     if ( pfnIsWow64Process )
1350     {
1351         pfnIsWow64Process(::GetCurrentProcess(), &wow64);
1352     }
1353     //else: running under a system without Win64 support
1354
1355     return wow64 != FALSE;
1356 #else
1357     return false;
1358 #endif // Win64/Win32
1359 }
1360
1361 wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
1362 {
1363     static struct
1364     {
1365         // this may be false, true or -1 if we tried to initialize but failed
1366         int initialized;
1367
1368         wxOperatingSystemId os;
1369
1370         int verMaj,
1371             verMin;
1372     } s_version;
1373
1374     // query the OS info only once as it's not supposed to change
1375     if ( !s_version.initialized )
1376     {
1377         OSVERSIONINFO info;
1378         wxZeroMemory(info);
1379         info.dwOSVersionInfoSize = sizeof(info);
1380         if ( ::GetVersionEx(&info) )
1381         {
1382             s_version.initialized = true;
1383
1384 #if defined(__WXWINCE__)
1385             s_version.os = wxOS_WINDOWS_CE;
1386 #elif defined(__WXMICROWIN__)
1387             s_version.os = wxOS_WINDOWS_MICRO;
1388 #else // "normal" desktop Windows system, use run-time detection
1389             switch ( info.dwPlatformId )
1390             {
1391                 case VER_PLATFORM_WIN32_NT:
1392                     s_version.os = wxOS_WINDOWS_NT;
1393                     break;
1394
1395                 case VER_PLATFORM_WIN32_WINDOWS:
1396                     s_version.os = wxOS_WINDOWS_9X;
1397                     break;
1398             }
1399 #endif // Windows versions
1400
1401             s_version.verMaj = info.dwMajorVersion;
1402             s_version.verMin = info.dwMinorVersion;
1403         }
1404         else // GetVersionEx() failed
1405         {
1406             s_version.initialized = -1;
1407         }
1408     }
1409
1410     if ( s_version.initialized == 1 )
1411     {
1412         if ( verMaj )
1413             *verMaj = s_version.verMaj;
1414         if ( verMin )
1415             *verMin = s_version.verMin;
1416     }
1417
1418     // this works even if we were not initialized successfully as the initial
1419     // values of this field is 0 which is wxOS_UNKNOWN and exactly what we need
1420     return s_version.os;
1421 }
1422
1423 wxWinVersion wxGetWinVersion()
1424 {
1425     int verMaj,
1426         verMin;
1427     switch ( wxGetOsVersion(&verMaj, &verMin) )
1428     {
1429         case wxOS_WINDOWS_9X:
1430             if ( verMaj == 4 )
1431             {
1432                 switch ( verMin )
1433                 {
1434                     case 0:
1435                         return wxWinVersion_95;
1436
1437                     case 10:
1438                         return wxWinVersion_98;
1439
1440                     case 90:
1441                         return wxWinVersion_ME;
1442                 }
1443             }
1444             break;
1445
1446         case wxOS_WINDOWS_NT:
1447             switch ( verMaj )
1448             {
1449                 case 3:
1450                     return wxWinVersion_NT3;
1451
1452                 case 4:
1453                     return wxWinVersion_NT4;
1454
1455                 case 5:
1456                     switch ( verMin )
1457                     {
1458                         case 0:
1459                             return wxWinVersion_2000;
1460
1461                         case 1:
1462                             return wxWinVersion_XP;
1463
1464                         case 2:
1465                             return wxWinVersion_2003;
1466                     }
1467                     break;
1468
1469                 case 6:
1470                     return wxWinVersion_NT6;
1471             }
1472             break;
1473
1474         default:
1475             // Do nothing just to silence GCC warning
1476             break;
1477     }
1478
1479     return wxWinVersion_Unknown;
1480 }
1481
1482 // ----------------------------------------------------------------------------
1483 // sleep functions
1484 // ----------------------------------------------------------------------------
1485
1486 void wxMilliSleep(unsigned long milliseconds)
1487 {
1488     ::Sleep(milliseconds);
1489 }
1490
1491 void wxMicroSleep(unsigned long microseconds)
1492 {
1493     wxMilliSleep(microseconds/1000);
1494 }
1495
1496 void wxSleep(int nSecs)
1497 {
1498     wxMilliSleep(1000*nSecs);
1499 }
1500
1501 // ----------------------------------------------------------------------------
1502 // font encoding <-> Win32 codepage conversion functions
1503 // ----------------------------------------------------------------------------
1504
1505 extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
1506 {
1507     switch ( encoding )
1508     {
1509         // although this function is supposed to return an exact match, do do
1510         // some mappings here for the most common case of "standard" encoding
1511         case wxFONTENCODING_SYSTEM:
1512             return DEFAULT_CHARSET;
1513
1514         case wxFONTENCODING_ISO8859_1:
1515         case wxFONTENCODING_ISO8859_15:
1516         case wxFONTENCODING_CP1252:
1517             return ANSI_CHARSET;
1518
1519 #if !defined(__WXMICROWIN__)
1520         // The following four fonts are multi-byte charsets
1521         case wxFONTENCODING_CP932:
1522             return SHIFTJIS_CHARSET;
1523
1524         case wxFONTENCODING_CP936:
1525             return GB2312_CHARSET;
1526
1527 #ifndef __WXWINCE__
1528         case wxFONTENCODING_CP949:
1529             return HANGUL_CHARSET;
1530 #endif
1531
1532         case wxFONTENCODING_CP950:
1533             return CHINESEBIG5_CHARSET;
1534
1535         // The rest are single byte encodings
1536         case wxFONTENCODING_CP1250:
1537             return EASTEUROPE_CHARSET;
1538
1539         case wxFONTENCODING_CP1251:
1540             return RUSSIAN_CHARSET;
1541
1542         case wxFONTENCODING_CP1253:
1543             return GREEK_CHARSET;
1544
1545         case wxFONTENCODING_CP1254:
1546             return TURKISH_CHARSET;
1547
1548         case wxFONTENCODING_CP1255:
1549             return HEBREW_CHARSET;
1550
1551         case wxFONTENCODING_CP1256:
1552             return ARABIC_CHARSET;
1553
1554         case wxFONTENCODING_CP1257:
1555             return BALTIC_CHARSET;
1556
1557         case wxFONTENCODING_CP874:
1558             return THAI_CHARSET;
1559 #endif // !__WXMICROWIN__
1560
1561         case wxFONTENCODING_CP437:
1562             return OEM_CHARSET;
1563
1564         default:
1565             // no way to translate this encoding into a Windows charset
1566             return -1;
1567     }
1568 }
1569
1570 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1571 // looks up the vlaues in the registry and the new one which is more
1572 // politically correct and has more chances to work on other Windows versions
1573 // as well but the old version is still needed for !wxUSE_FONTMAP case
1574 #if wxUSE_FONTMAP
1575
1576 #include "wx/fontmap.h"
1577
1578 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
1579 {
1580     // There don't seem to be symbolic names for
1581     // these under Windows so I just copied the
1582     // values from MSDN.
1583
1584     unsigned int ret;
1585
1586     switch (encoding)
1587     {
1588         case wxFONTENCODING_ISO8859_1:      ret = 28591; break;
1589         case wxFONTENCODING_ISO8859_2:      ret = 28592; break;
1590         case wxFONTENCODING_ISO8859_3:      ret = 28593; break;
1591         case wxFONTENCODING_ISO8859_4:      ret = 28594; break;
1592         case wxFONTENCODING_ISO8859_5:      ret = 28595; break;
1593         case wxFONTENCODING_ISO8859_6:      ret = 28596; break;
1594         case wxFONTENCODING_ISO8859_7:      ret = 28597; break;
1595         case wxFONTENCODING_ISO8859_8:      ret = 28598; break;
1596         case wxFONTENCODING_ISO8859_9:      ret = 28599; break;
1597         case wxFONTENCODING_ISO8859_10:     ret = 28600; break;
1598         case wxFONTENCODING_ISO8859_11:     ret = 874; break;
1599         // case wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
1600         case wxFONTENCODING_ISO8859_13:     ret = 28603; break;
1601         // case wxFONTENCODING_ISO8859_14:     ret = 28604; break; // no correspondence on Windows
1602         case wxFONTENCODING_ISO8859_15:     ret = 28605; break;
1603
1604         case wxFONTENCODING_KOI8:           ret = 20866; break;
1605         case wxFONTENCODING_KOI8_U:         ret = 21866; break;
1606
1607         case wxFONTENCODING_CP437:          ret = 437; break;
1608         case wxFONTENCODING_CP850:          ret = 850; break;
1609         case wxFONTENCODING_CP852:          ret = 852; break;
1610         case wxFONTENCODING_CP855:          ret = 855; break;
1611         case wxFONTENCODING_CP866:          ret = 866; break;
1612         case wxFONTENCODING_CP874:          ret = 874; break;
1613         case wxFONTENCODING_CP932:          ret = 932; break;
1614         case wxFONTENCODING_CP936:          ret = 936; break;
1615         case wxFONTENCODING_CP949:          ret = 949; break;
1616         case wxFONTENCODING_CP950:          ret = 950; break;
1617         case wxFONTENCODING_CP1250:         ret = 1250; break;
1618         case wxFONTENCODING_CP1251:         ret = 1251; break;
1619         case wxFONTENCODING_CP1252:         ret = 1252; break;
1620         case wxFONTENCODING_CP1253:         ret = 1253; break;
1621         case wxFONTENCODING_CP1254:         ret = 1254; break;
1622         case wxFONTENCODING_CP1255:         ret = 1255; break;
1623         case wxFONTENCODING_CP1256:         ret = 1256; break;
1624         case wxFONTENCODING_CP1257:         ret = 1257; break;
1625
1626         case wxFONTENCODING_EUC_JP:         ret = 20932; break;
1627
1628         case wxFONTENCODING_MACROMAN:       ret = 10000; break;
1629         case wxFONTENCODING_MACJAPANESE:    ret = 10001; break;
1630         case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break;
1631         case wxFONTENCODING_MACKOREAN:      ret = 10003; break;
1632         case wxFONTENCODING_MACARABIC:      ret = 10004; break;
1633         case wxFONTENCODING_MACHEBREW:      ret = 10005; break;
1634         case wxFONTENCODING_MACGREEK:       ret = 10006; break;
1635         case wxFONTENCODING_MACCYRILLIC:    ret = 10007; break;
1636         case wxFONTENCODING_MACTHAI:        ret = 10021; break;
1637         case wxFONTENCODING_MACCHINESESIMP: ret = 10008; break;
1638         case wxFONTENCODING_MACCENTRALEUR:  ret = 10029; break;
1639         case wxFONTENCODING_MACCROATIAN:    ret = 10082; break;
1640         case wxFONTENCODING_MACICELANDIC:   ret = 10079; break;
1641         case wxFONTENCODING_MACROMANIAN:    ret = 10009; break;
1642
1643         case wxFONTENCODING_ISO2022_JP:     ret = 50222; break;
1644
1645         case wxFONTENCODING_UTF7:           ret = 65000; break;
1646         case wxFONTENCODING_UTF8:           ret = 65001; break;
1647
1648         default:                            return -1;
1649     }
1650
1651     if (::IsValidCodePage(ret) == 0)
1652         return -1;
1653
1654     CPINFO info;
1655     if (::GetCPInfo(ret, &info) == 0)
1656         return -1;
1657
1658     return (long) ret;
1659 }
1660
1661 extern long wxCharsetToCodepage(const char *name)
1662 {
1663     // first get the font encoding for this charset
1664     if ( !name )
1665         return -1;
1666
1667     wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);
1668     if ( enc == wxFONTENCODING_SYSTEM )
1669         return -1;
1670
1671     // the use the helper function
1672     return wxEncodingToCodepage(enc);
1673 }
1674
1675 #else // !wxUSE_FONTMAP
1676
1677 #include "wx/msw/registry.h"
1678
1679 // this should work if Internet Exploiter is installed
1680 extern long wxCharsetToCodepage(const char *name)
1681 {
1682     if (!name)
1683         return GetACP();
1684
1685     long CP = -1;
1686
1687 #if wxUSE_REGKEY
1688     wxString path(wxT("MIME\\Database\\Charset\\"));
1689     wxString cn(name);
1690
1691     // follow the alias loop
1692     for ( ;; )
1693     {
1694         wxRegKey key(wxRegKey::HKCR, path + cn);
1695
1696         if (!key.Exists())
1697             break;
1698
1699         // two cases: either there's an AliasForCharset string,
1700         // or there are Codepage and InternetEncoding dwords.
1701         // The InternetEncoding gives us the actual encoding,
1702         // the Codepage just says which Windows character set to
1703         // use when displaying the data.
1704         if (key.HasValue(wxT("InternetEncoding")) &&
1705             key.QueryValue(wxT("InternetEncoding"), &CP))
1706             break;
1707
1708         // no encoding, see if it's an alias
1709         if (!key.HasValue(wxT("AliasForCharset")) ||
1710             !key.QueryValue(wxT("AliasForCharset"), cn))
1711             break;
1712     }
1713 #endif // wxUSE_REGKEY
1714
1715     return CP;
1716 }
1717
1718 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1719
1720 extern "C" WXDLLIMPEXP_BASE HWND
1721 wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
1722 {
1723     wxCHECK_MSG( classname && pclassname && wndproc, NULL,
1724                     wxT("NULL parameter in wxCreateHiddenWindow") );
1725
1726     // register the class fi we need to first
1727     if ( *pclassname == NULL )
1728     {
1729         WNDCLASS wndclass;
1730         wxZeroMemory(wndclass);
1731
1732         wndclass.lpfnWndProc   = wndproc;
1733         wndclass.hInstance     = wxGetInstance();
1734         wndclass.lpszClassName = classname;
1735
1736         if ( !::RegisterClass(&wndclass) )
1737         {
1738             wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1739
1740             return NULL;
1741         }
1742
1743         *pclassname = classname;
1744     }
1745
1746     // next create the window
1747     HWND hwnd = ::CreateWindow
1748                   (
1749                     *pclassname,
1750                     NULL,
1751                     0, 0, 0, 0,
1752                     0,
1753                     (HWND) NULL,
1754                     (HMENU)NULL,
1755                     wxGetInstance(),
1756                     (LPVOID) NULL
1757                   );
1758
1759     if ( !hwnd )
1760     {
1761         wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
1762     }
1763
1764     return hwnd;
1765 }