Added chapter on collection and container classes to contents

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

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index 3a114037d9f14d98808d93772742567cbe90098d..14346f1413a844fae01abfe845b3cf9fd6b70b58 100644 (file)
--- a/src/msw/utils.cpp
+++ b/src/msw/utils.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

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

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


@@ -9,6 +9,14 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 

+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+

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


@@ -17,88 +25,96 @@
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #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/cursor.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"

 #endif  //WX_PRECOMP
 
 #endif  //WX_PRECOMP
 

-#include "wx/msw/private.h"
-#include "wx/timer.h"
+// 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 <windows.h>
+#include "wx/msw/private.h"     // includes <windows.h>
+
+#include "wx/timer.h"

 
 #include <ctype.h>
 
 
 #include <ctype.h>
 

-#ifndef __GNUWIN32__
-#include <direct.h>
-#include <dos.h>
-#endif  //GNUWIN32
+#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__)
+    #include <direct.h>

 
 

-#ifdef __GNUWIN32__
-#include <sys/unistd.h>
-#include <sys/stat.h>
+    #ifndef __MWERKS__
+        #include <dos.h>
+    #endif

 #endif  //GNUWIN32
 
 #endif  //GNUWIN32
 

-#include "wx/log.h"
+#if defined(__GNUWIN32__) && !defined(__TWIN32__)
+    #include <sys/unistd.h>
+    #include <sys/stat.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
 

-#ifdef __WIN32__
-#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(__WXWINE__)
+    #include <io.h>
+
+    #ifndef __GNUWIN32__
+        #include <shellapi.h>
+    #endif

 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef __WATCOMC__
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef __WATCOMC__

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

 #endif
 #include <stdarg.h>
 
 //// BEGIN for console support: VC++ only
 #endif
 #include <stdarg.h>
 
 //// BEGIN for console support: VC++ only

+#ifdef __VISUALC__

 
 

-#if defined(__WXDEBUG__) && !defined(__WIN16__) && defined(_MSC_VER) && !defined(__NO_VC_CRTDBG__)
-    #define wxUSE_VC_CRTDBG
-#else
-    #undef wxUSE_VC_CRTDBG
-#endif
+#include "wx/msw/msvcrt.h"

 
 

-#ifdef wxUSE_VC_CRTDBG
-  // VC++ uses this macro as debug/release mode indicator
-  #ifndef _DEBUG
-    #define _DEBUG
-  #endif
+#include <fcntl.h>

 
 

-  #include <fcntl.h>
+#include "wx/ioswrap.h"

 
 #if wxUSE_IOSTREAMH
 // N.B. BC++ doesn't have istream.h, ostream.h
 
 #if wxUSE_IOSTREAMH
 // N.B. BC++ doesn't have istream.h, ostream.h

-#  include <iostream.h>

 #  include <io.h>
 #  include <fstream.h>
 #  include <io.h>
 #  include <fstream.h>

-

 #else
 #else

-#  include <istream>
-#  include <ostream>

 #  include <fstream>
 #  include <fstream>

-#  ifdef _MSC_VER
-      using namespace std;
-#  endif

 #endif
 
 /* Need to undef new if including crtdbg.h */
 #endif
 
 /* Need to undef new if including crtdbg.h */


@@ -111,236 +127,595 @@
 #endif
 
 #  if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
 #endif
 
 #  if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS

-#  define new new(__FILE__,__LINE__)
+#  define new new(__TFILE__,__LINE__)

 #  endif
 
 #endif
 #  endif
 
 #endif

-
+  // __VISUALC__

 /// END for console support
 
 /// END for console support
 

+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+

 // In the WIN.INI file
 // 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)
+static const wxChar WX_SECTION[] = wxT("wxWindows");
+static const wxChar eUSERNAME[]  = wxT("UserName");
+
+// these are only used under Win16
+#ifndef __WIN32__
+static const wxChar eHOSTNAME[]  = wxT("HostName");
+static const wxChar eUSERID[]    = wxT("UserId");
+#endif // !Win32
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// get host name and related
+// ----------------------------------------------------------------------------
+
+// Get hostname only (without domain name)
+bool wxGetHostName(wxChar *buf, int maxSize)

 {
 {

-#ifdef __WIN32__
-  DWORD nSize = maxSize;
-  return (::GetComputerName(buf, &nSize) != 0);
+#if defined(__WIN32__) && !defined(__TWIN32__)
+    DWORD nSize = maxSize;
+    if ( !::GetComputerName(buf, &nSize) )
+    {
+        wxLogLastError(wxT("GetComputerName"));
+
+        return FALSE;
+    }
+
+    return TRUE;

 #else
 #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;
+    wxChar *sysname;
+    const wxChar *default_host = wxT("noname");
+
+    if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
+        GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
+    } else
+        wxStrncpy(buf, sysname, maxSize - 1);
+    buf[maxSize] = wxT('\0');
+    return *buf ? TRUE : FALSE;

 #endif
 }
 
 #endif
 }
 

