Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added wxDialUpManager::IsAlwaysConnected() and GetISPNames(), also Dial()

Browse Source 
is now smart enough to propose to choose from available ISPs and tries to
find out the username and password on its own


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3859 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-10-06 23:00:40 +00:00
parent 28d00598b3
commit 2690830ea0
5 changed files with 325 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
include/wx/dialup.h
View File

@@ -19,9 +19,11 @@
#if wxUSE_DIALUP_MANAGER
// ----------------------------------------------------------------------------
// constants
// misc
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxArrayString;
extern const wxChar *wxEmptyString;
#define WXDIALUP_MANAGER_DEFAULT_BEACONHOST T("www.yahoo.com")
@@ -65,8 +67,17 @@ public:
// operations
// ----------
// fills the array with the names of all possible values for the first
// parameter to Dial() on this machine and returns their number (may be 0)
virtual size_t GetISPNames(wxArrayString& names) const = 0;
// dial the given ISP, use username and password to authentificate
//
// if no nameOfISP is given, the function will select the default one
//
// if no username/password are given, the function will try to do without
// them, but will ask the user if really needed
//
// if async parameter is FALSE, the function waits until the end of dialing
// and returns TRUE upon successful completion.
// if async is TRUE, the function only initiates the connection and returns
@@ -90,6 +101,14 @@ public:
// online status
// -------------
// returns TRUE if the computer has a permanent network connection (i.e. is
// on a LAN) and so there is no need to use Dial() function to go online
//
// NB: this functions tries to guess the result and it is not always
// guaranteed to be correct, so it's better to ask user for
// confirmation or give him a possibility to override it
virtual bool IsAlwaysOnline() const = 0;
// returns TRUE if the computer is connected to the network: under Windows,
// this just means that a RAS connection exists, under Unix we check that
// the "well-known host" (as specified by SetWellKnownHost) is reachable

41
samples/nettest/nettest.cpp
View File

