Compilation fix for !wxUSE_OWNER_DRAWN.

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

diff --git a/src/msw/dlmsw.cpp b/src/msw/dlmsw.cpp
index 22f7e40478c61ba948f63049a070f59659baf376..5957086cb45571460debd3803ada8b6e9320f825 100644 (file)
--- a/src/msw/dlmsw.cpp
+++ b/src/msw/dlmsw.cpp
@@ -1,10 +1,9 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

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

 // Purpose:     Win32-specific part of wxDynamicLibrary and related classes
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     2005-01-10 (partly extracted from common/dynlib.cpp)
 // Purpose:     Win32-specific part of wxDynamicLibrary and related classes
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     2005-01-10 (partly extracted from common/dynlib.cpp)

-// RCS-ID:      $Id$

 // Copyright:   (c) 1998-2005 Vadim Zeitlin <vadim@wxwindows.org>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) 1998-2005 Vadim Zeitlin <vadim@wxwindows.org>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -27,8 +26,7 @@
 
 #include "wx/msw/private.h"
 #include "wx/msw/debughlp.h"
 
 #include "wx/msw/private.h"
 #include "wx/msw/debughlp.h"

-
-const wxString wxDynamicLibrary::ms_dllext(_T(".dll"));
+#include "wx/filename.h"

 
 // ----------------------------------------------------------------------------
 // private classes
 
 // ----------------------------------------------------------------------------
 // private classes


@@ -65,7 +63,7 @@ private:
     wxDynamicLibrary m_dll;
 
 
     wxDynamicLibrary m_dll;
 
 

-    DECLARE_NO_COPY_CLASS(wxVersionDLL)
+    wxDECLARE_NO_COPY_CLASS(wxVersionDLL);

 };
 
 // class used to create wxDynamicLibraryDetails objects
 };
 
 // class used to create wxDynamicLibraryDetails objects


@@ -79,16 +77,6 @@ public:
         wxVersionDLL *verDLL;
     };
 
         wxVersionDLL *verDLL;
     };
 

-    // the declared type of the first EnumModulesProc() parameter changed in
-    // recent SDK versions and is no PCSTR instead of old PSTR, we know that
-    // it's const in version 11 and non-const in version 8 included with VC8
-    // (and earlier), suppose that it's only changed in version 11
-    #if defined(API_VERSION_NUMBER) && API_VERSION_NUMBER >= 11
-        typedef PCSTR NameStr_t;
-    #else
-        typedef PSTR NameStr_t;
-    #endif
-

     // TODO: fix EnumerateLoadedModules() to use EnumerateLoadedModules64()
     #ifdef __WIN64__
         typedef DWORD64 DWORD_32_64;
     // TODO: fix EnumerateLoadedModules() to use EnumerateLoadedModules64()
     #ifdef __WIN64__
         typedef DWORD64 DWORD_32_64;


@@ -97,56 +85,9 @@ public:
     #endif
 
     static BOOL CALLBACK
     #endif
 
     static BOOL CALLBACK

-    EnumModulesProc(NameStr_t name, DWORD_32_64 base, ULONG size, void *data);
+    EnumModulesProc(PCSTR name, DWORD_32_64 base, ULONG size, void *data);

 };
 
 };
 

