Added ability to switch off more components of the size page UI

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

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index f41729be610f426be21da2d53bd3602c487275c8..afd0bb2e6c0f38742c9bbf3cc2ac680ad7ea31c5 100644 (file)
--- a/src/msw/utils.cpp
+++ b/src/msw/utils.cpp
@@ -1,239 +1,353 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        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

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

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

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

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

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

 #endif  //WX_PRECOMP
 
 #endif  //WX_PRECOMP
 

-#include "wx/msw/private.h"
-#include "wx/timer.h"
-#include "wx/intl.h"
+#include "wx/msw/registry.h"
+#include "wx/apptrait.h"
+#include "wx/dynlib.h"
+#include "wx/dynload.h"
+#include "wx/scopeguard.h"
+#include "wx/filename.h"

 
 

-#include <windows.h>
+#include "wx/confbase.h"        // for wxExpandEnvVars()

 
 

-#include <ctype.h>
+#include "wx/msw/private.h"     // includes <windows.h>
+#include "wx/msw/private/hiddenwin.h"
+#include "wx/msw/missing.h"     // for CHARSET_HANGUL

 
 

-#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__)
-#include <direct.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

 
 

-#ifndef __MWERKS__
-#include <dos.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
 #endif

-#endif  //GNUWIN32

 
 

-#if defined(__GNUWIN32__) && !defined(__TWIN32__)
-#include <sys/unistd.h>
-#include <sys/stat.h>
+#if !defined(__GNUWIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
+    #include <direct.h>
+
+    #include <dos.h>

 #endif  //GNUWIN32
 
 #endif  //GNUWIN32
 

-#include "wx/log.h"
+#if defined(__CYGWIN__)
+    #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
                     // this (3.1 I believe) and how to test for it.
                     // If this works for Borland 4.0 as well, then no worries.
 
 #ifdef __BORLANDC__ // Please someone tell me which version of Borland needs
                     // this (3.1 I believe) and how to test for it.
                     // If this works for Borland 4.0 as well, then no worries.

-#include <dir.h>
+    #include <dir.h>

 #endif
 
 #endif
 

-#if defined(__WIN32__) && !defined(__WXWINE__)
-#include <io.h>
+// VZ: there is some code using NetXXX() functions to get the full user name:
+//     I don't think it's a good idea because they don't work under Win95 and
+//     seem to return the same as wxGetUserId() under NT. If you really want
+//     to use them, just #define USE_NET_API
+#undef USE_NET_API

 
 

-#ifndef __GNUWIN32__
-#include <shellapi.h>
-#endif
+#ifdef USE_NET_API
+    #include <lm.h>
+#endif // USE_NET_API
+
+#if defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
+    #ifndef __UNIX__
+        #include <io.h>
+    #endif
+
+    #ifndef __GNUWIN32__
+        #include <shellapi.h>
+    #endif

 #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"
+// For wxKillAllChildren
+#include <tlhelp32.h>

 
 

-#include <fcntl.h>
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------

 
 

-#include "wx/ioswrap.h"
+// In the WIN.INI file
+#if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)
+static const wxChar WX_SECTION[] = wxT("wxWindows");
+#endif

 
 

-#if wxUSE_IOSTREAMH
-// N.B. BC++ doesn't have istream.h, ostream.h
-#  include <io.h>
-#  include <fstream.h>
-#else
-#  include <fstream>
+#if (!defined(USE_NET_API) && !defined(__WXWINCE__))
+static const wxChar eUSERNAME[]  = wxT("UserName");

 #endif
 
 #endif
 

-/* Need to undef new if including crtdbg.h */
-#  ifdef new
-#  undef new
-#  endif
+WXDLLIMPEXP_DATA_BASE(const wxChar *) wxUserResourceStr = wxT("TEXT");

 
 

-#ifndef __WIN16__
-#  include <crtdbg.h>
-#endif
+// ============================================================================
+// implementation
+// ============================================================================

 
 

-#  if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
-#  define new new(__FILE__,__LINE__)
-#  endif
+// ----------------------------------------------------------------------------
+// get host name and related
+// ----------------------------------------------------------------------------

 
 

