don't include generic/statusbr.h directly

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

diff --git a/src/msw/dialup.cpp b/src/msw/dialup.cpp
index 595563115d8b1a05c1ac2229751fa11563e83703..76ad747b72e73499433f4adc78378440eda2ed41 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,37 +24,31 @@
     #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"
     #include "wx/intl.h"
     #include "wx/event.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/timer.h"
-#include "wx/app.h"

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

-#include "wx/dialup.h"

 
 DEFINE_EVENT_TYPE(wxEVT_DIALUP_CONNECTED)
 DEFINE_EVENT_TYPE(wxEVT_DIALUP_DISCONNECTED)
 
 // Doesn't yet compile under VC++ 4, BC++, Watcom C++,
 // Wine: no wininet.h
 
 DEFINE_EVENT_TYPE(wxEVT_DIALUP_CONNECTED)
 DEFINE_EVENT_TYPE(wxEVT_DIALUP_DISCONNECTED)
 
 // Doesn't yet compile under VC++ 4, BC++, Watcom C++,
 // Wine: no wininet.h

-#if !defined(__BORLANDC__) && \
+#if (!defined(__BORLANDC__) || (__BORLANDC__>=0x550)) && \

     (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION(0, 5)) && \
     !defined(__GNUWIN32_OLD__) && \
     (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION(0, 5)) && \
     !defined(__GNUWIN32_OLD__) && \

-    !defined(__WATCOMC__) && \
-    !defined(__WXWINE__) && \

     !defined(__WINE__) && \
     (!defined(__VISUALC__) || (__VISUALC__ >= 1020))
 
     !defined(__WINE__) && \
     (!defined(__VISUALC__) || (__VISUALC__ >= 1020))
 


@@ -71,6 +65,14 @@ DEFINE_EVENT_TYPE(wxEVT_DIALUP_DISCONNECTED)
 #define INTERNET_CONNECTION_PROXY 4
 #endif
 
 #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
 // ----------------------------------------------------------------------------


@@ -140,13 +142,26 @@ 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 WXDLLEXPORT wxDialUpManagerMSW *dialUpManager;  // the owner
 };


@@ -174,7 +189,7 @@ public:
     virtual bool HangUp();
     virtual bool IsAlwaysOnline() const;
     virtual bool IsOnline() const;
     virtual bool HangUp();
     virtual bool IsAlwaysOnline() 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);


@@ -190,6 +205,7 @@ public:
 
     // for wxRasDialFunc
     static HWND GetRasWindow() { return ms_hwndRas; }
 
     // for wxRasDialFunc
     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:


@@ -200,11 +216,15 @@ 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
     class WXDLLEXPORT RasTimer : public wxTimer
     {
     // timer used for polling RAS status
     class WXDLLEXPORT RasTimer : public wxTimer
     {


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

+
+        DECLARE_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


@@ -223,10 +245,10 @@ 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 rasapi32.dll when it's loaded
 
     // the handle of rasapi32.dll when it's loaded

-    wxPluginManager m_dllRas;
+    wxDynamicLibrary m_dllRas;

 
     // the hidden window we use for passing messages between threads
     static HWND ms_hwndRas;
 
     // the hidden window we use for passing messages between threads
     static HWND ms_hwndRas;


@@ -234,12 +256,6 @@ private:
     // the handle of the connection we initiated or 0 if none
     static HRASCONN ms_hRasConnection;
 
     // the handle of the connection we initiated or 0 if none
     static HRASCONN ms_hRasConnection;
 

-    // 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;
     static RASENUMCONNECTIONS ms_pfnRasEnumConnections;
     // the pointers to RAS functions
     static RASDIAL ms_pfnRasDial;
     static RASENUMCONNECTIONS ms_pfnRasEnumConnections;


@@ -271,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;

+
+    DECLARE_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
 // ----------------------------------------------------------------------------


@@ -338,11 +383,13 @@ wxDialUpManager *wxDialUpManager::Create()
 #endif // VC++
 
 wxDialUpManagerMSW::wxDialUpManagerMSW()
 #endif // VC++
 
 wxDialUpManagerMSW::wxDialUpManagerMSW()

-                  : m_timerStatusPolling(this)
-                  , m_dllRas(_T("RASAPI32"))
+                  : 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 ( !m_dllRas.IsLoaded() )
     {
 
     if ( !m_dllRas.IsLoaded() )
     {


@@ -451,7 +498,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);
     }


@@ -496,7 +543,7 @@ HRASCONN wxDialUpManagerMSW::FindActiveConnection()
         }
         else
         {
         }
         else
         {

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

             wxLogError(_("Cannot find active dialup connection: %s"),
                        GetErrorString(dwRet).c_str());
             return 0;
             wxLogError(_("Cannot find active dialup connection: %s"),
                        GetErrorString(dwRet).c_str());
             return 0;


@@ -535,35 +582,26 @@ void wxDialUpManagerMSW::CleanUpThreadData()
 {
     if ( m_hThread )
     {
 {
     if ( m_hThread )
     {

-        if ( !SetEvent(m_data.hEventQuit) )
+        if ( !SetEvent(m_data->hEventQuit) )

         {
             wxLogLastError(_T("SetEvent(RasThreadQuit)"));
         }
         {
             wxLogLastError(_T("SetEvent(RasThreadQuit)"));
         }

+        else // sent quit request to the background thread
+        {
+            // 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);
 
         m_hThread = 0;
     }
 
 
         CloseHandle(m_hThread);
 
         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;

     }
 }
 
     }
 }
 


@@ -630,14 +668,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 */);

     }
 }
 
     }
 }
 


