diff --git a/include/wx/defs.h b/include/wx/defs.h
index 1f8673a3a7..32ed238ad9 100644
--- a/include/wx/defs.h
+++ b/include/wx/defs.h
@@ -13,7 +13,7 @@
 #define _WX_DEFS_H_
 
 #ifdef __GNUG__
-    #pragma interface "defs.h"
+#pragma interface "defs.h"
 #endif
 
 // ----------------------------------------------------------------------------
@@ -24,15 +24,15 @@
 
 // Make sure the environment is set correctly
 #if defined(__WXMSW__) && defined(__X__)
-    #error "Target can't be both X and Windows"
+#error "Target can't be both X and Windows"
 #elif !defined(__WXMOTIF__) && !defined(__WXMSW__) && !defined(__WXGTK__) && \
       !defined(__WXPM__) && !defined(__WXMAC__) && !defined(__X__) && \
       !defined(__WXMGL__) && wxUSE_GUI
-    #ifdef __UNIX__
-        #error "No Target! You should use wx-config program for compilation flags!"
-    #else // !Unix
-        #error "No Target! You should use supplied makefiles for compilation!"
-    #endif // Unix/!Unix
+#ifdef __UNIX__
+#error "No Target! You should use wx-config program for compilation flags!"
+#else // !Unix
+#error "No Target! You should use supplied makefiles for compilation!"
+#endif // Unix/!Unix
 #endif
 
 // suppress some Visual C++ warnings
@@ -77,11 +77,11 @@
 // possibility to build non GUI apps is new, so don't burden ourselves with
 // compatibility code
 #if !wxUSE_GUI
-    #undef WXWIN_COMPATIBILITY_2
-    #undef WXWIN_COMPATIBILITY_2_2
+#undef WXWIN_COMPATIBILITY_2
+#undef WXWIN_COMPATIBILITY_2_2
 
-    #define WXWIN_COMPATIBILITY_2 0
-    #define WXWIN_COMPATIBILITY_2_2 0
+#define WXWIN_COMPATIBILITY_2 0
+#define WXWIN_COMPATIBILITY_2_2 0
 #endif // !GUI
 
 // ============================================================================
@@ -94,24 +94,30 @@
 
 #if defined(__VISUALC__) && !defined(WIN32)
     // VC1.5 does not have LPTSTR type
-    #define LPTSTR LPSTR
-    #define LPCTSTR LPCSTR
-#endif // VC++ 1.5
+#define LPTSTR  LPSTR
+#define LPCTSTR LPCSTR
+#elif defined(__BORLANDC__) && !defined(__WIN32__)
+#ifndef LPTSTR
+#define LPTSTR  LPSTR
+#endif
+#ifndef LPCTSTR
+#define LPCTSTR LPSTR
+#endif
+#endif
+
 
 /*
    Digital Unix C++ compiler only defines this symbol for .cxx and .hxx files,
    so define it ourselves (newer versions do it for all files, though, and
    don't allow it to be redefined)
  */
-#ifdef __DECCXX
-    #if !defined(__VMS) && !defined(__cplusplus)
-        #define __cplusplus
-    #endif
+#if defined(__DECCXX) && !defined(__VMS) && !defined(__cplusplus)
+#define __cplusplus
 #endif /* __DECCXX */
 
 // Resolves linking problems under HP-UX when compiling with gcc/g++
 #if defined(__HPUX__) && defined(__GNUG__)
-    #define va_list __gnuc_va_list
+#define va_list __gnuc_va_list
 #endif // HP-UX
 
 // ----------------------------------------------------------------------------
@@ -1722,17 +1728,7 @@ typedef unsigned long   WXHDC;
 typedef unsigned int    WXUINT;
 typedef unsigned long   WXDWORD;
 typedef unsigned short  WXWORD;
-#ifdef __WXMSW__
-typedef unsigned int    WXWPARAM;
-typedef long            WXLPARAM;
-#else
-#  define WXWPARAM      MPARAM
-#  define WXLPARAM      MPARAM
-#  define RECT          RECTL
-#  define LOGFONT       FATTRS
-#  define LOWORD        SHORT1FROMMP
-#  define HIWORD        SHORT2FROMMP
-#endif // __WXMSW__
+
 typedef unsigned long   WXCOLORREF;
 typedef void *          WXRGNDATA;
 typedef void *          WXMSG;
@@ -1744,7 +1740,31 @@ typedef void *          WXDRAWITEMSTRUCT;
 typedef void *          WXMEASUREITEMSTRUCT;
 typedef void *          WXLPCREATESTRUCT;
 
+typedef WXHWND          WXWidget;
+
+#endif // MSW or OS2
+
+
+#ifdef __WXMSW__
+typedef unsigned int    WXWPARAM;
+typedef long            WXLPARAM;
+
+#if !defined(__WIN32__) || defined(__GNUWIN32__) || defined(__WXWINE__) || defined(__WXMICROWIN__)
+typedef int             (*WXFARPROC)();
+#else
+typedef int             (__stdcall *WXFARPROC)();
+#endif
+#endif // __WXMSW__
+
+
 #if defined(__WXPM__)
+#define WXWPARAM        MPARAM
+#define WXLPARAM        MPARAM
+#define RECT            RECTL
+#define LOGFONT         FATTRS
+#define LOWORD          SHORT1FROMMP
+#define HIWORD          SHORT2FROMMP
+
 typedef unsigned long   WXMPARAM;
 typedef unsigned long   WXMSGID;
 typedef void*           WXRESULT;
@@ -1792,35 +1812,16 @@ typedef struct tagLOGPALETTE
     WORD palNumentries;
     WORD PALETTEENTRY[1];
 } LOGPALETTE;
+
+#if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) || defined (__WATCOMC__)
+    // VA 3.0 for some reason needs base data types when typedefing a proc proto???
+typedef void* (_System *WXFARPROC)(unsigned long, unsigned long, void*, void*);
+#else
+typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
+#endif
+
 #endif //__WXPM__
 
-#if defined(__GNUWIN32__) || defined(__WXWINE__) || defined(__WXMICROWIN__)
-    typedef int (*WXFARPROC)();
-#elif defined(__WIN32__)
-    typedef int (__stdcall *WXFARPROC)();
-#elif defined(__WXPM__)
-#  if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) || defined (__WATCOMC__)
-    // VA 3.0 for some reason needs base data types when typedefing a proc proto???
-    typedef void* (_System *WXFARPROC)(unsigned long, unsigned long, void*, void*);
-#  else
-    typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
-#  endif
-#else
-    typedef int (*WXFARPROC)();
-#endif
-
-typedef WXHWND WXWidget;
-
-#if defined(__BORLANDC__) && !defined(__WIN32__)
-#  ifndef LPTSTR
-#    define LPTSTR LPSTR
-#  endif
-#  ifndef LPCTSTR
-#    define LPCTSTR LPSTR
-#  endif
-#endif
-
-#endif // MSW or OS2
 
 #ifdef __WXMOTIF__
 /* Stand-ins for X/Xt/Motif types */
@@ -1860,13 +1861,13 @@ typedef struct _GdkColormap     GdkColormap;
 typedef struct _GdkFont         GdkFont;
 typedef struct _GdkGC           GdkGC;
 #ifdef __WXGTK20__
-    typedef struct _GdkDrawable     GdkWindow;
-    typedef struct _GdkDrawable     GdkBitmap;
-    typedef struct _GdkDrawable     GdkPixmap;
+typedef struct _GdkDrawable     GdkWindow;
+typedef struct _GdkDrawable     GdkBitmap;
+typedef struct _GdkDrawable     GdkPixmap;
 #else
