Add some version checks to help compiling on OSX.

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

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index f836d8dc4bc4e2813dc27c9e962d52e498d5004e..f208feb48fa6c50811d15f11cb9782614d940414 100644 (file)
--- a/src/msw/utils.cpp
+++ b/src/msw/utils.cpp
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

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

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

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

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

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

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


@@ -31,29 +27,36 @@
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/app.h"
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/app.h"

-    #include "wx/cursor.h"

     #include "wx/intl.h"
     #include "wx/log.h"
 #endif  //WX_PRECOMP
 
     #include "wx/intl.h"
     #include "wx/log.h"
 #endif  //WX_PRECOMP
 

-// In some mingws there is a missing extern "C" int the winsock header,
-// so we put it here just to be safe. Note that this must appear _before_
-// #include "wx/msw/private.h" which itself includes <windows.h>, as this 
-// one in turn includes <winsock.h> unless we define WIN32_LEAN_AND_MEAN.
-//
-#if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
-extern "C" {
-    #include <winsock.h>    // we use socket functions in wxGetFullHostName()
-}
-#endif
+#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/private.h"     // includes <windows.h>

+#include "wx/msw/missing.h"     // for CHARSET_HANGUL

 
 

-#include "wx/timer.h"
+#if defined(__CYGWIN__)
+    //CYGWIN gives annoying warning about runtime stuff if we don't do this
+#   define USE_SYS_TYPES_FD_SET
+#   include <sys/types.h>
+#endif

 
 

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

 
 

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

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


