src/msw/utils.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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/apptrait.h"
  35 #include "wx/dynload.h"
  36
  37 #include "wx/confbase.h"        // for wxExpandEnvVars()
  38
  39 #include "wx/msw/private.h"     // includes <windows.h>
  40 #include "wx/msw/missing.h"     // CHARSET_HANGUL
  41
  42 #if defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) \
  43     || defined(__CYGWIN32__)
  44     // apparently we need to include winsock.h to get WSADATA and other stuff
  45     // used in wxGetFullHostName() with the old mingw32 versions
  46     #include <winsock.h>
  47 #endif
  48
  49 #include "wx/timer.h"
  50
  51 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
  52     #include <direct.h>
  53
  54     #ifndef __MWERKS__
  55         #include <dos.h>
  56     #endif
  57 #endif  //GNUWIN32
  58
  59 #if defined(__CYGWIN__)
  60     #include <sys/unistd.h>
  61     #include <sys/stat.h>
  62     #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
  63 #endif  //GNUWIN32
  64
  65 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
  66                     // this (3.1 I believe) and how to test for it.
  67                     // If this works for Borland 4.0 as well, then no worries.
  68     #include <dir.h>
  69 #endif
  70
  71 // VZ: there is some code using NetXXX() functions to get the full user name:
  72 //     I don't think it's a good idea because they don't work under Win95 and
  73 //     seem to return the same as wxGetUserId() under NT. If you really want
  74 //     to use them, just #define USE_NET_API
  75 #undef USE_NET_API
  76
  77 #ifdef USE_NET_API
  78     #include <lm.h>
  79 #endif // USE_NET_API
  80
  81 #if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
  82     #ifndef __UNIX__
  83         #include <io.h>
  84     #endif
  85
  86     #ifndef __GNUWIN32__
  87         #include <shellapi.h>
  88     #endif
  89 #endif
  90
  91 #ifndef __WATCOMC__
  92     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
  93         #include <errno.h>
  94     #endif
  95 #endif
  96
  97 // For wxKillAllChildren
  98 #include <tlhelp32.h>
  99
 100 // ----------------------------------------------------------------------------
 101 // constants
 102 // ----------------------------------------------------------------------------
 103
 104 // In the WIN.INI file
 105 static const wxChar WX_SECTION[] = wxT("wxWindows");
 106 static const wxChar eUSERNAME[]  = wxT("UserName");
 107
 108 // ============================================================================
 109 // implementation
 110 // ============================================================================
 111
 112 // ----------------------------------------------------------------------------
 113 // get host name and related
 114 // ----------------------------------------------------------------------------
 115
 116 // Get hostname only (without domain name)
 117 bool wxGetHostName(wxChar *buf, int maxSize)
 118 {
 119 #if defined(__WXWINCE__)
 120     return false;
 121 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
 122     DWORD nSize = maxSize;
 123     if ( !::GetComputerName(buf, &nSize) )
 124     {
 125         wxLogLastError(wxT("GetComputerName"));
 126
 127         return false;
 128     }
 129
 130     return true;
 131 #else
 132     wxChar *sysname;
 133     const wxChar *default_host = wxT("noname");
 134
 135     if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
 136         GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
 137     } else
 138         wxStrncpy(buf, sysname, maxSize - 1);
 139     buf[maxSize] = wxT('\0');
 140     return *buf ? true : false;
 141 #endif
 142 }
 143
 144 // get full hostname (with domain name if possible)
 145 bool wxGetFullHostName(wxChar *buf, int maxSize)
 146 {
 147 #if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER
 148     // TODO should use GetComputerNameEx() when available
 149
 150     // we don't want to always link with Winsock DLL as we might not use it at
 151     // all, so load it dynamically here if needed (and don't complain if it is
 152     // missing, we handle this)
 153     wxLogNull noLog;
 154
 155     wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
 156     if ( dllWinsock.IsLoaded() )
 157     {
 158         typedef int (PASCAL *WSAStartup_t)(WORD, WSADATA *);
 159         typedef int (PASCAL *gethostname_t)(char *, int);
 160         typedef hostent* (PASCAL *gethostbyname_t)(const char *);
 161         typedef hostent* (PASCAL *gethostbyaddr_t)(const char *, int , int);
 162         typedef int (PASCAL *WSACleanup_t)(void);
 163
 164         #define LOAD_WINSOCK_FUNC(func)                                       \
 165             func ## _t                                                        \
 166                 pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))
 167
 168         LOAD_WINSOCK_FUNC(WSAStartup);
 169
 170         WSADATA wsa;
 171         if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
 172         {
 173             LOAD_WINSOCK_FUNC(gethostname);
 174
 175             wxString host;
 176             if ( pfngethostname )
 177             {
 178                 char bufA[256];
 179                 if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
 180                 {
 181                     // gethostname() won't usually include the DNS domain name,
 182                     // for this we need to work a bit more
 183                     if ( !strchr(bufA, '.') )
 184                     {
 185                         LOAD_WINSOCK_FUNC(gethostbyname);
 186
 187                         struct hostent *pHostEnt = pfngethostbyname
 188                                                     ? pfngethostbyname(bufA)
 189                                                     : NULL;
 190
 191                         if ( pHostEnt )
 192                         {
 193                             // Windows will use DNS internally now
 194                             LOAD_WINSOCK_FUNC(gethostbyaddr);
 195
 196                             pHostEnt = pfngethostbyaddr
 197                                         ? pfngethostbyaddr(pHostEnt->h_addr,
 198                                                            4, AF_INET)
 199                                         : NULL;
 200                         }
 201
 202                         if ( pHostEnt )
 203                         {
 204                             host = wxString::FromAscii(pHostEnt->h_name);
 205                         }
 206                     }
 207                 }
 208             }
 209
 210             LOAD_WINSOCK_FUNC(WSACleanup);
 211             if ( pfnWSACleanup )
 212                 pfnWSACleanup();
 213
 214
 215             if ( !host.empty() )
 216             {
 217                 wxStrncpy(buf, host, maxSize);
 218
 219                 return true;
 220             }
 221         }
 222     }
 223 #endif // !__WXMICROWIN__
 224
 225     return wxGetHostName(buf, maxSize);
 226 }
 227
 228 // Get user ID e.g. jacs
 229 bool wxGetUserId(wxChar *buf, int maxSize)
 230 {
 231 #if defined(__WXWINCE__)
 232     return false;
 233 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
 234     DWORD nSize = maxSize;
 235     if ( ::GetUserName(buf, &nSize) == 0 )
 236     {
 237         // actually, it does happen on Win9x if the user didn't log on
 238         DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize);
 239         if ( res == 0 )
 240         {
 241             // not found
 242             return false;
 243         }
 244     }
 245
 246     return true;
 247 #else   // __WXMICROWIN__
 248     wxChar *user;
 249     const wxChar *default_id = wxT("anonymous");
 250
 251     // Can't assume we have NIS (PC-NFS) or some other ID daemon
 252     // So we ...
 253     if (  (user = wxGetenv(wxT("USER"))) == NULL &&
 254             (user = wxGetenv(wxT("LOGNAME"))) == NULL )
 255     {
 256         // Use wxWidgets configuration data (comming soon)
 257         GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
 258     }
 259     else
 260     {
 261         wxStrncpy(buf, user, maxSize - 1);
 262     }
 263
 264     return *buf ? true : false;
 265 #endif
 266 }
 267
 268 // Get user name e.g. Julian Smart
 269 bool wxGetUserName(wxChar *buf, int maxSize)
 270 {
 271 #if defined(__WXWINCE__)
 272     return false;
 273 #elif defined(USE_NET_API)
 274     CHAR szUserName[256];
 275     if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
 276         return false;
 277
 278     // TODO how to get the domain name?
 279     CHAR *szDomain = "";
 280
 281     // the code is based on the MSDN example (also see KB article Q119670)
 282     WCHAR wszUserName[256];          // Unicode user name
 283     WCHAR wszDomain[256];
 284     LPBYTE ComputerName;
 285
 286     USER_INFO_2 *ui2;         // User structure
 287
 288     // Convert ANSI user name and domain to Unicode
 289     MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
 290             wszUserName, WXSIZEOF(wszUserName) );
 291     MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
 292             wszDomain, WXSIZEOF(wszDomain) );
 293
 294     // Get the computer name of a DC for the domain.
 295     if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
 296     {
 297         wxLogError(wxT("Can not find domain controller"));
 298
 299         goto error;
 300     }
 301
 302     // Look up the user on the DC
 303     NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName,
 304             (LPWSTR)&wszUserName,
 305             2, // level - we want USER_INFO_2
 306             (LPBYTE *) &ui2 );
 307     switch ( status )
 308     {
 309         case NERR_Success:
 310             // ok
 311             break;
 312
 313         case NERR_InvalidComputer:
 314             wxLogError(wxT("Invalid domain controller name."));
 315
 316             goto error;
 317
 318         case NERR_UserNotFound:
 319             wxLogError(wxT("Invalid user name '%s'."), szUserName);
 320
 321             goto error;
 322
 323         default:
 324             wxLogSysError(wxT("Can't get information about user"));
 325
 326             goto error;
 327     }
 328
 329     // Convert the Unicode full name to ANSI
 330     WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
 331             buf, maxSize, NULL, NULL );
 332
 333     return true;
 334
 335 error:
 336     wxLogError(wxT("Couldn't look up full user name."));
 337
 338     return false;
 339 #else  // !USE_NET_API
 340     // Could use NIS, MS-Mail or other site specific programs
 341     // Use wxWidgets configuration data
 342     bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
 343     if ( !ok )
 344     {
 345         ok = wxGetUserId(buf, maxSize);
 346     }
 347
 348     if ( !ok )
 349     {
 350         wxStrncpy(buf, wxT("Unknown User"), maxSize);
 351     }
 352 #endif // Win32/16
 353
 354     return true;
 355 }
 356
 357 const wxChar* wxGetHomeDir(wxString *pstr)
 358 {
 359     wxString& strDir = *pstr;
 360
 361     // first branch is for Cygwin
 362 #if defined(__UNIX__)
 363     const wxChar *szHome = wxGetenv("HOME");
 364     if ( szHome == NULL ) {
 365       // we're homeless...
 366       wxLogWarning(_("can't find user's HOME, using current directory."));
 367       strDir = wxT(".");
 368     }
 369     else
 370        strDir = szHome;
 371
 372     // add a trailing slash if needed
 373     if ( strDir.Last() != wxT('/') )
 374       strDir << wxT('/');
 375
 376     #ifdef __CYGWIN__
 377         // Cygwin returns unix type path but that does not work well
 378         static wxChar windowsPath[MAX_PATH];
 379         cygwin_conv_to_full_win32_path(strDir, windowsPath);
 380         strDir = windowsPath;
 381     #endif
 382 #elif defined(__WXWINCE__)
 383       // Nothing
 384 #else
 385     strDir.clear();
 386
 387     // If we have a valid HOME directory, as is used on many machines that
 388     // have unix utilities on them, we should use that.
 389     const wxChar *szHome = wxGetenv(wxT("HOME"));
 390
 391     if ( szHome != NULL )
 392     {
 393         strDir = szHome;
 394     }
 395     else // no HOME, try HOMEDRIVE/PATH
 396     {
 397         szHome = wxGetenv(wxT("HOMEDRIVE"));
 398         if ( szHome != NULL )
 399             strDir << szHome;
 400         szHome = wxGetenv(wxT("HOMEPATH"));
 401
 402         if ( szHome != NULL )
 403         {
 404             strDir << szHome;
 405
 406             // the idea is that under NT these variables have default values
 407             // of "%systemdrive%:" and "\\". As we don't want to create our
 408             // config files in the root directory of the system drive, we will
 409             // create it in our program's dir. However, if the user took care
 410             // to set HOMEPATH to something other than "\\", we suppose that he
 411             // knows what he is doing and use the supplied value.
 412             if ( wxStrcmp(szHome, wxT("\\")) == 0 )
 413                 strDir.clear();
 414         }
 415     }
 416
 417     if ( strDir.empty() )
 418     {
 419         // If we have a valid USERPROFILE directory, as is the case in
 420         // Windows NT, 2000 and XP, we should use that as our home directory.
 421         szHome = wxGetenv(wxT("USERPROFILE"));
 422
 423         if ( szHome != NULL )
 424             strDir = szHome;
 425     }
 426
 427     if ( !strDir.empty() )
 428     {
 429         // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
 430         // value once again, it shouldn't hurt anyhow
 431         strDir = wxExpandEnvVars(strDir);
 432     }
 433     else // fall back to the program directory
 434     {
 435         // extract the directory component of the program file name
 436         wxSplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);
 437     }
 438 #endif  // UNIX/Win
 439
 440     return strDir.c_str();
 441 }
 442
 443 wxChar *wxGetUserHome(const wxString& WXUNUSED(user))
 444 {
 445     // VZ: the old code here never worked for user != "" anyhow! Moreover, it
 446     //     returned sometimes a malloc()'d pointer, sometimes a pointer to a
 447     //     static buffer and sometimes I don't even know what.
 448     static wxString s_home;
 449
 450     return (wxChar *)wxGetHomeDir(&s_home);
 451 }
 452
 453 bool wxDirExists(const wxString& dir)
 454 {
 455 #ifdef __WXMICROWIN__
 456     return wxPathExist(dir);
 457 #elif defined(__WIN32__)
 458     DWORD attribs = GetFileAttributes(dir);
 459     return ((attribs != (DWORD)-1) && (attribs & FILE_ATTRIBUTE_DIRECTORY));
 460 #endif // Win32/__WXMICROWIN__
 461 }
 462
 463 bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 464 {
 465 #ifdef __WXWINCE__
 466     return false;
 467 #else
 468     if ( path.empty() )
 469         return false;
 470
 471 // old w32api don't have ULARGE_INTEGER
 472 #if defined(__WIN32__) && \
 473     (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
 474     // GetDiskFreeSpaceEx() is not available under original Win95, check for
 475     // it
 476     typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
 477                                                 PULARGE_INTEGER,
 478                                                 PULARGE_INTEGER,
 479                                                 PULARGE_INTEGER);
 480
 481     GetDiskFreeSpaceEx_t
 482         pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
 483                               (
 484                                 ::GetModuleHandle(_T("kernel32.dll")),
 485 #if wxUSE_UNICODE
 486                                 "GetDiskFreeSpaceExW"
 487 #else
 488                                 "GetDiskFreeSpaceExA"
 489 #endif
 490                               );
 491
 492     if ( pGetDiskFreeSpaceEx )
 493     {
 494         ULARGE_INTEGER bytesFree, bytesTotal;
 495
 496         // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
 497         if ( !pGetDiskFreeSpaceEx(path,
 498                                   &bytesFree,
 499                                   &bytesTotal,
 500                                   NULL) )
 501         {
 502             wxLogLastError(_T("GetDiskFreeSpaceEx"));
 503
 504             return false;
 505         }
 506
 507         // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
 508         // two 32 bit fields which may be or may be not named - try to make it
 509         // compile in all cases
 510 #if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
 511         #define UL(ul) ul.u
 512 #else // anon union
 513         #define UL(ul) ul
 514 #endif
 515         if ( pTotal )
 516         {
 517             *pTotal = wxLongLong(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
 518         }
 519
 520         if ( pFree )
 521         {
 522             *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
 523         }
 524     }
 525     else
 526 #endif // Win32
 527     {
 528         // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
 529         // should be used instead - but if it's not available, fall back on
 530         // GetDiskFreeSpace() nevertheless...
 531
 532         DWORD lSectorsPerCluster,
 533               lBytesPerSector,
 534               lNumberOfFreeClusters,
 535               lTotalNumberOfClusters;
 536
 537         // FIXME: this is wrong, we should extract the root drive from path
 538         //        instead, but this is the job for wxFileName...
 539         if ( !::GetDiskFreeSpace(path,
 540                                  &lSectorsPerCluster,
 541                                  &lBytesPerSector,
 542                                  &lNumberOfFreeClusters,
 543                                  &lTotalNumberOfClusters) )
 544         {
 545             wxLogLastError(_T("GetDiskFreeSpace"));
 546
 547             return false;
 548         }
 549
 550         wxLongLong lBytesPerCluster = lSectorsPerCluster;
 551         lBytesPerCluster *= lBytesPerSector;
 552
 553         if ( pTotal )
 554         {
 555             *pTotal = lBytesPerCluster;
 556             *pTotal *= lTotalNumberOfClusters;
 557         }
 558
 559         if ( pFree )
 560         {
 561             *pFree = lBytesPerCluster;
 562             *pFree *= lNumberOfFreeClusters;
 563         }
 564     }
 565
 566     return true;
 567 #endif
 568     // __WXWINCE__
 569 }
 570
 571 // ----------------------------------------------------------------------------
 572 // env vars
 573 // ----------------------------------------------------------------------------
 574
 575 bool wxGetEnv(const wxString& var, wxString *value)
 576 {
 577 #ifdef __WXWINCE__
 578     return false;
 579 #else // Win32
 580     // first get the size of the buffer
 581     DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
 582     if ( !dwRet )
 583     {
 584         // this means that there is no such variable
 585         return false;
 586     }
 587
 588     if ( value )
 589     {
 590         (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
 591                                        dwRet);
 592     }
 593
 594     return true;
 595 #endif // WinCE/32
 596 }
 597
 598 bool wxSetEnv(const wxString& var, const wxChar *value)
 599 {
 600     // some compilers have putenv() or _putenv() or _wputenv() but it's better
 601     // to always use Win32 function directly instead of dealing with them
 602 #if defined(__WIN32__) && !defined(__WXWINCE__)
 603     if ( !::SetEnvironmentVariable(var, value) )
 604     {
 605         wxLogLastError(_T("SetEnvironmentVariable"));
 606
 607         return false;
 608     }
 609
 610     return true;
 611 #else // no way to set env vars
 612     return false;
 613 #endif
 614 }
 615
 616 // ----------------------------------------------------------------------------
 617 // process management
 618 // ----------------------------------------------------------------------------
 619
 620 // structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
 621 struct wxFindByPidParams
 622 {
 623     wxFindByPidParams() { hwnd = 0; pid = 0; }
 624
 625     // the HWND used to return the result
 626     HWND hwnd;
 627
 628     // the PID we're looking from
 629     DWORD pid;
 630
 631     DECLARE_NO_COPY_CLASS(wxFindByPidParams)
 632 };
 633
 634 // wxKill helper: EnumWindows() callback which is used to find the first (top
 635 // level) window belonging to the given process
 636 BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)
 637 {
 638     DWORD pid;
 639     (void)::GetWindowThreadProcessId(hwnd, &pid);
 640
 641     wxFindByPidParams *params = (wxFindByPidParams *)lParam;
 642     if ( pid == params->pid )
 643     {
 644         // remember the window we found
 645         params->hwnd = hwnd;
 646
 647         // return FALSE to stop the enumeration
 648         return FALSE;
 649     }
 650
 651     // continue enumeration
 652     return TRUE;
 653 }
 654
 655 int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc);
 656
 657 int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
 658 {
 659     if (flags & wxKILL_CHILDREN)
 660         wxKillAllChildren(pid, sig, krc);
 661
 662     // get the process handle to operate on
 663     HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
 664                                     PROCESS_TERMINATE |
 665                                     PROCESS_QUERY_INFORMATION,
 666                                     FALSE, // not inheritable
 667                                     (DWORD)pid);
 668     if ( hProcess == NULL )
 669     {
 670         if ( krc )
 671         {
 672             if ( ::GetLastError() == ERROR_ACCESS_DENIED )
 673             {
 674                 *krc = wxKILL_ACCESS_DENIED;
 675             }
 676             else
 677             {
 678                 *krc = wxKILL_NO_PROCESS;
 679             }
 680         }
 681
 682         return -1;
 683     }
 684
 685     bool ok = true;
 686     switch ( sig )
 687     {
 688         case wxSIGKILL:
 689             // kill the process forcefully returning -1 as error code
 690             if ( !::TerminateProcess(hProcess, (UINT)-1) )
 691             {
 692                 wxLogSysError(_("Failed to kill process %d"), pid);
 693
 694                 if ( krc )
 695                 {
 696                     // this is not supposed to happen if we could open the
 697                     // process
 698                     *krc = wxKILL_ERROR;
 699                 }
 700
 701                 ok = false;
 702             }
 703             break;
 704
 705         case wxSIGNONE:
 706             // do nothing, we just want to test for process existence
 707             break;
 708
 709         default:
 710             // any other signal means "terminate"
 711             {
 712                 wxFindByPidParams params;
 713                 params.pid = (DWORD)pid;
 714
 715                 // EnumWindows() has nice semantics: it returns 0 if it found
 716                 // something or if an error occured and non zero if it
 717                 // enumerated all the window
 718                 if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
 719                 {
 720                     // did we find any window?
 721                     if ( params.hwnd )
 722                     {
 723                         // tell the app to close
 724                         //
 725                         // NB: this is the harshest way, the app won't have
 726                         //     opportunity to save any files, for example, but
 727                         //     this is probably what we want here. If not we
 728                         //     can also use SendMesageTimeout(WM_CLOSE)
 729                         if ( !::PostMessage(params.hwnd, WM_QUIT, 0, 0) )
 730                         {
 731                             wxLogLastError(_T("PostMessage(WM_QUIT)"));
 732                         }
 733                     }
 734                     else // it was an error then
 735                     {
 736                         wxLogLastError(_T("EnumWindows"));
 737
 738                         ok = false;
 739                     }
 740                 }
 741                 else // no windows for this PID
 742                 {
 743                     if ( krc )
 744                     {
 745                         *krc = wxKILL_ERROR;
 746                     }
 747
 748                     ok = false;
 749                 }
 750             }
 751     }
 752
 753     // the return code
 754     DWORD rc;
 755
 756     if ( ok )
 757     {
 758         // as we wait for a short time, we can use just WaitForSingleObject()
 759         // and not MsgWaitForMultipleObjects()
 760         switch ( ::WaitForSingleObject(hProcess, 500 /* msec */) )
 761         {
 762             case WAIT_OBJECT_0:
 763                 // process terminated
 764                 if ( !::GetExitCodeProcess(hProcess, &rc) )
 765                 {
 766                     wxLogLastError(_T("GetExitCodeProcess"));
 767                 }
 768                 break;
 769
 770             default:
 771                 wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
 772                 // fall through
 773
 774             case WAIT_FAILED:
 775                 wxLogLastError(_T("WaitForSingleObject"));
 776                 // fall through
 777
 778             case WAIT_TIMEOUT:
 779                 if ( krc )
 780                 {
 781                     *krc = wxKILL_ERROR;
 782                 }
 783
 784                 rc = STILL_ACTIVE;
 785                 break;
 786         }
 787     }
 788     else // !ok
 789     {
 790         // just to suppress the warnings about uninitialized variable
 791         rc = 0;
 792     }
 793
 794     ::CloseHandle(hProcess);
 795
 796     // the return code is the same as from Unix kill(): 0 if killed
 797     // successfully or -1 on error
 798     //
 799     // be careful to interpret rc correctly: for wxSIGNONE we return success if
 800     // the process exists, for all the other sig values -- if it doesn't
 801     if ( ok &&
 802             ((sig == wxSIGNONE) == (rc == STILL_ACTIVE)) )
 803     {
 804         if ( krc )
 805         {
 806             *krc = wxKILL_OK;
 807         }
 808
 809         return 0;
 810     }
 811
 812     // error
 813     return -1;
 814 }
 815
 816 HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
 817 BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
 818 BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
 819
 820 static void InitToolHelp32()
 821 {
 822     static bool s_initToolHelpDone = false;
 823
 824     if (s_initToolHelpDone)
 825         return;
 826
 827     s_initToolHelpDone = true;
 828
 829     lpfCreateToolhelp32Snapshot = NULL;
 830     lpfProcess32First = NULL;
 831     lpfProcess32Next = NULL;
 832
 833     HINSTANCE hInstLib = LoadLibrary( wxT("Kernel32.DLL") ) ;
 834     if( hInstLib == NULL )
 835         return ;
 836
 837     // Get procedure addresses.
 838     // We are linking to these functions of Kernel32
 839     // explicitly, because otherwise a module using
 840     // this code would fail to load under Windows NT,
 841     // which does not have the Toolhelp32
 842     // functions in the Kernel 32.
 843     lpfCreateToolhelp32Snapshot=
 844         (HANDLE(WINAPI *)(DWORD,DWORD))
 845         GetProcAddress( hInstLib,
 846 #ifdef __WXWINCE__
 847         wxT("CreateToolhelp32Snapshot")
 848 #else
 849         "CreateToolhelp32Snapshot"
 850 #endif
 851         ) ;
 852
 853     lpfProcess32First=
 854         (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
 855         GetProcAddress( hInstLib,
 856 #ifdef __WXWINCE__
 857         wxT("Process32First")
 858 #else
 859         "Process32First"
 860 #endif
 861         ) ;
 862
 863     lpfProcess32Next=
 864         (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
 865         GetProcAddress( hInstLib,
 866 #ifdef __WXWINCE__
 867         wxT("Process32Next")
 868 #else
 869         "Process32Next"
 870 #endif
 871         ) ;
 872
 873     FreeLibrary( hInstLib ) ;
 874 }
 875
 876 // By John Skiff
 877 int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc)
 878 {
 879     InitToolHelp32();
 880
 881     if (krc)
 882         *krc = wxKILL_OK;
 883
 884     // If not implemented for this platform (e.g. NT 4.0), silently ignore
 885     if (!lpfCreateToolhelp32Snapshot || !lpfProcess32First || !lpfProcess32Next)
 886         return 0;
 887
 888     // Take a snapshot of all processes in the system.
 889     HANDLE hProcessSnap = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 890     if (hProcessSnap == INVALID_HANDLE_VALUE) {
 891         if (krc)
 892             *krc = wxKILL_ERROR;
 893         return -1;
 894     }
 895
 896     //Fill in the size of the structure before using it.
 897     PROCESSENTRY32 pe = {0};
 898     pe.dwSize = sizeof(PROCESSENTRY32);
 899
 900     // Walk the snapshot of the processes, and for each process,
 901     // kill it if its parent is pid.
 902     if (!lpfProcess32First(hProcessSnap, &pe)) {
 903         // Can't get first process.
 904         if (krc)
 905             *krc = wxKILL_ERROR;
 906         CloseHandle (hProcessSnap);
 907         return -1;
 908     }
 909
 910     do {
 911         if (pe.th32ParentProcessID == (DWORD) pid) {
 912             if (wxKill(pe.th32ProcessID, sig, krc))
 913                 return -1;
 914         }
 915     } while (lpfProcess32Next (hProcessSnap, &pe));
 916
 917
 918     return 0;
 919 }
 920
 921 // Execute a program in an Interactive Shell
 922 bool wxShell(const wxString& command)
 923 {
 924     wxString cmd;
 925
 926 #ifdef __WXWINCE__
 927     cmd = command;
 928 #else
 929     wxChar *shell = wxGetenv(wxT("COMSPEC"));
 930     if ( !shell )
 931         shell = (wxChar*) wxT("\\COMMAND.COM");
 932
 933     if ( !command )
 934     {
 935         // just the shell
 936         cmd = shell;
 937     }
 938     else
 939     {
 940         // pass the command to execute to the command processor
 941         cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
 942     }
 943 #endif
 944
 945     return wxExecute(cmd, wxEXEC_SYNC) == 0;
 946 }
 947
 948 // Shutdown or reboot the PC
 949 bool wxShutdown(wxShutdownFlags wFlags)
 950 {
 951 #ifdef __WXWINCE__
 952     return false;
 953 #elif defined(__WIN32__)
 954     bool bOK = true;
 955
 956     if ( wxGetOsVersion(NULL, NULL) == wxWINDOWS_NT ) // if is NT or 2K
 957     {
 958         // Get a token for this process.
 959         HANDLE hToken;
 960         bOK = ::OpenProcessToken(GetCurrentProcess(),
 961                                  TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
 962                                  &hToken) != 0;
 963         if ( bOK )
 964         {
 965             TOKEN_PRIVILEGES tkp;
 966
 967             // Get the LUID for the shutdown privilege.
 968             ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
 969                                    &tkp.Privileges[0].Luid);
 970
 971             tkp.PrivilegeCount = 1;  // one privilege to set
 972             tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 973
 974             // Get the shutdown privilege for this process.
 975             ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
 976                                     (PTOKEN_PRIVILEGES)NULL, 0);
 977
 978             // Cannot test the return value of AdjustTokenPrivileges.
 979             bOK = ::GetLastError() == ERROR_SUCCESS;
 980         }
 981     }
 982
 983     if ( bOK )
 984     {
 985         UINT flags = EWX_SHUTDOWN | EWX_FORCE;
 986         switch ( wFlags )
 987         {
 988             case wxSHUTDOWN_POWEROFF:
 989                 flags |= EWX_POWEROFF;
 990                 break;
 991
 992             case wxSHUTDOWN_REBOOT:
 993                 flags |= EWX_REBOOT;
 994                 break;
 995
 996             default:
 997                 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
 998                 return false;
 999         }
1000
1001         bOK = ::ExitWindowsEx(flags, 0) != 0;
1002     }
1003
1004     return bOK;
1005 #endif // Win32/16
1006 }
1007
1008 // ----------------------------------------------------------------------------
1009 // misc
1010 // ----------------------------------------------------------------------------
1011
1012 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
1013 wxMemorySize wxGetFreeMemory()
1014 {
1015 #if defined(__WIN64__)
1016     MEMORYSTATUSEX memStatex;
1017     statex.dwLength = sizeof (statex);
1018     ::GlobalMemoryStatusEx (&statex);
1019     return (wxMemorySize)memStatus.ullAvailPhys;
1020 #else /* if defined(__WIN32__) */
1021     MEMORYSTATUS memStatus;
1022     memStatus.dwLength = sizeof(MEMORYSTATUS);
1023     ::GlobalMemoryStatus(&memStatus);
1024     return (wxMemorySize)memStatus.dwAvailPhys;
1025 #endif
1026 }
1027
1028 unsigned long wxGetProcessId()
1029 {
1030     return ::GetCurrentProcessId();
1031 }
1032
1033 // Emit a beeeeeep
1034 void wxBell()
1035 {
1036     ::MessageBeep((UINT)-1);        // default sound
1037 }
1038
1039 wxString wxGetOsDescription()
1040 {
1041     wxString str;
1042
1043     OSVERSIONINFO info;
1044     wxZeroMemory(info);
1045
1046     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1047     if ( ::GetVersionEx(&info) )
1048     {
1049         switch ( info.dwPlatformId )
1050         {
1051             case VER_PLATFORM_WIN32s:
1052                 str = _("Win32s on Windows 3.1");
1053                 break;
1054
1055             case VER_PLATFORM_WIN32_WINDOWS:
1056                 switch (info.dwMinorVersion)
1057                 {
1058                     case 0:
1059                         if ( info.szCSDVersion[1] == 'B' ||
1060                              info.szCSDVersion[1] == 'C' )
1061                         {
1062                             str = _("Windows 95 OSR2");
1063                         }
1064                         else
1065                         {
1066                             str = _("Windows 95");
1067                         }
1068                         break;
1069                     case 10:
1070                         if ( info.szCSDVersion[1] == 'B' ||
1071                              info.szCSDVersion[1] == 'C' )
1072                         {
1073                             str = _("Windows 98 SE");
1074                         }
1075                         else
1076                         {
1077                             str = _("Windows 98");
1078                         }
1079                         break;
1080                     case 90:
1081                         str = _("Windows ME");
1082                         break;
1083                     default:
1084                         str.Printf(_("Windows 9x (%d.%d)"),
1085                                    info.dwMajorVersion,
1086                                    info.dwMinorVersion);
1087                         break;
1088                 }
1089                 if ( !wxIsEmpty(info.szCSDVersion) )
1090                 {
1091                     str << _T(" (") << info.szCSDVersion << _T(')');
1092                 }
1093                 break;
1094
1095             case VER_PLATFORM_WIN32_NT:
1096                 if ( info.dwMajorVersion == 5 )
1097                 {
1098                     switch ( info.dwMinorVersion )
1099                     {
1100                         case 0:
1101                             str.Printf(_("Windows 2000 (build %lu"),
1102                                        info.dwBuildNumber);
1103                             break;
1104                         case 1:
1105                             str.Printf(_("Windows XP (build %lu"),
1106                                        info.dwBuildNumber);
1107                             break;
1108                         case 2:
1109                             str.Printf(_("Windows Server 2003 (build %lu"),
1110                                        info.dwBuildNumber);
1111                             break;
1112                     }
1113                 }
1114                 if ( wxIsEmpty(str) )
1115                 {
1116                     str.Printf(_("Windows NT %lu.%lu (build %lu"),
1117                            info.dwMajorVersion,
1118                            info.dwMinorVersion,
1119                            info.dwBuildNumber);
1120                 }
1121                 if ( !wxIsEmpty(info.szCSDVersion) )
1122                 {
1123                     str << _T(", ") << info.szCSDVersion;
1124                 }
1125                 str << _T(')');
1126                 break;
1127         }
1128     }
1129     else
1130     {
1131         wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
1132     }
1133
1134     return str;
1135 }
1136
1137 wxToolkitInfo& wxAppTraits::GetToolkitInfo()
1138 {
1139     // cache the version info, it's not going to change
1140     //
1141     // NB: this is MT-safe, we may use these static vars from different threads
1142     //     but as they always have the same value it doesn't matter
1143     static int s_ver = -1,
1144                s_major = -1,
1145                s_minor = -1;
1146
1147     if ( s_ver == -1 )
1148     {
1149         OSVERSIONINFO info;
1150         wxZeroMemory(info);
1151
1152         s_ver = wxWINDOWS;
1153         info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1154         if ( ::GetVersionEx(&info) )
1155         {
1156             s_major = info.dwMajorVersion;
1157             s_minor = info.dwMinorVersion;
1158
1159             switch ( info.dwPlatformId )
1160             {
1161                 case VER_PLATFORM_WIN32s:
1162                     s_ver = wxWIN32S;
1163                     break;
1164
1165                 case VER_PLATFORM_WIN32_WINDOWS:
1166                     s_ver = wxWIN95;
1167                     break;
1168
1169                 case VER_PLATFORM_WIN32_NT:
1170                     s_ver = wxWINDOWS_NT;
1171                     break;
1172 #ifdef __WXWINCE__
1173                 case VER_PLATFORM_WIN32_CE:
1174                     s_ver = wxWINDOWS_CE;
1175                     break;
1176 #endif
1177             }
1178         }
1179     }
1180
1181     static wxToolkitInfo info;
1182     info.versionMajor = s_major;
1183     info.versionMinor = s_minor;
1184     info.os = s_ver;
1185     info.name = _T("wxBase");
1186     return info;
1187 }
1188
1189 // ----------------------------------------------------------------------------
1190 // sleep functions
1191 // ----------------------------------------------------------------------------
1192
1193 void wxMilliSleep(unsigned long milliseconds)
1194 {
1195     ::Sleep(milliseconds);
1196 }
1197
1198 void wxMicroSleep(unsigned long microseconds)
1199 {
1200     wxMilliSleep(microseconds/1000);
1201 }
1202
1203 void wxSleep(int nSecs)
1204 {
1205     wxMilliSleep(1000*nSecs);
1206 }
1207
1208 // ----------------------------------------------------------------------------
1209 // font encoding <-> Win32 codepage conversion functions
1210 // ----------------------------------------------------------------------------
1211
1212 extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
1213 {
1214     switch ( encoding )
1215     {
1216         // although this function is supposed to return an exact match, do do
1217         // some mappings here for the most common case of "standard" encoding
1218         case wxFONTENCODING_SYSTEM:
1219             return DEFAULT_CHARSET;
1220
1221         case wxFONTENCODING_ISO8859_1:
1222         case wxFONTENCODING_ISO8859_15:
1223         case wxFONTENCODING_CP1252:
1224             return ANSI_CHARSET;
1225
1226 #if !defined(__WXMICROWIN__)
1227         // The following four fonts are multi-byte charsets
1228         case wxFONTENCODING_CP932:
1229             return SHIFTJIS_CHARSET;
1230
1231         case wxFONTENCODING_CP936:
1232             return GB2312_CHARSET;
1233
1234         case wxFONTENCODING_CP949:
1235             return HANGUL_CHARSET;
1236
1237         case wxFONTENCODING_CP950:
1238             return CHINESEBIG5_CHARSET;
1239
1240         // The rest are single byte encodings
1241         case wxFONTENCODING_CP1250:
1242             return EASTEUROPE_CHARSET;
1243
1244         case wxFONTENCODING_CP1251:
1245             return RUSSIAN_CHARSET;
1246
1247         case wxFONTENCODING_CP1253:
1248             return GREEK_CHARSET;
1249
1250         case wxFONTENCODING_CP1254:
1251             return TURKISH_CHARSET;
1252
1253         case wxFONTENCODING_CP1255:
1254             return HEBREW_CHARSET;
1255
1256         case wxFONTENCODING_CP1256:
1257             return ARABIC_CHARSET;
1258
1259         case wxFONTENCODING_CP1257:
1260             return BALTIC_CHARSET;
1261
1262         case wxFONTENCODING_CP874:
1263             return THAI_CHARSET;
1264 #endif // !__WXMICROWIN__
1265
1266         case wxFONTENCODING_CP437:
1267             return OEM_CHARSET;
1268
1269         default:
1270             // no way to translate this encoding into a Windows charset
1271             return -1;
1272     }
1273 }
1274
1275 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
1276 // looks up the vlaues in the registry and the new one which is more
1277 // politically correct and has more chances to work on other Windows versions
1278 // as well but the old version is still needed for !wxUSE_FONTMAP case
1279 #if wxUSE_FONTMAP
1280
1281 #include "wx/fontmap.h"
1282
1283 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
1284 {
1285     // translate encoding into the Windows CHARSET
1286     long charset = wxEncodingToCharset(encoding);
1287     if ( charset == -1 )
1288         return -1;
1289
1290     // translate CHARSET to code page
1291     CHARSETINFO csetInfo;
1292     if ( !::TranslateCharsetInfo((DWORD *)(DWORD)charset,
1293                                  &csetInfo,
1294                                  TCI_SRCCHARSET) )
1295     {
1296         wxLogLastError(_T("TranslateCharsetInfo(TCI_SRCCHARSET)"));
1297
1298         return -1;
1299     }
1300
1301     return csetInfo.ciACP;
1302 }
1303
1304 extern long wxCharsetToCodepage(const wxChar *name)
1305 {
1306     // first get the font encoding for this charset
1307     if ( !name )
1308         return -1;
1309
1310     wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(name, false);
1311     if ( enc == wxFONTENCODING_SYSTEM )
1312         return -1;
1313
1314     // the use the helper function
1315     return wxEncodingToCodepage(enc);
1316 }
1317
1318 #else // !wxUSE_FONTMAP
1319
1320 #include "wx/msw/registry.h"
1321
1322 // this should work if Internet Exploiter is installed
1323 extern long wxCharsetToCodepage(const wxChar *name)
1324 {
1325     if (!name)
1326         return GetACP();
1327
1328     long CP = -1;
1329
1330     wxString path(wxT("MIME\\Database\\Charset\\"));
1331     wxString cn(name);
1332
1333     // follow the alias loop
1334     for ( ;; )
1335     {
1336         wxRegKey key(wxRegKey::HKCR, path + cn);
1337
1338         if (!key.Exists())
1339             break;
1340
1341         // two cases: either there's an AliasForCharset string,
1342         // or there are Codepage and InternetEncoding dwords.
1343         // The InternetEncoding gives us the actual encoding,
1344         // the Codepage just says which Windows character set to
1345         // use when displaying the data.
1346         if (key.HasValue(wxT("InternetEncoding")) &&
1347             key.QueryValue(wxT("InternetEncoding"), &CP))
1348             break;
1349
1350         // no encoding, see if it's an alias
1351         if (!key.HasValue(wxT("AliasForCharset")) ||
1352             !key.QueryValue(wxT("AliasForCharset"), cn))
1353             break;
1354     }
1355
1356     return CP;
1357 }
1358
1359 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
1360
1361 /*
1362   Creates a hidden window with supplied window proc registering the class for
1363   it if necesssary (i.e. the first time only). Caller is responsible for
1364   destroying the window and unregistering the class (note that this must be
1365   done because wxWidgets may be used as a DLL and so may be loaded/unloaded
1366   multiple times into/from the same process so we cna't rely on automatic
1367   Windows class unregistration).
1368
1369   pclassname is a pointer to a caller stored classname, which must initially be
1370   NULL. classname is the desired wndclass classname. If function succesfully
1371   registers the class, pclassname will be set to classname.
1372  */
1373 extern "C" WXDLLIMPEXP_BASE HWND
1374 wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
1375 {
1376     wxCHECK_MSG( classname && pclassname && wndproc, NULL,
1377                     _T("NULL parameter in wxCreateHiddenWindow") );
1378
1379     // register the class fi we need to first
1380     if ( *pclassname == NULL )
1381     {
1382         WNDCLASS wndclass;
1383         wxZeroMemory(wndclass);
1384
1385         wndclass.lpfnWndProc   = wndproc;
1386         wndclass.hInstance     = wxGetInstance();
1387         wndclass.lpszClassName = classname;
1388
1389         if ( !::RegisterClass(&wndclass) )
1390         {
1391             wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
1392
1393             return NULL;
1394         }
1395
1396         *pclassname = classname;
1397     }
1398
1399     // next create the window
1400     HWND hwnd = ::CreateWindow
1401                   (
1402                     *pclassname,
1403                     NULL,
1404                     0, 0, 0, 0,
1405                     0,
1406                     (HWND) NULL,
1407                     (HMENU)NULL,
1408                     wxGetInstance(),
1409                     (LPVOID) NULL
1410                   );
1411
1412     if ( !hwnd )
1413     {
1414         wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
1415     }
1416
1417     return hwnd;
1418 }
1419