Rework the wxCusor ctor taking wx stock number to provide as many cursors as

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

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index 7da8065ba3b4c1b7ff1c99ab6279fe40a33c0575..c0efa166b7e964f6134be6bf0dade8abfa83db23 100644 (file)
--- a/src/msw/utils.cpp
+++ b/src/msw/utils.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

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

 // Purpose:     Various utilities
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     Various utilities
 // Author:      Julian Smart
 // Modified by:


@@ -31,23 +31,30 @@
     #include "wx/log.h"
 #endif  //WX_PRECOMP
 
     #include "wx/log.h"
 #endif  //WX_PRECOMP
 

+#include "wx/msw/registry.h"

 #include "wx/apptrait.h"
 #include "wx/apptrait.h"

+#include "wx/dynlib.h"

 #include "wx/dynload.h"
 #include "wx/dynload.h"

+#include "wx/scopeguard.h"

 
 #include "wx/confbase.h"        // for wxExpandEnvVars()
 
 #include "wx/msw/private.h"     // includes <windows.h>
 
 #include "wx/confbase.h"        // for wxExpandEnvVars()
 
 #include "wx/msw/private.h"     // includes <windows.h>

-#include "wx/msw/missing.h"     // CHARSET_HANGUL
+#include "wx/msw/missing.h"     // for 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

 
 

-#if defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) \
-    || defined(__CYGWIN32__)
+// 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
 
     // 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 "wx/timer.h"
-

 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     #include <direct.h>
 
 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     #include <direct.h>
 


@@ -94,24 +101,21 @@
     #endif
 #endif
 
     #endif
 #endif
 

-// 260 was taken from windef.h
-#ifndef MAX_PATH
-    #define MAX_PATH  260
-#endif
+// For wxKillAllChildren
+#include <tlhelp32.h>

 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // In the WIN.INI file
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // In the WIN.INI file

+#if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)

 static const wxChar WX_SECTION[] = wxT("wxWindows");
 static const wxChar WX_SECTION[] = wxT("wxWindows");

-static const wxChar eUSERNAME[]  = wxT("UserName");
+#endif

 
 

-// these are only used under Win16
-#if !defined(__WIN32__) && !defined(__WXMICROWIN__)
-static const wxChar eHOSTNAME[]  = wxT("HostName");
-static const wxChar eUSERID[]    = wxT("UserId");
-#endif // !Win32
+#if (!defined(USE_NET_API) && !defined(__WXWINCE__))
+static const wxChar eUSERNAME[]  = wxT("UserName");
+#endif

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -122,20 +126,22 @@ static const wxChar eUSERID[]    = wxT("UserId");
 // ----------------------------------------------------------------------------
 
 // Get hostname only (without domain name)
 // ----------------------------------------------------------------------------
 
 // Get hostname only (without domain name)

-bool wxGetHostName(wxChar *buf, int maxSize)
+bool wxGetHostName(wxChar *WXUNUSED_IN_WINCE(buf),
+                   int WXUNUSED_IN_WINCE(maxSize))

 {
 #if defined(__WXWINCE__)
 {
 #if defined(__WXWINCE__)

-    return FALSE;
+    // TODO-CE
+    return false;

 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
     DWORD nSize = maxSize;
     if ( !::GetComputerName(buf, &nSize) )
     {
         wxLogLastError(wxT("GetComputerName"));
 
 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
     DWORD nSize = maxSize;
     if ( !::GetComputerName(buf, &nSize) )
     {
         wxLogLastError(wxT("GetComputerName"));
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 #else
     wxChar *sysname;
     const wxChar *default_host = wxT("noname");
 #else
     wxChar *sysname;
     const wxChar *default_host = wxT("noname");


@@ -145,18 +151,21 @@ bool wxGetHostName(wxChar *buf, int maxSize)
     } else
         wxStrncpy(buf, sysname, maxSize - 1);
     buf[maxSize] = wxT('\0');
     } else
         wxStrncpy(buf, sysname, maxSize - 1);
     buf[maxSize] = wxT('\0');

-    return *buf ? TRUE : FALSE;
+    return *buf ? true : false;

 #endif
 }
 
 // get full hostname (with domain name if possible)
 bool wxGetFullHostName(wxChar *buf, int maxSize)
 {
 #endif
 }
 
 // get full hostname (with domain name if possible)
 bool wxGetFullHostName(wxChar *buf, int maxSize)
 {

-#if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER
+#if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER && wxUSE_SOCKETS

     // TODO should use GetComputerNameEx() when available
 
     // we don't want to always link with Winsock DLL as we might not use it at
     // TODO should use GetComputerNameEx() when available
 
     // 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
+    // all, so load it dynamically here if needed (and don't complain if it is
+    // missing, we handle this)
+    wxLogNull noLog;
+

     wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
     if ( dllWinsock.IsLoaded() )
     {
     wxDynamicLibrary dllWinsock(_T("ws2_32.dll"), wxDL_VERBATIM);
     if ( dllWinsock.IsLoaded() )
     {


@@ -221,7 +230,7 @@ bool wxGetFullHostName(wxChar *buf, int maxSize)
             {
                 wxStrncpy(buf, host, maxSize);
 
             {
                 wxStrncpy(buf, host, maxSize);
 

-                return TRUE;
+                return true;

             }
         }
     }
             }
         }
     }


