]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/utils.cpp
Fix MSW compilation with wxUSE_DEFERRED_SIZING==0.
[wxWidgets.git] / src / msw / utils.cpp
index aff561ff85f54d66a661a374628dda2b2259dcac..e23656dfa91a86f03f812fbc2328b90648ee240f 100644 (file)
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        msw/utils.cpp
+// Name:        src/msw/utils.cpp
 // Purpose:     Various utilities
 // Author:      Julian Smart
 // Modified by:
     #include "wx/log.h"
 #endif  //WX_PRECOMP
 
+#include "wx/msw/registry.h"
 #include "wx/apptrait.h"
+#include "wx/dynlib.h"
+#include "wx/dynload.h"
+#include "wx/scopeguard.h"
+#include "wx/filename.h"
+
+#include "wx/confbase.h"        // for wxExpandEnvVars()
 
 #include "wx/msw/private.h"     // includes <windows.h>
+#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
 
-#ifdef __GNUWIN32_OLD__
+// 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 "wx/timer.h"
-
-#if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__)
+#if !defined(__GNUWIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     #include <direct.h>
 
     #ifndef __MWERKS__
@@ -54,7 +67,9 @@
 #if defined(__CYGWIN__)
     #include <sys/unistd.h>
     #include <sys/stat.h>
-    #include <sys/cygwin.h> // for cygwin_conv_to_full_win32_path()
+    #include <sys/cygwin.h> // for cygwin_conv_path()
+    // and cygwin_conv_to_full_win32_path()
+    #include <cygwin/version.h>
 #endif  //GNUWIN32
 
 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
@@ -73,7 +88,7 @@
     #include <lm.h>
 #endif // USE_NET_API
 
-#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+#if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     #ifndef __UNIX__
         #include <io.h>
     #endif
     #endif
 #endif
 
-// ----------------------------------------------------------------------------
-// module globals
-// ----------------------------------------------------------------------------
-
-#if wxUSE_ON_FATAL_EXCEPTION
-    static bool gs_handleExceptions = FALSE;
-#endif
+// For wxKillAllChildren
+#include <tlhelp32.h>
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 // In the WIN.INI file
+#if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)
 static const wxChar WX_SECTION[] = wxT("wxWindows");
+#endif
+
+#if (!defined(USE_NET_API) && !defined(__WXWINCE__))
 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
+WXDLLIMPEXP_DATA_BASE(const wxChar *) wxUserResourceStr = wxT("TEXT");
 
 // ============================================================================
 // implementation
@@ -122,87 +133,121 @@ static const wxChar eUSERID[]    = wxT("UserId");
 // Get hostname only (without domain name)
 bool wxGetHostName(wxChar *buf, int maxSize)
 {
-#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+#if defined(__WXWINCE__)
+    // GetComputerName() is not supported but the name seems to be stored in
+    // this location in the registry, at least for PPC2003 and WM5
+    wxString hostName;
+    wxRegKey regKey(wxRegKey::HKLM, wxT("Ident"));
+    if ( !regKey.HasValue(wxT("Name")) ||
+            !regKey.QueryValue(wxT("Name"), hostName) )
+        return false;
+
+    wxStrlcpy(buf, hostName.wx_str(), maxSize);
+#else // !__WXWINCE__
     DWORD nSize = maxSize;
     if ( !::GetComputerName(buf, &nSize) )
     {
         wxLogLastError(wxT("GetComputerName"));
 
-        return FALSE;
+        return false;
     }
+#endif // __WXWINCE__/!__WXWINCE__
 
-    return TRUE;
-#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 true;
 }
 
 // get full hostname (with domain name if possible)
 bool wxGetFullHostName(wxChar *buf, int maxSize)
 {
-#if defined(__WIN32__) && !defined(__WXMICROWIN__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
+#if !defined( __WXMICROWIN__) && wxUSE_DYNLIB_CLASS && wxUSE_SOCKETS
     // TODO should use GetComputerNameEx() when available
 
-    // the idea is that if someone had set wxUSE_SOCKETS to 0 the code
-    // shouldn't use winsock.dll (a.k.a. ws2_32.dll) at all so only use this
-    // code if we link with it anyhow
-#if wxUSE_SOCKETS
+    // 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;
 
-    WSADATA wsa;
-    if ( WSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
+    wxDynamicLibrary dllWinsock(wxT("ws2_32.dll"), wxDL_VERBATIM);
+    if ( dllWinsock.IsLoaded() )
     {
-        wxString host;
-        char bufA[256];
-        if ( gethostname(bufA, WXSIZEOF(bufA)) == 0 )
+        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);
+
+        #define LOAD_WINSOCK_FUNC(func)                                       \
+            func ## _t                                                        \
+                pfn ## func = (func ## _t)dllWinsock.GetSymbol(wxT(#func))
+
+        LOAD_WINSOCK_FUNC(WSAStartup);
+
+        WSADATA wsa;
+        if ( pfnWSAStartup && pfnWSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
         {
-            // gethostname() won't usually include the DNS domain name, for
-            // this we need to work a bit more
-            if ( !strchr(bufA, '.') )
-            {
-                struct hostent *pHostEnt =  gethostbyname(bufA);
+            LOAD_WINSOCK_FUNC(gethostname);
 
-                if ( pHostEnt )
+            wxString host;
+            if ( pfngethostname )
+            {
+                char bufA[256];
+                if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
                 {
-                    // Windows will use DNS internally now
-                    pHostEnt = gethostbyaddr(pHostEnt->h_addr, 4, AF_INET);
-                }
+                    // 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);
 
-                if ( pHostEnt )
-                {
-                    host = wxString::FromAscii(pHostEnt->h_name);
+                        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);
+                        }
+                    }
                 }
             }
-        }
 
-        WSACleanup();
+            LOAD_WINSOCK_FUNC(WSACleanup);
+            if ( pfnWSACleanup )
+                pfnWSACleanup();
 
-        if ( !host.empty() )
-        {
-            wxStrncpy(buf, host, maxSize);
 
-            return TRUE;
+            if ( !host.empty() )
+            {
+                wxStrlcpy(buf, host.c_str(), maxSize);
+
+                return true;
+            }
         }
     }
