compilation fix

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

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index 8b36c7a3dea710996c2d85960a334f131e0da05b..f9db6a472b51f1a2914aa9e8784bf4208478bc68 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


@@ -21,21 +29,29 @@
 #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"
-#include "wx/intl.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(__WXMICROWIN__) && ! (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 <ctype.h>
+#include "wx/timer.h"

 
 

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

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


@@ -48,8 +64,6 @@
     #include <sys/stat.h>
 #endif  //GNUWIN32
 
     #include <sys/stat.h>
 #endif  //GNUWIN32
 

-#include "wx/log.h"
-

 #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.


@@ -66,7 +80,7 @@
     #include <lm.h>
 #endif // USE_NET_API
 
     #include <lm.h>
 #endif // USE_NET_API
 

-#if defined(__WIN32__) && !defined(__WXWINE__)
+#if defined(__WIN32__) && !defined(__WXWINE__) && !defined(__WXMICROWIN__)

     #include <io.h>
 
     #ifndef __GNUWIN32__
     #include <io.h>
 
     #ifndef __GNUWIN32__


@@ -74,15 +88,11 @@
     #endif
 #endif
 
     #endif
 #endif
 

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

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

-#include <stdarg.h>

 
 //// BEGIN for console support: VC++ only
 #ifdef __VISUALC__
 
 //// BEGIN for console support: VC++ only
 #ifdef __VISUALC__


@@ -93,13 +103,7 @@
 
 #include "wx/ioswrap.h"
 
 
 #include "wx/ioswrap.h"
 

-#if wxUSE_IOSTREAMH
-// N.B. BC++ doesn't have istream.h, ostream.h
-#  include <io.h>
-#  include <fstream.h>
-#else
-#  include <fstream>
-#endif
+#include "wx/ioswrap.h"

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


@@ -111,47 +115,112 @@
 #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
   // __VISUALC__
 /// END for console support
 
 #  endif
 
 #endif
   // __VISUALC__
 /// END for console support
 

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

 // In the WIN.INI file
 static const wxChar WX_SECTION[] = wxT("wxWindows");
 // In the WIN.INI file
 static const wxChar WX_SECTION[] = wxT("wxWindows");

+static const wxChar eUSERNAME[]  = wxT("UserName");
+
+// these are only used under Win16
+#if !defined(__WIN32__) && !defined(__WXMICROWIN__)

 static const wxChar eHOSTNAME[]  = wxT("HostName");
 static const wxChar eUSERID[]    = wxT("UserId");
 static const wxChar eHOSTNAME[]  = wxT("HostName");
 static const wxChar eUSERID[]    = wxT("UserId");

-static const wxChar eUSERNAME[]  = wxT("UserName");
+#endif // !Win32
+
+#ifndef __WXMICROWIN__

 
 

-// 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
+// ============================================================================
+// implementation
+// ============================================================================

 
 

-// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
+// ----------------------------------------------------------------------------
+// get host name and related
+// ----------------------------------------------------------------------------
+
+// Get hostname only (without domain name)

 bool wxGetHostName(wxChar *buf, int maxSize)
 {
 bool wxGetHostName(wxChar *buf, int maxSize)
 {

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

 #else
 #else

-  wxChar *sysname;
-  const wxChar *default_host = wxT("noname");
-
-  if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
-     GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
-  } else
-    wxStrncpy(buf, sysname, maxSize - 1);
-  buf[maxSize] = wxT('\0');
-  return *buf ? TRUE : FALSE;
+    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(__WXMICROWIN__) && ! (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
 bool wxGetUserId(wxChar *buf, int maxSize)
 {
 // Get user ID e.g. jacs
 bool wxGetUserId(wxChar *buf, int maxSize)
 {

-#if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__)
+#if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)

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


@@ -166,23 +235,23 @@ bool wxGetUserId(wxChar *buf, int maxSize)
 
     return TRUE;
 #else   // Win16 or Win32s
 
     return TRUE;
 #else   // Win16 or Win32s

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

 
 

-  return *buf ? TRUE : FALSE;
+    return *buf ? TRUE : FALSE;

 #endif
 }
 
 #endif
 }
 


@@ -190,149 +259,614 @@ bool wxGetUserId(wxChar *buf, int maxSize)
 bool wxGetUserName(wxChar *buf, int maxSize)
 {
 #if wxUSE_PENWINDOWS && !defined(__WATCOMC__) && !defined(__GNUWIN32__)
 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
+    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
 #endif

-  {
+    {

 #ifdef USE_NET_API
 #ifdef USE_NET_API

-    CHAR szUserName[256];
-    if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
+        CHAR szUserName[256];
+        if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
+            return FALSE;
+
+        // TODO how to get the domain name?
+        CHAR *szDomain = "";
+
+        // the code is based on the MSDN example (also see KB article Q119670)
+        WCHAR wszUserName[256];          // Unicode user name
+        WCHAR wszDomain[256];
+        LPBYTE ComputerName;
+
+        USER_INFO_2 *ui2;         // User structure
+
+        // Convert ANSI user name and domain to Unicode
+        MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
+                wszUserName, WXSIZEOF(wszUserName) );
+        MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
+                wszDomain, WXSIZEOF(wszDomain) );
+
+        // Get the computer name of a DC for the domain.
+        if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
+        {
+            wxLogError(wxT("Can not find domain controller"));
+
+            goto error;
+        }
+
+        // Look up the user on the DC
+        NET_API_STATUS status = NetUserGetInfo( (LPWSTR)ComputerName,
+                (LPWSTR)&wszUserName,
+                2, // level - we want USER_INFO_2
+                (LPBYTE *) &ui2 );
+        switch ( status )
+        {
+            case NERR_Success:
+                // ok
+                break;
+
+            case NERR_InvalidComputer:
+                wxLogError(wxT("Invalid domain controller name."));
+
+                goto error;
+
+            case NERR_UserNotFound:
+                wxLogError(wxT("Invalid user name '%s'."), szUserName);
+
+                goto error;
+
+            default:
+                wxLogSysError(wxT("Can't get information about user"));
+
+                goto error;
+        }
+
+        // Convert the Unicode full name to ANSI
+        WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
+                buf, maxSize, NULL, NULL );
+
+        return TRUE;
+
+error:
+        wxLogError(wxT("Couldn't look up full user name."));
+

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

 
 

-    // TODO how to get the domain name?
-    CHAR *szDomain = "";
+    wxString strPath;
+    ::GetModuleFileName(::GetModuleHandle(NULL),
+                        strPath.GetWriteBuf(MAX_PATH), MAX_PATH);
+    strPath.UngetWriteBuf();

 
 

-    // the code is based on the MSDN example (also see KB article Q119670)
-    WCHAR wszUserName[256];          // Unicode user name
-    WCHAR wszDomain[256];
-    LPBYTE ComputerName;
+    // extract the dir name
+    wxSplitPath(strPath, &strDir, NULL, NULL);

 
 

-    USER_INFO_2 *ui2;         // User structure
+  #endif  // UNIX/Win
+
+  return strDir.c_str();
+}
+
+wxChar *wxGetUserHome(const wxString& WXUNUSED(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)
+{
+#ifdef __WXMICROWIN__
+    return wxPathExist(dir);
+#elif defined(__WIN32__)
+    DWORD attribs = GetFileAttributes(dir);
+    return ((attribs != (DWORD)-1) && (attribs & FILE_ATTRIBUTE_DIRECTORY));
+#else // Win16
+    #ifdef __BORLANDC__
+        struct ffblk fileInfo;
+    #else
+        struct find_t fileInfo;
+    #endif
+    // In Borland findfirst has a different argument
+    // ordering from _dos_findfirst. But _dos_findfirst
+    // _should_ be ok in both MS and Borland... why not?
+    #ifdef __BORLANDC__
+        return (findfirst(dir, &fileInfo, _A_SUBDIR) == 0 &&
+               (fileInfo.ff_attrib & _A_SUBDIR) != 0);
+    #else
+        return (_dos_findfirst(dir, _A_SUBDIR, &fileInfo) == 0) &&
+               ((fileInfo.attrib & _A_SUBDIR) != 0);
+    #endif
+#endif // Win32/16
+}

 
 

-    // 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) );
+// ----------------------------------------------------------------------------
+// env vars
+// ----------------------------------------------------------------------------

 
 

-    // Get the computer name of a DC for the domain.
-    if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
+bool wxGetEnv(const wxString& var, wxString *value)
+{
+#ifdef __WIN16__
+    const wxChar* ret = wxGetenv(var);
+    if (ret)
+    {
+        *value = ret;
+        return TRUE;
+    }
+    else
+        return FALSE;
+#else
+    // first get the size of the buffer
+    DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
+    if ( !dwRet )

     {
     {

-        wxLogError(wxT("Can not find domain controller"));
+        // this means that there is no such variable
+        return FALSE;
+    }

 
 

-        goto error;
+    if ( value )
+    {
+        (void)::GetEnvironmentVariable(var, value->GetWriteBuf(dwRet), dwRet);
+        value->UngetWriteBuf();

     }
 
     }
 

-    // 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 )
+    return TRUE;
+#endif
+}
+
+bool wxSetEnv(const wxString& var, const wxChar *value)
+{
+    // some compilers have putenv() or _putenv() or _wputenv() but it's better
+    // to always use Win32 function directly instead of dealing with them
+#if defined(__WIN32__)
+    if ( !::SetEnvironmentVariable(var, value) )

     {
     {

-        case NERR_Success:
-            // ok
-            break;
+        wxLogLastError(_T("SetEnvironmentVariable"));

 
 

-        case NERR_InvalidComputer:
-            wxLogError(wxT("Invalid domain controller name."));
+        return FALSE;
+    }

 
 

-            goto error;
+    return TRUE;
+#else // no way to set env vars
+    return FALSE;
+#endif
+}

 
 

-        case NERR_UserNotFound:
-            wxLogError(wxT("Invalid user name '%s'."), szUserName);
+// ----------------------------------------------------------------------------
+// process management
+// ----------------------------------------------------------------------------

 
 

-            goto error;
+#ifdef __WIN32__

 
 

-        default:
-            wxLogSysError(wxT("Can't get information about user"));
+// structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
+struct wxFindByPidParams
+{
+    wxFindByPidParams() { hwnd = 0; pid = 0; }

 
 

-            goto error;
-    }
+    // the HWND used to return the result
+    HWND hwnd;
+
+    // the PID we're looking from
+    DWORD pid;
+};
+
+// wxKill helper: EnumWindows() callback which is used to find the first (top
+// level) window belonging to the given process
+BOOL CALLBACK wxEnumFindByPidProc(HWND hwnd, LPARAM lParam)
+{
+    DWORD pid;
+    (void)::GetWindowThreadProcessId(hwnd, &pid);
+
+    wxFindByPidParams *params = (wxFindByPidParams *)lParam;
+    if ( pid == params->pid )
+    {
+        // remember the window we found
+        params->hwnd = hwnd;

 
 

-    // Convert the Unicode full name to ANSI
-    WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
-                         buf, maxSize, NULL, NULL );
+        // return FALSE to stop the enumeration
+        return FALSE;
+    }

 
 

+    // continue enumeration

     return TRUE;
     return TRUE;

+}

 
 

-error:
-  wxLogError(wxT("Couldn't look up full user name."));
+#endif // __WIN32__

 
 

-  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 )
+int wxKill(long pid, wxSignal sig, wxKillError *krc)
+{
+#ifdef __WIN32__
+    // get the process handle to operate on
+    HANDLE hProcess = ::OpenProcess(SYNCHRONIZE |
+                                    PROCESS_TERMINATE |
+                                    PROCESS_QUERY_INFORMATION,
+                                    FALSE, // not inheritable
+                                    (DWORD)pid);
+    if ( hProcess == NULL )

     {
     {

-        ok = wxGetUserId(buf, maxSize);
+        if ( krc )
+        {
+            if ( ::GetLastError() == ERROR_ACCESS_DENIED )
+            {
+                *krc = wxKILL_ACCESS_DENIED;
+            }
+            else
+            {
+                *krc = wxKILL_NO_PROCESS;
+            }
+        }
+
+        return -1;

     }
 
     }
 

-    if ( !ok )
+    bool ok = TRUE;
+    switch ( sig )

     {
     {

-        wxStrncpy(buf, wxT("Unknown User"), maxSize);
+        case wxSIGKILL:
+            // kill the process forcefully returning -1 as error code
+            if ( !::TerminateProcess(hProcess, (UINT)-1) )
+            {
+                wxLogSysError(_("Failed to kill process %d"), pid);
+
+                if ( krc )
+                {
+                    // this is not supposed to happen if we could open the
+                    // process
+                    *krc = wxKILL_ERROR;
+                }
+
+                ok = FALSE;
+            }
+            break;
+
+        case wxSIGNONE:
+            // do nothing, we just want to test for process existence
+            break;
+
+        default:
+            // any other signal means "terminate"
+            {
+                wxFindByPidParams params;
+                params.pid = (DWORD)pid;
+
+                // EnumWindows() has nice semantics: it returns 0 if it found
+                // something or if an error occured and non zero if it
+                // enumerated all the window
+                if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
+                {
+                    // did we find any window?
+                    if ( params.hwnd )
+                    {
+                        // tell the app to close
+                        //
+                        // NB: this is the harshest way, the app won't have
+                        //     opportunity to save any files, for example, but
+                        //     this is probably what we want here. If not we
+                        //     can also use SendMesageTimeout(WM_CLOSE)
+                        if ( !::PostMessage(params.hwnd, WM_QUIT, 0, 0) )
+                        {
+                            wxLogLastError(_T("PostMessage(WM_QUIT)"));
+                        }
+                    }
+                    else // it was an error then
+                    {
+                        wxLogLastError(_T("EnumWindows"));
+
+                        ok = FALSE;
+                    }
+                }
+                else // no windows for this PID
+                {
+                    if ( krc )
+                    {
+                        *krc = wxKILL_ERROR;
+                    }
+
+                    ok = FALSE;
+                }
+            }

     }
     }

-#endif // Win32/16
-  }

 
 