+// get full hostname (with domain name if possible)
+bool wxGetFullHostName(wxChar *buf, int maxSize)
+{
+#if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
+    // TODO should use GetComputerNameEx() when available
+    WSADATA wsa;
+    if ( WSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
+    {
+        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);
+
+                if ( pHostEnt )
+                {
+                    // Windows will use DNS internally now
+                    pHostEnt = gethostbyaddr(pHostEnt->h_addr, 4, PF_INET);
+                }
+
+                if ( pHostEnt )
+                {
+                    host = pHostEnt->h_name;
+                }
+            }
+        }
+
+        WSACleanup();
+
+        if ( !!host )
+        {
+            wxStrncpy(buf, host, maxSize);
+
+            return TRUE;
+        }
+    }
+#endif // Win32
+
+    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 *buf, int maxSize)

 {
 {

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

 
 

-    // 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 );
+    return TRUE;
+#else   // Win16 or Win32s
+    wxChar *user;
+    const wxChar *default_id = wxT("anonymous");

 
 

-  WCHAR  wszUserName[256];           // Unicode user name
-  WCHAR  wszDomain[256];
-  LPBYTE ComputerName;
+    // 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);
+    }

 
 

-  struct _SERVER_INFO_100 *si100;   // Server structure
-  struct _USER_INFO_2 *ui;          // User structure
+    return *buf ? TRUE : FALSE;
+#endif
+}

 
 

-  // Convert ASCII user name and domain to Unicode.
+// Get user name e.g. Julian Smart
+bool wxGetUserName(wxChar *buf, int maxSize)
+{
+#if wxUSE_PENWINDOWS && !defined(__WATCOMC__) && !defined(__GNUWIN32__)
+    extern HANDLE g_hPenWin; // PenWindows Running?
+    if (g_hPenWin)
+    {
+        // PenWindows Does have a user concept!
+        // Get the current owner of the recognizer
+        GetPrivateProfileString("Current", "User", default_name, wxBuffer, maxSize - 1, "PENWIN.INI");
+        strncpy(buf, wxBuffer, maxSize - 1);
+    }
+    else
+#endif
+    {
+#ifdef USE_NET_API
+        CHAR szUserName[256];
+        if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
+            return FALSE;

 
 

-  MultiByteToWideChar( CP_ACP, 0, UserName,
-     strlen(UserName)+1, wszUserName, sizeof(wszUserName) );
-  MultiByteToWideChar( CP_ACP, 0, Domain,
-     strlen(Domain)+1, wszDomain, sizeof(wszDomain) );
+        // TODO how to get the domain name?
+        CHAR *szDomain = "";

 
 

-  // Get the computer name of a DC for the specified domain.
-  // >If you get a link error on this, include netapi32.lib<
+        // the code is based on the MSDN example (also see KB article Q119670)
+        WCHAR wszUserName[256];          // Unicode user name
+        WCHAR wszDomain[256];
+        LPBYTE ComputerName;

 
 

-  NetGetDCName( NULL, wszDomain, &ComputerName );
+        USER_INFO_2 *ui2;         // User structure

 
 

-  // Look up the user on the DC.
+        // 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) );

 
 

-  if(NetUserGetInfo( (LPWSTR) ComputerName,
-     (LPWSTR) &wszUserName, 2, (LPBYTE *) &ui))
-  {
-     printf( "Error getting user information.\n" );
-     return( FALSE );
-  }
+        // Get the computer name of a DC for the domain.
+        if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
+        {
+            wxLogError(wxT("Can not find domain controller"));

 
 

-  // Convert the Unicode full name to ASCII.
+            goto error;
+        }

 
 

-  WideCharToMultiByte( CP_ACP, 0, ui->usri2_full_name,
-     -1, buf, 256, NULL, NULL );
-  }
-  return( TRUE );
-#else   // 1
-    DWORD nSize = maxSize;
-    if ( ::GetUserName(buf, &nSize) == 0 )
-    {
-        wxLogSysError("Can not get user name");
+        // 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;
 
         return FALSE;

+#else  // !USE_NET_API
+        // Could use NIS, MS-Mail or other site specific programs
+        // Use wxWindows configuration data
+        bool ok = GetProfileString(WX_SECTION, eUSERNAME, wxT(""), buf, maxSize - 1) != 0;
+        if ( !ok )
+        {
+            ok = wxGetUserId(buf, maxSize);
+        }
+
+        if ( !ok )
+        {
+            wxStrncpy(buf, wxT("Unknown User"), maxSize);
+        }
+#endif // Win32/16

     }
 
     return TRUE;
     }
 
     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;
-#endif

 }
 
 }
 