-    typedef struct _GdkWindow       GdkWindow;
-    typedef struct _GdkWindow       GdkBitmap;
-    typedef struct _GdkWindow       GdkPixmap;
+typedef struct _GdkWindow       GdkWindow;
+typedef struct _GdkWindow       GdkBitmap;
+typedef struct _GdkWindow       GdkPixmap;
 #endif
 typedef struct _GdkCursor       GdkCursor;
 typedef struct _GdkRegion       GdkRegion;
diff --git a/include/wx/dynload.h b/include/wx/dynload.h
index d41c85802a..683cd67ac2 100644
--- a/include/wx/dynload.h
+++ b/include/wx/dynload.h
@@ -28,6 +28,15 @@
 #include "wx/hash.h"
 #include "wx/module.h"
 
+// FIXME: can this go in private.h or something too??
+#if defined(__WXPM__) || defined(__EMX__)
+#define INCL_DOS
+#include <os2.h>
+#endif
+
+#ifdef __WXMSW__
+#include "wx/msw/private.h"
+#endif
 
 // Ugh, I'd much rather this was typesafe, but no time
 // to rewrite wxHashTable right now..
@@ -42,66 +51,90 @@ typedef wxHashTable wxDLImports;
     // Note: WXPM/EMX has to be tested first, since we want to use
     // native version, even if configure detected presence of DLOPEN.
 
-#if defined(__WXPM__) || defined(__EMX__)
-#define INCL_DOS
-#include <os2.h>
-    typedef HMODULE wxDllType;
+#if defined(__WXPM__) || defined(__EMX__) || defined(__WINDOWS__)
+typedef HMODULE             wxDllType;
 #elif defined(HAVE_DLOPEN)
 #include <dlfcn.h>
-    typedef void *wxDllType;
+typedef void               *wxDllType;
 #elif defined(HAVE_SHL_LOAD)
 #include <dl.h>
-    typedef shl_t wxDllType;
-#elif defined(__WINDOWS__)
-#include <windows.h>         // needed to get HMODULE
-    typedef HMODULE wxDllType;
+typedef shl_t               wxDllType;
 #elif defined(__DARWIN__)
-    typedef void *wxDllType;
+typedef void               *wxDllType;
 #elif defined(__WXMAC__)
-    typedef CFragConnectionID wxDllType;
+typedef CFragConnectionID   wxDllType;
 #else
-#error "wxLibrary can't be compiled on this platform, sorry."
-#endif
-
-    // LoadLibrary is defined in windows.h as LoadLibraryA, but wxDllLoader
-    // method should be called LoadLibrary, not LoadLibraryA or LoadLibraryW!
-
-#if defined(__WIN32__) && defined(LoadLibrary)
-#   include "wx/msw/winundef.h"
+#error "Dynamic Loading classes can't be compiled on this platform, sorry."
 #endif
 
 
 // ---------------------------------------------------------------------------
-// wxDllLoader
+// wxDynamicLibrary
 // ---------------------------------------------------------------------------
 
-    //  Cross platform wrapper for dlopen and friends.
-    //  There are no instances of this class, it simply
-    //  serves as a namespace for its static member functions.
+//FIXME:  This class isn't really common at all, it should be moved
+//        into platform dependent files.
 
-class WXDLLEXPORT wxDllLoader
+// NOTE: this class is (deliberately) not virtual, do not attempt
+//       to use it polymorphically.
+
+enum wxDLFlags
+{
+    wxDL_LAZY       = 0x00000001,   // resolve undefined symbols at first use
+    wxDL_NOW        = 0x00000002,   // resolve undefined symbols on load
+    wxDL_GLOBAL     = 0x00000004,   // export extern symbols to subsequently
+                                    // loaded libs.
+    wxDL_VERBATIM   = 0x00000008,   // Attempt to load the supplied library
+                                    // name without appending the usual dll
+                                    // filename extension.
+#ifdef __osf__
+    wxDL_DEFAULT    = wxDL_LAZY
+#else
+    wxDL_DEFAULT    = wxDL_LAZY | wxDL_GLOBAL
+#endif
+};
+
+
+class WXDLLEXPORT wxDynamicLibrary
 {
 public:
 
-        // libname may be either the full path to the file or just the filename
-        // in which case the library is searched for in all standard locations.
-        // The platform specific library extension is automatically appended.
-
-    static wxDllType    Load(const wxString& name);
-
-        // The same as Load, except 'name' is searched for without modification.
-
-    static wxDllType    LoadLibrary(const wxString& name);
-    static void         UnloadLibrary(wxDllType dll);
-
         // return a valid handle for the main program itself or NULL if
         // back linking is not supported by the current platform (e.g. Win32)
 
-    static wxDllType GetProgramHandle();
+    static wxDllType         GetProgramHandle();
+
+        // return the platform standard DLL extension (with leading dot)
+
+    static const wxString   &GetDllExt() { return ms_dllext; }
+
+    wxDynamicLibrary() : m_handle(0) {}
+    wxDynamicLibrary(wxString libname, wxDLFlags flags = wxDL_DEFAULT)
+        : m_handle(0)
+    {
+        Load(libname, flags);
+    }
+    ~wxDynamicLibrary() { Unload(); }
+
+        // return TRUE if the library was loaded successfully
+
+    bool IsLoaded() const { return m_handle != 0; }
+
+        // load the library with the given name
+        // (full or not), return TRUE on success
+
+    bool Load(wxString libname, wxDLFlags flags = wxDL_DEFAULT);
+
+        // unload the library, also done automatically in dtor
+
+    void Unload();
+
+        // Return the raw handle from dlopen and friends.
+
+    wxDllType GetLibHandle() const { return m_handle; }
 
         // resolve a symbol in a loaded DLL, such as a variable or function
-        // name.  dllHandle is a handle previously returned by LoadLibrary(),
-        // symbol is the (possibly mangled) name of the symbol.
+        // name.  'name' is the (possibly mangled) name of the symbol.
         // (use extern "C" to export unmangled names)
         //
         // Since it is perfectly valid for the returned symbol to actually be
@@ -109,36 +142,55 @@ public:
         // parameter 'success' for a true indication of success or failure to
         // load the symbol.
         //
-        // Returns a pointer to the symbol on success.
+        // Returns a pointer to the symbol on success, or NULL if an error
+        // occurred or the symbol wasn't found.
 
-    static void *GetSymbol(wxDllType dllHandle, const wxString &name, bool *success = 0);
+    void *GetSymbol(const wxString& name, bool *success = 0) const;
 
-        // return the platform standard DLL extension (with leading dot)
+#if WXWIN_COMPATIBILITY_2_2
+    operator bool() const { return IsLoaded(); }
+#endif
 
-    static const wxString &GetDllExt() { return ms_dllext; }
+protected:
 
-private:
+        // Platform specific shared lib suffix.
 
-    wxDllLoader();                    // forbid construction of objects
-    static const wxString ms_dllext;  // Platform specific shared lib suffix.
+    static const wxString ms_dllext;
+
+        // the handle to DLL or NULL
+
+    wxDllType m_handle;
+
+        // no copy ctor/assignment operators
+        // or we'd try to unload the library twice
+
+DECLARE_NO_COPY_CLASS(wxDynamicLibrary)
 };
 
 
 // ---------------------------------------------------------------------------
-// wxDynamicLibrary
+// wxPluginLibrary
 // ---------------------------------------------------------------------------
 
