corrected use of Print Manager Session APIs for Carbon targets

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

diff --git a/src/msw/utils.cpp b/src/msw/utils.cpp
index e0ed4d72464ba873c3e150ccc0529db6f780a466..f5efb921f00893465a43df83d82b88b80dfbd423 100644 (file)
--- a/src/msw/utils.cpp
+++ b/src/msw/utils.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

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

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


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

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

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


@@ -17,51 +25,69 @@
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

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

 #endif  //WX_PRECOMP
 
 #endif  //WX_PRECOMP
 

-#include "wx/msw/private.h"
-#include "wx/timer.h"
-#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(__GNUWIN32__) && !defined(__MINGW32__))
+extern "C" {
+    #include <winsock.h>    // we use socket functions in wxGetFullHostName()
+}
+#endif
+
+#include "wx/msw/private.h"     // includes <windows.h>

 
 

-#include <windows.h>
+#include "wx/timer.h"

 
 #include <ctype.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__)
 #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
 
 #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.

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

 #endif
 
 #endif
 

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

 
 

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

 #endif
 
 #include <stdio.h>
 #endif
 
 #include <stdio.h>


@@ -75,6 +101,7 @@
 #include <stdarg.h>
 
 //// BEGIN for console support: VC++ only
 #include <stdarg.h>
 
 //// BEGIN for console support: VC++ only

+#ifdef __VISUALC__

 
 #include "wx/msw/msvcrt.h"
 
 
 #include "wx/msw/msvcrt.h"
 


@@ -100,234 +127,825 @@
 #endif
 
 #  if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
 #endif
 
 #  if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS

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

 #  endif
 
 #  endif
 

+#endif
+  // __VISUALC__

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

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

 // In the WIN.INI file
 // In the WIN.INI file

-static const char WX_SECTION[] = "wxWindows";
-static const char eHOSTNAME[]  = "HostName";
-static const char eUSERID[]    = "UserId";
-static const char eUSERNAME[]  = "UserName";
-
-// For the following functions we SHOULD fill in support
-// for Windows-NT (which I don't know) as I assume it begin
-// a POSIX Unix (so claims MS) that it has some special
-// functions beyond those provided by WinSock
-
-// Get full hostname (eg. DoDo.BSn-Germany.crg.de)
-bool wxGetHostName(char *buf, int maxSize)
+static const wxChar WX_SECTION[] = wxT("wxWindows");
+static const wxChar eUSERNAME[]  = wxT("UserName");
+
+// these are only used under Win16
+#ifndef __WIN32__
+static const wxChar eHOSTNAME[]  = wxT("HostName");
+static const wxChar eUSERID[]    = wxT("UserId");
+#endif // !Win32
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// get host name and related
+// ----------------------------------------------------------------------------
+
+// Get hostname only (without domain name)
+bool wxGetHostName(wxChar *buf, int maxSize)

 {
 #if defined(__WIN32__) && !defined(__TWIN32__)
 {
 #if defined(__WIN32__) && !defined(__TWIN32__)

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

 #else
 #else

-  char *sysname;
-  const char *default_host = "noname";
-
-  if ((sysname = getenv("SYSTEM_NAME")) == NULL) {
-     GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
-  } else
-    strncpy(buf, sysname, maxSize - 1);
-  buf[maxSize] = '\0';
-  return *buf ? TRUE : FALSE;
+    wxChar *sysname;
+    const wxChar *default_host = wxT("noname");
+
+    if ((sysname = wxGetenv(wxT("SYSTEM_NAME"))) == NULL) {
+        GetProfileString(WX_SECTION, eHOSTNAME, default_host, buf, maxSize - 1);
+    } else
+        wxStrncpy(buf, sysname, maxSize - 1);
+    buf[maxSize] = wxT('\0');
+    return *buf ? TRUE : FALSE;

 #endif
 }
 
 #endif
 }
 