@@ -61,9 +64,12 @@ extern "C" {
     #endif
 #endif  //GNUWIN32
 
     #endif
 #endif  //GNUWIN32
 

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

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

+    #include <sys/cygwin.h> // for cygwin_conv_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
 #endif  //GNUWIN32
 
 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs


@@ -82,71 +88,39 @@ extern "C" {
     #include <lm.h>
 #endif // USE_NET_API
 
     #include <lm.h>
 #endif // USE_NET_API
 

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

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

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

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

-#include <stdarg.h>
-
-//// BEGIN for console support: VC++ only
-#ifdef __VISUALC__
-
-#include "wx/msw/msvcrt.h"
-
-#include <fcntl.h>
-
-#include "wx/ioswrap.h"
-
-#if wxUSE_IOSTREAMH
-// N.B. BC++ doesn't have istream.h, ostream.h
-#  include <io.h>
-#  include <fstream.h>
-#else
-#  include <fstream>
-#endif

 
 

-/* Need to undef new if including crtdbg.h */
-#  ifdef new
-#  undef new
-#  endif
-
-#ifndef __WIN16__
-#  include <crtdbg.h>
-#endif
-
-#  if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
-#  define new new(__FILE__,__LINE__)
-#  endif
-
-#endif
-  // __VISUALC__
-/// END for console support
+// 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");

+#endif
+
+#if (!defined(USE_NET_API) && !defined(__WXWINCE__))

 static const wxChar eUSERNAME[]  = wxT("UserName");
 static const wxChar eUSERNAME[]  = wxT("UserName");

+#endif

 
 

-// these are only used under Win16
-#ifndef __WIN32__
-static const wxChar eHOSTNAME[]  = wxT("HostName");
-static const wxChar eUSERID[]    = wxT("UserId");
-#endif // !Win32
+WXDLLIMPEXP_DATA_BASE(const wxChar *) wxUserResourceStr = wxT("TEXT");

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


@@ -159,78 +133,121 @@ static const wxChar eUSERID[]    = wxT("UserId");
 // Get hostname only (without domain name)
 bool wxGetHostName(wxChar *buf, int maxSize)
 {
 // Get hostname only (without domain name)
 bool wxGetHostName(wxChar *buf, int maxSize)
 {

-#if defined(__WIN32__) && !defined(__TWIN32__)
+#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) )
     {
     DWORD nSize = maxSize;
     if ( !::GetComputerName(buf, &nSize) )
     {

-        wxLogLastError("GetComputerName");
+        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)
 {
 }
 
 // get full hostname (with domain name if possible)
 bool wxGetFullHostName(wxChar *buf, int maxSize)
 {

-#if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
+#if !defined( __WXMICROWIN__) && wxUSE_DYNLIB_CLASS && wxUSE_SOCKETS

     // TODO should use GetComputerNameEx() when available
     // TODO should use GetComputerNameEx() when available

-    WSADATA wsa;
-    if ( WSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
+
+    // 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;
+
+    wxDynamicLibrary dllWinsock(wxT("ws2_32.dll"), wxDL_VERBATIM);
+    if ( dllWinsock.IsLoaded() )

     {
     {

-        wxString host;
-        char bufA[256];
-        if ( gethostname(bufA, WXSIZEOF(bufA)) == 0 )
-        {
-            // gethostname() won't usually include the DNS domain name, for
-            // this we need to work a bit more
-            if ( !strchr(bufA, '.') )
-            {
-                struct hostent *pHostEnt =  gethostbyname(bufA);
+        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);

 
 

-                if ( pHostEnt )
-                {
-                    // Windows will use DNS internally now
-                    pHostEnt = gethostbyaddr(pHostEnt->h_addr, 4, PF_INET);
-                }
+        #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 )
+        {
+            LOAD_WINSOCK_FUNC(gethostname);

 
 

-                if ( pHostEnt )
+            wxString host;
+            if ( pfngethostname )
+            {
+                char bufA[256];
+                if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )

                 {
                 {

-                    host = pHostEnt->h_name;
+                    // gethostname() won't usually include the DNS domain name,
+                    // for this we need to work a bit more
+                    if ( !strchr(bufA, '.') )
+                    {
+                        LOAD_WINSOCK_FUNC(gethostbyname);
+
+                        struct hostent *pHostEnt = pfngethostbyname
+                                                    ? pfngethostbyname(bufA)
+                                                    : NULL;
+
+                        if ( pHostEnt )
+                        {
+                            // Windows will use DNS internally now
+                            LOAD_WINSOCK_FUNC(gethostbyaddr);
+
+                            pHostEnt = pfngethostbyaddr
+                                        ? pfngethostbyaddr(pHostEnt->h_addr,
+                                                           4, AF_INET)
+                                        : NULL;
+                        }
+
+                        if ( pHostEnt )
+                        {
+                            host = wxString::FromAscii(pHostEnt->h_name);
+                        }
+                    }

                 }
             }
                 }
             }

-        }

 
 

-        WSACleanup();
+            LOAD_WINSOCK_FUNC(WSACleanup);
+            if ( pfnWSACleanup )
+                pfnWSACleanup();

 
 

-        if ( !!host )
-        {
-            wxStrncpy(buf, host, maxSize);

 
 

-            return TRUE;
+            if ( !host.empty() )
+            {
+                wxStrlcpy(buf, host.c_str(), maxSize);
+
+                return true;
+            }

         }
     }
         }
     }

-#endif // Win32
+#endif // !__WXMICROWIN__

 
     return wxGetHostName(buf, maxSize);
 }
 
 // Get user ID e.g. jacs
 
     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(__TWIN32__)
+#if defined(__WXWINCE__)
+    // TODO-CE
+    return false;
+#else

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


@@ -239,138 +256,120 @@ bool wxGetUserId(wxChar *buf, int maxSize)
         if ( res == 0 )
         {
             // not found
         if ( res == 0 )
         {
             // not found

-            return FALSE;
+            return false;

         }
     }
 
         }
     }
 

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

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

-#if wxUSE_PENWINDOWS && !defined(__WATCOMC__) && !defined(__GNUWIN32__)
-    extern HANDLE g_hPenWin; // PenWindows Running?
-    if (g_hPenWin)
-    {
-        // PenWindows Does have a user concept!
-        // Get the current owner of the recognizer
-        GetPrivateProfileString("Current", "User", default_name, wxBuffer, maxSize - 1, "PENWIN.INI");
-        strncpy(buf, wxBuffer, maxSize - 1);
-    }
-    else
-#endif
+    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 = "";
+        wxLogError(wxT("Cannot find domain controller"));

 
 

-        // 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
+        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;
 
             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:
 
 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
 #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)
 {
 }
 
 const wxChar* wxGetHomeDir(wxString *pstr)
 {

-  wxString& strDir = *pstr;
+    wxString& strDir = *pstr;

 
 

-  #if defined(__UNIX__) && !defined(__TWIN32__)
-    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."));
     if ( szHome == NULL ) {
       // we're homeless...
       wxLogWarning(_("can't find user's HOME, using current directory."));


@@ -382,897 +381,1404 @@ const wxChar* wxGetHomeDir(wxString *pstr)
     // add a trailing slash if needed
     if ( strDir.Last() != wxT('/') )
       strDir << wxT('/');
     // add a trailing slash if needed
     if ( strDir.Last() != wxT('/') )
       strDir << wxT('/');

-  #else   // Windows
-    #ifdef  __WIN32__
-      const wxChar *szHome = wxGetenv(wxT("HOMEDRIVE"));
-      if ( szHome != NULL )
-        strDir << szHome;
-      szHome = wxGetenv(wxT("HOMEPATH"));
-      if ( szHome != NULL ) {
-        strDir << szHome;
-
-        // the idea is that under NT these variables have default values
-        // of "%systemdrive%:" and "\\". As we don't want to create our
-        // config files in the root directory of the system drive, we will
-        // create it in our program's dir. However, if the user took care
-        // to set HOMEPATH to something other than "\\", we suppose that he
-        // knows what he is doing and use the supplied value.
-        if ( wxStrcmp(szHome, wxT("\\")) != 0 )
-          return strDir.c_str();
-      }
-
-    #else   // Win16
-      // Win16 has no idea about home, so use the working directory instead
-    #endif  // WIN16/32
-
-    // 260 was taken from windef.h
-    #ifndef MAX_PATH
-      #define MAX_PATH  260
-    #endif
-
-    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
-
-  return strDir.c_str();
-}
-
-wxChar *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;
-
-    return (wxChar *)wxGetHomeDir(&s_home);
-}
-
-bool wxDirExists(const wxString& dir)
-{
-#if defined(__WIN32__)
-    WIN32_FIND_DATA fileInfo;
-#else // Win16
-    #ifdef __BORLANDC__
-        struct ffblk fileInfo;
-    #else
-        struct find_t fileInfo;
+    #ifdef __CYGWIN__
+        // 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
     #endif

-#endif // Win32/16
+#elif defined(__WXWINCE__)
+    strDir = wxT("\\");
+#else
+    strDir.clear();

 
 

-#if defined(__WIN32__)
-    HANDLE h = ::FindFirstFile(dir, &fileInfo);
+    // 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 ( h == INVALID_HANDLE_VALUE )
+    if ( szHome != NULL )

     {
     {

-        wxLogLastError("FindFirstFile");
-
-        return FALSE;
+        strDir = szHome;

     }
     }

+    else // no HOME, try HOMEDRIVE/PATH
+    {
+        szHome = wxGetenv(wxT("HOMEDRIVE"));
+        if ( szHome != NULL )
+            strDir << szHome;
+        szHome = wxGetenv(wxT("HOMEPATH"));

 
 

-    ::FindClose(h);
-
-    return (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
-#else // Win16
-    // 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
-}
-
-// ----------------------------------------------------------------------------
-// process management
-// ----------------------------------------------------------------------------
-
-int wxKill(long pid, int sig)
-{
-    // TODO use SendMessage(WM_QUIT) and TerminateProcess() if needed
+        if ( szHome != NULL )
+        {
+            strDir << szHome;
+
+            // the idea is that under NT these variables have default values
+            // of "%systemdrive%:" and "\\". As we don't want to create our
+            // config files in the root directory of the system drive, we will
+            // create it in our program's dir. However, if the user took care
+            // to set HOMEPATH to something other than "\\", we suppose that he
+            // knows what he is doing and use the supplied value.
+            if ( wxStrcmp(szHome, wxT("\\")) == 0 )
+                strDir.clear();
+        }
+    }

 
 

-    return 0;
-}
+    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"));

 
 

-// Execute a program in an Interactive Shell
-bool wxShell(const wxString& command)
-{
-    wxChar *shell = wxGetenv(wxT("COMSPEC"));
-    if ( !shell )
-        shell = wxT("\\COMMAND.COM");
+        if ( szHome != NULL )
+            strDir = szHome;
+    }

 
 

-    wxString cmd;
-    if ( !command )
+    if ( !strDir.empty() )

     {
     {

-        // just the shell
-        cmd = shell;
+        // sometimes the value of HOME may be "%USERPROFILE%", so reexpand the
+        // value once again, it shouldn't hurt anyhow
+        strDir = wxExpandEnvVars(strDir);

     }
     }

-    else
+    else // fall back to the program directory

     {
     {

-        // pass the command to execute to the command processor
-        cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
+        // extract the directory component of the program file name
+        wxFileName::SplitPath(wxGetFullModuleName(), &strDir, NULL, NULL);

     }
     }

+#endif  // UNIX/Win

 
 

-    return wxExecute(cmd, TRUE /* sync */) != 0;
+    return strDir.c_str();

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// misc
-// ----------------------------------------------------------------------------
-
-// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
-long wxGetFreeMemory()
+wxString wxGetUserHome(const wxString& user)

 {
 {

-#if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
-    MEMORYSTATUS memStatus;
-    memStatus.dwLength = sizeof(MEMORYSTATUS);
-    GlobalMemoryStatus(&memStatus);
-    return memStatus.dwAvailPhys;
-#else
-    return (long)GetFreeSpace(0);
-#endif
-}
+    wxString home;

 
 

-// Emit a beeeeeep
-void wxBell()
-{
-    ::MessageBeep((UINT)-1);        // default sound
+    if ( user.empty() || user == wxGetUserId() )
+        wxGetHomeDir(&home);
+
+    return home;

 }
 
 }
 

-wxString wxGetOsDescription()
+bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))

 {
 {

-#ifdef __WIN32__
-    wxString str;
-
-    OSVERSIONINFO info;
-    wxZeroMemory(info);
+#ifdef __WXWINCE__
+    // TODO-CE
+    return false;
+#else
+    if ( path.empty() )
+        return false;
+
+// old w32api don't have ULARGE_INTEGER
+#if defined(__WIN32__) && \
+    (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
+    // GetDiskFreeSpaceEx() is not available under original Win95, check for
+    // it
+    typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
+                                                PULARGE_INTEGER,
+                                                PULARGE_INTEGER,
+                                                PULARGE_INTEGER);
+
+    GetDiskFreeSpaceEx_t
+        pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
+                              (
+                                ::GetModuleHandle(wxT("kernel32.dll")),
+#if wxUSE_UNICODE
+                                "GetDiskFreeSpaceExW"
+#else
+                                "GetDiskFreeSpaceExA"
+#endif
+                              );

 
 

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

     {
     {

-        switch ( info.dwPlatformId )
+        ULARGE_INTEGER bytesFree, bytesTotal;
+
+        // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
+        if ( !pGetDiskFreeSpaceEx(path.t_str(),
+                                  &bytesFree,
+                                  &bytesTotal,
+                                  NULL) )

         {
         {

-            case VER_PLATFORM_WIN32s:
-                str = _("Win32s on Windows 3.1");
-                break;
+            wxLogLastError(wxT("GetDiskFreeSpaceEx"));

 
 

-            case VER_PLATFORM_WIN32_WINDOWS:
-                str.Printf(_("Windows 9%c"),
-                           info.dwMinorVersion == 0 ? _T('5') : _T('9'));
-                if ( !wxIsEmpty(info.szCSDVersion) )
-                {
-                    str << _T(" (") << info.szCSDVersion << _T(')');
-                }
-                break;
+            return false;
+        }

 
 

-            case VER_PLATFORM_WIN32_NT:
-                str.Printf(_T("Windows NT %lu.%lu (build %lu"),
-                           info.dwMajorVersion,
-                           info.dwMinorVersion,
-                           info.dwBuildNumber);
-                if ( !wxIsEmpty(info.szCSDVersion) )
-                {
-                    str << _T(", ") << info.szCSDVersion;
-                }
-                str << _T(')');
-                break;
+        // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
+        // two 32 bit fields which may be or may be not named - try to make it
+        // compile in all cases
+#if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
+        #define UL(ul) ul.u
+#else // anon union
+        #define UL(ul) ul
+#endif
+        if ( pTotal )
+        {
+#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
         }
     }
     else

+#endif // Win32

     {
     {

-        wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
-    }
+        // there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
+        // should be used instead - but if it's not available, fall back on
+        // GetDiskFreeSpace() nevertheless...
+
+        DWORD lSectorsPerCluster,
+              lBytesPerSector,
+              lNumberOfFreeClusters,
+              lTotalNumberOfClusters;
+
+        // FIXME: this is wrong, we should extract the root drive from path
+        //        instead, but this is the job for wxFileName...
+        if ( !::GetDiskFreeSpace(path.t_str(),
+                                 &lSectorsPerCluster,
+                                 &lBytesPerSector,
+                                 &lNumberOfFreeClusters,
+                                 &lTotalNumberOfClusters) )
+        {
+            wxLogLastError(wxT("GetDiskFreeSpace"));

 
 

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

 
 

-int wxGetOsVersion(int *majorVsn, int *minorVsn)
-{
-#if defined(__WIN32__) && !defined(__SC__)
-    OSVERSIONINFO info;
-    wxZeroMemory(info);
+        wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;
+        lBytesPerCluster *= lBytesPerSector;

 
 

-    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-    if ( ::GetVersionEx(&info) )
-    {
-        if (majorVsn)
-            *majorVsn = info.dwMajorVersion;
-        if (minorVsn)
-            *minorVsn = info.dwMinorVersion;
-        
-        switch ( info.dwPlatformId )
+        if ( pTotal )

         {
         {

-            case VER_PLATFORM_WIN32s:
-                return wxWIN32S;
-
-            case VER_PLATFORM_WIN32_WINDOWS:
-                return wxWIN95;
+            *pTotal = lBytesPerCluster;
+            *pTotal *= lTotalNumberOfClusters;
+        }

 
 

-            case VER_PLATFORM_WIN32_NT:
-                return wxWINDOWS_NT;
+        if ( pFree )
+        {
+            *pFree = lBytesPerCluster;
+            *pFree *= lNumberOfFreeClusters;

         }
     }
 
         }
     }
 

-    return wxWINDOWS; // error if we get here, return generic value
-#else // Win16
-    int retValue = wxWINDOWS;
-    #ifdef __WINDOWS_386__
-        retValue = wxWIN386;
-    #else
-        #if !defined(__WATCOMC__) && !defined(GNUWIN32) && wxUSE_PENWINDOWS
-            extern HANDLE g_hPenWin;
-            retValue = g_hPenWin ? wxPENWINDOWS : wxWINDOWS;
-        #endif
-    #endif
-
-    if (majorVsn)
-        *majorVsn = 3;
-    if (minorVsn)
-        *minorVsn = 1;
-
-    return retValue;
+    return true;

 #endif
 #endif

+    // __WXWINCE__

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

-// sleep functions
+// env vars

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-#if wxUSE_GUI
-
-// Sleep for nSecs seconds. Attempt a Windows implementation using timers.
-static bool gs_inTimer = FALSE;
-
-class wxSleepTimer: public wxTimer
+bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var),
+              wxString *WXUNUSED_IN_WINCE(value))

 {
 {

-public:
-    virtual void Notify()
+#ifdef __WXWINCE__
+    // no environment variables under CE
+    return false;
+#else // Win32
+    // first get the size of the buffer
+    DWORD dwRet = ::GetEnvironmentVariable(var.t_str(), NULL, 0);
+    if ( !dwRet )

     {
     {

-        gs_inTimer = FALSE;
-        Stop();
+        // this means that there is no such variable
+        return false;

     }
     }

-};
-
-static wxTimer *wxTheSleepTimer = NULL;
-
-void wxUsleep(unsigned long milliseconds)
-{
-#ifdef __WIN32__
-    ::Sleep(milliseconds);
-#else
-    if (gs_inTimer)
-        return;

 
 

-    wxTheSleepTimer = new wxSleepTimer;
-    gs_inTimer = TRUE;
-    wxTheSleepTimer->Start(milliseconds);
-    while (gs_inTimer)
+    if ( value )

     {
     {

-        if (wxTheApp->Pending())
-            wxTheApp->Dispatch();
+        (void)::GetEnvironmentVariable(var.t_str(),
+                                       wxStringBuffer(*value, dwRet),
+                                       dwRet);

     }
     }

-    delete wxTheSleepTimer;
-    wxTheSleepTimer = NULL;
-#endif
+
+    return true;
+#endif // WinCE/32

 }
 
 }
 

-void wxSleep(int nSecs)
+bool wxDoSetEnv(const wxString& var, const wxChar *value)

 {
 {

-    if (gs_inTimer)
-        return;
-
-    wxTheSleepTimer = new wxSleepTimer;
-    gs_inTimer = TRUE;
-    wxTheSleepTimer->Start(nSecs*1000);
-    while (gs_inTimer)
+#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__) || defined(__MINGW32__)
+    // 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) )

     {
     {

-        if (wxTheApp->Pending())
-            wxTheApp->Dispatch();
+        wxLogLastError(wxT("SetEnvironmentVariable"));
+
+        return false;

     }
     }

-    delete wxTheSleepTimer;
-    wxTheSleepTimer = NULL;
-}
+#endif // compiler

 
 

-// Consume all events until no more left
-void wxFlushEvents()
-{
-//  wxYield();
+    return true;
+#endif // __WXWINCE__/!__WXWINCE__

 }
 
 }
 

-#elif defined(__WIN32__) // wxUSE_GUI
-
-void wxUsleep(unsigned long milliseconds)
+bool wxSetEnv(const wxString& variable, const wxString& value)

 {
 {

-    ::Sleep(milliseconds);
+    return wxDoSetEnv(variable, value.t_str());

 }
 
 }
 

-void wxSleep(int nSecs)
+bool wxUnsetEnv(const wxString& variable)

 {
 {

-    wxUsleep(1000*nSecs);
+    return wxDoSetEnv(variable, NULL);

 }
 
 }
 

-#endif // wxUSE_GUI/!wxUSE_GUI
-

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-// deprecated (in favour of wxLog) log functions
+// process management

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-#if wxUSE_GUI
-
-// Output a debug mess., in a system dependent fashion.
-void wxDebugMsg(const wxChar *fmt ...)
+// structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
+struct wxFindByPidParams

 {
 {

-  va_list ap;
-  static wxChar buffer[512];
+    wxFindByPidParams() { hwnd = 0; pid = 0; }

 
 

-  if (!wxTheApp->GetWantDebugOutput())
-    return ;
+    // the HWND used to return the result
+    HWND hwnd;

 
 

-  va_start(ap, fmt);
+    // the PID we're looking from
+    DWORD pid;

 
 

-  wvsprintf(buffer,fmt,ap) ;
-  OutputDebugString((LPCTSTR)buffer) ;
-
-  va_end(ap);
-}
+    wxDECLARE_NO_COPY_CLASS(wxFindByPidParams);
+};

 
 

-// Non-fatal error: pop up message box and (possibly) continue
-void wxError(const wxString& msg, const wxString& title)
+// wxKill helper: EnumWindows() callback which is used to find the first (top
+// level) window belonging to the given process
+BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)

 {
 {

-  wxSprintf(wxBuffer, wxT("%s\nContinue?"), WXSTRINGCAST msg);
-  if (MessageBox(NULL, (LPCTSTR)wxBuffer, (LPCTSTR)WXSTRINGCAST title,
-             MB_ICONSTOP | MB_YESNO) == IDNO)
-    wxExit();
-}
+    DWORD pid;
+    (void)::GetWindowThreadProcessId(hwnd, &pid);

 
 

-// Fatal error: pop up message box and abort
-void wxFatalError(const wxString& msg, const wxString& title)
-{
-  wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg);
-  FatalAppExit(0, (LPCTSTR)wxBuffer);
-}
+    wxFindByPidParams *params = (wxFindByPidParams *)lParam;
+    if ( pid == params->pid )
+    {
+        // remember the window we found
+        params->hwnd = hwnd;

 
 

-// ----------------------------------------------------------------------------
-// functions to work with .INI files
-// ----------------------------------------------------------------------------
+        // return FALSE to stop the enumeration
+        return FALSE;
+    }

 
 

-// Reading and writing resources (eg WIN.INI, .Xdefaults)
-#if wxUSE_RESOURCES
-bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
-{
-  if (file != wxT(""))
-// Don't know what the correct cast should be, but it doesn't
-// compile in BC++/16-bit without this cast.
-#if !defined(__WIN32__)
-    return (WritePrivateProfileString((const char*) section, (const char*) entry, (const char*) value, (const char*) file) != 0);
-#else
-    return (WritePrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)value, (LPCTSTR)WXSTRINGCAST file) != 0);
-#endif
-  else
-    return (WriteProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)WXSTRINGCAST value) != 0);
+    // continue enumeration
+    return TRUE;

 }
 
 }
 

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

 {
 {

-    wxString buf;
-    buf.Printf(wxT("%.4f"), value);
+    if (flags & wxKILL_CHILDREN)
+        wxKillAllChildren(pid, sig, krc);

 
 

-    return wxWriteResource(section, entry, buf, file);
-}
+    // get the process handle to operate on
+    DWORD dwAccess = PROCESS_QUERY_INFORMATION | SYNCHRONIZE;
+    if ( sig == wxSIGKILL )
+        dwAccess |= PROCESS_TERMINATE;

 
 

-bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
-{
-    wxString buf;
-    buf.Printf(wxT("%ld"), value);
+    HANDLE hProcess = ::OpenProcess(dwAccess, FALSE, (DWORD)pid);
+    if ( hProcess == NULL )
+    {
+        if ( krc )
+        {
+            // 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 wxWriteResource(section, entry, buf, file);
-}
+        return -1;
+    }

 
 

-bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
-{
-    wxString buf;
-    buf.Printf(wxT("%d"), value);
+    wxON_BLOCK_EXIT1(::CloseHandle, hProcess);

 
 

-    return wxWriteResource(section, entry, buf, file);
-}
+    // Default timeout for waiting for the process termination after killing
+    // it. It should be long enough to allow the process to terminate even on a
+    // busy system but short enough to avoid blocking the main thread for too
+    // long.
+    DWORD waitTimeout = 500; // ms

 
 

-bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file)
-{
-    static const wxChar defunkt[] = wxT("$$default");
-    if (file != wxT(""))
+    bool ok = true;
+    switch ( sig )

     {
     {

-        int n = GetPrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
-                (LPTSTR)wxBuffer, 1000, (LPCTSTR)WXSTRINGCAST file);
-        if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
-            return FALSE;
+        case wxSIGKILL:
+            // kill the process forcefully returning -1 as error code
+            if ( !::TerminateProcess(hProcess, (UINT)-1) )
+            {
+                wxLogSysError(_("Failed to kill process %d"), pid);
+
+                if ( krc )
+                {
+                    // this is not supposed to happen if we could open the
+                    // process
+                    *krc = wxKILL_ERROR;
+                }
+
+                ok = false;
+            }
+            break;
+
+        case wxSIGNONE:
+            // Opening the process handle may succeed for a process even if it
+            // doesn't run any more (typically because open handles to it still
+            // exist elsewhere, possibly in this process itself if we're
+            // killing a child process) so we still need check if it hasn't
+            // terminated yet but, unlike when killing it, we don't need to
+            // wait for any time at all.
+            waitTimeout = 0;
+            break;
+
+        default:
+            // any other signal means "terminate"
+            {
+                wxFindByPidParams params;
+                params.pid = (DWORD)pid;
+
+                // EnumWindows() has nice semantics: it returns 0 if it found
+                // something or if an error occurred and non zero if it
+                // enumerated all the window
+                if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
+                {
+                    // did we find any window?
+                    if ( params.hwnd )
+                    {
+                        // tell the app to close
+                        //
+                        // NB: this is the harshest way, the app won't have 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(wxT("PostMessage(WM_QUIT)"));
+                        }
+                    }
+                    else // it was an error then
+                    {
+                        wxLogLastError(wxT("EnumWindows"));
+
+                        ok = false;
+                    }
+                }
+                else // no windows for this PID
+                {
+                    if ( krc )
+                        *krc = wxKILL_ERROR;
+
+                    ok = false;
+                }
+            }

     }
     }

