Avoid ICE with MinGW 2.95.3.

[wxWidgets.git] / src / msw / utils.cpp

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index 8b36c7a3dea710996c2d85960a334f131e0da05b..5e295b5a8e63cee6c3d6e4b6fd7ec422baf77381 100644 (file)
--- a/src/msw/utils.cpp
+++ b/src/msw/utils.cpp
@@ -1,17 +1,21 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        utils.cpp
+// Name:        msw/utils.cpp

 // Purpose:     Various utilities
 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Purpose:     Various utilities
 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:     wxWindows license
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-// #pragma implementation "utils.h"   // Note: this is done in utilscmn.cpp now.
-#endif
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------

 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"


@@ -21,21 +25,37 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-    #include "wx/setup.h"

     #include "wx/utils.h"
     #include "wx/app.h"
     #include "wx/utils.h"
     #include "wx/app.h"

-    #include "wx/cursor.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"

 #endif  //WX_PRECOMP
 
 #endif  //WX_PRECOMP
 

-#include "wx/msw/private.h"
-#include "wx/timer.h"
-#include "wx/intl.h"
+#include "wx/apptrait.h"
+#include "wx/dynlib.h"
+#include "wx/dynload.h"
+
+#include "wx/confbase.h"        // for wxExpandEnvVars()
+
+#include "wx/msw/private.h"     // includes <windows.h>
+#include "wx/msw/missing.h"     // CHARSET_HANGUL
+
+#if defined(__CYGWIN__)
+    //CYGWIN gives annoying warning about runtime stuff if we don't do this
+#   define USE_SYS_TYPES_FD_SET
+#   include <sys/types.h>
+#endif

 
 

-#include <windows.h>
+// Doesn't work with Cygwin at present
+#if wxUSE_SOCKETS && (defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) || defined(__CYGWIN32__))
+    // apparently we need to include winsock.h to get WSADATA and other stuff
+    // used in wxGetFullHostName() with the old mingw32 versions
+    #include <winsock.h>
+#endif

 
 

-#include <ctype.h>
+#include "wx/timer.h"

 
 

-#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__)
+#if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)

     #include <direct.h>
 
     #ifndef __MWERKS__
     #include <direct.h>
 
     #ifndef __MWERKS__


@@ -43,13 +63,12 @@
     #endif
 #endif  //GNUWIN32
 
     #endif
 #endif  //GNUWIN32
 

-#if defined(__GNUWIN32__) && !defined(__TWIN32__)
+#if defined(__CYGWIN__)

     #include <sys/unistd.h>
     #include <sys/stat.h>
     #include <sys/unistd.h>
     #include <sys/stat.h>

+    #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()

 #endif  //GNUWIN32
 
 #endif  //GNUWIN32
 

-#include "wx/log.h"
-

 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
                     // this (3.1 I believe) and how to test for it.
                     // If this works for Borland 4.0 as well, then no worries.
 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
                     // this (3.1 I believe) and how to test for it.
                     // If this works for Borland 4.0 as well, then no worries.


@@ -66,92 +85,165 @@
     #include <lm.h>
 #endif // USE_NET_API
 
     #include <lm.h>
 #endif // USE_NET_API
 

-#if defined(__WIN32__) && !defined(__WXWINE__)
-    #include <io.h>
+#if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
+    #ifndef __UNIX__
+        #include <io.h>
+    #endif

 
     #ifndef __GNUWIN32__
         #include <shellapi.h>
     #endif
 #endif
 
 
     #ifndef __GNUWIN32__
         #include <shellapi.h>
     #endif
 #endif
 

-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>

 #ifndef __WATCOMC__
     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
         #include <errno.h>
     #endif
 #endif
 #ifndef __WATCOMC__
     #if !(defined(_MSC_VER) && (_MSC_VER > 800))
         #include <errno.h>
     #endif
 #endif

-#include <stdarg.h>

 
 

-//// BEGIN for console support: VC++ only
-#ifdef __VISUALC__
+// For wxKillAllChildren
+#include <tlhelp32.h>

 
 

-#include "wx/msw/msvcrt.h"
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------

 
 

-#include <fcntl.h>
+// In the WIN.INI file
+static const wxChar WX_SECTION[] = wxT("wxWindows");
+static const wxChar eUSERNAME[]  = wxT("UserName");
+
+// ============================================================================
+// implementation
+// ============================================================================

 
 

-#include "wx/ioswrap.h"
+// ----------------------------------------------------------------------------
+// get host name and related
+// ----------------------------------------------------------------------------

 
 

-#if wxUSE_IOSTREAMH
-// N.B. BC++ doesn't have istream.h, ostream.h
-#  include <io.h>
-#  include <fstream.h>
+// Get hostname only (without domain name)
+bool wxGetHostName(wxChar *buf, int maxSize)
+{
+#if defined(__WXWINCE__)
+    // TODO-CE
+    wxUnusedVar(buf);
+    wxUnusedVar(maxSize);
+    return false;
+#elif defined(__WIN32__) && !defined(__WXMICROWIN__)
+    DWORD nSize = maxSize;
+    if ( !::GetComputerName(buf, &nSize) )
+    {
+        wxLogLastError(wxT("GetComputerName"));
+
+        return false;
+    }
+
+    return true;

 #else
 #else

-#  include <fstream>
+    wxChar *sysname;
+    const wxChar *default_host = wxT("noname");
+
+    if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
+        GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
+    } else
+        wxStrncpy(buf, sysname, maxSize - 1);
+    buf[maxSize] = wxT('\0');
+    return *buf ? true : false;

 #endif
 #endif

+}

 
 

