Some doc corrections

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

diff --git a/src/msw/dialup.cpp b/src/msw/dialup.cpp
index 81e4ed4288f24df35cf4909262d7797fc36eb9fd..8e01b68a87cd127099c9727dc4c4fcf411cbb9a8 100644 (file)
--- a/src/msw/dialup.cpp
+++ b/src/msw/dialup.cpp
@@ -34,16 +34,46 @@
 
 #ifndef WX_PRECOMP
     #include "wx/log.h"
 
 #ifndef WX_PRECOMP
     #include "wx/log.h"

+    #include "wx/intl.h"
+    #include "wx/event.h"
+#endif
+
+#include "wx/timer.h"
+#include "wx/app.h"
+#include "wx/generic/choicdgg.h"
+
+#include "wx/msw/private.h"  // must be before #include "dynlib.h"
+
+#if !wxUSE_DYNLIB_CLASS
+    #error You need wxUSE_DYNLIB_CLASS to be 1 to compile dialup.cpp.

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

-#include "wx/net.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++: no wininet.h
+#if !defined(__BORLANDC__) && \
+    (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION(0, 5)) && \
+    !defined(__GNUWIN32_OLD__) && \
+    !defined(__WATCOMC__) && \
+    (!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

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


@@ -51,6 +81,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,53 +93,53 @@
 // 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()
     {
 {
     wxRasThreadData()
     {


@@ -137,6 +168,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,6 +176,7 @@ 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 void SetOnlineStatus(bool isOnline = TRUE);
     virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
     virtual bool IsOnline() const;
     virtual void SetOnlineStatus(bool isOnline = TRUE);
     virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);


@@ -157,9 +190,10 @@ 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 wxDialUpManagerMSW *GetDialer() { return ms_dialer; }
 
 private:
     static wxDialUpManagerMSW *GetDialer() { return ms_dialer; }
 
 private:


@@ -176,7 +210,7 @@ private:
     void CleanUpThreadData();
 
     // timer used for polling RAS status
     void CleanUpThreadData();
 
     // timer used for polling RAS status

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

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


@@ -195,6 +229,9 @@ private:
     // each other
     wxRasThreadData m_data;
 
     // each other
     wxRasThreadData m_data;
 

+    // 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 handle of the connection we initiated or 0 if none
     static HRASCONN ms_hRasConnection;
 


@@ -233,6 +270,10 @@ private:
     // this flag tells us if we're online
     static int ms_isConnected;
 
     // this flag tells us if we're online
     static int ms_isConnected;
 

+    // this flag is the result of the call to IsAlwaysOnline() (-1 if not
+    // called yet)
+    static int ms_isAlwaysOnline;
+

     // 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;
 };


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

+HWND wxDialUpManagerMSW::ms_hwndRas = 0;
+

 int wxDialUpManagerMSW::ms_nDllCount = 0;
 wxDllType wxDialUpManagerMSW::ms_dllRas = 0;
 
 int wxDialUpManagerMSW::ms_nDllCount = 0;
 wxDllType wxDialUpManagerMSW::ms_dllRas = 0;
 


@@ -285,6 +328,7 @@ RASCONNECTIONNOTIFICATION wxDialUpManagerMSW::ms_pfnRasConnectionNotification =
 
 int wxDialUpManagerMSW::ms_userSpecifiedOnlineStatus = -1;
 int wxDialUpManagerMSW::ms_isConnected = -1;
 
 int wxDialUpManagerMSW::ms_userSpecifiedOnlineStatus = -1;
 int wxDialUpManagerMSW::ms_isConnected = -1;

+int wxDialUpManagerMSW::ms_isAlwaysOnline = -1;

 wxDialUpManagerMSW *wxDialUpManagerMSW::ms_dialer = NULL;
 
 // ----------------------------------------------------------------------------
 wxDialUpManagerMSW *wxDialUpManagerMSW::ms_dialer = NULL;
 
 // ----------------------------------------------------------------------------


@@ -314,9 +358,7 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
         ms_dllRas = wxDllLoader::LoadLibrary("RASAPI32");
         if ( !ms_dllRas )
         {
         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."));
+            wxLogError(_("Dial up functions are unavailable because the remote access service (RAS) is not installed on this machine. Please install it."));

         }
         else
         {
         }
         else
         {


@@ -329,7 +371,7 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
             // 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,  \
             // 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);        \
+                               wxString(_T(#name)) + gs_funcSuffix);    \

                 if ( !ms_pfn##name )                                    \
                 {                                                       \
                     funcName = #name;                                   \
                 if ( !ms_pfn##name )                                    \
                 {                                                       \
                     funcName = #name;                                   \


@@ -340,7 +382,7 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
             // not found in the DLL
             #define RESOLVE_OPTIONAL_RAS_FUNCTION(type, name)           \
                 ms_pfn##name = (type)wxDllLoader::GetSymbol(ms_dllRas,  \
             // not found in the DLL
             #define RESOLVE_OPTIONAL_RAS_FUNCTION(type, name)           \
                 ms_pfn##name = (type)wxDllLoader::GetSymbol(ms_dllRas,  \

-                               wxString(#name) + gs_funcSuffix);
+                               wxString(_T(#name)) + gs_funcSuffix);

 
             RESOLVE_RAS_FUNCTION(RASDIAL, RasDial);
             RESOLVE_RAS_FUNCTION(RASENUMCONNECTIONS, RasEnumConnections);
 
             RESOLVE_RAS_FUNCTION(RASDIAL, RasDial);
             RESOLVE_RAS_FUNCTION(RASENUMCONNECTIONS, RasEnumConnections);


@@ -348,6 +390,7 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
             RESOLVE_RAS_FUNCTION(RASGETCONNECTSTATUS, RasGetConnectStatus);
             RESOLVE_RAS_FUNCTION(RASGETERRORSTRING, RasGetErrorString);
             RESOLVE_RAS_FUNCTION(RASHANGUP, RasHangUp);
             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
 
             // suppress wxDllLoader messages about missing (non essential)
             // functions


@@ -358,7 +401,6 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
                 RESOLVE_OPTIONAL_RAS_FUNCTION(RASCREATEPHONEBOOKENTRY, RasCreatePhonebookEntry);
                 RESOLVE_OPTIONAL_RAS_FUNCTION(RASEDITPHONEBOOKENTRY, RasEditPhonebookEntry);
                 RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYDIALPARAMS, RasSetEntryDialParams);
                 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(RASGETENTRYPROPERTIES, RasGetEntryProperties);
                 RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYPROPERTIES, RasSetEntryProperties);
                 RESOLVE_OPTIONAL_RAS_FUNCTION(RASRENAMEENTRY, RasRenameEntry);


@@ -376,10 +418,12 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
 exit:
             if ( funcName )
             {
 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);
+                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;
 
                 wxDllLoader::UnloadLibrary(ms_dllRas);
                 ms_dllRas = 0;


@@ -422,8 +466,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);


@@ -479,7 +523,7 @@ HRASCONN wxDialUpManagerMSW::FindActiveConnection()
         {
             // an error occured
             wxLogError(_("Cannot find active dialup connection: %s"),
         {
             // an error occured
             wxLogError(_("Cannot find active dialup connection: %s"),

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

             return 0;
         }
     }
             return 0;
         }
     }


@@ -499,8 +543,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:


@@ -519,7 +562,7 @@ void wxDialUpManagerMSW::CleanUpThreadData()
     {
         if ( !SetEvent(m_data.hEventQuit) )
         {
     {
         if ( !SetEvent(m_data.hEventQuit) )
         {

-            wxLogLastError("SetEvent(RasThreadQuit)");
+            wxLogLastError(_T("SetEvent(RasThreadQuit)"));

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


@@ -601,7 +644,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 )


@@ -632,30 +675,152 @@ bool wxDialUpManagerMSW::IsOk() const
     return ms_dllRas != 0;
 }
 
     return ms_dllRas != 0;
 }
 

+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
+            rasEntries = (RASENTRYNAME *)realloc(rasEntries, size);
+        }
+        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,
                               const wxString& username,
                               const wxString& password,
                               bool async)
 {
 bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
                               const wxString& username,
                               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;
     }
 
 
         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;
+
+            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);
+    wxStrncpy(rasDialParams.szEntryName, entryName, 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
+       {
+               wxStrncpy(rasDialParams.szUserName, username, UNLEN);
+               wxStrncpy(rasDialParams.szPassword, password, 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';
 


@@ -701,7 +866,7 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
     {
         wxLogError(_("Failed to %s dialup connection: %s"),
                    async ? _("initiate") : _("establish"),
     {
         wxLogError(_("Failed to %s dialup connection: %s"),
                    async ? _("initiate") : _("establish"),

-                   GetErrorString(dwRet));
+                   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 )


@@ -737,7 +902,7 @@ bool wxDialUpManagerMSW::CancelDialing()
         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 +911,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


@@ -773,7 +938,7 @@ bool wxDialUpManagerMSW::HangUp()
     if ( dwRet != 0 )
     {
         wxLogError(_("Failed to terminate the dialup connection: %s"),
     if ( dwRet != 0 )
     {
         wxLogError(_("Failed to terminate the dialup connection: %s"),

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

     }
 
     ms_isConnected = FALSE;
     }
 
     ms_isConnected = FALSE;


@@ -781,9 +946,74 @@ bool wxDialUpManagerMSW::HangUp()
     return TRUE;
 }
 
     return TRUE;
 }
 

+bool wxDialUpManagerMSW::IsAlwaysOnline() const
+{
+    // we cache the result (presumably this won't change while the program is
+    // running!)
+    if ( ms_isAlwaysOnline != -1 )
+    {
+        return ms_isAlwaysOnline != 0;
+    }
+
+    // try to use WinInet function first
+    bool ok;
+    wxDllType hDll = wxDllLoader::LoadLibrary(_T("WININET"), &ok);
+    if ( ok )
+    {
+        typedef BOOL (*INTERNETGETCONNECTEDSTATE)(LPDWORD, DWORD);
+        INTERNETGETCONNECTEDSTATE pfnInternetGetConnectedState;
+
+        #define RESOLVE_FUNCTION(type, name) \
+            pfn##name = (type)wxDllLoader::GetSymbol(hDll, _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
+                ms_isAlwaysOnline = (flags & INTERNET_CONNECTION_LAN != 0) ||
+                                    (flags & INTERNET_CONNECTION_PROXY != 0);
+            }
+            else
+            {
+                // no Internet connection at all
+                ms_isAlwaysOnline = FALSE;
+            }
+        }
+
+        wxDllLoader::UnloadLibrary(hDll);
+    }
+
+    // did we succeed with WinInet? if not, try something else
+    if ( ms_isAlwaysOnline == -1 )
+    {
+        if ( !IsOnline() )
+        {
+            // definitely no permanent connection because we are not connected
+            // now
+            ms_isAlwaysOnline = FALSE;
+        }
+        else
+        {
+            // of course, having a modem doesn't prevent us from having a
+            // permanent connection as well, but we have to guess somehow and
+            // it's probably more common that a system connected via a modem
+            // doesn't have any other net access, so:
+            ms_isAlwaysOnline = FALSE;
+        }
+    }
+
+    wxASSERT_MSG( ms_isAlwaysOnline != -1, wxT("logic error") );
+
+    return ms_isAlwaysOnline != 0;
+}
+

 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 ( ms_userSpecifiedOnlineStatus != -1 )
     {
 
     if ( ms_userSpecifiedOnlineStatus != -1 )
     {


@@ -799,14 +1029,14 @@ bool wxDialUpManagerMSW::IsOnline() const
 
 void wxDialUpManagerMSW::SetOnlineStatus(bool isOnline)
 {
 
 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") );

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


@@ -824,7 +1054,7 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
                 dwSuspendCount = ResumeThread(m_hThread);
                 if ( dwSuspendCount == (DWORD)-1 )
                 {
                 dwSuspendCount = ResumeThread(m_hThread);
                 if ( dwSuspendCount == (DWORD)-1 )
                 {

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

 
                     ok = FALSE;
                 }
 
                     ok = FALSE;
                 }


@@ -852,7 +1082,7 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
                            );
         if ( !m_data.hEventRas )
         {
                            );
         if ( !m_data.hEventRas )
         {

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

 
             ok = FALSE;
         }
 
             ok = FALSE;
         }


@@ -864,7 +1094,7 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
         m_data.hEventQuit = CreateEvent(NULL, FALSE, FALSE, NULL);
         if ( !m_data.hEventQuit )
         {
         m_data.hEventQuit = CreateEvent(NULL, FALSE, FALSE, NULL);
         if ( !m_data.hEventQuit )
         {

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

 
             CleanUpThreadData();
 
 
             CleanUpThreadData();
 


@@ -872,18 +1102,18 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
         }
     }
 
         }
     }
 

-    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 )
+        extern const wxChar *wxPanelClassName;
+        ms_hwndRas = ::CreateWindow(wxPanelClassName, NULL,
+                                    0, 0, 0, 0,
+                                    0, NULL,
+                                    (HMENU)NULL, wxGetInstance(), 0);
+        if ( !ms_hwndRas )

         {
         {

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

 
             CleanUpThreadData();
 
 
             CleanUpThreadData();
 


@@ -897,9 +1127,11 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
                               wxGetInstance()
                              );
 
                               wxGetInstance()
                              );
 

-        ::SetWindowLong(m_data.hWnd, GWL_WNDPROC, (LONG) windowProc);
+        ::SetWindowLong(ms_hwndRas, GWL_WNDPROC, (LONG) windowProc);

     }
 
     }
 

+    m_data.hWnd = ms_hwndRas;
+

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


@@ -918,7 +1150,7 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
 
         if ( !m_hThread )
         {
 
         if ( !m_hThread )
         {

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

 
             CleanUpThreadData();
         }
 
             CleanUpThreadData();
         }


@@ -936,8 +1168,8 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
 
         if ( dwRet != 0 )
         {
 
         if ( dwRet != 0 )
         {

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

 
             CleanUpThreadData();
         }
 
             CleanUpThreadData();
         }


@@ -962,14 +1194,14 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
 
 void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
 {
 
 void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
 {

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

 
     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 +1218,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 +1226,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
 }


@@ -1027,7 +1259,7 @@ static DWORD wxRasMonitorThread(wxRasThreadData *data)
                 break;
 
             case WAIT_FAILED:
                 break;
 
             case WAIT_FAILED:

-                wxLogLastError("WaitForMultipleObjects(RasMonitor)");
+                wxLogLastError(wxT("WaitForMultipleObjects(RasMonitor)"));

                 break;
         }
     }
                 break;
         }
     }


@@ -1043,6 +1275,12 @@ static LRESULT APIENTRY wxRasStatusWindowProc(HWND hWnd, UINT message,
         wxRasThreadData *data = (wxRasThreadData *)lParam;
         data->dialUpManager->OnConnectStatusChange();
     }
         wxRasThreadData *data = (wxRasThreadData *)lParam;
         data->dialUpManager->OnConnectStatusChange();
     }

+    else if ( message == wxWM_RAS_DIALING_PROGRESS )
+    {
+        wxDialUpManagerMSW *dialUpManager = wxDialUpManagerMSW::GetDialer();
+
+        dialUpManager->OnDialProgress((RASCONNSTATE)wParam, lParam);
+    }

 
     return 0;
 }
 
     return 0;
 }


@@ -1053,9 +1291,12 @@ static void WINAPI wxRasDialFunc(UINT unMsg,
 {
     wxDialUpManagerMSW *dialUpManager = wxDialUpManagerMSW::GetDialer();
 
 {
     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(dialUpManager->GetRasWindow(), wxWM_RAS_DIALING_PROGRESS,
+                rasconnstate, dwError);

 }
 
 }
 

+#endif
+  // __BORLANDC__

 #endif // wxUSE_DIALUP_MANAGER
 #endif // wxUSE_DIALUP_MANAGER