@@ -80,6 +80,7 @@ public:
void OnAbout(wxCommandEvent& event);
void OnHangUp(wxCommandEvent& event);
void OnDial(wxCommandEvent& event);
void OnEnumISPs(wxCommandEvent& event);
void OnUpdateUI(wxUpdateUIEvent& event);
@@ -101,7 +102,9 @@ enum
NetTest_Quit = 1,
NetTest_About,
NetTest_HangUp,
NetTest_Dial
NetTest_Dial,
NetTest_EnumISP,
NetTest_Max
};
// ----------------------------------------------------------------------------
@@ -121,6 +124,7 @@ BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(NetTest_About, MyFrame::OnAbout)
EVT_MENU(NetTest_HangUp, MyFrame::OnHangUp)
EVT_MENU(NetTest_Dial, MyFrame::OnDial)
EVT_MENU(NetTest_EnumISP, MyFrame::OnEnumISPs)
EVT_UPDATE_UI(NetTest_Dial, MyFrame::OnUpdateUI)
@@ -168,6 +172,8 @@ bool MyApp::OnInit()
return FALSE;
}
frame->SetStatusText(GetDialer()->IsAlwaysOnline() ? "LAN" : "No LAN", 2);
return TRUE;
}
@@ -195,9 +201,7 @@ void MyApp::OnConnected(wxDialUpEvent& event)
: "Disconnected";
}
wxMessageBox(msg, "Dial Up Manager Notification",
wxOK | wxICON_INFORMATION,
GetTopWindow());
wxLogMessage(msg);
}
// ----------------------------------------------------------------------------
@@ -214,6 +218,8 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
menuFile->Append(NetTest_Dial, "&Dial\tCtrl-D", "Dial default ISP");
menuFile->Append(NetTest_HangUp, "&HangUp\tCtrl-H", "Hang up modem");
menuFile->AppendSeparator();
menuFile->Append(NetTest_EnumISP, "&Enumerate ISPs...\tCtrl-E");
menuFile->AppendSeparator();
menuFile->Append(NetTest_About, "&About...\tCtrl-A", "Show about dialog");
menuFile->AppendSeparator();
menuFile->Append(NetTest_Quit, "E&xit\tAlt-X", "Quit this program");
@@ -225,7 +231,10 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
// ... and attach this menu bar to the frame
SetMenuBar(menuBar);
CreateStatusBar(2);
// create status bar and fill the LAN field
CreateStatusBar(3);
static const int widths[3] = { -1, 100, 60 };
SetStatusWidths(3, widths);
}
@@ -264,7 +273,7 @@ void MyFrame::OnDial(wxCommandEvent& WXUNUSED(event))
wxYield();
wxBeginBusyCursor();
if ( wxGetApp().GetDialer()->Dial("Free", "zeitlin", "") )
if ( wxGetApp().GetDialer()->Dial() )
{
wxLogStatus(this, "Dialing...");
}
@@ -276,6 +285,26 @@ void MyFrame::OnDial(wxCommandEvent& WXUNUSED(event))
wxEndBusyCursor();
}
void MyFrame::OnEnumISPs(wxCommandEvent& WXUNUSED(event))
{
wxArrayString names;
size_t nCount = wxGetApp().GetDialer()->GetISPNames(names);
if ( nCount == 0 )
{
wxLogWarning("No ISPs found.");
}
else
{
wxString msg = "Known ISPs:\n";
for ( size_t n = 0; n < nCount; n++ )
{
msg << names[n] << '\n';
}
wxLogMessage(msg);
}
}
void MyFrame::OnUpdateUI(wxUpdateUIEvent& event)
{
// disable this item while dialing

1
samples/nettest/nettest.rc
View File

@@ -1,3 +1,2 @@
mondrian ICON "mondrian.ico"
#include "wx/msw/wx.rc"

319
src/msw/dialup.cpp
View File

@@ -38,11 +38,13 @@
#include "wx/dynlib.h"
#include "wx/net.h"
#include "wx/dialup.h"
#include <ras.h>
#include <raserror.h>
#include <wininet.h>
#include "wx/msw/private.h"
// ----------------------------------------------------------------------------
@@ -51,6 +53,7 @@
// 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
@@ -62,47 +65,47 @@
// 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 );
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 char gs_funcSuffix = 'A';
#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 );
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 char gs_funcSuffix = 'W';
#endif // ASCII/Unicode
@@ -137,6 +140,7 @@ public:
// 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,
@@ -144,6 +148,7 @@ public:
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);
@@ -157,9 +162,10 @@ public:
// for wxRasStatusWindowProc
void OnConnectStatusChange();
void OnDialProgress(RASCONNSTATE rasconnstate, DWORD dwError);
// for wxRasDialFunc
void OnDialProgress(RASCONNSTATE rasconnstate, DWORD dwError);
static HWND GetRasWindow() { return ms_hwndRas; }
static wxDialUpManagerMSW *GetDialer() { return ms_dialer; }
private:
@@ -195,6 +201,9 @@ private:
// 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;
@@ -233,6 +242,10 @@ private:
// 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;
};
@@ -260,6 +273,8 @@ static void WINAPI wxRasDialFunc(UINT unMsg,
HRASCONN wxDialUpManagerMSW::ms_hRasConnection = 0;
HWND wxDialUpManagerMSW::ms_hwndRas = 0;
int wxDialUpManagerMSW::ms_nDllCount = 0;
wxDllType wxDialUpManagerMSW::ms_dllRas = 0;
@@ -285,6 +300,7 @@ RASCONNECTIONNOTIFICATION wxDialUpManagerMSW::ms_pfnRasConnectionNotification =
int wxDialUpManagerMSW::ms_userSpecifiedOnlineStatus = -1;
int wxDialUpManagerMSW::ms_isConnected = -1;
int wxDialUpManagerMSW::ms_isAlwaysOnline = -1;
wxDialUpManagerMSW *wxDialUpManagerMSW::ms_dialer = NULL;
// ----------------------------------------------------------------------------
@@ -329,7 +345,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, \
wxString(#name) + gs_funcSuffix); \
wxString(_T(#name)) + gs_funcSuffix); \
if ( !ms_pfn##name ) \
{ \
funcName = #name; \
@@ -340,7 +356,7 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
// 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);
@@ -348,6 +364,7 @@ wxDialUpManagerMSW::wxDialUpManagerMSW()
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
@@ -358,7 +375,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(RASGETENTRYDIALPARAMS, RasGetEntryDialParams);
RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETENTRYPROPERTIES, RasGetEntryProperties);
RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYPROPERTIES, RasSetEntryProperties);
RESOLVE_OPTIONAL_RAS_FUNCTION(RASRENAMEENTRY, RasRenameEntry);
@@ -632,11 +648,62 @@ bool wxDialUpManagerMSW::IsOk() const
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));
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)
{
// check preconditions
wxCHECK_MSG( IsOk(), FALSE, T("using uninitialized wxDialUpManager") );
if ( ms_hRasConnection )
@@ -646,16 +713,87 @@ bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
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);
strncpy(rasDialParams.szEntryName, nameOfISP, RAS_MaxEntryName);
strncpy(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
{
strncpy(rasDialParams.szUserName, username, UNLEN);
strncpy(rasDialParams.szPassword, password, PWLEN);
}
// default values for other fields
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';
@@ -781,6 +919,74 @@ bool wxDialUpManagerMSW::HangUp()
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);
wxLogMessage("InternetGetConnectedState() returned TRUE, "
"flags = %08x", flags);
}
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, T("logic error") );
return ms_isAlwaysOnline != 0;
}
bool wxDialUpManagerMSW::IsOnline() const
{
wxCHECK_MSG( IsOk(), FALSE, T("using uninitialized wxDialUpManager") );
@@ -872,16 +1078,16 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
}
}
if ( ok )
if ( ok && !ms_hwndRas )
{
// create a hidden window to receive notification about connections
// status change
extern wxChar wxPanelClassName[];
m_data.hWnd = ::CreateWindow(wxPanelClassName, NULL,
ms_hwndRas = ::CreateWindow(wxPanelClassName, NULL,
0, 0, 0, 0,
0, NULL,
(HMENU)NULL, wxGetInstance(), 0);
if ( !m_data.hWnd )
if ( !ms_hwndRas )
{
wxLogLastError("CreateWindow(RasHiddenWindow)");
@@ -897,9 +1103,11 @@ bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
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
@@ -1043,6 +1251,12 @@ static LRESULT APIENTRY wxRasStatusWindowProc(HWND hWnd, UINT message,
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;
}
@@ -1055,7 +1269,8 @@ static void WINAPI wxRasDialFunc(UINT unMsg,
wxCHECK_RET( dialUpManager, T("who started to dial then?") );
dialUpManager->OnDialProgress(rasconnstate, dwError);
SendMessage(dialUpManager->GetRasWindow(), wxWM_RAS_DIALING_PROGRESS,
rasconnstate, dwError);
}
#endif // wxUSE_DIALUP_MANAGER

4
src/msw/window.cpp
View File

@@ -2240,11 +2240,7 @@ bool wxWindow::MSWCreate(int id,
if ( width > -1 ) width1 = width;
if ( height > -1 ) height1 = height;
#ifdef __WXWINE__
HWND hParent = (HWND)NULL;
#else
HWND hParent = NULL;
#endif
if ( parent )
hParent = (HWND) parent->GetHWND();