@@ -231,11 +240,13 @@ bool wxGetFullHostName(wxChar *buf, int maxSize)
 }
 
 // Get user ID e.g. jacs
 }
 
 // Get user ID e.g. jacs

-bool wxGetUserId(wxChar *buf, int maxSize)
+bool wxGetUserId(wxChar *WXUNUSED_IN_WINCE(buf),
+                 int WXUNUSED_IN_WINCE(maxSize))

 {
 #if defined(__WXWINCE__)
 {
 #if defined(__WXWINCE__)

-    return FALSE;
-#elif defined(__WIN32__) && !defined(__win32s__) && !defined(__WXMICROWIN__)
+    // TODO-CE
+    return false;
+#elif defined(__WIN32__) && !defined(__WXMICROWIN__)

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


@@ -244,21 +255,21 @@ 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
+    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 ...
     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 )
+    if ( (user = wxGetenv(wxT("USER"))) == NULL &&
+         (user = wxGetenv(wxT("LOGNAME"))) == NULL )

     {
     {

-        // Use wxWindows configuration data (comming soon)
+        // Use wxWidgets configuration data (comming soon)

         GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
     }
     else
         GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
     }
     else


@@ -266,19 +277,30 @@ bool wxGetUserId(wxChar *buf, int maxSize)
         wxStrncpy(buf, user, maxSize - 1);
     }
 
         wxStrncpy(buf, user, maxSize - 1);
     }
 

-    return *buf ? TRUE : FALSE;
+    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)
 {

+    wxCHECK_MSG( buf && ( maxSize > 0 ), false,
+                    _T("empty buffer in wxGetUserName") );

 #if defined(__WXWINCE__)
 #if defined(__WXWINCE__)

-    return FALSE;
+    wxLogNull noLog;
+    wxRegKey key(wxRegKey::HKCU, wxT("ControlPanel\\Owner"));
+    if(!key.Open(wxRegKey::Read))
+        return false;
+    wxString name;
+    if(!key.QueryValue(wxT("Owner"),name))
+        return false;
+    wxStrncpy(buf, name.c_str(), maxSize-1);
+    buf[maxSize-1] = _T('\0');
+    return true;

 #elif defined(USE_NET_API)
     CHAR szUserName[256];
     if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
 #elif defined(USE_NET_API)
     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 = "";


@@ -335,15 +357,15 @@ bool wxGetUserName(wxChar *buf, int maxSize)
     WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
             buf, maxSize, NULL, NULL );
 
     WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
             buf, maxSize, NULL, NULL );
 

-    return TRUE;
+    return true;

 
 error:
     wxLogError(wxT("Couldn't look up full user name."));
 
 
 error:
     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
+    // Use wxWidgets configuration data

     bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
     if ( !ok )
     {
     bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
     if ( !ok )
     {


@@ -354,9 +376,9 @@ error:
     {
         wxStrncpy(buf, wxT("Unknown User"), maxSize);
     }
     {
         wxStrncpy(buf, wxT("Unknown User"), maxSize);
     }

-#endif // Win32/16

 
 

-    return TRUE;
+    return true;
+#endif // Win32/16

 }
 
 const wxChar* wxGetHomeDir(wxString *pstr)
 }
 
 const wxChar* wxGetHomeDir(wxString *pstr)


@@ -364,7 +386,7 @@ const wxChar* wxGetHomeDir(wxString *pstr)
     wxString& strDir = *pstr;
 
     // first branch is for Cygwin
     wxString& strDir = *pstr;
 
     // first branch is for Cygwin

-#if defined(__UNIX__)
+#if defined(__UNIX__) && !defined(__WINE__)

     const wxChar *szHome = wxGetenv("HOME");
     if ( szHome == NULL ) {
       // we're homeless...
     const wxChar *szHome = wxGetenv("HOME");
     if ( szHome == NULL ) {
       // we're homeless...


@@ -385,7 +407,7 @@ const wxChar* wxGetHomeDir(wxString *pstr)
         strDir = windowsPath;
     #endif
 #elif defined(__WXWINCE__)
         strDir = windowsPath;
     #endif
 #elif defined(__WXWINCE__)

-      // Nothing
+    strDir = wxT("\\");

 #else
     strDir.clear();
 
 #else
     strDir.clear();
 


@@ -437,12 +459,8 @@ const wxChar* wxGetHomeDir(wxString *pstr)
     }
     else // fall back to the program directory
     {
     }
     else // fall back to the program directory
     {

-        wxString strPath;
-        ::GetModuleFileName(::GetModuleHandle(NULL),
-                            wxStringBuffer(strPath, MAX_PATH), MAX_PATH);
-
-        // extract the dir name
-        wxSplitPath(strPath, &strDir, NULL, NULL);
+        // extract the directory component of the program file name
+        wxSplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);

     }
 #endif  // UNIX/Win
 
     }
 #endif  // UNIX/Win
 