-
-#endif // wxUSE_SOCKETS
-
-#endif // Win32
+#endif // !__WXMICROWIN__
 
     return wxGetHostName(buf, maxSize);
 }
 
 // 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(__WIN32__) && !defined(__win32s__) && !defined(__WXMICROWIN__)
+#if defined(__WXWINCE__)
+    // TODO-CE
+    return false;
+#else
     DWORD nSize = maxSize;
     if ( ::GetUserName(buf, &nSize) == 0 )
     {
@@ -211,138 +256,120 @@ bool wxGetUserId(wxChar *buf, int maxSize)
         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;
 #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
+    wxCHECK_MSG( buf && ( maxSize > 0 ), false,
+                    wxT("empty buffer in wxGetUserName") );
+#if defined(__WXWINCE__) && wxUSE_REGKEY
+    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;
+    wxStrlcpy(buf, name.c_str(), maxSize);
+    return true;
+#elif defined(USE_NET_API)
+    CHAR szUserName[256];
+    if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
+        return false;
+
+    // TODO how to get the domain name?
+    CHAR *szDomain = "";
+
+    // the code is based on the MSDN example (also see KB article Q119670)
+    WCHAR wszUserName[256];          // Unicode user name
+    WCHAR wszDomain[256];
+    LPBYTE ComputerName;
+
+    USER_INFO_2 *ui2;         // User structure
+
+    // Convert ANSI user name and domain to Unicode
+    MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
+            wszUserName, WXSIZEOF(wszUserName) );
+    MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
+            wszDomain, WXSIZEOF(wszDomain) );
+
+    // Get the computer name of a DC for the domain.
+    if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
     {
-#ifdef USE_NET_API
-        CHAR szUserName[256];
-        if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
-            return FALSE;
-
-        // TODO how to get the domain name?
-        CHAR *szDomain = "";
-
-        // the code is based on the MSDN example (also see KB article Q119670)
-        WCHAR wszUserName[256];          // Unicode user name
-        WCHAR wszDomain[256];
-        LPBYTE ComputerName;
+        wxLogError(wxT("Can not find domain controller"));
 
-        USER_INFO_2 *ui2;         // User structure
+        goto error;
+    }
 
-        // Convert ANSI user name and domain to Unicode
-        MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
-                wszUserName, WXSIZEOF(wszUserName) );
-        MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
-                wszDomain, WXSIZEOF(wszDomain) );
+    // 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 );
+    switch ( status )
+    {
+        case NERR_Success:
+            // ok
+            break;
 
-        // Get the computer name of a DC for the domain.
-        if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
-        {
-            wxLogError(wxT("Can not find domain controller"));
+        case NERR_InvalidComputer:
+            wxLogError(wxT("Invalid domain controller name."));
 
             goto error;
-        }
 
-        // 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 );
-        switch ( status )
-        {
-            case NERR_Success:
-                // ok
-                break;
-
-            case NERR_InvalidComputer:
-                wxLogError(wxT("Invalid domain controller name."));
-
-                goto error;
+        case NERR_UserNotFound:
+            wxLogError(wxT("Invalid user name '%s'."), szUserName);
 
-            case NERR_UserNotFound:
-                wxLogError(wxT("Invalid user name '%s'."), szUserName);
-
-                goto error;
+            goto error;
 
-            default:
-                wxLogSysError(wxT("Can't get information about user"));
+        default:
+            wxLogSysError(wxT("Can't get information about user"));
 
-                goto error;
-        }
+            goto error;
+    }
 
-        // Convert the Unicode full name to ANSI
-        WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
-                buf, maxSize, NULL, NULL );
+    // Convert the Unicode full name to ANSI
+    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."));
+    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
-        // Use wxWindows configuration data
-        bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxT(""), buf, maxSize - 1) != 0;
-        if ( !ok )
-        {
-            ok = wxGetUserId(buf, maxSize);
-        }
+    // Could use NIS, MS-Mail or other site specific programs
+    // Use wxWidgets configuration data
+    bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxEmptyString, buf, maxSize - 1) != 0;
+    if ( !ok )
+    {
+        ok = wxGetUserId(buf, maxSize);
+    }
 