+// get full hostname (with domain name if possible)
+bool wxGetFullHostName(wxChar *buf, int maxSize)
+{
+#if defined(__WIN32__) && !defined(__TWIN32__) && ! (defined(__GNUWIN32__) && !defined(__MINGW32__))
+    // TODO should use GetComputerNameEx() when available
+    WSADATA wsa;
+    if ( WSAStartup(MAKEWORD(1, 1), &wsa) == 0 )
+    {
+        wxString host;
+        char bufA[256];
+        if ( gethostname(bufA, WXSIZEOF(bufA)) == 0 )
+        {
+            // gethostname() won't usually include the DNS domain name, for
+            // this we need to work a bit more
+            if ( !strchr(bufA, '.') )
+            {
+                struct hostent *pHostEnt =  gethostbyname(bufA);
+
+                if ( pHostEnt )
+                {
+                    // Windows will use DNS internally now
+                    pHostEnt = gethostbyaddr(pHostEnt->h_addr, 4, PF_INET);
+                }
+
+                if ( pHostEnt )
+                {
+                    host = pHostEnt->h_name;
+                }
+            }
+        }
+
+        WSACleanup();
+
+        if ( !!host )
+        {
+            wxStrncpy(buf, host, maxSize);
+
+            return TRUE;
+        }
+    }
+#endif // Win32
+
+    return wxGetHostName(buf, maxSize);
+}
+

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

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

 {
 #if defined(__WIN32__) && !defined(__win32s__) && !defined(__TWIN32__)
 {
 #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
+}
+
+// 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;

 
 

-  // Convert ASCII user name and domain to Unicode.
+        // TODO how to get the domain name?
+        CHAR *szDomain = "";

 
 

-  MultiByteToWideChar( CP_ACP, 0, UserName,
-     strlen(UserName)+1, wszUserName, sizeof(wszUserName) );
-  MultiByteToWideChar( CP_ACP, 0, Domain,
-     strlen(Domain)+1, wszDomain, sizeof(wszDomain) );
+        // the code is based on the MSDN example (also see KB article Q119670)
+        WCHAR wszUserName[256];          // Unicode user name
+        WCHAR wszDomain[256];
+        LPBYTE ComputerName;

 
 

-  // Get the computer name of a DC for the specified domain.
-  // >If you get a link error on this, include netapi32.lib<
+        USER_INFO_2 *ui2;         // User structure

 
 

-  NetGetDCName( NULL, wszDomain, &ComputerName );
+        // Convert ANSI user name and domain to Unicode
+        MultiByteToWideChar( CP_ACP, 0, szUserName, strlen(szUserName)+1,
+                wszUserName, WXSIZEOF(wszUserName) );
+        MultiByteToWideChar( CP_ACP, 0, szDomain, strlen(szDomain)+1,
+                wszDomain, WXSIZEOF(wszDomain) );

 
 

-  // Look up the user on the DC.
+        // Get the computer name of a DC for the domain.
+        if ( NetGetDCName( NULL, wszDomain, &ComputerName ) != NERR_Success )
+        {
+            wxLogError(wxT("Can not find domain controller"));

 
 

-  if(NetUserGetInfo( (LPWSTR) ComputerName,
-     (LPWSTR) &wszUserName, 2, (LPBYTE *) &ui))
-  {
-     printf( "Error getting user information.\n" );
-     return( FALSE );
-  }
+            goto error;
+        }

 
 

-  // Convert the Unicode full name to ASCII.
+        // 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;

 
 

-  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");
+            case NERR_InvalidComputer:
+                wxLogError(wxT("Invalid domain controller name."));
+
+                goto error;
+
+            case NERR_UserNotFound:
+                wxLogError(wxT("Invalid user name '%s'."), szUserName);
+
+                goto error;
+
+            default:
+                wxLogSysError(wxT("Can't get information about user"));
+
+                goto error;
+        }
+
+        // Convert the Unicode full name to ANSI
+        WideCharToMultiByte( CP_ACP, 0, ui2->usri2_full_name, -1,
+                buf, maxSize, NULL, NULL );
+
+        return TRUE;
+
+error:
+        wxLogError(wxT("Couldn't look up full user name."));

 
         return FALSE;
 
         return FALSE;

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

     }
 
     return TRUE;
     }
 
     return TRUE;

-#endif  // 0/1
+}

 
 

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

 }
 
 }
 

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

 {
 {

-#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
+    // 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__)
+    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
+}
+
+// ----------------------------------------------------------------------------
+// env vars
+// ----------------------------------------------------------------------------
+
+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 )
+    {
+        // this means that there is no such variable
+        return FALSE;
+    }
+
+    if ( value )
+    {
+        (void)::GetEnvironmentVariable(var, value->GetWriteBuf(dwRet), dwRet);
+        value->UngetWriteBuf();
+    }
+
+    return TRUE;

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

     {
     {

-        ok = wxGetUserId(buf, maxSize);
+        wxLogLastError(_T("SetEnvironmentVariable"));
+
+        return FALSE;

     }
 
     }
 

