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