@@ -459,39 +477,16 @@ wxChar *wxGetUserHome(const wxString& WXUNUSED(user))
     return (wxChar *)wxGetHomeDir(&s_home);
 }
 
     return (wxChar *)wxGetHomeDir(&s_home);
 }
 

-bool wxDirExists(const wxString& dir)
-{
-#ifdef __WXMICROWIN__
-    return wxPathExist(dir);
-#elif defined(__WIN32__)
-    DWORD attribs = GetFileAttributes(dir);
-    return ((attribs != (DWORD)-1) && (attribs & FILE_ATTRIBUTE_DIRECTORY));
-#else // Win16
-    #ifdef __BORLANDC__
-        struct ffblk fileInfo;
-    #else
-        struct find_t fileInfo;
-    #endif
-    // 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(dir, &fileInfo, _A_SUBDIR) == 0 &&
-               (fileInfo.ff_attrib & _A_SUBDIR) != 0);
-    #else
-        return (_dos_findfirst(dir, _A_SUBDIR, &fileInfo) == 0) &&
-               ((fileInfo.attrib & _A_SUBDIR) != 0);
-    #endif
-#endif // Win32/16
-}
-
-bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
+bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))

 {
 #ifdef __WXWINCE__
 {
 #ifdef __WXWINCE__

-    return FALSE;
+    // TODO-CE
+    return false;

 #else
     if ( path.empty() )
 #else
     if ( path.empty() )

-        return FALSE;
+        return false;

 
 // old w32api don't have ULARGE_INTEGER
 #if defined(__WIN32__) && \
 
 // old w32api don't have ULARGE_INTEGER
 #if defined(__WIN32__) && \


@@ -519,14 +514,14 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
         ULARGE_INTEGER bytesFree, bytesTotal;
 
         // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
         ULARGE_INTEGER bytesFree, bytesTotal;
 
         // may pass the path as is, GetDiskFreeSpaceEx() is smart enough

-        if ( !pGetDiskFreeSpaceEx(path,
+        if ( !pGetDiskFreeSpaceEx(path.fn_str(),

                                   &bytesFree,
                                   &bytesTotal,
                                   NULL) )
         {
             wxLogLastError(_T("GetDiskFreeSpaceEx"));
 
                                   &bytesFree,
                                   &bytesTotal,
                                   NULL) )
         {
             wxLogLastError(_T("GetDiskFreeSpaceEx"));
 

-            return FALSE;
+            return false;

         }
 
         // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
         }
 
         // ULARGE_INTEGER is a union of a 64 bit value and a struct containing


@@ -539,12 +534,20 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 #endif
         if ( pTotal )
         {
 #endif
         if ( pTotal )
         {

-            *pTotal = wxLongLong(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
+#if wxUSE_LONGLONG
+            *pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
+#else
+            *pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
+#endif

         }
 
         if ( pFree )
         {
         }
 
         if ( pFree )
         {

+#if wxUSE_LONGLONG

             *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
             *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);

+#else
+            *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
+#endif

         }
     }
     else
         }
     }
     else


@@ -561,7 +564,7 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 
         // FIXME: this is wrong, we should extract the root drive from path
         //        instead, but this is the job for wxFileName...
 
         // FIXME: this is wrong, we should extract the root drive from path
         //        instead, but this is the job for wxFileName...

-        if ( !::GetDiskFreeSpace(path,
+        if ( !::GetDiskFreeSpace(path.fn_str(),

                                  &lSectorsPerCluster,
                                  &lBytesPerSector,
                                  &lNumberOfFreeClusters,
                                  &lSectorsPerCluster,
                                  &lBytesPerSector,
                                  &lNumberOfFreeClusters,


@@ -569,10 +572,10 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
         {
             wxLogLastError(_T("GetDiskFreeSpace"));
 
         {
             wxLogLastError(_T("GetDiskFreeSpace"));
 

-            return FALSE;
+            return false;

         }
 
         }
 

-        wxLongLong lBytesPerCluster = lSectorsPerCluster;
+        wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;

         lBytesPerCluster *= lBytesPerSector;
 
         if ( pTotal )
         lBytesPerCluster *= lBytesPerSector;
 
         if ( pTotal )


@@ -588,7 +591,7 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

 #endif
     // __WXWINCE__
 }
 #endif
     // __WXWINCE__
 }


@@ -597,58 +600,62 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 // env vars
 // ----------------------------------------------------------------------------
 
 // env vars
 // ----------------------------------------------------------------------------
 

-bool wxGetEnv(const wxString& var, wxString *value)
+bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var),
+              wxString *WXUNUSED_IN_WINCE(value))

 {
 #ifdef __WXWINCE__
 {
 #ifdef __WXWINCE__

-    return FALSE;
-#elif defined(__WIN16__)
-    const wxChar* ret = wxGetenv(var);
-    if ( !ret )
-        return FALSE;
-
-    if ( value )
-    {
-        *value = ret;
-    }
-
-    return TRUE;
+    // no environment variables under CE
+    return false;

 #else // Win32
     // first get the size of the buffer
 #else // Win32
     // first get the size of the buffer

-    DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
+    DWORD dwRet = ::GetEnvironmentVariable(var.wx_str(), NULL, 0);

     if ( !dwRet )
     {
         // this means that there is no such variable
     if ( !dwRet )
     {
         // this means that there is no such variable

-        return FALSE;
+        return false;

     }
 
     if ( value )
     {
     }
 
     if ( value )
     {

-        (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
+        (void)::GetEnvironmentVariable(var.wx_str(),
+                                       wxStringBuffer(*value, dwRet),

                                        dwRet);
     }
 
                                        dwRet);
     }
 

-    return TRUE;
-#endif // Win16/32
+    return true;
+#endif // WinCE/32

 }
 
 }
 