-class WXDLLEXPORT wxDLManifestEntry
+// NOTE: Do not attempt to use a base class pointer to this class.
+//       wxDL is not virtual and we deliberately hide some of it's
+//       methods here.
+//
+//       Unless you know exacty why you need to, you probably shouldn't
+//       instantiate this class directly anyway, use wxPluginManager
+//       instead.
+
+class WXDLLEXPORT wxPluginLibrary : public wxDynamicLibrary
 {
 public:
 
     static wxDLImports ms_classes;  // Static hash of all imported classes.
 
-    wxDLManifestEntry( const wxString &libname );
-    ~wxDLManifestEntry();
+    wxPluginLibrary( const wxString &libname, wxDLFlags flags = wxDL_DEFAULT );
+    ~wxPluginLibrary();
 
-    wxDLManifestEntry  *RefLib() { ++m_linkcount; return this; }
-    bool                UnrefLib();
+    wxPluginLibrary  *RefLib() { ++m_linkcount; return this; }
+    bool              UnrefLib();
 
         // These two are called by the PluginSentinel on (PLUGGABLE) object
         // creation/destruction.  There is usually no reason for the user to
@@ -152,28 +204,21 @@ public:
         //        probably only be active in DEBUG mode, but let's just
         //        get it right first.
 
-    void        RefObj() { ++m_objcount; }
-    void        UnrefObj()
+    void  RefObj() { ++m_objcount; }
+    void  UnrefObj()
     {
         wxASSERT_MSG( m_objcount > 0, _T("Too many objects deleted??") );
         --m_objcount;
     }
 
-    bool        IsLoaded() const { return m_linkcount > 0; }
+        // Override/hide some base class methods
 
-    wxDllType   GetLinkHandle() const { return m_handle; }
-    wxDllType   GetProgramHandle() const { return wxDllLoader::GetProgramHandle(); }
-    void       *GetSymbol(const wxString &symbol, bool *success = 0)
-    {
-        return wxDllLoader::GetSymbol( m_handle, symbol, success );
-    }
+    bool  IsLoaded() const { return m_linkcount > 0; }
+    void  Unload() { UnrefLib(); }
 
 private:
 
-        // Order of these three *is* important, do not change it
-
     wxClassInfo    *m_before;       // sm_first before loading this lib
-    wxDllType       m_handle;       // Handle from dlopen.
     wxClassInfo    *m_after;        // ..and after.
 
     size_t          m_linkcount;    // Ref count of library link calls
@@ -185,23 +230,38 @@ private:
     void    RegisterModules();      // Init any wxModules in the lib.
     void    UnregisterModules();    // Cleanup any wxModules we installed.
 
-DECLARE_NO_COPY_CLASS(wxDLManifestEntry)
+DECLARE_NO_COPY_CLASS(wxPluginLibrary)
 };
 
 
-class WXDLLEXPORT wxDynamicLibrary
+class WXDLLEXPORT wxPluginManager
 {
 public:
 
         // Static accessors.
 
-    static wxDLManifestEntry    *Link(const wxString &libname);
-    static bool                  Unlink(const wxString &libname);
+    static wxPluginLibrary    *LoadLibrary( const wxString &libname,
+                                            wxDLFlags flags = wxDL_DEFAULT );
+    static bool                UnloadLibrary(const wxString &libname);
+
+        // This is used by wxDllLoader.  It's wrapped in the compatibility
+        // macro because it's of arguable use outside of that.
+
+#if WXWIN_COMPATIBILITY_2_2
+    static wxPluginLibrary *GetObjectFromHandle(wxDllType handle);
+#endif
 
         // Instance methods.
 
-    wxDynamicLibrary(const wxString &libname);
-    ~wxDynamicLibrary();
+    wxPluginManager() : m_entry(0) {};
+    wxPluginManager(const wxString &libname, wxDLFlags flags = wxDL_DEFAULT)
+    {
+        Load(libname, flags);
+    }
+    ~wxPluginManager() { Unload(); }
+
+    bool   Load(const wxString &libname, wxDLFlags flags = wxDL_DEFAULT);
+    void   Unload();
 
     bool   IsLoaded() const { return m_entry && m_entry->IsLoaded(); }
     void  *GetSymbol(const wxString &symbol, bool *success = 0)
@@ -212,15 +272,44 @@ public:
 private:
 
     static wxDLManifest  ms_manifest;  // Static hash of loaded libs.
-    wxDLManifestEntry   *m_entry;      // Cache our entry in the manifest.
+    wxPluginLibrary     *m_entry;      // Cache our entry in the manifest.
 
     // We could allow this class to be copied if we really
     // wanted to, but not without modification.
 
-DECLARE_NO_COPY_CLASS(wxDynamicLibrary)
+DECLARE_NO_COPY_CLASS(wxPluginManager)
 };
 
 
+// ---------------------------------------------------------------------------
+// wxDllLoader
+// ---------------------------------------------------------------------------
+
+    //  Cross platform wrapper for dlopen and friends.
+    //  There are no instances of this class, it simply
+    //  serves as a namespace for its static member functions.
+
+#if WXWIN_COMPATIBILITY_2_2
+class WXDLLEXPORT wxDllLoader
+{
+public:
+
+    static wxDllType    LoadLibrary(const wxString& name);
+    static void         UnloadLibrary(wxDllType dll);
+
+    static wxDllType GetProgramHandle() { return wxDynamicLibrary::GetProgramHandle(); }
+
+    static void *GetSymbol(wxDllType dllHandle, const wxString &name, bool *success = 0);
+
+    static const wxString &GetDllExt() { return wxDynamicLibrary::GetDllExt(); }
+
+private:
+
+    wxDllLoader();                    // forbid construction of objects
+};
+#endif
+
+
 #endif  // wxUSE_DYNAMIC_LOADER
 #endif  // _WX_DYNAMICLOADER_H__
 
diff --git a/include/wx/object.h b/include/wx/object.h
index 1ae3844253..43688968ab 100644
--- a/include/wx/object.h
+++ b/include/wx/object.h
@@ -208,11 +208,11 @@ name##PluginSentinel  m_pluginsentinel;
 #define _IMPLEMENT_DL_SENTINEL(name)                                \
  const wxString name::name##PluginSentinel::sm_className(#name);    \
  name::name##PluginSentinel::name##PluginSentinel() {               \
-    wxDLManifestEntry *e = (wxDLManifestEntry*) wxDLManifestEntry::ms_classes.Get(#name);   \
+    wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name);   \
     if( e != 0 ) { e->RefObj(); }                                      \
  }                                                                  \
  name::name##PluginSentinel::~##name##PluginSentinel() {            \
