X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3f4a0c5be34be837210768501c13dbcff81e533c..37b8e6798782278fdfe4f3c1291aaff55cdbb8c9:/src/msw/utils.cpp?ds=sidebyside

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index e0ed4d7246..2f56096849 100644
--- 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:
@@ -9,6 +9,14 @@
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 #ifdef __GNUG__
 // #pragma implementation "utils.h"   // Note: this is done in utilscmn.cpp now.
 #endif
@@ -17,35 +25,33 @@
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #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"
 #endif  //WX_PRECOMP
 
-#include "wx/msw/private.h"
+#include "wx/msw/private.h"     // includes <windows.h>
+
 #include "wx/timer.h"
 #include "wx/intl.h"
 
-#include <windows.h>
-
 #include <ctype.h>
 
-#if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
-#include <direct.h>
+#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__)
+    #include <direct.h>
 
-#ifndef __MWERKS__
-#include <dos.h>
-#endif
+    #ifndef __MWERKS__
+        #include <dos.h>
+    #endif
 #endif  //GNUWIN32
 
 #if defined(__GNUWIN32__) && !defined(__TWIN32__)
-#include <sys/unistd.h>
-#include <sys/stat.h>
+    #include <sys/unistd.h>
+    #include <sys/stat.h>
 #endif  //GNUWIN32
 
 #include "wx/log.h"
@@ -53,15 +59,25 @@
 #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
 
-#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>
@@ -75,6 +91,7 @@
 #include <stdarg.h>
 
 //// BEGIN for console support: VC++ only
+#ifdef __VISUALC__
 
 #include "wx/msw/msvcrt.h"
 
@@ -103,231 +120,554 @@
 #  define new new(__FILE__,__LINE__)
 #  endif
 
+#endif
+  // __VISUALC__
 /// END for console support
 
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
 // 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";