-/* Need to undef new if including crtdbg.h */
-#  ifdef new
-#  undef new
-#  endif
+// get full hostname (with domain name if possible)
+bool wxGetFullHostName(wxChar *buf, int maxSize)
+{
+#if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER && wxUSE_SOCKETS
+    // TODO should use GetComputerNameEx() when available

 
 

-#ifndef __WIN16__
-#  include <crtdbg.h>
-#endif
+    // we don't want to always link with Winsock DLL as we might not use it at
+    // all, so load it dynamically here if needed (and don't complain if it is
+    // missing, we handle this)
+    wxLogNull noLog;

 
 

-#  if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
-#  define new new(__FILE__,__LINE__)
-#  endif
+    wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
+    if ( dllWinsock.IsLoaded() )
+    {
+        typedef int (PASCAL *WSAStartup_t)(WORD, WSADATA *);
+        typedef int (PASCAL *gethostname_t)(char *, int);
+        typedef hostent* (PASCAL *gethostbyname_t)(const char *);
+        typedef hostent* (PASCAL *gethostbyaddr_t)(const char *, int , int);
+        typedef int (PASCAL *WSACleanup_t)(void);

 
 

-#endif
-  // __VISUALC__
-/// END for console support
+        #define LOAD_WINSOCK_FUNC(func)                                       \
+            func ## _t                                                        \
+                pfn ## func = (func ## _t)dllWinsock.GetSymbol(_T(#func))

 
 

-// In the WIN.INI file
-static const wxChar WX_SECTION[] = wxT("wxWindows");
-static const wxChar eHOSTNAME[]  = wxT("HostName");
-static const wxChar eUSERID[]    = wxT("UserId");
-static const wxChar eUSERNAME[]  = wxT("UserName");
+        LOAD_WINSOCK_FUNC(WSAStartup);

 
 

-// For the following functions we SHOULD fill in support
-// for Windows-NT (which I don't know) as I assume it begin
-// a POSIX Unix (so claims MS) that it has some special
-// functions beyond those provided by WinSock
+        WSADATA wsa;
+        if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
+        {
+            LOAD_WINSOCK_FUNC(gethostname);
+
+            wxString host;
+            if ( pfngethostname )
+            {
+                char bufA[256];
+                if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
+                {
+                    // gethostname() won't usually include the DNS domain name,
+                    // for this we need to work a bit more
+                    if ( !strchr(bufA, '.') )
+                    {
+                        LOAD_WINSOCK_FUNC(gethostbyname);
+
+                        struct hostent *pHostEnt = pfngethostbyname
+                                                    ? pfngethostbyname(bufA)
+                                                    : NULL;
+
+                        if ( pHostEnt )
+                        {
+                            // Windows will use DNS internally now
+                            LOAD_WINSOCK_FUNC(gethostbyaddr);
+
+                            pHostEnt = pfngethostbyaddr
+                                        ? pfngethostbyaddr(pHostEnt->h_addr,
+                                                           4, AF_INET)
+                                        : NULL;
+                        }
+
+                        if ( pHostEnt )
+                        {
+                            host = wxString::FromAscii(pHostEnt->h_name);
+                        }
+                    }
+                }
+            }
+
+            LOAD_WINSOCK_FUNC(WSACleanup);
+            if ( pfnWSACleanup )
+                pfnWSACleanup();
+
+
+            if ( !host.empty() )
+            {
+                wxStrncpy(buf, host, maxSize);
+
+                return true;
+            }
+        }
+    }
+#endif // !__WXMICROWIN__

 
 

-// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
-bool wxGetHostName(wxChar *buf, int maxSize)
-{
-#if defined(__WIN32__) && !defined(__TWIN32__)
-  DWORD nSize = maxSize;
-  return (::GetComputerName(buf, &nSize) != 0);
-#else
-  wxChar *sysname;
-  const wxChar *default_host = wxT("noname");
-
-  if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
-     GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
-  } else
-    wxStrncpy(buf, sysname, maxSize - 1);
-  buf[maxSize] = wxT('\0');
-  return *buf ? TRUE : FALSE;
-#endif
+    return wxGetHostName(buf, maxSize);

 }
 
 // Get user ID e.g. jacs
 bool wxGetUserId(wxChar *buf, int maxSize)
 {
 }
 
 // Get user ID e.g. jacs
 bool wxGetUserId(wxChar *buf, int maxSize)
 {

-#if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__)
+#if defined(__WXWINCE__)
+    // TODO-CE
+    wxUnusedVar(buf);
+    wxUnusedVar(maxSize);
+    return false;
+#elif defined(__WIN32__) && !defined(__WXMICROWIN__)

     DWORD nSize = maxSize;
     if ( ::GetUserName(buf, &nSize) == 0 )
     {
     DWORD nSize = maxSize;
     if ( ::GetUserName(buf, &nSize) == 0 )
     {


@@ -160,51 +252,44 @@ bool wxGetUserId(wxChar *buf, int maxSize)
         if ( res == 0 )
         {
             // not found
         if ( res == 0 )
         {
             // not found

-            return FALSE;
+            return false;

         }
     }
 
         }
     }
 

-    return TRUE;
-#else   // Win16 or Win32s
-  wxChar *user;
-  const wxChar *default_id = wxT("anonymous");
-
-  // Can't assume we have NIS (PC-NFS) or some other ID daemon
-  // So we ...
-  if (  (user = wxGetenv(wxT("USER"))) == NULL &&
-        (user = wxGetenv(wxT("LOGNAME"))) == NULL )
-  {
-     // Use wxWindows configuration data (comming soon)
-     GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
-  }
-  else
-  {
-    wxStrncpy(buf, user, maxSize - 1);
-  }
-
-  return *buf ? TRUE : FALSE;
+    return true;
+#else   // __WXMICROWIN__
+    wxChar *user;
+    const wxChar *default_id = wxT("anonymous");
+
+    // Can't assume we have NIS (PC-NFS) or some other ID daemon
+    // So we ...
+    if (  (user = wxGetenv(wxT("USER"))) == NULL &&
+            (user = wxGetenv(wxT("LOGNAME"))) == NULL )
+    {
+        // Use wxWidgets configuration data (comming soon)
+        GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
+    }
+    else
+    {
+        wxStrncpy(buf, user, maxSize - 1);
+    }
+
+    return *buf ? true : false;

 #endif
 }
 
 // Get user name e.g. Julian Smart
 bool wxGetUserName(wxChar *buf, int maxSize)
 {
 #endif
 }
 
 // Get user name e.g. Julian Smart
 bool wxGetUserName(wxChar *buf, int maxSize)
 {

-#if wxUSE_PENWINDOWS && !defined(__WATCOMC__) && !defined(__GNUWIN32__)
-  extern HANDLE g_hPenWin; // PenWindows Running?
-  if (g_hPenWin)
-  {
-    // PenWindows Does have a user concept!
-    // Get the current owner of the recognizer
-    GetPrivateProfileString("Current", "User", default_name, wxBuffer, maxSize - 1, "PENWIN.INI");
-    strncpy(buf, wxBuffer, maxSize - 1);
-  }
-  else
-#endif
-  {
-#ifdef USE_NET_API
+#if defined(__WXWINCE__)
+    // TODO-CE
+    wxUnusedVar(buf);
+    wxUnusedVar(maxSize);
+    return false;
+#elif defined(USE_NET_API)

     CHAR szUserName[256];
     if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
     CHAR szUserName[256];
     if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )

-        return FALSE;
+        return false;

 
     // TODO how to get the domain name?
     CHAR *szDomain = "";
 
     // TODO how to get the domain name?
     CHAR *szDomain = "";


@@ -218,9 +303,9 @@ bool wxGetUserName(wxChar *buf, int maxSize)
 
     // Convert ANSI user name and domain to Unicode
     MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
 
     // Convert ANSI user name and domain to Unicode
     MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,

-                          wszUserName, WXSIZEOF(wszUserName) );
+            wszUserName, WXSIZEOF(wszUserName) );

     MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
     MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,

-                         wszDomain, WXSIZEOF(wszDomain) );
+            wszDomain, WXSIZEOF(wszDomain) );

 
     // Get the computer name of a DC for the domain.
     if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
 
     // Get the computer name of a DC for the domain.
     if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )


@@ -232,9 +317,9 @@ bool wxGetUserName(wxChar *buf, int maxSize)
 
     // Look up the user on the DC
     NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName,
 
     // Look up the user on the DC
     NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName,

-                                            (LPWSTR)&wszUserName,
-                                            2, // level - we want USER_INFO_2
-                                            (LPBYTE *) &ui2 );
+            (LPWSTR)&wszUserName,
+            2, // level - we want USER_INFO_2
+            (LPBYTE *) &ui2 );

     switch ( status )
     {
         case NERR_Success:
     switch ( status )
     {
         case NERR_Success:


@@ -259,18 +344,18 @@ bool wxGetUserName(wxChar *buf, int maxSize)
 
     // Convert the Unicode full name to ANSI
     WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
 
     // Convert the Unicode full name to ANSI
     WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,

-                         buf, maxSize, NULL, NULL );
+            buf, maxSize, NULL, NULL );

 
 

-    return TRUE;
+    return true;

 
 error:
 
 error:

-  wxLogError(wxT("Couldn't look up full user name."));
+    wxLogError(wxT("Couldn't look up full user name."));

 
 

-  return FALSE;
+    return false;

 #else  // !USE_NET_API
     // Could use NIS, MS-Mail or other site specific programs
 #else  // !USE_NET_API
     // Could use NIS, MS-Mail or other site specific programs

-    // Use wxWindows configuration data
-    bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxT(""), buf, maxSize - 1) != 0;
+    // Use wxWidgets configuration data
+    bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;

     if ( !ok )
     {
         ok = wxGetUserId(buf, maxSize);
     if ( !ok )
     {
         ok = wxGetUserId(buf, maxSize);


@@ -280,852 +365,1164 @@ error:
     {
         wxStrncpy(buf, wxT("Unknown User"), maxSize);
     }
     {
         wxStrncpy(buf, wxT("Unknown User"), maxSize);
     }

-#endif // Win32/16
-  }
-
-  return TRUE;
-}

 
 

-int wxKill(long pid, int sig)
-{
-  return 0;
+    return true;
+#endif // Win32/16

 }
 
 }
 

-//
-// Execute a program in an Interactive Shell
-//
-bool
-wxShell(const wxString& command)
+const wxChar* wxGetHomeDir(wxString *pstr)

 {
 {

-  wxChar *shell;
-  if ((shell = wxGetenv(wxT("COMSPEC"))) == NULL)
-    shell = wxT("\\COMMAND.COM");
+    wxString& strDir = *pstr;

 
 

-  wxChar tmp[255];
-  if (command != wxT(""))
-    wxSprintf(tmp, wxT("%s /c %s"), shell, WXSTRINGCAST command);
-  else
-    wxStrcpy(tmp, shell);
+    // first branch is for Cygwin
+#if defined(__UNIX__)
+    const wxChar *szHome = wxGetenv("HOME");
+    if ( szHome == NULL ) {
+      // we're homeless...
+      wxLogWarning(_("can't find user's HOME, using current directory."));
+      strDir = wxT(".");
+    }
+    else
+       strDir = szHome;

 
 

-  return (wxExecute((wxChar *)tmp, FALSE) != 0);
-}
+    // add a trailing slash if needed
+    if ( strDir.Last() != wxT('/') )
+      strDir << wxT('/');

 
 

-// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
-long wxGetFreeMemory()
-{
-#if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
-  MEMORYSTATUS memStatus;
-  memStatus.dwLength = sizeof(MEMORYSTATUS);
-  GlobalMemoryStatus(&memStatus);
-  return memStatus.dwAvailPhys;
+    #ifdef __CYGWIN__
+        // Cygwin returns unix type path but that does not work well
+        static wxChar windowsPath[MAX_PATH];
+        cygwin_conv_to_full_win32_path(strDir, windowsPath);
+        strDir = windowsPath;
+    #endif
+#elif defined(__WXWINCE__)
+    strDir = wxT("\\");

 #else
 #else

-  return (long)GetFreeSpace(0);
-#endif
+    strDir.clear();
+
+    // If we have a valid HOME directory, as is used on many machines that
+    // have unix utilities on them, we should use that.
+    const wxChar *szHome = wxGetenv(wxT("HOME"));
+
+    if ( szHome != NULL )
+    {
+        strDir = szHome;
+    }
+    else // no HOME, try HOMEDRIVE/PATH
+    {
+        szHome = wxGetenv(wxT("HOMEDRIVE"));
+        if ( szHome != NULL )
+            strDir << szHome;
+        szHome = wxGetenv(wxT("HOMEPATH"));
+
+        if ( szHome != NULL )
+        {
+            strDir << szHome;
+
+            // the idea is that under NT these variables have default values
+            // of "%systemdrive%:" and "\\". As we don't want to create our
+            // config files in the root directory of the system drive, we will
+            // create it in our program's dir. However, if the user took care
+            // to set HOMEPATH to something other than "\\", we suppose that he
+            // knows what he is doing and use the supplied value.
+            if ( wxStrcmp(szHome, wxT("\\")) == 0 )
+                strDir.clear();
+        }
+    }
+
+    if ( strDir.empty() )
+    {
+        // If we have a valid USERPROFILE directory, as is the case in
+        // Windows NT, 2000 and XP, we should use that as our home directory.
+        szHome = wxGetenv(wxT("USERPROFILE"));
+
+        if ( szHome != NULL )
+            strDir = szHome;
+    }
+
+    if ( !strDir.empty() )
+    {
+        // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
+        // value once again, it shouldn't hurt anyhow
+        strDir = wxExpandEnvVars(strDir);
+    }
+    else // fall back to the program directory
+    {
+        // extract the directory component of the program file name
+        wxSplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);
+    }
+#endif  // UNIX/Win
+
+    return strDir.c_str();

 }
 
 }
 

