src/msw/utils.cpp

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