-// Get user name e.g. Julian Smart
-bool wxGetUserName(char *buf, int maxSize)
+const wxChar* wxGetHomeDir(wxString *pstr)

 {
 {

-#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
-  {
-    // Could use NIS, MS-Mail or other site specific programs
-    // Use wxWindows configuration data
-    bool ok = GetProfileString(WX_SECTION, eUSERNAME, "", buf, maxSize - 1) != 0;
-    if ( !ok )
-    {
-        ok = wxGetUserId(buf, maxSize);
+  wxString& strDir = *pstr;
+
+  #if defined(__UNIX__) && !defined(__TWIN32__)
+    const wxChar *szHome = wxGetenv("HOME");
+    if ( szHome == NULL ) {
+      // we're homeless...
+      wxLogWarning(_("can't find user's HOME, using current directory."));
+      strDir = wxT(".");

     }
     }

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

 
 

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

     {
     {

-        strncpy(buf, "Unknown User", maxSize);
+        wxLogLastError(wxT("FindFirstFile"));
+
+        return FALSE;

     }
     }

-  }

 
 

-  return TRUE;
+    ::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)
 {
 int wxKill(long pid, int sig)
 {

-  return 0;
+    // TODO use SendMessage(WM_QUIT) and TerminateProcess() if needed
+
+    return 0;

 }
 
 }
 

-//

 // Execute a program in an Interactive Shell
 // Execute a program in an Interactive Shell

-//
-bool
-wxShell(const wxString& command)
+bool wxShell(const wxString& command)

 {
 {

-  char *shell;
-  if ((shell = getenv("COMSPEC")) == NULL)
-    shell = "\\COMMAND.COM";
+    wxChar *shell = wxGetenv(wxT("COMSPEC"));
+    if ( !shell )
+        shell = wxT("\\COMMAND.COM");

 
 

-  char tmp[255];
-  if (command != "")
-    sprintf(tmp, "%s /c %s", shell, WXSTRINGCAST command);
-  else
-    strcpy(tmp, shell);
+    wxString cmd;
+    if ( !command )
+    {
+        // just the shell
+        cmd = shell;
+    }
+    else
+    {
+        // pass the command to execute to the command processor
+        cmd.Printf(wxT("%s /c %s"), shell, command.c_str());
+    }

 
 

-  return (wxExecute((char *)tmp, FALSE) != 0);
+    return wxExecute(cmd, TRUE /* sync */) != 0;

 }
 
 }
 

+// ----------------------------------------------------------------------------
+// misc
+// ----------------------------------------------------------------------------
+

 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)

-long wxGetFreeMemory(void)
+long wxGetFreeMemory()

 {
 {

-#if defined(__WIN32__) && !defined(__BORLANDC__)
-  MEMORYSTATUS memStatus;
-  memStatus.dwLength = sizeof(MEMORYSTATUS);
-  GlobalMemoryStatus(&memStatus);
-  return memStatus.dwAvailPhys;
+#if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
+    MEMORYSTATUS memStatus;
+    memStatus.dwLength = sizeof(MEMORYSTATUS);
+    GlobalMemoryStatus(&memStatus);
+    return memStatus.dwAvailPhys;

 #else
 #else

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

 #endif
 }
 
 #endif
 }
 

+// Emit a beeeeeep
+void wxBell()
+{
+    ::MessageBeep((UINT)-1);        // default sound
+}
+
+wxString wxGetOsDescription()
+{
+#ifdef __WIN32__
+    wxString str;
+
+    OSVERSIONINFO info;
+    wxZeroMemory(info);
+
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    if ( ::GetVersionEx(&info) )
+    {
+        switch ( info.dwPlatformId )
+        {
+            case VER_PLATFORM_WIN32s:
+                str = _("Win32s on Windows 3.1");
+                break;
+
+            case VER_PLATFORM_WIN32_WINDOWS:
+                str.Printf(_("Windows 9%c"),
+                           info.dwMinorVersion == 0 ? _T('5') : _T('9'));
+                if ( !wxIsEmpty(info.szCSDVersion) )
+                {
+                    str << _T(" (") << info.szCSDVersion << _T(')');
+                }
+                break;
+
+            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;
+        }
+    }
+    else
+    {
+        wxFAIL_MSG( _T("GetVersionEx() failed") ); // should never happen
+    }
+
+    return str;
+#else // Win16
+    return _("Windows 3.1");
+#endif // Win32/16
+}
+
+int wxGetOsVersion(int *majorVsn, int *minorVsn)
+{
+#if defined(__WIN32__) && !defined(__SC__)
+    OSVERSIONINFO info;
+    wxZeroMemory(info);
+
+    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;
+
+            case VER_PLATFORM_WIN32_WINDOWS:
+                return wxWIN95;
+
+            case VER_PLATFORM_WIN32_NT:
+                return wxWINDOWS_NT;
+        }
+    }
+
+    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;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// sleep functions
+// ----------------------------------------------------------------------------
+
+#if wxUSE_GUI
+

 // Sleep for nSecs seconds. Attempt a Windows implementation using timers.
 // Sleep for nSecs seconds. Attempt a Windows implementation using timers.

-static bool inTimer = FALSE;
+static bool gs_inTimer = FALSE;
+

 class wxSleepTimer: public wxTimer
 {
 class wxSleepTimer: public wxTimer
 {

- public:
-  inline void Notify(void)
-  {
-    inTimer = FALSE;
-    Stop();
-  }
+public:
+    virtual void Notify()
+    {
+        gs_inTimer = FALSE;
+        Stop();
+    }

 };
 
 static wxTimer *wxTheSleepTimer = NULL;
 
 };
 
 static wxTimer *wxTheSleepTimer = NULL;
 