-        if ( !ok )
-        {
-            wxStrncpy(buf, wxT("Unknown User"), maxSize);
-        }
-#endif // Win32/16
+    if ( !ok )
+    {
+        wxStrlcpy(buf, wxT("Unknown User"), maxSize);
     }
 
-    return TRUE;
+    return true;
+#endif // Win32/16
 }
 
 const wxChar* wxGetHomeDir(wxString *pstr)
 {
-  wxString& strDir = *pstr;
+    wxString& strDir = *pstr;
 
-  #if defined(__UNIX__)
-    const wxChar *szHome = wxGetenv("HOME");
+    // first branch is for Cygwin
+#if defined(__UNIX__) && !defined(__WINE__)
+    const wxChar *szHome = wxGetenv(wxT("HOME"));
     if ( szHome == NULL ) {
       // we're homeless...
       wxLogWarning(_("can't find user's HOME, using current directory."));
@@ -356,32 +383,37 @@ const wxChar* wxGetHomeDir(wxString *pstr)
       strDir << wxT('/');
 
     #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;
+        // Cygwin returns unix type path but that does not work well
+        static wxChar windowsPath[MAX_PATH];
+        #if CYGWIN_VERSION_DLL_MAJOR >= 1007
+            cygwin_conv_path(CCP_POSIX_TO_WIN_W, strDir, windowsPath, MAX_PATH);
+        #else
+            cygwin_conv_to_full_win32_path(strDir, windowsPath);
+        #endif
+        strDir = windowsPath;
     #endif
-  #else   // Windows
-    #ifdef  __WIN32__
-      strDir.clear();
+#elif defined(__WXWINCE__)
+    strDir = wxT("\\");
+#else
+    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 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 )
-      {
+    if ( szHome != NULL )
+    {
         strDir = szHome;
-      }
-      else // no HOME, try HOMEDRIVE/PATH
-      {
-          szHome = wxGetenv(wxT("HOMEDRIVE"));
-          if ( szHome != NULL )
+    }
+    else // no HOME, try HOMEDRIVE/PATH
+    {
+        szHome = wxGetenv(wxT("HOMEDRIVE"));
+        if ( szHome != NULL )
             strDir << szHome;
-          szHome = wxGetenv(wxT("HOMEPATH"));
+        szHome = wxGetenv(wxT("HOMEPATH"));
 
-          if ( szHome != NULL )
-          {
+        if ( szHome != NULL )
+        {
             strDir << szHome;
 
             // the idea is that under NT these variables have default values
@@ -391,87 +423,56 @@ const wxChar* wxGetHomeDir(wxString *pstr)
             // 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();
-          }
-      }
+                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 ( 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 )
+        if ( szHome != NULL )
             strDir = szHome;
-      }
-
-      if ( !strDir.empty() )
-      {
-          return strDir.c_str();
-      }
-      //else: fall back to the prograrm directory
-    #else   // Win16
-      // Win16 has no idea about home, so use the executable directory instead
-    #endif  // WIN16/32
-
-    // 260 was taken from windef.h
-    #ifndef MAX_PATH
-      #define MAX_PATH  260
-    #endif
-
-    wxString strPath;
-    ::GetModuleFileName(::GetModuleHandle(NULL),
-                        strPath.GetWriteBuf(MAX_PATH), MAX_PATH);
-    strPath.UngetWriteBuf();
-
-    // extract the dir name
-    wxSplitPath(strPath, &strDir, NULL, NULL);
+    }
 
-  #endif  // UNIX/Win
+    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
+        wxFileName::SplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);
+    }
+#endif  // UNIX/Win
 
-  return strDir.c_str();
+    return strDir.c_str();
 }
 
-wxChar *wxGetUserHome(const wxString& WXUNUSED(user))
+wxString wxGetUserHome(const wxString& user)
 {
-    // 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;
+    wxString home;
 
-    return (wxChar *)wxGetHomeDir(&s_home);
-}
+    if ( user.empty() || user == wxGetUserId() )
+        wxGetHomeDir(&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
+    return home;
 }
 
-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__
+    // TODO-CE
+    return false;
+#else
     if ( path.empty() )
-        return FALSE;
+        return false;
 
 // old w32api don't have ULARGE_INTEGER
 #if defined(__WIN32__) && \
@@ -486,7 +487,7 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
     GetDiskFreeSpaceEx_t
         pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
                               (
-                                ::GetModuleHandle(_T("kernel32.dll")),
+                                ::GetModuleHandle(wxT("kernel32.dll")),
 #if wxUSE_UNICODE
                                 "GetDiskFreeSpaceExW"
 #else
@@ -499,14 +500,14 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
         ULARGE_INTEGER bytesFree, bytesTotal;
 
         // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
-        if ( !pGetDiskFreeSpaceEx(path,
+        if ( !pGetDiskFreeSpaceEx(path.t_str(),
                                   &bytesFree,
                                   &bytesTotal,
                                   NULL) )
         {
-            wxLogLastError(_T("GetDiskFreeSpaceEx"));
+            wxLogLastError(wxT("GetDiskFreeSpaceEx"));
 
-            return FALSE;
+            return false;
         }
 
         // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
@@ -519,12 +520,20 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 #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 wxUSE_LONGLONG
             *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
+#else
+            *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
+#endif
         }
     }
     else
@@ -541,18 +550,18 @@ 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...
-        if ( !::GetDiskFreeSpace(path,
+        if ( !::GetDiskFreeSpace(path.t_str(),
                                  &lSectorsPerCluster,
                                  &lBytesPerSector,
                                  &lNumberOfFreeClusters,
                                  &lTotalNumberOfClusters) )
         {
-            wxLogLastError(_T("GetDiskFreeSpace"));
+            wxLogLastError(wxT("GetDiskFreeSpace"));
 
-            return FALSE;
+            return false;
         }
 
-        wxLongLong lBytesPerCluster = lSectorsPerCluster;
+        wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;
         lBytesPerCluster *= lBytesPerSector;
 
         if ( pTotal )
@@ -568,61 +577,88 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
         }
     }
 
-    return TRUE;
+    return true;
+#endif
+    // __WXWINCE__
 }
 
 // ----------------------------------------------------------------------------
 // env vars
 // ----------------------------------------------------------------------------
 