-    else
+
+    // the return code
+    if ( ok )

     {
     {

-        int n = GetProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
-                (LPTSTR)wxBuffer, 1000);
-        if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
-            return FALSE;
+        // as we wait for a short time, we can use just WaitForSingleObject()
+        // and not MsgWaitForMultipleObjects()
+        switch ( ::WaitForSingleObject(hProcess, waitTimeout) )
+        {
+            case WAIT_OBJECT_0:
+                // Process terminated: normally this indicates that we
+                // successfully killed it but when testing for the process
+                // existence, this means failure.
+                if ( sig == wxSIGNONE )
+                {
+                    if ( krc )
+                        *krc = wxKILL_NO_PROCESS;
+
+                    ok = false;
+                }
+                break;
+
+            default:
+                wxFAIL_MSG( wxT("unexpected WaitForSingleObject() return") );
+                // fall through
+
+            case WAIT_FAILED:
+                wxLogLastError(wxT("WaitForSingleObject"));
+                // fall through
+
+            case WAIT_TIMEOUT:
+                // Process didn't terminate: normally this is a failure but not
+                // when we're just testing for its existence.
+                if ( sig != wxSIGNONE )
+                {
+                    if ( krc )
+                        *krc = wxKILL_ERROR;
+
+                    ok = false;
+                }
+                break;
+        }

     }
     }