-void wxSleep(int nSecs)
+void wxUsleep(unsigned long milliseconds)

 {
 {

-#if 0 // WIN32 hangs app
-  Sleep( 1000*nSecs );
+#ifdef __WIN32__
+    ::Sleep(milliseconds);

 #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;
+    if (gs_inTimer)
+        return;
+
+    wxTheSleepTimer = new wxSleepTimer;
+    gs_inTimer = TRUE;
+    wxTheSleepTimer->Start(milliseconds);
+    while (gs_inTimer)
+    {
+        if (wxTheApp->Pending())
+            wxTheApp->Dispatch();
+    }
+    delete wxTheSleepTimer;
+    wxTheSleepTimer = NULL;

 #endif
 }
 
 #endif
 }
 

+void wxSleep(int nSecs)
+{
+    if (gs_inTimer)
+        return;
+
+    wxTheSleepTimer = new wxSleepTimer;
+    gs_inTimer = TRUE;
+    wxTheSleepTimer->Start(nSecs*1000);
+    while (gs_inTimer)
+    {
+        if (wxTheApp->Pending())
+            wxTheApp->Dispatch();
+    }
+    delete wxTheSleepTimer;
+    wxTheSleepTimer = NULL;
+}
+

 // Consume all events until no more left
 // Consume all events until no more left

-void wxFlushEvents(void)
+void wxFlushEvents()

 {
 //  wxYield();
 }
 
 {
 //  wxYield();
 }
 

+#elif defined(__WIN32__) // wxUSE_GUI
+
+void wxUsleep(unsigned long milliseconds)
+{
+    ::Sleep(milliseconds);
+}
+
+void wxSleep(int nSecs)
+{
+    wxUsleep(1000*nSecs);
+}
+
+#endif // wxUSE_GUI/!wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// deprecated (in favour of wxLog) log functions
+// ----------------------------------------------------------------------------
+
+#if wxUSE_GUI
+

 // Output a debug mess., in a system dependent fashion.
 // Output a debug mess., in a system dependent fashion.

-void wxDebugMsg(const char *fmt ...)
+void wxDebugMsg(const wxChar *fmt ...)

 {
   va_list ap;
 {
   va_list ap;

-  static char buffer[512];
+  static wxChar buffer[512];

 
   if (!wxTheApp->GetWantDebugOutput())
     return ;
 
   if (!wxTheApp->GetWantDebugOutput())
     return ;


@@ -348,7 +723,7 @@ void wxDebugMsg(const char *fmt ...)
   va_start(ap, fmt);
 
   wvsprintf(buffer,fmt,ap) ;
   va_start(ap, fmt);
 
   wvsprintf(buffer,fmt,ap) ;

-  OutputDebugString((LPCSTR)buffer) ;
+  OutputDebugString((LPCTSTR)buffer) ;

 
   va_end(ap);
 }
 
   va_end(ap);
 }


@@ -356,8 +731,8 @@ void wxDebugMsg(const char *fmt ...)
 // Non-fatal error: pop up message box and (possibly) continue
 void wxError(const wxString& msg, const wxString& title)
 {
 // 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,
+  wxSprintf(wxBuffer, wxT("%s\nContinue?"), WXSTRINGCAST msg);
+  if (MessageBox(NULL, (LPCTSTR)wxBuffer, (LPCTSTR)WXSTRINGCAST title,

              MB_ICONSTOP | MB_YESNO) == IDNO)
     wxExit();
 }
              MB_ICONSTOP | MB_YESNO) == IDNO)
     wxExit();
 }


@@ -365,423 +740,254 @@ void wxError(const wxString& msg, const wxString& title)
 // Fatal error: pop up message box and abort
 void wxFatalError(const wxString& msg, const wxString& title)
 {
 // Fatal error: pop up message box and abort
 void wxFatalError(const wxString& msg, const wxString& title)
 {

-  sprintf(wxBuffer, "%s: %s", WXSTRINGCAST title, WXSTRINGCAST msg);
-  FatalAppExit(0, (LPCSTR)wxBuffer);
+  wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg);
+  FatalAppExit(0, (LPCTSTR)wxBuffer);

 }
 
 }
 