-bool wxGetEnv(const wxString& var, wxString *value)
+bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var),
+              wxString *WXUNUSED_IN_WINCE(value))
 {
-#ifdef __WIN16__
-    const wxChar* ret = wxGetenv(var);
-    if ( !ret )
-        return FALSE;
-
-    if ( value )
-    {
-        *value = ret;
-    }
-
-    return TRUE;
+#ifdef __WXWINCE__
+    // no environment variables under CE
+    return false;
 #else // Win32
     // first get the size of the buffer
-    DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
+    DWORD dwRet = ::GetEnvironmentVariable(var.t_str(), NULL, 0);
     if ( !dwRet )
     {
         // this means that there is no such variable
-        return FALSE;
+        return false;
     }
 
     if ( value )
     {
-        (void)::GetEnvironmentVariable(var, value->GetWriteBuf(dwRet), dwRet);
-        value->UngetWriteBuf();
+        (void)::GetEnvironmentVariable(var.t_str(),
+                                       wxStringBuffer(*value, dwRet),
+                                       dwRet);
     }
 
-    return TRUE;
-#endif // Win16/32
+    return true;
+#endif // WinCE/32
 }
 
-bool wxSetEnv(const wxString& var, const wxChar *value)
+bool wxDoSetEnv(const wxString& var, const wxChar *value)
 {
-    // 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__)
-    if ( !::SetEnvironmentVariable(var, value) )
+#ifdef __WXWINCE__
+    // no environment variables under CE
+    wxUnusedVar(var);
+    wxUnusedVar(value);
+    return false;
+#else // !__WXWINCE__
+    // update the CRT environment if possible as people expect getenv() to also
+    // work and it is not affected by Win32 SetEnvironmentVariable() call (OTOH
+    // the CRT does use Win32 call to update the process environment block so
+    // there is no need to call it)
+    //
+    // TODO: add checks for the other compilers (and update wxSetEnv()
+    //       documentation in interface/wx/utils.h accordingly)
+#if defined(__VISUALC__)
+    // notice that Microsoft _putenv() has different semantics from POSIX
+    // function with almost the same name: in particular it makes a copy of the
+    // string instead of using it as part of environment so we can safely call
+    // it here without going through all the troubles with wxSetEnvModule as in
+    // src/unix/utilsunx.cpp
+    wxString envstr = var;
+    envstr += '=';
+    if ( value )
+        envstr += value;
+    _tputenv(envstr.t_str());
+#else // other compiler
+    if ( !::SetEnvironmentVariable(var.t_str(), value) )
     {
-        wxLogLastError(_T("SetEnvironmentVariable"));
+        wxLogLastError(wxT("SetEnvironmentVariable"));
 
-        return FALSE;
+        return false;
     }
+#endif // compiler
 
-    return TRUE;
-#else // no way to set env vars
-    return FALSE;
-#endif
+    return true;
+#endif // __WXWINCE__/!__WXWINCE__
+}
+
+bool wxSetEnv(const wxString& variable, const wxString& value)
+{
+    return wxDoSetEnv(variable, value.t_str());
+}
+
+bool wxUnsetEnv(const wxString& variable)
+{
+    return wxDoSetEnv(variable, NULL);
 }
 
 // ----------------------------------------------------------------------------
@@ -640,7 +676,7 @@ struct wxFindByPidParams
     // the PID we're looking from
     DWORD pid;
 
-    DECLARE_NO_COPY_CLASS(wxFindByPidParams)
+    wxDECLARE_NO_COPY_CLASS(wxFindByPidParams);
 };
 
 // wxKill helper: EnumWindows() callback which is used to find the first (top
@@ -664,8 +700,13 @@ BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)
     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 |
@@ -676,20 +717,20 @@ int wxKill(long pid, wxSignal sig, wxKillError *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;
     }
 
-    bool ok = TRUE;
+    wxON_BLOCK_EXIT1(::CloseHandle, hProcess);
+
+    bool ok = true;
     switch ( sig )
     {
         case wxSIGKILL:
@@ -705,13 +746,15 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                     *krc = wxKILL_ERROR;
                 }
 
-                ok = FALSE;
+                ok = false;
             }
             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"