-    if (*value) delete[] (*value);
-    *value = copystring(wxBuffer);
-    return TRUE;
+
+
+    // the return code is the same as from Unix kill(): 0 if killed
+    // successfully or -1 on error
+    if ( !ok )
+        return -1;
+
+    if ( krc )
+        *krc = wxKILL_OK;
+
+    return 0;

 }
 
 }
 

-bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
+typedef HANDLE (WINAPI *CreateToolhelp32Snapshot_t)(DWORD,DWORD);
+typedef BOOL (WINAPI *Process32_t)(HANDLE,LPPROCESSENTRY32);
+
+CreateToolhelp32Snapshot_t lpfCreateToolhelp32Snapshot;
+Process32_t lpfProcess32First, lpfProcess32Next;
+
+static void InitToolHelp32()

 {
 {

-    wxChar *s = NULL;
-    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
-    if (succ)
-    {
-        *value = (float)wxStrtod(s, NULL);
-        delete[] s;
-        return TRUE;
-    }
-    else return FALSE;
+    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

 }
 
 }
 

-bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
+// By John Skiff
+int wxKillAllChildren(long pid, wxSignal sig, wxKillError *krc)

 {
 {

-    wxChar *s = NULL;
-    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
-    if (succ)
-    {
-        *value = wxStrtol(s, NULL, 10);
-        delete[] s;
-        return TRUE;
+    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;

     }
     }

-    else return FALSE;
-}

 
 

-bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
-{
-    wxChar *s = NULL;
-    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
-    if (succ)
-    {
-        *value = (int)wxStrtol(s, NULL, 10);
-        delete[] s;
-        return TRUE;
+    //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;

     }
     }

-    else return FALSE;
-}
-#endif // wxUSE_RESOURCES

 
 

-// ---------------------------------------------------------------------------
-// helper functions for showing a "busy" cursor
-// ---------------------------------------------------------------------------
+    do {
+        if (pe.th32ParentProcessID == (DWORD) pid) {
+            if (wxKill(pe.th32ProcessID, sig, krc))
+                return -1;
+        }
+    } while (lpfProcess32Next (hProcessSnap, &pe));

 
 

-static HCURSOR gs_wxBusyCursor = 0;     // new, busy cursor
-static HCURSOR gs_wxBusyCursorOld = 0;  // old cursor
-static int gs_wxBusyCursorCount = 0;

 
 

-extern HCURSOR wxGetCurrentBusyCursor()
-{
-    return gs_wxBusyCursor;
+    return 0;

 }
 
 }
 

-// Set the cursor to the busy cursor for all windows
-void wxBeginBusyCursor(wxCursor *cursor)
+// Execute a program in an Interactive Shell
+bool wxShell(const wxString& command)

 {
 {

-    if ( gs_wxBusyCursorCount++ == 0 )
+    wxString cmd;
+
+#ifdef __WXWINCE__
+    cmd = command;
+#else
+    wxChar *shell = wxGetenv(wxT("COMSPEC"));
+    if ( !shell )
+        shell = (wxChar*) wxT("\\COMMAND.COM");
+
+    if ( !command )
+    {
+        // just the shell
+        cmd = shell;
+    }
+    else

     {
     {

-        gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
-        gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
+        // pass the command to execute to the command processor
+        cmd.Printf(wxT("%s /c %s"), shell, command.c_str());

     }
     }

-    //else: nothing to do, already set
+#endif
+
+    return wxExecute(cmd, wxEXEC_SYNC) == 0;

 }
 
 }
 