-    wxDLManifestEntry *e = (wxDLManifestEntry*) wxDLManifestEntry::ms_classes.Get(#name);   \
+    wxPluginLibrary *e = (wxPluginLibrary*) wxPluginLibrary::ms_classes.Get(#name);   \
     if( e != 0 ) { e->UnrefObj(); }                                 \
  }
 #else
diff --git a/include/wx/settings.h b/include/wx/settings.h
index 4b114def80..1a52f5d711 100644
--- a/include/wx/settings.h
+++ b/include/wx/settings.h
@@ -131,6 +131,8 @@ enum wxSystemFeature
 // also note that the methods are implemented in the platform-specific source
 // files (i.e. this is not a real base class as we can't override its virtual
 // functions because it doesn't have any)
+
+#if 0
 class WXDLLEXPORT wxSystemSettingsBase
 {
 public:
@@ -158,6 +160,7 @@ public:
     static bool GetCapability(int index)
         { return HasFeature((wxSystemFeature)index); }
 };
+#endif
 
 // ----------------------------------------------------------------------------
 // include the declaration of the real platform-dependent class
diff --git a/src/common/dynload.cpp b/src/common/dynload.cpp
index 3b2ff4bf0e..6341b6d593 100644
--- a/src/common/dynload.cpp
+++ b/src/common/dynload.cpp
@@ -37,127 +37,46 @@
 
 #include "wx/dynload.h"
 
-// ----------------------------------------------------------------------------
-// conditional compilation
-// ----------------------------------------------------------------------------
-
-#if defined(__WXPM__) || defined(__EMX__)
-#define INCL_DOS
-#include <os2.h>
-#define wxDllOpen(error, lib, handle)   DosLoadModule(error, sizeof(error), lib, &handle)
-#define wxDllGetSymbol(handle, modaddr) DosQueryProcAddr(handle, 1L, NULL, (PFN*)modaddr)
-#define wxDllClose(handle)              DosFreeModule(handle)
-
-#elif defined(HAVE_DLOPEN)
-    // note about dlopen() flags: we use RTLD_NOW to have more Windows-like
-    // behaviour (Win won't let you load a library with missing symbols) and
-    // RTLD_GLOBAL because it is needed sometimes and probably doesn't hurt
-    // otherwise. On True64-Unix RTLD_GLOBAL is not allowed and on VMS the
-    // second argument on dlopen is ignored.
-
-#ifdef __VMS
-#define wxDllOpen(lib)                dlopen(lib.fn_str(), 0)
-
-#elif defined( __osf__ )
-#define wxDllOpen(lib)                dlopen(lib.fn_str(), RTLD_LAZY)
-
-#else
-#define wxDllOpen(lib)                dlopen(lib.fn_str(), RTLD_LAZY | RTLD_GLOBAL)
-#endif  // __VMS
-
-#define wxDllGetSymbol(handle, name)  dlsym(handle, name)
-#define wxDllClose                    dlclose
-
-#elif defined(HAVE_SHL_LOAD)
-#define wxDllOpen(lib)                shl_load(lib.fn_str(), BIND_DEFERRED, 0)
-#define wxDllClose                    shl_unload
-
-static inline void *wxDllGetSymbol(shl_t handle, const wxString& name)
-{
-    void *sym;
-    return ( shl_findsym(&handle, name.mb_str(), TYPE_UNDEFINED, &sym) == 0 )
-           ? sym : 0;
-}
-
-#elif defined(__DARWIN__)
-
-    // Porting notes:
-    //   The dlopen port is a port from dl_next.xs by Anno Siegel.
-    //   dl_next.xs is itself a port from dl_dlopen.xs by Paul Marquess.
-    //   The method used here is just to supply the sun style dlopen etc.
-    //   functions in terms of Darwin NS*.
-
-void        *dlopen(const char *path, int mode);        // mode is ignored
-void        *dlsym(void *handle, const char *symbol);
-int          dlclose(void *handle);
-const char  *dlerror(void);
-
-#define wxDllOpen(lib)                  dlopen(lib.fn_str(), 0)
-#define wxDllGetSymbol(handle, name)    dlsym(handle, name)
-#define wxDllClose                      dlclose
-
-#elif defined(__WINDOWS__)
-
-    // using LoadLibraryEx under Win32 to avoid name clash with LoadLibrary
-
-#ifdef __WIN32__
-
-#ifdef _UNICODE
-#define wxDllOpen(lib)                  ::LoadLibraryExW(lib, 0, 0)
-#else
-#define wxDllOpen(lib)                  ::LoadLibraryExA(lib, 0, 0)
-#endif
-
-#else   // Win16
-#define wxDllOpen(lib)                  ::LoadLibrary(lib)
-#endif  // Win32/16
-#define wxDllGetSymbol(handle, name)    ::GetProcAddress(handle, name)
-#define wxDllClose                      ::FreeLibrary
-
-#elif defined(__WXMAC__)
-#define wxDllClose(handle)              CloseConnection(&handle)
-#else
-#error "Don't know how to load shared libraries on this platform."
-#endif
-
 
 // ============================================================================
 // implementation
 // ============================================================================
 
 // ---------------------------------------------------------------------------
-// wxDllLoader   (all these methods are static)
+// wxDynamicLibrary
 // ---------------------------------------------------------------------------
 
+//FIXME:  This class isn't really common at all, it should be moved into
+//        platform dependent files.
 
 #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
-const wxString wxDllLoader::ms_dllext( _T(".dll") );
+const wxString wxDynamicLibrary::ms_dllext( _T(".dll") );
 #elif defined(__UNIX__)
 #if defined(__HPUX__)
-const wxString wxDllLoader::ms_dllext( _T(".sl") );
+const wxString wxDynamicLibrary::ms_dllext( _T(".sl") );
 #else
-const wxString wxDllLoader::ms_dllext( _T(".so") );
+const wxString wxDynamicLibrary::ms_dllext( _T(".so") );
 #endif
 #endif
 
-wxDllType wxDllLoader::GetProgramHandle()
+wxDllType wxDynamicLibrary::GetProgramHandle()
 {
 #if defined( HAVE_DLOPEN ) && !defined(__EMX__)
-   // obtain handle for main program
-   return dlopen(NULL, RTLD_NOW/*RTLD_LAZY*/);
+   return dlopen(0, RTLD_LAZY);
 #elif defined (HAVE_SHL_LOAD)
-   // shl_findsymbol with NULL handle looks up in main program
-   return 0;
+   return PROG_HANDLE;
 #else
    wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2"));
    return 0;
 #endif
 }
 
-wxDllType wxDllLoader::LoadLibrary(const wxString &name)
+bool wxDynamicLibrary::Load(wxString libname, wxDLFlags flags)
 {
-    wxString    libname( name + wxDllLoader::GetDllExt() );
-    wxDllType   handle;
+    wxASSERT_MSG(m_handle == 0, _T("Library already loaded."));
+
+    if( !(flags & wxDL_VERBATIM) )
+        libname += GetDllExt();
 
 #if defined(__WXMAC__) && !defined(__UNIX__)
     FSSpec      myFSSpec;
@@ -171,7 +90,7 @@ wxDllType wxDllLoader::LoadLibrary(const wxString &name)
                          kCFragGoesToEOF,
                          "\p",
                          kPrivateCFragCopy,
-                         &handle,
+                         &m_handle,
                          &myMainAddr,
                          myErrName ) != noErr )
     {
@@ -179,16 +98,79 @@ wxDllType wxDllLoader::LoadLibrary(const wxString &name)
         wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
                        libname.c_str(),
                        (char*)myErrName );
-        handle = 0;
+        m_handle = 0;
     }
 
 #elif defined(__WXPM__) || defined(__EMX__)
-    char        zError[256] = "";
-    wxDllOpen(zError, libname, handle);
+    char    err[256] = "";
+    DosLoadModule(err, sizeof(err), libname.c_str(), &m_handle)
+
+#elif defined(HAVE_DLOPEN)
+
+#ifdef __VMS
+    m_handle = dlopen(libname.c_str(), 0);  // The second parameter is ignored
 #else
