Rework the wxCusor ctor taking wx stock number to provide as many cursors as

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

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

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

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


@@ -31,24 +31,30 @@
     #include "wx/log.h"
 #endif  //WX_PRECOMP
 
     #include "wx/log.h"
 #endif  //WX_PRECOMP
 

+#include "wx/msw/registry.h"

 #include "wx/apptrait.h"
 #include "wx/dynlib.h"
 #include "wx/dynload.h"
 #include "wx/apptrait.h"
 #include "wx/dynlib.h"
 #include "wx/dynload.h"

+#include "wx/scopeguard.h"

 
 #include "wx/confbase.h"        // for wxExpandEnvVars()
 
 #include "wx/msw/private.h"     // includes <windows.h>
 
 #include "wx/confbase.h"        // for wxExpandEnvVars()
 
 #include "wx/msw/private.h"     // includes <windows.h>

-#include "wx/msw/missing.h"     // CHARSET_HANGUL
+#include "wx/msw/missing.h"     // for CHARSET_HANGUL

 
 

-#if defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) \
-    || defined(__CYGWIN32__)
+#if defined(__CYGWIN__)
+    //CYGWIN gives annoying warning about runtime stuff if we don't do this
+#   define USE_SYS_TYPES_FD_SET
+#   include <sys/types.h>
+#endif
+
+// Doesn't work with Cygwin at present
+#if wxUSE_SOCKETS && (defined(__GNUWIN32_OLD__) || defined(__WXWINCE__) || defined(__CYGWIN32__))

     // apparently we need to include winsock.h to get WSADATA and other stuff
     // used in wxGetFullHostName() with the old mingw32 versions
     #include <winsock.h>
 #endif
 
     // apparently we need to include winsock.h to get WSADATA and other stuff
     // used in wxGetFullHostName() with the old mingw32 versions
     #include <winsock.h>
 #endif
 

-#include "wx/timer.h"
-

 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     #include <direct.h>
 
 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     #include <direct.h>
 


@@ -103,8 +109,13 @@
 // ----------------------------------------------------------------------------
 
 // In the WIN.INI file
 // ----------------------------------------------------------------------------
 
 // In the WIN.INI file

+#if (!defined(USE_NET_API) && !defined(__WXWINCE__)) || defined(__WXMICROWIN__)

 static const wxChar WX_SECTION[] = wxT("wxWindows");
 static const wxChar WX_SECTION[] = wxT("wxWindows");

+#endif
+
+#if (!defined(USE_NET_API) && !defined(__WXWINCE__))

 static const wxChar eUSERNAME[]  = wxT("UserName");
 static const wxChar eUSERNAME[]  = wxT("UserName");