-    if ( !ok )
+    return TRUE;
+#else // no way to set env vars
+    return FALSE;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// process management
+// ----------------------------------------------------------------------------
+
+#ifdef __WIN32__
+
+// structure used to pass parameters from wxKill() to wxEnumFindByPidProc()
+struct wxFindByPidParams
+{
+    wxFindByPidParams() { hwnd = 0; pid = 0; }
+
+    // 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 )

     {
     {

-        strncpy(buf, "Unknown User", maxSize);
+        // remember the window we found
+        params->hwnd = hwnd;
+
+        // return FALSE to stop the enumeration
+        return FALSE;

     }
     }

-  }

 
 

-  return TRUE;
+    // continue enumeration
+    return TRUE;

 }
 
 }
 

-int wxKill(long pid, int sig)
+#endif // __WIN32__
+
+int wxKill(long pid, wxSignal sig, wxKillError *krc)

 {
 {

-  return 0;
+#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 )
+    {
+        if ( krc )
+        {
+            if ( ::GetLastError() == ERROR_ACCESS_DENIED )
+            {
+                *krc = wxKILL_ACCESS_DENIED;
+            }
+            else
+            {
+                *krc = wxKILL_NO_PROCESS;
+            }
+        }
+
+        return -1;
+    }
+
+    bool ok = TRUE;
+    switch ( sig )
+    {
+        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;
+                }
+            }
+    }
+
+    // the return code
+    DWORD rc;
+
+    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)

 {
 {

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

 
 

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

 
 

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

 }
 
 }
 

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

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