-// Emit a beeeeeep
-void wxBell(void)
-{
-    // 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
-}
-
-// 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;
-
-#ifdef WIN32
-  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 ;
-#  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
-}
+// ----------------------------------------------------------------------------
+// functions to work with .INI files
+// ----------------------------------------------------------------------------

 
 // 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)
 {
 
 // 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 != "")
-    return (WritePrivateProfileString((LPCSTR)WXSTRINGCAST section, (LPCSTR)WXSTRINGCAST entry, (LPCSTR)value, (LPCSTR)WXSTRINGCAST file) != 0);
+  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
   else

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

 }
 
 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
 {
 }
 
 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
 {

-  char buf[50];
-  sprintf(buf, "%.4f", value);
-  return wxWriteResource(section, entry, buf, file);
+    wxString buf;
+    buf.Printf(wxT("%.4f"), value);
+
+    return wxWriteResource(section, entry, buf, file);

 }
 
 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
 {
 }
 
 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
 {

-  char buf[50];
-  sprintf(buf, "%ld", value);
-  return wxWriteResource(section, entry, buf, file);
+    wxString buf;
+    buf.Printf(wxT("%ld"), value);
+
+    return wxWriteResource(section, entry, buf, file);

 }
 
 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
 {
 }
 
 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
 {

-  char buf[50];
-  sprintf(buf, "%d", value);
-  return wxWriteResource(section, entry, buf, file);
+    wxString buf;
+    buf.Printf(wxT("%d"), value);
+
+    return wxWriteResource(section, entry, buf, file);

 }
 
 }
 

-bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
+bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file)

 {
 {

-  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;
+    static const wxChar defunkt[] = wxT("$$default");
+    if (file != wxT(""))
+    {
+        int n = GetPrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
+                (LPTSTR)wxBuffer, 1000, (LPCTSTR)WXSTRINGCAST file);
+        if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
+            return FALSE;

     }
     }

+    else
+    {
+        int n = GetProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
+                (LPTSTR)wxBuffer, 1000);
+        if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
+            return FALSE;
+    }
+    if (*value) delete[] (*value);
+    *value = copystring(wxBuffer);
+    return TRUE;
+}

 
 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
 {
 
 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;
-    return TRUE;
-  }
-  else return FALSE;
+    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;

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

 }
 
 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
 {
 }
 
 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
 {

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

 }
 #endif // wxUSE_RESOURCES
 
 }
 #endif // wxUSE_RESOURCES
 

-// Old cursor
-static HCURSOR wxBusyCursorOld = 0;
-static int wxBusyCursorCount = 0;
+// ---------------------------------------------------------------------------
+// helper functions for showing a "busy" cursor
+// ---------------------------------------------------------------------------

 
 

-// Set the cursor to the busy cursor for all windows
-void wxBeginBusyCursor(wxCursor *cursor)
-{
-  wxBusyCursorCount ++;
-  if (wxBusyCursorCount == 1)
-  {
-    wxBusyCursorOld = ::SetCursor((HCURSOR) cursor->GetHCURSOR());
-  }
-  else
-  {
-    (void)::SetCursor((HCURSOR) cursor->GetHCURSOR());
-  }
-}
+static HCURSOR gs_wxBusyCursor = 0;     // new, busy cursor
+static HCURSOR gs_wxBusyCursorOld = 0;  // old cursor
+static int gs_wxBusyCursorCount = 0;

 
 

-// Restore cursor to normal
-void wxEndBusyCursor(void)
+extern HCURSOR wxGetCurrentBusyCursor()

 {
 {

-  if (wxBusyCursorCount == 0)
-    return;
-
-  wxBusyCursorCount --;
-  if (wxBusyCursorCount == 0)
-  {
-    ::SetCursor(wxBusyCursorOld);
-    wxBusyCursorOld = 0;
-  }
+    return gs_wxBusyCursor;

 }
 
 }
 

-// TRUE if we're between the above two calls
-bool wxIsBusy(void)
+// Set the cursor to the busy cursor for all windows
+void wxBeginBusyCursor(wxCursor *cursor)

 {
 {

-  return (wxBusyCursorCount > 0);
+    if ( gs_wxBusyCursorCount++ == 0 )
+    {
+        gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
+        gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
+    }
+    //else: nothing to do, already set

 }
 
 }
 

-const char* wxGetHomeDir(wxString *pstr)
+// Restore cursor to normal
+void wxEndBusyCursor()

 {
 {

-  wxString& strDir = *pstr;
+    wxCHECK_RET( gs_wxBusyCursorCount > 0,
+                 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );

 
 

-  #ifdef __UNIX__
-    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;
-
-    // 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
-
-    wxString strPath;
-    ::GetModuleFileName(::GetModuleHandle(NULL),
-                        strPath.GetWriteBuf(MAX_PATH), MAX_PATH);
-    strPath.UngetWriteBuf();
-
-    // extract the dir name
-    wxSplitPath(strPath, &strDir, NULL, NULL);
-
-  #endif  // UNIX/Win
+    if ( --gs_wxBusyCursorCount == 0 )
+    {
+        ::SetCursor(gs_wxBusyCursorOld);

 
 

-  return strDir.c_str();
+        gs_wxBusyCursorOld = 0;
+    }

 }
 
 }
 

-// Hack for MS-DOS
-char *wxGetUserHome (const wxString& user)
+// TRUE if we're between the above two calls
+bool wxIsBusy()

 {
 {

-  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 : "\\";
-      }
-      if (Stricmp(tmp, WXSTRINGCAST user1) == 0)
-        user1 = "";
-    }
-  }
-  if (user1 == "")
-    if ((home = getenv("HOME")) != NULL)
-    {
-      strcpy(wxBuffer, home);
-      Unix2DosFilename(wxBuffer);
-      return wxBuffer;
-    }
-  return NULL; // No home known!
+  return (gs_wxBusyCursorCount > 0);

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

