try to clear the device/logical unit fog; remove unused and unsupported (an assertion...

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

diff --git a/src/msw/dialup.cpp b/src/msw/dialup.cpp
index 3c17c47e14fd2830f6d3d8f2911291cd97427ed7..66a5a034faabe0f6d0ae6a329d63db60492dd478 100644 (file)
--- a/src/msw/dialup.cpp
+++ b/src/msw/dialup.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

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

 // Purpose:     MSW implementation of network/dialup classes and functions
 // Author:      Vadim Zeitlin
 // Modified by:
 // Purpose:     MSW implementation of network/dialup classes and functions
 // Author:      Vadim Zeitlin
 // Modified by:


@@ -24,26 +24,54 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-// these functions require Win32
-#if defined(__WIN16__) && wxUSE_DIALUP_MANAGER
-    #undef wxUSE_DIALUP_MANAGER
-    #define wxUSE_DIALUP_MANAGER 0
-#endif // wxUSE_DIALUP_MANAGER && Win16
-

 #if wxUSE_DIALUP_MANAGER
 
 #if wxUSE_DIALUP_MANAGER
 

+#include "wx/dialup.h"
+

 #ifndef WX_PRECOMP
     #include "wx/log.h"
 #ifndef WX_PRECOMP
     #include "wx/log.h"

+    #include "wx/intl.h"
+    #include "wx/event.h"
+    #include "wx/app.h"
+    #include "wx/timer.h"
+    #include "wx/module.h"

 #endif
 
 #endif
 

+#include "wx/generic/choicdgg.h"
+

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

-#include "wx/net.h"
+wxDEFINE_EVENT( wxEVT_DIALUP_CONNECTED, wxDialUpEvent );
+wxDEFINE_EVENT( wxEVT_DIALUP_DISCONNECTED, wxDialUpEvent );
+
+// Doesn't yet compile under VC++ 4, BC++, Watcom C++,
+// Wine: no wininet.h
+#if (!defined(__BORLANDC__) || (__BORLANDC__>=0x550)) && \
+    (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION(0, 5)) && \
+    !defined(__GNUWIN32_OLD__) && \
+    !defined(__WINE__) && \
+    (!defined(__VISUALC__) || (__VISUALC__ >= 1020))

 
 #include <ras.h>
 #include <raserror.h>
 
 
 #include <ras.h>
 #include <raserror.h>
 

-#include "wx/msw/private.h"
+#include <wininet.h>
+
+// Not in VC++ 5
+#ifndef INTERNET_CONNECTION_LAN
+#define INTERNET_CONNECTION_LAN 2
+#endif
+#ifndef INTERNET_CONNECTION_PROXY
+#define INTERNET_CONNECTION_PROXY 4
+#endif
+
+// implemented in utils.cpp
+extern "C" WXDLLIMPEXP_BASE HWND
+wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc);
+
+static const wxChar *
+    wxMSWDIALUP_WNDCLASSNAME = wxT("_wxDialUpManager_Internal_Class");
+static const wxChar *gs_classForDialUpWindow = NULL;

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -51,6 +79,7 @@
 
 // this message is sent by the secondary thread when RAS status changes
 #define wxWM_RAS_STATUS_CHANGED (WM_USER + 10010)
 
 // this message is sent by the secondary thread when RAS status changes
 #define wxWM_RAS_STATUS_CHANGED (WM_USER + 10010)

+#define wxWM_RAS_DIALING_PROGRESS (WM_USER + 10011)

 
 // ----------------------------------------------------------------------------
 // types
 
 // ----------------------------------------------------------------------------
 // types


@@ -62,66 +91,79 @@
 // startup because of the missing DLL...
 
 #ifndef UNICODE
 // startup because of the missing DLL...
 
 #ifndef UNICODE

-    typedef DWORD (* RASDIAL)( LPRASDIALEXTENSIONS, LPCSTR, LPRASDIALPARAMSA, DWORD, LPVOID, LPHRASCONN );
-    typedef DWORD (* RASENUMCONNECTIONS)( LPRASCONNA, LPDWORD, LPDWORD );
-    typedef DWORD (* RASENUMENTRIES)( LPCSTR, LPCSTR, LPRASENTRYNAMEA, LPDWORD, LPDWORD );
-    typedef DWORD (* RASGETCONNECTSTATUS)( HRASCONN, LPRASCONNSTATUSA );
-    typedef DWORD (* RASGETERRORSTRING)( UINT, LPSTR, DWORD );
-    typedef DWORD (* RASHANGUP)( HRASCONN );
-    typedef DWORD (* RASGETPROJECTIONINFO)( HRASCONN, RASPROJECTION, LPVOID, LPDWORD );
-    typedef DWORD (* RASCREATEPHONEBOOKENTRY)( HWND, LPCSTR );
-    typedef DWORD (* RASEDITPHONEBOOKENTRY)( HWND, LPCSTR, LPCSTR );
-    typedef DWORD (* RASSETENTRYDIALPARAMS)( LPCSTR, LPRASDIALPARAMSA, BOOL );
-    typedef DWORD (* RASGETENTRYDIALPARAMS)( LPCSTR, LPRASDIALPARAMSA, LPBOOL );
-    typedef DWORD (* RASENUMDEVICES)( LPRASDEVINFOA, LPDWORD, LPDWORD );
-    typedef DWORD (* RASGETCOUNTRYINFO)( LPRASCTRYINFOA, LPDWORD );
-    typedef DWORD (* RASGETENTRYPROPERTIES)( LPCSTR, LPCSTR, LPRASENTRYA, LPDWORD, LPBYTE, LPDWORD );
-    typedef DWORD (* RASSETENTRYPROPERTIES)( LPCSTR, LPCSTR, LPRASENTRYA, DWORD, LPBYTE, DWORD );
-    typedef DWORD (* RASRENAMEENTRY)( LPCSTR, LPCSTR, LPCSTR );
-    typedef DWORD (* RASDELETEENTRY)( LPCSTR, LPCSTR );
-    typedef DWORD (* RASVALIDATEENTRYNAME)( LPCSTR, LPCSTR );
-    typedef DWORD (* RASCONNECTIONNOTIFICATION)( HRASCONN, HANDLE, DWORD );
-
-    static const char gs_funcSuffix = 'A';
+    typedef DWORD (APIENTRY * RASDIAL)( LPRASDIALEXTENSIONS, LPCSTR, LPRASDIALPARAMSA, DWORD, LPVOID, LPHRASCONN );
+    typedef DWORD (APIENTRY * RASENUMCONNECTIONS)( LPRASCONNA, LPDWORD, LPDWORD );
+    typedef DWORD (APIENTRY * RASENUMENTRIES)( LPCSTR, LPCSTR, LPRASENTRYNAMEA, LPDWORD, LPDWORD );
+    typedef DWORD (APIENTRY * RASGETCONNECTSTATUS)( HRASCONN, LPRASCONNSTATUSA );
+    typedef DWORD (APIENTRY * RASGETERRORSTRING)( UINT, LPSTR, DWORD );
+    typedef DWORD (APIENTRY * RASHANGUP)( HRASCONN );
+    typedef DWORD (APIENTRY * RASGETPROJECTIONINFO)( HRASCONN, RASPROJECTION, LPVOID, LPDWORD );
+    typedef DWORD (APIENTRY * RASCREATEPHONEBOOKENTRY)( HWND, LPCSTR );
+    typedef DWORD (APIENTRY * RASEDITPHONEBOOKENTRY)( HWND, LPCSTR, LPCSTR );
+    typedef DWORD (APIENTRY * RASSETENTRYDIALPARAMS)( LPCSTR, LPRASDIALPARAMSA, BOOL );
+    typedef DWORD (APIENTRY * RASGETENTRYDIALPARAMS)( LPCSTR, LPRASDIALPARAMSA, LPBOOL );
+    typedef DWORD (APIENTRY * RASENUMDEVICES)( LPRASDEVINFOA, LPDWORD, LPDWORD );
+    typedef DWORD (APIENTRY * RASGETCOUNTRYINFO)( LPRASCTRYINFOA, LPDWORD );
+    typedef DWORD (APIENTRY * RASGETENTRYPROPERTIES)( LPCSTR, LPCSTR, LPRASENTRYA, LPDWORD, LPBYTE, LPDWORD );
+    typedef DWORD (APIENTRY * RASSETENTRYPROPERTIES)( LPCSTR, LPCSTR, LPRASENTRYA, DWORD, LPBYTE, DWORD );
+    typedef DWORD (APIENTRY * RASRENAMEENTRY)( LPCSTR, LPCSTR, LPCSTR );
+    typedef DWORD (APIENTRY * RASDELETEENTRY)( LPCSTR, LPCSTR );
+    typedef DWORD (APIENTRY * RASVALIDATEENTRYNAME)( LPCSTR, LPCSTR );
+    typedef DWORD (APIENTRY * RASCONNECTIONNOTIFICATION)( HRASCONN, HANDLE, DWORD );
+
+    static const wxChar gs_funcSuffix = _T('A');

 #else // Unicode
 #else // Unicode