-// Sleep for nSecs seconds. Attempt a Windows implementation using timers.
-static bool inTimer = FALSE;
-class wxSleepTimer: public wxTimer
+wxChar *wxGetUserHome(const wxString& WXUNUSED(user))

 {
 {

- public:
-  inline void Notify()
-  {
-    inTimer = FALSE;
-    Stop();
-  }
-};
+    // VZ: the old code here never worked for user != "" anyhow! Moreover, it
+    //     returned sometimes a malloc()'d pointer, sometimes a pointer to a
+    //     static buffer and sometimes I don't even know what.
+    static wxString s_home;

 
 

-static wxTimer *wxTheSleepTimer = NULL;
+    return (wxChar *)wxGetHomeDir(&s_home);
+}

 
 

-void wxUsleep(unsigned long milliseconds)
+bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)

 {
 {

-#ifdef __WIN32__
-    ::Sleep(milliseconds);
+#ifdef __WXWINCE__
+    // TODO-CE
+    wxUnusedVar(path);
+    wxUnusedVar(pTotal);
+    wxUnusedVar(pFree);
+    return false;

 #else
 #else

-  if (inTimer)
-    return;
-
-  wxTheSleepTimer = new wxSleepTimer;
-  inTimer = TRUE;
-  wxTheSleepTimer->Start(milliseconds);
-  while (inTimer)
-  {
-    if (wxTheApp->Pending())
-      wxTheApp->Dispatch();
-  }
-  delete wxTheSleepTimer;
-  wxTheSleepTimer = NULL;
+    if ( path.empty() )
+        return false;
+
+// old w32api don't have ULARGE_INTEGER
+#if defined(__WIN32__) && \
+    (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
+    // GetDiskFreeSpaceEx() is not available under original Win95, check for
+    // it
+    typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
+                                                PULARGE_INTEGER,
+                                                PULARGE_INTEGER,
+                                                PULARGE_INTEGER);
+
+    GetDiskFreeSpaceEx_t
+        pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
+                              (
+                                ::GetModuleHandle(_T("kernel32.dll")),
+#if wxUSE_UNICODE
+                                "GetDiskFreeSpaceExW"
+#else
+                                "GetDiskFreeSpaceExA"

 #endif
 #endif

-}
+                              );

 
 

-void wxSleep(int nSecs)
-{
-#if 0 // WIN32 hangs app
-  Sleep( 1000*nSecs );
-#else
-  if (inTimer)
-    return;
-
-  wxTheSleepTimer = new wxSleepTimer;
-  inTimer = TRUE;
-  wxTheSleepTimer->Start(nSecs*1000);
-  while (inTimer)
-  {
-    if (wxTheApp->Pending())
-      wxTheApp->Dispatch();
-  }
-  delete wxTheSleepTimer;
-  wxTheSleepTimer = NULL;
+    if ( pGetDiskFreeSpaceEx )
+    {
+        ULARGE_INTEGER bytesFree, bytesTotal;
+
+        // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
+        if ( !pGetDiskFreeSpaceEx(path,
+                                  &bytesFree,
+                                  &bytesTotal,
+                                  NULL) )
+        {
+            wxLogLastError(_T("GetDiskFreeSpaceEx"));
+
+            return false;
+        }
+
+        // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
+        // two 32 bit fields which may be or may be not named - try to make it
+        // compile in all cases
+#if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
+        #define UL(ul) ul.u
+#else // anon union
+        #define UL(ul) ul

 #endif
 #endif

-}
+        if ( pTotal )
+        {
+            *pTotal = wxLongLong(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
+        }

 
 

-// Consume all events until no more left
-void wxFlushEvents()
-{
-//  wxYield();
-}
+        if ( pFree )
+        {
+            *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
+        }
+    }
+    else
+#endif // Win32
+    {
+        // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
+        // should be used instead - but if it's not available, fall back on
+        // GetDiskFreeSpace() nevertheless...
+
+        DWORD lSectorsPerCluster,
+              lBytesPerSector,
+              lNumberOfFreeClusters,
+              lTotalNumberOfClusters;
+
+        // FIXME: this is wrong, we should extract the root drive from path
+        //        instead, but this is the job for wxFileName...
+        if ( !::GetDiskFreeSpace(path,
+                                 &lSectorsPerCluster,
+                                 &lBytesPerSector,
+                                 &lNumberOfFreeClusters,
+                                 &lTotalNumberOfClusters) )
+        {
+            wxLogLastError(_T("GetDiskFreeSpace"));

 
 

-// Output a debug mess., in a system dependent fashion.
-void wxDebugMsg(const wxChar *fmt ...)
-{
-  va_list ap;
-  static wxChar buffer[512];
+            return false;
+        }

 
 

-  if (!wxTheApp->GetWantDebugOutput())
-    return ;
+        wxLongLong lBytesPerCluster = lSectorsPerCluster;
+        lBytesPerCluster *= lBytesPerSector;

 
 

-  va_start(ap, fmt);
+        if ( pTotal )
+        {
+            *pTotal = lBytesPerCluster;
+            *pTotal *= lTotalNumberOfClusters;
+        }

 
 

-  wvsprintf(buffer,fmt,ap) ;
-  OutputDebugString((LPCTSTR)buffer) ;
+        if ( pFree )
+        {
+            *pFree = lBytesPerCluster;
+            *pFree *= lNumberOfFreeClusters;
+        }
+    }

 
 

-  va_end(ap);
+    return true;
+#endif
+    // __WXWINCE__

 }
 
 }
 

-// Non-fatal error: pop up message box and (possibly) continue
-void wxError(const wxString& msg, const wxString& title)
-{
-  wxSprintf(wxBuffer, wxT("%s\nContinue?"), WXSTRINGCAST msg);
-  if (MessageBox(NULL, (LPCTSTR)wxBuffer, (LPCTSTR)WXSTRINGCAST title,
-             MB_ICONSTOP | MB_YESNO) == IDNO)
-    wxExit();
-}
+// ----------------------------------------------------------------------------
+// env vars
+// ----------------------------------------------------------------------------

 
 

-// Fatal error: pop up message box and abort
-void wxFatalError(const wxString& msg, const wxString& title)
+bool wxGetEnv(const wxString& var, wxString *value)

 {
 {

-  wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg);
-  FatalAppExit(0, (LPCTSTR)wxBuffer);
-}
+#ifdef __WXWINCE__
+    // no environment variables under CE
+    wxUnusedVar(var);
+    wxUnusedVar(value);
+    return false;
+#else // Win32
+    // first get the size of the buffer
+    DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
+    if ( !dwRet )
+    {
+        // this means that there is no such variable
+        return false;
+    }

 
 

-// Emit a beeeeeep
-void wxBell()
-{
-    // Removed by RD because IHMO syncronous sound is a Bad Thing.  MessageBeep
-    // will do a similar thing anyway if there is no sound card...
-//#ifdef __WIN32__
-//  Beep(1000,1000) ; // 1kHz during 1 sec.
-//#else
-  MessageBeep((UINT)-1) ;
-//#endif
-}
+    if ( value )
+    {
+        (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
+                                       dwRet);
+    }

 
 

-// Chris Breeze 27/5/98: revised WIN32 code to
-// detect WindowsNT correctly
-int wxGetOsVersion(int *majorVsn, int *minorVsn)
-{
-  if (majorVsn) *majorVsn = 0;
-  if (minorVsn) *minorVsn = 0;
-
-#if defined(__WIN32__) && !defined(__SC__)
-  OSVERSIONINFO info;
-  memset(&info, 0, sizeof(OSVERSIONINFO));
-  info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-  if (GetVersionEx(&info))
-  {
-    if (majorVsn) *majorVsn = info.dwMajorVersion;
-    if (minorVsn) *minorVsn = info.dwMinorVersion;
-    switch (info.dwPlatformId)
-  {
-  case VER_PLATFORM_WIN32s:
-    return wxWIN32S;
-    break;
-  case VER_PLATFORM_WIN32_WINDOWS:
-    return wxWIN95;
-    break;
-  case VER_PLATFORM_WIN32_NT:
-    return wxWINDOWS_NT;
-    break;
-  }
-  }
-  return wxWINDOWS; // error if we get here, return generic value
-#else
-  // Win16 code...
-  int retValue = 0;
-#  ifdef __WINDOWS_386__
-  retValue = wxWIN386;
-#  else
-#    if !defined(__WATCOMC__) && !defined(GNUWIN32) && wxUSE_PENWINDOWS
-  extern HANDLE g_hPenWin;
-  retValue = g_hPenWin ? wxPENWINDOWS : wxWINDOWS ;
-#    endif
-#  endif
-  // @@@@ To be completed. I don't have the manual here...
-  if (majorVsn) *majorVsn = 3 ;
-  if (minorVsn) *minorVsn = 1 ;
-  return retValue ;
-#endif
+    return true;
+#endif // WinCE/32

 }
 
 }
 