-  if(wnd){
+    wxCHECK( wnd, FALSE );
+

     MSG msg;
     MSG msg;

-    HWND win= (HWND) wnd->GetHWND();
-    while(PeekMessage(&msg,win,0,0,PM_REMOVE)){
-      TranslateMessage(&msg);
-      DispatchMessage(&msg);
+    while ( ::PeekMessage(&msg, GetHwndOf(wnd), 0, 0, PM_REMOVE) )
+    {
+        ::TranslateMessage(&msg);
+        ::DispatchMessage(&msg);

     }
     }

-    return TRUE;//*** temporary?
-  }
-  else{
-    wxError("wnd==NULL !!!");
-    return FALSE;//*** temporary?
-  }
+
+    return TRUE;

 }
 
 // MSW only: get user-defined resource from the .res file.
 // Returns NULL or newly-allocated memory, so use delete[] to clean up.
 
 }
 
 // MSW only: get user-defined resource from the .res file.
 // Returns NULL or newly-allocated memory, so use delete[] to clean up.
 

-#ifdef __WXMSW__
-char *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
+wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)

 {
 {

-  char *s = NULL;
-#ifndef __WIN32__
-  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
+    HRSRC hResource = ::FindResource(wxGetInstance(), resourceName, resourceType);
+    if ( hResource == 0 )
+        return NULL;

 
 

-  if (hResource == 0)
-    return NULL;
-  HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
-  if (hData == 0)
-    return NULL;
-  char *theText = (char *)LockResource(hData);
-  if (!theText)
-    return NULL;
+    HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
+    if ( hData == 0 )
+        return NULL;

 
 

-  s = copystring(theText);
+    wxChar *theText = (wxChar *)::LockResource(hData);
+    if ( !theText )
+        return NULL;

 
 

-  // Obsolete in WIN32
+    // 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;
+
+    // wxChar *s = copystring(theText);
+
+    // Obsolete in WIN32

 #ifndef __WIN32__
 #ifndef __WIN32__

-  UnlockResource(hData);
+    UnlockResource(hData);

 #endif
 
 #endif
 

-  // No need??
-//  GlobalFree(hData);
+    // No need??
+    //  GlobalFree(hData);

 
 

-  return s;
+    return s;

 }
 }

-#endif
+
+// ----------------------------------------------------------------------------
+// get display info
+// ----------------------------------------------------------------------------

 
 void wxGetMousePosition( int* x, int* y )
 {
 
 void wxGetMousePosition( int* x, int* y )
 {

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

 };
 
 // Return TRUE if we have a colour display
 };
 
 // Return TRUE if we have a colour display

-bool wxColourDisplay(void)
+bool wxColourDisplay()

 {
 {

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

 }
 
 // Returns depth of screen
 }
 
 // Returns depth of screen