-    handle = wxDllOpen(libname);
+    int rtldFlags = 0;
+
+    if( flags & wxDL_LAZY )
+    {
+        wxASSERT_MSG( (flags & wxDL_NOW) == 0,
+                      _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
+        rtldFlags |= RTLD_LAZY;
+    }
+    else if( flags & wxDL_NOW )
+    {
+        rtldFlags |= RTLD_NOW;
+    }
+    if( flags & wxDL_GLOBAL )
+    {
+#ifdef __osf__
+        wxLogDebug(_T("WARNING: RTLD_GLOBAL is not a supported on this platform."));
 #endif
-    if ( !handle )
+        rtldFlags |= RTLD_GLOBAL;
+    }
+
+    m_handle = dlopen(libname.c_str(), rtldFlags);
+#endif  // __VMS
+
+#elif defined(HAVE_SHL_LOAD)
+    int shlFlags = 0;
+
+    if( flags & wxDL_LAZY )
+    {
+        wxASSERT_MSG( (flags & wxDL_NOW) == 0,
+                      _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
+        shlFlags |= BIND_DEFERRED;
+    }
+    else if( flags & wxDL_NOW )
+    {
+        shlFlags |= BIND_IMMEDIATE;
+    }
+    m_handle = shl_load(libname.c_str(), BIND_DEFERRED, 0);
+
+#elif defined(__DARWIN__)
+    NSObjectFileImage   ofile;
+    int                 dyld_result = NSCreateObjectFileImageFromFile(libname.c_str(), &ofile);
+
+    if (dyld_result != NSObjectFileImageSuccess)
+    {
+        TranslateError(libname.c_str(), OFImage, dyld_result);
+    }
+    else
+    {
+        // NSLinkModule will cause the run to abort on any link error's
+        // not very friendly but the error recovery functionality is limited.
+        m_handle = NSLinkModule(ofile, libname.c_str(), TRUE);
+    }
+
+#elif defined(__WINDOWS__)
+    m_handle = ::LoadLibrary(libname.c_str());
+
+#else
+#error  "runtime shared lib support not implemented"
+#endif
+
+    if ( m_handle == 0 )
     {
         wxString msg(_("Failed to load shared library '%s'"));
 #ifdef HAVE_DLERROR
@@ -199,16 +181,36 @@ wxDllType wxDllLoader::LoadLibrary(const wxString &name)
         wxLogSysError( msg, libname.c_str() );
 #endif
     }
-    return handle;
+
+    return IsLoaded();
 }
 
-void wxDllLoader::UnloadLibrary(wxDllType handle)
+void wxDynamicLibrary::Unload()
 {
-   wxDllClose(handle);
+    if( IsLoaded() )
+    {
+#if defined(__WXPM__) || defined(__EMX__)
+        DosFreeModule( m_handle );
+#elif defined(HAVE_DLOPEN)
+        dlclose( m_handle );
+#elif defined(HAVE_SHL_LOAD)
+        shl_unload( m_handle );
+#elif defined(__WINDOWS__)
+        ::FreeLibrary( m_handle );
+#elif defined(__WXMAC__)
+        CloseConnection( &m_handle );
+#else
+#error  "runtime shared lib support not implemented"
+#endif
+        m_handle = 0;
+    }
 }
 
-void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
+void *wxDynamicLibrary::GetSymbol(const wxString &name, bool *success) const
 {
+    wxCHECK_MSG( IsLoaded(), NULL,
+                 _T("Can't load symbol from unloaded library") );
+
     bool     failed = FALSE;
     void    *symbol = 0;
 
@@ -219,23 +221,36 @@ void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *su
 #if TARGET_CARBON
     c2pstrcpy( (StringPtr) symName, name );
 #else
-    strcpy( (char *) symName, name );
-    c2pstr( (char *) symName );
+    strcpy( (char *)symName, name );
+    c2pstr( (char *)symName );
 #endif
     if( FindSymbol( dllHandle, symName, &symAddress, &symClass ) == noErr )
         symbol = (void *)symAddress;
 
 #elif defined(__WXPM__) || defined(__EMX__)
-    wxDllGetSymbol(dllHandle, symbol);
-#else
+    DosQueryProcAddr( m_handle, 1L, name.c_str(), (PFN*)symbol );
 
-    // mb_str() is necessary in Unicode build
-    symbol = wxDllGetSymbol(dllHandle, name.mb_str());
+#elif defined(HAVE_DLOPEN)
+    symbol = dlsym( m_handle, name.c_str() );
+
+#elif defined(HAVE_SHL_LOAD)
+    if( shl_findsym( &m_handle, name.c_str(), TYPE_UNDEFINED, &symbol ) != 0 )
+        symbol = 0;
+
+#elif defined(__DARWIN__)
+    if( NSIsSymbolNameDefined( name.c_str() ) )
+        symbol = NSAddressOfSymbol( NSLookupAndBindSymbol( name.c_str() ) );
+
+#elif defined(__WINDOWS__)
+    symbol = ::GetProcAddress( m_handle, name.c_str() );
+
+#else
+#error  "runtime shared lib support not implemented"
 #endif
 
     if ( !symbol )
     {
-        wxString msg(_("wxDllLoader failed to GetSymbol '%s'"));
+        wxString msg(_("wxDynamicLibrary failed to GetSymbol '%s'"));
 #ifdef HAVE_DLERROR
         const wxChar *err = dlerror();
         if( err )
@@ -257,19 +272,20 @@ void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *su
 
 
 // ---------------------------------------------------------------------------
-// wxDLManifestEntry
+// wxPluginLibrary
 // ---------------------------------------------------------------------------
 
 
-wxDLImports  wxDLManifestEntry::ms_classes(wxKEY_STRING);
+wxDLImports  wxPluginLibrary::ms_classes(wxKEY_STRING);
 
-wxDLManifestEntry::wxDLManifestEntry( const wxString &libname )
-        : m_before(wxClassInfo::sm_first)
-        , m_handle(wxDllLoader::LoadLibrary( libname ))
-        , m_after(wxClassInfo::sm_first)
-        , m_linkcount(1)
+wxPluginLibrary::wxPluginLibrary(const wxString &libname, wxDLFlags flags)
+        : m_linkcount(1)
         , m_objcount(0)
 {
+    m_before = wxClassInfo::sm_first;
+    Load( libname, flags );
+    m_after = wxClassInfo::sm_first;
+
     if( m_handle != 0 )
     {
         UpdateClassInfo();
@@ -279,17 +295,16 @@ wxDLManifestEntry::wxDLManifestEntry( const wxString &libname )
         --m_linkcount;      // Flag us for deletion
 }
 
-wxDLManifestEntry::~wxDLManifestEntry()
+wxPluginLibrary::~wxPluginLibrary()
 {
     if( m_handle != 0 )
     {
         UnregisterModules();
         RestoreClassInfo();
-        wxDllLoader::UnloadLibrary(m_handle);
     }
 }
 
-bool wxDLManifestEntry::UnrefLib()
+bool wxPluginLibrary::UnrefLib()
 {
     wxASSERT_MSG( m_objcount == 0, _T("Library unloaded before all objects were destroyed") );
     if( m_linkcount == 0 || --m_linkcount == 0 )
@@ -304,7 +319,7 @@ bool wxDLManifestEntry::UnrefLib()
 // Private methods
 // ------------------------
 
-void wxDLManifestEntry::UpdateClassInfo()
+void wxPluginLibrary::UpdateClassInfo()
 {
     wxClassInfo     *info;
     wxHashTable     *t = wxClassInfo::sm_classTable;
@@ -342,7 +357,7 @@ void wxDLManifestEntry::UpdateClassInfo()
     }
 }
 
-void wxDLManifestEntry::RestoreClassInfo()
+void wxPluginLibrary::RestoreClassInfo()
 {
     wxClassInfo *info;
 
@@ -359,13 +374,13 @@ void wxDLManifestEntry::RestoreClassInfo()
         info = wxClassInfo::sm_first;
         while( info->m_next && info->m_next != m_after ) info = info->m_next;
 
-        wxASSERT_MSG( info, _T("ClassInfo from wxDynamicLibrary not found on purge"))
+        wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge"))
 
         info->m_next = m_before;
     }
 }
 
-void wxDLManifestEntry::RegisterModules()
+void wxPluginLibrary::RegisterModules()
 {
     // Plugin libraries might have wxModules, Register and initialise them if
     // they do.
@@ -397,7 +412,7 @@ void wxDLManifestEntry::RegisterModules()
     {
         if( !node->GetData()->Init() )
         {
-            wxLogDebug(_T("wxModule::Init() failed for wxDynamicLibrary"));
+            wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary"));
 
             // XXX: Watch this, a different hash implementation might break it,
             //      a good hash implementation would let us fix it though.
@@ -420,7 +435,7 @@ void wxDLManifestEntry::RegisterModules()
     }
 }
 
-void wxDLManifestEntry::UnregisterModules()
+void wxPluginLibrary::UnregisterModules()
 {
     wxModuleList::Node  *node;
 
@@ -435,30 +450,35 @@ void wxDLManifestEntry::UnregisterModules()
 
 
 // ---------------------------------------------------------------------------
-// wxDynamicLibrary
+// wxPluginLibrary
 // ---------------------------------------------------------------------------
 
-wxDLManifest   wxDynamicLibrary::ms_manifest(wxKEY_STRING);
+wxDLManifest   wxPluginManager::ms_manifest(wxKEY_STRING);
 
 // ------------------------
 // Static accessors
 // ------------------------
 
-wxDLManifestEntry *wxDynamicLibrary::Link(const wxString &libname)
+wxPluginLibrary *wxPluginManager::LoadLibrary(const wxString &libname, wxDLFlags flags)
 {
-    wxDLManifestEntry *entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
+    wxString realname(libname);
 
-    if( entry )
+    if( !(flags & wxDL_VERBATIM) )
+        realname += wxDynamicLibrary::GetDllExt();
+
+    wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest.Get(realname);
+
+    if( entry != 0 )
     {
         entry->RefLib();
     }
     else
     {
-        entry = new wxDLManifestEntry( libname );
+        entry = new wxPluginLibrary( libname, flags );
 
         if( entry->IsLoaded() )
         {
-            ms_manifest.Put(libname, (wxObject*) entry);
+            ms_manifest.Put(realname, (wxObject*) entry);
         }
         else
         {
@@ -470,39 +490,45 @@ wxDLManifestEntry *wxDynamicLibrary::Link(const wxString &libname)
     return entry;
 }
 
-bool wxDynamicLibrary::Unlink(const wxString &libname)
+bool wxPluginManager::UnloadLibrary(const wxString &libname)
 {
-    wxDLManifestEntry *entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
+    wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest.Get(libname);
+
+    if( !entry )
+        entry = (wxPluginLibrary*) ms_manifest.Get(libname + wxDynamicLibrary::GetDllExt());
 
     if( entry )
         return entry->UnrefLib();
 
     wxLogDebug(_T("Attempt to Unlink library '%s' (which is not linked)."), libname.c_str());
+    return FALSE;
+}
+
+#if WXWIN_COMPATIBILITY_2_2
+wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
+{
+    wxNode  *node;
+    ms_manifest.BeginFind();
+
+    for(node = ms_manifest.Next(); node; node = ms_manifest.Next())
+        if( ((wxPluginLibrary*)node->GetData())->GetLibHandle() == handle )
+            return (wxPluginLibrary*)node->GetData();
+
     return 0;
 }
+#endif
 
 // ------------------------
 // Class implementation
 // ------------------------
 
-wxDynamicLibrary::wxDynamicLibrary(const wxString &libname)
+bool wxPluginManager::Load(const wxString &libname, wxDLFlags flags)
 {
-    m_entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
-
-    if( m_entry != 0 )
-    {
-        m_entry->RefLib();
-    }
-    else
-    {
-        m_entry = new wxDLManifestEntry( libname );
-        ms_manifest.Put(libname, (wxObject*) m_entry);
-
-        wxASSERT_MSG( m_entry != 0, _T("Failed to create manifest entry") );
-    }
+    m_entry = wxPluginManager::LoadLibrary(libname, flags);
+    return IsLoaded();
 }
 
-wxDynamicLibrary::~wxDynamicLibrary()
+void wxPluginManager::Unload()
 {
     wxNode  *node;
     ms_manifest.BeginFind();
@@ -510,11 +536,14 @@ wxDynamicLibrary::~wxDynamicLibrary()
     // It's either this or store the name of the lib just to do this.
 
     for(node = ms_manifest.Next(); node; node = ms_manifest.Next())
-        if( (wxDLManifestEntry*)node->GetData() == m_entry )
+        if( (wxPluginLibrary*)node->GetData() == m_entry )
             break;
 
     if( m_entry && m_entry->UnrefLib() )
+    {
         delete node;
+        m_entry = 0;
+    }
 }
 
 
@@ -535,8 +564,7 @@ enum dyldErrorSource
 
 static char dl_last_error[1024];
 
-static
-void TranslateError(const char *path, enum dyldErrorSource type, int number)
+static void TranslateError(const char *path, enum dyldErrorSource type, int number)
 {
     unsigned int index;
     static char *OFIErrorStrings[] =
@@ -568,44 +596,35 @@ void TranslateError(const char *path, enum dyldErrorSource type, int number)
     }
 }
 
-const char *dlerror()
-{
-    return dl_last_error;
-}
-void *dlopen(const char *path, int mode /* mode is ignored */)
-{
-    int                 dyld_result;
-    NSObjectFileImage   ofile;
-    NSModule            handle = 0;
-
-    dyld_result = NSCreateObjectFileImageFromFile(path, &ofile);
-    if(dyld_result != NSObjectFileImageSuccess)
-    {
-	TranslateError(path, OFImage, dyld_result);
-    }
-    else
-    {
-	// NSLinkModule will cause the run to abort on any link error's
-	// not very friendly but the error recovery functionality is limited.
-	handle = NSLinkModule(ofile, path, TRUE);
-    }
-
-    return handle;
-}
-
-int dlclose(void *handle) /* stub only */
-{
-    return 0;
-}
-
-void *dlsym(void *handle, const char *symbol)
-{
-    return NSIsSymbolNameDefined(symbol)
-            ? NSAddressOfSymbol( NSLookupAndBindSymbol(symbol) )
-            : 0 ;
-}
-
 #endif // __DARWIN__
+
+
+// ---------------------------------------------------------------------------
+// wxDllLoader   (all these methods are static)
+// ---------------------------------------------------------------------------
+
+#if WXWIN_COMPATIBILITY_2_2
+
+wxDllType wxDllLoader::LoadLibrary(const wxString &name)
+{
+    wxPluginLibrary *p = wxPluginManager::LoadLibrary(name, wxDL_DEFAULT | wxDL_VERBATIM);
+    return p->GetLibHandle();
+}
+
+void wxDllLoader::UnloadLibrary(wxDllType handle)
+{
+    wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
+    p->UnrefLib();
+}
+
+void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
+{
+    wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
+    return p->GetSymbol(name, success);
+}
+
+#endif  // WXWIN_COMPATIBILITY_2_2
+
 #endif  // wxUSE_DYNAMIC_LOADER
 
 // vi:sts=4:sw=4:et
diff --git a/src/common/filename.cpp b/src/common/filename.cpp
index 0867508342..f8d725c523 100644
--- a/src/common/filename.cpp
+++ b/src/common/filename.cpp
@@ -1265,19 +1265,17 @@ wxString wxFileName::GetLongPath() const
     if ( !s_triedToLoad )
     {
         s_triedToLoad = TRUE;
-        wxDllType dllKernel = wxDllLoader::LoadLibrary(_T("kernel32"));
-        if ( dllKernel )
+        wxDynamicLibrary dllKernel(_T("kernel32"));
+        if ( dllKernel.IsLoaded() )
         {
             // may succeed or fail depending on the Windows version
             static GET_LONG_PATH_NAME s_pfnGetLongPathName = NULL;
 #ifdef _UNICODE
-            s_pfnGetLongPathName = (GET_LONG_PATH_NAME) wxDllLoader::GetSymbol(dllKernel, _T("GetLongPathNameW"));
+            s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameW"));
 #else
-            s_pfnGetLongPathName = (GET_LONG_PATH_NAME) wxDllLoader::GetSymbol(dllKernel, _T("GetLongPathNameA"));
+            s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameA"));
 #endif
 
-            wxDllLoader::UnloadLibrary(dllKernel);
-
             if ( s_pfnGetLongPathName )
             {
                 DWORD dwSize = (*s_pfnGetLongPathName)(path, NULL, 0);
diff --git a/src/msw/dialup.cpp b/src/msw/dialup.cpp
index e6e83d87ad..60dd7bfd70 100644
--- a/src/msw/dialup.cpp
+++ b/src/msw/dialup.cpp
@@ -42,8 +42,6 @@
 #include "wx/app.h"
 #include "wx/generic/choicdgg.h"
 
-#include "wx/msw/private.h"  // must be before #include "dynlib.h"
-
 #include "wx/dynlib.h"
 #include "wx/dialup.h"
 
@@ -224,17 +222,20 @@ private:
     // each other
     wxRasThreadData m_data;
 
+    // the handle of rasapi32.dll when it's loaded
+    wxPluginManager m_dllRas;
+
     // the hidden window we use for passing messages between threads
     static HWND ms_hwndRas;
 
     // the handle of the connection we initiated or 0 if none
     static HRASCONN ms_hRasConnection;
 
-    // the use count of rasapi32.dll
-    static int ms_nDllCount;
-
-    // the handle of rasapi32.dll when it's loaded
-    static wxDllType ms_dllRas;
+    // FIXME: There is probably no reason these really need to
+    //        be static anymore since the dll refcounting is
+    //        handled by wxPluginManager now.  Whether or not
+    //        we still _want_ them to be static is another
+    //        issue entirely..
 
     // the pointers to RAS functions
     static RASDIAL ms_pfnRasDial;
@@ -298,9 +299,6 @@ HRASCONN wxDialUpManagerMSW::ms_hRasConnection = 0;
 
 HWND wxDialUpManagerMSW::ms_hwndRas = 0;
 
-int wxDialUpManagerMSW::ms_nDllCount = 0;
-wxDllType wxDialUpManagerMSW::ms_dllRas = 0;
-
 RASDIAL wxDialUpManagerMSW::ms_pfnRasDial = 0;
 RASENUMCONNECTIONS wxDialUpManagerMSW::ms_pfnRasEnumConnections = 0;
 RASENUMENTRIES wxDialUpManagerMSW::ms_pfnRasEnumEntries = 0;
@@ -343,89 +341,80 @@ wxDialUpManager *wxDialUpManager::Create()
 
 wxDialUpManagerMSW::wxDialUpManagerMSW()
                   : m_timerStatusPolling(this)
+                  , m_dllRas(_T("RASAPI32"))
 {
     // initialize our data
     m_hThread = 0;
 
-    if ( !ms_nDllCount++ )
+    if ( !m_dllRas.IsLoaded() )
     {
-        // load the RAS library
-        ms_dllRas = wxDllLoader::LoadLibrary(_T("RASAPI32"));
-        if ( !ms_dllRas )
-        {
-            wxLogError(_("Dial up functions are unavailable because the remote access service (RAS) is not installed on this machine. Please install it."));
-        }
-        else
-        {
-            // resolve the functions we need
+        wxLogError(_("Dial up functions are unavailable because the remote access service (RAS) is not installed on this machine. Please install it."));
+    }
+    else if( ms_pfnRasDial == 0 )
+    {
+        // resolve the functions we need
 
-            // this will contain the name of the function we failed to resolve
-            // if any at the end
-            const char *funcName = NULL;
+        // this will contain the name of the function we failed to resolve
+        // if any at the end
+        const char *funcName = NULL;
 
-            // get the function from rasapi32.dll and abort if it's not found
-            #define RESOLVE_RAS_FUNCTION(type, name)                    \
-                ms_pfn##name = (type)wxDllLoader::GetSymbol(ms_dllRas,  \
-                               wxString(_T(#name)) + gs_funcSuffix);    \
-                if ( !ms_pfn##name )                                    \
-                {                                                       \
-                    funcName = #name;                                   \
-                    goto exit;                                          \
-                }
-
-            // a variant of above macro which doesn't abort if the function is
-            // not found in the DLL
-            #define RESOLVE_OPTIONAL_RAS_FUNCTION(type, name)           \
-                ms_pfn##name = (type)wxDllLoader::GetSymbol(ms_dllRas,  \
-                               wxString(_T(#name)) + gs_funcSuffix);
-
-            RESOLVE_RAS_FUNCTION(RASDIAL, RasDial);
-            RESOLVE_RAS_FUNCTION(RASENUMCONNECTIONS, RasEnumConnections);
-            RESOLVE_RAS_FUNCTION(RASENUMENTRIES, RasEnumEntries);
-            RESOLVE_RAS_FUNCTION(RASGETCONNECTSTATUS, RasGetConnectStatus);
-            RESOLVE_RAS_FUNCTION(RASGETERRORSTRING, RasGetErrorString);
-            RESOLVE_RAS_FUNCTION(RASHANGUP, RasHangUp);
-            RESOLVE_RAS_FUNCTION(RASGETENTRYDIALPARAMS, RasGetEntryDialParams);
-
-            // suppress wxDllLoader messages about missing (non essential)
-            // functions
-            {
-                wxLogNull noLog;
-
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETPROJECTIONINFO, RasGetProjectionInfo);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASCREATEPHONEBOOKENTRY, RasCreatePhonebookEntry);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASEDITPHONEBOOKENTRY, RasEditPhonebookEntry);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYDIALPARAMS, RasSetEntryDialParams);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETENTRYPROPERTIES, RasGetEntryProperties);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYPROPERTIES, RasSetEntryProperties);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASRENAMEENTRY, RasRenameEntry);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASDELETEENTRY, RasDeleteEntry);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASVALIDATEENTRYNAME, RasValidateEntryName);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETCOUNTRYINFO, RasGetCountryInfo);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASENUMDEVICES, RasEnumDevices);
-                RESOLVE_OPTIONAL_RAS_FUNCTION(RASCONNECTIONNOTIFICATION, RasConnectionNotification);
+        // get the function from rasapi32.dll and abort if it's not found
+        #define RESOLVE_RAS_FUNCTION(type, name)                          \
+            ms_pfn##name = (type)m_dllRas.GetSymbol( wxString(_T(#name))  \
+                                                     + gs_funcSuffix);    \
+            if ( !ms_pfn##name )                                          \
+            {                                                             \
+                funcName = #name;                                         \
+                goto exit;                                                \
             }
 
-            // keep your preprocessor name space clean
-            #undef RESOLVE_RAS_FUNCTION
-            #undef RESOLVE_OPTIONAL_RAS_FUNCTION
+        // a variant of above macro which doesn't abort if the function is
+        // not found in the DLL
+        #define RESOLVE_OPTIONAL_RAS_FUNCTION(type, name)                 \
+            ms_pfn##name = (type)m_dllRas.GetSymbol( wxString(_T(#name))  \
+                                                     + gs_funcSuffix);
+
+        RESOLVE_RAS_FUNCTION(RASDIAL, RasDial);
+        RESOLVE_RAS_FUNCTION(RASENUMCONNECTIONS, RasEnumConnections);
+        RESOLVE_RAS_FUNCTION(RASENUMENTRIES, RasEnumEntries);
+        RESOLVE_RAS_FUNCTION(RASGETCONNECTSTATUS, RasGetConnectStatus);
+        RESOLVE_RAS_FUNCTION(RASGETERRORSTRING, RasGetErrorString);
+        RESOLVE_RAS_FUNCTION(RASHANGUP, RasHangUp);
+        RESOLVE_RAS_FUNCTION(RASGETENTRYDIALPARAMS, RasGetEntryDialParams);
+
+        // suppress error messages about missing (non essential) functions
+        {
+            wxLogNull noLog;
+
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETPROJECTIONINFO, RasGetProjectionInfo);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASCREATEPHONEBOOKENTRY, RasCreatePhonebookEntry);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASEDITPHONEBOOKENTRY, RasEditPhonebookEntry);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYDIALPARAMS, RasSetEntryDialParams);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETENTRYPROPERTIES, RasGetEntryProperties);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYPROPERTIES, RasSetEntryProperties);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASRENAMEENTRY, RasRenameEntry);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASDELETEENTRY, RasDeleteEntry);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASVALIDATEENTRYNAME, RasValidateEntryName);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETCOUNTRYINFO, RasGetCountryInfo);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASENUMDEVICES, RasEnumDevices);
+            RESOLVE_OPTIONAL_RAS_FUNCTION(RASCONNECTIONNOTIFICATION, RasConnectionNotification);
+        }
+
+        // keep your preprocessor name space clean
+        #undef RESOLVE_RAS_FUNCTION
+        #undef RESOLVE_OPTIONAL_RAS_FUNCTION
 
 exit:
