src/msw/utils.cpp

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