+static const wxChar WX_SECTION[] = wxT("wxWindows");
+static const wxChar eUSERNAME[]  = wxT("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
+// 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 full hostname (eg. DoDo.BSn-Germany.crg.de)
-bool wxGetHostName(char *buf, int maxSize)
+bool wxGetHostName(wxChar *buf, int maxSize)
 {
 #if defined(__WIN32__) && !defined(__TWIN32__)
-  DWORD nSize = maxSize;
-  return (::GetComputerName(buf, &nSize) != 0);
+    // TODO should use GetComputerNameEx() when available
+
+    DWORD nSize = maxSize;
+    if ( !::GetComputerName(buf, &nSize) )
+    {
+        wxLogLastError("GetComputerName");
+
+        return FALSE;
+    }
+
+    return TRUE;
 #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
 }
 
+bool wxGetFullHostName(wxChar *buf, int maxSize)
+{
+    return wxGetHostName(buf, maxSize);
+}
+
 // Get user ID e.g. jacs
-bool wxGetUserId(char *buf, int maxSize)
+bool wxGetUserId(wxChar *buf, int maxSize)
 {
 #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;
+#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;
-#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
 
-    if ( !ok )
+    // 260 was taken from windef.h
+    #ifndef MAX_PATH
+      #define MAX_PATH  260
+    #endif
+
+    wxString strPath;
+    ::GetModuleFileName(::GetModuleHandle(NULL),
+                        strPath.GetWriteBuf(MAX_PATH), MAX_PATH);
+    strPath.UngetWriteBuf();
+
+    // extract the dir name
+    wxSplitPath(strPath, &strDir, NULL, NULL);
+
+  #endif  // UNIX/Win
+
+  return strDir.c_str();
+}
+
+wxChar *wxGetUserHome(const wxString& user)
+{
+    // VZ: the old code here never worked for user != "" anyhow! Moreover, it
+    //     returned sometimes a malloc()'d pointer, sometimes a pointer to a
+    //     static buffer and sometimes I don't even know what.
+    static wxString s_home;
+
+    return (wxChar *)wxGetHomeDir(&s_home);
+}
+
+bool wxDirExists(const wxString& dir)
+{
+#if defined(__WIN32__)
+    WIN32_FIND_DATA fileInfo;
+#else // Win16
+    #ifdef __BORLANDC__
+        struct ffblk fileInfo;
+    #else
+        struct find_t fileInfo;
+    #endif
+#endif // Win32/16
+
+#if defined(__WIN32__)
+    HANDLE h = ::FindFirstFile(dir, &fileInfo);
+
+    if ( h == INVALID_HANDLE_VALUE )
     {
-        strncpy(buf, "Unknown User", maxSize);
+        wxLogLastError("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)
 {
-  return 0;
+    // TODO use SendMessage(WM_QUIT) and TerminateProcess() if needed
+
+    return 0;
 }
 
-//
 // 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)
-long wxGetFreeMemory(void)
+long wxGetFreeMemory()
 {
 #if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
-  MEMORYSTATUS memStatus;
-  memStatus.dwLength = sizeof(MEMORYSTATUS);
-  GlobalMemoryStatus(&memStatus);
-  return memStatus.dwAvailPhys;
+    MEMORYSTATUS memStatus;
+    memStatus.dwLength = sizeof(MEMORYSTATUS);
+    GlobalMemoryStatus(&memStatus);
+    return memStatus.dwAvailPhys;
 #else
-  return (long)GetFreeSpace(0);
+    return (long)GetFreeSpace(0);
 #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.
-static bool inTimer = FALSE;
+static bool gs_inTimer = FALSE;
+
 class wxSleepTimer: public wxTimer
 {
- public:
-  inline void Notify(void)
-  {
-    inTimer = FALSE;
-    Stop();
-  }
+public:
+    virtual void Notify()
+    {
+        gs_inTimer = FALSE;
+        Stop();
+    }
 };
 
 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
-  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
 }
 
+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
-void wxFlushEvents(void)
+void wxFlushEvents()
 {
 //  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.
-void wxDebugMsg(const char *fmt ...)
+void wxDebugMsg(const wxChar *fmt ...)
 {
   va_list ap;
-  static char buffer[512];
+  static wxChar buffer[512];
 
   if (!wxTheApp->GetWantDebugOutput())
     return ;
@@ -335,7 +675,7 @@ void wxDebugMsg(const char *fmt ...)
   va_start(ap, fmt);
 
   wvsprintf(buffer,fmt,ap) ;
-  OutputDebugString((LPCSTR)buffer) ;
+  OutputDebugString((LPCTSTR)buffer) ;
 
   va_end(ap);
 }
@@ -343,8 +683,8 @@ void wxDebugMsg(const char *fmt ...)
 // 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();
 }
@@ -352,423 +692,251 @@ void wxError(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);
-}
-
-// 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
+  wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg);
+  FatalAppExit(0, (LPCTSTR)wxBuffer);
 }
 
-// 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
-}
+// ----------------------------------------------------------------------------
+// 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)
 {
-  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
-    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)
 {
-  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)
 {
-  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)
 {
-  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)
 {
-  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)
 {
-  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)
 {
-  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
 
-// Old cursor
-static HCURSOR wxBusyCursorOld = 0;
-static int wxBusyCursorCount = 0;
+// ---------------------------------------------------------------------------
+// helper functions for showing a "busy" cursor
+// ---------------------------------------------------------------------------
+
+HCURSOR gs_wxBusyCursor = 0;     // new, busy cursor
+HCURSOR gs_wxBusyCursorOld = 0;  // old cursor
+static int gs_wxBusyCursorCount = 0;
 
 // 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());
-  }
+    if ( gs_wxBusyCursorCount++ == 0 )
+    {
+        gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
+        gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
+    }
+    //else: nothing to do, already set
 }
 
 // Restore cursor to normal