-bool wxSetEnv(const wxString& var, const wxChar *value)
+bool wxDoSetEnv(const wxString& WXUNUSED_IN_WINCE(var),
+                const wxChar *WXUNUSED_IN_WINCE(value))

 {
     // some compilers have putenv() or _putenv() or _wputenv() but it's better
     // to always use Win32 function directly instead of dealing with them
 {
     // 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) )
+#ifdef __WXWINCE__
+    // no environment variables under CE
+    return false;
+#else
+    if ( !::SetEnvironmentVariable(var.wx_str(), value) )

     {
         wxLogLastError(_T("SetEnvironmentVariable"));
 
     {
         wxLogLastError(_T("SetEnvironmentVariable"));
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
-#else // no way to set env vars
-    return FALSE;
+    return true;

 #endif
 }
 
 #endif
 }
 

+bool wxSetEnv(const wxString& variable, const wxString& value)
+{
+    return wxDoSetEnv(variable, value.wx_str());
+}
+
+bool wxUnsetEnv(const wxString& variable)
+{
+    return wxDoSetEnv(variable, NULL);
+}
+

 // ----------------------------------------------------------------------------
 // process management
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // process management
 // ----------------------------------------------------------------------------


@@ -688,8 +695,13 @@ BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)
     return TRUE;
 }
 
     return TRUE;
 }
 

-int wxKill(long pid, wxSignal sig, wxKillError *krc)
+int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc);
+
+int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)

 {
 {

+    if (flags & wxKILL_CHILDREN)
+        wxKillAllChildren(pid, sig, krc);
+

     // get the process handle to operate on
     HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
                                     PROCESS_TERMINATE |
     // get the process handle to operate on
     HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
                                     PROCESS_TERMINATE |


@@ -700,20 +712,20 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
     {
         if ( krc )
         {
     {
         if ( krc )
         {

-            if ( ::GetLastError() == ERROR_ACCESS_DENIED )
-            {
-                *krc = wxKILL_ACCESS_DENIED;
-            }
-            else
-            {
-                *krc = wxKILL_NO_PROCESS;
-            }
+            // recognize wxKILL_ACCESS_DENIED as special because this doesn't
+            // mean that the process doesn't exist and this is important for
+            // wxProcess::Exists()
+            *krc = ::GetLastError() == ERROR_ACCESS_DENIED
+                        ? wxKILL_ACCESS_DENIED
+                        : wxKILL_NO_PROCESS;

         }
 
         return -1;
     }
 
         }
 
         return -1;
     }
 

-    bool ok = TRUE;
+    wxON_BLOCK_EXIT1(::CloseHandle, hProcess);
+
+    bool ok = true;

     switch ( sig )
     {
         case wxSIGKILL:
     switch ( sig )
     {
         case wxSIGKILL:


@@ -729,13 +741,15 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                     *krc = wxKILL_ERROR;
                 }
 
                     *krc = wxKILL_ERROR;
                 }
 

-                ok = FALSE;
+                ok = false;

             }
             break;
 
         case wxSIGNONE:
             // do nothing, we just want to test for process existence
             }
             break;
 
         case wxSIGNONE:
             // do nothing, we just want to test for process existence

-            break;
+            if ( krc )
+                *krc = wxKILL_OK;
+            return 0;

 
         default:
             // any other signal means "terminate"
 
         default:
             // any other signal means "terminate"


@@ -744,7 +758,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                 params.pid = (DWORD)pid;
 
                 // EnumWindows() has nice semantics: it returns 0 if it found
                 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
