src/msw/utils.cpp

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