-// Reading and writing resources (eg WIN.INI, .Xdefaults)
-#if wxUSE_RESOURCES
-bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
+bool wxSetEnv(const wxString& var, const wxChar *value)

 {
 {

-  if (file != wxT(""))
-// Don't know what the correct cast should be, but it doesn't
-// compile in BC++/16-bit without this cast.
-#if !defined(__WIN32__)
-    return (WritePrivateProfileString((const char*) section, (const char*) entry, (const char*) value, (const char*) file) != 0);
-#else
-    return (WritePrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)value, (LPCTSTR)WXSTRINGCAST file) != 0);
+    // some compilers have putenv() or _putenv() or _wputenv() but it's better
+    // to always use Win32 function directly instead of dealing with them
+#if defined(__WIN32__) && !defined(__WXWINCE__)
+    if ( !::SetEnvironmentVariable(var, value) )
+    {
+        wxLogLastError(_T("SetEnvironmentVariable"));
+
+        return false;
+    }
+
+    return true;
+#else // no way to set env vars
+    // no environment variables under CE
+    wxUnusedVar(var);
+    wxUnusedVar(value);
+    return false;

 #endif
 #endif

-  else
-    return (WriteProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)WXSTRINGCAST value) != 0);

 }
 
 }
 

-bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
-{
-  wxChar buf[50];
-  wxSprintf(buf, wxT("%.4f"), value);
-  return wxWriteResource(section, entry, buf, file);
-}
+// ----------------------------------------------------------------------------
+// process management
+// ----------------------------------------------------------------------------

 
 

-bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
+// structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
+struct wxFindByPidParams

 {
 {

-  wxChar buf[50];
-  wxSprintf(buf, wxT("%ld"), value);
-  return wxWriteResource(section, entry, buf, file);
-}
+    wxFindByPidParams() { hwnd = 0; pid = 0; }

 
 

-bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
-{
-  wxChar buf[50];
-  wxSprintf(buf, wxT("%d"), value);
-  return wxWriteResource(section, entry, buf, file);
-}
+    // the HWND used to return the result
+    HWND hwnd;
+
+    // the PID we're looking from
+    DWORD pid;
+
+    DECLARE_NO_COPY_CLASS(wxFindByPidParams)
+};

 
 

-bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file)
+// wxKill helper: EnumWindows() callback which is used to find the first (top
+// level) window belonging to the given process
+BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)

 {
 {

-  static const wxChar defunkt[] = wxT("$$default");
-  if (file != wxT(""))
-  {
-    int n = GetPrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
-                                    (LPTSTR)wxBuffer, 1000, (LPCTSTR)WXSTRINGCAST file);
-    if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
-     return FALSE;
-  }
-  else
-  {
-    int n = GetProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
-                                    (LPTSTR)wxBuffer, 1000);
-    if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
-      return FALSE;
-  }
-  if (*value) delete[] (*value);
-      *value = copystring(wxBuffer);
-      return TRUE;
+    DWORD pid;
+    (void)::GetWindowThreadProcessId(hwnd, &pid);
+
+    wxFindByPidParams *params = (wxFindByPidParams *)lParam;
+    if ( pid == params->pid )
+    {
+        // remember the window we found
+        params->hwnd = hwnd;
+
+        // return FALSE to stop the enumeration
+        return FALSE;

     }
 
     }
 

-bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
-{
-  wxChar *s = NULL;
-  bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
-  if (succ)
-  {
-    *value = (float)wxStrtod(s, NULL);
-    delete[] s;
+    // continue enumeration

     return TRUE;
     return TRUE;

-  }
-  else return FALSE;

 }
 
 }
 

-bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
-{
-  wxChar *s = NULL;
-  bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
-  if (succ)
-  {
-    *value = wxStrtol(s, NULL, 10);
-    delete[] s;
-    return TRUE;
-  }
-  else return FALSE;
-}
+int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc);

 
 

-bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
+int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)

 {
 {

-  wxChar *s = NULL;
-  bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
-  if (succ)
-  {
-    *value = (int)wxStrtol(s, NULL, 10);
-    delete[] s;
-    return TRUE;
-  }
-  else return FALSE;
-}
-#endif // wxUSE_RESOURCES
+    if (flags & wxKILL_CHILDREN)
+        wxKillAllChildren(pid, sig, krc);
+
+    // get the process handle to operate on
+    HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
+                                    PROCESS_TERMINATE |
+                                    PROCESS_QUERY_INFORMATION,
+                                    FALSE, // not inheritable
+                                    (DWORD)pid);
+    if ( hProcess == NULL )
+    {
+        if ( krc )
+        {
+            if ( ::GetLastError() == ERROR_ACCESS_DENIED )
+            {
+                *krc = wxKILL_ACCESS_DENIED;
+            }
+            else
+            {
+                *krc = wxKILL_NO_PROCESS;
+            }
+        }

 
 

-// ---------------------------------------------------------------------------
-// helper functions for showing a "busy" cursor
-// ---------------------------------------------------------------------------
+        return -1;
+    }

 
 

-HCURSOR gs_wxBusyCursor = 0;     // new, busy cursor
-HCURSOR gs_wxBusyCursorOld = 0;  // old cursor
-static int gs_wxBusyCursorCount = 0;
+    bool ok = true;
+    switch ( sig )
+    {
+        case wxSIGKILL:
+            // kill the process forcefully returning -1 as error code
+            if ( !::TerminateProcess(hProcess, (UINT)-1) )
+            {
+                wxLogSysError(_("Failed to kill process %d"), pid);
+
+                if ( krc )
+                {
+                    // this is not supposed to happen if we could open the
+                    // process
+                    *krc = wxKILL_ERROR;
+                }
+
+                ok = false;
+            }
+            break;

 
 

-// Set the cursor to the busy cursor for all windows
-void wxBeginBusyCursor(wxCursor *cursor)
-{
-    if ( gs_wxBusyCursorCount++ == 0 )
+        case wxSIGNONE:
+            // do nothing, we just want to test for process existence
+            break;
+
+        default:
+            // any other signal means "terminate"
+            {
+                wxFindByPidParams params;
+                params.pid = (DWORD)pid;
+
+                // EnumWindows() has nice semantics: it returns 0 if it found
+                // something or if an error occured and non zero if it
+                // enumerated all the window
+                if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
+                {
+                    // did we find any window?
+                    if ( params.hwnd )
+                    {
+                        // tell the app to close
+                        //
+                        // NB: this is the harshest way, the app won't have
+                        //     opportunity to save any files, for example, but
+                        //     this is probably what we want here. If not we
+                        //     can also use SendMesageTimeout(WM_CLOSE)
+                        if ( !::PostMessage(params.hwnd, WM_QUIT, 0, 0) )
+                        {
+                            wxLogLastError(_T("PostMessage(WM_QUIT)"));
+                        }
+                    }
+                    else // it was an error then
+                    {
+                        wxLogLastError(_T("EnumWindows"));
+
+                        ok = false;
+                    }
+                }
+                else // no windows for this PID
+                {
+                    if ( krc )
+                    {
+                        *krc = wxKILL_ERROR;
+                    }
+
+                    ok = false;
+                }
+            }
+    }
+
+    // the return code
+    DWORD rc;
+
+    if ( ok )

     {
     {

-        gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
-        gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
+        // as we wait for a short time, we can use just WaitForSingleObject()
+        // and not MsgWaitForMultipleObjects()
+        switch ( ::WaitForSingleObject(hProcess, 500 /* msec */) )
+        {
+            case WAIT_OBJECT_0:
+                // process terminated
+                if ( !::GetExitCodeProcess(hProcess, &rc) )
+                {
+                    wxLogLastError(_T("GetExitCodeProcess"));
+                }
+                break;
+
+            default:
+                wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
+                // fall through
+
+            case WAIT_FAILED:
+                wxLogLastError(_T("WaitForSingleObject"));
+                // fall through
+
+            case WAIT_TIMEOUT:
+                if ( krc )
+                {
+                    *krc = wxKILL_ERROR;
+                }
+
+                rc = STILL_ACTIVE;
+                break;
+        }
+    }
+    else // !ok
+    {
+        // just to suppress the warnings about uninitialized variable
+        rc = 0;

     }
     }

-    //else: nothing to do, already set
-}

 
 

-// Restore cursor to normal
-void wxEndBusyCursor()
-{
-    wxCHECK_RET( gs_wxBusyCursorCount > 0,
-                 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
+    ::CloseHandle(hProcess);

 
 

-    if ( --gs_wxBusyCursorCount == 0 )
+    // the return code is the same as from Unix kill(): 0 if killed
+    // successfully or -1 on error
+    //
+    // be careful to interpret rc correctly: for wxSIGNONE we return success if
+    // the process exists, for all the other sig values -- if it doesn't
+    if ( ok &&
+            ((sig == wxSIGNONE) == (rc == STILL_ACTIVE)) )

     {
     {

-        ::SetCursor(gs_wxBusyCursorOld);
+        if ( krc )
+        {
+            *krc = wxKILL_OK;
+        }

 
 

-        gs_wxBusyCursorOld = 0;
+        return 0;

     }
     }

+
+    // error
+    return -1;

 }
 
 }
 