-// Restore cursor to normal
-void wxEndBusyCursor()
+// Shutdown or reboot the PC
+bool wxShutdown(int WXUNUSED_IN_WINCE(flags))

 {
 {

-    wxCHECK_RET( gs_wxBusyCursorCount > 0,
-                 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
+#ifdef __WXWINCE__
+    // TODO-CE
+    return false;
+#elif defined(__WIN32__)
+    bool bOK = true;

 
 

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

     {
     {

-        ::SetCursor(gs_wxBusyCursorOld);
+        // Get a token for this process.
+        HANDLE hToken;
+        bOK = ::OpenProcessToken(GetCurrentProcess(),
+                                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                                 &hToken) != 0;
+        if ( bOK )
+        {
+            TOKEN_PRIVILEGES tkp;
+
+            // Get the LUID for the shutdown privilege.
+            bOK = ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
+                                         &tkp.Privileges[0].Luid) != 0;
+
+            if ( bOK )
+            {
+                tkp.PrivilegeCount = 1;  // one privilege to set
+                tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

 
 

-        gs_wxBusyCursorOld = 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;
+            }
+
+            ::CloseHandle(hToken);
+        }

     }
     }

+
+    if ( bOK )
+    {
+        UINT wFlags = 0;
+        if ( flags & wxSHUTDOWN_FORCE )
+        {
+            wFlags = EWX_FORCE;
+            flags &= ~wxSHUTDOWN_FORCE;
+        }
+
+        switch ( flags )
+        {
+            case wxSHUTDOWN_POWEROFF:
+                wFlags |= EWX_POWEROFF;
+                break;
+
+            case wxSHUTDOWN_REBOOT:
+                wFlags |= EWX_REBOOT;
+                break;
+
+            case wxSHUTDOWN_LOGOFF:
+                wFlags |= EWX_LOGOFF;
+                break;
+
+            default:
+                wxFAIL_MSG( wxT("unknown wxShutdown() flag") );
+                return false;
+        }
+
+        bOK = ::ExitWindowsEx(wFlags, 0) != 0;
+    }
+
+    return bOK;
+#endif // WinCE/!WinCE

 }
 
 }
 

-// TRUE if we're between the above two calls
-bool wxIsBusy()
+// ----------------------------------------------------------------------------
+// misc
+// ----------------------------------------------------------------------------
+
+// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
+wxMemorySize wxGetFreeMemory()

 {
 {

-  return (gs_wxBusyCursorCount > 0);
+#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 (wxMemorySize)memStatus.dwAvailPhys;
+#endif

 }
 
 }
 

-// Check whether this window wants to process messages, e.g. Stop button
-// in long calculations.
-bool wxCheckForInterrupt(wxWindow *wnd)
+unsigned long wxGetProcessId()

 {
 {

-    wxCHECK( wnd, FALSE );
+    return ::GetCurrentProcessId();
+}

 
 

-    MSG msg;
-    while ( ::PeekMessage(&msg, GetHwndOf(wnd), 0, 0, PM_REMOVE) )
+// Emit a beeeeeep
+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")) )

     {
     {

-        ::TranslateMessage(&msg);
-        ::DispatchMessage(&msg);
+        // no way to know, assume no
+        return false;

     }
 
     }
 

-    return TRUE;
+    return (*(IsDebuggerPresent_t)dll.GetSymbol(wxT("IsDebuggerPresent")))() != 0;
+#else
+    return false;
+#endif

 }
 
 }
 

-#endif // wxUSE_GUI
-
-// MSW only: get user-defined resource from the .res file.
-// Returns NULL or newly-allocated memory, so use delete[] to clean up.
+// ----------------------------------------------------------------------------
+// working with MSW resources
+// ----------------------------------------------------------------------------

 
 

-wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
+bool
+wxLoadUserResource(const void **outData,
+                   size_t *outLen,
+                   const wxString& resourceName,
+                   const wxString& resourceType,
+                   WXHINSTANCE instance)

 {
 {

-    HRSRC hResource = ::FindResource(wxGetInstance(), resourceName, resourceType);
-    if ( hResource == 0 )
-        return NULL;
+    wxCHECK_MSG( outData && outLen, false, "output pointers can't be NULL" );

 
 

-    HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
-    if ( hData == 0 )
-        return NULL;
+    HRSRC hResource = ::FindResource(instance,
+                                     resourceName.wx_str(),
+                                     resourceType.wx_str());
+    if ( !hResource )
+        return false;

 
 

-    wxChar *theText = (wxChar *)::LockResource(hData);
-    if ( !theText )
-        return NULL;
+    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;
+    }

 
 

-    // Not all compilers put a zero at the end of the resource (e.g. BC++ doesn't).
-    // so we need to find the length of the resource.
-    int len = ::SizeofResource(wxGetInstance(), hResource);
-    wxChar  *s = new wxChar[len+1];
-    wxStrncpy(s,theText,len);
-    s[len]=0;
+    *outLen = ::SizeofResource(instance, hResource);

 
 

-    // wxChar *s = copystring(theText);
+    // Notice that we do not need to call neither UnlockResource() (which is
+    // obsolete in Win32) nor GlobalFree() (resources are freed on process
+    // termination only)

 
 

-    // Obsolete in WIN32
-#ifndef __WIN32__
-    UnlockResource(hData);
-#endif
+    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

 
 

-    // No need??
-    //  GlobalFree(hData);
+    if (pLen)
+      *pLen = len;

 
     return s;
 }
 
 // ----------------------------------------------------------------------------
 
     return s;
 }
 
 // ----------------------------------------------------------------------------