-// ----------------------------------------------------------------------------
-// private functions
-// ----------------------------------------------------------------------------
-
-// return the module handle for the given base name
-static
-HMODULE wxGetModuleHandle(const char *name, void *addr)
-{
-    // we want to use GetModuleHandleEx() instead of usual GetModuleHandle()
-    // because the former works correctly for comctl32.dll while the latter
-    // returns NULL when comctl32.dll version 6 is used under XP (note that
-    // GetModuleHandleEx() is only available under XP and later, coincidence?)
-
-    // check if we can use GetModuleHandleEx
-    typedef BOOL (WINAPI *GetModuleHandleEx_t)(DWORD, LPCSTR, HMODULE *);
-
-    static const GetModuleHandleEx_t INVALID_FUNC_PTR = (GetModuleHandleEx_t)-1;
-
-    static GetModuleHandleEx_t s_pfnGetModuleHandleEx = INVALID_FUNC_PTR;
-    if ( s_pfnGetModuleHandleEx == INVALID_FUNC_PTR )
-    {
-        wxDynamicLibrary dll(_T("kernel32.dll"), wxDL_VERBATIM);
-        s_pfnGetModuleHandleEx =
-            (GetModuleHandleEx_t)dll.RawGetSymbol(_T("GetModuleHandleExA"));
-
-        // dll object can be destroyed, kernel32.dll won't be unloaded anyhow
-    }
-
-    // get module handle from its address
-    if ( s_pfnGetModuleHandleEx )
-    {
-        // flags are GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
-        //           GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
-        HMODULE hmod;
-        if ( s_pfnGetModuleHandleEx(6, (char *)addr, &hmod) && hmod )
-            return hmod;
-    }
-
-    // Windows CE only has Unicode API, so even we have an ANSI string here, we
-    // still need to use GetModuleHandleW() there
-#ifdef __WXWINCE__
-    return ::GetModuleHandleW(wxConvLibc.cMB2WC(name).data());
-#else
-    return ::GetModuleHandleA((char *)name);
-#endif
-}
-

 // ============================================================================
 // wxVersionDLL implementation
 // ============================================================================
 // ============================================================================
 // wxVersionDLL implementation
 // ============================================================================


@@ -161,7 +102,7 @@ wxVersionDLL::wxVersionDLL()
     // handle it
     wxLogNull noLog;
 
     // handle it
     wxLogNull noLog;
 