+                // something or if an error occurred and non zero if it

                 // enumerated all the window
                 if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
                 {
                 // enumerated all the window
                 if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
                 {


@@ -753,7 +767,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                     {
                         // tell the app to close
                         //
                     {
                         // tell the app to close
                         //

-                        // NB: this is the harshest way, the app won't have
+                        // NB: this is the harshest way, the app won't have an

                         //     opportunity to save any files, for example, but
                         //     this is probably what we want here. If not we
                         //     can also use SendMesageTimeout(WM_CLOSE)
                         //     opportunity to save any files, for example, but
                         //     this is probably what we want here. If not we
                         //     can also use SendMesageTimeout(WM_CLOSE)


@@ -766,24 +780,21 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                     {
                         wxLogLastError(_T("EnumWindows"));
 
                     {
                         wxLogLastError(_T("EnumWindows"));
 

-                        ok = FALSE;
+                        ok = false;

                     }
                 }
                 else // no windows for this PID
                 {
                     if ( krc )
                     }
                 }
                 else // no windows for this PID
                 {
                     if ( krc )

-                    {

                         *krc = wxKILL_ERROR;
                         *krc = wxKILL_ERROR;

-                    }

 
 

-                    ok = FALSE;
+                    ok = false;

                 }
             }
     }
 
     // the return code
                 }
             }
     }
 
     // the return code

-    DWORD rc;
-
+    DWORD rc wxDUMMY_INITIALIZE(0);

     if ( ok )
     {
         // as we wait for a short time, we can use just WaitForSingleObject()
     if ( ok )
     {
         // as we wait for a short time, we can use just WaitForSingleObject()


@@ -808,53 +819,124 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
 
             case WAIT_TIMEOUT:
                 if ( krc )
 
             case WAIT_TIMEOUT:
                 if ( krc )

-                {

                     *krc = wxKILL_ERROR;
                     *krc = wxKILL_ERROR;

-                }

 
                 rc = STILL_ACTIVE;
                 break;
         }
     }
 
                 rc = STILL_ACTIVE;
                 break;
         }
     }

-    else // !ok
-    {
-        // just to suppress the warnings about uninitialized variable
-        rc = 0;
-    }

 
 

-    ::CloseHandle(hProcess);

 
     // the return code is the same as from Unix kill(): 0 if killed
     // successfully or -1 on error
 
     // 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)) )
-    {
-        if ( krc )
-        {
-            *krc = wxKILL_OK;
-        }
+    if ( !ok || rc == STILL_ACTIVE )
+        return -1;
+
+    if ( krc )
+        *krc = wxKILL_OK;
+
+    return 0;
+}

 
 

+typedef HANDLE (WINAPI *CreateToolhelp32Snapshot_t)(DWORD,DWORD);
+typedef BOOL (WINAPI *Process32_t)(HANDLE,LPPROCESSENTRY32);
+
+CreateToolhelp32Snapshot_t lpfCreateToolhelp32Snapshot;
+Process32_t lpfProcess32First, lpfProcess32Next;
+
+static void InitToolHelp32()
+{
+    static bool s_initToolHelpDone = false;
+
+    if (s_initToolHelpDone)
+        return;
+
+    s_initToolHelpDone = true;
+
+    lpfCreateToolhelp32Snapshot = NULL;
+    lpfProcess32First = NULL;
+    lpfProcess32Next = NULL;
+
+#if wxUSE_DYNLIB_CLASS
+
+    wxDynamicLibrary dllKernel(_T("kernel32.dll"), wxDL_VERBATIM);
+
+    // 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 =
+        (CreateToolhelp32Snapshot_t)dllKernel.RawGetSymbol(_T("CreateToolhelp32Snapshot"));
+
+    lpfProcess32First =
+        (Process32_t)dllKernel.RawGetSymbol(_T("Process32First"));
+
+    lpfProcess32Next =
+        (Process32_t)dllKernel.RawGetSymbol(_T("Process32Next"));
+
+#endif // wxUSE_DYNLIB_CLASS
+}
+
+// By John Skiff
+int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc)
+{
+    InitToolHelp32();
+
+    if (krc)
+        *krc = wxKILL_OK;
+
+    // If not implemented for this platform (e.g. NT 4.0), silently ignore
+    if (!lpfCreateToolhelp32Snapshot || !lpfProcess32First || !lpfProcess32Next)

         return 0;
         return 0;

+
+    // 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;

     }
 
     }
 