@@ -707,13 +745,13 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
                               bool async)
 {
     // check preconditions
                               bool async)
 {
     // check preconditions

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

 
     if ( ms_hRasConnection )
     {
         wxFAIL_MSG(wxT("there is already an active connection"));
 
 
     if ( ms_hRasConnection )
     {
         wxFAIL_MSG(wxT("there is already an active connection"));
 

-        return TRUE;
+        return true;

     }
 
     // get the default ISP if none given
     }
 
     // get the default ISP if none given


@@ -728,7 +766,7 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
                 // no known ISPs, abort
                 wxLogError(_("Failed to connect: no ISP to dial."));
 
                 // no known ISPs, abort
                 wxLogError(_("Failed to connect: no ISP to dial."));
 

-                return FALSE;
+                return false;

 
             case 1:
                 // only one ISP, choose it
 
             case 1:
                 // only one ISP, choose it


@@ -757,7 +795,7 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
                     if ( !entryName )
                     {
                         // cancelled by user
                     if ( !entryName )
                     {
                         // cancelled by user

-                        return FALSE;
+                        return false;

                     }
                 }
         }
                     }
                 }
         }


@@ -782,7 +820,7 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
         {
             wxLogError(_("Failed to connect: missing username/password."));
 
         {
             wxLogError(_("Failed to connect: missing username/password."));
 

-            return FALSE;
+            return false;

         }
     }
     else
         }
     }
     else


@@ -853,16 +891,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


@@ -875,7 +913,7 @@ bool wxDialUpManagerMSW::CancelDialing()
     if ( !GetDialer() )
     {
         // silently ignore
     if ( !GetDialer() )
     {
         // silently ignore

-        return FALSE;
+        return false;

     }
 
     wxASSERT_MSG( ms_hRasConnection, wxT("dialing but no connection?") );
     }
 
     wxASSERT_MSG( ms_hRasConnection, wxT("dialing but no connection?") );