-// TRUE if we're between the above two calls
-bool wxIsBusy()
+HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
+BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
+BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
+
+static void InitToolHelp32()

 {
 {

-  return (gs_wxBusyCursorCount > 0);
+    static bool s_initToolHelpDone = false;
+
+    if (s_initToolHelpDone)
+        return;
+
+    s_initToolHelpDone = true;
+
+    lpfCreateToolhelp32Snapshot = NULL;
+    lpfProcess32First = NULL;
+    lpfProcess32Next = NULL;
+
+    HINSTANCE hInstLib = LoadLibrary( wxT("Kernel32.DLL") ) ;
+    if( hInstLib == NULL )
+        return ;
+
+    // Get procedure addresses.
+    // We are linking to these functions of Kernel32
+    // explicitly, because otherwise a module using
+    // this code would fail to load under Windows NT,
+    // which does not have the Toolhelp32
+    // functions in the Kernel 32.
+    lpfCreateToolhelp32Snapshot=
+        (HANDLE(WINAPI *)(DWORD,DWORD))
+        GetProcAddress( hInstLib,
+#ifdef __WXWINCE__
+        wxT("CreateToolhelp32Snapshot")
+#else
+        "CreateToolhelp32Snapshot"
+#endif
+        ) ;
+
+    lpfProcess32First=
+        (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
+        GetProcAddress( hInstLib,
+#ifdef __WXWINCE__
+        wxT("Process32First")
+#else
+        "Process32First"
+#endif
+        ) ;
+
+    lpfProcess32Next=
+        (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
+        GetProcAddress( hInstLib,
+#ifdef __WXWINCE__
+        wxT("Process32Next")
+#else
+        "Process32Next"
+#endif
+        ) ;
+
+    FreeLibrary( hInstLib ) ;

 }
 
 }
 

-// ---------------------------------------------------------------------------
-const wxChar* wxGetHomeDir(wxString *pstr)
+// By John Skiff
+int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc)

 {
 {

-  wxString& strDir = *pstr;
+    InitToolHelp32();

 
 

-  #if defined(__UNIX__) && !defined(__TWIN32__)
-    const wxChar *szHome = wxGetenv("HOME");
-    if ( szHome == NULL ) {
-      // we're homeless...
-      wxLogWarning(_("can't find user's HOME, using current directory."));
-      strDir = wxT(".");
-    }
-    else
-       strDir = szHome;
+    if (krc)
+        *krc = wxKILL_OK;

 
 

-    // add a trailing slash if needed
-    if ( strDir.Last() != wxT('/') )
-      strDir << wxT('/');
-  #else   // Windows
-    #ifdef  __WIN32__
-      const wxChar *szHome = wxGetenv(wxT("HOMEDRIVE"));
-      if ( szHome != NULL )
-        strDir << szHome;
-      szHome = wxGetenv(wxT("HOMEPATH"));
-      if ( szHome != NULL ) {
-        strDir << szHome;
-
-        // the idea is that under NT these variables have default values
-        // of "%systemdrive%:" and "\\". As we don't want to create our
-        // config files in the root directory of the system drive, we will
-        // create it in our program's dir. However, if the user took care
-        // to set HOMEPATH to something other than "\\", we suppose that he
-        // knows what he is doing and use the supplied value.
-        if ( wxStrcmp(szHome, wxT("\\")) != 0 )
-          return strDir.c_str();
-      }
-
-    #else   // Win16
-      // Win16 has no idea about home, so use the working directory instead
-    #endif  // WIN16/32
-
-    // 260 was taken from windef.h
-    #ifndef MAX_PATH
-      #define MAX_PATH  260
-    #endif
+    // If not implemented for this platform (e.g. NT 4.0), silently ignore
+    if (!lpfCreateToolhelp32Snapshot || !lpfProcess32First || !lpfProcess32Next)
+        return 0;

 
 

-    wxString strPath;
-    ::GetModuleFileName(::GetModuleHandle(NULL),
-                        strPath.GetWriteBuf(MAX_PATH), MAX_PATH);
-    strPath.UngetWriteBuf();
+    // Take a snapshot of all processes in the system.
+    HANDLE hProcessSnap = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    if (hProcessSnap == INVALID_HANDLE_VALUE) {
+        if (krc)
+            *krc = wxKILL_ERROR;
+        return -1;
+    }
+
+    //Fill in the size of the structure before using it.
+    PROCESSENTRY32 pe;
+    wxZeroMemory(pe);
+    pe.dwSize = sizeof(PROCESSENTRY32);
+
+    // Walk the snapshot of the processes, and for each process,
+    // kill it if its parent is pid.
+    if (!lpfProcess32First(hProcessSnap, &pe)) {
+        // Can't get first process.
+        if (krc)
+            *krc = wxKILL_ERROR;
+        CloseHandle (hProcessSnap);
+        return -1;
+    }

 
 

-    // extract the dir name
-    wxSplitPath(strPath, &strDir, NULL, NULL);
+    do {
+        if (pe.th32ParentProcessID == (DWORD) pid) {
+            if (wxKill(pe.th32ProcessID, sig, krc))
+                return -1;
+        }
+    } while (lpfProcess32Next (hProcessSnap, &pe));

 
 

-  #endif  // UNIX/Win

 
 

-  return strDir.c_str();
+    return 0;

 }
 
 }
 

-// Hack for MS-DOS
-wxChar *wxGetUserHome (const wxString& user)
+// Execute a program in an Interactive Shell
+bool wxShell(const wxString& command)

 {
 {

-  wxChar *home;
-  wxString user1(user);
-
-  if (user1 != wxT("")) {
-    wxChar tmp[64];
-    if (wxGetUserId(tmp, sizeof(tmp)/sizeof(char))) {
-      // Guests belong in the temp dir
-      if (wxStricmp(tmp, wxT("annonymous")) == 0) {
-        if ((home = wxGetenv(wxT("TMP"))) != NULL ||
-            (home = wxGetenv(wxT("TMPDIR"))) != NULL ||
-            (home = wxGetenv(wxT("TEMP"))) != NULL)
-            return *home ? home : (wxChar*)wxT("\\");
-      }
-      if (wxStricmp(tmp, WXSTRINGCAST user1) == 0)
-        user1 = wxT("");
+    wxString cmd;
+
+#ifdef __WXWINCE__
+    cmd = command;
+#else
+    wxChar *shell = wxGetenv(wxT("COMSPEC"));
+    if ( !shell )
+        shell = (wxChar*) wxT("\\COMMAND.COM");
+
+    if ( !command )
+    {
+        // just the shell
+        cmd = shell;

     }
     }

-  }
-  if (user1 == wxT(""))
-    if ((home = wxGetenv(wxT("HOME"))) != NULL)
+    else

     {
     {

-      wxStrcpy(wxBuffer, home);
-      Unix2DosFilename(wxBuffer);
-      return wxBuffer;
+        // pass the command to execute to the command processor
+        cmd.Printf(wxT("%s /c %s"), shell, command.c_str());

     }
     }

-  return NULL; // No home known!
+#endif
+
+    return wxExecute(cmd, wxEXEC_SYNC) == 0;

 }
 
 }
 

-// Check whether this window wants to process messages, e.g. Stop button
-// in long calculations.
-bool wxCheckForInterrupt(wxWindow *wnd)
+// Shutdown or reboot the PC
+bool wxShutdown(wxShutdownFlags wFlags)

 {
 {

-  if(wnd){
-    MSG msg;
-    HWND win= (HWND) wnd->GetHWND();
-    while(PeekMessage(&msg,win,0,0,PM_REMOVE)){
-      TranslateMessage(&msg);
-      DispatchMessage(&msg);
-    }
-    return TRUE;//*** temporary?
-  }
-  else{
-    wxFAIL_MSG(wxT("wnd==NULL !!!"));
+#ifdef __WXWINCE__
+    // TODO-CE
+    wxUnusedVar(wFlags);
+    return false;
+#elif defined(__WIN32__)
+    bool bOK = true;
+
+    if ( wxGetOsVersion(NULL, NULL) == wxWINDOWS_NT ) // if is NT or 2K
+    {
+        // Get a token for this process.
+        HANDLE hToken;
+        bOK = ::OpenProcessToken(GetCurrentProcess(),
+                                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                                 &hToken) != 0;
+        if ( bOK )
+        {
+            TOKEN_PRIVILEGES tkp;

 
 

-    return FALSE;//*** temporary?
-  }
-}
+            // Get the LUID for the shutdown privilege.
+            ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
+                                   &tkp.Privileges[0].Luid);

 
 

-// MSW only: get user-defined resource from the .res file.
-// Returns NULL or newly-allocated memory, so use delete[] to clean up.
+            tkp.PrivilegeCount = 1;  // one privilege to set
+            tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

 
 

-#ifdef __WXMSW__
-wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
-{
-  wxChar *s = NULL;
-#if !defined(__WIN32__) || defined(__TWIN32__)
-  HRSRC hResource = ::FindResource(wxGetInstance(), WXSTRINGCAST resourceName, WXSTRINGCAST resourceType);
-#else
-#ifdef UNICODE
-  HRSRC hResource = ::FindResourceW(wxGetInstance(), WXSTRINGCAST resourceName, WXSTRINGCAST resourceType);
-#else
-  HRSRC hResource = ::FindResourceA(wxGetInstance(), WXSTRINGCAST resourceName, WXSTRINGCAST resourceType);
-#endif
-#endif
+            // Get the shutdown privilege for this process.
+            ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
+                                    (PTOKEN_PRIVILEGES)NULL, 0);

 
 

-  if (hResource == 0)
-    return NULL;
-  HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
-  if (hData == 0)
-    return NULL;
-  wxChar *theText = (wxChar *)LockResource(hData);
-  if (!theText)
-    return NULL;
+            // Cannot test the return value of AdjustTokenPrivileges.
+            bOK = ::GetLastError() == ERROR_SUCCESS;
+        }
+    }

 
 

-  s = copystring(theText);
+    if ( bOK )
+    {
+        UINT flags = EWX_SHUTDOWN | EWX_FORCE;
+        switch ( wFlags )
+        {
+            case wxSHUTDOWN_POWEROFF:
+                flags |= EWX_POWEROFF;
+                break;

 
 

-  // Obsolete in WIN32
-#ifndef __WIN32__
-  UnlockResource(hData);
-#endif
+            case wxSHUTDOWN_REBOOT:
+                flags |= EWX_REBOOT;
+                break;

 
 

-  // No need??
-//  GlobalFree(hData);
+            default:
+                wxFAIL_MSG( _T("unknown wxShutdown() flag") );
+                return false;
+        }
+
+        bOK = ::ExitWindowsEx(flags, 0) != 0;
+    }

 
 

-  return s;
+    return bOK;
+#endif // Win32/16

 }
 }