@@ -720,7 +763,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                 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) )
                 {
@@ -729,37 +772,34 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                     {
                         // 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)
                         if ( !::PostMessage(params.hwnd, WM_QUIT, 0, 0) )
                         {
-                            wxLogLastError(_T("PostMessage(WM_QUIT)"));
+                            wxLogLastError(wxT("PostMessage(WM_QUIT)"));
                         }
                     }
                     else // it was an error then
                     {
-                        wxLogLastError(_T("EnumWindows"));
+                        wxLogLastError(wxT("EnumWindows"));
 
-                        ok = FALSE;
+                        ok = false;
                     }
                 }
                 else // no windows for this PID
                 {
                     if ( krc )
-                    {
                         *krc = wxKILL_ERROR;
-                    }
 
-                    ok = FALSE;
+                    ok = false;
                 }
             }
     }
 
     // the return code
-    DWORD rc;
-
+    DWORD rc wxDUMMY_INITIALIZE(0);
     if ( ok )
     {
         // as we wait for a short time, we can use just WaitForSingleObject()
@@ -770,64 +810,138 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc)
                 // process terminated
                 if ( !::GetExitCodeProcess(hProcess, &rc) )
                 {
-                    wxLogLastError(_T("GetExitCodeProcess"));
+                    wxLogLastError(wxT("GetExitCodeProcess"));
                 }
                 break;
 
             default:
-                wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
+                wxFAIL_MSG( wxT("unexpected WaitForSingleObject() return") );
                 // fall through
 
             case WAIT_FAILED:
-                wxLogLastError(_T("WaitForSingleObject"));
+                wxLogLastError(wxT("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;
-    }
 
-    ::CloseHandle(hProcess);
 
     // 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(wxT("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(wxT("CreateToolhelp32Snapshot"));
+
+    lpfProcess32First =
+        (Process32_t)dllKernel.RawGetSymbol(wxT("Process32First"));
+
+    lpfProcess32Next =
+        (Process32_t)dllKernel.RawGetSymbol(wxT("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;
+
+    // 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)
 {
+    wxString cmd;
+
+#ifdef __WXWINCE__
+    cmd = command;
+#else
     wxChar *shell = wxGetenv(wxT("COMSPEC"));
     if ( !shell )
         shell = (wxChar*) wxT("\\COMMAND.COM");
 
-    wxString cmd;
     if ( !command )
     {
         // just the shell
@@ -838,17 +952,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());
     }
+#endif
 
     return wxExecute(cmd, wxEXEC_SYNC) == 0;
 }
 
 // Shutdown or reboot the PC
-bool wxShutdown(wxShutdownFlags wFlags)
+bool wxShutdown(int WXUNUSED_IN_WINCE(flags))
 {
-#ifdef __WIN32__
-    bool bOK = TRUE;
+#ifdef __WXWINCE__
+    // TODO-CE
+    return false;
+#elif defined(__WIN32__)
+    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;
@@ -860,46 +978,59 @@ bool wxShutdown(wxShutdownFlags wFlags)
             TOKEN_PRIVILEGES tkp;
 
             // Get the LUID for the shutdown privilege.
-            ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
-                                   &tkp.Privileges[0].Luid);
+            bOK = ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
+                                         &tkp.Privileges[0].Luid) != 0;
 
-            tkp.PrivilegeCount = 1;  // one privilege to set
-            tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+            if ( bOK )
+            {
+                tkp.PrivilegeCount = 1;  // one privilege to set
+                tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+
+                // Get the shutdown privilege for this process.
+                ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
+                                        (PTOKEN_PRIVILEGES)NULL, 0);
 
-            // Get the shutdown privilege for this process.
-            ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
-                                    (PTOKEN_PRIVILEGES)NULL, 0);
+                // Cannot test the return value of AdjustTokenPrivileges.
+                bOK = ::GetLastError() == ERROR_SUCCESS;
+            }
 
-            // Cannot test the return value of AdjustTokenPrivileges.
-            bOK = ::GetLastError() == ERROR_SUCCESS;
+            ::CloseHandle(hToken);
         }
     }
 
     if ( bOK )
     {
-        UINT flags = EWX_SHUTDOWN | EWX_FORCE;
-        switch ( wFlags )
+        UINT wFlags = 0;
+        if ( flags & wxSHUTDOWN_FORCE )
+        {
+            wFlags = EWX_FORCE;
+            flags &= ~wxSHUTDOWN_FORCE;
+        }
+
+        switch ( flags )
         {
             case wxSHUTDOWN_POWEROFF:
-                flags |= EWX_POWEROFF;
+                wFlags |= EWX_POWEROFF;
                 break;
 
             case wxSHUTDOWN_REBOOT:
-                flags |= EWX_REBOOT;
+                wFlags |= EWX_REBOOT;
+                break;
+
+            case wxSHUTDOWN_LOGOFF:
+                wFlags |= EWX_LOGOFF;
                 break;
 
             default:
-                wxFAIL_MSG( _T("unknown wxShutdown() flag") );
-                return FALSE;
+                wxFAIL_MSG( wxT("unknown wxShutdown() flag") );
+                return false;
         }
 
-        bOK = ::ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE | EWX_REBOOT, 0) != 0;
+        bOK = ::ExitWindowsEx(wFlags, 0) != 0;
     }
 
     return bOK;