-#endif
-  // __VISUALC__
-/// END for console support
+// Get hostname only (without domain name)
+bool wxGetHostName(wxChar *buf, int maxSize)
+{
+#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.t_str(), maxSize);
+#else // !__WXWINCE__
+    DWORD nSize = maxSize;
+    if ( !::GetComputerName(buf, &nSize) )
+    {
+        wxLogLastError(wxT("GetComputerName"));

 
 

-// In the WIN.INI file
-static const char WX_SECTION[] = "wxWindows";
-static const char eHOSTNAME[]  = "HostName";
-static const char eUSERID[]    = "UserId";
-static const char eUSERNAME[]  = "UserName";
-
-// For the following functions we SHOULD fill in support
-// for Windows-NT (which I don't know) as I assume it begin
-// a POSIX Unix (so claims MS) that it has some special
-// functions beyond those provided by WinSock
-
-// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
-bool wxGetHostName(char *buf, int maxSize)
+        return false;
+    }
+#endif // __WXWINCE__/!__WXWINCE__
+
+    return true;
+}
+
+// get full hostname (with domain name if possible)
+bool wxGetFullHostName(wxChar *buf, int maxSize)

 {
 {

-#if defined(__WIN32__) && !defined(__TWIN32__)
-  DWORD nSize = maxSize;
-  return (::GetComputerName(buf, &nSize) != 0);
-#else
-  char *sysname;
-  const char *default_host = "noname";
-
-  if ((sysname = getenv("SYSTEM_NAME")) == NULL) {
-     GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
-  } else
-    strncpy(buf, sysname, maxSize - 1);
-  buf[maxSize] = '\0';
-  return *buf ? TRUE : FALSE;
-#endif
+#if !defined( __WXMICROWIN__) && wxUSE_DYNLIB_CLASS && wxUSE_SOCKETS
+    // TODO should use GetComputerNameEx() when available
+
+    // we don't want to always link with Winsock DLL as we might not use it at
+    // 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() )
+    {
+        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 )
+        {
+            LOAD_WINSOCK_FUNC(gethostname);
+
+            wxString host;
+            if ( pfngethostname )
+            {
+                char bufA[256];
+                if ( pfngethostname(bufA, WXSIZEOF(bufA)) == 0 )
+                {
+                    // gethostname() won't usually include the DNS domain name,
+                    // for this we need to work a bit more
+                    if ( !strchr(bufA, '.') )
+                    {
+                        LOAD_WINSOCK_FUNC(gethostbyname);
+
+                        struct hostent *pHostEnt = pfngethostbyname
+                                                    ? pfngethostbyname(bufA)
+                                                    : NULL;
+
+                        if ( pHostEnt )
+                        {
+                            // Windows will use DNS internally now
+                            LOAD_WINSOCK_FUNC(gethostbyaddr);
+
+                            pHostEnt = pfngethostbyaddr
+                                        ? pfngethostbyaddr(pHostEnt->h_addr,
+                                                           4, AF_INET)
+                                        : NULL;
+                        }
+
+                        if ( pHostEnt )
+                        {
+                            host = wxString::FromAscii(pHostEnt->h_name);
+                        }
+                    }
+                }
+            }
+
+            LOAD_WINSOCK_FUNC(WSACleanup);
+            if ( pfnWSACleanup )
+                pfnWSACleanup();
+
+
+            if ( !host.empty() )
+            {
+                wxStrlcpy(buf, host.c_str(), maxSize);
+
+                return true;
+            }
+        }
+    }
+#endif // !__WXMICROWIN__
+
+    return wxGetHostName(buf, maxSize);

 }
 
 // Get user ID e.g. jacs
 }
 
 // Get user ID e.g. jacs

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

 {
 {

-#if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__)
-
-    // VZ: why should it be so complicated??
-#if 0
-  // Gets the current user's full name according to the MS article PSS ID
-  // Number: Q119670
-  // Seems to be the same as the login name for me?
-  char *UserName = new char[256];
-  char *Domain = new char[256];
-  DWORD maxCharacters = 255;
-  GetUserName( UserName, &maxCharacters );
-  GetComputerName( Domain, &maxCharacters );
-
-  WCHAR  wszUserName[256];           // Unicode user name
-  WCHAR  wszDomain[256];
-  LPBYTE ComputerName;
-
-  struct _SERVER_INFO_100 *si100;   // Server structure
-  struct _USER_INFO_2 *ui;          // User structure
-
-  // Convert ASCII user name and domain to Unicode.
-
-  MultiByteToWideChar( CP_ACP, 0, UserName,
-     strlen(UserName)+1, wszUserName, sizeof(wszUserName) );
-  MultiByteToWideChar( CP_ACP, 0, Domain,
-     strlen(Domain)+1, wszDomain, sizeof(wszDomain) );
-
-  // Get the computer name of a DC for the specified domain.
-  // >If you get a link error on this, include netapi32.lib<
-
-  NetGetDCName( NULL, wszDomain, &ComputerName );
-
-  // Look up the user on the DC.
-
-  if(NetUserGetInfo( (LPWSTR) ComputerName,
-     (LPWSTR) &wszUserName, 2, (LPBYTE *) &ui))
-  {
-     printf( "Error getting user information.\n" );
-     return( FALSE );
-  }
-
-  // Convert the Unicode full name to ASCII.
-
-  WideCharToMultiByte( CP_ACP, 0, ui->usri2_full_name,
-     -1, buf, 256, NULL, NULL );
-  }
-  return( TRUE );
-#else   // 1
+#if defined(__WXWINCE__)
+    // TODO-CE
+    return false;
+#else

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

-        wxLogSysError("Can not get user name");
-
-        return FALSE;
+        // actually, it does happen on Win9x if the user didn't log on
+        DWORD res = ::GetEnvironmentVariable(wxT("username"), buf, maxSize);
+        if ( res == 0 )
+        {
+            // not found
+            return false;
+        }

     }
 
     }
 

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

 #endif
 }
 
 // Get user name e.g. Julian Smart
 #endif
 }
 
 // Get user name e.g. Julian Smart