-#endif

 
 

-void wxGetMousePosition( int* x, int* y )
+wxPowerType wxGetPowerType()

 {
 {

-  POINT pt;
-  GetCursorPos( & pt );
-  *x = pt.x;
-  *y = pt.y;
-};
+    // TODO
+    return wxPOWER_UNKNOWN;
+}

 
 

-// Return TRUE if we have a colour display
-bool wxColourDisplay()
+wxBatteryState wxGetBatteryState()

 {
 {

-  HDC dc = ::GetDC((HWND) NULL);
-  bool flag;
-  int noCols = GetDeviceCaps(dc, NUMCOLORS);
-  if ((noCols == -1) || (noCols > 2))
-    flag = TRUE;
-  else
-    flag = FALSE;
-  ReleaseDC((HWND) NULL, dc);
-  return flag;
+    // TODO
+    return wxBATTERY_UNKNOWN_STATE;

 }
 
 }
 

-// Returns depth of screen
-int wxDisplayDepth()
+// ----------------------------------------------------------------------------
+// misc
+// ----------------------------------------------------------------------------
+
+// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
+wxMemorySize wxGetFreeMemory()

 {
 {

-  HDC dc = ::GetDC((HWND) NULL);
-  int planes = GetDeviceCaps(dc, PLANES);
-  int bitsPerPixel = GetDeviceCaps(dc, BITSPIXEL);
-  int depth = planes*bitsPerPixel;
-  ReleaseDC((HWND) NULL, dc);
-  return depth;
+#if defined(__WIN64__)
+    MEMORYSTATUSEX memStatex;
+    statex.dwLength = sizeof (statex);
+    ::GlobalMemoryStatusEx (&statex);
+    return (wxMemorySize)memStatus.ullAvailPhys;
+#else /* if defined(__WIN32__) */
+    MEMORYSTATUS memStatus;
+    memStatus.dwLength = sizeof(MEMORYSTATUS);
+    ::GlobalMemoryStatus(&memStatus);
+    return (wxMemorySize)memStatus.dwAvailPhys;
+#endif

 }
 
 }
 

-// Get size of display
-void wxDisplaySize(int *width, int *height)
+unsigned long wxGetProcessId()

 {
 {

-  HDC dc = ::GetDC((HWND) NULL);
-  *width = GetDeviceCaps(dc, HORZRES); *height = GetDeviceCaps(dc, VERTRES);
-  ReleaseDC((HWND) NULL, dc);
+    return ::GetCurrentProcessId();

 }
 
 }
 