-            if ( funcName )
-            {
-                static const wxChar *msg = wxTRANSLATE(
+        if ( funcName )
+        {
+            static const wxChar *msg = wxTRANSLATE(
 "The version of remote access service (RAS) installed on this machine is too\
 old, please upgrade (the following required function is missing: %s)."
-                                                       );
+                                                   );
 
-                wxLogError(wxGetTranslation(msg), funcName);
-
-                wxDllLoader::UnloadLibrary(ms_dllRas);
-                ms_dllRas = 0;
-                ms_nDllCount = 0;
-
-                return;
-            }
+            wxLogError(wxGetTranslation(msg), funcName);
+            m_dllRas.Unload();
+            return;
         }
     }
 
@@ -436,13 +425,6 @@ old, please upgrade (the following required function is missing: %s)."
 wxDialUpManagerMSW::~wxDialUpManagerMSW()
 {
     CleanUpThreadData();
-
-    if ( !--ms_nDllCount )
-    {
-        // unload the RAS library
-        wxDllLoader::UnloadLibrary(ms_dllRas);
-        ms_dllRas = 0;
-    }
 }
 
 // ----------------------------------------------------------------------------
@@ -667,7 +649,7 @@ void wxDialUpManagerMSW::OnDialProgress(RASCONNSTATE rasconnstate,
 
 bool wxDialUpManagerMSW::IsOk() const
 {
-    return ms_dllRas != 0;
+    return m_dllRas.IsLoaded();
 }
 
 size_t wxDialUpManagerMSW::GetISPNames(wxArrayString& names) const
@@ -805,13 +787,13 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
             return FALSE;
         }
     }