-bool wxGetUserName(char *buf, int maxSize)
+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 )
+    {
+        wxLogError(wxT("Cannot find domain controller"));
+
+        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);
+
+            goto error;
+
+        default:
+            wxLogSysError(wxT("Can't get information about user"));
+
+            goto error;
+    }
+
+    // Convert the Unicode full name to ANSI
+    WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
+            buf, maxSize, NULL, NULL );
+
+    return true;
+
+error:
+    wxLogError(wxT("Couldn't look up full user name."));
+
+    return false;
+#else  // !USE_NET_API

     // Could use NIS, MS-Mail or other site specific programs
     // Could use NIS, MS-Mail or other site specific programs

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

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


@@ -241,982 +355,1412 @@ bool wxGetUserName(char *buf, int maxSize)
 
     if ( !ok )
     {
 
     if ( !ok )
     {

-        strncpy(buf, "Unknown User", maxSize);
+        wxStrlcpy(buf, wxT("Unknown User"), maxSize);

     }
     }

-  }

 
 

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

 }
 
 }
 

-int wxKill(long pid, int sig)
+const wxChar* wxGetHomeDir(wxString *pstr)

 {
 {

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

 }
 
 }
 

-//
-// Execute a program in an Interactive Shell
-//
-bool
-wxShell(const wxString& command)
+wxString wxGetUserHome(const wxString& user)

 {
 {

-  char *shell;
-  if ((shell = getenv("COMSPEC")) == NULL)
-    shell = "\\COMMAND.COM";
+    wxString home;

 
 

-  char tmp[255];
-  if (command != "")
-    sprintf(tmp, "%s /c %s", shell, WXSTRINGCAST command);
-  else
-    strcpy(tmp, shell);
+    if ( user.empty() || user == wxGetUserId() )
+        wxGetHomeDir(&home);

 
 

-  return (wxExecute((char *)tmp, FALSE) != 0);
+    return home;

 }
 
 }
 

-// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
-long wxGetFreeMemory()
+bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))

 {
 {

-#if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
-  MEMORYSTATUS memStatus;
-  memStatus.dwLength = sizeof(MEMORYSTATUS);
-  GlobalMemoryStatus(&memStatus);
-  return memStatus.dwAvailPhys;
+#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
 #else

-  return (long)GetFreeSpace(0);
+                                "GetDiskFreeSpaceExA"

 #endif
 #endif

-}
+                              );

 
 

-// Sleep for nSecs seconds. Attempt a Windows implementation using timers.
-static bool inTimer = FALSE;
-class wxSleepTimer: public wxTimer
-{
- public:
-  inline void Notify()
-  {
-    inTimer = FALSE;
-    Stop();
-  }
-};
+    if ( pGetDiskFreeSpaceEx )
+    {
+        ULARGE_INTEGER bytesFree, bytesTotal;

 
 

-static wxTimer *wxTheSleepTimer = NULL;
+        // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
+        if ( !pGetDiskFreeSpaceEx(path.t_str(),
+                                  &bytesFree,
+                                  &bytesTotal,
+                                  NULL) )
+        {
+            wxLogLastError(wxT("GetDiskFreeSpaceEx"));

 
 

-void wxUsleep(unsigned long milliseconds)
-{
-#ifdef __WIN32__
-    ::Sleep(milliseconds);
+            return false;
+        }
+
+        // ULARGE_INTEGER is a union of a 64 bit value and a struct containing
+        // two 32 bit fields which may be or may be not named - try to make it
+        // compile in all cases
+#if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
+        #define UL(ul) ul.u
+#else // anon union
+        #define UL(ul) ul
+#endif
+        if ( pTotal )
+        {
+#if wxUSE_LONGLONG
+            *pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);

 #else
 #else

-  if (inTimer)
-    return;
-
-  wxTheSleepTimer = new wxSleepTimer;
-  inTimer = TRUE;
-  wxTheSleepTimer->Start(milliseconds);
-  while (inTimer)
-  {
-    if (wxTheApp->Pending())
-      wxTheApp->Dispatch();
-  }
-  delete wxTheSleepTimer;
-  wxTheSleepTimer = NULL;
+            *pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);

 #endif
 #endif

-}
+        }

 
 

-void wxSleep(int nSecs)
-{
-#if 0 // WIN32 hangs app
-  Sleep( 1000*nSecs );
+        if ( pFree )
+        {
+#if wxUSE_LONGLONG
+            *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);

 #else
 #else

-  if (inTimer)
-    return;
-
-  wxTheSleepTimer = new wxSleepTimer;
-  inTimer = TRUE;
-  wxTheSleepTimer->Start(nSecs*1000);
-  while (inTimer)
-  {
-    if (wxTheApp->Pending())
-      wxTheApp->Dispatch();
-  }
-  delete wxTheSleepTimer;
-  wxTheSleepTimer = NULL;
+            *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);

 #endif
 #endif

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

 
 

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

 
 

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

 
 

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

 
 

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

 
 

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

 }
 
 }
 

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

 
 

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

 {
 {

-  sprintf(wxBuffer, "%s: %s", WXSTRINGCAST title, WXSTRINGCAST msg);
-  FatalAppExit(0, (LPCSTR)wxBuffer);
-}
+#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 )
+    {
+        // this means that there is no such variable
+        return false;
+    }

 
 

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

 
 

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

 }
 
 }
 

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

 {
 {

-  if (file != "")
-    return (WritePrivateProfileString((LPCSTR)WXSTRINGCAST section, (LPCSTR)WXSTRINGCAST entry, (LPCSTR)value, (LPCSTR)WXSTRINGCAST file) != 0);
-  else
-    return (WriteProfileString((LPCSTR)WXSTRINGCAST section, (LPCSTR)WXSTRINGCAST entry, (LPCSTR)WXSTRINGCAST value) != 0);
+#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;
+    if ( _tputenv(envstr.t_str()) != 0 )
+        return false;
+#else // other compiler
+    if ( !::SetEnvironmentVariable(var.t_str(), value) )
+    {
+        wxLogLastError(wxT("SetEnvironmentVariable"));
+
+        return false;
+    }
+#endif // compiler
+
+    return true;
+#endif // __WXWINCE__/!__WXWINCE__

 }
 
 }
 

-bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
+bool wxSetEnv(const wxString& variable, const wxString& value)

 {
 {

-  char buf[50];
-  sprintf(buf, "%.4f", value);
-  return wxWriteResource(section, entry, buf, file);
+    return wxDoSetEnv(variable, value.t_str());

 }
 
 }
 

-bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
+bool wxUnsetEnv(const wxString& variable)

 {
 {

-  char buf[50];
-  sprintf(buf, "%ld", value);
-  return wxWriteResource(section, entry, buf, file);
+    return wxDoSetEnv(variable, NULL);

 }
 
 }
 

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

 {
 {

-  char buf[50];
-  sprintf(buf, "%d", value);
-  return wxWriteResource(section, entry, buf, file);
-}
+    wxFindByPidParams() { hwnd = 0; pid = 0; }
+
+    // the HWND used to return the result
+    HWND hwnd;
+
+    // the PID we're looking from
+    DWORD pid;

 
 

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

 {
 {

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

     }
 
     }
 

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

     return TRUE;
     return TRUE;

-  }
-  else return FALSE;

 }
 
 }
 

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

 
 

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

 {
 {

-  char *s = NULL;
-  bool succ = wxGetResource(section, entry, (char **)&s, file);
-  if (succ)
-  {
-    *value = (int)strtol(s, NULL, 10);
-    delete[] s;
-    return TRUE;
-  }
-  else return FALSE;
-}
-#endif // wxUSE_RESOURCES
-
-// ---------------------------------------------------------------------------
-// helper functiosn for showing a "busy" cursor
-// ---------------------------------------------------------------------------
+    if (flags & wxKILL_CHILDREN)
+        wxKillAllChildren(pid, sig, krc);

 
 

-extern HCURSOR gs_wxBusyCursor = 0;     // new, busy cursor
-static HCURSOR gs_wxBusyCursorOld = 0;  // old cursor
-static int gs_wxBusyCursorCount = 0;
+    // get the process handle to operate on
+    DWORD dwAccess = PROCESS_QUERY_INFORMATION | SYNCHRONIZE;
+    if ( sig == wxSIGKILL )
+        dwAccess |= PROCESS_TERMINATE;

 
 

-// Set the cursor to the busy cursor for all windows
-void wxBeginBusyCursor(wxCursor *cursor)
-{
-    if ( gs_wxBusyCursorCount++ == 0 )
+    HANDLE hProcess = ::OpenProcess(dwAccess, FALSE, (DWORD)pid);
+    if ( hProcess == NULL )

     {
     {

-        gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
-        gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
+        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 -1;

     }
     }

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

 
 

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

 
 

-    if ( --gs_wxBusyCursorCount == 0 )
+    // 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 ok = true;
+    switch ( sig )

     {
     {

-        ::SetCursor(gs_wxBusyCursorOld);
+        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;
+                }
+            }
+    }

 
 

-        gs_wxBusyCursorOld = 0;
+    // the return code
+    if ( ok )
+    {
+        // 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;
+        }

     }
     }

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

 }
 
 }
 

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

 {
 {

-  return (gs_wxBusyCursorCount > 0);
+    static bool s_initToolHelpDone = false;
+
+    if (s_initToolHelpDone)
+        return;
+
+    s_initToolHelpDone = true;
+
+    lpfCreateToolhelp32Snapshot = NULL;
+    lpfProcess32First = NULL;
+    lpfProcess32Next = NULL;
+
+#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

 }
 
 }
 

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

 {
 {

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

 
 

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

 
 

-    // add a trailing slash if needed
-    if ( strDir.Last() != '/' )
-      strDir << '/';
-  #else   // Windows
-    #ifdef  __WIN32__
-      const char *szHome = getenv("HOMEDRIVE");
-      if ( szHome != NULL )
-        strDir << szHome;
-      szHome = getenv("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 ( strcmp(szHome, "\\") != 0 )
-          return strDir.c_str();
-      }
-
-    #else   // Win16
-      // Win16 has no idea about home, so use the working directory instead
-    #endif  // WIN16/32
-
-    // 260 was taken from windef.h
-    #ifndef MAX_PATH
-      #define MAX_PATH  260
-    #endif
+    // If not implemented for this platform (e.g. NT 4.0), silently ignore
+    if (!lpfCreateToolhelp32Snapshot || !lpfProcess32First || !lpfProcess32Next)
+        return 0;

 
 

-    wxString strPath;
-    ::GetModuleFileName(::GetModuleHandle(NULL),
-                        strPath.GetWriteBuf(MAX_PATH), MAX_PATH);
-    strPath.UngetWriteBuf();
+    // Take a snapshot of all processes in the system.
+    HANDLE hProcessSnap = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    if (hProcessSnap == INVALID_HANDLE_VALUE) {
+        if (krc)
+            *krc = wxKILL_ERROR;
+        return -1;
+    }

 
 

-    // extract the dir name
-    wxSplitPath(strPath, &strDir, NULL, NULL);
+    //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));

 
 

-  #endif  // UNIX/Win

 
 

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

 }
 
 }
 

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

 {
 {

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

     }
     }

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

     {
     {

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

     }
     }

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

 }
 
 }
 

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

 {
 {

-  if(wnd){
-    MSG msg;
-    HWND win= (HWND) wnd->GetHWND();
-    while(PeekMessage(&msg,win,0,0,PM_REMOVE)){
-      TranslateMessage(&msg);
-      DispatchMessage(&msg);
-    }
-    return TRUE;//*** temporary?
-  }
-  else{
-    wxFAIL_MSG("wnd==NULL !!!");
+#ifdef __WXWINCE__
+    // TODO-CE
+    return false;
+#elif defined(__WIN32__)
+    bool bOK = true;

 
 

-    return FALSE;//*** temporary?
-  }
-}
+    if ( wxGetOsVersion(NULL, NULL) == wxOS_WINDOWS_NT ) // if is NT or 2K
+    {
+        // Get a token for this process.
+        HANDLE hToken;
+        bOK = ::OpenProcessToken(GetCurrentProcess(),
+                                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+                                 &hToken) != 0;
+        if ( bOK )
+        {
+            TOKEN_PRIVILEGES tkp;

 
 

-// MSW only: get user-defined resource from the .res file.
-// Returns NULL or newly-allocated memory, so use delete[] to clean up.
+            // Get the LUID for the shutdown privilege.
+            bOK = ::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,
+                                         &tkp.Privileges[0].Luid) != 0;

 
 

-#ifdef __WXMSW__
-char *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
-{
-  char *s = NULL;
-#if !defined(__WIN32__) || defined(__TWIN32__)
-  HRSRC hResource = ::FindResource(wxGetInstance(), WXSTRINGCAST resourceName, WXSTRINGCAST resourceType);
-#else
-#ifdef UNICODE
-  HRSRC hResource = ::FindResourceW(wxGetInstance(), WXSTRINGCAST resourceName, WXSTRINGCAST resourceType);
-#else
-  HRSRC hResource = ::FindResourceA(wxGetInstance(), WXSTRINGCAST resourceName, WXSTRINGCAST resourceType);
-#endif
-#endif
+            if ( bOK )
+            {
+                tkp.PrivilegeCount = 1;  // one privilege to set
+                tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

 
 

-  if (hResource == 0)
-    return NULL;
-  HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
-  if (hData == 0)
-    return NULL;
-  char *theText = (char *)LockResource(hData);
-  if (!theText)
-    return NULL;
+                // Get the shutdown privilege for this process.
+                ::AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,
+                                        (PTOKEN_PRIVILEGES)NULL, 0);

 
 

-  s = copystring(theText);
+                // Cannot test the return value of AdjustTokenPrivileges.
+                bOK = ::GetLastError() == ERROR_SUCCESS;
+            }

 
 

-  // Obsolete in WIN32
-#ifndef __WIN32__
-  UnlockResource(hData);
-#endif
+            ::CloseHandle(hToken);
+        }
+    }

 
 