-bool wxDirExists(const wxString& dir)
+// Emit a beeeeeep
+void wxBell()

 {
 {

-  /* MATTHEW: [6] Always use same code for Win32, call FindClose */
-#if defined(__WIN32__)
-  WIN32_FIND_DATA fileInfo;
-#else
-#ifdef __BORLANDC__
-  struct ffblk fileInfo;
-#else
-  struct find_t fileInfo;
-#endif
-#endif
-
-#if defined(__WIN32__)
-  HANDLE h = FindFirstFile((LPTSTR) WXSTRINGCAST dir,(LPWIN32_FIND_DATA)&fileInfo);
-
-  if (h==INVALID_HANDLE_VALUE)
-   return FALSE;
-  else {
-   FindClose(h);
-   return ((fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
-  }
-#else
-  // In Borland findfirst has a different argument
-  // ordering from _dos_findfirst. But _dos_findfirst
-  // _should_ be ok in both MS and Borland... why not?
-#ifdef __BORLANDC__
-  return ((findfirst(WXSTRINGCAST dir, &fileInfo, _A_SUBDIR) == 0  && (fileInfo.ff_attrib & _A_SUBDIR) != 0));
-#else
-  return (((_dos_findfirst(WXSTRINGCAST dir, _A_SUBDIR, &fileInfo) == 0) && (fileInfo.attrib & _A_SUBDIR)) != 0);
-#endif
-#endif
+    ::MessageBeep((UINT)-1);        // default sound

 }
 
 }
 

-// ---------------------------------------------------------------------------
-// window information functions
-// ---------------------------------------------------------------------------
-
-wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
+bool wxIsDebuggerRunning()

 {
 {

-    wxString str;
-    int len = GetWindowTextLength((HWND)hWnd) + 1;
-    GetWindowText((HWND)hWnd, str.GetWriteBuf(len), len);
-    str.UngetWriteBuf();
+    // IsDebuggerPresent() is not available under Win95, so load it dynamically
+    wxDynamicLibrary dll(_T("kernel32.dll"), wxDL_VERBATIM);

 
 

-    return str;
+    typedef BOOL (WINAPI *IsDebuggerPresent_t)();
+    if ( !dll.HasSymbol(_T("IsDebuggerPresent")) )
+    {
+        // no way to know, assume no
+        return false;
+    }
+
+    return (*(IsDebuggerPresent_t)dll.GetSymbol(_T("IsDebuggerPresent")))() != 0;

 }
 
 }
 

-wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
+// ----------------------------------------------------------------------------
+// OS version
+// ----------------------------------------------------------------------------
+
+wxString wxGetOsDescription()

 {
     wxString str;
 
 {
     wxString str;
 

-    int len = 256; // some starting value
+    OSVERSIONINFO info;
+    wxZeroMemory(info);

 
 

-    for ( ;; )
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    if ( ::GetVersionEx(&info) )

     {
     {

-        // as we've #undefined GetClassName we must now manually choose the
-        // right function to call
-        int count =
-
-        #ifndef __WIN32__
-            GetClassName
-        #else // Win32
-            #ifdef UNICODE
-                GetClassNameW
-            #else // !Unicode
-                #ifdef __TWIN32__
-                    GetClassName
-                #else // !Twin32
-                    GetClassNameA
-                #endif // Twin32/!Twin32
-            #endif // Unicode/ANSI
-        #endif // Win16/32
-                                    ((HWND)hWnd, str.GetWriteBuf(len), len);
-
-        str.UngetWriteBuf();
-        if ( count == len )
+        switch ( info.dwPlatformId )

         {
         {

-            // the class name might have been truncated, retry with larger
-            // buffer
-            len *= 2;
+            case VER_PLATFORM_WIN32s:
+                str = _("Win32s on Windows 3.1");
+                break;
+
+            case VER_PLATFORM_WIN32_WINDOWS:
+                switch (info.dwMinorVersion)
+                {
+                    case 0:
+                        if ( info.szCSDVersion[1] == 'B' ||
+                             info.szCSDVersion[1] == 'C' )
+                        {
+                            str = _("Windows 95 OSR2");
+                        }
+                        else
+                        {
+                            str = _("Windows 95");
+                        }
+                        break;
+                    case 10:
+                        if ( info.szCSDVersion[1] == 'B' ||
+                             info.szCSDVersion[1] == 'C' )
+                        {
+                            str = _("Windows 98 SE");
+                        }
+                        else
+                        {
+                            str = _("Windows 98");
+                        }
+                        break;
+                    case 90:
+                        str = _("Windows ME");
+                        break;
+                    default:
+                        str.Printf(_("Windows 9x (%d.%d)"),
+                                   info.dwMajorVersion,
+                                   info.dwMinorVersion);
+                        break;
+                }
+                if ( !wxIsEmpty(info.szCSDVersion) )
+                {
+                    str << _T(" (") << info.szCSDVersion << _T(')');
+                }
+                break;
+
+            case VER_PLATFORM_WIN32_NT:
+                if ( info.dwMajorVersion == 5 )
+                {
+                    switch ( info.dwMinorVersion )
+                    {
+                        case 0:
+                            str.Printf(_("Windows 2000 (build %lu"),
+                                       info.dwBuildNumber);
+                            break;
+                        case 1:
+                            str.Printf(_("Windows XP (build %lu"),
+                                       info.dwBuildNumber);
+                            break;
+                        case 2:
+                            str.Printf(_("Windows Server 2003 (build %lu"),
+                                       info.dwBuildNumber);
+                            break;
+                    }
+                }
+                if ( wxIsEmpty(str) )
+                {
+                    str.Printf(_("Windows NT %lu.%lu (build %lu"),
+                           info.dwMajorVersion,
+                           info.dwMinorVersion,
+                           info.dwBuildNumber);
+                }
+                if ( !wxIsEmpty(info.szCSDVersion) )
+                {
+                    str << _T(", ") << info.szCSDVersion;
+                }
+                str << _T(')');
+                break;

         }
         }

-        else
+    }
+    else
+    {
+        wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
+    }
+
+    return str;
+}
+
+wxToolkitInfo& wxAppTraits::GetToolkitInfo()
+{
+    // cache the version info, it's not going to change
+    //
+    // NB: this is MT-safe, we may use these static vars from different threads
+    //     but as they always have the same value it doesn't matter
+    static int s_ver = -1,
+               s_major = -1,
+               s_minor = -1;
+
+    if ( s_ver == -1 )
+    {
+        OSVERSIONINFO info;
+        wxZeroMemory(info);
+
+        s_ver = wxWINDOWS;
+        info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+        if ( ::GetVersionEx(&info) )

         {
         {

-            break;
+            s_major = info.dwMajorVersion;
+            s_minor = info.dwMinorVersion;
+
+#ifdef __SMARTPHONE__
+            s_ver = wxWINDOWS_SMARTPHONE;
+#elif defined(__POCKETPC__)
+            s_ver = wxWINDOWS_POCKETPC;
+#else
+            switch ( info.dwPlatformId )
+            {
+                case VER_PLATFORM_WIN32s:
+                    s_ver = wxWIN32S;
+                    break;
+
+                case VER_PLATFORM_WIN32_WINDOWS:
+                    s_ver = wxWIN95;
+                    break;
+
+                case VER_PLATFORM_WIN32_NT:
+                    s_ver = wxWINDOWS_NT;
+                    break;
+#ifdef __WXWINCE__
+                case VER_PLATFORM_WIN32_CE:
+                    s_ver = wxWINDOWS_CE;
+#endif
+            }
+#endif

         }
     }
 
         }
     }
 

-    return str;
+    static wxToolkitInfo info;
+    info.versionMajor = s_major;
+    info.versionMinor = s_minor;
+    info.os = s_ver;
+    info.name = _T("wxBase");
+    return info;

 }
 
 }
 

-WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
+// ----------------------------------------------------------------------------
+// sleep functions
+// ----------------------------------------------------------------------------
+
+void wxMilliSleep(unsigned long milliseconds)

 {
 {

-#ifndef __WIN32__
-    return GetWindowWord((HWND)hWnd, GWW_ID);
-#else // Win32
-    return GetWindowLong((HWND)hWnd, GWL_ID);
-#endif // Win16/32
+    ::Sleep(milliseconds);

 }
 
 }
 

-#if 0
-//------------------------------------------------------------------------
-// wild character routines
-//------------------------------------------------------------------------
+void wxMicroSleep(unsigned long microseconds)
+{
+    wxMilliSleep(microseconds/1000);
+}

 
 

-bool wxIsWild( const wxString& pattern )
+void wxSleep(int nSecs)

 {
 {

-  wxString tmp = pattern;
-  char *pat = WXSTRINGCAST(tmp);
-    while (*pat) {
-  switch (*pat++) {
-  case '?': case '*': case '[': case '{':
-      return TRUE;
-  case '\\':
-      if (!*pat++)
-    return FALSE;
-  }
-    }
-    return FALSE;
-};
+    wxMilliSleep(1000*nSecs);
+}

 
 

+// ----------------------------------------------------------------------------
+// font encoding <-> Win32 codepage conversion functions
+// ----------------------------------------------------------------------------

 
 

-bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
+extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)

 {
 {

-  wxString tmp1 = pat;
-  char *pattern = WXSTRINGCAST(tmp1);
-  wxString tmp2 = text;
-  char *str = WXSTRINGCAST(tmp2);
-    char c;
-    char *cp;
-    bool done = FALSE, ret_code, ok;
-    // Below is for vi fans
-    const char OB = '{', CB = '}';
-
-    // dot_special means '.' only matches '.'
-    if (dot_special && *str == '.' && *pattern != *str)
-  return FALSE;
-
-    while ((*pattern != '\0') && (!done)
-    && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) {
-  switch (*pattern) {
-  case '\\':
-      pattern++;
-      if (*pattern != '\0')
-    pattern++;
-      break;
-  case '*':
-      pattern++;
-      ret_code = FALSE;
-      while ((*str!='\0')
-      && (!(ret_code=wxMatchWild(pattern, str++, FALSE))))
-    /*loop*/;
-      if (ret_code) {
-    while (*str != '\0')
-        str++;
-    while (*pattern != '\0')
-        pattern++;
-      }
-      break;
-  case '[':
-      pattern++;
-    repeat:
-      if ((*pattern == '\0') || (*pattern == ']')) {
-    done = TRUE;
-    break;
-      }
-      if (*pattern == '\\') {
-    pattern++;
-    if (*pattern == '\0') {
-        done = TRUE;
-        break;
-    }
-      }
-      if (*(pattern + 1) == '-') {
-    c = *pattern;
-    pattern += 2;
-    if (*pattern == ']') {
-        done = TRUE;
-        break;
-    }
-    if (*pattern == '\\') {
-        pattern++;
-        if (*pattern == '\0') {
-      done = TRUE;
-      break;
-        }
-    }
-    if ((*str < c) || (*str > *pattern)) {
-        pattern++;
-        goto repeat;
-    }
-      } else if (*pattern != *str) {
-    pattern++;
-    goto repeat;
-      }
-      pattern++;
-      while ((*pattern != ']') && (*pattern != '\0')) {
-    if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
-        pattern++;
-    pattern++;
-      }
-      if (*pattern != '\0') {
-    pattern++, str++;
-      }
-      break;
-  case '?':
-      pattern++;
-      str++;
-      break;
-  case OB:
-      pattern++;
-      while ((*pattern != CB) && (*pattern != '\0')) {
-    cp = str;
-    ok = TRUE;
-    while (ok && (*cp != '\0') && (*pattern != '\0')
-    &&  (*pattern != ',') && (*pattern != CB)) {
-        if (*pattern == '\\')
-      pattern++;
-        ok = (*pattern++ == *cp++);
-    }
-    if (*pattern == '\0') {
-        ok = FALSE;
-        done = TRUE;
-        break;
-    } else if (ok) {
-        str = cp;
-        while ((*pattern != CB) && (*pattern != '\0')) {
-      if (*++pattern == '\\') {
-          if (*++pattern == CB)
-        pattern++;
-      }
-        }
-    } else {
-        while (*pattern!=CB && *pattern!=',' && *pattern!='\0') {
-      if (*++pattern == '\\') {
-                            if (*++pattern == CB || *pattern == ',')
-        pattern++;
-      }
-        }
-    }
-    if (*pattern != '\0')
-        pattern++;
-      }
-      break;
-  default:
-      if (*str == *pattern) {
-    str++, pattern++;
-      } else {
-    done = TRUE;
-      }
-  }
+    switch ( encoding )
+    {
+        // although this function is supposed to return an exact match, do do
+        // some mappings here for the most common case of "standard" encoding
+        case wxFONTENCODING_SYSTEM:
+            return DEFAULT_CHARSET;
+
+        case wxFONTENCODING_ISO8859_1:
+        case wxFONTENCODING_ISO8859_15:
+        case wxFONTENCODING_CP1252:
+            return ANSI_CHARSET;
+
+#if !defined(__WXMICROWIN__)
+        // The following four fonts are multi-byte charsets
+        case wxFONTENCODING_CP932:
+            return SHIFTJIS_CHARSET;
+
+        case wxFONTENCODING_CP936:
+            return GB2312_CHARSET;
+
+        case wxFONTENCODING_CP949:
+            return HANGUL_CHARSET;
+
+        case wxFONTENCODING_CP950:
+            return CHINESEBIG5_CHARSET;
+
+        // The rest are single byte encodings
+        case wxFONTENCODING_CP1250:
+            return EASTEUROPE_CHARSET;
+
+        case wxFONTENCODING_CP1251:
+            return RUSSIAN_CHARSET;
+
+        case wxFONTENCODING_CP1253:
+            return GREEK_CHARSET;
+
+        case wxFONTENCODING_CP1254:
+            return TURKISH_CHARSET;
+
+        case wxFONTENCODING_CP1255:
+            return HEBREW_CHARSET;
+
+        case wxFONTENCODING_CP1256:
+            return ARABIC_CHARSET;
+
+        case wxFONTENCODING_CP1257:
+            return BALTIC_CHARSET;
+
+        case wxFONTENCODING_CP874:
+            return THAI_CHARSET;
+#endif // !__WXMICROWIN__
+
+        case wxFONTENCODING_CP437:
+            return OEM_CHARSET;
+
+        default:
+            // no way to translate this encoding into a Windows charset
+            return -1;

     }
     }

-    while (*pattern == '*')
-  pattern++;
-    return ((*str == '\0') && (*pattern == '\0'));
-};
+}

 
 

-#endif
+// we have 2 versions of wxCharsetToCodepage(): the old one which directly
+// looks up the vlaues in the registry and the new one which is more
+// politically correct and has more chances to work on other Windows versions
+// as well but the old version is still needed for !wxUSE_FONTMAP case
+#if wxUSE_FONTMAP
+
+#include "wx/fontmap.h"
+
+extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
+{
+    // There don't seem to be symbolic names for
+    // these under Windows so I just copied the
+    // values from MSDN.

 
 

-#if 0
+    unsigned int ret;

 
 

-// maximum mumber of lines the output console should have
-static const WORD MAX_CONSOLE_LINES = 500;
+    switch (encoding)
+    {
+        case wxFONTENCODING_ISO8859_1:      ret = 28591; break;
+        case wxFONTENCODING_ISO8859_2:      ret = 28592; break;
+        case wxFONTENCODING_ISO8859_3:      ret = 28593; break;
+        case wxFONTENCODING_ISO8859_4:      ret = 28594; break;
+        case wxFONTENCODING_ISO8859_5:      ret = 28595; break;
+        case wxFONTENCODING_ISO8859_6:      ret = 28596; break;
+        case wxFONTENCODING_ISO8859_7:      ret = 28597; break;
+        case wxFONTENCODING_ISO8859_8:      ret = 28598; break;
+        case wxFONTENCODING_ISO8859_9:      ret = 28599; break;
+        case wxFONTENCODING_ISO8859_10:     ret = 28600; break;
+        case wxFONTENCODING_ISO8859_11:     ret = 28601; break;
+        // case wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
+        case wxFONTENCODING_ISO8859_13:     ret = 28603; break;
+        case wxFONTENCODING_ISO8859_14:     ret = 28604; break;
+        case wxFONTENCODING_ISO8859_15:     ret = 28605; break;
+        case wxFONTENCODING_KOI8:           ret = 20866; break;
+        case wxFONTENCODING_KOI8_U:         ret = 21866; break;
+        case wxFONTENCODING_CP437:          ret = 437; break;
+        case wxFONTENCODING_CP850:          ret = 850; break;
+        case wxFONTENCODING_CP852:          ret = 852; break;
+        case wxFONTENCODING_CP855:          ret = 855; break;
+        case wxFONTENCODING_CP866:          ret = 866; break;
+        case wxFONTENCODING_CP874:          ret = 874; break;
+        case wxFONTENCODING_CP932:          ret = 932; break;
+        case wxFONTENCODING_CP936:          ret = 936; break;
+        case wxFONTENCODING_CP949:          ret = 949; break;
+        case wxFONTENCODING_CP950:          ret = 950; break;
+        case wxFONTENCODING_CP1250:         ret = 1250; break;
+        case wxFONTENCODING_CP1251:         ret = 1251; break;
+        case wxFONTENCODING_CP1252:         ret = 1252; break;
+        case wxFONTENCODING_CP1253:         ret = 1253; break;
+        case wxFONTENCODING_CP1254:         ret = 1254; break;
+        case wxFONTENCODING_CP1255:         ret = 1255; break;
+        case wxFONTENCODING_CP1256:         ret = 1256; break;
+        case wxFONTENCODING_CP1257:         ret = 1257; break;
+        case wxFONTENCODING_EUC_JP:         ret = 51932; break;
+        case wxFONTENCODING_MACROMAN:       ret = 10000; break;
+        case wxFONTENCODING_MACJAPANESE:    ret = 10001; break;
+        case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break;
+        case wxFONTENCODING_MACKOREAN:      ret = 10003; break;
+        case wxFONTENCODING_MACARABIC:      ret = 10004; break;
+        case wxFONTENCODING_MACHEBREW:      ret = 10005; break;
+        case wxFONTENCODING_MACGREEK:       ret = 10006; break;
+        case wxFONTENCODING_MACCYRILLIC:    ret = 10007; break;
+        case wxFONTENCODING_MACTHAI:        ret = 10021; break;
+        case wxFONTENCODING_MACCHINESESIMP: ret = 10008; break;
+        case wxFONTENCODING_MACCENTRALEUR:  ret = 10029; break;
+        case wxFONTENCODING_MACCROATIAN:    ret = 10082; break;
+        case wxFONTENCODING_MACICELANDIC:   ret = 10079; break;
+        case wxFONTENCODING_MACROMANIAN:    ret = 10009; break;
+        case wxFONTENCODING_UTF7:           ret = 65000; break;
+        case wxFONTENCODING_UTF8:           ret = 65001; break;
+        default:                            return -1;
+    }
+
+    if (::IsValidCodePage(ret) == 0)
+        return -1;

 
 

-BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) {   //  control signal type
-  FreeConsole();
-  return TRUE;
+    CPINFO info;
+    if (::GetCPInfo(ret, &info) == 0)
+        return -1;
+
+    return (long) ret;

 }
 
 }
 