-#else // Win16
-    return FALSE;
-#endif // Win32/16
+#endif // WinCE/!WinCE
 }
 
 // ----------------------------------------------------------------------------
@@ -907,25 +1038,24 @@ bool wxShutdown(wxShutdownFlags wFlags)
 // ----------------------------------------------------------------------------
 
 // 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);
-    GlobalMemoryStatus(&memStatus);
-    return memStatus.dwAvailPhys;
-#else
-    return (long)GetFreeSpace(0);
+    ::GlobalMemoryStatus(&memStatus);
+    return (wxMemorySize)memStatus.dwAvailPhys;
 #endif
 }
 
 unsigned long wxGetProcessId()
 {
-#ifdef __WIN32__
     return ::GetCurrentProcessId();
-#else
-    return 0;
-#endif
 }
 
 // Emit a beeeeeep
@@ -934,9 +1064,129 @@ void wxBell()
     ::MessageBeep((UINT)-1);        // default sound
 }
 
+bool wxIsDebuggerRunning()
+{
+#if wxUSE_DYNLIB_CLASS
+    // IsDebuggerPresent() is not available under Win95, so load it dynamically
+    wxDynamicLibrary dll(wxT("kernel32.dll"), wxDL_VERBATIM);
+
+    typedef BOOL (WINAPI *IsDebuggerPresent_t)();
+    if ( !dll.HasSymbol(wxT("IsDebuggerPresent")) )
+    {
+        // no way to know, assume no
+        return false;
+    }
+
+    return (*(IsDebuggerPresent_t)dll.GetSymbol(wxT("IsDebuggerPresent")))() != 0;
+#else
+    return false;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// working with MSW resources
+// ----------------------------------------------------------------------------
+
+bool
+wxLoadUserResource(const void **outData,
+                   size_t *outLen,
+                   const wxString& resourceName,
+                   const wxString& resourceType,
+                   WXHINSTANCE instance)
+{
+    wxCHECK_MSG( outData && outLen, false, "output pointers can't be NULL" );
+
+    HRSRC hResource = ::FindResource(instance,
+                                     resourceName.wx_str(),
+                                     resourceType.wx_str());
+    if ( !hResource )
+        return false;
+
+    HGLOBAL hData = ::LoadResource(instance, hResource);
+    if ( !hData )
+    {
+        wxLogSysError(_("Failed to load resource \"%s\"."), resourceName);
+        return false;
+    }
+
+    *outData = ::LockResource(hData);
+    if ( !*outData )
+    {
+        wxLogSysError(_("Failed to lock resource \"%s\"."), resourceName);
+        return false;
+    }
+
+    *outLen = ::SizeofResource(instance, hResource);
+
+    // Notice that we do not need to call neither UnlockResource() (which is
+    // obsolete in Win32) nor GlobalFree() (resources are freed on process
+    // termination only)
+
+    return true;
+}
+
+char *
+wxLoadUserResource(const wxString& resourceName,
+                   const wxString& resourceType,
+                   int* pLen,
+                   WXHINSTANCE instance)
+{
+    const void *data;
+    size_t len;
+    if ( !wxLoadUserResource(&data, &len, resourceName, resourceType, instance) )
+        return NULL;
+
+    char *s = new char[len + 1];
+    memcpy(s, data, len);
+    s[len] = '\0'; // NUL-terminate in case the resource itself wasn't
+
+    if (pLen)
+      *pLen = len;
+
+    return s;
+}
+
+// ----------------------------------------------------------------------------
+// OS version
+// ----------------------------------------------------------------------------
+
+// check if we're running under a server or workstation Windows system: it
+// returns true or false with obvious meaning as well as -1 if the system type
+// couldn't be determined
+//
+// this function is currently private but we may want to expose it later if
+// it's really useful
+namespace
+{
+
+int wxIsWindowsServer()
+{
+#ifdef VER_NT_WORKSTATION
+    OSVERSIONINFOEX info;
+    wxZeroMemory(info);
+
+    info.dwOSVersionInfoSize = sizeof(info);
+    if ( ::GetVersionEx(reinterpret_cast<OSVERSIONINFO *>(&info)) )
+    {
+        switch ( info.wProductType )
+        {
+            case VER_NT_WORKSTATION:
+                return false;
+
+            case VER_NT_SERVER:
+            case VER_NT_DOMAIN_CONTROLLER:
+                return true;
+        }
+    }
+#endif // VER_NT_WORKSTATION
+
+    return -1;
+}
+
+} // anonymous namespace
+
 wxString wxGetOsDescription()
 {
-#ifdef __WIN32__
     wxString str;
 
     OSVERSIONINFO info;
@@ -947,109 +1197,293 @@ wxString wxGetOsDescription()
     {
         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:
-                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(')');
+                    str << wxT(" (") << info.szCSDVersion << wxT(')');
                 }
                 break;
 
             case VER_PLATFORM_WIN32_NT:
-                str.Printf(_T("Windows NT %lu.%lu (build %lu"),
+                switch ( info.dwMajorVersion )
+                {
+                    case 5:
+                        switch ( info.dwMinorVersion )
+                        {
+                            case 0:
+                                str.Printf(_("Windows 2000 (build %lu"),
+                                           info.dwBuildNumber);
+                                break;
+
+                            case 2:
+                                // we can't distinguish between XP 64 and 2003
+                                // as they both are 5.2, so examine the product
+                                // type to resolve this ambiguity
+                                if ( wxIsWindowsServer() == 1 )
+                                {
+                                    str.Printf(_("Windows Server 2003 (build %lu"),
+                                               info.dwBuildNumber);
+                                    break;
+                                }
+                                //else: must be XP, fall through
+
+                            case 1:
+                                str.Printf(_("Windows XP (build %lu"),
+                                           info.dwBuildNumber);
+                                break;
+                        }
+                        break;
+
+                    case 6:
+                        if ( info.dwMinorVersion == 0 )
+                        {
+                            str.Printf(_("Windows Vista (build %lu"),
+                                       info.dwBuildNumber);
+                        }
+                        break;
+                }
+
+                if ( str.empty() )
+                {
+                    str.Printf(_("Windows NT %lu.%lu (build %lu"),
                            info.dwMajorVersion,
                            info.dwMinorVersion,
                            info.dwBuildNumber);
+                }
+
                 if ( !wxIsEmpty(info.szCSDVersion) )
                 {
-                    str << _T(", ") << info.szCSDVersion;
+                    str << wxT(", ") << info.szCSDVersion;
                 }
-                str << _T(')');
+                str << wxT(')');
+
+                if ( wxIsPlatform64Bit() )
+                    str << _(", 64-bit edition");
                 break;
         }
     }
     else
     {
-        wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
+        wxFAIL_MSG( wxT("GetVersionEx() failed") ); // should never happen
     }
 
     return str;
-#else // Win16
-    return _("Windows 3.1");
-#endif // Win32/16
 }
 