-    typedef DWORD (* RASDIAL)( LPRASDIALEXTENSIONS, LPCWSTR, LPRASDIALPARAMSW, DWORD, LPVOID, LPHRASCONN );
-    typedef DWORD (* RASENUMCONNECTIONS)( LPRASCONNW, LPDWORD, LPDWORD );
-    typedef DWORD (* RASENUMENTRIES)( LPCWSTR, LPCWSTR, LPRASENTRYNAMEW, LPDWORD, LPDWORD );
-    typedef DWORD (* RASGETCONNECTSTATUS)( HRASCONN, LPRASCONNSTATUSW );
-    typedef DWORD (* RASGETERRORSTRING)( UINT, LPWSTR, DWORD );
-    typedef DWORD (* RASHANGUP)( HRASCONN );
-    typedef DWORD (* RASGETPROJECTIONINFO)( HRASCONN, RASPROJECTION, LPVOID, LPDWORD );
-    typedef DWORD (* RASCREATEPHONEBOOKENTRY)( HWND, LPCWSTR );
-    typedef DWORD (* RASEDITPHONEBOOKENTRY)( HWND, LPCWSTR, LPCWSTR );
-    typedef DWORD (* RASSETENTRYDIALPARAMS)( LPCWSTR, LPRASDIALPARAMSW, BOOL );
-    typedef DWORD (* RASGETENTRYDIALPARAMS)( LPCWSTR, LPRASDIALPARAMSW, LPBOOL );
-    typedef DWORD (* RASENUMDEVICES)( LPRASDEVINFOW, LPDWORD, LPDWORD );
-    typedef DWORD (* RASGETCOUNTRYINFO)( LPRASCTRYINFOW, LPDWORD );
-    typedef DWORD (* RASGETENTRYPROPERTIES)( LPCWSTR, LPCWSTR, LPRASENTRYW, LPDWORD, LPBYTE, LPDWORD );
-    typedef DWORD (* RASSETENTRYPROPERTIES)( LPCWSTR, LPCWSTR, LPRASENTRYW, DWORD, LPBYTE, DWORD );
-    typedef DWORD (* RASRENAMEENTRY)( LPCWSTR, LPCWSTR, LPCWSTR );
-    typedef DWORD (* RASDELETEENTRY)( LPCWSTR, LPCWSTR );
-    typedef DWORD (* RASVALIDATEENTRYNAME)( LPCWSTR, LPCWSTR );
-    typedef DWORD (* RASCONNECTIONNOTIFICATION)( HRASCONN, HANDLE, DWORD );
-
-    static const char gs_funcSuffix = 'W';
+    typedef DWORD (APIENTRY * RASDIAL)( LPRASDIALEXTENSIONS, LPCWSTR, LPRASDIALPARAMSW, DWORD, LPVOID, LPHRASCONN );
+    typedef DWORD (APIENTRY * RASENUMCONNECTIONS)( LPRASCONNW, LPDWORD, LPDWORD );
+    typedef DWORD (APIENTRY * RASENUMENTRIES)( LPCWSTR, LPCWSTR, LPRASENTRYNAMEW, LPDWORD, LPDWORD );
+    typedef DWORD (APIENTRY * RASGETCONNECTSTATUS)( HRASCONN, LPRASCONNSTATUSW );
+    typedef DWORD (APIENTRY * RASGETERRORSTRING)( UINT, LPWSTR, DWORD );
+    typedef DWORD (APIENTRY * RASHANGUP)( HRASCONN );
+    typedef DWORD (APIENTRY * RASGETPROJECTIONINFO)( HRASCONN, RASPROJECTION, LPVOID, LPDWORD );
+    typedef DWORD (APIENTRY * RASCREATEPHONEBOOKENTRY)( HWND, LPCWSTR );
+    typedef DWORD (APIENTRY * RASEDITPHONEBOOKENTRY)( HWND, LPCWSTR, LPCWSTR );
+    typedef DWORD (APIENTRY * RASSETENTRYDIALPARAMS)( LPCWSTR, LPRASDIALPARAMSW, BOOL );
+    typedef DWORD (APIENTRY * RASGETENTRYDIALPARAMS)( LPCWSTR, LPRASDIALPARAMSW, LPBOOL );
+    typedef DWORD (APIENTRY * RASENUMDEVICES)( LPRASDEVINFOW, LPDWORD, LPDWORD );
+    typedef DWORD (APIENTRY * RASGETCOUNTRYINFO)( LPRASCTRYINFOW, LPDWORD );
+    typedef DWORD (APIENTRY * RASGETENTRYPROPERTIES)( LPCWSTR, LPCWSTR, LPRASENTRYW, LPDWORD, LPBYTE, LPDWORD );
+    typedef DWORD (APIENTRY * RASSETENTRYPROPERTIES)( LPCWSTR, LPCWSTR, LPRASENTRYW, DWORD, LPBYTE, DWORD );
+    typedef DWORD (APIENTRY * RASRENAMEENTRY)( LPCWSTR, LPCWSTR, LPCWSTR );
+    typedef DWORD (APIENTRY * RASDELETEENTRY)( LPCWSTR, LPCWSTR );
+    typedef DWORD (APIENTRY * RASVALIDATEENTRYNAME)( LPCWSTR, LPCWSTR );
+    typedef DWORD (APIENTRY * RASCONNECTIONNOTIFICATION)( HRASCONN, HANDLE, DWORD );
+
+    static const wxChar gs_funcSuffix = _T('W');

 #endif // ASCII/Unicode
 
 // structure passed to the secondary thread
 #endif // ASCII/Unicode
 
 // structure passed to the secondary thread