-    // 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;
+    }
+
+    do {
+        if (pe.th32ParentProcessID == (DWORD) pid) {
+            if (wxKill(pe.th32ProcessID, sig, krc))
+                return -1;
+        }
+    } while (lpfProcess32Next (hProcessSnap, &pe));
+
+
+    return 0;

 }
 
 // Execute a program in an Interactive Shell
 bool wxShell(const wxString& command)
 {
 }
 
 // Execute a program in an Interactive Shell
 bool wxShell(const wxString& command)
 {

+    wxString cmd;
+

 #ifdef __WXWINCE__
 #ifdef __WXWINCE__

-    return FALSE;
+    cmd = command;

 #else
     wxChar *shell = wxGetenv(wxT("COMSPEC"));
     if ( !shell )
         shell = (wxChar*) wxT("\\COMMAND.COM");
 
 #else
     wxChar *shell = wxGetenv(wxT("COMSPEC"));
     if ( !shell )
         shell = (wxChar*) wxT("\\COMMAND.COM");
 

-    wxString cmd;

     if ( !command )
     {
         // just the shell
     if ( !command )
     {
         // just the shell


@@ -865,20 +947,21 @@ bool wxShell(const wxString& command)
         // pass the command to execute to the command processor
         cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
     }
         // pass the command to execute to the command processor
         cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
     }

+#endif

 
     return wxExecute(cmd, wxEXEC_SYNC) == 0;
 
     return wxExecute(cmd, wxEXEC_SYNC) == 0;

-#endif

 }
 
 // Shutdown or reboot the PC
 }
 
 // Shutdown or reboot the PC

-bool wxShutdown(wxShutdownFlags wFlags)
+bool wxShutdown(wxShutdownFlags WXUNUSED_IN_WINCE(wFlags))

 {
 #ifdef __WXWINCE__
 {
 #ifdef __WXWINCE__

-    return FALSE;
+    // TODO-CE
+    return false;

 #elif defined(__WIN32__)
 #elif defined(__WIN32__)

-    bool bOK = TRUE;
+    bool bOK = true;

 
 

-    if ( wxGetOsVersion(NULL, NULL) == wxWINDOWS_NT ) // if is NT or 2K
+    if ( wxGetOsVersion(NULL, NULL) == wxOS_WINDOWS_NT ) // if is NT or 2K

     {
         // Get a token for this process.
         HANDLE hToken;
     {
         // Get a token for this process.
         HANDLE hToken;


@@ -920,15 +1003,13 @@ bool wxShutdown(wxShutdownFlags wFlags)
 
             default:
                 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
 
             default:
                 wxFAIL_MSG( _T("unknown wxShutdown() flag") );

-                return FALSE;
+                return false;

         }
 
         bOK = ::ExitWindowsEx(flags, 0) != 0;
     }
 
     return bOK;
         }
 
         bOK = ::ExitWindowsEx(flags, 0) != 0;
     }
 
     return bOK;

-#else // Win16
-    return FALSE;

 #endif // Win32/16
 }
 
 #endif // Win32/16
 }
 


@@ -937,25 +1018,24 @@ bool wxShutdown(wxShutdownFlags wFlags)
 // ----------------------------------------------------------------------------
 
 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
 // ----------------------------------------------------------------------------
 
 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)

-long wxGetFreeMemory()
+wxMemorySize wxGetFreeMemory()

 {
 {

-#if defined(__WIN32__) && !defined(__BORLANDC__)
+#if defined(__WIN64__)
+    MEMORYSTATUSEX memStatex;
+    memStatex.dwLength = sizeof (memStatex);
+    ::GlobalMemoryStatusEx (&memStatex);
+    return (wxMemorySize)memStatex.ullAvailPhys;
+#else /* if defined(__WIN32__) */

     MEMORYSTATUS memStatus;
     memStatus.dwLength = sizeof(MEMORYSTATUS);
     MEMORYSTATUS memStatus;
     memStatus.dwLength = sizeof(MEMORYSTATUS);

-    GlobalMemoryStatus(&memStatus);
-    return memStatus.dwAvailPhys;
-#else
-    return (long)GetFreeSpace(0);
+    ::GlobalMemoryStatus(&memStatus);
+    return (wxMemorySize)memStatus.dwAvailPhys;

 #endif
 }
 
 unsigned long wxGetProcessId()
 {
 #endif
 }
 
 unsigned long wxGetProcessId()
 {

-#ifdef __WIN32__

     return ::GetCurrentProcessId();
     return ::GetCurrentProcessId();

-#else
-    return 0;
-#endif

 }
 
 // Emit a beeeeeep
 }
 
 // Emit a beeeeeep


@@ -964,9 +1044,31 @@ void wxBell()
     ::MessageBeep((UINT)-1);        // default sound
 }
 
     ::MessageBeep((UINT)-1);        // default sound
 }
 

