src/msw/utils.cpp

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