-	else
-	{
-		wxStrncpy(rasDialParams.szUserName, username, UNLEN);
-		wxStrncpy(rasDialParams.szPassword, password, PWLEN);
-	}
+    else
+    {
+        wxStrncpy(rasDialParams.szUserName, username, UNLEN);
+        wxStrncpy(rasDialParams.szPassword, password, PWLEN);
+    }
 
-	// default values for other fields
+    // default values for other fields
     rasDialParams.szPhoneNumber[0] = '\0';
     rasDialParams.szCallbackNumber[0] = '\0';
     rasDialParams.szCallbackNumber[0] = '\0';
@@ -959,14 +941,19 @@ bool wxDialUpManagerMSW::IsAlwaysOnline() const
     }
 
     // try to use WinInet function first
-    wxDllType hDll = wxDllLoader::LoadLibrary(_T("WININET"));
-    if ( hDll )
+
+    // NB: we could probably use wxDynamicLibrary here just as well,
+    //     but we allow multiple instances of wxDialUpManagerMSW so
+    //     we might as well use the ref counted version here too.
+
+    wxPluginManager hDll(_T("WININET"));
+    if ( hDll.IsLoaded() )
     {
         typedef BOOL (WINAPI *INTERNETGETCONNECTEDSTATE)(LPDWORD, DWORD);
         INTERNETGETCONNECTEDSTATE pfnInternetGetConnectedState;
 
         #define RESOLVE_FUNCTION(type, name) \
-            pfn##name = (type)wxDllLoader::GetSymbol(hDll, _T(#name))
+            pfn##name = (type)hDll.GetSymbol(_T(#name))
 
         RESOLVE_FUNCTION(INTERNETGETCONNECTEDSTATE, InternetGetConnectedState);
 
@@ -985,8 +972,6 @@ bool wxDialUpManagerMSW::IsAlwaysOnline() const
                 ms_isAlwaysOnline = FALSE;
             }
         }