@@ -887,7 +925,7 @@ bool wxDialUpManagerMSW::CancelDialing()
 
 bool wxDialUpManagerMSW::HangUp()
 {
 
 bool wxDialUpManagerMSW::HangUp()
 {

-    wxCHECK_MSG( IsOk(), FALSE, wxT("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


@@ -907,25 +945,27 @@ 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"),
                    GetErrorString(dwRet).c_str());
     }
 
     {
         wxLogError(_("Failed to terminate the dialup connection: %s"),
                    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 wxDialUpManagerMSW::IsAlwaysOnline() const
 {
     // assume no permanent connection by default

-    bool isAlwaysOnline = FALSE;
+    bool isAlwaysOnline = false;

 
     // try to use WinInet functions
 
 
     // try to use WinInet functions
 


@@ -933,7 +973,7 @@ bool wxDialUpManagerMSW::IsAlwaysOnline() const
     //     but we allow multiple instances of wxDialUpManagerMSW so
     //     we might as well use the ref counted version here too.
 
     //     but we allow multiple instances of wxDialUpManagerMSW so
     //     we might as well use the ref counted version here too.
 

-    wxPluginManager hDll(_T("WININET"));
+    wxDynamicLibrary hDll(_T("WININET"));

     if ( hDll.IsLoaded() )
     {
         typedef BOOL (WINAPI *INTERNETGETCONNECTEDSTATE)(LPDWORD, DWORD);
     if ( hDll.IsLoaded() )
     {
         typedef BOOL (WINAPI *INTERNETGETCONNECTEDSTATE)(LPDWORD, DWORD);


@@ -962,7 +1002,13 @@ bool wxDialUpManagerMSW::IsAlwaysOnline() const
 
 bool wxDialUpManagerMSW::IsOnline() const
 {
 
 bool wxDialUpManagerMSW::IsOnline() const
 {

-    wxCHECK_MSG( IsOk(), FALSE, wxT("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 )
     {


@@ -971,7 +1017,7 @@ 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;
     }
 }
         return FindActiveConnection() != 0;
     }
 }


@@ -985,7 +1031,13 @@ void wxDialUpManagerMSW::SetOnlineStatus(bool isOnline)
 
 bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
 {
 
 bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
 {

-    wxCHECK_MSG( IsOk(), FALSE, wxT("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;
 


@@ -997,22 +1049,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(wxT("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;

         }
     }
 
         }
     }
 


@@ -1022,32 +1065,41 @@ 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(wxT("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(wxT("CreateEvent(RasThreadQuit)"));
 
             CleanUpThreadData();
 
         {
             wxLogLastError(wxT("CreateEvent(RasThreadQuit)"));
 
             CleanUpThreadData();
 

-            ok = FALSE;
+            ok = false;

         }
     }
 
         }
     }
 


@@ -1055,36 +1107,28 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
     {
         // create a hidden window to receive notification about connections
         // status change
     {
         // create a hidden window to receive notification about connections
         // status change

-        extern const wxChar *wxCanvasClassName;
-        ms_hwndRas = ::CreateWindow(wxCanvasClassName, NULL,
-                                    0, 0, 0, 0,
-                                    0, NULL,
-                                    (HMENU)NULL, wxGetInstance(), 0);
+        ms_hwndRas = wxCreateHiddenWindow
+                     (
+                        &gs_classForDialUpWindow,
+                        wxMSWDIALUP_WNDCLASSNAME,
+                        wxRasStatusWindowProc
+                     );

         if ( !ms_hwndRas )
         {
             wxLogLastError(wxT("CreateWindow(RasHiddenWindow)"));
 
             CleanUpThreadData();
 
         if ( !ms_hwndRas )
         {
             wxLogLastError(wxT("CreateWindow(RasHiddenWindow)"));
 
             CleanUpThreadData();
 

-            ok = FALSE;
+            ok = false;

         }
         }

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

     }
 
     }
 

-    m_data.hWnd = ms_hwndRas;
+    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


@@ -1092,7 +1136,7 @@ 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
                     );
                      0,
                      &tid
                     );


@@ -1111,7 +1155,7 @@ 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 */
                       );
 
                         3 /* RASCN_Connection | RASCN_Disconnection */
                       );
 


@@ -1124,7 +1168,7 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
         }
         else
         {
         }
         else
         {

-            return TRUE;
+            return true;

         }
     }
 
         }
     }
 


@@ -1138,13 +1182,19 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
     }
     m_timerStatusPolling.Start(nSeconds * 1000);
 
     }
     m_timerStatusPolling.Start(nSeconds * 1000);
 

-    return TRUE;
+    return true;

 }
 
 void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
 {
     wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );
 
 }
 
 void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
 {
     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 ( m_hThread )
     {
         // we have running secondary thread, it's just enough to suspend it


@@ -1190,10 +1240,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 )
         {


@@ -1204,15 +1254,37 @@ 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(wxT("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;
 }
 
     return 0;
 }
 


@@ -1243,7 +1315,7 @@ static LRESULT APIENTRY wxRasStatusWindowProc(HWND hWnd, UINT message,
     return 0;
 }
 
     return 0;
 }
 

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

                                  RASCONNSTATE rasconnstate,
                                  DWORD dwError)
 {
                                  RASCONNSTATE rasconnstate,
                                  DWORD dwError)
 {


@@ -1251,11 +1323,10 @@ static void WINAPI wxRasDialFunc(UINT unMsg,
 
     wxCHECK_RET( dialUpManager, wxT("who started to dial then?") );
 
 
     wxCHECK_RET( dialUpManager, wxT("who started to dial then?") );
 

-    SendMessage(dialUpManager->GetRasWindow(), wxWM_RAS_DIALING_PROGRESS,
+    SendMessage(wxDialUpManagerMSW::GetRasWindow(), wxWM_RAS_DIALING_PROGRESS,

                 rasconnstate, dwError);
 }
 
 #endif // __BORLANDC__
 
 #endif // wxUSE_DIALUP_MANAGER
                 rasconnstate, dwError);
 }
 
 #endif // __BORLANDC__
 
 #endif // wxUSE_DIALUP_MANAGER

-