-  return TRUE;
-}
+    // the return code
+    DWORD rc;

 
 

-int wxKill(long pid, int sig)
-{
-  return 0;
+    if ( ok )
+    {
+        // as we wait for a short time, we can use just WaitForSingleObject()
+        // and not MsgWaitForMultipleObjects()
+        switch ( ::WaitForSingleObject(hProcess, 500 /* msec */) )
+        {
+            case WAIT_OBJECT_0:
+                // process terminated
+                if ( !::GetExitCodeProcess(hProcess, &rc) )
+                {
+                    wxLogLastError(_T("GetExitCodeProcess"));
+                }
+                break;
+
+            default:
+                wxFAIL_MSG( _T("unexpected WaitForSingleObject() return") );
+                // fall through
+
+            case WAIT_FAILED:
+                wxLogLastError(_T("WaitForSingleObject"));
+                // fall through
+
+            case WAIT_TIMEOUT:
+                if ( krc )
+                {
+                    *krc = wxKILL_ERROR;
+                }
+
+                rc = STILL_ACTIVE;
+                break;
+        }
+    }
+    else // !ok
+    {
+        // just to suppress the warnings about uninitialized variable
+        rc = 0;
+    }
+
+    ::CloseHandle(hProcess);
+
+    // the return code is the same as from Unix kill(): 0 if killed
+    // successfully or -1 on error
+    if ( sig == wxSIGNONE )
+    {
+        if ( ok && rc == STILL_ACTIVE )
+        {
+            // there is such process => success
+            return 0;
+        }
+    }
+    else // not SIGNONE
+    {
+        if ( ok && rc != STILL_ACTIVE )
+        {
+            // killed => success
+            return 0;
+        }
+    }
+#else // Win15
+    wxFAIL_MSG( _T("not implemented") );
+#endif // Win32/Win16
+
+    // error
+    return -1;

 }
 
 }
 

