1294 lines
38 KiB
C++
1294 lines
38 KiB
C++
#include "shellprv.h"
|
|
#include "mshtml.h"
|
|
#include "mshtmhst.h"
|
|
#include "mshtmdid.h"
|
|
#include "htiframe.h"
|
|
#include "exdisp.h"
|
|
#include "exdispid.h"
|
|
#include "dspsprt.h"
|
|
#include "cowsite.h"
|
|
#include "ids.h"
|
|
#include "inetsmgr.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
// helper functions
|
|
|
|
typedef BOOL (*pfnDllRegisterWindowClasses)(const SHDRC * pshdrc);
|
|
|
|
BOOL SHDOCVW_DllRegisterWindowClasses(const SHDRC * pshdrc)
|
|
{
|
|
static HINSTANCE _hinstShdocvw = NULL;
|
|
static pfnDllRegisterWindowClasses _regfunc = NULL;
|
|
|
|
BOOL fSuccess = FALSE;
|
|
|
|
if (!_hinstShdocvw)
|
|
{
|
|
_hinstShdocvw = LoadLibrary(TEXT("shdocvw.dll"));
|
|
_regfunc = (pfnDllRegisterWindowClasses) GetProcAddress(_hinstShdocvw, "DllRegisterWindowClasses");
|
|
}
|
|
|
|
if (_regfunc)
|
|
fSuccess = _regfunc(pshdrc);
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
// Advise point for DIID_DWebBrowserEvents2
|
|
// Just an IDispatch implementation that delegates back to the main class. Allows us to have a separate "Invoke".
|
|
|
|
class CWebWizardPage;
|
|
|
|
class CWebEventHandler : public IServiceProvider, DWebBrowserEvents2
|
|
{
|
|
public:
|
|
CWebEventHandler(CWebWizardPage *pswp);
|
|
~CWebEventHandler(); // TODO: Make this virtual or it will never execute.
|
|
|
|
// IUnknown
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
|
|
STDMETHODIMP_(ULONG) AddRef() {return 2;}
|
|
STDMETHODIMP_(ULONG) Release() {return 1;}
|
|
|
|
// (DwebBrowserEvents)IDispatch
|
|
STDMETHODIMP GetTypeInfoCount(/* [out] */ UINT *pctinfo) { return E_NOTIMPL; }
|
|
STDMETHODIMP GetTypeInfo(
|
|
/* [in] */ UINT iTInfo,
|
|
/* [in] */ LCID lcid,
|
|
/* [out] */ ITypeInfo **ppTInfo)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP GetIDsOfNames(
|
|
/* [in] */ REFIID riid,
|
|
/* [size_is][in] */ LPOLESTR *rgszNames,
|
|
/* [in] */ UINT cNames,
|
|
/* [in] */ LCID lcid,
|
|
/* [size_is][out] */ DISPID *rgDispId)
|
|
{ return E_NOTIMPL; }
|
|
|
|
/* [local] */ STDMETHODIMP Invoke(
|
|
/* [in] */ DISPID dispIdMember,
|
|
/* [in] */ REFIID riid,
|
|
/* [in] */ LCID lcid,
|
|
/* [in] */ WORD wFlags,
|
|
/* [out][in] */ DISPPARAMS *pDispParams,
|
|
/* [out] */ VARIANT *pVarResult,
|
|
/* [out] */ EXCEPINFO *pExcepInfo,
|
|
/* [out] */ UINT *puArgErr);
|
|
|
|
HRESULT _Advise(BOOL fConnect);
|
|
|
|
// IServiceProvider
|
|
STDMETHODIMP QueryService(REFGUID guidService, REFIID riid, void **ppv);
|
|
|
|
private:
|
|
CWebWizardPage* _pwizPage;
|
|
DWORD _dwCPCookie;
|
|
IConnectionPoint* _pcpCurrentConnection;
|
|
};
|
|
|
|
#define SHOW_PROGRESS_TIMER 1
|
|
#define SHOW_PROGRESS_TIMEOUT 1000 // Start showing the progress indicator after 1 second of dead time.
|
|
|
|
class CWebWizardPage : public CImpIDispatch,
|
|
CObjectWithSite,
|
|
IDocHostUIHandler,
|
|
IServiceProvider,
|
|
IWebWizardExtension,
|
|
INewWDEvents
|
|
{
|
|
public:
|
|
CWebWizardPage();
|
|
~CWebWizardPage();
|
|
|
|
// IUnknown
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IDocHostUIHandler
|
|
STDMETHODIMP ShowContextMenu(
|
|
/* [in] */ DWORD dwID,
|
|
/* [in] */ POINT *ppt,
|
|
/* [in] */ IUnknown *pcmdtReserved,
|
|
/* [in] */ IDispatch *pdispReserved)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP GetHostInfo(
|
|
/* [out][in] */ DOCHOSTUIINFO *pInfo);
|
|
|
|
STDMETHODIMP ShowUI(
|
|
/* [in] */ DWORD dwID,
|
|
/* [in] */ IOleInPlaceActiveObject *pActiveObject,
|
|
/* [in] */ IOleCommandTarget *pCommandTarget,
|
|
/* [in] */ IOleInPlaceFrame *pFrame,
|
|
/* [in] */ IOleInPlaceUIWindow *pDoc)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP HideUI(void)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP UpdateUI(void)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP EnableModeless(
|
|
/* [in] */ BOOL fEnable)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP OnDocWindowActivate(
|
|
/* [in] */ BOOL fActivate)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP OnFrameWindowActivate(
|
|
/* [in] */ BOOL fActivate)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP ResizeBorder(
|
|
/* [in] */ LPCRECT prcBorder,
|
|
/* [in] */ IOleInPlaceUIWindow *pUIWindow,
|
|
/* [in] */ BOOL fRameWindow)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP TranslateAccelerator(
|
|
/* [in] */ LPMSG lpMsg,
|
|
/* [in] */ const GUID *pguidCmdGroup,
|
|
/* [in] */ DWORD nCmdID)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP GetOptionKeyPath(
|
|
/* [out] */ LPOLESTR *pchKey,
|
|
/* [in] */ DWORD dw)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP GetDropTarget(
|
|
/* [in] */ IDropTarget *pDropTarget,
|
|
/* [out] */ IDropTarget **ppDropTarget)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP GetExternal(
|
|
/* [out] */ IDispatch **ppDispatch);
|
|
|
|
STDMETHODIMP TranslateUrl(
|
|
/* [in] */ DWORD dwTranslate,
|
|
/* [in] */ OLECHAR *pchURLIn,
|
|
/* [out] */ OLECHAR **ppchURLOut)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP FilterDataObject(
|
|
/* [in] */ IDataObject *pDO,
|
|
/* [out] */ IDataObject **ppDORet)
|
|
{ return E_NOTIMPL; }
|
|
|
|
// IServiceProvider
|
|
STDMETHODIMP QueryService(
|
|
/*[in]*/ REFGUID guidService,
|
|
/*[in]*/ REFIID riid,
|
|
/*[out]*/ void **ppv);
|
|
|
|
// INewWDEvents
|
|
|
|
// (IDispatch)
|
|
STDMETHODIMP GetTypeInfoCount(
|
|
/* [out] */ UINT *pctinfo)
|
|
{ return E_NOTIMPL; }
|
|
|
|
STDMETHODIMP GetTypeInfo(
|
|
/* [in] */ UINT iTInfo,
|
|
/* [in] */ LCID lcid,
|
|
/* [out] */ ITypeInfo **ppTInfo)
|
|
{
|
|
return CImpIDispatch::GetTypeInfo(iTInfo, lcid, ppTInfo);
|
|
}
|
|
|
|
STDMETHODIMP GetIDsOfNames(
|
|
/* [in] */ REFIID riid,
|
|
/* [size_is][in] */ LPOLESTR *rgszNames,
|
|
/* [in] */ UINT cNames,
|
|
/* [in] */ LCID lcid,
|
|
/* [size_is][out] */ DISPID *rgDispId)
|
|
{
|
|
return CImpIDispatch::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
|
|
}
|
|
|
|
STDMETHODIMP Invoke(
|
|
/* [in] */ DISPID dispIdMember,
|
|
/* [in] */ REFIID riid,
|
|
/* [in] */ LCID lcid,
|
|
/* [in] */ WORD wFlags,
|
|
/* [out][in] */ DISPPARAMS *pDispParams,
|
|
/* [out] */ VARIANT *pVarResult,
|
|
/* [out] */ EXCEPINFO *pExcepInfo,
|
|
/* [out] */ UINT *puArgErr)
|
|
{
|
|
return CImpIDispatch::Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
|
|
}
|
|
|
|
STDMETHODIMP FinalBack(void);
|
|
STDMETHODIMP FinalNext(void);
|
|
STDMETHODIMP Cancel(void);
|
|
|
|
STDMETHODIMP put_Caption(
|
|
/* [in] */ BSTR bstrCaption);
|
|
|
|
STDMETHODIMP get_Caption(
|
|
/* [retval][out] */ BSTR *pbstrCaption);
|
|
|
|
STDMETHODIMP put_Property(
|
|
/* [in] */ BSTR bstrPropertyName,
|
|
/* [in] */ VARIANT *pvProperty);
|
|
|
|
STDMETHODIMP get_Property(
|
|
/* [in] */ BSTR bstrPropertyName,
|
|
/* [retval][out] */ VARIANT *pvProperty);
|
|
|
|
STDMETHODIMP SetWizardButtons(
|
|
/* [in] */ VARIANT_BOOL vfEnableBack,
|
|
/* [in] */ VARIANT_BOOL vfEnableNext,
|
|
/* [in] */ VARIANT_BOOL vfLastPage);
|
|
|
|
STDMETHODIMP SetHeaderText(
|
|
/* [in] */ BSTR bstrHeaderTitle,
|
|
/* [in] */ BSTR bstrHeaderSubtitle);
|
|
|
|
STDMETHODIMP PassportAuthenticate(
|
|
/* [in] */ BSTR bstrSignInUrl,
|
|
/* [retval][out] */ VARIANT_BOOL * pvfAuthenticated);
|
|
|
|
// IWizardExtension
|
|
STDMETHODIMP AddPages(HPROPSHEETPAGE* aPages, UINT cPages, UINT *pnPages);
|
|
STDMETHODIMP GetFirstPage(HPROPSHEETPAGE *phPage);
|
|
STDMETHODIMP GetLastPage(HPROPSHEETPAGE *phPage)
|
|
{ return GetFirstPage(phPage); }
|
|
|
|
// IWebWizardExtension
|
|
STDMETHODIMP SetInitialURL(LPCWSTR pszDefaultURL);
|
|
STDMETHODIMP SetErrorURL(LPCWSTR pszErrorURL);
|
|
|
|
protected:
|
|
friend class CWebEventHandler;
|
|
void _OnDownloadBegin();
|
|
void _OnDocumentComplete();
|
|
|
|
private:
|
|
void _InitBrowser();
|
|
HRESULT _NavigateBrowser(LPCWSTR pszUrl);
|
|
HRESULT _CallScript(IWebBrowser2* pbrowser, LPCWSTR pszFunction);
|
|
BOOL _IsScriptFunctionOnPage(IWebBrowser2* pbrowser, LPCWSTR pszFunction);
|
|
BOOL _IsBrowserVisible();
|
|
void _ShowBrowser(BOOL fShow);
|
|
void _SizeProgress();
|
|
void _ShowProgress(BOOL fShow);
|
|
void _StartShowProgressTimer();
|
|
void _SetHeaderText(LPCWSTR pszHeader, LPCWSTR pszSubHeader);
|
|
|
|
virtual INT_PTR DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
static INT_PTR StaticProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
static UINT PropPageProc(HWND hwndDlg, UINT uMsg, PROPSHEETPAGE *ppsp);
|
|
|
|
BOOL OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam);
|
|
BOOL OnDestroy(HWND hwnd);
|
|
BOOL OnNotify(HWND hwnd, int idCtrl, LPNMHDR pnmh);
|
|
BOOL OnTimer(HWND hwnd, UINT nIDEvent);
|
|
|
|
LONG _cRef;
|
|
CWebEventHandler *_pwebEventHandler;
|
|
IWebBrowser2 *_pwebbrowser;
|
|
IOleInPlaceActiveObject *_poipao;
|
|
HWND _hwndOCHost; // Web browser control window
|
|
HWND _hwndFrame; // Wizard frame window
|
|
HWND _hwnd; // Dialog window
|
|
HPROPSHEETPAGE _hPage;
|
|
|
|
LPWSTR _pszInitialURL;
|
|
LPWSTR _pszErrorURL;
|
|
};
|
|
|
|
|
|
INT_PTR CWebWizardPage::StaticProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CWebWizardPage* pthis = (CWebWizardPage*) GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
|
|
PROPSHEETPAGE* ppage;
|
|
INT_PTR fProcessed;
|
|
|
|
if (uMsg == WM_INITDIALOG)
|
|
{
|
|
ppage = (PROPSHEETPAGE*) lParam;
|
|
pthis = (CWebWizardPage*) ppage->lParam;
|
|
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR) pthis);
|
|
}
|
|
|
|
if (pthis != NULL)
|
|
{
|
|
fProcessed = pthis->DialogProc(hwndDlg, uMsg, wParam, lParam);
|
|
}
|
|
else
|
|
{
|
|
fProcessed = FALSE;
|
|
}
|
|
|
|
return fProcessed;
|
|
}
|
|
|
|
|
|
// construction and IUnknown
|
|
|
|
CWebEventHandler::CWebEventHandler(CWebWizardPage *pwswp) :
|
|
_pcpCurrentConnection(NULL),
|
|
_pwizPage(pwswp)
|
|
{
|
|
}
|
|
|
|
CWebEventHandler::~CWebEventHandler()
|
|
{
|
|
_Advise(FALSE);
|
|
}
|
|
|
|
HRESULT CWebEventHandler::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENTMULTI(CWebEventHandler, IDispatch, DWebBrowserEvents2),
|
|
QITABENTMULTI2(CWebEventHandler, DIID_DWebBrowserEvents2, DWebBrowserEvents2),
|
|
// QITABENTMULTI2(CWebEventHandler, DIID_DWebBrowserEvents, DWebBrowserEvents),
|
|
QITABENT(CWebEventHandler, IServiceProvider),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP CWebEventHandler::QueryService(REFGUID guidService, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_NOINTERFACE;
|
|
*ppv = NULL; // no result yet
|
|
|
|
// we are a site for the OleControlSite interfaces only
|
|
if (guidService == SID_OleControlSite)
|
|
{
|
|
if (riid == IID_IDispatch)
|
|
{
|
|
hr = this->QueryInterface(riid, ppv);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebEventHandler_CreateInstance(CWebWizardPage *pwswp, CWebEventHandler **ppweh)
|
|
{
|
|
*ppweh = new CWebEventHandler(pwswp);
|
|
if (!*ppweh)
|
|
return E_OUTOFMEMORY;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebEventHandler::_Advise(BOOL fConnect)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// If we're already connected, disconnect, since we either want to disconnect or reconnect to
|
|
// a different webbrowser.
|
|
if (_pcpCurrentConnection)
|
|
{
|
|
hr = _pcpCurrentConnection->Unadvise(_dwCPCookie);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ATOMICRELEASE(_pcpCurrentConnection);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We expect that if _pcpCurrentConnection is NULL, no code earlier would have changed hr, and that it is still S_OK
|
|
// The code below expects that if !SUCCEEDED(hr), Unadvise failed above.
|
|
ASSERT(SUCCEEDED(hr));
|
|
}
|
|
|
|
if (_pwizPage && _pwizPage->_pwebbrowser)
|
|
{
|
|
if (SUCCEEDED(hr) && fConnect)
|
|
{
|
|
IConnectionPointContainer* pcontainer;
|
|
hr = _pwizPage->_pwebbrowser->QueryInterface(IID_PPV_ARG(IConnectionPointContainer, &pcontainer));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IConnectionPoint* pconnpoint;
|
|
hr = pcontainer->FindConnectionPoint(DIID_DWebBrowserEvents2, &pconnpoint);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IDispatch* pDisp;
|
|
hr = QueryInterface(IID_PPV_ARG(IDispatch, &pDisp));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pconnpoint->Advise(pDisp, &_dwCPCookie);
|
|
pDisp->Release();
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// TODO: Enable ATOMICRELEASE() to verify we won't leak anything
|
|
// ATOMICRELEASE(_pcpCurrentConnection);
|
|
_pcpCurrentConnection = pconnpoint;
|
|
}
|
|
else
|
|
{
|
|
pconnpoint->Release();
|
|
}
|
|
}
|
|
pcontainer->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebEventHandler::Invoke(
|
|
/* [in] */ DISPID dispIdMember,
|
|
/* [in] */ REFIID riid,
|
|
/* [in] */ LCID lcid,
|
|
/* [in] */ WORD wFlags,
|
|
/* [out][in] */ DISPPARAMS *pDispParams,
|
|
/* [out] */ VARIANT *pVarResult,
|
|
/* [out] */ EXCEPINFO *pExcepInfo,
|
|
/* [out] */ UINT *puArgErr)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
switch (dispIdMember)
|
|
{
|
|
case DISPID_BEFORENAVIGATE2:
|
|
_pwizPage->_OnDownloadBegin();
|
|
break;
|
|
|
|
case DISPID_DOCUMENTCOMPLETE:
|
|
_pwizPage->_OnDocumentComplete();
|
|
break;
|
|
|
|
default:
|
|
hr = DISP_E_MEMBERNOTFOUND;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// Object for hosting HTML wizard pages
|
|
|
|
CWebWizardPage::CWebWizardPage() :
|
|
CImpIDispatch(LIBID_Shell32, 0, 0, IID_INewWDEvents),
|
|
_cRef(1)
|
|
{
|
|
// Ensure zero-init happened
|
|
ASSERT(NULL == _pwebbrowser);
|
|
ASSERT(NULL == _pwebEventHandler);
|
|
ASSERT(NULL == _pszInitialURL);
|
|
ASSERT(NULL == _pszErrorURL);
|
|
}
|
|
|
|
CWebWizardPage::~CWebWizardPage()
|
|
{
|
|
ATOMICRELEASE(_pwebbrowser);
|
|
ATOMICRELEASE(_pwebEventHandler);
|
|
ATOMICRELEASE(_punkSite);
|
|
ATOMICRELEASE(_poipao);
|
|
|
|
Str_SetPtr(&_pszInitialURL, NULL);
|
|
Str_SetPtr(&_pszErrorURL, NULL);
|
|
}
|
|
|
|
HRESULT CWebWizardPage::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] =
|
|
{
|
|
QITABENTMULTI(CWebWizardPage, IWizardExtension, IWebWizardExtension),
|
|
QITABENT(CWebWizardPage, IWebWizardExtension),
|
|
QITABENT(CWebWizardPage, IDocHostUIHandler),
|
|
QITABENT(CWebWizardPage, IServiceProvider),
|
|
QITABENT(CWebWizardPage, INewWDEvents),
|
|
QITABENT(CWebWizardPage, IDispatch),
|
|
QITABENT(CWebWizardPage, IWebWizardExtension),
|
|
QITABENT(CWebWizardPage, IObjectWithSite),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
ULONG CWebWizardPage::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
ULONG CWebWizardPage::Release()
|
|
{
|
|
if (InterlockedDecrement(&_cRef))
|
|
return _cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
|
|
HRESULT CWebWizardPage::QueryService(REFGUID guidService, REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = E_NOINTERFACE;
|
|
*ppv = NULL;
|
|
|
|
if (_punkSite)
|
|
hr = IUnknown_QueryService(_punkSite, guidService, riid, ppv);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
void CWebWizardPage::_OnDownloadBegin()
|
|
{
|
|
_ShowBrowser(FALSE);
|
|
_StartShowProgressTimer();
|
|
|
|
SetWizardButtons(VARIANT_FALSE, VARIANT_FALSE, VARIANT_FALSE);
|
|
}
|
|
|
|
void CWebWizardPage::_OnDocumentComplete()
|
|
{
|
|
if (!_IsScriptFunctionOnPage(_pwebbrowser, L"OnBack"))
|
|
{
|
|
// This is an invalid page; navigate to our private error page
|
|
BSTR bstrOldUrl;
|
|
if (_pwebbrowser && SUCCEEDED(_pwebbrowser->get_LocationURL(&bstrOldUrl)))
|
|
{
|
|
#ifdef DEBUG
|
|
if (IDYES == ::MessageBox(_hwnd, L"A Web Service Error has occured.\n\nDo you want to load the HTML page anyway so you can debug it?\n\n(This only appears in debug builds)", bstrOldUrl, MB_ICONERROR | MB_YESNO))
|
|
{
|
|
_ShowBrowser(TRUE);
|
|
SysFreeString(bstrOldUrl);
|
|
return;
|
|
}
|
|
#endif
|
|
BSTR bstrUrl = NULL;
|
|
BOOL fUsingCustomError = FALSE;
|
|
|
|
// If we have a custom error URL and we haven't already failed trying
|
|
// to navigate to this custom URL...
|
|
if ((NULL != _pszErrorURL) &&
|
|
(0 != StrCmpI(_pszErrorURL, bstrOldUrl)))
|
|
{
|
|
// then use the custom URL.
|
|
bstrUrl = SysAllocString(_pszErrorURL);
|
|
fUsingCustomError = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bstrUrl = SysAllocString(L"res://shell32.dll/WebServiceError.htm");
|
|
}
|
|
|
|
if (bstrUrl)
|
|
{
|
|
_pwebbrowser->Navigate(bstrUrl, NULL, NULL, NULL, NULL);
|
|
SysFreeString(bstrUrl);
|
|
|
|
// Custom error URL will provide its own header and subheader
|
|
if (!fUsingCustomError)
|
|
{
|
|
WCHAR szTitle[256];
|
|
LoadString(g_hinst, IDS_WEBDLG_ERRTITLE, szTitle, ARRAYSIZE(szTitle));
|
|
#ifdef DEBUG
|
|
_SetHeaderText(szTitle, bstrOldUrl);
|
|
#else
|
|
_SetHeaderText(szTitle, L"");
|
|
#endif
|
|
}
|
|
}
|
|
SysFreeString(bstrOldUrl);
|
|
}
|
|
// else out of memory - oops.
|
|
}
|
|
else
|
|
{
|
|
_ShowBrowser(TRUE);
|
|
}
|
|
}
|
|
|
|
HRESULT CWebWizardPage::GetHostInfo(DOCHOSTUIINFO *pInfo)
|
|
{
|
|
ZeroMemory(pInfo, sizeof(*pInfo));
|
|
pInfo->cbSize = sizeof(*pInfo);
|
|
pInfo->dwDoubleClick = DOCHOSTUIDBLCLK_DEFAULT;
|
|
pInfo->dwFlags = DOCHOSTUIFLAG_DIALOG | DOCHOSTUIFLAG_NO3DBORDER |
|
|
DOCHOSTUIFLAG_ENABLE_FORMS_AUTOCOMPLETE | DOCHOSTUIFLAG_THEME |
|
|
DOCHOSTUIFLAG_FLAT_SCROLLBAR;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::GetExternal(IDispatch** ppDispatch)
|
|
{
|
|
return QueryInterface(IID_PPV_ARG(IDispatch, ppDispatch));
|
|
}
|
|
|
|
INT_PTR CWebWizardPage::DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
HANDLE_MSG(hwndDlg, WM_INITDIALOG, OnInitDialog);
|
|
HANDLE_MSG(hwndDlg, WM_DESTROY, OnDestroy);
|
|
HANDLE_MSG(hwndDlg, WM_NOTIFY, OnNotify);
|
|
HANDLE_MSG(hwndDlg, WM_TIMER, OnTimer);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::_CallScript(IWebBrowser2* pbrowser, LPCWSTR pszFunction)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pbrowser)
|
|
{
|
|
IDispatch* pdocDispatch;
|
|
|
|
hr = pbrowser->get_Document(&pdocDispatch);
|
|
if ((S_OK == hr) && pdocDispatch)
|
|
{
|
|
IHTMLDocument* pdoc;
|
|
hr = pdocDispatch->QueryInterface(IID_PPV_ARG(IHTMLDocument, &pdoc));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IDispatch* pdispScript;
|
|
hr = pdoc->get_Script(&pdispScript);
|
|
if (S_OK == hr)
|
|
{
|
|
DISPID dispid;
|
|
hr = pdispScript->GetIDsOfNames(IID_NULL, const_cast<LPWSTR*>(&pszFunction), 1, LOCALE_SYSTEM_DEFAULT, &dispid);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
unsigned int uArgErr;
|
|
DISPPARAMS dispparams = {0};
|
|
hr = pdispScript->Invoke(dispid, IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &dispparams, NULL, NULL, &uArgErr);
|
|
}
|
|
pdispScript->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
pdoc->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
pdocDispatch->Release();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL CWebWizardPage::_IsScriptFunctionOnPage(IWebBrowser2* pbrowser, LPCWSTR pszFunction)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
|
|
if (pbrowser)
|
|
{
|
|
IDispatch* pdocDispatch;
|
|
|
|
hr = pbrowser->get_Document(&pdocDispatch);
|
|
if (S_OK == hr && pdocDispatch)
|
|
{
|
|
IHTMLDocument* pdoc;
|
|
hr = pdocDispatch->QueryInterface(IID_PPV_ARG(IHTMLDocument, &pdoc));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IDispatch* pdispScript;
|
|
hr = pdoc->get_Script(&pdispScript);
|
|
if (S_OK == hr)
|
|
{
|
|
DISPID dispid;
|
|
hr = pdispScript->GetIDsOfNames(IID_NULL, const_cast<LPWSTR*>(&pszFunction), 1, LOCALE_SYSTEM_DEFAULT, &dispid);
|
|
pdispScript->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
pdoc->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
pdocDispatch->Release();
|
|
}
|
|
}
|
|
|
|
return (S_OK == hr) ? TRUE : FALSE;
|
|
}
|
|
|
|
|
|
// Uncomment this to NOT pass the LCID on the URL query string - for testing only.
|
|
|
|
BOOL CWebWizardPage::OnNotify(HWND hwnd, int idCtrl, LPNMHDR pnmh)
|
|
{
|
|
switch (pnmh->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
{
|
|
_SizeProgress();
|
|
_ShowProgress(FALSE);
|
|
_ShowBrowser(FALSE);
|
|
|
|
// fetch the high contrast flag, and set accordingly for the HTML to read
|
|
// its OK for us to fail setting this into the property bag.
|
|
|
|
HIGHCONTRAST hc = {sizeof(hc)};
|
|
if (SystemParametersInfo(SPI_GETHIGHCONTRAST, sizeof(hc), &hc, 0))
|
|
{
|
|
VARIANT var = {VT_BOOL};
|
|
var.boolVal = (hc.dwFlags & HCF_HIGHCONTRASTON) ? VARIANT_TRUE:VARIANT_FALSE;
|
|
put_Property(L"HighContrast", &var);
|
|
}
|
|
|
|
// Position the OCHost window
|
|
|
|
RECT rectClient;
|
|
GetClientRect(hwnd, &rectClient);
|
|
SetWindowPos(_hwndOCHost, NULL, 0, 0, rectClient.right, rectClient.bottom, SWP_NOMOVE | SWP_NOOWNERZORDER);
|
|
|
|
// set the initial URL
|
|
|
|
if (_pszInitialURL)
|
|
{
|
|
WCHAR szURLWithLCID[INTERNET_MAX_URL_LENGTH];
|
|
LPCWSTR pszFormat = StrChr(_pszInitialURL, L'?') ? L"%s&lcid=%d&langid=%d":L"%s?lcid=%d&langid=%d";
|
|
if (wnsprintf(szURLWithLCID, ARRAYSIZE(szURLWithLCID), pszFormat, _pszInitialURL, GetUserDefaultLCID(), GetUserDefaultUILanguage()) > 0)
|
|
{
|
|
_NavigateBrowser(szURLWithLCID);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
// WIZNEXT and WIZBACK don't actually cause a navigation to occur - they instead forward on the message to the
|
|
// hosted web page. Real wizard navigations occur when the hosted web page calls our FinalBack() and FinalNext() methods.
|
|
|
|
case PSN_WIZNEXT:
|
|
_CallScript(_pwebbrowser, L"OnNext");
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LONG_PTR) -1);
|
|
return TRUE;
|
|
|
|
case PSN_WIZBACK:
|
|
_CallScript(_pwebbrowser, L"OnBack");
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LONG_PTR) -1);
|
|
return TRUE;
|
|
|
|
// query cancel results in a call to the site to determine if we are going
|
|
// to cancel out and if the site wants to provide a page for us to navigate
|
|
// to - in some cases, eg. the web publishing wizard this is important
|
|
// so that we can cancel the order being processed etc.
|
|
|
|
case PSN_QUERYCANCEL:
|
|
if (_punkSite)
|
|
{
|
|
IWizardSite *pws;
|
|
if (SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws))))
|
|
{
|
|
HPROPSHEETPAGE hpage;
|
|
if (S_OK == pws->GetCancelledPage(&hpage))
|
|
{
|
|
PropSheet_SetCurSel(GetParent(hwnd), hpage, -1);
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)TRUE);
|
|
}
|
|
pws->Release();
|
|
}
|
|
}
|
|
return TRUE;
|
|
|
|
case PSN_TRANSLATEACCELERATOR:
|
|
{
|
|
LPPSHNOTIFY ppsn = (LPPSHNOTIFY)pnmh;
|
|
MSG *pmsg = (MSG *)ppsn->lParam;
|
|
LONG_PTR lres = PSNRET_NOERROR;
|
|
|
|
if (_poipao && S_OK == _poipao->TranslateAccelerator(pmsg))
|
|
{
|
|
lres = PSNRET_MESSAGEHANDLED;
|
|
}
|
|
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, lres);
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CWebWizardPage::OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
|
|
{
|
|
_hwnd = hwnd;
|
|
_hwndFrame = GetParent(hwnd);
|
|
|
|
// lets remap some of the text in the dialog if we need to
|
|
|
|
IResourceMap *prm;
|
|
HRESULT hr = IUnknown_QueryService(_punkSite, SID_ResourceMap, IID_PPV_ARG(IResourceMap, &prm));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IXMLDOMNode *pdn;
|
|
hr = prm->SelectResourceScope(TEXT("dialog"), TEXT("ws:downloading"), &pdn);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TCHAR szBuffer[512];
|
|
if (SUCCEEDED(prm->LoadString(pdn, TEXT("header"), szBuffer, ARRAYSIZE(szBuffer))))
|
|
{
|
|
SetDlgItemText(hwnd, IDC_PROGTEXT1, szBuffer);
|
|
}
|
|
if (SUCCEEDED(prm->LoadString(pdn, TEXT("footer"), szBuffer, ARRAYSIZE(szBuffer))))
|
|
{
|
|
SetDlgItemText(hwnd, IDC_PROGTEXT2, szBuffer);
|
|
}
|
|
pdn->Release();
|
|
}
|
|
prm->Release();
|
|
}
|
|
|
|
// create the web view browser that we will show the providers HTML in
|
|
|
|
SHDRC shdrc = {0};
|
|
shdrc.cbSize = sizeof(shdrc);
|
|
shdrc.dwFlags = SHDRCF_OCHOST;
|
|
|
|
if (SHDOCVW_DllRegisterWindowClasses(&shdrc))
|
|
{
|
|
RECT rectClient;
|
|
GetClientRect(hwnd, &rectClient);
|
|
|
|
_hwndOCHost = CreateWindow(OCHOST_CLASS, NULL,
|
|
WS_CHILD|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_TABSTOP,
|
|
0, 0, rectClient.right, rectClient.bottom,
|
|
hwnd, NULL, g_hinst, NULL);
|
|
if (_hwndOCHost)
|
|
{
|
|
OCHINITSTRUCT ocs = {0};
|
|
ocs.cbSize = sizeof(ocs);
|
|
ocs.clsidOC = CLSID_WebBrowser;
|
|
ocs.punkOwner = SAFECAST(this, IDocHostUIHandler*);
|
|
|
|
hr = OCHost_InitOC(_hwndOCHost, (LPARAM)&ocs);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_InitBrowser();
|
|
|
|
OCHost_DoVerb(_hwndOCHost, OLEIVERB_INPLACEACTIVATE, TRUE);
|
|
ShowWindow(_hwndOCHost, TRUE);
|
|
|
|
IServiceProvider* pSP;
|
|
hr = _pwebEventHandler->QueryInterface(IID_PPV_ARG(IServiceProvider, &pSP));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
OCHost_SetServiceProvider(_hwndOCHost, pSP);
|
|
pSP->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
EndDialog(hwnd, IDCANCEL);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CWebWizardPage::OnTimer(HWND hwnd, UINT nIDEvent)
|
|
{
|
|
if (nIDEvent == SHOW_PROGRESS_TIMER)
|
|
{
|
|
_ShowProgress(TRUE);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CWebWizardPage::OnDestroy(HWND hwnd)
|
|
{
|
|
ATOMICRELEASE(_pwebbrowser);
|
|
return TRUE;
|
|
}
|
|
|
|
void CWebWizardPage::_InitBrowser(void)
|
|
{
|
|
ASSERT(IsWindow(_hwndOCHost));
|
|
ASSERT(!_pwebbrowser);
|
|
|
|
HRESULT hr = OCHost_QueryInterface(_hwndOCHost, IID_PPV_ARG(IWebBrowser2, &_pwebbrowser));
|
|
if (SUCCEEDED(hr) && _pwebbrowser)
|
|
{
|
|
ITargetFrame2* ptgf;
|
|
if (SUCCEEDED(_pwebbrowser->QueryInterface(IID_PPV_ARG(ITargetFrame2, &ptgf))))
|
|
{
|
|
DWORD dwOptions;
|
|
if (SUCCEEDED(ptgf->GetFrameOptions(&dwOptions)))
|
|
{
|
|
dwOptions |= FRAMEOPTIONS_BROWSERBAND | FRAMEOPTIONS_SCROLL_AUTO;
|
|
ptgf->SetFrameOptions(dwOptions);
|
|
}
|
|
ptgf->Release();
|
|
}
|
|
|
|
_pwebbrowser->put_RegisterAsDropTarget(VARIANT_FALSE);
|
|
|
|
// Set up the connection point (including creating the object
|
|
|
|
if (!_pwebEventHandler)
|
|
CWebEventHandler_CreateInstance(this, &_pwebEventHandler);
|
|
|
|
if (_pwebEventHandler)
|
|
_pwebEventHandler->_Advise(TRUE);
|
|
|
|
OCHost_QueryInterface(_hwndOCHost, IID_PPV_ARG(IOleInPlaceActiveObject, &_poipao));
|
|
}
|
|
}
|
|
|
|
HRESULT CWebWizardPage::_NavigateBrowser(LPCWSTR pszUrl)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (_hwndOCHost && _pwebbrowser)
|
|
{
|
|
BSTR bstrUrl = SysAllocString(pszUrl);
|
|
if (bstrUrl)
|
|
{
|
|
hr = _pwebbrowser->Navigate(bstrUrl, NULL, NULL, NULL, NULL);
|
|
SysFreeString(bstrUrl);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::FinalBack(void)
|
|
{
|
|
if (_punkSite)
|
|
{
|
|
IWizardSite *pws;
|
|
if (SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws))))
|
|
{
|
|
HPROPSHEETPAGE hpage;
|
|
HRESULT hr = pws->GetPreviousPage(&hpage);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
PropSheet_SetCurSel(_hwndFrame, hpage, -1);
|
|
}
|
|
pws->Release();
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::FinalNext(void)
|
|
{
|
|
if (_punkSite)
|
|
{
|
|
IWizardSite *pws;
|
|
if (SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws))))
|
|
{
|
|
HPROPSHEETPAGE hpage;
|
|
HRESULT hr = pws->GetNextPage(&hpage);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
PropSheet_SetCurSel(_hwndFrame, hpage, -1);
|
|
}
|
|
pws->Release();
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::Cancel(void)
|
|
{
|
|
PropSheet_PressButton(_hwndFrame, PSBTN_CANCEL); // simulate cancel...
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::put_Caption(
|
|
/* [in] */ BSTR bstrCaption)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::get_Caption(
|
|
/* [retval][out] */ BSTR *pbstrCaption)
|
|
{
|
|
WCHAR szCaption[MAX_PATH];
|
|
|
|
GetWindowText(_hwndFrame, szCaption, ARRAYSIZE(szCaption));
|
|
*pbstrCaption = SysAllocString(szCaption);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// fetch and put properties into the frames property bag. this we do
|
|
// by a QueryService call and then we can modify the properties accordingly.
|
|
|
|
HRESULT CWebWizardPage::put_Property(
|
|
/* [in] */ BSTR bstrPropertyName,
|
|
/* [in] */ VARIANT *pvProperty)
|
|
{
|
|
IPropertyBag *ppb;
|
|
HRESULT hr = IUnknown_QueryService(_punkSite, SID_WebWizardHost, IID_PPV_ARG(IPropertyBag, &ppb));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ppb->Write(bstrPropertyName, pvProperty);
|
|
ppb->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::get_Property(
|
|
/* [in] */ BSTR bstrPropertyName,
|
|
/* [retval][out] */ VARIANT *pvProperty)
|
|
{
|
|
IPropertyBag *ppb;
|
|
HRESULT hr = IUnknown_QueryService(_punkSite, SID_WebWizardHost, IID_PPV_ARG(IPropertyBag, &ppb));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ppb->Read(bstrPropertyName, pvProperty, NULL);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
// Return a NULL-variant
|
|
VariantInit(pvProperty);
|
|
pvProperty->vt = VT_NULL;
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
ppb->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::SetWizardButtons(
|
|
/* [in] */ VARIANT_BOOL vfEnableBack,
|
|
/* [in] */ VARIANT_BOOL vfEnableNext,
|
|
/* [in] */ VARIANT_BOOL vfLastPage)
|
|
{
|
|
// We ignore vfLastPage because it isn't the last page for us!
|
|
DWORD dwButtons = 0;
|
|
|
|
if (vfEnableBack)
|
|
dwButtons |= PSWIZB_BACK;
|
|
|
|
if (vfEnableNext)
|
|
dwButtons |= PSWIZB_NEXT;
|
|
|
|
PropSheet_SetWizButtons(_hwndFrame, dwButtons);
|
|
return S_OK;
|
|
}
|
|
|
|
void CWebWizardPage::_SetHeaderText(LPCWSTR pszHeader, LPCWSTR pszSubHeader)
|
|
{
|
|
int iPageNumber = PropSheet_HwndToIndex(_hwndFrame, _hwnd);
|
|
if (-1 != iPageNumber)
|
|
{
|
|
PropSheet_SetHeaderTitle(_hwndFrame, iPageNumber, pszHeader);
|
|
PropSheet_SetHeaderSubTitle(_hwndFrame, iPageNumber, pszSubHeader);
|
|
}
|
|
}
|
|
|
|
HRESULT CWebWizardPage::SetHeaderText(
|
|
/* [in] */ BSTR bstrHeaderTitle,
|
|
/* [in] */ BSTR bstrHeaderSubtitle)
|
|
{
|
|
_SetHeaderText(bstrHeaderTitle, bstrHeaderSubtitle);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::PassportAuthenticate(
|
|
/* [in] */ BSTR bstrURL,
|
|
/* [retval][out] */ VARIANT_BOOL * pfAuthenticated)
|
|
{
|
|
*pfAuthenticated = VARIANT_FALSE; // the user isn't authenticated.
|
|
|
|
IXMLHttpRequest *preq;
|
|
HRESULT hr = CoCreateInstance(CLSID_XMLHTTPRequest, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IXMLHttpRequest, &preq));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
VARIANT varNULL = {0};
|
|
VARIANT varAsync = {VT_BOOL};
|
|
varAsync.boolVal = VARIANT_FALSE;
|
|
|
|
// open a post request to the destination that we have
|
|
hr = preq->open(L"GET", bstrURL, varAsync, varNULL, varNULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
VARIANT varBody = {0};
|
|
hr = preq->send(varBody);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
long lStatus;
|
|
hr = preq->get_status(&lStatus);
|
|
if (SUCCEEDED(hr) && (lStatus == HTTP_STATUS_OK))
|
|
{
|
|
*pfAuthenticated = VARIANT_TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL CWebWizardPage::_IsBrowserVisible()
|
|
{
|
|
return IsWindowVisible(_hwndOCHost);
|
|
}
|
|
|
|
void CWebWizardPage::_ShowBrowser(BOOL fShow)
|
|
{
|
|
ShowWindow(_hwndOCHost, fShow ? SW_SHOW : SW_HIDE);
|
|
|
|
if (fShow)
|
|
{
|
|
// Can't have these windows overlapping.
|
|
_ShowProgress(FALSE);
|
|
}
|
|
}
|
|
|
|
void CWebWizardPage::_StartShowProgressTimer()
|
|
{
|
|
_ShowProgress(FALSE);
|
|
|
|
if (!SetTimer(_hwnd, SHOW_PROGRESS_TIMER, SHOW_PROGRESS_TIMEOUT, NULL))
|
|
{
|
|
// Timer failed to set; show progress now;
|
|
_ShowProgress(TRUE);
|
|
}
|
|
}
|
|
|
|
// Size the progress bar to fit the client area it is in.
|
|
void CWebWizardPage::_SizeProgress()
|
|
{
|
|
HWND hwndProgress = GetDlgItem(_hwnd, IDC_PROGRESS);
|
|
|
|
RECT rcPage;
|
|
GetClientRect(_hwnd, &rcPage);
|
|
RECT rcProgress;
|
|
GetClientRect(hwndProgress, &rcProgress);
|
|
MapWindowPoints(hwndProgress, _hwnd, (LPPOINT) &rcProgress, 2);
|
|
|
|
rcProgress.right = rcPage.right - rcProgress.left;
|
|
|
|
SetWindowPos(hwndProgress, NULL, 0, 0, rcProgress.right - rcProgress.left, rcProgress.bottom - rcProgress.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOREPOSITION);
|
|
}
|
|
|
|
void CWebWizardPage::_ShowProgress(BOOL fShow)
|
|
{
|
|
HWND hwndProgress = GetDlgItem(_hwnd, IDC_PROGRESS);
|
|
ShowWindow(hwndProgress, fShow ? SW_SHOW : SW_HIDE);
|
|
ShowWindow(GetDlgItem(_hwnd, IDC_PROGTEXT1), fShow ? SW_SHOW : SW_HIDE);
|
|
ShowWindow(GetDlgItem(_hwnd, IDC_PROGTEXT2), fShow ? SW_SHOW : SW_HIDE);
|
|
|
|
KillTimer(_hwnd, SHOW_PROGRESS_TIMER);
|
|
|
|
if (fShow)
|
|
{
|
|
SendMessage(hwndProgress, PBM_SETMARQUEE, (WPARAM) TRUE, 0);
|
|
|
|
// Set the header/subheader to a "Connecting to Internet" message.
|
|
WCHAR szTitle[256];
|
|
WCHAR szSubtitle[256];
|
|
LoadString(g_hinst, IDS_WEBDLG_TITLE, szTitle, ARRAYSIZE(szTitle));
|
|
LoadString(g_hinst, IDS_WEBDLG_SUBTITLE, szSubtitle, ARRAYSIZE(szSubtitle));
|
|
_SetHeaderText(szTitle, szSubtitle);
|
|
}
|
|
else
|
|
{
|
|
SendMessage(hwndProgress, PBM_SETMARQUEE, (WPARAM) FALSE, 0);
|
|
}
|
|
}
|
|
|
|
|
|
// IWizardExtn
|
|
|
|
UINT CWebWizardPage::PropPageProc(HWND hwndDlg, UINT uMsg, PROPSHEETPAGE *ppsp)
|
|
{
|
|
CWebWizardPage *pwwp = (CWebWizardPage*)ppsp->lParam;
|
|
switch (uMsg)
|
|
{
|
|
case PSPCB_CREATE:
|
|
return TRUE;
|
|
|
|
// we need to release our site in this scenario, we know that we won't be using it
|
|
// anymore, and to ensure that clients down have a circular refernce to us we
|
|
// release it before they call us for our final destruction.
|
|
|
|
case PSPCB_RELEASE:
|
|
ATOMICRELEASE(pwwp->_punkSite);
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT CWebWizardPage::AddPages(HPROPSHEETPAGE* aPages, UINT cPages, UINT *pnPages)
|
|
{
|
|
PROPSHEETPAGE psp = { 0 };
|
|
psp.dwSize = sizeof(psp);
|
|
psp.hInstance = g_hinst;
|
|
psp.dwFlags = PSP_DEFAULT|PSP_USECALLBACK ;
|
|
psp.pszTemplate = MAKEINTRESOURCE(DLG_WEBWIZARD);
|
|
psp.lParam = (LPARAM) this;
|
|
psp.pfnDlgProc = CWebWizardPage::StaticProc;
|
|
psp.pfnCallback = PropPageProc;
|
|
|
|
_hPage = CreatePropertySheetPage(&psp);
|
|
if (!_hPage)
|
|
return E_FAIL;
|
|
|
|
// return the page we created.
|
|
|
|
*aPages = _hPage;
|
|
*pnPages = 1;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CWebWizardPage::GetFirstPage(HPROPSHEETPAGE *phPage)
|
|
{
|
|
*phPage = _hPage;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CWebWizardPage::SetInitialURL(LPCWSTR pszDefaultURL)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
if (pszDefaultURL)
|
|
{
|
|
hr = Str_SetPtr(&_pszInitialURL, pszDefaultURL) ? S_OK:E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CWebWizardPage::SetErrorURL(LPCWSTR pszErrorURL)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
if (pszErrorURL)
|
|
{
|
|
hr = Str_SetPtr(&_pszErrorURL, pszErrorURL) ? S_OK:E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDAPI CWebWizardPage_CreateInstance(IUnknown* pUnkOuter, REFIID riid, void **ppv)
|
|
{
|
|
if (NULL != pUnkOuter)
|
|
{
|
|
return CLASS_E_NOAGGREGATION;
|
|
}
|
|
|
|
CWebWizardPage *pwwp = new CWebWizardPage();
|
|
if (!pwwp)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
HRESULT hr = pwwp->QueryInterface(riid, ppv);
|
|
pwwp->Release();
|
|
return hr;
|
|
}
|