-void wxEndBusyCursor(void)
+void wxEndBusyCursor()
 {
-  if (wxBusyCursorCount == 0)
-    return;
-
-  wxBusyCursorCount --;
-  if (wxBusyCursorCount == 0)
-  {
-    ::SetCursor(wxBusyCursorOld);
-    wxBusyCursorOld = 0;
-  }
-}
+    wxCHECK_RET( gs_wxBusyCursorCount > 0,
+                 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
 
-// TRUE if we're between the above two calls
-bool wxIsBusy(void)
-{
-  return (wxBusyCursorCount > 0);
-}
-
-const char* wxGetHomeDir(wxString *pstr)
-{
-  wxString& strDir = *pstr;
+    if ( --gs_wxBusyCursorCount == 0 )
+    {
+        ::SetCursor(gs_wxBusyCursorOld);
 
-  #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 = ".";
+        gs_wxBusyCursorOld = 0;
     }
-    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
-
-  return strDir.c_str();
 }
 
-// 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)
 {
-  if(wnd){
+    wxCHECK( wnd, FALSE );
+
     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;
 }
 
+#endif // wxUSE_GUI
+
 // MSW only: get user-defined resource from the .res file.
 // Returns NULL or newly-allocated memory, so use delete[] to clean up.
 
-#ifdef __WXMSW__
-char *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
+wxChar *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
+    HRSRC hResource = ::FindResource(wxGetInstance(), resourceName, resourceType);
+    if ( hResource == 0 )
+        return NULL;
+
+    HGLOBAL hData = ::LoadResource(wxGetInstance(), hResource);
+    if ( hData == 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;
+    wxChar *theText = (wxChar *)::LockResource(hData);
+    if ( !theText )
+        return NULL;
 
-  s = copystring(theText);
+    // 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;
 
-  // Obsolete in WIN32
+    // wxChar *s = copystring(theText);
+
+    // Obsolete in WIN32
 #ifndef __WIN32__
-  UnlockResource(hData);
+    UnlockResource(hData);
 #endif
 
-  // No need??
-//  GlobalFree(hData);
+    // No need??
+    //  GlobalFree(hData);
 
-  return s;
+    return s;
 }
-#endif
+
+// ----------------------------------------------------------------------------
+// get display info
+// ----------------------------------------------------------------------------
 
 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
-bool wxColourDisplay(void)
+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;
+    ScreenHDC dc;
+    int noCols = GetDeviceCaps(dc, NUMCOLORS);
+
+    return (noCols == -1) || (noCols > 2);
 }
 
 // Returns depth of screen
-int wxDisplayDepth(void)
+int wxDisplayDepth()
 {
-  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;
+    ScreenHDC dc;
+    return GetDeviceCaps(dc, PLANES) * GetDeviceCaps(dc, BITSPIXEL);
 }
 
 // Get size of display
 void wxDisplaySize(int *width, int *height)
 {
-  HDC dc = ::GetDC((HWND) NULL);
-  *width = GetDeviceCaps(dc, HORZRES); *height = GetDeviceCaps(dc, VERTRES);
-  ReleaseDC((HWND) 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
-
-#if defined(__WIN32__)
-  HANDLE h = FindFirstFile((LPTSTR) WXSTRINGCAST dir,(LPWIN32_FIND_DATA)&fileInfo);
+    ScreenHDC dc;
 
-  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;
@@ -779,6 +947,58 @@ wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
     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
+}
+
 #if 0
 //------------------------------------------------------------------------
 // wild character routines
@@ -938,141 +1158,7 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
 
 #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
-*/
-
-#if !defined(__MWERKS__) && !defined(__SALFORDC__) && !defined(__TWIN32__)
-#include <process.h>
-#endif
-
-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
-#ifdef __TWIN32__
-    ::OutputDebugString(achBuffer);
-#else
-    ::OutputDebugStringA(achBuffer);
-#endif
-#endif
-
-    /* bail if it's not Win95 */
-    {
-        OSVERSIONINFO VerInfo;
-        VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-        GetVersionEx(&VerInfo);
-        if ( VerInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS )
-            return;
-    }
-
-    /* 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;
-    }
-
-    /* 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;
-    }
-
-    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;
-    }
-
-    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;
-    }
-
-    /* wait for buffer event */
-    WaitForSingleObject(heventDBWIN, INFINITE);
-
-    /* write it to the shared memory */
-#if defined( __BORLANDC__ ) || defined( __MWERKS__ ) || defined(__SALFORDC__)
-    *((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
-
-
-#ifdef 0
+#if 0
 
 // maximum mumber of lines the output console should have
 static const WORD MAX_CONSOLE_LINES = 500;