-//

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

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

 {
 {

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

 
 

-  wxChar tmp[255];
-  if (command != wxT(""))
-    wxSprintf(tmp, wxT("%s /c %s"), shell, WXSTRINGCAST command);
-  else
-    wxStrcpy(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((wxChar *)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()
 {
 #if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
 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
 #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('8'));
+                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
+
+#if wxUSE_TIMER
+

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

-static bool inTimer = FALSE;
-class wxSleepTimer: public wxTimer
+static bool gs_inTimer = FALSE;
+
+class wxSleepTimer : public wxTimer

 {
 {

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

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


@@ -341,42 +875,38 @@ void wxUsleep(unsigned long milliseconds)
 {
 #ifdef __WIN32__
     ::Sleep(milliseconds);
 {
 #ifdef __WIN32__
     ::Sleep(milliseconds);

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

 }
 
 void wxSleep(int nSecs)
 {
 }
 
 void wxSleep(int nSecs)
 {

-#if 0 // WIN32 hangs app
-  Sleep( 1000*nSecs );
-#else
-  if (inTimer)
-    return;
-
-  wxTheSleepTimer = new wxSleepTimer;
-  inTimer = TRUE;
-  wxTheSleepTimer->Start(nSecs*1000);
-  while (inTimer)
-  {
-    if (wxTheApp->Pending())
-      wxTheApp->Dispatch();
-  }
-  delete wxTheSleepTimer;
-  wxTheSleepTimer = NULL;
-#endif
+    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


@@ -385,7 +915,32 @@ void wxFlushEvents()
 //  wxYield();
 }
 
 //  wxYield();
 }
 

+#endif // wxUSE_TIMER
+
+#elif defined(__WIN32__) // wxUSE_GUI
+
+void wxUsleep(unsigned long milliseconds)
+{
+    ::Sleep(milliseconds);
+}
+
+void wxSleep(int nSecs)
+{
+    wxUsleep(1000*nSecs);
+}
+
+#endif // wxUSE_GUI/!wxUSE_GUI
+#endif
+  // __WXMICROWIN__
+
+// ----------------------------------------------------------------------------
+// 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.

+#ifndef __WXMICROWIN__

 void wxDebugMsg(const wxChar *fmt ...)
 {
   va_list ap;
 void wxDebugMsg(const wxChar *fmt ...)
 {
   va_list ap;


@@ -417,65 +972,11 @@ void wxFatalError(const wxString& msg, const wxString& title)
   wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg);
   FatalAppExit(0, (LPCTSTR)wxBuffer);
 }
   wxSprintf(wxBuffer, wxT("%s: %s"), WXSTRINGCAST title, WXSTRINGCAST msg);
   FatalAppExit(0, (LPCTSTR)wxBuffer);
 }

+#endif // __WXMICROWIN__

 
 

-// Emit a beeeeeep
-void wxBell()
-{
-    // Removed by RD because IHMO syncronous sound is a Bad Thing.  MessageBeep
-    // will do a similar thing anyway if there is no sound card...
-//#ifdef __WIN32__
-//  Beep(1000,1000) ; // 1kHz during 1 sec.
-//#else
-  MessageBeep((UINT)-1) ;
-//#endif
-}
-
-// Chris Breeze 27/5/98: revised WIN32 code to
-// detect WindowsNT correctly
-int wxGetOsVersion(int *majorVsn, int *minorVsn)
-{
-  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
 
 // Reading and writing resources (eg WIN.INI, .Xdefaults)
 #if wxUSE_RESOURCES


@@ -495,84 +996,87 @@ bool wxWriteResource(const wxString& section, const wxString& entry, const wxStr
 
 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)
 {

-  wxChar buf[50];
-  wxSprintf(buf, wxT("%.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)
 {

-  wxChar buf[50];
-  wxSprintf(buf, wxT("%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)
 {

-  wxChar buf[50];
-  wxSprintf(buf, wxT("%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, wxChar **value, const wxString& file)
 {
 }
 
 bool wxGetResource(const wxString& section, const wxString& entry, wxChar **value, const wxString& file)
 {

-  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;
+    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)
 {

-  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;
+    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)
 {

-  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;
+    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)
 {

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


@@ -580,17 +1084,24 @@ bool wxGetResource(const wxString& section, const wxString& entry, int *value, c
 // helper functions for showing a "busy" cursor
 // ---------------------------------------------------------------------------
 
 // helper functions for showing a "busy" cursor
 // ---------------------------------------------------------------------------
 

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

 static int gs_wxBusyCursorCount = 0;
 
 static int gs_wxBusyCursorCount = 0;
 

+extern HCURSOR wxGetCurrentBusyCursor()
+{
+    return gs_wxBusyCursor;
+}
+

 // Set the cursor to the busy cursor for all windows
 void wxBeginBusyCursor(wxCursor *cursor)
 {
     if ( gs_wxBusyCursorCount++ == 0 )
     {
         gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();
 // Set the cursor to the busy cursor for all windows
 void wxBeginBusyCursor(wxCursor *cursor)
 {
     if ( gs_wxBusyCursorCount++ == 0 )
     {
         gs_wxBusyCursor = (HCURSOR)cursor->GetHCURSOR();

+#ifndef __WXMICROWIN__

         gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);
         gs_wxBusyCursorOld = ::SetCursor(gs_wxBusyCursor);

+#endif

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


@@ -603,8 +1114,9 @@ void wxEndBusyCursor()
 
     if ( --gs_wxBusyCursorCount == 0 )
     {
 
     if ( --gs_wxBusyCursorCount == 0 )
     {

+#ifndef __WXMICROWIN__

         ::SetCursor(gs_wxBusyCursorOld);
         ::SetCursor(gs_wxBusyCursorOld);

-
+#endif

         gs_wxBusyCursorOld = 0;
     }
 }
         gs_wxBusyCursorOld = 0;
     }
 }


@@ -615,230 +1127,158 @@ bool wxIsBusy()
   return (gs_wxBusyCursorCount > 0);
 }
 
   return (gs_wxBusyCursorCount > 0);
 }
 

-// ---------------------------------------------------------------------------
-const wxChar* wxGetHomeDir(wxString *pstr)
-{
-  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
-
-    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
-wxChar *wxGetUserHome (const wxString& user)
-{
-  wxChar *home;
-  wxString user1(user);
-
-  if (user1 != wxT("")) {
-    wxChar tmp[64];
-    if (wxGetUserId(tmp, sizeof(tmp)/sizeof(char))) {
-      // Guests belong in the temp dir
-      if (wxStricmp(tmp, wxT("annonymous")) == 0) {
-        if ((home = wxGetenv(wxT("TMP"))) != NULL ||
-            (home = wxGetenv(wxT("TMPDIR"))) != NULL ||
-            (home = wxGetenv(wxT("TEMP"))) != NULL)
-            return *home ? home : (wxChar*)wxT("\\");
-      }
-      if (wxStricmp(tmp, WXSTRINGCAST user1) == 0)
-        user1 = wxT("");
-    }
-  }
-  if (user1 == wxT(""))
-    if ((home = wxGetenv(wxT("HOME"))) != NULL)
-    {
-      wxStrcpy(wxBuffer, home);
-      Unix2DosFilename(wxBuffer);
-      return wxBuffer;
-    }
-  return NULL; // No home known!
-}
-

 // 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{
-    wxFAIL_MSG(wxT("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__
+#ifndef __WXMICROWIN__

 wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
 {
 wxChar *wxLoadUserResource(const wxString& resourceName, const wxString& resourceType)
 {

-  wxChar *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;
-  wxChar *theText = (wxChar *)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__
 #ifndef __WIN32__

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

 #endif
 
 #endif
 

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

 
 

-  return s;
+    return s;

 }
 #endif
 
 }
 #endif
 

+// ----------------------------------------------------------------------------
+// get display info
+// ----------------------------------------------------------------------------
+
+// See also the wxGetMousePosition in window.cpp
+// Deprecated: use wxPoint wxGetMousePosition() instead

 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
 bool wxColourDisplay()
 {
 };
 
 // Return TRUE if we have a colour display
 bool wxColourDisplay()
 {

-  HDC dc = ::GetDC((HWND) NULL);
-  bool flag;
-  int noCols = GetDeviceCaps(dc, NUMCOLORS);
-  if ((noCols == -1) || (noCols > 2))
-    flag = TRUE;
-  else
-    flag = FALSE;
-  ReleaseDC((HWND) NULL, dc);
-  return flag;
+#ifdef __WXMICROWIN__
+    // MICROWIN_TODO
+    return TRUE;
+#else
+    // this function is called from wxDC ctor so it is called a *lot* of times
+    // hence we optimize it a bit but doign the check only once
+    //
+    // this should be MT safe as only the GUI thread (holding the GUI mutex)
+    // can call us
+    static int s_isColour = -1;
+
+    if ( s_isColour == -1 )
+    {
+        ScreenHDC dc;
+        int noCols = ::GetDeviceCaps(dc, NUMCOLORS);
+
+        s_isColour = (noCols == -1) || (noCols > 2);
+    }
+
+    return s_isColour != 0;
+#endif

 }
 
 // Returns depth of screen
 int wxDisplayDepth()
 {
 }
 
 // Returns depth of screen
 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)
 {
 }
 
 // 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);
+#ifdef __WXMICROWIN__
+    RECT rect;
+    HWND hWnd = GetDesktopWindow();
+    ::GetWindowRect(hWnd, & rect);
+
+    *width = rect.right - rect.left;
+    *height = rect.bottom - rect.top;
+#else
+    ScreenHDC dc;
+
+    if ( width ) *width = GetDeviceCaps(dc, HORZRES);
+    if ( height ) *height = GetDeviceCaps(dc, VERTRES);
+#endif

 }
 
 }
 

-bool wxDirExists(const wxString& dir)
+void wxDisplaySizeMM(int *width, int *height)

 {
 {

-  /* MATTHEW: [6] Always use same code for Win32, call FindClose */
-#if defined(__WIN32__)
-  WIN32_FIND_DATA fileInfo;
+#ifdef __WXMICROWIN__
+    // MICROWIN_TODO
+    *width = 0; * height = 0;

 #else
 #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 ( width ) *width = GetDeviceCaps(dc, HORZSIZE);
+    if ( height ) *height = GetDeviceCaps(dc, VERTSIZE);
+#endif
+}

 
 

-  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));
+void wxClientDisplayRect(int *x, int *y, int *width, int *height)
+{
+#if defined(__WIN16__) || defined(__WXMICROWIN__)
+    *x = 0; *y = 0;
+    wxDisplaySize(width, height);

 #else
 #else

-  return (((_dos_findfirst(WXSTRINGCAST dir, _A_SUBDIR, &fileInfo) == 0) && (fileInfo.attrib & _A_SUBDIR)) != 0);
-#endif
+    // Determine the desktop dimensions minus the taskbar and any other
+    // special decorations...
+    RECT r;
+
+    SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
+    if (x)      *x = r.left;
+    if (y)      *y = r.top;
+    if (width)  *width = r.right - r.left;
+    if (height) *height = r.bottom - r.top;

 #endif
 }
 
 #endif
 }
 

+

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


@@ -855,6 +1295,10 @@ wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
 
 wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
 {
 
 wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
 {

+#ifdef __WXMICROWIN__
+    // MICROWIN_TODO
+    return wxEmptyString;
+#else

     wxString str;
 
     int len = 256; // some starting value
     wxString str;
 
     int len = 256; // some starting value


@@ -894,17 +1338,58 @@ wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
     }
 
     return str;
     }
 
     return str;

+#endif

 }
 
 WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
 {
 #ifndef __WIN32__
 }
 
 WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
 {
 #ifndef __WIN32__

-    return GetWindowWord((HWND)hWnd, GWW_ID);
+    return (WXWORD)GetWindowWord((HWND)hWnd, GWW_ID);

 #else // Win32
 #else // Win32

-    return GetWindowLong((HWND)hWnd, GWL_ID);
+    return (WXWORD)GetWindowLong((HWND)hWnd, GWL_ID);

 #endif // Win16/32
 }
 
 #endif // Win16/32
 }
 

+#endif // wxUSE_GUI
+
+#if wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// Metafile helpers
+// ----------------------------------------------------------------------------
+
+extern void PixelToHIMETRIC(LONG *x, LONG *y)
+{
+    ScreenHDC hdcRef;
+
+    int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
+        iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
+        iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
+        iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
+
+    *x *= (iWidthMM * 100);
+    *x /= iWidthPels;
+    *y *= (iHeightMM * 100);
+    *y /= iHeightPels;
+}
+
+extern void HIMETRICToPixel(LONG *x, LONG *y)
+{
+    ScreenHDC hdcRef;
+
+    int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
+        iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
+        iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
+        iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
+
+    *x *= iWidthPels;
+    *x /= (iWidthMM * 100);
+    *y *= iHeightPels;
+    *y /= (iHeightMM * 100);
+}
+
+#endif // wxUSE_GUI
+

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


@@ -1062,7 +1547,7 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
     return ((*str == '\0') && (*pattern == '\0'));
 };
 
     return ((*str == '\0') && (*pattern == '\0'));
 };
 

-#endif
+#endif // 0

 
 #if 0
 
 
 #if 0
 


@@ -1128,4 +1613,13 @@ void wxRedirectIOToConsole()
 }
 #endif
 
 }
 #endif
 

+#ifdef __WXMICROWIN__
+int wxGetOsVersion(int *majorVsn, int *minorVsn)
+{
+    // MICROWIN_TODO
+    if (majorVsn) *majorVsn = 0;
+    if (minorVsn) *minorVsn = 0;
+    return wxUNIX;
+}
+#endif