-int wxDisplayDepth(void)
+int wxDisplayDepth()

 {
 {

-  HDC dc = ::GetDC(NULL);
-  int planes = GetDeviceCaps(dc, PLANES);
-  int bitsPerPixel = GetDeviceCaps(dc, BITSPIXEL);
-  int depth = planes*bitsPerPixel;
-  ReleaseDC(NULL, dc);
-  return depth;
+    ScreenHDC dc;
+    return GetDeviceCaps(dc, PLANES) * GetDeviceCaps(dc, BITSPIXEL);

 }
 
 // Get size of display
 void wxDisplaySize(int *width, int *height)
 {
 }
 
 // Get size of display
 void wxDisplaySize(int *width, int *height)
 {

-  HDC dc = ::GetDC(NULL);
-  *width = GetDeviceCaps(dc, HORZRES); *height = GetDeviceCaps(dc, VERTRES);
-  ReleaseDC(NULL, dc);
-}
-
-bool wxDirExists(const wxString& dir)
-{
-  /* 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
+    ScreenHDC dc;

 
 

-#if defined(__WIN32__)
-       HANDLE h = FindFirstFile((LPTSTR) WXSTRINGCAST dir,(LPWIN32_FIND_DATA)&fileInfo);
-
-       if (h==INVALID_HANDLE_VALUE)
-        return FALSE;
-       else {
-        FindClose(h);
-        return ((fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
-       }
-#else
-  // In Borland findfirst has a different argument
-  // ordering from _dos_findfirst. But _dos_findfirst
-  // _should_ be ok in both MS and Borland... why not?
-#ifdef __BORLANDC__
-  return ((findfirst(WXSTRINGCAST dir, &fileInfo, _A_SUBDIR) == 0  && (fileInfo.ff_attrib & _A_SUBDIR) != 0));
-#else
-  return (((_dos_findfirst(WXSTRINGCAST dir, _A_SUBDIR, &fileInfo) == 0) && (fileInfo.attrib & _A_SUBDIR)) != 0);
-#endif
-#endif
+    if ( width ) *width = GetDeviceCaps(dc, HORZRES);
+    if ( height ) *height = GetDeviceCaps(dc, VERTRES);

 }
 
 }
 

+// ---------------------------------------------------------------------------
+// window information functions
+// ---------------------------------------------------------------------------
+

 wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
 {
     wxString str;
 wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
 {
     wxString str;


@@ -792,6 +998,60 @@ wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
     return str;
 }
 
     return str;
 }
 

+wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
+{
+    wxString str;
+
+    int len = 256; // some starting value
+
+    for ( ;; )
+    {
+        // 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 )
+        {
+            // the class name might have been truncated, retry with larger
+            // buffer
+            len *= 2;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return str;
+}
+
+WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
+{
+#ifndef __WIN32__
+    return GetWindowWord((HWND)hWnd, GWW_ID);
+#else // Win32
+    return GetWindowLong((HWND)hWnd, GWL_ID);
+#endif // Win16/32
+}
+
+#endif // wxUSE_GUI
+

 #if 0
 //------------------------------------------------------------------------
 // wild character routines
 #if 0
 //------------------------------------------------------------------------
 // wild character routines


@@ -802,13 +1062,13 @@ bool wxIsWild( const wxString& pattern )
   wxString tmp = pattern;
   char *pat = WXSTRINGCAST(tmp);
     while (*pat) {
   wxString tmp = pattern;
   char *pat = WXSTRINGCAST(tmp);
     while (*pat) {

-       switch (*pat++) {
-       case '?': case '*': case '[': case '{':
-           return TRUE;
-       case '\\':
-           if (!*pat++)
-               return FALSE;
-       }
+  switch (*pat++) {
+  case '?': case '*': case '[': case '{':
+      return TRUE;
+  case '\\':
+      if (!*pat++)
+    return FALSE;
+  }

     }
     return FALSE;
 };
     }
     return FALSE;
 };


@@ -828,265 +1088,137 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
 
     // dot_special means '.' only matches '.'
     if (dot_special && *str == '.' && *pattern != *str)
 
     // dot_special means '.' only matches '.'
     if (dot_special && *str == '.' && *pattern != *str)

-       return FALSE;
+  return FALSE;

 
     while ((*pattern != '\0') && (!done)
     && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) {
 
     while ((*pattern != '\0') && (!done)
     && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) {

-       switch (*pattern) {
-       case '\\':
-           pattern++;
-           if (*pattern != '\0')
-               pattern++;
-           break;
-       case '*':
-           pattern++;
-           ret_code = FALSE;
-           while ((*str!='\0')
-           && (!(ret_code=wxMatchWild(pattern, str++, FALSE))))
-               /*loop*/;
-           if (ret_code) {
-               while (*str != '\0')
-                   str++;
-               while (*pattern != '\0')
-                   pattern++;
-           }
-           break;
-       case '[':
-           pattern++;
-         repeat:
-           if ((*pattern == '\0') || (*pattern == ']')) {
-               done = TRUE;
-               break;
-           }
-           if (*pattern == '\\') {
-               pattern++;
-               if (*pattern == '\0') {
-                   done = TRUE;
-                   break;
-               }
-           }
-           if (*(pattern + 1) == '-') {
-               c = *pattern;
-               pattern += 2;
-               if (*pattern == ']') {
-                   done = TRUE;
-                   break;
-               }
-               if (*pattern == '\\') {
-                   pattern++;
-                   if (*pattern == '\0') {
-                       done = TRUE;
-                       break;
-                   }
-               }
-               if ((*str < c) || (*str > *pattern)) {
-                   pattern++;
-                   goto repeat;
-               }
-           } else if (*pattern != *str) {
-               pattern++;
-               goto repeat;
-           }
-           pattern++;
-           while ((*pattern != ']') && (*pattern != '\0')) {
-               if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
-                   pattern++;
-               pattern++;
-           }
-           if (*pattern != '\0') {
-               pattern++, str++;
-           }
-           break;
-       case '?':
-           pattern++;
-           str++;
-           break;
-       case OB:
-           pattern++;
-           while ((*pattern != CB) && (*pattern != '\0')) {
-               cp = str;
-               ok = TRUE;
-               while (ok && (*cp != '\0') && (*pattern != '\0')
-               &&  (*pattern != ',') && (*pattern != CB)) {
-                   if (*pattern == '\\')
-                       pattern++;
-                   ok = (*pattern++ == *cp++);
-               }
-               if (*pattern == '\0') {
-                   ok = FALSE;
-                   done = TRUE;
-                   break;
-               } else if (ok) {
-                   str = cp;
-                   while ((*pattern != CB) && (*pattern != '\0')) {
-                       if (*++pattern == '\\') {
-                           if (*++pattern == CB)
-                               pattern++;
-                       }
-                   }
-               } else {
-                   while (*pattern!=CB && *pattern!=',' && *pattern!='\0') {
-                       if (*++pattern == '\\') {
-                            if (*++pattern == CB || *pattern == ',')
-                               pattern++;
-                       }
-                   }
-               }
-               if (*pattern != '\0')
-                   pattern++;
-           }
-           break;
-       default:
-           if (*str == *pattern) {
-               str++, pattern++;
-           } else {
-               done = TRUE;
-           }
-       }
+  switch (*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;

     }
     }