+#endif

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -115,12 +126,11 @@ static const wxChar eUSERNAME[]  = wxT("UserName");
 // ----------------------------------------------------------------------------
 
 // Get hostname only (without domain name)
 // ----------------------------------------------------------------------------
 
 // Get hostname only (without domain name)

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

 {
 #if defined(__WXWINCE__)
     // TODO-CE
 {
 #if defined(__WXWINCE__)
     // TODO-CE

-    wxUnusedVar(buf);
-    wxUnusedVar(maxSize);

     return false;
 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
     DWORD nSize = maxSize;
     return false;
 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
     DWORD nSize = maxSize;


@@ -148,7 +158,7 @@ bool wxGetHostName(wxChar *buf, int maxSize)
 // get full hostname (with domain name if possible)
 bool wxGetFullHostName(wxChar *buf, int maxSize)
 {
 // get full hostname (with domain name if possible)
 bool wxGetFullHostName(wxChar *buf, int maxSize)
 {

-#if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER
+#if !defined( __WXMICROWIN__) && wxUSE_DYNAMIC_LOADER && wxUSE_SOCKETS

     // TODO should use GetComputerNameEx() when available
 
     // we don't want to always link with Winsock DLL as we might not use it at
     // TODO should use GetComputerNameEx() when available
 
     // we don't want to always link with Winsock DLL as we might not use it at


@@ -230,12 +240,11 @@ bool wxGetFullHostName(wxChar *buf, int maxSize)
 }
 
 // Get user ID e.g. jacs
 }
 
 // Get user ID e.g. jacs

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

 {
 #if defined(__WXWINCE__)
     // TODO-CE
 {
 #if defined(__WXWINCE__)
     // TODO-CE

-    wxUnusedVar(buf);
-    wxUnusedVar(maxSize);

     return false;
 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
     DWORD nSize = maxSize;
     return false;
 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
     DWORD nSize = maxSize;


@@ -257,8 +266,8 @@ bool wxGetUserId(wxChar *buf, int maxSize)
 
     // Can't assume we have NIS (PC-NFS) or some other ID daemon
     // So we ...
 
     // 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 )
+    if ( (user = wxGetenv(wxT("USER"))) == NULL &&
+         (user = wxGetenv(wxT("LOGNAME"))) == NULL )

     {
         // Use wxWidgets configuration data (comming soon)
         GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);
     {
         // Use wxWidgets configuration data (comming soon)
         GetProfileString(WX_SECTION, eUSERID, default_id, buf, maxSize - 1);


@@ -275,11 +284,19 @@ bool wxGetUserId(wxChar *buf, int maxSize)
 // Get user name e.g. Julian Smart
 bool wxGetUserName(wxChar *buf, int maxSize)
 {
 // Get user name e.g. Julian Smart
 bool wxGetUserName(wxChar *buf, int maxSize)
 {

+    wxCHECK_MSG( buf && ( maxSize > 0 ), false,
+                    _T("empty buffer in wxGetUserName") );

 #if defined(__WXWINCE__)
 #if defined(__WXWINCE__)

-    // TODO-CE
-    wxUnusedVar(buf);
-    wxUnusedVar(maxSize);
-    return false;
+    wxLogNull noLog;
+    wxRegKey key(wxRegKey::HKCU, wxT("ControlPanel\\Owner"));
+    if(!key.Open(wxRegKey::Read))
+        return false;
+    wxString name;
+    if(!key.QueryValue(wxT("Owner"),name))
+        return false;
+    wxStrncpy(buf, name.c_str(), maxSize-1);
+    buf[maxSize-1] = _T('\0');
+    return true;

 #elif defined(USE_NET_API)
     CHAR szUserName[256];
     if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )
 #elif defined(USE_NET_API)
     CHAR szUserName[256];
     if ( !wxGetUserId(szUserName, WXSIZEOF(szUserName)) )


@@ -369,7 +386,7 @@ const wxChar* wxGetHomeDir(wxString *pstr)
     wxString& strDir = *pstr;
 
     // first branch is for Cygwin
     wxString& strDir = *pstr;
 
     // first branch is for Cygwin

-#if defined(__UNIX__)
+#if defined(__UNIX__) && !defined(__WINE__)

     const wxChar *szHome = wxGetenv("HOME");
     if ( szHome == NULL ) {
       // we're homeless...
     const wxChar *szHome = wxGetenv("HOME");
     if ( szHome == NULL ) {
       // we're homeless...


@@ -390,7 +407,7 @@ const wxChar* wxGetHomeDir(wxString *pstr)
         strDir = windowsPath;
     #endif
 #elif defined(__WXWINCE__)
         strDir = windowsPath;
     #endif
 #elif defined(__WXWINCE__)

-      // Nothing
+    strDir = wxT("\\");

 #else
     strDir.clear();
 
 #else
     strDir.clear();
 


@@ -460,23 +477,12 @@ wxChar *wxGetUserHome(const wxString& WXUNUSED(user))
     return (wxChar *)wxGetHomeDir(&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));
-#endif // Win32/__WXMICROWIN__
-}
-
-bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
+bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
+                    wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))

 {
 #ifdef __WXWINCE__
     // TODO-CE
 {
 #ifdef __WXWINCE__
     // TODO-CE

-    wxUnusedVar(path);
-    wxUnusedVar(pTotal);
-    wxUnusedVar(pFree);

     return false;
 #else
     if ( path.empty() )
     return false;
 #else
     if ( path.empty() )


@@ -508,7 +514,7 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
         ULARGE_INTEGER bytesFree, bytesTotal;
 
         // may pass the path as is, GetDiskFreeSpaceEx() is smart enough
         ULARGE_INTEGER bytesFree, bytesTotal;
 
         // may pass the path as is, GetDiskFreeSpaceEx() is smart enough

-        if ( !pGetDiskFreeSpaceEx(path,
+        if ( !pGetDiskFreeSpaceEx(path.fn_str(),

                                   &bytesFree,
                                   &bytesTotal,
                                   NULL) )
                                   &bytesFree,
                                   &bytesTotal,
                                   NULL) )


@@ -528,12 +534,20 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 #endif
         if ( pTotal )
         {
 #endif
         if ( pTotal )
         {

-            *pTotal = wxLongLong(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
+#if wxUSE_LONGLONG
+            *pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
+#else
+            *pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
+#endif

         }
 
         if ( pFree )
         {
         }
 
         if ( pFree )
         {

+#if wxUSE_LONGLONG

             *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
             *pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);

+#else
+            *pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
+#endif

         }
     }
     else
         }
     }
     else


@@ -550,7 +564,7 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 
         // FIXME: this is wrong, we should extract the root drive from path
         //        instead, but this is the job for wxFileName...
 
         // FIXME: this is wrong, we should extract the root drive from path
         //        instead, but this is the job for wxFileName...

-        if ( !::GetDiskFreeSpace(path,
+        if ( !::GetDiskFreeSpace(path.fn_str(),

                                  &lSectorsPerCluster,
                                  &lBytesPerSector,
                                  &lNumberOfFreeClusters,
                                  &lSectorsPerCluster,
                                  &lBytesPerSector,
                                  &lNumberOfFreeClusters,


@@ -561,7 +575,7 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
             return false;
         }
 
             return false;
         }
 

-        wxLongLong lBytesPerCluster = lSectorsPerCluster;
+        wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;

         lBytesPerCluster *= lBytesPerSector;
 
         if ( pTotal )
         lBytesPerCluster *= lBytesPerSector;
 
         if ( pTotal )


@@ -586,16 +600,15 @@ bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
 // env vars
 // ----------------------------------------------------------------------------
 
 // env vars
 // ----------------------------------------------------------------------------
 

-bool wxGetEnv(const wxString& var, wxString *value)
+bool wxGetEnv(const wxString& WXUNUSED_IN_WINCE(var),
+              wxString *WXUNUSED_IN_WINCE(value))

 {
 #ifdef __WXWINCE__
     // no environment variables under CE
 {
 #ifdef __WXWINCE__
     // no environment variables under CE

-    wxUnusedVar(var);
-    wxUnusedVar(value);

     return false;
 #else // Win32
     // first get the size of the buffer
     return false;
 #else // Win32
     // first get the size of the buffer

-    DWORD dwRet = ::GetEnvironmentVariable(var, NULL, 0);
+    DWORD dwRet = ::GetEnvironmentVariable(var.wx_str(), NULL, 0);

     if ( !dwRet )
     {
         // this means that there is no such variable
     if ( !dwRet )
     {
         // this means that there is no such variable


@@ -604,7 +617,8 @@ bool wxGetEnv(const wxString& var, wxString *value)
 
     if ( value )
     {
 
     if ( value )
     {

-        (void)::GetEnvironmentVariable(var, wxStringBuffer(*value, dwRet),
+        (void)::GetEnvironmentVariable(var.wx_str(),
+                                       wxStringBuffer(*value, dwRet),

                                        dwRet);
     }
 
                                        dwRet);
     }
 


@@ -612,12 +626,16 @@ bool wxGetEnv(const wxString& var, wxString *value)
 #endif // WinCE/32
 }
 
 #endif // WinCE/32
 }
 

-bool wxSetEnv(const wxString& var, const wxChar *value)
+bool wxDoSetEnv(const wxString& WXUNUSED_IN_WINCE(var),
+                const wxChar *WXUNUSED_IN_WINCE(value))

 {
     // some compilers have putenv() or _putenv() or _wputenv() but it's better
     // to always use Win32 function directly instead of dealing with them
 {
     // 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__) && !defined(__WXWINCE__)
-    if ( !::SetEnvironmentVariable(var, value) )
+#ifdef __WXWINCE__
+    // no environment variables under CE
+    return false;
+#else
+    if ( !::SetEnvironmentVariable(var.wx_str(), value) )

     {
         wxLogLastError(_T("SetEnvironmentVariable"));
 
     {
         wxLogLastError(_T("SetEnvironmentVariable"));
 


@@ -625,14 +643,19 @@ bool wxSetEnv(const wxString& var, const wxChar *value)
     }
 
     return true;
     }
 
     return true;

-#else // no way to set env vars
-    // no environment variables under CE
-    wxUnusedVar(var);
-    wxUnusedVar(value);
-    return false;

 #endif
 }
 
 #endif
 }
 

+bool wxSetEnv(const wxString& variable, const wxString& value)
+{
+    return wxDoSetEnv(variable, value.wx_str());
+}
+
+bool wxUnsetEnv(const wxString& variable)
+{
+    return wxDoSetEnv(variable, NULL);
+}
+

 // ----------------------------------------------------------------------------
 // process management
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // process management
 // ----------------------------------------------------------------------------


@@ -689,19 +712,19 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
     {
         if ( krc )
         {
     {
         if ( krc )
         {

-            if ( ::GetLastError() == ERROR_ACCESS_DENIED )
-            {
-                *krc = wxKILL_ACCESS_DENIED;
-            }
-            else
-            {
-                *krc = wxKILL_NO_PROCESS;
-            }
+            // recognize wxKILL_ACCESS_DENIED as special because this doesn't
+            // mean that the process doesn't exist and this is important for
+            // wxProcess::Exists()
+            *krc = ::GetLastError() == ERROR_ACCESS_DENIED
+                        ? wxKILL_ACCESS_DENIED
+                        : wxKILL_NO_PROCESS;

         }
 
         return -1;
     }
 
         }
 
         return -1;
     }
 

+    wxON_BLOCK_EXIT1(::CloseHandle, hProcess);
+

     bool ok = true;
     switch ( sig )
     {
     bool ok = true;
     switch ( sig )
     {


@@ -724,7 +747,9 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
 
         case wxSIGNONE:
             // do nothing, we just want to test for process existence
 
         case wxSIGNONE:
             // do nothing, we just want to test for process existence

-            break;
+            if ( krc )
+                *krc = wxKILL_OK;
+            return 0;

 
         default:
             // any other signal means "terminate"
 
         default:
             // any other signal means "terminate"


@@ -733,7 +758,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
                 params.pid = (DWORD)pid;
 
                 // EnumWindows() has nice semantics: it returns 0 if it found
                 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
+                // something or if an error occurred and non zero if it

                 // enumerated all the window
                 if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
                 {
                 // enumerated all the window
                 if ( !::EnumWindows(wxEnumFindByPidProc, (LPARAM)&params) )
                 {


@@ -742,7 +767,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
                     {
                         // tell the app to close
                         //
                     {
                         // tell the app to close
                         //

-                        // NB: this is the harshest way, the app won't have
+                        // NB: this is the harshest way, the app won't have an

                         //     opportunity to save any files, for example, but
                         //     this is probably what we want here. If not we
                         //     can also use SendMesageTimeout(WM_CLOSE)
                         //     opportunity to save any files, for example, but
                         //     this is probably what we want here. If not we
                         //     can also use SendMesageTimeout(WM_CLOSE)


@@ -761,9 +786,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
                 else // no windows for this PID
                 {
                     if ( krc )
                 else // no windows for this PID
                 {
                     if ( krc )

-                    {

                         *krc = wxKILL_ERROR;
                         *krc = wxKILL_ERROR;

-                    }

 
                     ok = false;
                 }
 
                     ok = false;
                 }


@@ -771,8 +794,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
     }
 
     // the return code
     }
 
     // the return code

-    DWORD rc;
-
+    DWORD rc wxDUMMY_INITIALIZE(0);

     if ( ok )
     {
         // as we wait for a short time, we can use just WaitForSingleObject()
     if ( ok )
     {
         // as we wait for a short time, we can use just WaitForSingleObject()


@@ -797,45 +819,30 @@ int wxKill(long pid, wxSignal sig, wxKillError *krc, int flags)
 
             case WAIT_TIMEOUT:
                 if ( krc )
 
             case WAIT_TIMEOUT:
                 if ( krc )

-                {

                     *krc = wxKILL_ERROR;
                     *krc = wxKILL_ERROR;

-                }

 
                 rc = STILL_ACTIVE;
                 break;
         }
     }
 
                 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
 
     // the return code is the same as from Unix kill(): 0 if killed
     // successfully or -1 on error

-    //
-    // be careful to interpret rc correctly: for wxSIGNONE we return success if
-    // the process exists, for all the other sig values -- if it doesn't
-    if ( ok &&
-            ((sig == wxSIGNONE) == (rc == STILL_ACTIVE)) )
-    {
-        if ( krc )
-        {
-            *krc = wxKILL_OK;
-        }
+    if ( !ok || rc == STILL_ACTIVE )
+        return -1;

 
 

-        return 0;
-    }
+    if ( krc )
+        *krc = wxKILL_OK;

 
 

-    // error
-    return -1;
+    return 0;

 }
 
 }
 

-HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
-BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
-BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
+typedef HANDLE (WINAPI *CreateToolhelp32Snapshot_t)(DWORD,DWORD);
+typedef BOOL (WINAPI *Process32_t)(HANDLE,LPPROCESSENTRY32);
+
+CreateToolhelp32Snapshot_t lpfCreateToolhelp32Snapshot;
+Process32_t lpfProcess32First, lpfProcess32Next;

 
 static void InitToolHelp32()
 {
 
 static void InitToolHelp32()
 {


@@ -850,9 +857,9 @@ static void InitToolHelp32()
     lpfProcess32First = NULL;
     lpfProcess32Next = NULL;
 
     lpfProcess32First = NULL;
     lpfProcess32Next = NULL;
 

-    HINSTANCE hInstLib = LoadLibrary( wxT("Kernel32.DLL") ) ;
-    if( hInstLib == NULL )
-        return ;
+#if wxUSE_DYNLIB_CLASS
+
+    wxDynamicLibrary dllKernel(_T("kernel32.dll"), wxDL_VERBATIM);

 
     // Get procedure addresses.
     // We are linking to these functions of Kernel32
 
     // Get procedure addresses.
     // We are linking to these functions of Kernel32


@@ -860,37 +867,16 @@ static void InitToolHelp32()
     // this code would fail to load under Windows NT,
     // which does not have the Toolhelp32
     // functions in the Kernel 32.
     // this code would fail to load under Windows NT,
     // which does not have the Toolhelp32
     // functions in the Kernel 32.

-    lpfCreateToolhelp32Snapshot=
-        (HANDLE(WINAPI *)(DWORD,DWORD))
-        GetProcAddress( hInstLib,
-#ifdef __WXWINCE__
-        wxT("CreateToolhelp32Snapshot")
-#else
-        "CreateToolhelp32Snapshot"
-#endif
-        ) ;
+    lpfCreateToolhelp32Snapshot =
+        (CreateToolhelp32Snapshot_t)dllKernel.RawGetSymbol(_T("CreateToolhelp32Snapshot"));

 
 

-    lpfProcess32First=
-        (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
-        GetProcAddress( hInstLib,
-#ifdef __WXWINCE__
-        wxT("Process32First")
-#else
-        "Process32First"
-#endif
-        ) ;
+    lpfProcess32First =
+        (Process32_t)dllKernel.RawGetSymbol(_T("Process32First"));

 
 

-    lpfProcess32Next=
-        (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
-        GetProcAddress( hInstLib,
-#ifdef __WXWINCE__
-        wxT("Process32Next")
-#else
-        "Process32Next"
-#endif
-        ) ;
+    lpfProcess32Next =
+        (Process32_t)dllKernel.RawGetSymbol(_T("Process32Next"));

 
 

-    FreeLibrary( hInstLib ) ;
+#endif // wxUSE_DYNLIB_CLASS

 }
 
 // By John Skiff
 }
 
 // By John Skiff


@@ -967,16 +953,15 @@ bool wxShell(const wxString& command)
 }
 
 // Shutdown or reboot the PC
 }
 
 // Shutdown or reboot the PC

-bool wxShutdown(wxShutdownFlags wFlags)
+bool wxShutdown(wxShutdownFlags WXUNUSED_IN_WINCE(wFlags))

 {
 #ifdef __WXWINCE__
     // TODO-CE
 {
 #ifdef __WXWINCE__
     // TODO-CE

-    wxUnusedVar(wFlags);

     return false;
 #elif defined(__WIN32__)
     bool bOK = true;
 
     return false;
 #elif defined(__WIN32__)
     bool bOK = true;
 

-    if ( wxGetOsVersion(NULL, NULL) == wxWINDOWS_NT ) // if is NT or 2K
+    if ( wxGetOsVersion(NULL, NULL) == wxOS_WINDOWS_NT ) // if is NT or 2K

     {
         // Get a token for this process.
         HANDLE hToken;
     {
         // Get a token for this process.
         HANDLE hToken;


@@ -1028,18 +1013,6 @@ bool wxShutdown(wxShutdownFlags wFlags)
 #endif // Win32/16
 }
 
 #endif // Win32/16
 }
 

-wxPowerType wxGetPowerType()
-{
-    // TODO
-    return wxPOWER_UNKNOWN;
-}
-
-wxBatteryState wxGetBatteryState()
-{
-    // TODO
-    return wxBATTERY_UNKNOWN_STATE;
-}
-

 // ----------------------------------------------------------------------------
 // misc
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // misc
 // ----------------------------------------------------------------------------


@@ -1049,9 +1022,9 @@ wxMemorySize wxGetFreeMemory()
 {
 #if defined(__WIN64__)
     MEMORYSTATUSEX memStatex;
 {
 #if defined(__WIN64__)
     MEMORYSTATUSEX memStatex;

-    statex.dwLength = sizeof (statex);
-    ::GlobalMemoryStatusEx (&statex);
-    return (wxMemorySize)memStatus.ullAvailPhys;
+    memStatex.dwLength = sizeof (memStatex);
+    ::GlobalMemoryStatusEx (&memStatex);
+    return (wxMemorySize)memStatex.ullAvailPhys;

 #else /* if defined(__WIN32__) */
     MEMORYSTATUS memStatus;
     memStatus.dwLength = sizeof(MEMORYSTATUS);
 #else /* if defined(__WIN32__) */
     MEMORYSTATUS memStatus;
     memStatus.dwLength = sizeof(MEMORYSTATUS);


@@ -1073,6 +1046,7 @@ void wxBell()
 
 bool wxIsDebuggerRunning()
 {
 
 bool wxIsDebuggerRunning()
 {

+#if wxUSE_DYNLIB_CLASS

     // IsDebuggerPresent() is not available under Win95, so load it dynamically
     wxDynamicLibrary dll(_T("kernel32.dll"), wxDL_VERBATIM);
 
     // IsDebuggerPresent() is not available under Win95, so load it dynamically
     wxDynamicLibrary dll(_T("kernel32.dll"), wxDL_VERBATIM);
 


@@ -1084,6 +1058,9 @@ bool wxIsDebuggerRunning()
     }
 
     return (*(IsDebuggerPresent_t)dll.GetSymbol(_T("IsDebuggerPresent")))() != 0;
     }
 
     return (*(IsDebuggerPresent_t)dll.GetSymbol(_T("IsDebuggerPresent")))() != 0;

+#else
+    return false;
+#endif

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1102,6 +1079,13 @@ wxString wxGetOsDescription()
     {
         switch ( info.dwPlatformId )
         {
     {
         switch ( info.dwPlatformId )
         {

+#ifdef VER_PLATFORM_WIN32_CE
+            case VER_PLATFORM_WIN32_CE:
+                str.Printf(_("Windows CE (%d.%d)"),
+                           info.dwMajorVersion,
+                           info.dwMinorVersion);
+                break;
+#endif

             case VER_PLATFORM_WIN32s:
                 str = _("Win32s on Windows 3.1");
                 break;
             case VER_PLATFORM_WIN32s:
                 str = _("Win32s on Windows 3.1");
                 break;


@@ -1165,7 +1149,7 @@ wxString wxGetOsDescription()
                             break;
                     }
                 }
                             break;
                     }
                 }

-                if ( wxIsEmpty(str) )
+                if ( str.empty() )

                 {
                     str.Printf(_("Windows NT %lu.%lu (build %lu"),
                            info.dwMajorVersion,
                 {
                     str.Printf(_("Windows NT %lu.%lu (build %lu"),
                            info.dwMajorVersion,


@@ -1188,56 +1172,116 @@ wxString wxGetOsDescription()
     return str;
 }
 
     return str;
 }
 

-wxToolkitInfo& wxAppTraits::GetToolkitInfo()
+bool wxIsPlatform64Bit()

 {
 {

-    // cache the version info, it's not going to change
-    //
-    // NB: this is MT-safe, we may use these static vars from different threads
-    //     but as they always have the same value it doesn't matter
-    static int s_ver = -1,
-               s_major = -1,
-               s_minor = -1;
-
-    if ( s_ver == -1 )
+#if defined(_WIN64)
+    return true;  // 64-bit programs run only on Win64
+#else // Win32
+    // 32-bit programs run on both 32-bit and 64-bit Windows so check
+    typedef BOOL (WINAPI *IsWow64Process_t)(HANDLE, BOOL *);
+
+    wxDynamicLibrary dllKernel32(_T("kernel32.dll"));
+    IsWow64Process_t pfnIsWow64Process =
+        (IsWow64Process_t)dllKernel32.RawGetSymbol(_T("IsWow64Process"));
+
+    BOOL wow64 = FALSE;
+    if ( pfnIsWow64Process )

     {
     {

-        OSVERSIONINFO info;
-        wxZeroMemory(info);
+        pfnIsWow64Process(::GetCurrentProcess(), &wow64);
+    }
+    //else: running under a system without Win64 support

 
 

-        s_ver = wxWINDOWS;
-        info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-        if ( ::GetVersionEx(&info) )
-        {
-            s_major = info.dwMajorVersion;
-            s_minor = info.dwMinorVersion;
+    return wow64 != FALSE;
+#endif // Win64/Win32
+}
+
+wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
+{
+    OSVERSIONINFO info;
+    wxZeroMemory(info);
+
+    info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    if ( ::GetVersionEx(&info) )
+    {
+        if (verMaj) *verMaj = info.dwMajorVersion;
+        if (verMin) *verMin = info.dwMinorVersion;
+    }
+
+#if defined( __WXWINCE__ )
+    return wxOS_WINDOWS_CE;
+#elif defined( __WXMICROWIN__ )
+    return wxOS_WINDOWS_MICRO;
+#else
+    switch ( info.dwPlatformId )
+    {
+    case VER_PLATFORM_WIN32_NT:
+        return wxOS_WINDOWS_NT;
+
+    case VER_PLATFORM_WIN32_WINDOWS:
+        return wxOS_WINDOWS_9X;
+    }
+
+    return wxOS_UNKNOWN;
+#endif
+}

 
 

-            switch ( info.dwPlatformId )
+wxWinVersion wxGetWinVersion()
+{
+    int verMaj,
+        verMin;
+    switch ( wxGetOsVersion(&verMaj, &verMin) )
+    {
+        case wxOS_WINDOWS_9X:
+            if ( verMaj == 4 )

             {
             {

-                case VER_PLATFORM_WIN32s:
-                    s_ver = wxWIN32S;
-                    break;
+                switch ( verMin )
+                {
+                    case 0:
+                        return wxWinVersion_95;

 
 

-                case VER_PLATFORM_WIN32_WINDOWS:
-                    s_ver = wxWIN95;
-                    break;
+                    case 10:
+                        return wxWinVersion_98;

 
 

-                case VER_PLATFORM_WIN32_NT:
-                    s_ver = wxWINDOWS_NT;
-                    break;
-#ifdef __WXWINCE__
-                case VER_PLATFORM_WIN32_CE:
-                    s_ver = wxWINDOWS_CE;
+                    case 90:
+                        return wxWinVersion_ME;
+                }
+            }
+            break;
+
+        case wxOS_WINDOWS_NT:
+            switch ( verMaj )
+            {
+                case 3:
+                    return wxWinVersion_NT3;
+
+                case 4:
+                    return wxWinVersion_NT4;
+
+                case 5:
+                    switch ( verMin )
+                    {
+                        case 0:
+                            return wxWinVersion_2000;
+
+                        case 1:
+                            return wxWinVersion_XP;
+
+                        case 2:
+                            return wxWinVersion_2003;
+                    }

                     break;
                     break;

-#endif
+
+                case 6:
+                    return wxWinVersion_NT6;

             }
             }

-        }
+            break;
+
+        default:
+            // Do nothing just to silence GCC warning
+            break;

     }
 
     }
 

-    static wxToolkitInfo info;
-    info.versionMajor = s_major;
-    info.versionMinor = s_minor;
-    info.os = s_ver;
-    info.name = _T("wxBase");
-    return info;
+    return wxWinVersion_Unknown;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1285,8 +1329,10 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCharset(wxFontEncoding encoding)
         case wxFONTENCODING_CP936:
             return GB2312_CHARSET;
 
         case wxFONTENCODING_CP936:
             return GB2312_CHARSET;
 

+#ifndef __WXWINCE__

         case wxFONTENCODING_CP949:
             return HANGUL_CHARSET;
         case wxFONTENCODING_CP949:
             return HANGUL_CHARSET;

+#endif

 
         case wxFONTENCODING_CP950:
             return CHINESEBIG5_CHARSET;
 
         case wxFONTENCODING_CP950:
             return CHINESEBIG5_CHARSET;


@@ -1354,10 +1400,10 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
         case wxFONTENCODING_ISO8859_8:      ret = 28598; break;
         case wxFONTENCODING_ISO8859_9:      ret = 28599; break;
         case wxFONTENCODING_ISO8859_10:     ret = 28600; break;
         case wxFONTENCODING_ISO8859_8:      ret = 28598; break;
         case wxFONTENCODING_ISO8859_9:      ret = 28599; break;
         case wxFONTENCODING_ISO8859_10:     ret = 28600; break;

-        case wxFONTENCODING_ISO8859_11:     ret = 28601; break;
+        case wxFONTENCODING_ISO8859_11:     ret = 874; break;

         // case wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
         case wxFONTENCODING_ISO8859_13:     ret = 28603; break;
         // case wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
         case wxFONTENCODING_ISO8859_13:     ret = 28603; break;

-        case wxFONTENCODING_ISO8859_14:     ret = 28604; break;
+        // case wxFONTENCODING_ISO8859_14:     ret = 28604; break; // no correspondence on Windows

         case wxFONTENCODING_ISO8859_15:     ret = 28605; break;
         case wxFONTENCODING_KOI8:           ret = 20866; break;
         case wxFONTENCODING_KOI8_U:         ret = 21866; break;
         case wxFONTENCODING_ISO8859_15:     ret = 28605; break;
         case wxFONTENCODING_KOI8:           ret = 20866; break;
         case wxFONTENCODING_KOI8_U:         ret = 21866; break;


@@ -1379,7 +1425,7 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
         case wxFONTENCODING_CP1255:         ret = 1255; break;
         case wxFONTENCODING_CP1256:         ret = 1256; break;
         case wxFONTENCODING_CP1257:         ret = 1257; break;
         case wxFONTENCODING_CP1255:         ret = 1255; break;
         case wxFONTENCODING_CP1256:         ret = 1256; break;
         case wxFONTENCODING_CP1257:         ret = 1257; break;

-        case wxFONTENCODING_EUC_JP:         ret = 51932; break;
+        case wxFONTENCODING_EUC_JP:         ret = 20932; break;

         case wxFONTENCODING_MACROMAN:       ret = 10000; break;
         case wxFONTENCODING_MACJAPANESE:    ret = 10001; break;
         case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break;
         case wxFONTENCODING_MACROMAN:       ret = 10000; break;
         case wxFONTENCODING_MACJAPANESE:    ret = 10001; break;
         case wxFONTENCODING_MACCHINESETRAD: ret = 10002; break;


@@ -1409,13 +1455,13 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding)
     return (long) ret;
 }
 
     return (long) ret;
 }
 

-extern long wxCharsetToCodepage(const wxChar *name)
+extern long wxCharsetToCodepage(const char *name)

 {
     // first get the font encoding for this charset
     if ( !name )
         return -1;
 
 {
     // first get the font encoding for this charset
     if ( !name )
         return -1;
 

-    wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(name, false);
+    wxFontEncoding enc = wxFontMapperBase::Get()->CharsetToEncoding(name, false);

     if ( enc == wxFONTENCODING_SYSTEM )
         return -1;
 
     if ( enc == wxFONTENCODING_SYSTEM )
         return -1;
 


@@ -1428,7 +1474,7 @@ extern long wxCharsetToCodepage(const wxChar *name)
 #include "wx/msw/registry.h"
 
 // this should work if Internet Exploiter is installed
 #include "wx/msw/registry.h"
 
 // this should work if Internet Exploiter is installed

-extern long wxCharsetToCodepage(const wxChar *name)
+extern long wxCharsetToCodepage(const char *name)

 {
     if (!name)
         return GetACP();
 {
     if (!name)
         return GetACP();


@@ -1475,7 +1521,7 @@ extern long wxCharsetToCodepage(const wxChar *name)
   Windows class unregistration).
 
   pclassname is a pointer to a caller stored classname, which must initially be
   Windows class unregistration).
 
   pclassname is a pointer to a caller stored classname, which must initially be

-  NULL. classname is the desired wndclass classname. If function succesfully
+  NULL. classname is the desired wndclass classname. If function successfully

   registers the class, pclassname will be set to classname.
  */
 extern "C" WXDLLIMPEXP_BASE HWND
   registers the class, pclassname will be set to classname.
  */
 extern "C" WXDLLIMPEXP_BASE HWND


@@ -1524,4 +1570,3 @@ wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc)
 
     return hwnd;
 }
 
     return hwnd;
 }

-