-// get display info
+// OS version

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-void wxGetMousePosition( int* x, int* y )
+// 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

 {
 {

-    POINT pt;
-    GetCursorPos( & pt );
-    if ( x ) *x = pt.x;
-    if ( y ) *y = pt.y;
-};

 
 

-// Return TRUE if we have a colour display
-bool wxColourDisplay()
+int wxIsWindowsServer()

 {
 {

-    ScreenHDC dc;
-    int noCols = GetDeviceCaps(dc, NUMCOLORS);
-
-    return (noCols == -1) || (noCols > 2);
-}
+#ifdef VER_NT_WORKSTATION
+    OSVERSIONINFOEX info;
+    wxZeroMemory(info);

 
 

-// Returns depth of screen
-int wxDisplayDepth()
-{
-    ScreenHDC dc;
-    return GetDeviceCaps(dc, PLANES) * GetDeviceCaps(dc, BITSPIXEL);
-}
+    info.dwOSVersionInfoSize = sizeof(info);
+    if ( ::GetVersionEx(reinterpret_cast<OSVERSIONINFO *>(&info)) )
+    {
+        switch ( info.wProductType )
+        {
+            case VER_NT_WORKSTATION:
+                return false;

 
 

-// Get size of display
-void wxDisplaySize(int *width, int *height)
-{
-    ScreenHDC dc;
+            case VER_NT_SERVER:
+            case VER_NT_DOMAIN_CONTROLLER:
+                return true;
+        }
+    }
+#endif // VER_NT_WORKSTATION

 
 

-    if ( width ) *width = GetDeviceCaps(dc, HORZRES);
-    if ( height ) *height = GetDeviceCaps(dc, VERTRES);
+    return -1;

 }
 
 }
 

-// ---------------------------------------------------------------------------
-// window information functions
-// ---------------------------------------------------------------------------
+} // anonymous namespace

 
 

-wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
+wxString wxGetOsDescription()

 {
     wxString str;
 {
     wxString str;

-    int len = GetWindowTextLength((HWND)hWnd) + 1;
-    GetWindowText((HWND)hWnd, str.GetWriteBuf(len), len);
-    str.UngetWriteBuf();
+
+    OSVERSIONINFO info;
+    wxZeroMemory(info);
+
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    if ( ::GetVersionEx(&info) )
+    {
+        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:
+                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 << wxT(" (") << info.szCSDVersion << wxT(')');
+                }
+                break;
+
+            case VER_PLATFORM_WIN32_NT:
+                switch ( info.dwMajorVersion )
+                {
+                    case 5:
+                        switch ( info.dwMinorVersion )
+                        {
+                            case 0:
+                                str = _("Windows 2000");
+                                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 = _("Windows Server 2003");
+                                    break;
+                                }
+                                //else: must be XP, fall through
+
+                            case 1:
+                                str = _("Windows XP");
+                                break;
+                        }
+                        break;
+
+                    case 6:
+                        switch ( info.dwMinorVersion )
+                        {
+                            case 0:
+                                str = wxIsWindowsServer() == 1
+                                        ? _("Windows Server 2008")
+                                        : _("Windows Vista");
+                                break;
+
+                            case 1:
+                                str = wxIsWindowsServer() == 1
+                                        ? _("Windows Server 2008 R2")
+                                        : _("Windows 7");
+                                break;
+                        }
+                        break;
+                }
+
+                if ( str.empty() )
+                {
+                    str.Printf(_("Windows NT %lu.%lu"),
+                               info.dwMajorVersion,
+                               info.dwMinorVersion);
+                }
+
+                str << wxT(" (")
+                    << wxString::Format(_("build %lu"), info.dwBuildNumber);
+                if ( !wxIsEmpty(info.szCSDVersion) )
+                {
+                    str << wxT(", ") << info.szCSDVersion;
+                }
+                str << wxT(')');
+
+                if ( wxIsPlatform64Bit() )
+                    str << _(", 64-bit edition");
+                break;
+        }
+    }
+    else
+    {
+        wxFAIL_MSG( wxT("GetVersionEx() failed") ); // should never happen
+    }

 
     return str;
 }
 
 
     return str;
 }
 

-wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
+bool wxIsPlatform64Bit()

 {
 {

-    wxString str;
+#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

 
 

-    int len = 256; // some starting value
+    return wow64 != FALSE;
+#else
+    return false;
+#endif // Win64/Win32
+}

 
 

-    for ( ;; )
+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 )

     {
     {

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

         {
         {

-            // the class name might have been truncated, retry with larger
-            // buffer
-            len *= 2;
+            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_WIN32_NT:
+                    s_version.os = wxOS_WINDOWS_NT;
+                    break;
+
+                case VER_PLATFORM_WIN32_WINDOWS:
+                    s_version.os = wxOS_WINDOWS_9X;
+                    break;
+            }
+#endif // Windows versions
+
+            s_version.verMaj = info.dwMajorVersion;
+            s_version.verMin = info.dwMinorVersion;

         }
         }

-        else
+        else // GetVersionEx() failed

         {
         {

-            break;
+            s_version.initialized = -1;

         }
     }
 
         }
     }
 

-    return str;
+    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;

 }
 
 }
 

-WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
+wxWinVersion wxGetWinVersion()

 {
 {

-#ifndef __WIN32__
-    return GetWindowWord((HWND)hWnd, GWW_ID);
-#else // Win32
-    return GetWindowLong((HWND)hWnd, GWL_ID);
-#endif // Win16/32
+    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;
+
+        default:
+            // Do nothing just to silence GCC warning
+            break;
+    }
+
+    return wxWinVersion_Unknown;

 }
 
 }
 

-#if 0
-//------------------------------------------------------------------------
-// wild character routines
-//------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// sleep functions
+// ----------------------------------------------------------------------------

 
 