+bool wxIsDebuggerRunning()
+{
+#if wxUSE_DYNLIB_CLASS
+    // IsDebuggerPresent() is not available under Win95, so load it dynamically
+    wxDynamicLibrary dll(_T("kernel32.dll"), wxDL_VERBATIM);
+
+    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;
+#else
+    return false;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// OS version
+// ----------------------------------------------------------------------------
+

 wxString wxGetOsDescription()
 {
 wxString wxGetOsDescription()
 {

-#ifdef __WIN32__

     wxString str;
 
     OSVERSIONINFO info;
     wxString str;
 
     OSVERSIONINFO info;


@@ -977,13 +1079,51 @@ wxString wxGetOsDescription()
     {
         switch ( info.dwPlatformId )
         {
     {
         switch ( info.dwPlatformId )
         {

+#ifdef VER_PLATFORM_WIN32_CE
+            case VER_PLATFORM_WIN32_CE:
+                str.Printf(_("Windows CE (%d.%d)"),
+                           info.dwMajorVersion,
+                           info.dwMinorVersion);
+                break;
+#endif

             case VER_PLATFORM_WIN32s:
                 str = _("Win32s on Windows 3.1");
                 break;
 
             case VER_PLATFORM_WIN32_WINDOWS:
             case VER_PLATFORM_WIN32s:
                 str = _("Win32s on Windows 3.1");
                 break;
 
             case VER_PLATFORM_WIN32_WINDOWS:

-                str.Printf(_("Windows 9%c"),
-                           info.dwMinorVersion == 0 ? _T('5') : _T('8'));
+                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(')');
                 if ( !wxIsEmpty(info.szCSDVersion) )
                 {
                     str << _T(" (") << info.szCSDVersion << _T(')');


@@ -991,10 +1131,31 @@ wxString wxGetOsDescription()
                 break;
 
             case VER_PLATFORM_WIN32_NT:
                 break;
 
             case VER_PLATFORM_WIN32_NT:

-                str.Printf(_T("Windows NT %lu.%lu (build %lu"),
+                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 ( str.empty() )
+                {
+                    str.Printf(_("Windows NT %lu.%lu (build %lu"),

                            info.dwMajorVersion,
                            info.dwMinorVersion,
                            info.dwBuildNumber);
                            info.dwMajorVersion,
                            info.dwMinorVersion,
                            info.dwBuildNumber);

+                }

                 if ( !wxIsEmpty(info.szCSDVersion) )
                 {
                     str << _T(", ") << info.szCSDVersion;
                 if ( !wxIsEmpty(info.szCSDVersion) )
                 {
                     str << _T(", ") << info.szCSDVersion;


@@ -1009,75 +1170,137 @@ wxString wxGetOsDescription()
     }
 
     return str;
     }
 
     return str;

-#else // Win16
-    return _("Windows 3.1");
-#endif // Win32/16

 }
 
 }
 

-wxToolkitInfo& wxAppTraits::GetToolkitInfo()
+bool wxIsPlatform64Bit()

 {
 {

-    // 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 )
+#if defined(_WIN64)
+    return true;  // 64-bit programs run only on Win64
+#else // Win32
+    // 32-bit programs run on both 32-bit and 64-bit Windows so check
+    typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *);
+
+    wxDynamicLibrary dllKernel32(_T("kernel32.dll"));
+    IsWow64Process_t pfnIsWow64Process =
+        (IsWow64Process_t)dllKernel32.RawGetSymbol(_T("IsWow64Process"));
+
+    BOOL wow64 = FALSE;
+    if ( pfnIsWow64Process )

     {
     {

-        OSVERSIONINFO info;
-        wxZeroMemory(info);
+        pfnIsWow64Process(::GetCurrentProcess(), &wow64);
+    }
+    //else: running under a system without Win64 support

 
 

-        s_ver = wxWINDOWS;
-        info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-        if ( ::GetVersionEx(&info) )
-        {
-            s_major = info.dwMajorVersion;
-            s_minor = info.dwMinorVersion;
+    return wow64 != FALSE;
+#endif // Win64/Win32
+}

 
 

-            switch ( info.dwPlatformId )
+wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
+{
+    OSVERSIONINFO info;
+    wxZeroMemory(info);
+
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    if ( ::GetVersionEx(&info) )
+    {
+        if (verMaj) *verMaj = info.dwMajorVersion;
+        if (verMin) *verMin = info.dwMinorVersion;
+    }
+
+#if defined( __WXWINCE__ )
+    return wxOS_WINDOWS_CE;
+#elif defined( __WXMICROWIN__ )
+    return wxOS_WINDOWS_MICRO;
+#else
+    switch ( info.dwPlatformId )
+    {
+    case VER_PLATFORM_WIN32_NT:
+        return wxOS_WINDOWS_NT;
+
+    case VER_PLATFORM_WIN32_WINDOWS:
+        return wxOS_WINDOWS_9X;
+    }
+
+    return wxOS_UNKNOWN;
+#endif
+}
+
+wxWinVersion wxGetWinVersion()
+{
+    int verMaj,
+        verMin;
+    switch ( wxGetOsVersion(&verMaj, &verMin) )
+    {
+        case wxOS_WINDOWS_9X:
+            if ( verMaj == 4 )

             {
             {

-                case VER_PLATFORM_WIN32s:
-                    s_ver = wxWIN32S;
-                    break;
+                switch ( verMin )
+                {
+                    case 0:
+                        return wxWinVersion_95;

 
 

-                case VER_PLATFORM_WIN32_WINDOWS:
-                    s_ver = wxWIN95;
-                    break;
+                    case 10:
+                        return wxWinVersion_98;

 
 

-                case VER_PLATFORM_WIN32_NT:
-                    s_ver = wxWINDOWS_NT;
-                    break;
-#ifdef __WXWINCE__
-                case VER_PLATFORM_WIN32_CE:
-                    s_ver = wxWINDOWS_CE;
+                    case 90:
+                        return wxWinVersion_ME;
+                }
+            }
+            break;
+
+        case wxOS_WINDOWS_NT:
+            switch ( verMaj )
+            {
+                case 3:
+                    return wxWinVersion_NT3;
+
+                case 4:
+                    return wxWinVersion_NT4;
+
+                case 5:
+                    switch ( verMin )
+                    {
+                        case 0:
+                            return wxWinVersion_2000;
+
+                        case 1:
+                            return wxWinVersion_XP;
+
+                        case 2:
+                            return wxWinVersion_2003;
+                    }

                     break;
                     break;

-#endif
+
+                case 6:
+                    return wxWinVersion_NT6;

             }
             }

-        }
+            break;
+
+        default:
+            // Do nothing just to silence GCC warning
+            break;

     }
 
     }
 

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

 }
 
 // ----------------------------------------------------------------------------
 // sleep functions
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // sleep functions
 // ----------------------------------------------------------------------------
 

-void wxUsleep(unsigned long milliseconds)
+void wxMilliSleep(unsigned long milliseconds)

 {
     ::Sleep(milliseconds);
 }
 
 {
     ::Sleep(milliseconds);
 }
 

+void wxMicroSleep(unsigned long microseconds)
+{
+    wxMilliSleep(microseconds/1000);
+}
+

 void wxSleep(int nSecs)
 {
 void wxSleep(int nSecs)
 {

-    wxUsleep(1000*nSecs);
+    wxMilliSleep(1000*nSecs);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1106,8 +1329,10 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
         case wxFONTENCODING_CP936:
             return GB2312_CHARSET;
 
         case wxFONTENCODING_CP936:
             return GB2312_CHARSET;
 

+#ifndef __WXWINCE__

         case wxFONTENCODING_CP949:
             return HANGUL_CHARSET;
         case wxFONTENCODING_CP949:
             return HANGUL_CHARSET;

+#endif

 
         case wxFONTENCODING_CP950:
             return CHINESEBIG5_CHARSET;
 
         case wxFONTENCODING_CP950:
             return CHINESEBIG5_CHARSET;


@@ -1157,32 +1382,86 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
 
 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
 {
 
 extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
 {

-    // translate encoding into the Windows CHARSET
-    long charset = wxEncodingToCharset(encoding);
-    if ( charset == -1 )
-        return -1;
+    // There don't seem to be symbolic names for
+    // these under Windows so I just copied the
+    // values from MSDN.

 
 

-    // translate CHARSET to code page
-    CHARSETINFO csetInfo;
-    if ( !::TranslateCharsetInfo((DWORD *)(DWORD)charset,
-                                 &csetInfo,
-                                 TCI_SRCCHARSET) )
+    unsigned int ret;
+
+    switch (encoding)

     {
     {

-        wxLogLastError(_T("TranslateCharsetInfo(TCI_SRCCHARSET)"));
+        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 = 874; 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; // no correspondence on Windows
+        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 = 20932; 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;
         return -1;

-    }

 
 

-    return csetInfo.ciACP;
+    CPINFO info;
+    if (::GetCPInfo(ret, &info) == 0)
+        return -1;
+
+    return (long) ret;

 }
 
 }
 

-extern long wxCharsetToCodepage(const wxChar *name)
+extern long wxCharsetToCodepage(const char *name)

 {
     // first get the font encoding for this charset
     if ( !name )
         return -1;
 
 {
     // first get the font encoding for this charset
     if ( !name )
         return -1;
 

-    wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(name, FALSE);
+    wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);

     if ( enc == wxFONTENCODING_SYSTEM )
         return -1;
 
     if ( enc == wxFONTENCODING_SYSTEM )
         return -1;
 


@@ -1195,7 +1474,7 @@ extern long wxCharsetToCodepage(const wxChar *name)
 #include "wx/msw/registry.h"
 
 // this should work if Internet Exploiter is installed
 #include "wx/msw/registry.h"
 
 // this should work if Internet Exploiter is installed

-extern long wxCharsetToCodepage(const wxChar *name)
+extern long wxCharsetToCodepage(const char *name)

 {
     if (!name)
         return GetACP();
 {
     if (!name)
         return GetACP();


@@ -1237,12 +1516,12 @@ extern long wxCharsetToCodepage(const wxChar *name)
   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
   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 wxWindows may be used as a DLL and so may be loaded/unloaded
+  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
   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
+  NULL. classname is the desired wndclass classname. If function successfully

   registers the class, pclassname will be set to classname.
  */
 extern "C" WXDLLIMPEXP_BASE HWND
   registers the class, pclassname will be set to classname.
  */
 extern "C" WXDLLIMPEXP_BASE HWND


@@ -1291,4 +1570,3 @@ wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
 
     return hwnd;
 }
 
     return hwnd;
 }

-