-long wxGetFreeMemory(void)
+long wxGetFreeMemory()

 {
 #if defined(__WIN32__) && !defined(__BORLANDC__) && !defined(__TWIN32__)
 {
 #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
+

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

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

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

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

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

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

 {
 {

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

 #else
 #else

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

 #endif
 }
 
 #endif
 }
 

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

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

-void wxFlushEvents(void)
+void wxFlushEvents()

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

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

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

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

 {
   va_list ap;
 {
   va_list ap;

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

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


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

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

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


@@ -343,8 +961,8 @@ void wxDebugMsg(const char *fmt ...)
 // Non-fatal error: pop up message box and (possibly) continue
 void wxError(const wxString& msg, const wxString& title)
 {
 // Non-fatal error: pop up message box and (possibly) continue
 void wxError(const wxString& msg, const wxString& title)
 {

-  sprintf(wxBuffer, "%s\nContinue?", WXSTRINGCAST msg);
-  if (MessageBox(NULL, (LPCSTR)wxBuffer, (LPCSTR)WXSTRINGCAST title,
+  wxSprintf(wxBuffer, wxT("%s\nContinue?"), WXSTRINGCAST msg);
+  if (MessageBox(NULL, (LPCTSTR)wxBuffer, (LPCTSTR)WXSTRINGCAST title,

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


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

-  sprintf(wxBuffer, "%s: %s", WXSTRINGCAST title, WXSTRINGCAST msg);
-  FatalAppExit(0, (LPCSTR)wxBuffer);
-}
-
-// 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)
 {
 
 // Reading and writing resources (eg WIN.INI, .Xdefaults)
 #if wxUSE_RESOURCES
 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
 {

-  if (file != "")
-    return (WritePrivateProfileString((LPCSTR)WXSTRINGCAST section, (LPCSTR)WXSTRINGCAST entry, (LPCSTR)value, (LPCSTR)WXSTRINGCAST file) != 0);
+  if (file != wxT(""))
+// Don't know what the correct cast should be, but it doesn't
+// compile in BC++/16-bit without this cast.
+#if !defined(__WIN32__)
+    return (WritePrivateProfileString((const char*) section, (const char*) entry, (const char*) value, (const char*) file) != 0);
+#else
+    return (WritePrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)value, (LPCTSTR)WXSTRINGCAST file) != 0);
+#endif

   else
   else

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

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

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

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

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

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

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

 }
 
 }
 

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

 {
 {

-  static const char defunkt[] = "$$default";
-  if (file != "")
-  {
-    int n = GetPrivateProfileString((LPCSTR)WXSTRINGCAST section, (LPCSTR)WXSTRINGCAST entry, (LPCSTR)defunkt,
-                                    (LPSTR)wxBuffer, 1000, (LPCSTR)WXSTRINGCAST file);
-    if (n == 0 || strcmp(wxBuffer, defunkt) == 0)
-     return FALSE;
-  }
-  else
-  {
-    int n = GetProfileString((LPCSTR)WXSTRINGCAST section, (LPCSTR)WXSTRINGCAST entry, (LPCSTR)defunkt,
-                                    (LPSTR)wxBuffer, 1000);
-    if (n == 0 || strcmp(wxBuffer, defunkt) == 0)
-      return FALSE;
-  }
-  if (*value) delete[] (*value);
-      *value = copystring(wxBuffer);
-      return TRUE;
+    static const wxChar defunkt[] = wxT("$$default");
+    if (file != wxT(""))
+    {
+        int n = GetPrivateProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
+                (LPTSTR)wxBuffer, 1000, (LPCTSTR)WXSTRINGCAST file);
+        if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
+            return FALSE;
+    }
+    else
+    {
+        int n = GetProfileString((LPCTSTR)WXSTRINGCAST section, (LPCTSTR)WXSTRINGCAST entry, (LPCTSTR)defunkt,
+                (LPTSTR)wxBuffer, 1000);
+        if (n == 0 || wxStrcmp(wxBuffer, defunkt) == 0)
+            return FALSE;

     }
     }

+    if (*value) delete[] (*value);
+    *value = copystring(wxBuffer);
+    return TRUE;
+}

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

-  char *s = NULL;
-  bool succ = wxGetResource(section, entry, (char **)&s, file);
-  if (succ)
-  {
-    *value = (float)strtod(s, NULL);
-    delete[] s;
-    return TRUE;
-  }
-  else return FALSE;
+    wxChar *s = NULL;
+    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
+    if (succ)
+    {
+        *value = (float)wxStrtod(s, NULL);
+        delete[] s;
+        return TRUE;
+    }
+    else return FALSE;

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

-  char *s = NULL;
-  bool succ = wxGetResource(section, entry, (char **)&s, file);
-  if (succ)
-  {
-    *value = strtol(s, NULL, 10);
-    delete[] s;
-    return TRUE;
-  }
-  else return FALSE;
+    wxChar *s = NULL;
+    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
+    if (succ)
+    {
+        *value = wxStrtol(s, NULL, 10);
+        delete[] s;
+        return TRUE;
+    }
+    else return FALSE;

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

-  char *s = NULL;
-  bool succ = wxGetResource(section, entry, (char **)&s, file);
-  if (succ)
-  {
-    *value = (int)strtol(s, NULL, 10);
-    delete[] s;
-    return TRUE;
-  }
-  else return FALSE;
+    wxChar *s = NULL;
+    bool succ = wxGetResource(section, entry, (wxChar **)&s, file);
+    if (succ)
+    {
+        *value = (int)wxStrtol(s, NULL, 10);
+        delete[] s;
+        return TRUE;
+    }
+    else return FALSE;

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

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

 
 

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

 
 

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

 {
 {

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

 }
 
 }
 

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

 {
 {

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

 }
 
 }
 

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

 {
 {

-  wxString& strDir = *pstr;
-
-  #if defined(__UNIX__) && !defined(__TWIN32__)
-    const char *szHome = getenv("HOME");
-    if ( szHome == NULL ) {
-      // we're homeless...
-      wxLogWarning(_("can't find user's HOME, using current directory."));
-      strDir = ".";
-    }
-    else
-       strDir = szHome;
-
-    // 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);
+    wxCHECK_RET( gs_wxBusyCursorCount > 0,
+                 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );

 
 

-  #endif  // UNIX/Win
+    if ( --gs_wxBusyCursorCount == 0 )
+    {
+        ::SetCursor(gs_wxBusyCursorOld);

 
 

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

 }
 
 }
 

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

 {
 {

-  char *home;
-  wxString user1(user);
-
-  if (user1 != "") {
-    char tmp[64];
-    if (wxGetUserId(tmp, sizeof(tmp)/sizeof(char))) {
-      // Guests belong in the temp dir
-      if (Stricmp(tmp, "annonymous") == 0) {
-        if ((home = getenv("TMP")) != NULL ||
-            (home = getenv("TMPDIR")) != NULL ||
-            (home = getenv("TEMP")) != NULL)
-            return *home ? home : "\\";
-      }
-      if (Stricmp(tmp, WXSTRINGCAST user1) == 0)
-        user1 = "";
-    }
-  }
-  if (user1 == "")
-    if ((home = getenv("HOME")) != NULL)
-    {
-      strcpy(wxBuffer, home);
-      Unix2DosFilename(wxBuffer);
-      return wxBuffer;
-    }
-  return NULL; // No home known!
+  return (gs_wxBusyCursorCount > 0);

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

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

     MSG msg;
     MSG msg;

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

     }
     }

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

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

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

 {
 {

-  char *s = NULL;
-#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;
+
+    wxChar *theText = (wxChar *)::LockResource(hData);
+    if ( !theText )
+        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;
+    // 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;

 
 

-  s = copystring(theText);
+    // wxChar *s = copystring(theText);

 
 

-  // Obsolete in WIN32
+    // Obsolete in WIN32

 #ifndef __WIN32__
 #ifndef __WIN32__

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

 #endif
 
 #endif
 

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

 
 

-  return s;
+    return s;

 }
 }

-#endif

 
 

+// ----------------------------------------------------------------------------
+// get display info
+// ----------------------------------------------------------------------------
+
+// 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
 };
 
 // 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;
+    // 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;

 }
 
 // Returns depth of screen
 }
 
 // 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)
 {
 }
 
 // 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);
+    ScreenHDC dc;
+
+    if ( width ) *width = GetDeviceCaps(dc, HORZRES);
+    if ( height ) *height = GetDeviceCaps(dc, VERTRES);

 }
 
 }
 

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

 
 

-  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)
+{
+#ifdef __WIN16__
+    *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
+// ---------------------------------------------------------------------------
+

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


@@ -779,6 +1269,98 @@ wxString WXDLLEXPORT wxGetWindowText(WXHWND hWnd)
     return str;
 }
 
     return str;
 }
 