-    while (*pattern == '*')
-       pattern++;
-    return ((*str == '\0') && (*pattern == '\0'));
-};
-
-#endif
-
-#if defined(__WIN95__) && defined(__WXDEBUG__) && wxUSE_DBWIN32
-
-/*
-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.
-
-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.
-
-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.
-
-If you have questions, problems or suggestions about DBWIN32, I welcome your
-feedback and plan to actively maintain the code.
-
-Andrew Tucker
-ast@halcyon.com
-
-To download dbwin32, see e.g.:
-
-http://ftp.digital.com/pub/micro/NT/WinSite/programr/dbwin32.zip
-*/
-
-#include <process.h>
-
-void OutputDebugStringW95(const char* lpOutputString, ...)
-{
-    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
-    ::OutputDebugStringA(achBuffer);
-#endif
-
-    /* bail if it's not Win95 */
-    {
-        OSVERSIONINFO VerInfo;
-        VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-        GetVersionEx(&VerInfo);
-        if ( VerInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS )
-            return;
+      }
+      if (*(pattern + 1) == '-') {
+    c = *pattern;
+    pattern += 2;
+    if (*pattern == ']') {
+        done = TRUE;
+        break;

     }
     }

-
-    /* 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;
+    if (*pattern == '\\') {
+        pattern++;
+        if (*pattern == '\0') {
+      done = TRUE;
+      break;
+        }

     }
     }

-
-    /* 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;
+    if ((*str < c) || (*str > *pattern)) {
+        pattern++;
+        goto repeat;

     }
     }

-
-    hSharedFile = CreateFileMapping((HANDLE)-1, NULL, PAGE_READWRITE, 0, 4096, "DBWIN_BUFFER");
-    if (!hSharedFile)
-    {
-        //MessageBox(NULL, "DebugTrace: Unable to create file mapping object DBWIN_BUFFER", "Error", MB_OK);
-        CloseHandle(heventDBWIN);
-        CloseHandle(heventData);
-        return;
+      } 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++);

     }
     }

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

 
 

-    /* wait for buffer event */
-    WaitForSingleObject(heventDBWIN, INFINITE);
-
-    /* write it to the shared memory */
-#ifdef __BORLANDC__
-    *((LPDWORD)lpszSharedMem) = getpid();
-#else
-    *((LPDWORD)lpszSharedMem) = _getpid();
-#endif
-
-    wsprintf(lpszSharedMem + sizeof(DWORD), "%s", achBuffer);
-
-    /* signal data ready event */
-    SetEvent(heventData);
-
-    /* clean up handles */
-    CloseHandle(hSharedFile);
-    CloseHandle(heventData);
-    CloseHandle(heventDBWIN);
-
-    return;
-}
-
-
-#endif
-
+#endif // 0

 
 

-#ifdef wxUSE_VC_CRTDBG
+#if 0

 
 // maximum mumber of lines the output console should have
 static const WORD MAX_CONSOLE_LINES = 500;
 
 BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) {   //  control signal type
 
 // maximum mumber of lines the output console should have
 static const WORD MAX_CONSOLE_LINES = 500;
 
 BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) {   //  control signal type

-       FreeConsole();
-       return TRUE;
+  FreeConsole();
+  return TRUE;

 }
 
 void wxRedirectIOToConsole()
 }
 
 void wxRedirectIOToConsole()


@@ -1100,10 +1232,10 @@ void wxRedirectIOToConsole()
     AllocConsole();
 
     // set the screen buffer to be big enough to let us scroll text
     AllocConsole();
 
     // set the screen buffer to be big enough to let us scroll text

-    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), 
+    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),

                                &coninfo);
     coninfo.dwSize.Y = MAX_CONSOLE_LINES;
                                &coninfo);
     coninfo.dwSize.Y = MAX_CONSOLE_LINES;

-    SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), 
+    SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE),

                                coninfo.dwSize);
 
     // redirect unbuffered STDOUT to the console
                                coninfo.dwSize);
 
     // redirect unbuffered STDOUT to the console


@@ -1129,13 +1261,12 @@ void wxRedirectIOToConsole()
     fp = _fdopen( hConHandle, "w" );
     *stderr = *fp;
     setvbuf( stderr, NULL, _IONBF, 0 );
     fp = _fdopen( hConHandle, "w" );
     *stderr = *fp;
     setvbuf( stderr, NULL, _IONBF, 0 );

-    
-    // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog 
+
+    // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog

     // point to console as well
     ios::sync_with_stdio();
 
     // point to console as well
     ios::sync_with_stdio();
 

-       SetConsoleCtrlHandler(MyConsoleHandler, TRUE);
-
+    SetConsoleCtrlHandler(MyConsoleHandler, TRUE);

 }
 #else
 // Not supported
 }
 #else
 // Not supported