-bool wxIsWild( const wxString& pattern )
+void wxMilliSleep(unsigned long milliseconds)

 {
 {

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

 
 

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

 
 

-bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
+void wxSleep(int nSecs)

 {
 {

-  wxString tmp1 = pat;
-  char *pattern = WXSTRINGCAST(tmp1);
-  wxString tmp2 = text;
-  char *str = WXSTRINGCAST(tmp2);
-    char c;
-    char *cp;
-    bool done = FALSE, ret_code, ok;
-    // Below is for vi fans
-    const char OB = '{', CB = '}';
-
-    // dot_special means '.' only matches '.'
-    if (dot_special && *str == '.' && *pattern != *str)
-  return FALSE;
-
-    while ((*pattern != '\0') && (!done)
-    && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) {
-  switch (*pattern) {
-  case '\\':
-      pattern++;
-      if (*pattern != '\0')
-    pattern++;
-      break;
-  case '*':
-      pattern++;
-      ret_code = FALSE;
-      while ((*str!='\0')
-      && (!(ret_code=wxMatchWild(pattern, str++, FALSE))))
-    /*loop*/;
-      if (ret_code) {
-    while (*str != '\0')
-        str++;
-    while (*pattern != '\0')
-        pattern++;
-      }
-      break;
-  case '[':
-      pattern++;
-    repeat:
-      if ((*pattern == '\0') || (*pattern == ']')) {
-    done = TRUE;
-    break;
-      }
-      if (*pattern == '\\') {
-    pattern++;
-    if (*pattern == '\0') {
-        done = TRUE;
-        break;
-    }
-      }
-      if (*(pattern + 1) == '-') {
-    c = *pattern;
-    pattern += 2;
-    if (*pattern == ']') {
-        done = TRUE;
-        break;
-    }
-    if (*pattern == '\\') {
-        pattern++;
-        if (*pattern == '\0') {
-      done = TRUE;
-      break;
-        }
-    }
-    if ((*str < c) || (*str > *pattern)) {
-        pattern++;
-        goto repeat;
-    }
-      } else if (*pattern != *str) {
-    pattern++;
-    goto repeat;
-      }
-      pattern++;
-      while ((*pattern != ']') && (*pattern != '\0')) {
-    if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
-        pattern++;
-    pattern++;
-      }
-      if (*pattern != '\0') {
-    pattern++, str++;
-      }
-      break;
-  case '?':
-      pattern++;
-      str++;
-      break;
-  case OB:
-      pattern++;
-      while ((*pattern != CB) && (*pattern != '\0')) {
-    cp = str;
-    ok = TRUE;
-    while (ok && (*cp != '\0') && (*pattern != '\0')
-    &&  (*pattern != ',') && (*pattern != CB)) {
-        if (*pattern == '\\')
-      pattern++;
-        ok = (*pattern++ == *cp++);
-    }
-    if (*pattern == '\0') {
-        ok = FALSE;
-        done = TRUE;
-        break;
-    } else if (ok) {
-        str = cp;
-        while ((*pattern != CB) && (*pattern != '\0')) {
-      if (*++pattern == '\\') {
-          if (*++pattern == CB)
-        pattern++;
-      }
-        }
-    } else {
-        while (*pattern!=CB && *pattern!=',' && *pattern!='\0') {
-      if (*++pattern == '\\') {
-                            if (*++pattern == CB || *pattern == ',')
-        pattern++;
-      }
-        }
-    }
-    if (*pattern != '\0')
-        pattern++;
-      }
-      break;
-  default:
-      if (*str == *pattern) {
-    str++, pattern++;
-      } else {
-    done = TRUE;
-      }
-  }
-    }
-    while (*pattern == '*')
-  pattern++;
-    return ((*str == '\0') && (*pattern == '\0'));
-};
+    wxMilliSleep(1000*nSecs);
+}

 
 

+// ----------------------------------------------------------------------------
+// font encoding <-> Win32 codepage conversion functions
+// ----------------------------------------------------------------------------
+
+extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
+{
+    switch ( encoding )
+    {
+        // although this function is supposed to return an exact match, do do
+        // some mappings here for the most common case of "standard" encoding
+        case wxFONTENCODING_SYSTEM:
+            return DEFAULT_CHARSET;
+
+        case wxFONTENCODING_ISO8859_1:
+        case wxFONTENCODING_ISO8859_15:
+        case wxFONTENCODING_CP1252:
+            return ANSI_CHARSET;
+
+#if !defined(__WXMICROWIN__)
+        // The following four fonts are multi-byte charsets
+        case wxFONTENCODING_CP932:
+            return SHIFTJIS_CHARSET;
+
+        case wxFONTENCODING_CP936:
+            return GB2312_CHARSET;
+
+#ifndef __WXWINCE__
+        case wxFONTENCODING_CP949:
+            return HANGUL_CHARSET;

 #endif
 
 #endif
 

-#if 0
+        case wxFONTENCODING_CP950:
+            return CHINESEBIG5_CHARSET;
+
+        // The rest are single byte encodings
+        case wxFONTENCODING_CP1250:
+            return EASTEUROPE_CHARSET;
+
+        case wxFONTENCODING_CP1251:
+            return RUSSIAN_CHARSET;
+
+        case wxFONTENCODING_CP1253:
+            return GREEK_CHARSET;
+
+        case wxFONTENCODING_CP1254:
+            return TURKISH_CHARSET;
+
+        case wxFONTENCODING_CP1255:
+            return HEBREW_CHARSET;
+
+        case wxFONTENCODING_CP1256:
+            return ARABIC_CHARSET;
+
+        case wxFONTENCODING_CP1257:
+            return BALTIC_CHARSET;
+
+        case wxFONTENCODING_CP874:
+            return THAI_CHARSET;
+#endif // !__WXMICROWIN__
+
+        case wxFONTENCODING_CP437:
+            return OEM_CHARSET;
+
+        default:
+            // no way to translate this encoding into a Windows charset
+            return -1;
+    }
+}
+
+// we have 2 versions of wxCharsetToCodepage(): the old one which directly
+// looks up the vlaues in the registry and the new one which is more
+// politically correct and has more chances to work on other Windows versions
+// as well but the old version is still needed for !wxUSE_FONTMAP case
+#if wxUSE_FONTMAP
+
+#include "wx/fontmap.h"
+
+extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
+{
+    // There don't seem to be symbolic names for
+    // these under Windows so I just copied the
+    // values from MSDN.
+
+    unsigned int ret;
+
+    switch (encoding)
+    {
+        case wxFONTENCODING_ISO8859_1:      ret = 28591; break;
+        case wxFONTENCODING_ISO8859_2:      ret = 28592; break;
+        case wxFONTENCODING_ISO8859_3:      ret = 28593; break;
+        case wxFONTENCODING_ISO8859_4:      ret = 28594; break;
+        case wxFONTENCODING_ISO8859_5:      ret = 28595; break;
+        case wxFONTENCODING_ISO8859_6:      ret = 28596; break;
+        case wxFONTENCODING_ISO8859_7:      ret = 28597; break;
+        case wxFONTENCODING_ISO8859_8:      ret = 28598; break;
+        case wxFONTENCODING_ISO8859_9:      ret = 28599; break;
+        case wxFONTENCODING_ISO8859_10:     ret = 28600; break;
+        case wxFONTENCODING_ISO8859_11:     ret = 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;
+    }

 
 

-// maximum mumber of lines the output console should have
-static const WORD MAX_CONSOLE_LINES = 500;
+    if (::IsValidCodePage(ret) == 0)
+        return -1;

 
 

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

 }
 
 }
 

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

 {
 {

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

 }
 }

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

 {
 {

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

 }
 }

-#endif

 
 

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

 
 

+        if ( !::RegisterClass(&wndclass) )
+        {
+            wxLogLastError(wxT("RegisterClass() in wxCreateHiddenWindow"));
+
+            return NULL;
+        }
+
+        *pclassname = classname;
+    }
+
+    // next create the window
+    HWND hwnd = ::CreateWindow
+                  (
+                    *pclassname,
+                    NULL,
+                    0, 0, 0, 0,
+                    0,
+                    (HWND) NULL,
+                    (HMENU)NULL,
+                    wxGetInstance(),
+                    (LPVOID) NULL
+                  );
+
+    if ( !hwnd )
+    {
+        wxLogLastError(wxT("CreateWindow() in wxCreateHiddenWindow"));
+    }
+
+    return hwnd;
+}