-void wxRedirectIOToConsole()
+extern long wxCharsetToCodepage(const wxChar *name)

 {
 {

-    int                        hConHandle;
-    long                       lStdHandle;
-    CONSOLE_SCREEN_BUFFER_INFO coninfo;
-    FILE                       *fp;
-
-    // allocate a console for this app
-    AllocConsole();
-
-    // set the screen buffer to be big enough to let us scroll text
-    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
-                               &coninfo);
-    coninfo.dwSize.Y = MAX_CONSOLE_LINES;
-    SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE),
-                               coninfo.dwSize);
-
-    // redirect unbuffered STDOUT to the console
-    lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
-    hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
-    if(hConHandle <= 0) return;
-    fp = _fdopen( hConHandle, "w" );
-    *stdout = *fp;
-    setvbuf( stdout, NULL, _IONBF, 0 );
-
-    // redirect unbuffered STDIN to the console
-    lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
-    hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
-    if(hConHandle <= 0) return;
-    fp = _fdopen( hConHandle, "r" );
-    *stdin = *fp;
-    setvbuf( stdin, NULL, _IONBF, 0 );
-
-    // redirect unbuffered STDERR to the console
-    lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
-    hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
-    if(hConHandle <= 0) return;
-    fp = _fdopen( hConHandle, "w" );
-    *stderr = *fp;
-    setvbuf( stderr, NULL, _IONBF, 0 );
-
-    // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
-    // point to console as well
-    ios::sync_with_stdio();
-
-    SetConsoleCtrlHandler(MyConsoleHandler, TRUE);
+    // first get the font encoding for this charset
+    if ( !name )
+        return -1;
+
+    wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);
+    if ( enc == wxFONTENCODING_SYSTEM )
+        return -1;
+
+    // the use the helper function
+    return wxEncodingToCodepage(enc);

 }
 }

-#else
-// Not supported
-void wxRedirectIOToConsole()
+
+#else // !wxUSE_FONTMAP
+
+#include "wx/msw/registry.h"
+
+// this should work if Internet Exploiter is installed
+extern long wxCharsetToCodepage(const wxChar *name)

 {
 {

+    if (!name)
+        return GetACP();
+
+    long CP = -1;
+
+    wxString path(wxT("MIME\\Database\\Charset\\"));
+    wxString cn(name);
+
+    // follow the alias loop
+    for ( ;; )
+    {
+        wxRegKey key(wxRegKey::HKCR, path + cn);
+
+        if (!key.Exists())
+            break;
+
+        // two cases: either there's an AliasForCharset string,
+        // or there are Codepage and InternetEncoding dwords.
+        // The InternetEncoding gives us the actual encoding,
+        // the Codepage just says which Windows character set to
+        // use when displaying the data.
+        if (key.HasValue(wxT("InternetEncoding")) &&
+            key.QueryValue(wxT("InternetEncoding"), &CP))
+            break;
+
+        // no encoding, see if it's an alias
+        if (!key.HasValue(wxT("AliasForCharset")) ||
+            !key.QueryValue(wxT("AliasForCharset"), cn))
+            break;
+    }
+
+    return CP;

 }
 }

-#endif

 
 

+#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
+
+/*
+  Creates a hidden window with supplied window proc registering the class for
+  it if necesssary (i.e. the first time only). Caller is responsible for
+  destroying the window and unregistering the class (note that this must be
+  done because wxWidgets may be used as a DLL and so may be loaded/unloaded
+  multiple times into/from the same process so we cna't rely on automatic
+  Windows class unregistration).
+
+  pclassname is a pointer to a caller stored classname, which must initially be
+  NULL. classname is the desired wndclass classname. If function succesfully
+  registers the class, pclassname will be set to classname.
+ */
+extern "C" WXDLLIMPEXP_BASE HWND
+wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
+{
+    wxCHECK_MSG( classname && pclassname && wndproc, NULL,
+                    _T("NULL parameter in wxCreateHiddenWindow") );
+
+    // register the class fi we need to first
+    if ( *pclassname == NULL )
+    {
+        WNDCLASS wndclass;
+        wxZeroMemory(wndclass);
+
+        wndclass.lpfnWndProc   = wndproc;
+        wndclass.hInstance     = wxGetInstance();
+        wndclass.lpszClassName = classname;
+
+        if ( !::RegisterClass(&wndclass) )
+        {
+            wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
+
+            return NULL;
+        }
+
+        *pclassname = classname;
+    }
+
+    // next create the window
+    HWND hwnd = ::CreateWindow
+                  (
+                    *pclassname,
+                    NULL,
+                    0, 0, 0, 0,
+                    0,
+                    (HWND) NULL,
+                    (HMENU)NULL,
+                    wxGetInstance(),
+                    (LPVOID) NULL
+                  );
+
+    if ( !hwnd )
+    {
+        wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
+    }
+
+    return hwnd;
+}