-  // No need??
-//  GlobalFree(hData);
+    if ( bOK )
+    {
+        UINT wFlags = 0;
+        if ( flags & wxSHUTDOWN_FORCE )
+        {
+            wFlags = EWX_FORCE;
+            flags &= ~wxSHUTDOWN_FORCE;
+        }

 
 

-  return s;
-}
-#endif
+        switch ( flags )
+        {
+            case wxSHUTDOWN_POWEROFF:
+                wFlags |= EWX_POWEROFF;
+                break;

 
 

-void wxGetMousePosition( int* x, int* y )
-{
-  POINT pt;
-  GetCursorPos( & pt );
-  *x = pt.x;
-  *y = pt.y;
-};
+            case wxSHUTDOWN_REBOOT:
+                wFlags |= EWX_REBOOT;
+                break;

 
 

-// Return TRUE if we have a colour display
-bool wxColourDisplay()
-{
-  HDC dc = ::GetDC((HWND) NULL);
-  bool flag;
-  int noCols = GetDeviceCaps(dc, NUMCOLORS);
-  if ((noCols == -1) || (noCols > 2))
-    flag = TRUE;
-  else
-    flag = FALSE;
-  ReleaseDC((HWND) NULL, dc);
-  return flag;
+            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

 }
 
 }
 

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

 {
 {

-  HDC dc = ::GetDC((HWND) NULL);
-  int planes = GetDeviceCaps(dc, PLANES);
-  int bitsPerPixel = GetDeviceCaps(dc, BITSPIXEL);
-  int depth = planes*bitsPerPixel;
-  ReleaseDC((HWND) NULL, dc);
-  return depth;
+#if defined(__WIN64__)
+    MEMORYSTATUSEX memStatex;
+    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

 }
 
 }
 

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

 {
 {

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

 }
 
 }
 