+wxString WXDLLEXPORT wxGetWindowClass(WXHWND hWnd)
+{
+    wxString str;
+
+    int len = 256; // some starting value
+
+    for ( ;; )
+    {
+        // as we've #undefined GetClassName we must now manually choose the
+        // right function to call
+        int count =
+
+        #ifndef __WIN32__
+            GetClassName
+        #else // Win32
+            #ifdef UNICODE
+                GetClassNameW
+            #else // !Unicode
+                #ifdef __TWIN32__
+                    GetClassName
+                #else // !Twin32
+                    GetClassNameA
+                #endif // Twin32/!Twin32
+            #endif // Unicode/ANSI
+        #endif // Win16/32
+                                    ((HWND)hWnd, str.GetWriteBuf(len), len);
+
+        str.UngetWriteBuf();
+        if ( count == len )
+        {
+            // the class name might have been truncated, retry with larger
+            // buffer
+            len *= 2;
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    return str;
+}
+
+WXWORD WXDLLEXPORT wxGetWindowId(WXHWND hWnd)
+{
+#ifndef __WIN32__
+    return (WXWORD)GetWindowWord((HWND)hWnd, GWW_ID);
+#else // Win32
+    return (WXWORD)GetWindowLong((HWND)hWnd, GWL_ID);
+#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


@@ -936,143 +1518,9 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
     return ((*str == '\0') && (*pattern == '\0'));
 };
 
     return ((*str == '\0') && (*pattern == '\0'));
 };
 

-#endif
-
-#if defined(__WIN95__) && defined(__WXDEBUG__) && wxUSE_DBWIN32
-
-/*
-When I started programming with Visual C++ v4.0, I missed one of my favorite
-tools -- DBWIN.  Finding the code for a simple debug trace utility, DBMON,
-on MSDN was a step in the right direction, but it is a console application
-and thus has limited features and extensibility.  DBWIN32 is my creation
-to solve this problem.
-
-The code is essentially a merging of a stripped down version of the DBWIN code
-from VC 1.5 and DBMON.C with a few 32 bit changes.
-
-As of version 1.2B, DBWIN32 supports both Win95 and NT.  The NT support is
-built into the operating system and works just by running DBWIN32.  The Win95
-team decided not to support this hook, so I have provided code that will do
-this for you.  See the file WIN95.TXT for instructions on installing this.
-
-If you have questions, problems or suggestions about DBWIN32, I welcome your
-feedback and plan to actively maintain the code.
-
-Andrew Tucker
-ast@halcyon.com
-
-To download dbwin32, see e.g.:
-
-http://ftp.digital.com/pub/micro/NT/WinSite/programr/dbwin32.zip
-*/
-
-#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);
+#endif // 0

 
 

-    /* 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;
 
 // maximum mumber of lines the output console should have
 static const WORD MAX_CONSOLE_LINES = 500;