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