-bool wxDirExists(const wxString& dir)
+bool wxIsDebuggerRunning()

 {
 {

-  /* MATTHEW: [6] Always use same code for Win32, call FindClose */
-#if defined(__WIN32__)
-  WIN32_FIND_DATA fileInfo;
-#else
-#ifdef __BORLANDC__
-  struct ffblk fileInfo;
-#else
-  struct find_t fileInfo;
-#endif
-#endif
+#if wxUSE_DYNLIB_CLASS
+    // IsDebuggerPresent() is not available under Win95, so load it dynamically
+    wxDynamicLibrary dll(wxT("kernel32.dll"), wxDL_VERBATIM);

 
 

-#if defined(__WIN32__)
-  HANDLE h = FindFirstFile((LPTSTR) WXSTRINGCAST dir,(LPWIN32_FIND_DATA)&fileInfo);
+    typedef BOOL (WINAPI *IsDebuggerPresent_t)();
+    if ( !dll.HasSymbol(wxT("IsDebuggerPresent")) )
+    {
+        // no way to know, assume no
+        return false;
+    }

 
 

-  if (h==INVALID_HANDLE_VALUE)
-   return FALSE;
-  else {
-   FindClose(h);
-   return ((fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
-  }
+    return (*(IsDebuggerPresent_t)dll.GetSymbol(wxT("IsDebuggerPresent")))() != 0;

 #else
 #else

-  // In Borland findfirst has a different argument
-  // ordering from _dos_findfirst. But _dos_findfirst
-  // _should_ be ok in both MS and Borland... why not?
-#ifdef __BORLANDC__
-  return ((findfirst(WXSTRINGCAST dir, &fileInfo, _A_SUBDIR) == 0  && (fileInfo.ff_attrib & _A_SUBDIR) != 0));
-#else
-  return (((_dos_findfirst(WXSTRINGCAST dir, _A_SUBDIR, &fileInfo) == 0) && (fileInfo.attrib & _A_SUBDIR)) != 0);
-#endif
+    return false;

 #endif
 }
 
 #endif
 }
 

-// ---------------------------------------------------------------------------
-// window information functions
-// ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// working with MSW resources
+// ----------------------------------------------------------------------------

 
 

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

 {
 {

-    wxString str;
-    int len = GetWindowTextLength((HWND)hWnd) + 1;
-    GetWindowText((HWND)hWnd, str.GetWriteBuf(len), len);
-    str.UngetWriteBuf();
+    wxCHECK_MSG( outData && outLen, false, "output pointers can't be NULL" );

 
 

-    return str;
+    HRSRC hResource = ::FindResource(instance,
+                                     resourceName.t_str(),
+                                     resourceType);
+    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;

 }
 
 }
 

-wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
+char *
+wxLoadUserResource(const wxString& resourceName,
+                   const wxChar* resourceType,
+                   int* pLen,
+                   WXHINSTANCE instance)

 {
 {

-    wxString str;
+    const void *data;
+    size_t len;
+    if ( !wxLoadUserResource(&data, &len, resourceName, resourceType, instance) )
+        return NULL;

 
 

-    int len = 256; // some starting value
+    char *s = new char[len + 1];
+    memcpy(s, data, len);
+    s[len] = '\0'; // NUL-terminate in case the resource itself wasn't

 
 

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

     {
     {

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

         {
         {

-            // the class name might have been truncated, retry with larger
-            // buffer
-            len *= 2;
+            case VER_NT_WORKSTATION:
+                return false;
+
+            case VER_NT_SERVER:
+            case VER_NT_DOMAIN_CONTROLLER:
+                return true;

         }
         }

-        else
+    }
+#endif // VER_NT_WORKSTATION
+
+    return -1;
+}
+
+} // anonymous namespace
+
+wxString wxGetOsDescription()
+{
+    wxString str;
+
+    OSVERSIONINFO info;
+    wxZeroMemory(info);
+
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    if ( ::GetVersionEx(&info) )
+    {
+        switch ( info.dwPlatformId )

         {
         {

-            break;
+#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;
 }
 

-WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
+bool wxIsPlatform64Bit()

 {
 {

-#ifndef __WIN32__
-    return GetWindowWord((HWND)hWnd, GWW_ID);
-#else // Win32
-    return GetWindowLong((HWND)hWnd, GWL_ID);
-#endif // Win16/32
-}
+#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

 
 

-#if 0
-//------------------------------------------------------------------------
-// wild character routines
-//------------------------------------------------------------------------
+    return wow64 != FALSE;
+#else
+    return false;
+#endif // Win64/Win32
+}

 
 

-bool wxIsWild( const wxString& pattern )
+wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)

 {
 {

-  wxString tmp = pattern;
-  char *pat = WXSTRINGCAST(tmp);
-    while (*pat) {
-  switch (*pat++) {
-  case '?': case '*': case '[': case '{':
-      return TRUE;
-  case '\\':
-      if (!*pat++)
-    return FALSE;
-  }
-    }
-    return FALSE;
-};
+    static struct
+    {
+        // this may be false, true or -1 if we tried to initialize but failed
+        int initialized;

 
 

+        wxOperatingSystemId os;

 
 

-bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
-{
-  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++;
-      }
+        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);
+        info.dwOSVersionInfoSize = sizeof(info);
+        if ( ::GetVersionEx(&info) )
+        {
+            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 {
-        while (*pattern!=CB && *pattern!=',' && *pattern!='\0') {
-      if (*++pattern == '\\') {
-                            if (*++pattern == CB || *pattern == ',')
-        pattern++;
-      }
+        else // GetVersionEx() failed
+        {
+            s_version.initialized = -1;

         }
     }
         }
     }

-    if (*pattern != '\0')
-        pattern++;
-      }
-      break;
-  default:
-      if (*str == *pattern) {
-    str++, pattern++;
-      } else {
-    done = TRUE;
-      }
-  }
+
+    if ( s_version.initialized == 1 )
+    {
+        if ( verMaj )
+            *verMaj = s_version.verMaj;
+        if ( verMin )
+            *verMin = s_version.verMin;

     }
     }

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

 
 

-#endif
+    // 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;
+}

 
 

-#if defined(__WIN95__) && defined(__WXDEBUG__) && wxUSE_DBWIN32
+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;

 
 

-/*
-When I started programming with Visual C++ v4.0, I missed one of my favorite
-tools -- DBWIN.  Finding the code for a simple debug trace utility, DBMON,
-on MSDN was a step in the right direction, but it is a console application
-and thus has limited features and extensibility.  DBWIN32 is my creation
-to solve this problem.
+        case wxOS_WINDOWS_NT:
+            switch ( verMaj )
+            {
+                case 3:
+                    return wxWinVersion_NT3;

 
 

-The code is essentially a merging of a stripped down version of the DBWIN code
-from VC 1.5 and DBMON.C with a few 32 bit changes.
+                case 4:
+                    return wxWinVersion_NT4;

 
 

-As of version 1.2B, DBWIN32 supports both Win95 and NT.  The NT support is
-built into the operating system and works just by running DBWIN32.  The Win95
-team decided not to support this hook, so I have provided code that will do
-this for you.  See the file WIN95.TXT for instructions on installing this.
+                case 5:
+                    switch ( verMin )
+                    {
+                        case 0:
+                            return wxWinVersion_2000;

 
 

-If you have questions, problems or suggestions about DBWIN32, I welcome your
-feedback and plan to actively maintain the code.
+                        case 1:
+                            return wxWinVersion_XP;

 
 

-Andrew Tucker
-ast@halcyon.com
+                        case 2:
+                            return wxWinVersion_2003;
+                    }
+                    break;

 
 

-To download dbwin32, see e.g.:
+                case 6:
+                    return wxWinVersion_NT6;
+            }
+            break;

 
 

-http://ftp.digital.com/pub/micro/NT/WinSite/programr/dbwin32.zip
-*/
+        default:
+            // Do nothing just to silence GCC warning
+            break;
+    }

 
 

-#if !defined(__MWERKS__) && !defined(__SALFORDC__) && !defined(__TWIN32__)
-#include <process.h>
-#endif
+    return wxWinVersion_Unknown;
+}

 
 