-struct wxRasThreadData
+struct WXDLLEXPORT wxRasThreadData

 {
     wxRasThreadData()
     {
         hWnd = 0;
 {
     wxRasThreadData()
     {
         hWnd = 0;

-        hEventRas = hEventQuit = INVALID_HANDLE_VALUE;
+        hEventRas =
+        hEventQuit = 0;

         dialUpManager = NULL;
     }
 
         dialUpManager = NULL;
     }
 

+    ~wxRasThreadData()
+    {
+        if ( hWnd )
+            DestroyWindow(hWnd);
+
+        if ( hEventQuit )
+            CloseHandle(hEventQuit);
+
+        if ( hEventRas )
+            CloseHandle(hEventRas);
+    }
+

     HWND    hWnd;       // window to send notifications to
     HWND    hWnd;       // window to send notifications to

-    HANDLE  hEventRas,  // event which RAS signals when status changes
-            hEventQuit; // event which we signal when we terminate
+    HANDLE  hEventRas,  // automatic event which RAS signals when status changes
+            hEventQuit; // manual event which we signal when we terminate

 
 

-    class WXDLLEXPORT wxDialUpManagerMSW *dialUpManager;  // the owner
+    class WXDLLIMPEXP_FWD_CORE wxDialUpManagerMSW *dialUpManager;  // the owner

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -137,6 +179,7 @@ public:
 
     // implement base class pure virtuals
     virtual bool IsOk() const;
 
     // implement base class pure virtuals
     virtual bool IsOk() const;

+    virtual size_t GetISPNames(wxArrayString& names) const;

     virtual bool Dial(const wxString& nameOfISP,
                       const wxString& username,
                       const wxString& password,
     virtual bool Dial(const wxString& nameOfISP,
                       const wxString& username,
                       const wxString& password,


@@ -144,8 +187,9 @@ public:
     virtual bool IsDialing() const;
     virtual bool CancelDialing();
     virtual bool HangUp();
     virtual bool IsDialing() const;
     virtual bool CancelDialing();
     virtual bool HangUp();

+    virtual bool IsAlwaysOnline() const;

     virtual bool IsOnline() const;
     virtual bool IsOnline() const;

-    virtual void SetOnlineStatus(bool isOnline = TRUE);
+    virtual void SetOnlineStatus(bool isOnline = true);

     virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
     virtual void DisableAutoCheckOnlineStatus();
     virtual void SetWellKnownHost(const wxString& hostname, int port);
     virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
     virtual void DisableAutoCheckOnlineStatus();
     virtual void SetWellKnownHost(const wxString& hostname, int port);


@@ -157,9 +201,11 @@ public:
 
     // for wxRasStatusWindowProc
     void OnConnectStatusChange();
 
     // for wxRasStatusWindowProc
     void OnConnectStatusChange();

+    void OnDialProgress(RASCONNSTATE rasconnstate, DWORD dwError);

 
     // for wxRasDialFunc
 
     // for wxRasDialFunc

-    void OnDialProgress(RASCONNSTATE rasconnstate, DWORD dwError);
+    static HWND GetRasWindow() { return ms_hwndRas; }
+    static void ResetRasWindow() { ms_hwndRas = NULL; }

     static wxDialUpManagerMSW *GetDialer() { return ms_dialer; }
 
 private:
     static wxDialUpManagerMSW *GetDialer() { return ms_dialer; }
 
 private:


@@ -170,13 +216,17 @@ private:
     static HRASCONN FindActiveConnection();
 
     // notify the application about status change
     static HRASCONN FindActiveConnection();
 
     // notify the application about status change

-    void NotifyApp(bool connected, bool fromOurselves = FALSE) const;
+    void NotifyApp(bool connected, bool fromOurselves = false) const;

 
     // destroy the thread data and the thread itself
     void CleanUpThreadData();
 
 
     // destroy the thread data and the thread itself
     void CleanUpThreadData();
 

+    // number of times EnableAutoCheckOnlineStatus() had been called minus the
+    // number of times DisableAutoCheckOnlineStatus() had been called
+    int m_autoCheckLevel;
+

     // timer used for polling RAS status
     // timer used for polling RAS status

-    class RasTimer : public wxTimer
+    class WXDLLEXPORT RasTimer : public wxTimer

     {
     public:
         RasTimer(wxDialUpManagerMSW *dialUpManager)
     {
     public:
         RasTimer(wxDialUpManagerMSW *dialUpManager)


@@ -186,6 +236,8 @@ private:
 
     private:
         wxDialUpManagerMSW *m_dialUpManager;
 
     private:
         wxDialUpManagerMSW *m_dialUpManager;

+
+        wxDECLARE_NO_COPY_CLASS(RasTimer);

     } m_timerStatusPolling;
 
     // thread handle for the thread sitting on connection change event
     } m_timerStatusPolling;
 
     // thread handle for the thread sitting on connection change event


@@ -193,16 +245,16 @@ private:
 
     // data used by this thread and our hidden window to send messages between
     // each other
 
     // data used by this thread and our hidden window to send messages between
     // each other

-    wxRasThreadData m_data;
+    wxRasThreadData *m_data;

 
 

-    // the handle of the connection we initiated or 0 if none
-    static HRASCONN ms_hRasConnection;
+    // the handle of rasapi32.dll when it's loaded
+    wxDynamicLibrary m_dllRas;

 
 

-    // the use count of rasapi32.dll
-    static int ms_nDllCount;
+    // the hidden window we use for passing messages between threads
+    static HWND ms_hwndRas;

 
 

-    // the handle of rasapi32.dll when it's loaded
-    static wxDllType ms_dllRas;
+    // the handle of the connection we initiated or 0 if none
+    static HRASCONN ms_hRasConnection;

 
     // the pointers to RAS functions
     static RASDIAL ms_pfnRasDial;
 
     // the pointers to RAS functions
     static RASDIAL ms_pfnRasDial;


@@ -235,8 +287,37 @@ private:
 
     // this flag tells us whether a call to RasDial() is in progress
     static wxDialUpManagerMSW *ms_dialer;
 
     // this flag tells us whether a call to RasDial() is in progress
     static wxDialUpManagerMSW *ms_dialer;

+
+    wxDECLARE_NO_COPY_CLASS(wxDialUpManagerMSW);
+};
+
+// module to destroy helper window created by wxDialUpManagerMSW
+class wxDialUpManagerModule : public wxModule
+{
+public:
+    bool OnInit() { return true; }
+    void OnExit()
+    {
+        HWND hwnd = wxDialUpManagerMSW::GetRasWindow();
+        if ( hwnd )
+        {
+            ::DestroyWindow(hwnd);
+            wxDialUpManagerMSW::ResetRasWindow();
+        }
+
+        if ( gs_classForDialUpWindow )
+        {
+            ::UnregisterClass(wxMSWDIALUP_WNDCLASSNAME, wxGetInstance());
+            gs_classForDialUpWindow = NULL;
+        }
+    }
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxDialUpManagerModule)

 };
 
 };
 

+IMPLEMENT_DYNAMIC_CLASS(wxDialUpManagerModule, wxModule)
+

 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------


@@ -260,8 +341,7 @@ static void WINAPI wxRasDialFunc(UINT unMsg,
 
 HRASCONN wxDialUpManagerMSW::ms_hRasConnection = 0;
 
 
 HRASCONN wxDialUpManagerMSW::ms_hRasConnection = 0;
 

-int wxDialUpManagerMSW::ms_nDllCount = 0;
-wxDllType wxDialUpManagerMSW::ms_dllRas = 0;
+HWND wxDialUpManagerMSW::ms_hwndRas = 0;

 
 RASDIAL wxDialUpManagerMSW::ms_pfnRasDial = 0;
 RASENUMCONNECTIONS wxDialUpManagerMSW::ms_pfnRasEnumConnections = 0;
 
 RASDIAL wxDialUpManagerMSW::ms_pfnRasDial = 0;
 RASENUMCONNECTIONS wxDialUpManagerMSW::ms_pfnRasEnumConnections = 0;


@@ -303,90 +383,81 @@ wxDialUpManager *wxDialUpManager::Create()
 #endif // VC++
 
 wxDialUpManagerMSW::wxDialUpManagerMSW()
 #endif // VC++
 
 wxDialUpManagerMSW::wxDialUpManagerMSW()

-                  : m_timerStatusPolling(this)
+                  : m_timerStatusPolling(this),
+                    m_dllRas(_T("RASAPI32"))

 {
     // initialize our data
 {
     // initialize our data

+    m_autoCheckLevel = 0;

     m_hThread = 0;
     m_hThread = 0;

+    m_data = new wxRasThreadData;

 
 

-    if ( !ms_nDllCount++ )
+    if ( !m_dllRas.IsLoaded() )

     {
     {

-        // load the RAS library
-        ms_dllRas = wxDllLoader::LoadLibrary("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 if ( !ms_pfnRasDial )
+    {
+        // 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;
+
+        // 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;                                                \
+            }
+
+        // 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

         {
         {

-            wxLogError(_("Dial up functions are unavailable because the "
-                         "remote access service (RAS) is not installed "
-                         "on this machine. Please install it."));
+            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);

         }
         }

-        else
-        {
-            // 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;
-
-            // 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(#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(#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);
-
-            // 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(RASGETENTRYDIALPARAMS, RasGetEntryDialParams);
-                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
+        // keep your preprocessor name space clean
+        #undef RESOLVE_RAS_FUNCTION
+        #undef RESOLVE_OPTIONAL_RAS_FUNCTION

 
 exit:
 
 exit:

-            if ( funcName )
-            {
-                wxLogError(_("The version of remote access service (RAS) "
-                             "installed on this machine is too old, please "
-                             "upgrade (the following required function is "
-                             "missing: %s)."), funcName);
-
-                wxDllLoader::UnloadLibrary(ms_dllRas);
-                ms_dllRas = 0;
-                ms_nDllCount = 0;
-
-                return;
-            }
+        if ( funcName )
+        {
+            wxLogError(_("The version of remote access service (RAS) installed "
+                          "on this machine is too old, please upgrade (the "
+                          "following required function is missing: %s)."),
+                       funcName);
+            m_dllRas.Unload();
+            return;

         }
     }
 
         }
     }
 


@@ -397,13 +468,6 @@ exit:
 wxDialUpManagerMSW::~wxDialUpManagerMSW()
 {
     CleanUpThreadData();
 wxDialUpManagerMSW::~wxDialUpManagerMSW()
 {
     CleanUpThreadData();

-
-    if ( !--ms_nDllCount )
-    {
-        // unload the RAS library
-        wxDllLoader::UnloadLibrary(ms_dllRas);
-        ms_dllRas = 0;
-    }

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


@@ -422,8 +486,8 @@ wxString wxDialUpManagerMSW::GetErrorString(DWORD error)
 
         default:
             {
 
         default:
             {

-                wxLogSysError(dwRet, _("Failed to retrieve text of RAS "
-                                       "error message"));
+                wxLogSysError(dwRet,
+                      _("Failed to retrieve text of RAS error message"));

 
                 wxString msg;
                 msg.Printf(_("unknown error (error code %08x)."), error);
 
                 wxString msg;
                 msg.Printf(_("unknown error (error code %08x)."), error);


@@ -432,7 +496,7 @@ wxString wxDialUpManagerMSW::GetErrorString(DWORD error)
 
         case 0:
             // we want the error message to start from a lower case letter
 
         case 0:
             // we want the error message to start from a lower case letter

-            buffer[0] = wxTolower(buffer[0]);
+            buffer[0] = (wxChar)wxTolower(buffer[0]);

 
             return wxString(buffer);
     }
 
             return wxString(buffer);
     }


@@ -477,9 +541,9 @@ HRASCONN wxDialUpManagerMSW::FindActiveConnection()
         }
         else
         {
         }
         else
         {

-            // an error occured
+            // an error occurred

             wxLogError(_("Cannot find active dialup connection: %s"),
             wxLogError(_("Cannot find active dialup connection: %s"),

-                       GetErrorString(dwRet));
+                       GetErrorString(dwRet).c_str());

             return 0;
         }
     }
             return 0;
         }
     }


@@ -499,8 +563,7 @@ HRASCONN wxDialUpManagerMSW::FindActiveConnection()
             // connection) - the warning is really needed because this function
             // is used, for example, to select the connection to hang up and so
             // we may hang up the wrong connection here...
             // connection) - the warning is really needed because this function
             // is used, for example, to select the connection to hang up and so
             // we may hang up the wrong connection here...

-            wxLogWarning(_("Several active dialup connections found, "
-                           "choosing one randomly."));
+            wxLogWarning(_("Several active dialup connections found, choosing one randomly."));

             // fall through
 
         case 1:
             // fall through
 
         case 1:


@@ -517,9 +580,15 @@ void wxDialUpManagerMSW::CleanUpThreadData()
 {
     if ( m_hThread )
     {
 {
     if ( m_hThread )
     {

-        if ( !SetEvent(m_data.hEventQuit) )
+        if ( !SetEvent(m_data->hEventQuit) )
+        {
+            wxLogLastError(_T("SetEvent(RasThreadQuit)"));
+        }
+        else // sent quit request to the background thread

         {
         {

-            wxLogLastError("SetEvent(RasThreadQuit)");
+            // the thread still needs m_data so we can't free it here, rather
+            // let the thread do it itself
+            m_data = NULL;

         }
 
         CloseHandle(m_hThread);
         }
 
         CloseHandle(m_hThread);


@@ -527,25 +596,10 @@ void wxDialUpManagerMSW::CleanUpThreadData()
         m_hThread = 0;
     }
 
         m_hThread = 0;
     }
 

-    if ( m_data.hWnd )
+    if ( m_data )

     {
     {

-        DestroyWindow(m_data.hWnd);
-
-        m_data.hWnd = 0;
-    }
-
-    if ( m_data.hEventQuit )
-    {
-        CloseHandle(m_data.hEventQuit);
-
-        m_data.hEventQuit = 0;
-    }
-
-    if ( m_data.hEventRas )
-    {
-        CloseHandle(m_data.hEventRas);
-
-        m_data.hEventRas = 0;
+        delete m_data;
+        m_data = NULL;

     }
 }
 
     }
 }
 


@@ -601,7 +655,7 @@ void wxDialUpManagerMSW::OnDialProgress(RASCONNSTATE rasconnstate,
     if ( dwError )
     {
         wxLogError(_("Failed to establish dialup connection: %s"),
     if ( dwError )
     {
         wxLogError(_("Failed to establish dialup connection: %s"),

-                   GetErrorString(dwError));
+                   GetErrorString(dwError).c_str());

 
         // we should still call RasHangUp() if we got a non 0 connection
         if ( ms_hRasConnection )
 
         // we should still call RasHangUp() if we got a non 0 connection
         if ( ms_hRasConnection )


@@ -612,14 +666,14 @@ void wxDialUpManagerMSW::OnDialProgress(RASCONNSTATE rasconnstate,
 
         ms_dialer = NULL;
 
 
         ms_dialer = NULL;
 

-        NotifyApp(FALSE /* !connected */, TRUE /* we dialed ourselves */);
+        NotifyApp(false /* !connected */, true /* we dialed ourselves */);

     }
     else if ( rasconnstate == RASCS_Connected )
     {
     }
     else if ( rasconnstate == RASCS_Connected )
     {

-        ms_isConnected = TRUE;
+        ms_isConnected = true;

         ms_dialer = NULL;
 
         ms_dialer = NULL;
 

-        NotifyApp(TRUE /* connected */, TRUE /* we dialed ourselves */);
+        NotifyApp(true /* connected */, true /* we dialed ourselves */);

     }
 }
 
     }
 }
 


@@ -629,7 +683,64 @@ void wxDialUpManagerMSW::OnDialProgress(RASCONNSTATE rasconnstate,
 
 bool wxDialUpManagerMSW::IsOk() const
 {
 
 bool wxDialUpManagerMSW::IsOk() const
 {

-    return ms_dllRas != 0;
+    return m_dllRas.IsLoaded();
+}
+
+size_t wxDialUpManagerMSW::GetISPNames(wxArrayString& names) const
+{
+    // fetch the entries
+    DWORD size = sizeof(RASENTRYNAME);
+    RASENTRYNAME *rasEntries = (RASENTRYNAME *)malloc(size);
+    rasEntries->dwSize = sizeof(RASENTRYNAME);
+
+    DWORD nEntries;
+    DWORD dwRet;
+    do
+    {
+        dwRet = ms_pfnRasEnumEntries
+                  (
+                   NULL,                // reserved
+                   NULL,                // default phone book (or all)
+                   rasEntries,          // [out] buffer for the entries
+                   &size,               // [in/out] size of the buffer
+                   &nEntries            // [out] number of entries fetched
+                  );
+
+        if ( dwRet == ERROR_BUFFER_TOO_SMALL )
+        {
+            // reallocate the buffer
+            void *n  = realloc(rasEntries, size);
+            if (n == NULL)
+            {
+                free(rasEntries);
+                return 0;
+            }
+            rasEntries = (RASENTRYNAME *)n;
+        }
+        else if ( dwRet != 0 )
+        {
+            // some other error - abort
+            wxLogError(_("Failed to get ISP names: %s"),
+                       GetErrorString(dwRet).c_str());
+
+            free(rasEntries);
+
+            return 0u;
+        }
+    }
+    while ( dwRet != 0 );
+
+    // process them
+    names.Empty();
+    for ( size_t n = 0; n < (size_t)nEntries; n++ )
+    {
+        names.Add(rasEntries[n].szEntryName);
+    }
+
+    free(rasEntries);
+
+    // return the number of entries
+    return names.GetCount();

 }
 
 bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
 }
 
 bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,


@@ -637,25 +748,96 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
                               const wxString& password,
                               bool async)
 {
                               const wxString& password,
                               bool async)
 {

-    wxCHECK_MSG( IsOk(), FALSE, _T("using uninitialized wxDialUpManager") );
+    // check preconditions
+    wxCHECK_MSG( IsOk(), false, wxT("using uninitialized wxDialUpManager") );

 
     if ( ms_hRasConnection )
     {
 
     if ( ms_hRasConnection )
     {

-        wxFAIL_MSG(_T("there is already an active connection"));
+        wxFAIL_MSG(wxT("there is already an active connection"));
+
+        return true;
+    }
+
+    // get the default ISP if none given
+    wxString entryName(nameOfISP);
+    if ( !entryName )
+    {
+        wxArrayString names;
+        size_t count = GetISPNames(names);
+        switch ( count )
+        {
+            case 0:
+                // no known ISPs, abort
+                wxLogError(_("Failed to connect: no ISP to dial."));
+
+                return false;
+
+            case 1:
+                // only one ISP, choose it
+                entryName = names[0u];
+                break;

 
 

-        return TRUE;
+            default:
+                // several ISPs, let the user choose
+                {
+                    wxString *strings = new wxString[count];
+                    for ( size_t i = 0; i < count; i++ )
+                    {
+                        strings[i] = names[i];
+                    }
+
+                    entryName = wxGetSingleChoice
+                                (
+                                 _("Choose ISP to dial"),
+                                 _("Please choose which ISP do you want to connect to"),
+                                 count,
+                                 strings
+                                );
+
+                    delete [] strings;
+
+                    if ( !entryName )
+                    {
+                        // cancelled by user
+                        return false;
+                    }
+                }
+        }

     }
 
     RASDIALPARAMS rasDialParams;
     rasDialParams.dwSize = sizeof(rasDialParams);
     }
 
     RASDIALPARAMS rasDialParams;
     rasDialParams.dwSize = sizeof(rasDialParams);

-    strncpy(rasDialParams.szEntryName, nameOfISP, RAS_MaxEntryName);
+    wxStrlcpy(rasDialParams.szEntryName, entryName.c_str(), RAS_MaxEntryName);
+
+    // do we have the username and password?
+    if ( !username || !password )
+    {
+        BOOL gotPassword;
+        DWORD dwRet = ms_pfnRasGetEntryDialParams
+                      (
+                       NULL,            // default phonebook
+                       &rasDialParams,  // [in/out] the params of this entry
+                       &gotPassword     // [out] did we get password?
+                      );
+
+        if ( dwRet != 0 )
+        {
+            wxLogError(_("Failed to connect: missing username/password."));
+
+            return false;
+        }
+    }
+    else
+    {
+        wxStrlcpy(rasDialParams.szUserName, username.c_str(), UNLEN);
+        wxStrlcpy(rasDialParams.szPassword, password.c_str(), PWLEN);
+    }
+
+    // default values for other fields

     rasDialParams.szPhoneNumber[0] = '\0';
     rasDialParams.szCallbackNumber[0] = '\0';
     rasDialParams.szCallbackNumber[0] = '\0';
 
     rasDialParams.szPhoneNumber[0] = '\0';
     rasDialParams.szCallbackNumber[0] = '\0';
     rasDialParams.szCallbackNumber[0] = '\0';
 

-    strncpy(rasDialParams.szUserName, username, UNLEN);
-    strncpy(rasDialParams.szPassword, password, PWLEN);
-

     rasDialParams.szDomain[0] = '*';
     rasDialParams.szDomain[1] = '\0';
 
     rasDialParams.szDomain[0] = '*';
     rasDialParams.szDomain[1] = '\0';
 


@@ -688,20 +870,24 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
 
     DWORD dwRet = ms_pfnRasDial
                   (
 
     DWORD dwRet = ms_pfnRasDial
                   (

-                   (LPRASDIALEXTENSIONS)NULL,   // no extended features
-                   NULL,                  // default phone book file (NT only)
+                   NULL,                    // no extended features
+                   NULL,                    // default phone book file (NT only)

                    &rasDialParams,
                    &rasDialParams,

-                   0,                     // use callback for notifications
-                   async ? wxRasDialFunc  // the callback
-                         : 0,             // no notifications - sync operation
+                   0,                       // use callback for notifications
+                   async ? (void *)wxRasDialFunc  // cast needed for gcc 3.1
+                         : 0,               // no notifications, sync operation

                    &ms_hRasConnection
                   );
 
     if ( dwRet != 0 )
     {
                    &ms_hRasConnection
                   );
 
     if ( dwRet != 0 )
     {

-        wxLogError(_("Failed to %s dialup connection: %s"),
-                   async ? _("initiate") : _("establish"),
-                   GetErrorString(dwRet));
+        // can't pass a wxWCharBuffer through ( ... )
+        if ( async )
+            wxLogError(_("Failed to initiate dialup connection: %s"),
+                       GetErrorString(dwRet).c_str());
+        else
+            wxLogError(_("Failed to establish dialup connection: %s"),
+                       GetErrorString(dwRet).c_str());

 
         // we should still call RasHangUp() if we got a non 0 connection
         if ( ms_hRasConnection )
 
         // we should still call RasHangUp() if we got a non 0 connection
         if ( ms_hRasConnection )


@@ -712,16 +898,16 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
 
         ms_dialer = NULL;
 
 
         ms_dialer = NULL;
 

-        return FALSE;
+        return false;

     }
 
     // for async dialing, we're not yet connected
     if ( !async )
     {
     }
 
     // for async dialing, we're not yet connected
     if ( !async )
     {

-        ms_isConnected = TRUE;
+        ms_isConnected = true;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 bool wxDialUpManagerMSW::IsDialing() const
 }
 
 bool wxDialUpManagerMSW::IsDialing() const


@@ -734,10 +920,10 @@ bool wxDialUpManagerMSW::CancelDialing()
     if ( !GetDialer() )
     {
         // silently ignore
     if ( !GetDialer() )
     {
         // silently ignore

-        return FALSE;
+        return false;

     }
 
     }
 

-    wxASSERT_MSG( ms_hRasConnection, _T("dialing but no connection?") );
+    wxASSERT_MSG( ms_hRasConnection, wxT("dialing but no connection?") );

 
     ms_dialer = NULL;
 
 
     ms_dialer = NULL;
 


@@ -746,7 +932,7 @@ bool wxDialUpManagerMSW::CancelDialing()
 
 bool wxDialUpManagerMSW::HangUp()
 {
 
 bool wxDialUpManagerMSW::HangUp()
 {

-    wxCHECK_MSG( IsOk(), FALSE, _T("using uninitialized wxDialUpManager") );
+    wxCHECK_MSG( IsOk(), false, wxT("using uninitialized wxDialUpManager") );

 
     // we may terminate either the connection we initiated or another one which
     // is active now
 
     // we may terminate either the connection we initiated or another one which
     // is active now


@@ -766,24 +952,70 @@ bool wxDialUpManagerMSW::HangUp()
     {
         wxLogError(_("Cannot hang up - no active dialup connection."));
 
     {
         wxLogError(_("Cannot hang up - no active dialup connection."));
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    DWORD dwRet = ms_pfnRasHangUp(hRasConn);
-    if ( dwRet != 0 )
+    // note that it's not an error if the connection had been already
+    // terminated
+    const DWORD dwRet = ms_pfnRasHangUp(hRasConn);
+    if ( dwRet != 0 && dwRet != ERROR_NO_CONNECTION )

     {
         wxLogError(_("Failed to terminate the dialup connection: %s"),
     {
         wxLogError(_("Failed to terminate the dialup connection: %s"),

-                   GetErrorString(dwRet));
+                   GetErrorString(dwRet).c_str());

     }
 
     }
 

-    ms_isConnected = FALSE;
+    ms_isConnected = false;

 
 

-    return TRUE;
+    return true;
+}
+
+bool wxDialUpManagerMSW::IsAlwaysOnline() const
+{
+    // assume no permanent connection by default
+    bool isAlwaysOnline = false;
+
+    // try to use WinInet functions
+
+    // 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.
+
+    wxDynamicLibrary hDll(_T("WININET"));
+    if ( hDll.IsLoaded() )
+    {
+        typedef BOOL (WINAPI *INTERNETGETCONNECTEDSTATE)(LPDWORD, DWORD);
+        INTERNETGETCONNECTEDSTATE pfnInternetGetConnectedState;
+
+        #define RESOLVE_FUNCTION(type, name) \
+            pfn##name = (type)hDll.GetSymbol(_T(#name))
+
+        RESOLVE_FUNCTION(INTERNETGETCONNECTEDSTATE, InternetGetConnectedState);
+
+        if ( pfnInternetGetConnectedState )
+        {
+            DWORD flags = 0;
+            if ( pfnInternetGetConnectedState(&flags, 0 /* reserved */) )
+            {
+                // there is some connection to the net, see of which type
+                isAlwaysOnline = (flags & (INTERNET_CONNECTION_LAN |
+                                           INTERNET_CONNECTION_PROXY)) != 0;
+            }
+            //else: no Internet connection at all
+        }
+    }
+
+    return isAlwaysOnline;

 }
 
 bool wxDialUpManagerMSW::IsOnline() const
 {
 }
 
 bool wxDialUpManagerMSW::IsOnline() const
 {

-    wxCHECK_MSG( IsOk(), FALSE, _T("using uninitialized wxDialUpManager") );
+    wxCHECK_MSG( IsOk(), false, wxT("using uninitialized wxDialUpManager") );
+
+    if ( IsAlwaysOnline() )
+    {
+        // always => now
+        return true;
+    }

 
     if ( ms_userSpecifiedOnlineStatus != -1 )
     {
 
     if ( ms_userSpecifiedOnlineStatus != -1 )
     {


@@ -792,21 +1024,27 @@ bool wxDialUpManagerMSW::IsOnline() const
     }
     else
     {
     }
     else
     {

-        // return TRUE if there is at least one active connection
+        // return true if there is at least one active connection

         return FindActiveConnection() != 0;
     }
 }
 
 void wxDialUpManagerMSW::SetOnlineStatus(bool isOnline)
 {
         return FindActiveConnection() != 0;
     }
 }
 
 void wxDialUpManagerMSW::SetOnlineStatus(bool isOnline)
 {

-    wxCHECK_RET( IsOk(), _T("using uninitialized wxDialUpManager") );
+    wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );

 
     ms_userSpecifiedOnlineStatus = isOnline;
 }
 
 bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
 {
 
     ms_userSpecifiedOnlineStatus = isOnline;
 }
 
 bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
 {

-    wxCHECK_MSG( IsOk(), FALSE, _T("using uninitialized wxDialUpManager") );
+    wxCHECK_MSG( IsOk(), false, wxT("using uninitialized wxDialUpManager") );
+
+    if ( m_autoCheckLevel++ )
+    {
+        // already checking
+        return true;
+    }

 
     bool ok = ms_pfnRasConnectionNotification != 0;
 
 
     bool ok = ms_pfnRasConnectionNotification != 0;
 


@@ -818,22 +1056,13 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
         // first, see if we don't have this thread already running
         if ( m_hThread != 0 )
         {
         // first, see if we don't have this thread already running
         if ( m_hThread != 0 )
         {

-            DWORD dwSuspendCount = 2;
-            while ( dwSuspendCount > 1 )
-            {
-                dwSuspendCount = ResumeThread(m_hThread);
-                if ( dwSuspendCount == (DWORD)-1 )
-                {
-                    wxLogLastError("ResumeThread(RasThread)");
+            if ( ::ResumeThread(m_hThread) != (DWORD)-1 )
+                return true;

 
 

-                    ok = FALSE;
-                }
-            }
+            // we're leaving a zombie thread... but what else can we do?
+            wxLogLastError(wxT("ResumeThread(RasThread)"));

 
 

-            if ( ok )
-            {
-                return TRUE;
-            }
+            ok = false;

         }
     }
 
         }
     }
 


@@ -843,67 +1072,70 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
     if ( ok )
     {
         // first create an event to wait on
     if ( ok )
     {
         // first create an event to wait on

-        m_data.hEventRas = CreateEvent
-                           (
+        m_data->hEventRas = ::CreateEvent
+                            (

                              NULL,      // security attribute (default)
                              NULL,      // security attribute (default)

-                             FALSE,     // manual reset (not)
+                             FALSE,     // manual reset (no, it is automatic)

                              FALSE,     // initial state (not signaled)
                              NULL       // name (no)
                              FALSE,     // initial state (not signaled)
                              NULL       // name (no)

-                           );
-        if ( !m_data.hEventRas )
+                            );
+        if ( !m_data->hEventRas )

         {
         {

-            wxLogLastError("CreateEvent(RasStatus)");
+            wxLogLastError(wxT("CreateEvent(RasStatus)"));

 
 

-            ok = FALSE;
+            ok = false;

         }
     }
 
     if ( ok )
     {
         }
     }
 
     if ( ok )
     {

-        // create the event we use to quit the thread
-        m_data.hEventQuit = CreateEvent(NULL, FALSE, FALSE, NULL);
-        if ( !m_data.hEventQuit )
+        // create the event we use to quit the thread: using a manual event
+        // here avoids problems with missing the event if wxDialUpManagerMSW
+        // is created and destroyed immediately, before wxRasStatusWindowProc
+        // starts waiting on the event
+        m_data->hEventQuit = ::CreateEvent
+                             (
+                                NULL,   // default security
+                                TRUE,   // manual event
+                                FALSE,  // initially non signalled
+                                NULL    // nameless
+                             );
+        if ( !m_data->hEventQuit )

         {
         {

-            wxLogLastError("CreateEvent(RasThreadQuit)");
+            wxLogLastError(wxT("CreateEvent(RasThreadQuit)"));

 
             CleanUpThreadData();
 
 
             CleanUpThreadData();
 

-            ok = FALSE;
+            ok = false;

         }
     }
 
         }
     }
 

-    if ( ok )
+    if ( ok && !ms_hwndRas )

     {
         // create a hidden window to receive notification about connections
         // status change
     {
         // create a hidden window to receive notification about connections
         // status change

-        extern wxChar wxPanelClassName[];
-        m_data.hWnd = ::CreateWindow(wxPanelClassName, NULL,
-                                     0, 0, 0, 0,
-                                     0, NULL,
-                                     (HMENU)NULL, wxGetInstance(), 0);
-        if ( !m_data.hWnd )
+        ms_hwndRas = wxCreateHiddenWindow
+                     (
+                        &gs_classForDialUpWindow,
+                        wxMSWDIALUP_WNDCLASSNAME,
+                        wxRasStatusWindowProc
+                     );
+        if ( !ms_hwndRas )

         {
         {

-            wxLogLastError("CreateWindow(RasHiddenWindow)");
+            wxLogLastError(wxT("CreateWindow(RasHiddenWindow)"));

 
             CleanUpThreadData();
 
 
             CleanUpThreadData();
 

-            ok = FALSE;
+            ok = false;

         }
         }

-
-        // and subclass it
-        FARPROC windowProc = MakeProcInstance
-                             (
-                              (FARPROC)wxRasStatusWindowProc,
-                              wxGetInstance()
-                             );
-
-        ::SetWindowLong(m_data.hWnd, GWL_WNDPROC, (LONG) windowProc);

     }
 
     }
 

+    m_data->hWnd = ms_hwndRas;
+

     if ( ok )
     {
         // start the secondary thread
     if ( ok )
     {
         // start the secondary thread

-        m_data.dialUpManager = this;
+        m_data->dialUpManager = this;

 
         DWORD tid;
         m_hThread = CreateThread
 
         DWORD tid;
         m_hThread = CreateThread


@@ -911,14 +1143,14 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
                      NULL,
                      0,
                      (LPTHREAD_START_ROUTINE)wxRasMonitorThread,
                      NULL,
                      0,
                      (LPTHREAD_START_ROUTINE)wxRasMonitorThread,

-                     (void *)&m_data,
+                     (void *)m_data,

                      0,
                      &tid
                     );
 
         if ( !m_hThread )
         {
                      0,
                      &tid
                     );
 
         if ( !m_hThread )
         {

-            wxLogLastError("CreateThread(RasStatusThread)");
+            wxLogLastError(wxT("CreateThread(RasStatusThread)"));

 
             CleanUpThreadData();
         }
 
             CleanUpThreadData();
         }


@@ -930,20 +1162,20 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
         DWORD dwRet = ms_pfnRasConnectionNotification
                       (
                         (HRASCONN)INVALID_HANDLE_VALUE,
         DWORD dwRet = ms_pfnRasConnectionNotification
                       (
                         (HRASCONN)INVALID_HANDLE_VALUE,

-                        m_data.hEventRas,
+                        m_data->hEventRas,

                         3 /* RASCN_Connection | RASCN_Disconnection */
                       );
 
         if ( dwRet != 0 )
         {
                         3 /* RASCN_Connection | RASCN_Disconnection */
                       );
 
         if ( dwRet != 0 )
         {

-            wxLogDebug(_T("RasConnectionNotification() failed: %s"),
-                       GetErrorString(dwRet));
+            wxLogDebug(wxT("RasConnectionNotification() failed: %s"),
+                       GetErrorString(dwRet).c_str());

 
             CleanUpThreadData();
         }
         else
         {
 
             CleanUpThreadData();
         }
         else
         {

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 


@@ -957,19 +1189,25 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
     }
     m_timerStatusPolling.Start(nSeconds * 1000);
 
     }
     m_timerStatusPolling.Start(nSeconds * 1000);
 

-    return TRUE;
+    return true;

 }
 
 void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
 {
 }
 
 void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
 {

-    wxCHECK_RET( IsOk(), _T("using uninitialized wxDialUpManager") );
+    wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );
+
+    if ( --m_autoCheckLevel != 0 )
+    {
+        // still checking
+        return;
+    }

 
     if ( m_hThread )
     {
         // we have running secondary thread, it's just enough to suspend it
         if ( SuspendThread(m_hThread) == (DWORD)-1 )
         {
 
     if ( m_hThread )
     {
         // we have running secondary thread, it's just enough to suspend it
         if ( SuspendThread(m_hThread) == (DWORD)-1 )
         {

-            wxLogLastError("SuspendThread(RasThread)");
+            wxLogLastError(wxT("SuspendThread(RasThread)"));

         }
     }
     else
         }
     }
     else


@@ -986,7 +1224,7 @@ void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
 void wxDialUpManagerMSW::SetWellKnownHost(const wxString& WXUNUSED(hostname),
                                           int WXUNUSED(port))
 {
 void wxDialUpManagerMSW::SetWellKnownHost(const wxString& WXUNUSED(hostname),
                                           int WXUNUSED(port))
 {

-    wxCHECK_RET( IsOk(), _T("using uninitialized wxDialUpManager") );
+    wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );

 
     // nothing to do - we don't use this
 }
 
     // nothing to do - we don't use this
 }


@@ -994,7 +1232,7 @@ void wxDialUpManagerMSW::SetWellKnownHost(const wxString& WXUNUSED(hostname),
 void wxDialUpManagerMSW::SetConnectCommand(const wxString& WXUNUSED(dial),
                                            const wxString& WXUNUSED(hangup))
 {
 void wxDialUpManagerMSW::SetConnectCommand(const wxString& WXUNUSED(dial),
                                            const wxString& WXUNUSED(hangup))
 {

-    wxCHECK_RET( IsOk(), _T("using uninitialized wxDialUpManager") );
+    wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );

 
     // nothing to do - we don't use this
 }
 
     // nothing to do - we don't use this
 }


@@ -1009,10 +1247,10 @@ static DWORD wxRasMonitorThread(wxRasThreadData *data)
     handles[0] = data->hEventRas;
     handles[1] = data->hEventQuit;
 
     handles[0] = data->hEventRas;
     handles[1] = data->hEventQuit;
 

-    bool cont = TRUE;
+    bool cont = true;

     while ( cont )
     {
     while ( cont )
     {

-        DWORD dwRet = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
+        DWORD dwRet = ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);

 
         switch ( dwRet )
         {
 
         switch ( dwRet )
         {


@@ -1023,39 +1261,79 @@ static DWORD wxRasMonitorThread(wxRasThreadData *data)
                 break;
 
             case WAIT_OBJECT_0 + 1:
                 break;
 
             case WAIT_OBJECT_0 + 1:

-                cont = FALSE;
+                cont = false;

                 break;
 
                 break;
 

+            default:
+                wxFAIL_MSG( _T("unexpected return of WaitForMultipleObjects()") );
+                // fall through
+

             case WAIT_FAILED:
             case WAIT_FAILED:

-                wxLogLastError("WaitForMultipleObjects(RasMonitor)");
-                break;
+#ifdef __WXDEBUG__
+                // using wxLogLastError() from here is dangerous: we risk to
+                // deadlock the main thread if wxLog sends output to GUI
+                DWORD err = GetLastError();
+                wxMessageOutputDebug dbg;
+                dbg.Printf
+                (
+                    wxT("WaitForMultipleObjects(RasMonitor) failed: 0x%08lx (%s)"),
+                    err,
+                    wxSysErrorMsg(err)
+                );
+#endif // __WXDEBUG__
+
+                // no sense in continuing, who knows if the handles we're
+                // waiting for even exist yet...
+                return (DWORD)-1;

         }
     }
 
         }
     }
 

+    // we don't need it any more now and if this thread ran, it is our
+    // responsability to free the data
+    delete data;
+

     return 0;
 }
 
 static LRESULT APIENTRY wxRasStatusWindowProc(HWND hWnd, UINT message,
                                               WPARAM wParam, LPARAM lParam)
 {
     return 0;
 }
 
 static LRESULT APIENTRY wxRasStatusWindowProc(HWND hWnd, UINT message,
                                               WPARAM wParam, LPARAM lParam)
 {

-    if ( message == wxWM_RAS_STATUS_CHANGED )
+    switch ( message )

     {
     {

-        wxRasThreadData *data = (wxRasThreadData *)lParam;
-        data->dialUpManager->OnConnectStatusChange();
+        case wxWM_RAS_STATUS_CHANGED:
+            {
+                wxRasThreadData *data = (wxRasThreadData *)lParam;
+                data->dialUpManager->OnConnectStatusChange();
+            }
+            break;
+
+        case wxWM_RAS_DIALING_PROGRESS:
+            {
+                wxDialUpManagerMSW *dialMan = wxDialUpManagerMSW::GetDialer();
+
+                dialMan->OnDialProgress((RASCONNSTATE)wParam, lParam);
+            }
+            break;
+
+        default:
+            return ::DefWindowProc(hWnd, message, wParam, lParam);

     }
 
     return 0;
 }
 
     }
 
     return 0;
 }
 

-static void WINAPI wxRasDialFunc(UINT unMsg,
+static void WINAPI wxRasDialFunc(UINT WXUNUSED(unMsg),

                                  RASCONNSTATE rasconnstate,
                                  DWORD dwError)
 {
     wxDialUpManagerMSW *dialUpManager = wxDialUpManagerMSW::GetDialer();
 
                                  RASCONNSTATE rasconnstate,
                                  DWORD dwError)
 {
     wxDialUpManagerMSW *dialUpManager = wxDialUpManagerMSW::GetDialer();
 

-    wxCHECK_RET( dialUpManager, _T("who started to dial then?") );
+    wxCHECK_RET( dialUpManager, wxT("who started to dial then?") );

 
 

-    dialUpManager->OnDialProgress(rasconnstate, dwError);
+    SendMessage(wxDialUpManagerMSW::GetRasWindow(), wxWM_RAS_DIALING_PROGRESS,
+                rasconnstate, dwError);

 }
 
 }
 

+#endif // __BORLANDC__
+

 #endif // wxUSE_DIALUP_MANAGER
 #endif // wxUSE_DIALUP_MANAGER