-int wxAppTraits::GetOSVersion(int *verMaj, int *verMin)
+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 defined(_WIN64)
+    return true;  // 64-bit programs run only on Win64
+#elif wxUSE_DYNLIB_CLASS // Win32
+    // 32-bit programs run on both 32-bit and 64-bit Windows so check
+    typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *);
+
+    wxDynamicLibrary dllKernel32(wxT("kernel32.dll"));
+    IsWow64Process_t pfnIsWow64Process =
+        (IsWow64Process_t)dllKernel32.RawGetSymbol(wxT("IsWow64Process"));
+
+    BOOL wow64 = FALSE;
+    if ( pfnIsWow64Process )
+    {
+        pfnIsWow64Process(::GetCurrentProcess(), &wow64);
+    }
+    //else: running under a system without Win64 support
+
+    return wow64 != FALSE;
+#else
+    return false;
+#endif // Win64/Win32
+}
 
-    if ( s_ver == -1 )
+wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
+{
+    static struct
+    {
+        // this may be false, true or -1 if we tried to initialize but failed
+        int initialized;
+
+        wxOperatingSystemId os;
+
+        int verMaj,
+            verMin;
+    } s_version;
+
+    // query the OS info only once as it's not supposed to change
+    if ( !s_version.initialized )
     {
         OSVERSIONINFO info;
         wxZeroMemory(info);
-
-        s_ver = wxWINDOWS;
-        info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+        info.dwOSVersionInfoSize = sizeof(info);
         if ( ::GetVersionEx(&info) )
         {
-            s_major = info.dwMajorVersion;
-            s_minor = info.dwMinorVersion;
+            s_version.initialized = true;
 
+#if defined(__WXWINCE__)
+            s_version.os = wxOS_WINDOWS_CE;
+#elif defined(__WXMICROWIN__)
+            s_version.os = wxOS_WINDOWS_MICRO;
+#else // "normal" desktop Windows system, use run-time detection
             switch ( info.dwPlatformId )
             {
-                case VER_PLATFORM_WIN32s:
-                    s_ver = wxWIN32S;
+                case VER_PLATFORM_WIN32_NT:
+                    s_version.os = wxOS_WINDOWS_NT;
                     break;
 
                 case VER_PLATFORM_WIN32_WINDOWS:
-                    s_ver = wxWIN95;
-                    break;
-
-                case VER_PLATFORM_WIN32_NT:
-                    s_ver = wxWINDOWS_NT;
+                    s_version.os = wxOS_WINDOWS_9X;
                     break;
             }
+#endif // Windows versions
+
+            s_version.verMaj = info.dwMajorVersion;
+            s_version.verMin = info.dwMinorVersion;
+        }
+        else // GetVersionEx() failed
+        {
+            s_version.initialized = -1;
         }
     }
 
-    if ( verMaj )
-        *verMaj = s_major;
-    if ( verMin )
-        *verMin = s_minor;
+    if ( s_version.initialized == 1 )
+    {
+        if ( verMaj )
+            *verMaj = s_version.verMaj;
+        if ( verMin )
+            *verMin = s_version.verMin;
+    }
+
+    // this works even if we were not initialized successfully as the initial
+    // values of this field is 0 which is wxOS_UNKNOWN and exactly what we need
+    return s_version.os;
+}
+
+wxWinVersion wxGetWinVersion()
+{
+    int verMaj,
+        verMin;
+    switch ( wxGetOsVersion(&verMaj, &verMin) )
+    {
+        case wxOS_WINDOWS_9X:
+            if ( verMaj == 4 )
+            {
+                switch ( verMin )
+                {
+                    case 0:
+                        return wxWinVersion_95;
+
+                    case 10:
+                        return wxWinVersion_98;
+
+                    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;
+
+                case 6:
+                    return wxWinVersion_NT6;
+            }
+            break;
 
-    return s_ver;
+        default:
+            // Do nothing just to silence GCC warning
+            break;
+    }
+
+    return wxWinVersion_Unknown;
 }
 
 // ----------------------------------------------------------------------------
 // sleep functions
 // ----------------------------------------------------------------------------
 
-void wxUsleep(unsigned long milliseconds)
+void wxMilliSleep(unsigned long milliseconds)
 {
     ::Sleep(milliseconds);
 }
 
+void wxMicroSleep(unsigned long microseconds)
+{
+    wxMilliSleep(microseconds/1000);
+}
+
 void wxSleep(int nSecs)
 {
-    wxUsleep(1000*nSecs);
+    wxMilliSleep(1000*nSecs);
 }
 
 // ----------------------------------------------------------------------------
 // font encoding <-> Win32 codepage conversion functions
 // ----------------------------------------------------------------------------
 
-extern long wxEncodingToCharset(wxFontEncoding encoding)
+extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
 {
     switch ( encoding )
     {
@@ -1071,8 +1505,10 @@ extern long wxEncodingToCharset(wxFontEncoding encoding)
         case wxFONTENCODING_CP936:
             return GB2312_CHARSET;
 
+#ifndef __WXWINCE__
         case wxFONTENCODING_CP949:
             return HANGUL_CHARSET;
+#endif
 
         case wxFONTENCODING_CP950:
             return CHINESEBIG5_CHARSET;
@@ -1105,12 +1541,11 @@ extern long wxEncodingToCharset(wxFontEncoding encoding)
 
         case wxFONTENCODING_CP437:
             return OEM_CHARSET;
-        default: // fix GCC warning
+
+        default:
+            // no way to translate this encoding into a Windows charset
             return -1;
     }
-
-    // no way to translate this encoding into a Windows charset
-    return -1;
 }
 
 // we have 2 versions of wxCharsetToCodepage(): the old one which directly
@@ -1121,34 +1556,96 @@ extern long wxEncodingToCharset(wxFontEncoding encoding)
 
 #include "wx/fontmap.h"
 
-extern 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_ISO2022_JP:     ret = 50222; break;
+
+        case wxFONTENCODING_UTF7:           ret = 65000; break;
+        case wxFONTENCODING_UTF8:           ret = 65001; break;
+
+        default:                            return -1;
+    }
 