-
-        wxDllLoader::UnloadLibrary(hDll);
     }
 
     // did we succeed with WinInet? if not, try something else
@@ -1302,3 +1287,5 @@ static void WINAPI wxRasDialFunc(UINT unMsg,
 #endif
   // __BORLANDC__
 #endif // wxUSE_DIALUP_MANAGER
+
+// vi:sts=4:sw=4:et
diff --git a/src/msw/helpchm.cpp b/src/msw/helpchm.cpp
index c7090d0877..4a6148671f 100644
--- a/src/msw/helpchm.cpp
+++ b/src/msw/helpchm.cpp
@@ -6,7 +6,7 @@
 // Created:     16/04/2000
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:   	wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
@@ -56,41 +56,29 @@ typedef HWND ( WINAPI * HTMLHELP )( HWND, LPCSTR, UINT, DWORD );
 typedef HWND ( WINAPI * HTMLHELP )( HWND, LPCWSTR, UINT, DWORD );
 #define HTMLHELP_NAME "HtmlHelpW"
 #endif
-// dll handle/reference count
+// dll symbol handle
 static HTMLHELP gs_htmlHelp = 0;
-static wxDllType gs_dllHandle = 0;
-static int gs_dllCount = 0;
 
 static bool LoadHtmlHelpLibrary()
 {
-    if( !gs_dllCount )
+    wxPluginLibrary *lib = wxPluginManager::LoadLibrary( _T("HHCTRL.OCX"), wxDL_DEFAULT | wxDL_VERBATIM );
+
+    if( !lib->IsLoaded() )
     {
-        gs_dllHandle = wxDllLoader::LoadLibrary( "hhctrl.ocx" );
-        if( !gs_dllHandle )
-        {
-            wxLogError(_("MS HTML Help functions are unavailable because the MS HTML Help library is not installed on this machine. Please install it."));
-            return FALSE;
-        }
-        else
-        {
-            gs_dllCount = 1;
-            gs_htmlHelp = (HTMLHELP)wxDllLoader::GetSymbol( gs_dllHandle, HTMLHELP_NAME );
-
-            if( !gs_htmlHelp )
-            {
-                wxLogError(_("Failed to initialize MS HTML Help."));
-
-                wxDllLoader::UnloadLibrary(gs_dllHandle);
-                gs_dllHandle = 0;
-                gs_dllCount = 0;
-
-                return FALSE ;
-            }
-        }
+        wxLogError(_("MS HTML Help functions are unavailable because the MS HTML Help library is not installed on this machine. Please install it."));
+        return FALSE;
     }
     else
     {
-        ++gs_dllCount;
+        gs_htmlHelp = (HTMLHELP)lib->GetSymbol( HTMLHELP_NAME );
+
+        if( !gs_htmlHelp )
+        {
+            wxLogError(_("Failed to initialize MS HTML Help."));
+
+            lib->UnrefLib();
+            return FALSE ;
+        }
     }
 
     return TRUE;
@@ -98,10 +86,9 @@ static bool LoadHtmlHelpLibrary()
 
 static void UnloadHtmlHelpLibrary()
 {
-    if( gs_dllCount != 0 && !--gs_dllCount )
+    if( gs_htmlHelp )
     {
-        wxDllLoader::UnloadLibrary( gs_dllHandle );
-        gs_dllHandle = 0;
+        wxPluginManager::UnloadLibrary( _T("HHCTRL.OCX") );
         gs_htmlHelp = 0;
     }
 }
@@ -263,3 +250,5 @@ wxString wxCHMHelpController::GetValidFilename(const wxString& file) const
 }
 
 #endif // wxUSE_HELP
+
+// vi:sts=4:sw=4:et