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