+    if (::IsValidCodePage(ret) == 0)
         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;
 
-    wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(name, FALSE);
+    wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);
     if ( enc == wxFONTENCODING_SYSTEM )
         return -1;
 
@@ -1161,13 +1658,14 @@ extern long wxCharsetToCodepage(const wxChar *name)
 #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();
 
     long CP = -1;
 
+#if wxUSE_REGKEY
     wxString path(wxT("MIME\\Database\\Charset\\"));
     wxString cn(name);
 
@@ -1193,46 +1691,68 @@ extern long wxCharsetToCodepage(const wxChar *name)
             !key.QueryValue(wxT("AliasForCharset"), cn))
             break;
     }
+#endif // wxUSE_REGKEY
 
     return CP;
 }
 
 #endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
 
-// ----------------------------------------------------------------------------
-// wxApp::OnFatalException() support
-// ----------------------------------------------------------------------------
-
-bool wxHandleFatalExceptions(bool doit)
+/*
+  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 successfully
+  registers the class, pclassname will be set to classname.
+ */
+extern "C" WXDLLIMPEXP_BASE HWND
+wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
 {
-#if wxUSE_ON_FATAL_EXCEPTION
-    // assume this can only be called from the main thread
-    gs_handleExceptions = doit;
+    wxCHECK_MSG( classname && pclassname && wndproc, NULL,
+                    wxT("NULL parameter in wxCreateHiddenWindow") );
 
-    return TRUE;
-#else
-    wxFAIL_MSG(_T("set wxUSE_ON_FATAL_EXCEPTION to 1 to use this function"));
+    // register the class fi we need to first
+    if ( *pclassname == NULL )
+    {
+        WNDCLASS wndclass;
+        wxZeroMemory(wndclass);
 
-    (void)doit;
-    return FALSE;
-#endif
-}
+        wndclass.lpfnWndProc   = wndproc;
+        wndclass.hInstance     = wxGetInstance();
+        wndclass.lpszClassName = classname;
 
-#if wxUSE_ON_FATAL_EXCEPTION
+        if ( !::RegisterClass(&wndclass) )
+        {
+            wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
 
-extern unsigned long wxGlobalSEHandler()
-{
-    if ( gs_handleExceptions && wxTheApp )
-    {
-        // give the user a chance to do something special about this
-        wxTheApp->OnFatalException();
+            return NULL;
+        }
 
-        // this will execute our handler and terminate the process
-        return EXCEPTION_EXECUTE_HANDLER;
+        *pclassname = classname;
     }
 
-    return EXCEPTION_CONTINUE_SEARCH;
-}
-
-#endif // wxUSE_ON_FATAL_EXCEPTION
+    // 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;
+}