-void OutputDebugStringW95(const char* lpOutputString, ...)
+// ----------------------------------------------------------------------------
+// sleep functions
+// ----------------------------------------------------------------------------
+
+void wxMilliSleep(unsigned long milliseconds)

 {
 {

-    HANDLE heventDBWIN;  /* DBWIN32 synchronization object */
-    HANDLE heventData;   /* data passing synch object */
-    HANDLE hSharedFile;  /* memory mapped file shared data */
-    LPSTR lpszSharedMem;
-    char achBuffer[500];
-
-    /* create the output buffer */
-    va_list args;
-    va_start(args, lpOutputString);
-    vsprintf(achBuffer, lpOutputString, args);
-    va_end(args);
-
-    /*
-        Do a regular OutputDebugString so that the output is
-        still seen in the debugger window if it exists.
-
-        This ifdef is necessary to avoid infinite recursion
-        from the inclusion of W95TRACE.H
-    */
-#ifdef _UNICODE
-    ::OutputDebugStringW(achBuffer);
-#else
-#ifdef __TWIN32__
-    ::OutputDebugString(achBuffer);
-#else
-    ::OutputDebugStringA(achBuffer);
-#endif
-#endif
+    ::Sleep(milliseconds);
+}

 
 

-    /* bail if it's not Win95 */
-    {
-        OSVERSIONINFO VerInfo;
-        VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-        GetVersionEx(&VerInfo);
-        if ( VerInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS )
-            return;
-    }
+void wxMicroSleep(unsigned long microseconds)
+{
+    wxMilliSleep(microseconds/1000);
+}

 
 

-    /* make sure DBWIN is open and waiting */
-    heventDBWIN = OpenEvent(EVENT_MODIFY_STATE, FALSE, "DBWIN_BUFFER_READY");
-    if ( !heventDBWIN )
-    {
-        //MessageBox(NULL, "DBWIN_BUFFER_READY nonexistent", NULL, MB_OK);
-        return;
-    }
+void wxSleep(int nSecs)
+{
+    wxMilliSleep(1000*nSecs);
+}

 
 

-    /* get a handle to the data synch object */
-    heventData = OpenEvent(EVENT_MODIFY_STATE, FALSE, "DBWIN_DATA_READY");
-    if ( !heventData )
-    {
-        // MessageBox(NULL, "DBWIN_DATA_READY nonexistent", NULL, MB_OK);
-        CloseHandle(heventDBWIN);
-        return;
-    }
+// ----------------------------------------------------------------------------
+// font encoding <-> Win32 codepage conversion functions
+// ----------------------------------------------------------------------------

 
 

-    hSharedFile = CreateFileMapping((HANDLE)-1, NULL, PAGE_READWRITE, 0, 4096, "DBWIN_BUFFER");
-    if (!hSharedFile)
+extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
+{
+    switch ( encoding )

     {
     {

-        //MessageBox(NULL, "DebugTrace: Unable to create file mapping object DBWIN_BUFFER", "Error", MB_OK);
-        CloseHandle(heventDBWIN);
-        CloseHandle(heventData);
-        return;
-    }
+        // 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

 
 

-    lpszSharedMem = (LPSTR)MapViewOfFile(hSharedFile, FILE_MAP_WRITE, 0, 0, 512);
-    if (!lpszSharedMem)
-    {
-        //MessageBox(NULL, "DebugTrace: Unable to map shared memory", "Error", MB_OK);
-        CloseHandle(heventDBWIN);
-        CloseHandle(heventData);
-        return;
-    }
+        case wxFONTENCODING_CP950:
+            return CHINESEBIG5_CHARSET;

 
 

-    /* wait for buffer event */
-    WaitForSingleObject(heventDBWIN, INFINITE);
+        // The rest are single byte encodings
+        case wxFONTENCODING_CP1250:
+            return EASTEUROPE_CHARSET;

 
 

-    /* write it to the shared memory */
-#if defined( __BORLANDC__ ) || defined( __MWERKS__ ) || defined(__SALFORDC__)
-    *((LPDWORD)lpszSharedMem) = getpid();
-#else
-    *((LPDWORD)lpszSharedMem) = _getpid();
-#endif
+        case wxFONTENCODING_CP1251:
+            return RUSSIAN_CHARSET;
+
+        case wxFONTENCODING_CP1253:
+            return GREEK_CHARSET;
+
+        case wxFONTENCODING_CP1254:
+            return TURKISH_CHARSET;
+
+        case wxFONTENCODING_CP1255:
+            return HEBREW_CHARSET;

 
 

-    wsprintf(lpszSharedMem + sizeof(DWORD), "%s", achBuffer);
+        case wxFONTENCODING_CP1256:
+            return ARABIC_CHARSET;

 
 

-    /* signal data ready event */
-    SetEvent(heventData);
+        case wxFONTENCODING_CP1257:
+            return BALTIC_CHARSET;

 
 

-    /* clean up handles */
-    CloseHandle(hSharedFile);
-    CloseHandle(heventData);
-    CloseHandle(heventDBWIN);
+        case wxFONTENCODING_CP874:
+            return THAI_CHARSET;
+#endif // !__WXMICROWIN__

 
 

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

 
 

-#endif
+#include "wx/fontmap.h"

 
 

+extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
+{
+    // There don't seem to be symbolic names for
+    // these under Windows so I just copied the
+    // values from MSDN.

 
 

-#if 0
+    unsigned int ret;

 
 

-// maximum mumber of lines the output console should have
-static const WORD MAX_CONSOLE_LINES = 500;
+    switch (encoding)
+    {
+        case wxFONTENCODING_ISO8859_1:      ret = 28591; break;
+        case wxFONTENCODING_ISO8859_2:      ret = 28592; break;
+        case wxFONTENCODING_ISO8859_3:      ret = 28593; break;
+        case wxFONTENCODING_ISO8859_4:      ret = 28594; break;
+        case wxFONTENCODING_ISO8859_5:      ret = 28595; break;
+        case wxFONTENCODING_ISO8859_6:      ret = 28596; break;
+        case wxFONTENCODING_ISO8859_7:      ret = 28597; break;
+        case wxFONTENCODING_ISO8859_8:      ret = 28598; break;
+        case wxFONTENCODING_ISO8859_9:      ret = 28599; break;
+        case wxFONTENCODING_ISO8859_10:     ret = 28600; break;
+        case wxFONTENCODING_ISO8859_11:     ret = 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;
+    }

 
 

-BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) {   //  control signal type
-  FreeConsole();
-  return TRUE;
+    if (::IsValidCodePage(ret) == 0)
+        return -1;
+
+    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

 
 

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