-    if ( m_dll.Load(_T("version.dll"), wxDL_VERBATIM) )
+    if ( m_dll.Load(wxT("version.dll"), wxDL_VERBATIM) )

     {
         // the functions we load have either 'A' or 'W' suffix depending on
         // whether we're in ANSI or Unicode build
     {
         // the functions we load have either 'A' or 'W' suffix depending on
         // whether we're in ANSI or Unicode build


@@ -172,7 +113,7 @@ wxVersionDLL::wxVersionDLL()
         #endif // UNICODE/ANSI
 
         #define LOAD_VER_FUNCTION(name)                                       \
         #endif // UNICODE/ANSI
 
         #define LOAD_VER_FUNCTION(name)                                       \

-            m_pfn ## name = (name ## _t)m_dll.GetSymbol(_T(#name SUFFIX));    \
+            m_pfn ## name = (name ## _t)m_dll.GetSymbol(wxT(#name SUFFIX));    \

         if ( !m_pfn ## name )                                                 \
         {                                                                     \
             m_dll.Unload();                                                   \
         if ( !m_pfn ## name )                                                 \
         {                                                                     \
             m_dll.Unload();                                                   \


@@ -194,7 +135,7 @@ wxString wxVersionDLL::GetFileVersion(const wxString& filename) const
     wxString ver;
     if ( m_dll.IsLoaded() )
     {
     wxString ver;
     if ( m_dll.IsLoaded() )
     {

-        wxChar *pc = wx_const_cast(wxChar *, filename.wx_str());
+        wxChar *pc = const_cast<wxChar *>((const wxChar*) filename.t_str());

 
         DWORD dummy;
         DWORD sizeVerInfo = m_pfnGetFileVersionInfoSize(pc, &dummy);
 
         DWORD dummy;
         DWORD sizeVerInfo = m_pfnGetFileVersionInfoSize(pc, &dummy);


@@ -205,10 +146,13 @@ wxString wxVersionDLL::GetFileVersion(const wxString& filename) const
             {
                 void *pVer;
                 UINT sizeInfo;
             {
                 void *pVer;
                 UINT sizeInfo;

-                if ( m_pfnVerQueryValue(buf.data(), _T("\\"), &pVer, &sizeInfo) )
+                if ( m_pfnVerQueryValue(buf.data(),
+                                        const_cast<wxChar *>(wxT("\\")),
+                                        &pVer,
+                                        &sizeInfo) )

                 {
                     VS_FIXEDFILEINFO *info = (VS_FIXEDFILEINFO *)pVer;
                 {
                     VS_FIXEDFILEINFO *info = (VS_FIXEDFILEINFO *)pVer;

-                    ver.Printf(_T("%d.%d.%d.%d"),
+                    ver.Printf(wxT("%d.%d.%d.%d"),

                                HIWORD(info->dwFileVersionMS),
                                LOWORD(info->dwFileVersionMS),
                                HIWORD(info->dwFileVersionLS),
                                HIWORD(info->dwFileVersionMS),
                                LOWORD(info->dwFileVersionMS),
                                HIWORD(info->dwFileVersionLS),


@@ -228,7 +172,7 @@ wxString wxVersionDLL::GetFileVersion(const wxString& filename) const
 
 /* static */
 BOOL CALLBACK
 
 /* static */
 BOOL CALLBACK

-wxDynamicLibraryDetailsCreator::EnumModulesProc(NameStr_t name,
+wxDynamicLibraryDetailsCreator::EnumModulesProc(PCSTR name,

                                                 DWORD_32_64 base,
                                                 ULONG size,
                                                 void *data)
                                                 DWORD_32_64 base,
                                                 ULONG size,
                                                 void *data)


@@ -238,12 +182,16 @@ wxDynamicLibraryDetailsCreator::EnumModulesProc(NameStr_t name,
     wxDynamicLibraryDetails *details = new wxDynamicLibraryDetails;
 
     // fill in simple properties
     wxDynamicLibraryDetails *details = new wxDynamicLibraryDetails;
 
     // fill in simple properties

-    details->m_name = wxString::FromAscii(name);
+    details->m_name = name;

     details->m_address = wxUIntToPtr(base);
     details->m_length = size;
 
     // to get the version, we first need the full path
     details->m_address = wxUIntToPtr(base);
     details->m_length = size;
 
     // to get the version, we first need the full path

-    HMODULE hmod = wxGetModuleHandle(name, details->m_address);
+    const HMODULE hmod = wxDynamicLibrary::MSWGetModuleHandle
+                         (
+                            details->m_name,
+                            details->m_address
+                         );

     if ( hmod )
     {
         wxString fullname = wxGetFullModuleName(hmod);
     if ( hmod )
     {
         wxString fullname = wxGetFullModuleName(hmod);


@@ -277,11 +225,62 @@ wxDllType wxDynamicLibrary::GetProgramHandle()
 // loading/unloading DLLs
 // ----------------------------------------------------------------------------
 
 // loading/unloading DLLs
 // ----------------------------------------------------------------------------
 

+#ifndef MAX_PATH
+    #define MAX_PATH 260        // from VC++ headers
+#endif
+

 /* static */
 wxDllType
 /* static */
 wxDllType

-wxDynamicLibrary::RawLoad(const wxString& libname, int WXUNUSED(flags))
+wxDynamicLibrary::RawLoad(const wxString& libname, int flags)

 {
 {

-    return ::LoadLibrary(libname.wx_str());
+    if (flags & wxDL_GET_LOADED)
+        return ::GetModuleHandle(libname.t_str());
+
+    // Explicitly look in the same path as where the main wx HINSTANCE module
+    // is located (usually the executable or the DLL that uses wx).  Normally
+    // this is automatically part of the default search path but in some cases
+    // it may not be, such as when the wxPython extension modules need to load
+    // a DLL, but the intperpreter executable is located elsewhere.  Doing
+    // this allows us to always be able to dynamically load a DLL that is
+    // located at the same place as the wx modules.
+    wxString modpath, path;
+    ::GetModuleFileName(wxGetInstance(),
+                        wxStringBuffer(modpath, MAX_PATH+1),
+                        MAX_PATH);
+    
+    wxFileName::SplitPath(modpath, &path, NULL, NULL);
+
+    typedef BOOL (WINAPI *SetDllDirectory_t)(LPCTSTR lpPathName);
+
+    static SetDllDirectory_t s_pfnSetDllDirectory = (SetDllDirectory_t) -1;
+
+    if ( s_pfnSetDllDirectory == (SetDllDirectory_t) -1 )
+    {
+        /*
+        Should wxLoadedDLL ever not be used here (or rather, the
+        wxDL_GET_LOADED flag isn't used), infinite recursion will take
+        place (unless s_pfnSetDllDirectory is set to NULL here right
+        before loading the DLL).
+        */
+        wxLoadedDLL dllKernel("kernel32.dll");
+
+        wxDL_INIT_FUNC_AW(s_pfn, SetDllDirectory, dllKernel);
+    }
+
+    if (s_pfnSetDllDirectory)
+    {
+        s_pfnSetDllDirectory(path.t_str());
+    }
+
+    wxDllType handle = ::LoadLibrary(libname.t_str());
+
+    // reset the search path
+    if (s_pfnSetDllDirectory)
+    {
+        s_pfnSetDllDirectory(NULL);
+    }
+
+    return handle;

 }
 
 /* static */
 }
 
 /* static */


@@ -321,14 +320,20 @@ wxDynamicLibraryDetailsArray wxDynamicLibrary::ListLoaded()
         params.dlls = &dlls;
         params.verDLL = &verDLL;
 
         params.dlls = &dlls;
         params.verDLL = &verDLL;
 

+        // Note that the cast of EnumModulesProc is needed because the type of
+        // PENUMLOADED_MODULES_CALLBACK changed: in old SDK versions its first
+        // argument was non-const PSTR while now it's PCSTR. By explicitly
+        // casting to whatever the currently used headers require we ensure
+        // that the code compilers in any case.

         if ( !wxDbgHelpDLL::EnumerateLoadedModules
                             (
                                 ::GetCurrentProcess(),
         if ( !wxDbgHelpDLL::EnumerateLoadedModules
                             (
                                 ::GetCurrentProcess(),

+                                (PENUMLOADED_MODULES_CALLBACK)

                                 wxDynamicLibraryDetailsCreator::EnumModulesProc,
                                 &params
                             ) )
         {
                                 wxDynamicLibraryDetailsCreator::EnumModulesProc,
                                 &params
                             ) )
         {

-            wxLogLastError(_T("EnumerateLoadedModules"));
+            wxLogLastError(wxT("EnumerateLoadedModules"));

         }
     }
 #endif // wxUSE_DBGHELP
         }
     }
 #endif // wxUSE_DBGHELP


@@ -336,5 +341,41 @@ wxDynamicLibraryDetailsArray wxDynamicLibrary::ListLoaded()
     return dlls;
 }
 
     return dlls;
 }
 

+/* static */
+WXHMODULE wxDynamicLibrary::MSWGetModuleHandle(const wxString& name, void *addr)
+{
+    // we want to use GetModuleHandleEx() instead of usual GetModuleHandle()
+    // because the former works correctly for comctl32.dll while the latter
+    // returns NULL when comctl32.dll version 6 is used under XP (note that
+    // GetModuleHandleEx() is only available under XP and later, coincidence?)
+
+    // check if we can use GetModuleHandleEx
+    typedef BOOL (WINAPI *GetModuleHandleEx_t)(DWORD, LPCTSTR, HMODULE *);
+
+    static const GetModuleHandleEx_t INVALID_FUNC_PTR = (GetModuleHandleEx_t)-1;
+
+    static GetModuleHandleEx_t s_pfnGetModuleHandleEx = INVALID_FUNC_PTR;
+    if ( s_pfnGetModuleHandleEx == INVALID_FUNC_PTR )
+    {
+        wxDynamicLibrary dll(wxT("kernel32.dll"), wxDL_VERBATIM);
+        s_pfnGetModuleHandleEx =
+            (GetModuleHandleEx_t)dll.GetSymbolAorW(wxT("GetModuleHandleEx"));
+
+        // dll object can be destroyed, kernel32.dll won't be unloaded anyhow
+    }
+
+    // get module handle from its address
+    if ( s_pfnGetModuleHandleEx )
+    {
+        // flags are GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT |
+        //           GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
+        HMODULE hmod;
+        if ( s_pfnGetModuleHandleEx(6, (LPCTSTR)addr, &hmod) && hmod )
+            return hmod;
+    }
+
+    return ::GetModuleHandle(name.t_str());
+}
+

 #endif // wxUSE_DYNLIB_CLASS
 
 #endif // wxUSE_DYNLIB_CLASS