#include "stdafx.h" #include "shimgdata.h" #include "shui.h" #include "netplace.h" #include #include #include "pubwiz.h" #include "gdiplus\gdiplus.h" #include "imgprop.h" #include "shdguid.h" #include "urlmon.h" #include "xmldomdid.h" #include "winnlsp.h" #pragma hdrstop // Helpers - moved to shell/lib in longhorn HRESULT GetServiceCurrentState(LPCWSTR pszService, DWORD *pdwCurrentState) { HRESULT hr = E_FAIL; *pdwCurrentState = SERVICE_STOPPED; SC_HANDLE hscm = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CONNECT); if (hscm) { SC_HANDLE hsvc = OpenService(hscm, pszService, SERVICE_QUERY_STATUS); if (hsvc) { SERVICE_STATUS ss; if (QueryServiceStatus(hsvc, &ss)) { *pdwCurrentState = ss.dwCurrentState; hr = S_OK; } CloseServiceHandle(hsvc); } CloseServiceHandle(hscm); } if (FAILED(hr)) { // Return interesting error codes, like service not found or access denied hr = HRESULT_FROM_WIN32(GetLastError()); if (SUCCEEDED(hr)) { // However, never return success hr = E_FAIL; } } return hr; } BOOL IsWebDavAvailable() { DWORD dwCurrentState; return (SUCCEEDED(GetServiceCurrentState(L"WebClient", &dwCurrentState)) && (dwCurrentState == SERVICE_RUNNING)); } // handle the events from the DOM as we load #define XMLDOC_LOADING 1 #define XMLDOC_LOADED 2 #define XMLDOC_INTERACTIVE 3 #define XMLDOC_COMPLETED 4 // this message is posted to the parent HWND, the lParam parse result #define MSG_XMLDOC_COMPLETED WM_APP class CXMLDOMStateChange : public IDispatch { public: CXMLDOMStateChange(IXMLDOMDocument *pdoc, HWND hwnd); ~CXMLDOMStateChange(); HRESULT Advise(BOOL fAdvise); // IUnknown STDMETHODIMP QueryInterface(REFIID riid, void **ppv); STDMETHODIMP_(ULONG) AddRef(); STDMETHODIMP_(ULONG) Release(); // IDispatch STDMETHODIMP GetTypeInfoCount( UINT *pctinfo) { return E_NOTIMPL; } STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) { return E_NOTIMPL; } STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) { return E_NOTIMPL; } STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pvar, EXCEPINFO *pExcepInfo, UINT *puArgErr); private: long _cRef; IXMLDOMDocument *_pdoc; DWORD _dwCookie; HWND _hwnd; }; // construction and IUnknown CXMLDOMStateChange::CXMLDOMStateChange(IXMLDOMDocument *pdoc, HWND hwnd) : _cRef(1), _dwCookie(0), _hwnd(hwnd) { IUnknown_Set((IUnknown**)&_pdoc, pdoc); } CXMLDOMStateChange::~CXMLDOMStateChange() { IUnknown_Set((IUnknown**)&_pdoc, NULL); } ULONG CXMLDOMStateChange::AddRef() { return InterlockedIncrement(&_cRef); } ULONG CXMLDOMStateChange::Release() { ASSERT( 0 != _cRef ); ULONG cRef = InterlockedDecrement(&_cRef); if ( 0 == cRef ) { delete this; } return cRef; } HRESULT CXMLDOMStateChange::QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENT(CXMLDOMStateChange, IDispatch), { 0 }, }; return QISearch(this, qit, riid, ppv); } // handle the advise/unadvise to the parent object HRESULT CXMLDOMStateChange::Advise(BOOL fAdvise) { IConnectionPointContainer *pcpc; HRESULT hr = _pdoc->QueryInterface(IID_PPV_ARG(IConnectionPointContainer, &pcpc)); if (SUCCEEDED(hr)) { IConnectionPoint *pcp; hr = pcpc->FindConnectionPoint(DIID_XMLDOMDocumentEvents, &pcp); if (SUCCEEDED(hr)) { if (fAdvise) { hr = pcp->Advise(SAFECAST(this, IDispatch *), &_dwCookie); } else if (_dwCookie) { hr = pcp->Unadvise(_dwCookie); _dwCookie = 0; } pcp->Release(); } pcpc->Release(); } return hr; } // handle the invoke for the doc state changing HRESULT CXMLDOMStateChange::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pvar, EXCEPINFO *pExcepInfo, UINT *puArgErr) { HRESULT hr = S_OK; switch (dispIdMember) { case DISPID_XMLDOMEVENT_ONREADYSTATECHANGE: { long lReadyState; if (SUCCEEDED(_pdoc->get_readyState(&lReadyState))) { if (lReadyState == XMLDOC_COMPLETED) { IXMLDOMParseError *pdpe; hr = _pdoc->get_parseError(&pdpe); if (SUCCEEDED(hr)) { long lError; hr = pdpe->get_errorCode(&lError); if (SUCCEEDED(hr)) { hr = (HRESULT)lError; } PostMessage(_hwnd, MSG_XMLDOC_COMPLETED, 0, (LPARAM)hr); pdpe->Release(); } } } break; } } return hr; } // copied from shell stuff - should be in public header #define DEFINE_SCID(name, fmtid, pid) const SHCOLUMNID name = { fmtid, pid } DEFINE_SCID(SCID_NAME, PSGUID_STORAGE, PID_STG_NAME); DEFINE_SCID(SCID_TYPE, PSGUID_STORAGE, PID_STG_STORAGETYPE); DEFINE_SCID(SCID_SIZE, PSGUID_STORAGE, PID_STG_SIZE); DEFINE_SCID(SCID_WRITETIME, PSGUID_STORAGE, PID_STG_WRITETIME); DEFINE_SCID(SCID_ImageCX, PSGUID_IMAGESUMMARYINFORMATION, PIDISI_CX); DEFINE_SCID(SCID_ImageCY, PSGUID_IMAGESUMMARYINFORMATION, PIDISI_CY); // provider XML defines the following properties #define DEFAULT_PROVIDER_SCOPE TEXT("PublishingWizard") #define FMT_PROVIDER TEXT("providermanifest/providers[@scope='%s']") #define FMT_PROVIDERS TEXT("providermanifest/providers[@scope='%s']/provider") #define ELEMENT_PROVIDERMANIFEST L"providermanifest" #define ELEMENT_PROVIDERS L"providers" #define ELEMENT_PROVIDER L"provider" #define ATTRIBUTE_ID L"id" #define ATTRIBUTE_SUPPORTEDTYPES L"supportedtypes" #define ATTRIBUTE_REQUIRESWEBDAV L"requiresWebDAV" #define ATTRIBUTE_DISPLAYNAME L"displayname" #define ATTRIBUTE_DESCRIPTION L"description" #define ATTRIBUTE_HREF L"href" #define ATTRIBUTE_ICONPATH L"iconpath" #define ATTRIBUTE_ICON L"icon" #define ELEMENT_STRINGS L"strings" #define ATTRIBUTE_LANGID L"langid" #define ELEMENT_STRING L"string" #define ATTRIBUTE_LANGID L"langid" #define ATTRIBUTE_ID L"id" // registry state is stored under the this key #define SZ_REGKEY_PUBWIZ TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\PublishingWizard") // per machine values in the registry #define SZ_REGVAL_SERVICEPARTNERID TEXT("PartnerID") // these are stored per machine under the provider #define SZ_REGVAL_FILEFILTER TEXT("ContentTypeFilter") #define SZ_REGVAL_DEFAULTPROVIDERICON TEXT("DefaultIcon") // per user values in the registry #define SZ_REGVAL_DEFAULTPROVIDER TEXT("DefaultProvider") // per provider settings #define SZ_REGVAL_MRU TEXT("LocationMRU") #define SZ_REGVAL_ALTPROVIDERS TEXT("Providers") // Properties exposed by the property bag (from the Web Service) #define PROPERTY_EXTENSIONCOUNT TEXT("UniqueExtensionCount") #define PROPERTY_EXTENSION TEXT("UniqueExtension") #define PROPERTY_TRANSFERMANIFEST TEXT("TransferManifest") // This is the COM object that exposes the publishing wizard #define WIZPAGE_WHICHFILE 0 // which file should we publish #define WIZPAGE_FETCHINGPROVIDERS 1 // provider download page #define WIZPAGE_PROVIDERS 2 // pick a service provider #define WIZPAGE_RESIZE 3 // resample the data? #define WIZPAGE_COPYING 4 // copying page #define WIZPAGE_LOCATION 5 // location page (advanced) #define WIZPAGE_FTPUSER 6 // username / password (advanced) #define WIZPAGE_FRIENDLYNAME 7 // friendly name #define WIZPAGE_MAX 8 // resize information struct { int cx; int cy; int iQuality; } _aResizeSettings[] = { { 0, 0, 0 }, { 640, 480, 80 }, // low quality { 800, 600, 80 }, // medium quality { 1024, 768, 80 }, // high quality }; typedef enum { RESIZE_NONE = 0, RESIZE_SMALL, RESIZE_MEDIUM, RESIZE_LARGE, } RESIZEOPTION; class CPublishingWizard : public IServiceProvider, IPublishingWizard, CObjectWithSite, ITransferAdviseSink, ICommDlgBrowser, IOleWindow, IWizardSite { public: CPublishingWizard(); ~CPublishingWizard(); // IUnknown STDMETHOD(QueryInterface)(REFIID riid, void **ppvObj); STDMETHOD_(ULONG,AddRef)(); STDMETHOD_(ULONG,Release)(); // IServiceProvider STDMETHODIMP QueryService(REFGUID guidService, REFIID riid, void **ppv); // IWizardExtension STDMETHODIMP AddPages(HPROPSHEETPAGE* aPages, UINT cPages, UINT *pnPages); STDMETHODIMP GetFirstPage(HPROPSHEETPAGE *phPage); STDMETHODIMP GetLastPage(HPROPSHEETPAGE *phPage); // IWizardSite STDMETHODIMP GetPreviousPage(HPROPSHEETPAGE *phPage); STDMETHODIMP GetNextPage(HPROPSHEETPAGE *phPage); STDMETHODIMP GetCancelledPage(HPROPSHEETPAGE *phPage); // IPublishingWizard STDMETHODIMP Initialize(IDataObject *pdo, DWORD dwFlags, LPCTSTR pszServiceProvider); STDMETHODIMP GetTransferManifest(HRESULT *phrFromTransfer, IXMLDOMDocument **pdocManifest); // IOleWindow STDMETHODIMP GetWindow(HWND *phwnd) { *phwnd = _hwndCopyingPage; return S_OK; } STDMETHODIMP ContextSensitiveHelp(BOOL fEnter) { return E_NOTIMPL; } // ICommDlgBrowser STDMETHOD(OnDefaultCommand)(IShellView *ppshv) { return E_NOTIMPL; } STDMETHOD(OnStateChange)(IShellView *ppshv, ULONG uChange); STDMETHOD(IncludeObject)(IShellView *ppshv, LPCITEMIDLIST lpItem); // ITransferAdviseSink STDMETHODIMP PreOperation (const STGOP op, IShellItem *psiItem, IShellItem *psiDest); STDMETHODIMP ConfirmOperation(IShellItem *psiItem, IShellItem *psiDest, STGTRANSCONFIRMATION stc, LPCUSTOMCONFIRMATION pcc) { return STRESPONSE_CONTINUE; } STDMETHODIMP OperationProgress(const STGOP op, IShellItem *psiItem, IShellItem *psiDest, ULONGLONG ulTotal, ULONGLONG ulComplete); STDMETHODIMP PostOperation(const STGOP op, IShellItem *psiItem, IShellItem *psiDest, HRESULT hrResult) { return S_OK; } STDMETHODIMP QueryContinue() { return _fCancelled ? S_FALSE : S_OK; } private: LONG _cRef; // object lifetime count IDataObject *_pdo; // data object provided by the site IDataObject *_pdoSelection; // this is the selection IDataObject - used instead of _pdo if defined DWORD _dwFlags; // flags provided by the site TCHAR _szProviderScope[MAX_PATH]; // provider scope (eg. Web Publishing) BOOL _fOfferResize; // show the resize page - pictures/music etc RESIZEOPTION _ro; // resize setting we will use BOOL _fUsingTemporaryProviders; // temporary provider listed pull in, replace when we can BOOL _fRecomputeManifest; // recompute the manifest BOOL _fRepopulateProviders; // repopulate the providers list BOOL _fShownCustomLocation; // show the custom locaiton page BOOL _fShownUserName; // password page was shown BOOL _fValidating; // validating a server (Advanced path); BOOL _fCancelled; // operation was cancelled BOOL _fTransferComplete; // transfer completed. HWND _hwndSelector; // hwnd for the selector dialog HWND _hwndCopyingPage; int _iPercentageComplete; // % compelte of this transfer DWORD _dwTotal; DWORD _dwCompleted; int _cFiles; // maximum number of files int _iFile; // current file we are on HRESULT _hrFromTransfer; // result of the transfer performed HPROPSHEETPAGE _aWizPages[WIZPAGE_MAX]; // page handles for this wizard (so we can navigate) IPropertyBag *_ppb; // property bag object exposed from the site IWebWizardExtension *_pwwe; // host for the HTML wizard pages IResourceMap *_prm; // resource map object we create if we can't query from the host IXMLDOMDocument *_pdocProviders; // XML dom which exposes the providers CXMLDOMStateChange *_pdscProviders; // DOMStateChange for the provider list IXMLDOMDocument *_pdocManifest; // document describing the files to be transfered LPITEMIDLIST *_aItems; // array of items we copied UINT _cItems; IAutoComplete2 *_pac; // auto complete object IUnknown *_punkACLMulti; // IObjMgr object that exposes all the enumerators IACLCustomMRU *_pmru; // custom MRU for the objects we want to list CNetworkPlace _npCustom; // net place object for handling the custom entry HCURSOR _hCursor; IFolderView *_pfv; // file selector view object TCHAR _szFilter[MAX_PATH]; // filter string read from the registry static CPublishingWizard* s_GetPPW(HWND hwnd, UINT uMsg, LPARAM lParam); static int s_FreeStringProc(void* pFreeMe, void* pData); static HRESULT s_SetPropertyFromDisp(IPropertyBag *ppb, LPCWSTR pszID, IDispatch *pdsp); static DWORD CALLBACK s_ValidateThreadProc(void *pv); static int s_CompareItems(TRANSFERITEM *pti1, TRANSFERITEM *pti2, CPublishingWizard *ppw); static UINT s_SelectorPropPageProc(HWND hwndDlg, UINT uMsg, PROPSHEETPAGE *ppsp); static INT_PTR s_SelectorDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_SelectorDlgProc(hwnd, uMsg, wParam, lParam); } static INT_PTR s_FetchProvidersDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_FetchProvidersDlgProc(hwnd, uMsg, wParam, lParam); } static INT_PTR s_ProviderDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_ProviderDlgProc(hwnd, uMsg, wParam, lParam); } static INT_PTR s_ResizeDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_ResizeDlgProc(hwnd, uMsg, wParam, lParam); } static INT_PTR s_CopyDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_CopyDlgProc(hwnd, uMsg, wParam, lParam); } static INT_PTR s_LocationDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_LocationDlgProc(hwnd, uMsg, wParam, lParam); } static INT_PTR s_UserNameDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_UserNameDlgProc(hwnd, uMsg, wParam, lParam); } static INT_PTR s_FriendlyNameDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CPublishingWizard *ppw = s_GetPPW(hwnd, uMsg, lParam); return ppw->_FriendlyNameDlgProc(hwnd, uMsg, wParam, lParam); } // these are used for publishing INT_PTR _SelectorDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); INT_PTR _FetchProvidersDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); INT_PTR _ProviderDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); INT_PTR _ResizeDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); INT_PTR _CopyDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); // these are used for ANP INT_PTR _LocationDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); INT_PTR _UserNameDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); INT_PTR _FriendlyNameDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); void _FreeProviderList(); HRESULT _GetProviderKey(HKEY hkRoot, DWORD dwAccess, LPCTSTR pszSubKey, HKEY *phkResult); void _MapDlgItemText(HWND hwnd, UINT idc, LPCTSTR pszDlgID, LPCTSTR pszResourceID); HRESULT _GetResourceMap(IResourceMap **pprm); HRESULT _LoadMappedString(LPCTSTR pszDlgID, LPCTSTR pszResourceID, LPTSTR pszBuffer, int cch); HRESULT _CreateWizardPages(); INT_PTR _WizardNext(HWND hwnd, int iPage); HRESULT _AddExtenisonToList(HDPA hdpa, LPCTSTR pszExtension); HRESULT _InitPropertyBag(LPCTSTR pszURL); int _GetSelectedItem(HWND hwndList); void _GetDefaultProvider(LPTSTR pszProvider, int cch); void _SetDefaultProvider(IXMLDOMNode *pdn); HRESULT _FetchProviderList(HWND hwnd); HRESULT _MergeLocalProviders(); int _AddProvider(HWND hwnd, IXMLDOMNode *pdn); void _PopulateProviderList(HWND hwnd); void _ProviderEnableNext(HWND hwnd); void _ProviderGetDispInfo(LV_DISPINFO *plvdi); HRESULT _ProviderNext(HWND hwnd, HPROPSHEETPAGE *phPage); void _SetWaitCursor(BOOL bOn); void _ShowExampleTip(HWND hwnd); void _LocationChanged(HWND hwnd); void _UserNameChanged(HWND hwnd); DWORD _GetAutoCompleteFlags(DWORD dwFlags); HRESULT _InitAutoComplete(); void _InitLocation(HWND hwnd); HRESULT _AddCommonItemInfo(IXMLDOMNode *pdn, TRANSFERITEM *pti); HRESULT _AddTransferItem(CDPA *pdpaItems, IXMLDOMNode *pdn); HRESULT _AddPostItem(CDPA *pdpaItems, IXMLDOMNode *pdn); void _FreeTransferManifest(); HRESULT _AddFilesToManifest(IXMLDOMDocument *pdocManifest); HRESULT _BuildTransferManifest(); HRESULT _GetUniqueTypeList(BOOL fIncludeFolder, HDPA *phdpa); HRESULT _InitTransferInfo(IXMLDOMDocument *pdocManifest, TRANSFERINFO *pti, CDPA *pdpaItems); void _TryToValidateDestination(HWND hwnd); void _InitProvidersDialog(HWND hwnd); void _SetProgress(DWORD dwCompleted, DWORD dwTotal); BOOL _HasAttributes(IShellItem *psi, SFGAOF flags); HRESULT _BeginTransfer(HWND hwnd); HPROPSHEETPAGE _TransferComplete(HRESULT hrFromTransfer); void _FriendlyNameChanged(HWND hwnd); HRESULT _CreateFavorite(IXMLDOMNode *pdnUploadInfo); int _GetRemoteIcon(LPCTSTR pszID, BOOL fCanRefresh); HRESULT _GetSiteURL(LPTSTR pszBuffer, int cchBuffer, LPCTSTR pszFilenameToCombine); void _StateChanged(); void _ShowHideFetchProgress(HWND hwnd, BOOL fShow); void _FetchComplete(HWND hwnd, HRESULT hrFromFetch); HRESULT _GetProviderString(IXMLDOMNode *pdn, USHORT idPrimary, USHORT idSub, LPCTSTR pszID, LPTSTR pszBuffer, int cch); HRESULT _GetProviderString(IXMLDOMNode *pdn, LPCTSTR pszID, LPTSTR pszBuffer, int cch); HRESULT _GeoFromLocaleInfo(LCID lcid, GEOID *pgeoID); HRESULT _GetProviderListFilename(LPTSTR pszFile, int cchFile); }; // publishing wizard obj CPublishingWizard::CPublishingWizard() : _cRef(1), _fRecomputeManifest(TRUE), _hrFromTransfer(S_FALSE) { StrCpyN(_szProviderScope, DEFAULT_PROVIDER_SCOPE, ARRAYSIZE(_szProviderScope)); // fill the default provider scope DllAddRef(); } CPublishingWizard::~CPublishingWizard() { if (_pwwe) { IUnknown_SetSite(_pwwe, NULL); _pwwe->Release(); } ATOMICRELEASE(_pdo); ATOMICRELEASE(_pdoSelection); ATOMICRELEASE(_prm); _FreeProviderList(); _FreeTransferManifest(); DllRelease(); } ULONG CPublishingWizard::AddRef() { return InterlockedIncrement(&_cRef); } ULONG CPublishingWizard::Release() { ASSERT( 0 != _cRef ); ULONG cRef = InterlockedDecrement(&_cRef); if ( 0 == cRef ) { delete this; } return cRef; } HRESULT CPublishingWizard::QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENT(CPublishingWizard, IWizardSite), // IID_IWizardSite QITABENT(CPublishingWizard, IObjectWithSite), // IID_IObjectWithSite QITABENT(CPublishingWizard, IServiceProvider), // IID_IServiceProvider QITABENT(CPublishingWizard, IPublishingWizard), // IID_IPublishingWizard QITABENT(CPublishingWizard, ITransferAdviseSink), // IID_ITransferAdviseSink QITABENTMULTI(CPublishingWizard, IQueryContinue, ITransferAdviseSink), // IID_IQueryContinue QITABENT(CPublishingWizard, IOleWindow), // IID_IOleWindow QITABENT(CPublishingWizard, ICommDlgBrowser), // IID_ICommDlgBrowser {0, 0 }, }; return QISearch(this, qit, riid, ppv); } STDAPI CPublishingWizard_CreateInstance(IUnknown* pUnkOuter, IUnknown** ppunk, LPCOBJECTINFO poi) { CPublishingWizard *pwiz = new CPublishingWizard(); if (!pwiz) { *ppunk = NULL; // incase of failure return E_OUTOFMEMORY; } HRESULT hr = pwiz->QueryInterface(IID_PPV_ARG(IUnknown, ppunk)); pwiz->Release(); return hr; } // IPublishingWizard methods HRESULT CPublishingWizard::Initialize(IDataObject *pdo, DWORD dwOptions, LPCTSTR pszServiceProvider) { IUnknown_Set((IUnknown**)&_pdo, pdo); IUnknown_Set((IUnknown**)&_pdoSelection, NULL); _dwFlags = dwOptions; _fRecomputeManifest = TRUE; // _fRepopulateProviders set when manifest rebuilt if (!pszServiceProvider) pszServiceProvider = DEFAULT_PROVIDER_SCOPE; StrCpyN(_szProviderScope, pszServiceProvider, ARRAYSIZE(_szProviderScope)); return S_OK; } HRESULT CPublishingWizard::GetTransferManifest(HRESULT *phrFromTransfer, IXMLDOMDocument **ppdocManifest) { HRESULT hr = E_UNEXPECTED; if (_ppb) { if (phrFromTransfer) *phrFromTransfer = _hrFromTransfer; if (ppdocManifest) { VARIANT var = {VT_DISPATCH}; hr = _ppb->Read(PROPERTY_TRANSFERMANIFEST, &var, NULL); if (SUCCEEDED(hr)) { hr = var.pdispVal->QueryInterface(IID_PPV_ARG(IXMLDOMDocument, ppdocManifest)); VariantClear(&var); } } else { hr = S_OK; } } return hr; } // Wizard site methods STDMETHODIMP CPublishingWizard::GetPreviousPage(HPROPSHEETPAGE *phPage) { *phPage = _aWizPages[WIZPAGE_FETCHINGPROVIDERS]; return S_OK; } STDMETHODIMP CPublishingWizard::GetNextPage(HPROPSHEETPAGE *phPage) { // lets get the next page we'd need to show if all else fails. IWizardSite *pws; HRESULT hr = _punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws)); if (SUCCEEDED(hr)) { hr = pws->GetNextPage(phPage); pws->Release(); } // if we have not transfered and we have a IDataObject then we should // advance to one of the special pages we are supposed to show. if (!_fTransferComplete && _pdo) { *phPage = _aWizPages[_fOfferResize ? WIZPAGE_RESIZE:WIZPAGE_COPYING]; } return hr; } STDMETHODIMP CPublishingWizard::GetCancelledPage(HPROPSHEETPAGE *phPage) { HRESULT hr = E_NOTIMPL; if (!_fTransferComplete) { *phPage = _TransferComplete(HRESULT_FROM_WIN32(ERROR_CANCELLED)); if (*phPage) hr = S_OK; } else { IWizardSite *pws; hr = _punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws)); if (SUCCEEDED(hr)) { hr = pws->GetCancelledPage(phPage); pws->Release(); } } return hr; } // Service provider object STDMETHODIMP CPublishingWizard::QueryService(REFGUID guidService, REFIID riid, void **ppv) { if (guidService == SID_WebWizardHost) { if (riid == IID_IPropertyBag) { return _ppb->QueryInterface(riid, ppv); } } else if (guidService == SID_SCommDlgBrowser) { return this->QueryInterface(riid, ppv); } else if (_punkSite) { return IUnknown_QueryService(_punkSite, guidService, riid, ppv); } return E_FAIL; } // IWizardExtension methods HRESULT CPublishingWizard::_CreateWizardPages() { const struct { LPCTSTR pszID; int idPage; DLGPROC dlgproc; UINT idsHeading; UINT idsSubHeading; LPFNPSPCALLBACK pfnCallback; } _wp[] = { {TEXT("wp:selector"), IDD_PUB_SELECTOR, CPublishingWizard::s_SelectorDlgProc, IDS_PUB_SELECTOR, IDS_PUB_SELECTOR_SUB, NULL}, {TEXT("wp:fetching"), IDD_PUB_FETCHPROVIDERS, CPublishingWizard::s_FetchProvidersDlgProc, IDS_PUB_FETCHINGPROVIDERS, IDS_PUB_FETCHINGPROVIDERS_SUB, CPublishingWizard::s_SelectorPropPageProc}, {TEXT("wp:destination"), IDD_PUB_DESTINATION, CPublishingWizard::s_ProviderDlgProc, IDS_PUB_DESTINATION, IDS_PUB_DESTINATION_SUB, NULL}, {TEXT("wp:resize"), IDD_PUB_RESIZE, CPublishingWizard::s_ResizeDlgProc, IDS_PUB_RESIZE, IDS_PUB_RESIZE_SUB, NULL}, {TEXT("wp:copying"), IDD_PUB_COPY, CPublishingWizard::s_CopyDlgProc, IDS_PUB_COPY, IDS_PUB_COPY_SUB, NULL}, {TEXT("wp:location"), IDD_PUB_LOCATION, CPublishingWizard::s_LocationDlgProc, IDS_PUB_LOCATION, IDS_PUB_LOCATION_SUB, NULL}, {TEXT("wp:ftppassword"), IDD_PUB_FTPPASSWORD, CPublishingWizard::s_UserNameDlgProc, IDS_PUB_FTPPASSWORD, IDS_PUB_FTPPASSWORD_SUB, NULL}, {TEXT("wp:friendlyname"),IDD_ANP_FRIENDLYNAME, CPublishingWizard::s_FriendlyNameDlgProc, IDS_ANP_FRIENDLYNAME, IDS_ANP_FRIENDLYNAME_SUB, NULL}, }; // if we haven't created the pages yet, then lets initialize our array of handlers. HRESULT hr = S_OK; if (!_aWizPages[0]) { INITCOMMONCONTROLSEX iccex = { 0 }; iccex.dwSize = sizeof (iccex); iccex.dwICC = ICC_LISTVIEW_CLASSES | ICC_PROGRESS_CLASS | ICC_LINK_CLASS; InitCommonControlsEx(&iccex); LinkWindow_RegisterClass(); // we will use the link window (can this be removed) for (int i = 0; SUCCEEDED(hr) && (i < ARRAYSIZE(_wp)) ; i++ ) { TCHAR szHeading[MAX_PATH], szSubHeading[MAX_PATH]; // if we have a resource map then load the heading and sub heading text // if there is no resource map from the parent object then we must default // the strings. IResourceMap *prm; hr = _GetResourceMap(&prm); if (SUCCEEDED(hr)) { IXMLDOMNode *pdn; hr = prm->SelectResourceScope(TEXT("dialog"), _wp[i].pszID, &pdn); if (SUCCEEDED(hr)) { prm->LoadString(pdn, L"heading", szHeading, ARRAYSIZE(szHeading)); prm->LoadString(pdn, L"subheading", szSubHeading, ARRAYSIZE(szSubHeading)); pdn->Release(); } prm->Release(); } if (FAILED(hr)) { LoadString(g_hinst, _wp[i].idsHeading, szHeading, ARRAYSIZE(szHeading)); LoadString(g_hinst, _wp[i].idsSubHeading, szSubHeading, ARRAYSIZE(szSubHeading)); } // lets create the page now that we have loaded the relevant strings, more mapping // will occur later (during dialog initialization) PROPSHEETPAGE psp = { 0 }; psp.dwSize = SIZEOF(PROPSHEETPAGE); psp.hInstance = g_hinst; psp.lParam = (LPARAM)this; psp.dwFlags = PSP_DEFAULT | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE; psp.pszTemplate = MAKEINTRESOURCE(_wp[i].idPage); psp.pfnDlgProc = _wp[i].dlgproc; psp.pszHeaderTitle = szHeading; psp.pszHeaderSubTitle = szSubHeading; if (_wp[i].pfnCallback) { psp.dwFlags |= PSP_USECALLBACK; psp.pfnCallback = _wp[i].pfnCallback; } _aWizPages[i] = CreatePropertySheetPage(&psp); hr = _aWizPages[i] ? S_OK:E_FAIL; } } return hr; } STDMETHODIMP CPublishingWizard::AddPages(HPROPSHEETPAGE* aPages, UINT cPages, UINT *pnPages) { // create our pages and then copy the handles to the buffer HRESULT hr = _CreateWizardPages(); if (SUCCEEDED(hr)) { for (int i = 0; i < ARRAYSIZE(_aWizPages); i++) { aPages[i] = _aWizPages[i]; } // we also leverage the HTML host for showing pages from the sites we are // interacting with. hr = CoCreateInstance(CLSID_WebWizardHost, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IWebWizardExtension, &_pwwe)); if (SUCCEEDED(hr)) { // NOTE: this site should be broken into a seperate object so we avoid any circular reference issues // NOTE: there is code in websvc.cpp that attempts to break this by listening for the page // NOTE: destruction and then releasing its site. IUnknown_SetSite(_pwwe, (IObjectWithSite*)this); UINT nPages; if (SUCCEEDED(_pwwe->AddPages(&aPages[i], cPages-i, &nPages))) { i += nPages; } } *pnPages = i; // the number of pages we added } return hr; } // navigation pages STDMETHODIMP CPublishingWizard::GetFirstPage(HPROPSHEETPAGE *phPage) { if (_dwFlags & SHPWHF_NOFILESELECTOR) { *phPage = _aWizPages[WIZPAGE_FETCHINGPROVIDERS]; } else { *phPage = _aWizPages[WIZPAGE_WHICHFILE]; } return S_OK; } STDMETHODIMP CPublishingWizard::GetLastPage(HPROPSHEETPAGE *phPage) { if (_fShownCustomLocation) { *phPage = _aWizPages[WIZPAGE_FRIENDLYNAME]; } else { *phPage = _aWizPages[WIZPAGE_FETCHINGPROVIDERS]; } return S_OK; } // computer this pointers for the page objects CPublishingWizard* CPublishingWizard::s_GetPPW(HWND hwnd, UINT uMsg, LPARAM lParam) { if (uMsg == WM_INITDIALOG) { PROPSHEETPAGE *ppsp = (PROPSHEETPAGE*)lParam; SetWindowLongPtr(hwnd, GWLP_USERDATA, ppsp->lParam); return (CPublishingWizard*)ppsp->lParam; } return (CPublishingWizard*)GetWindowLongPtr(hwnd, GWLP_USERDATA); } // initialize a property in the property bag from an IUnknown pointer. HRESULT CPublishingWizard::s_SetPropertyFromDisp(IPropertyBag *ppb, LPCWSTR pszID, IDispatch *pdsp) { VARIANT var = { VT_DISPATCH }; HRESULT hr = pdsp->QueryInterface(IID_PPV_ARG(IDispatch, &var.pdispVal)); if (SUCCEEDED(hr)) { hr = ppb->Write(pszID, &var); VariantClear(&var); } return hr; } // get the resource map from the site, if we can get it then us it, otherwise // we need to load the resouce map local to this DLL. HRESULT CPublishingWizard::_GetResourceMap(IResourceMap **pprm) { HRESULT hr = IUnknown_QueryService(_punkSite, SID_ResourceMap, IID_PPV_ARG(IResourceMap, pprm)); if (FAILED(hr)) { if (!_prm) { hr = CResourceMap_Initialize(L"res://netplwiz.dll/xml/resourcemap.xml", &_prm); if (SUCCEEDED(hr)) { hr = _prm->LoadResourceMap(TEXT("wizard"), _szProviderScope); if (SUCCEEDED(hr)) { hr = _prm->QueryInterface(IID_PPV_ARG(IResourceMap, pprm)); } } } else { hr = _prm->QueryInterface(IID_PPV_ARG(IResourceMap, pprm)); } } return hr; } // handle loading resource map strings HRESULT CPublishingWizard::_LoadMappedString(LPCTSTR pszDlgID, LPCTSTR pszResourceID, LPTSTR pszBuffer, int cch) { IResourceMap *prm; HRESULT hr = _GetResourceMap(&prm); if (SUCCEEDED(hr)) { IXMLDOMNode *pdn; hr = prm->SelectResourceScope(TEXT("dialog"), pszDlgID, &pdn); if (SUCCEEDED(hr)) { hr = prm->LoadString(pdn, pszResourceID, pszBuffer, cch); pdn->Release(); } prm->Release(); } return hr; } void CPublishingWizard::_MapDlgItemText(HWND hwnd, UINT idc, LPCTSTR pszDlgID, LPCTSTR pszResourceID) { TCHAR szBuffer[MAX_PATH]; if (SUCCEEDED(_LoadMappedString(pszDlgID, pszResourceID, szBuffer, ARRAYSIZE(szBuffer)))) { SetDlgItemText(hwnd, idc, szBuffer); } } // Set the wizard next (index to hpage translation) INT_PTR CPublishingWizard::_WizardNext(HWND hwnd, int iPage) { PropSheet_SetCurSel(GetParent(hwnd), _aWizPages[iPage], -1); SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)-1); return TRUE; } // get a provider key from the registry HRESULT CPublishingWizard::_GetProviderKey(HKEY hkBase, DWORD dwAccess, LPCTSTR pszSubKey, HKEY *phkResult) { TCHAR szBuffer[MAX_PATH]; wnsprintf(szBuffer, ARRAYSIZE(szBuffer), (SZ_REGKEY_PUBWIZ TEXT("\\%s")), _szProviderScope); if (pszSubKey) { StrCatBuff(szBuffer, TEXT("\\"), ARRAYSIZE(szBuffer)); StrCatBuff(szBuffer, pszSubKey, ARRAYSIZE(szBuffer)); } DWORD dwResult = RegOpenKeyEx(hkBase, szBuffer, 0, dwAccess, phkResult); if ((dwResult != ERROR_SUCCESS) && (dwAccess != KEY_READ)) { dwResult = RegCreateKeyEx(hkBase, szBuffer, 0, NULL, REG_OPTION_NON_VOLATILE, dwAccess, NULL, phkResult, NULL); } return (ERROR_SUCCESS == dwResult) ? S_OK:E_FAIL; } // compute the site URL based on the stored information we have // Enable this only for testing purposes. Allows registry to override manifest location. #define USE_REGISTRY_BASED_URL HRESULT CPublishingWizard::_GetSiteURL(LPTSTR pszBuffer, int cchBuffer, LPCTSTR pszFilenameToCombine) { DWORD cch = cchBuffer; #ifdef USE_REGISTRY_BASED_URL WCHAR szURL[INTERNET_MAX_URL_LENGTH] = {0}; DWORD cbURL = sizeof (szURL); SHGetValue(HKEY_CURRENT_USER, SZ_REGKEY_PUBWIZ, L"ProviderUrl", NULL, szURL, &cbURL); if (*szURL) { return UrlCombine(szURL, pszFilenameToCombine, pszBuffer, &cch, 0); } #endif return UrlCombine(TEXT("http://shell.windows.com/publishwizard/"), pszFilenameToCombine, pszBuffer, &cch, 0); } // get the data object from the site that we have CLIPFORMAT g_cfHIDA = 0; void InitClipboardFormats() { if (g_cfHIDA == 0) g_cfHIDA = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_SHELLIDLIST); } // DPA helpers for comparing and destroying a TRANSFERITEM structure int CALLBACK CPublishingWizard::s_CompareItems(TRANSFERITEM *pti1, TRANSFERITEM *pti2, CPublishingWizard *ppw) { return StrCmpI(pti1->szFilename, pti2->szFilename); } int _FreeFormData(FORMDATA *pfd, void *pvState) { VariantClear(&pfd->varName); VariantClear(&pfd->varValue); return 1; } int _FreeTransferItems(TRANSFERITEM *pti, void *pvState) { ILFree(pti->pidl); if (pti->psi) pti->psi->Release(); if (pti->pstrm) pti->pstrm->Release(); if (pti->dsaFormData != NULL) pti->dsaFormData.DestroyCallback(_FreeFormData, NULL); LocalFree(pti); return 1; } HRESULT CPublishingWizard::_AddCommonItemInfo(IXMLDOMNode *pdn, TRANSFERITEM *pti) { // default to the user selected resize (this will only be set if // we are using the Web Publishing Wizard). if (_ro != RESIZE_NONE) { pti->fResizeOnUpload = TRUE; pti->cxResize = _aResizeSettings[_ro].cx; pti->cyResize = _aResizeSettings[_ro].cy; pti->iQuality = _aResizeSettings[_ro].iQuality; } // give the site ultimate control over the resizing that is performed, // by checking for the element in the manifest. IXMLDOMNode *pdnResize; HRESULT hr = pdn->selectSingleNode(ELEMENT_RESIZE, &pdnResize); if (hr == S_OK) { int cx, cy, iQuality; hr = GetIntFromAttribute(pdnResize, ATTRIBUTE_CX, &cx); if (SUCCEEDED(hr)) hr = GetIntFromAttribute(pdnResize, ATTRIBUTE_CY, &cy); if (SUCCEEDED(hr)) hr = GetIntFromAttribute(pdnResize, ATTRIBUTE_QUALITY, &iQuality); if (SUCCEEDED(hr)) { pti->fResizeOnUpload = TRUE; pti->cxResize = cx; pti->cyResize = cy; pti->iQuality = iQuality; } pdnResize->Release(); } return S_OK; } HRESULT CPublishingWizard::_AddTransferItem(CDPA *pdpaItems, IXMLDOMNode *pdn) { HRESULT hr = E_OUTOFMEMORY; TRANSFERITEM *pti = (TRANSFERITEM*)LocalAlloc(LPTR, sizeof(*pti)); if (pti) { // copy the destination, and then the IDLIST for the item without // that we cannot push the file. hr = GetStrFromAttribute(pdn, ATTRIBUTE_DESTINATION, pti->szFilename, ARRAYSIZE(pti->szFilename)); if (SUCCEEDED(hr)) { int iItem; hr = GetIntFromAttribute(pdn, ATTRIBUTE_ID, &iItem); if (SUCCEEDED(hr)) { if ((iItem >= 0) && (iItem < (int)_cItems)) { hr = SHILClone(_aItems[iItem], &pti->pidl); } else { hr = E_INVALIDARG; // index is invalid, therefore can't handle item. } } } // lets add the common transfer item info if (SUCCEEDED(hr)) hr = _AddCommonItemInfo(pdn, pti); // if we have a structure then lets append it to the DPA if (SUCCEEDED(hr)) hr = (-1 == pdpaItems->AppendPtr(pti)) ? E_OUTOFMEMORY:S_OK; // failed if (FAILED(hr)) { _FreeTransferItems(pti); } } return hr; } HRESULT CPublishingWizard::_AddPostItem(CDPA *pdpaItems, IXMLDOMNode *pdn) { HRESULT hr = E_OUTOFMEMORY; TRANSFERITEM *pti = (TRANSFERITEM*)LocalAlloc(LPTR, sizeof(*pti)); if (pti) { // get the post data, from this we can work out how to post the data IXMLDOMNode *pdnPostData; if (pdn->selectSingleNode(ELEMENT_POSTDATA, &pdnPostData) == S_OK) { // we must have a HREF for the post value hr = GetStrFromAttribute(pdnPostData, ATTRIBUTE_HREF, pti->szURL, ARRAYSIZE(pti->szURL)); if (SUCCEEDED(hr)) { // we must be able to get a posting name from the element hr = GetStrFromAttribute(pdnPostData, ATTRIBUTE_NAME, pti->szName, ARRAYSIZE(pti->szName)); if (SUCCEEDED(hr)) { // lets get the posting name, we get that from the filename attribute, if that // is not defined then try and compute it from the source information // if that isn't defined the use the name attribute they gave us earlier. if (FAILED(GetStrFromAttribute(pdnPostData, ATTRIBUTE_FILENAME, pti->szFilename, ARRAYSIZE(pti->szFilename)))) { TCHAR szSource[MAX_PATH]; if (SUCCEEDED(GetStrFromAttribute(pdn, ATTRIBUTE_SOURCE, szSource, ARRAYSIZE(szSource)))) { StrCpyN(pti->szFilename, PathFindFileName(szSource), ARRAYSIZE(pti->szFilename)); } else { StrCpyN(pti->szFilename, pti->szName, ARRAYSIZE(pti->szFilename)); } } // lets get the verb we should be using (and default accordingly), therefore // we can ignore the result. StrCpyN(pti->szVerb, TEXT("POST"), ARRAYSIZE(pti->szVerb)); GetStrFromAttribute(pdnPostData, ATTRIBUTE_VERB, pti->szVerb, ARRAYSIZE(pti->szVerb)); // pick up the IDLIST for the item int iItem; hr = GetIntFromAttribute(pdn, ATTRIBUTE_ID, &iItem); if (SUCCEEDED(hr)) { hr = SHILClone(_aItems[iItem], &pti->pidl); } // do we have any form data that needs to be passed to the transfer engine // and therefore to the site. if so lets package it up now. IXMLDOMNodeList *pnl; if (SUCCEEDED(hr) && (S_OK == pdnPostData->selectNodes(ELEMENT_FORMDATA, &pnl))) { hr = pti->dsaFormData.Create(4) ? S_OK:E_FAIL; if (SUCCEEDED(hr)) { // walk the selection filling the DSA, each structure contains // two VARIANTs which we can push across to the bg thread describing the // form data we want the site to receive. long cSelection; hr = pnl->get_length(&cSelection); for (long lNode = 0; SUCCEEDED(hr) && (lNode != cSelection); lNode++) { IXMLDOMNode *pdnFormData; hr = pnl->get_item(lNode, &pdnFormData); if (SUCCEEDED(hr)) { FORMDATA fd = {0}; hr = pdnFormData->get_nodeTypedValue(&fd.varValue); if (SUCCEEDED(hr)) { IXMLDOMElement *pdelFormData; hr = pdnFormData->QueryInterface(IID_PPV_ARG(IXMLDOMElement, &pdelFormData)); if (SUCCEEDED(hr)) { hr = pdelFormData->getAttribute(ATTRIBUTE_NAME, &fd.varName); if (SUCCEEDED(hr)) { hr = (-1 == pti->dsaFormData.AppendItem(&fd)) ? E_FAIL:S_OK; } pdelFormData->Release(); } } // failed to fully create the form data, so lets release if (FAILED(hr)) _FreeFormData(&fd, NULL); pdnFormData->Release(); } } pnl->Release(); } } } } } else { hr = E_FAIL; } // lets add the common transfer item info if (SUCCEEDED(hr)) hr = _AddCommonItemInfo(pdn, pti); // if we have a structure then lets append it to the DPA if (SUCCEEDED(hr)) hr = (-1 == pdpaItems->AppendPtr(pti)) ? E_OUTOFMEMORY:S_OK; // failed if (FAILED(hr)) _FreeTransferItems(pti); } return hr; } HRESULT CPublishingWizard::_InitTransferInfo(IXMLDOMDocument *pdocManifest, TRANSFERINFO *pti, CDPA *pdpaItems) { // pull the destination and shortcut information from the manifest into the // transfer info structure. IXMLDOMNode *pdn; HRESULT hr = pdocManifest->selectSingleNode(XPATH_UPLOADINFO, &pdn); if (SUCCEEDED(hr)) { if (hr == S_OK) { // get the friendly name for the site, this is stored in the upload information, this can fail. if (FAILED(GetStrFromAttribute(pdn, ATTRIBUTE_FRIENDLYNAME, pti->szSiteName, ARRAYSIZE(pti->szSiteName)))) { // B2: handle this so that MSN still works, we moved the friendly name attribute to // a to the element, however they were locked down and couldn't take // that change, therefore ensure that we pick this up from its previous location. IXMLDOMNode *pdnTarget; if (S_OK == pdn->selectSingleNode(ELEMENT_TARGET, &pdnTarget)) { GetStrFromAttribute(pdnTarget, ATTRIBUTE_FRIENDLYNAME, pti->szSiteName, ARRAYSIZE(pti->szSiteName)); pdnTarget->Release(); } } // from the manifest lets read the file location and then the net place creation information // this is then placed into the transfer info strucuture which we used on the bg thread // to both upload the files and also create a net place. if (FAILED(GetURLFromElement(pdn, ELEMENT_TARGET, pti->szFileTarget, ARRAYSIZE(pti->szFileTarget)))) { pti->fUsePost = TRUE; // if we don't get the target string then we are posting } // we have the target for upload to, then lets pick up the optional information about // the site, and the net place. if (SUCCEEDED(GetURLFromElement(pdn, ELEMENT_NETPLACE, pti->szLinkTarget, ARRAYSIZE(pti->szLinkTarget)))) { IXMLDOMNode *pdnNetPlace; if (pdn->selectSingleNode(ELEMENT_NETPLACE, &pdnNetPlace) == S_OK) { GetStrFromAttribute(pdnNetPlace, ATTRIBUTE_FILENAME, pti->szLinkName, ARRAYSIZE(pti->szLinkName)); GetStrFromAttribute(pdnNetPlace, ATTRIBUTE_COMMENT, pti->szLinkDesc, ARRAYSIZE(pti->szLinkDesc)); pdnNetPlace->Release(); } // fix up the site name from the link description if its not defined. if (!pti->szSiteName[0] && pti->szLinkDesc) { StrCpyN(pti->szSiteName, pti->szLinkDesc, ARRAYSIZE(pti->szSiteName)); } } // get the site URL GetURLFromElement(pdn, ELEMENT_HTMLUI, pti->szSiteURL, ARRAYSIZE(pti->szSiteURL)); } else { hr = E_FAIL; } } // if they want a DPA of items then lets create them one, this is also based on the manifest. if (SUCCEEDED(hr) && pdpaItems) { hr = (pdpaItems->Create(16)) ? S_OK:E_OUTOFMEMORY; if (SUCCEEDED(hr)) { IXMLDOMNodeList *pnl; hr = pdocManifest->selectNodes(XPATH_ALLFILESTOUPLOAD, &pnl); if (hr == S_OK) { long cSelection; hr = pnl->get_length(&cSelection); for (long lNode = 0; SUCCEEDED(hr) && (lNode != cSelection); lNode++) { IXMLDOMNode *pdn; hr = pnl->get_item(lNode, &pdn); if (SUCCEEDED(hr)) { if (pti->fUsePost) hr = _AddPostItem(pdpaItems, pdn); else hr = _AddTransferItem(pdpaItems, pdn); pdn->Release(); } } pnl->Release(); } // if we are *NOT* posting then sort the DPA so that we can support // enum items correctly. if (!pti->fUsePost) { pdpaItems->SortEx(s_CompareItems, this); // sort the DPA so we can search better } } } return hr; } // File selector dialog HRESULT CPublishingWizard::IncludeObject(IShellView *ppshv, LPCITEMIDLIST pidl) { BOOL fInclude = FALSE; LPITEMIDLIST pidlFolder; HRESULT hr = SHGetIDListFromUnk(ppshv, &pidlFolder); if (SUCCEEDED(hr)) { IShellFolder *psf; hr = SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidlFolder, &psf)); if (SUCCEEDED(hr)) { // cannot publish folders, but can publish ZIP files (which are both folder and stream at the same time) if (!(SHGetAttributes(psf, pidl, SFGAO_FOLDER | SFGAO_STREAM) == SFGAO_FOLDER)) { // filter based on the content type if we are given a filter string if (_szFilter[0]) { TCHAR szBuffer[MAX_PATH]; hr = DisplayNameOf(psf, pidl, SHGDN_FORPARSING, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { TCHAR szContentType[MAX_PATH]; DWORD cch = ARRAYSIZE(szContentType); hr = AssocQueryString(0, ASSOCSTR_CONTENTTYPE, szBuffer, NULL, szContentType, &cch); fInclude = SUCCEEDED(hr) && PathMatchSpec(szContentType, _szFilter); } } else { fInclude = TRUE; } } psf->Release(); } ILFree(pidlFolder); } return fInclude ? S_OK:S_FALSE; } // handle the state changing in the dialog and therefore us updating the buttons & status void CPublishingWizard::_StateChanged() { int cItemsChecked = 0; int cItems = 0; if (_pfv) { _pfv->ItemCount(SVGIO_ALLVIEW, &cItems); _pfv->ItemCount(SVGIO_CHECKED, &cItemsChecked); } // format and display the status bar for this item TCHAR szFmt[MAX_PATH]; if (FAILED(_LoadMappedString(L"wp:selector", L"countfmt", szFmt, ARRAYSIZE(szFmt)))) { LoadString(g_hinst, IDS_PUB_SELECTOR_FMT, szFmt, ARRAYSIZE(szFmt)); } TCHAR szBuffer[MAX_PATH]; FormatMessageTemplate(szFmt, szBuffer, ARRAYSIZE(szBuffer), cItemsChecked, cItems); SetDlgItemText(_hwndSelector, IDC_PUB_SELECTORSTATUS, szBuffer); // ensure that Next is only enabled when we have checked some items in the view PropSheet_SetWizButtons(GetParent(_hwndSelector), ((cItemsChecked > 0) ? PSWIZB_NEXT:0) | PSWIZB_BACK); } HRESULT CPublishingWizard::OnStateChange(IShellView *pshv, ULONG uChange) { if (uChange == CDBOSC_STATECHANGE) { _StateChanged(); _fRecomputeManifest = TRUE; } return S_OK; } UINT CPublishingWizard::s_SelectorPropPageProc(HWND hwndDlg, UINT uMsg, PROPSHEETPAGE *ppsp) { CPublishingWizard *ppw = (CPublishingWizard*)ppsp->lParam; switch (uMsg) { case PSPCB_CREATE: return TRUE; // we are cleaning up the page, lets ensure that we release file view object // if we have one. that way our reference count correctly reflects our state // rather than us ending up with a circular reference to other objects case PSPCB_RELEASE: if (ppw->_pfv) { IUnknown_SetSite(ppw->_pfv, NULL); ATOMICRELEASE(ppw->_pfv); } break; } return FALSE; } INT_PTR CPublishingWizard::_SelectorDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_INITDIALOG: { _hwndSelector = hwnd; // lets read the default state for this provider from a key in the registry // this will define the types of files we are going to allow, the format is // a spec (eg. image/* means all images), each element can be seperated by a ; HKEY hkProvider; HRESULT hr = _GetProviderKey(HKEY_LOCAL_MACHINE, KEY_READ, NULL, &hkProvider); if (SUCCEEDED(hr)) { DWORD cbFilter = sizeof(TCHAR)*ARRAYSIZE(_szFilter); SHGetValue(hkProvider, NULL, SZ_REGVAL_FILEFILTER, NULL, _szFilter, &cbFilter); RegCloseKey(hkProvider); } // create the file picker object, align with the hidden control on the window // and initialize with the IDataObject which contains the selection. hr = CoCreateInstance(CLSID_FolderViewHost, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IFolderView, &_pfv)); if (SUCCEEDED(hr)) { IUnknown_SetSite(_pfv, (IObjectWithSite*)this); IFolderViewHost *pfvh; hr = _pfv->QueryInterface(IID_PPV_ARG(IFolderViewHost, &pfvh)); if (SUCCEEDED(hr)) { RECT rc; GetWindowRect(GetDlgItem(hwnd, IDC_PUB_SELECTOR), &rc); MapWindowRect(HWND_DESKTOP, hwnd, &rc); InitClipboardFormats(); // initialize walks data object hr = pfvh->Initialize(hwnd, _pdo, &rc); if (SUCCEEDED(hr)) { HWND hwndPicker; hr = IUnknown_GetWindow(_pfv, &hwndPicker); if (SUCCEEDED(hr)) { SetWindowPos(hwndPicker, HWND_TOP, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE); } } pfvh->Release(); } if (FAILED(hr)) { ATOMICRELEASE(_pfv); } } return TRUE; } case WM_COMMAND: { if (HIWORD(wParam) == BN_CLICKED) { switch (LOWORD(wParam)) { case IDC_PUB_ALL: case IDC_PUB_NOTHING: if (_pfv) { int cItems; HRESULT hr = _pfv->ItemCount(SVGIO_ALLVIEW, &cItems); for (int iItem = 0; SUCCEEDED(hr) && (iItem != cItems); iItem++) { BOOL fSelect = (LOWORD(wParam) == IDC_PUB_ALL); hr = _pfv->SelectItem(iItem, SVSI_NOSTATECHANGE | (fSelect ? SVSI_CHECK:0)); } break; } } break; } } case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case PSN_SETACTIVE: { if (_pfv) { _StateChanged(); PostMessage(hwnd, WM_APP, 0, 0); } else { // no IFolderView, so lets skip this page. int i = PropSheet_PageToIndex(GetParent(hwnd), _aWizPages[WIZPAGE_FETCHINGPROVIDERS]); SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)PropSheet_IndexToId(GetParent(hwnd), i)); } return TRUE; } case PSN_WIZNEXT: { if (_fRecomputeManifest && _pfv) { IDataObject *pdo; HRESULT hr = _pfv->Items(SVGIO_CHECKED, IID_PPV_ARG(IDataObject, &pdo)); if (SUCCEEDED(hr)) { IUnknown_Set((IUnknown**)&_pdoSelection, pdo); pdo->Release(); } } return _WizardNext(hwnd, WIZPAGE_FETCHINGPROVIDERS); } case PSN_WIZBACK: { if (_punkSite) { IWizardSite *pws; if (SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws)))) { HPROPSHEETPAGE hpage; if (SUCCEEDED(pws->GetPreviousPage(&hpage))) { PropSheet_SetCurSel(GetParent(hwnd), hpage, -1); } pws->Release(); } } SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)-1); return TRUE; } } break; } // this is to work around the issue where defview (listview) forces a redraw of itself // in a non-async way when it receives a SetFocus, therefore causing it to render // incorrectly in the wizard frame. to fix this we post ourselves a WM_APP during the // handle of PSN_SETACTIVE, and then turn around and call RedrawWindow. case WM_APP: { HWND hwndPicker; if (SUCCEEDED(IUnknown_GetWindow(_pfv, &hwndPicker))) { RedrawWindow(hwndPicker, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN); } break; } } return FALSE; } // tidy up and release the providers list void CPublishingWizard::_FreeProviderList() { if (_pdscProviders) _pdscProviders->Advise(FALSE); IUnknown_Set((IUnknown**)&_pdscProviders, NULL); IUnknown_Set((IUnknown**)&_pdocProviders, NULL); // discard the previous providers. } // begin a download of the provider list, we pull the providers list async from the server // therefore we need to register a state change monitor so that we can pull the information // dynamically and then receive a message to merge in our extra data. #define FETCH_TIMERID 1 #define FETCH_TIMEOUT 1000 HRESULT CPublishingWizard::_GeoFromLocaleInfo(LCID lcid, GEOID *pgeoID) { TCHAR szBuf[128] = {0}; if (GetLocaleInfo(lcid, LOCALE_IGEOID | LOCALE_RETURN_NUMBER, szBuf, ARRAYSIZE(szBuf)) > 0) { *pgeoID = *((LPDWORD)szBuf); return S_OK; } return E_FAIL; } HRESULT CPublishingWizard::_GetProviderListFilename(LPTSTR pszFile, int cchFile) { HRESULT hr = S_OK; GEOID idGEO = GetUserGeoID(GEOCLASS_NATION); if (idGEO == GEOID_NOT_AVAILABLE) { hr = _GeoFromLocaleInfo(GetUserDefaultLCID(), &idGEO); if (FAILED(hr)) hr = _GeoFromLocaleInfo(GetSystemDefaultLCID(), &idGEO); if (FAILED(hr)) hr = _GeoFromLocaleInfo((MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)), &idGEO); // default to US English } if (SUCCEEDED(hr) && (idGEO != GEOID_NOT_AVAILABLE)) { // read the provider prefix from the registry int cchProvider = 0; DWORD cbFile = sizeof(TCHAR)*cchFile; if (ERROR_SUCCESS == SHGetValue(HKEY_LOCAL_MACHINE, SZ_REGKEY_PUBWIZ, SZ_REGVAL_SERVICEPARTNERID, NULL, pszFile, &cbFile)) { StrCatBuff(pszFile, TEXT("."), cchFile); cchProvider = lstrlen(pszFile); } // build .xml into the buffer (as a suffix of the partner if needed) GetGeoInfo(idGEO, GEO_ISO3, pszFile + cchProvider, cchFile - cchProvider, 0); StrCatBuff(pszFile, TEXT(".xml"), cchFile); CharLowerBuff(pszFile, lstrlen(pszFile)); } else if (SUCCEEDED(hr)) { hr = E_FAIL; } return hr; } HRESULT CPublishingWizard::_FetchProviderList(HWND hwnd) { _FreeProviderList(); HRESULT hr = HRESULT_FROM_WIN32(ERROR_ACCESS_DISABLED_BY_POLICY); if (!SHRestricted(REST_NOWEBSERVICES)) { hr = CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IXMLDOMDocument, &_pdocProviders)); if (SUCCEEDED(hr)) { TCHAR szFile[MAX_PATH]; hr = _GetProviderListFilename(szFile, ARRAYSIZE(szFile)); if (SUCCEEDED(hr)) { TCHAR szBuffer[INTERNET_MAX_URL_LENGTH]; hr = _GetSiteURL(szBuffer, ARRAYSIZE(szBuffer), szFile); if (SUCCEEDED(hr)) { LaunchICW(); if (InternetGoOnline(szBuffer, hwnd, 0)) { _pdscProviders = new CXMLDOMStateChange(_pdocProviders, hwnd); if (_pdscProviders) { hr = _pdscProviders->Advise(TRUE); if (SUCCEEDED(hr)) { VARIANT varName; hr = InitVariantFromStr(&varName, szBuffer); if (SUCCEEDED(hr)) { VARIANT_BOOL fSuccess; hr = _pdocProviders->load(varName, &fSuccess); if (FAILED(hr) || (fSuccess != VARIANT_TRUE)) { hr = FAILED(hr) ? hr:E_FAIL; } VariantClear(&varName); } } } else { hr = E_OUTOFMEMORY; } } else { hr = E_FAIL; } } } } } // if any of this failed then lets post ourselves the completed message // with the failure code, at which point we can then load the default document. if (FAILED(hr)) PostMessage(hwnd, MSG_XMLDOC_COMPLETED, 0, (LPARAM)hr); return hr; } void CPublishingWizard::_FetchComplete(HWND hwnd, HRESULT hr) { // if we failed to load the document then lets pull in the default provider // list from our DLL, this can also fail, but its unlikely to. we recreate // the XML DOM object to ensure our state is pure. _fUsingTemporaryProviders = FAILED(hr); _fRepopulateProviders = TRUE; // provider list will have changed! if (FAILED(hr)) { _FreeProviderList(); hr = CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IXMLDOMDocument, &_pdocProviders)); if (SUCCEEDED(hr)) { VARIANT varName; hr = InitVariantFromStr(&varName, TEXT("res://netplwiz.dll/xml/providers.xml")); if (SUCCEEDED(hr)) { VARIANT_BOOL fSuccess = VARIANT_FALSE; hr = _pdocProviders->load(varName, &fSuccess); if (FAILED(hr) || (fSuccess != VARIANT_TRUE)) { hr = FAILED(hr) ? hr:E_FAIL; } VariantClear(&varName); } } } KillTimer(hwnd, FETCH_TIMERID); _ShowHideFetchProgress(hwnd, FALSE); _WizardNext(hwnd, WIZPAGE_PROVIDERS); } void CPublishingWizard::_ShowHideFetchProgress(HWND hwnd, BOOL fShow) { ShowWindow(GetDlgItem(hwnd, IDC_PUB_SRCHPROVIDERS), fShow ? SW_SHOW:SW_HIDE); ShowWindow(GetDlgItem(hwnd, IDC_PUB_SRCHPROVIDERS_STATIC1), fShow ? SW_SHOW:SW_HIDE); ShowWindow(GetDlgItem(hwnd, IDC_PUB_SRCHPROVIDERS_STATIC2), fShow ? SW_SHOW:SW_HIDE); SendDlgItemMessage(hwnd, IDC_PUB_SRCHPROVIDERS, PBM_SETMARQUEE, (WPARAM)fShow, 0); } INT_PTR CPublishingWizard::_FetchProvidersDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_INITDIALOG: _MapDlgItemText(hwnd, IDC_PUB_SRCHPROVIDERS_STATIC1, L"wp:destination", L"downloading"); break; case MSG_XMLDOC_COMPLETED: _FetchComplete(hwnd, (HRESULT)lParam); break; case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case PSN_SETACTIVE: { BOOL fFetch = TRUE; if (_pdocProviders && !_fUsingTemporaryProviders) { long lReadyState; HRESULT hr = _pdocProviders->get_readyState(&lReadyState); if (SUCCEEDED(hr) && (lReadyState == XMLDOC_COMPLETED)) { _WizardNext(hwnd, WIZPAGE_PROVIDERS); fFetch = FALSE; } } if (fFetch) { SetTimer(hwnd, FETCH_TIMERID, FETCH_TIMEOUT, NULL); _FetchProviderList(hwnd); PropSheet_SetWizButtons(GetParent(hwnd), 0x0); } return TRUE; } } break; } case WM_TIMER: { KillTimer(hwnd, FETCH_TIMERID); _ShowHideFetchProgress(hwnd, TRUE); return TRUE; } } return FALSE; } // Destination page int CPublishingWizard::_GetSelectedItem(HWND hwndList) { int iSelected = ListView_GetNextItem(hwndList, -1, LVNI_FOCUSED|LVNI_SELECTED); if (iSelected == -1) { iSelected = ListView_GetNextItem(hwndList, -1, LVNI_SELECTED); } return iSelected; } void CPublishingWizard::_ProviderEnableNext(HWND hwnd) { DWORD dwButtons = PSWIZB_BACK; // there must be an item available in the list, and it must have a ID property defined // for it so it can be enabled. int iSelected = _GetSelectedItem(GetDlgItem(hwnd, IDC_PUB_PROVIDERS)); if (iSelected != -1) { LVITEM lvi = { 0 }; lvi.iItem = iSelected; lvi.mask = LVIF_PARAM; if (ListView_GetItem(GetDlgItem(hwnd, IDC_PUB_PROVIDERS), &lvi)) { IXMLDOMNode *pdn = (IXMLDOMNode*)lvi.lParam; TCHAR szID[INTERNET_MAX_URL_LENGTH]; if (SUCCEEDED(GetStrFromAttribute(pdn, ATTRIBUTE_ID, szID, ARRAYSIZE(szID)))) { dwButtons |= PSWIZB_NEXT; } } } PropSheet_SetWizButtons(GetParent(hwnd), dwButtons); } // extract an icon resource from the provider XML documents. the icons are stored as // mime encoded bitmaps that we decode into files in the users settings folder. we return // an index to the shared image list. int CPublishingWizard::_GetRemoteIcon(LPCTSTR pszID, BOOL fCanRefresh) { int iResult = -1; TCHAR szURL[INTERNET_MAX_URL_LENGTH]; HRESULT hr = _GetSiteURL(szURL, ARRAYSIZE(szURL), pszID); if (SUCCEEDED(hr)) { TCHAR szFilename[MAX_PATH]; hr = URLDownloadToCacheFile(NULL, szURL, szFilename, ARRAYSIZE(szFilename), 0x0, NULL); if (SUCCEEDED(hr)) { iResult = Shell_GetCachedImageIndex(szFilename, 0x0, 0x0); } } return iResult; } // get the provider list from the internet struct { LPTSTR pszAttribute; BOOL fIsString; } aProviderElements[] = { { ATTRIBUTE_SUPPORTEDTYPES, FALSE }, { ATTRIBUTE_REQUIRESWEBDAV, FALSE }, { ATTRIBUTE_DISPLAYNAME, TRUE }, { ATTRIBUTE_DESCRIPTION, TRUE }, { ATTRIBUTE_HREF, FALSE }, { ATTRIBUTE_ICONPATH, FALSE }, { ATTRIBUTE_ICON, FALSE }, }; HRESULT CPublishingWizard::_MergeLocalProviders() { TCHAR szBuffer[MAX_PATH]; wnsprintf(szBuffer, ARRAYSIZE(szBuffer), FMT_PROVIDER, _szProviderScope); IXMLDOMNode *pdn; HRESULT hr = _pdocProviders->selectSingleNode(szBuffer, &pdn); if (hr == S_OK) { HKEY hk; hr = _GetProviderKey(HKEY_CURRENT_USER, KEY_READ, SZ_REGVAL_ALTPROVIDERS, &hk); if (SUCCEEDED(hr)) { for (int i =0; SUCCEEDED(hr) && (RegEnumKey(hk, i, szBuffer, ARRAYSIZE(szBuffer)) == ERROR_SUCCESS); i++) { // the manifest always overrides the entries that are stored in the registry, // therefore if there is an element in the document that has a matching ID to the // one in the registry then lets handle it. TCHAR szSelectValue[MAX_PATH]; wnsprintf(szSelectValue, ARRAYSIZE(szSelectValue), TEXT("provider[@id=\"%s\"]"), szBuffer); IXMLDOMNode *pdnProvider; if (pdn->selectSingleNode(szSelectValue, &pdnProvider) == S_FALSE) { IPropertyBag *ppb; hr = SHCreatePropertyBagOnRegKey(hk, szBuffer, STGM_READ, IID_PPV_ARG(IPropertyBag, &ppb)); if (SUCCEEDED(hr)) { IXMLDOMElement *pdel; hr = _pdocProviders->createElement(ELEMENT_PROVIDER, &pdel); if (SUCCEEDED(hr)) { hr = SetAttributeFromStr(pdel, ATTRIBUTE_ID, szBuffer); if (SUCCEEDED(hr)) { // loop and replicate all the attributes from the property bag // into the element. once we have done that we can add // the element to the provider list. for (int i = 0; SUCCEEDED(hr) && (i < ARRAYSIZE(aProviderElements)); i++) { VARIANT var = {0}; if (SUCCEEDED(ppb->Read(aProviderElements[i].pszAttribute, &var, NULL))) { hr = pdel->setAttribute(aProviderElements[i].pszAttribute, var); VariantClear(&var); } } if (SUCCEEDED(hr)) { hr = pdn->appendChild(pdel, NULL); } } pdel->Release(); } ppb->Release(); } } else { pdnProvider->Release(); } } RegCloseKey(hk); } pdn->Release(); } return hr; } void CPublishingWizard::_GetDefaultProvider(LPTSTR pszProvider, int cch) { HKEY hk; HRESULT hr = _GetProviderKey(HKEY_CURRENT_USER, KEY_READ, NULL, &hk); if (SUCCEEDED(hr)) { DWORD cb = cch*sizeof(*pszProvider); SHGetValue(hk, NULL, SZ_REGVAL_DEFAULTPROVIDER, NULL, pszProvider, &cb); RegCloseKey(hk); } } void CPublishingWizard::_SetDefaultProvider(IXMLDOMNode *pdn) { TCHAR szProvider[MAX_PATH]; HRESULT hr = GetStrFromAttribute(pdn, ATTRIBUTE_ID, szProvider, ARRAYSIZE(szProvider)); if (SUCCEEDED(hr)) { HKEY hk; hr = _GetProviderKey(HKEY_CURRENT_USER, KEY_WRITE, NULL, &hk); if (SUCCEEDED(hr)) { // store the default provider value DWORD cb = (lstrlen(szProvider)+1)*sizeof(*szProvider); SHSetValue(hk, NULL, SZ_REGVAL_DEFAULTPROVIDER, REG_SZ, szProvider, cb); // we now need to replicate the properties from the DOM into the registry so that // the user can always get to the specified site. to make this easier we // will create a property bag that we will copy values using. TCHAR szBuffer[MAX_PATH]; wnsprintf(szBuffer, ARRAYSIZE(szBuffer), (SZ_REGVAL_ALTPROVIDERS TEXT("\\%s")), szProvider); IPropertyBag *ppb; hr = SHCreatePropertyBagOnRegKey(hk, szBuffer, STGM_CREATE | STGM_WRITE, IID_PPV_ARG(IPropertyBag, &ppb)); if (SUCCEEDED(hr)) { IXMLDOMElement *pdel; hr = pdn->QueryInterface(IID_PPV_ARG(IXMLDOMElement, &pdel)); if (SUCCEEDED(hr)) { for (int i = 0; SUCCEEDED(hr) && (i < ARRAYSIZE(aProviderElements)); i++) { VARIANT varEmpty = {0}; // VT_EMPTY if (aProviderElements[i].fIsString) { hr = _GetProviderString(pdn, aProviderElements[i].pszAttribute, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { hr = SHPropertyBag_WriteStr(ppb, aProviderElements[i].pszAttribute, szBuffer); } else { // clear out any old value for this attribute that may be stored in the registry ppb->Write(aProviderElements[i].pszAttribute, &varEmpty); } } else { VARIANT var = {0}; if (S_OK == pdel->getAttribute(aProviderElements[i].pszAttribute, &var)) { hr = ppb->Write(aProviderElements[i].pszAttribute, &var); VariantClear(&var); } else { // clear out any old value for this attribute that may be stored in the registry ppb->Write(aProviderElements[i].pszAttribute, &varEmpty); } } } pdel->Release(); } ppb->Release(); } RegCloseKey(hk); } } } // load a localized string from the XML node for the provider HRESULT CPublishingWizard::_GetProviderString(IXMLDOMNode *pdn, USHORT idPrimary, USHORT idSub, LPCTSTR pszID, LPTSTR pszBuffer, int cch) { TCHAR szPath[MAX_PATH]; wnsprintf(szPath, ARRAYSIZE(szPath), TEXT("strings[@langid='%04x']/string[@id='%s'][@langid='%04x']"), idPrimary, pszID, idSub); IXMLDOMNode *pdnString; HRESULT hr = pdn->selectSingleNode(szPath, &pdnString); if (hr == S_OK) { VARIANT var = {VT_BSTR}; hr = pdnString->get_nodeTypedValue(&var); if (SUCCEEDED(hr)) { VariantToStr(&var, pszBuffer, cch); VariantClear(&var); } pdnString->Release(); } return hr; } HRESULT CPublishingWizard::_GetProviderString(IXMLDOMNode *pdn, LPCTSTR pszID, LPTSTR pszBuffer, int cch) { *pszBuffer = TEXT('\0'); LANGID idLang = GetUserDefaultLangID(); HRESULT hr = _GetProviderString(pdn, PRIMARYLANGID(idLang), SUBLANGID(idLang), pszID, pszBuffer, cch); if (hr == S_FALSE) { hr = _GetProviderString(pdn, PRIMARYLANGID(idLang), SUBLANG_NEUTRAL, pszID, pszBuffer, cch); if (hr == S_FALSE) { hr = _GetProviderString(pdn, LANG_NEUTRAL, SUBLANG_NEUTRAL, pszID, pszBuffer, cch); if (hr == S_FALSE) { hr = GetStrFromAttribute(pdn, pszID, pszBuffer, cch); } } } SHLoadIndirectString(pszBuffer, pszBuffer, cch, NULL); return hr; } // populate the provider list on the destination page #define TILE_DISPLAYNAME 0 #define TILE_DESCRIPTION 1 #define TILE_MAX 1 const UINT c_auTileColumns[] = {TILE_DISPLAYNAME, TILE_DESCRIPTION}; const UINT c_auTileSubItems[] = {TILE_DESCRIPTION}; int CPublishingWizard::_AddProvider(HWND hwnd, IXMLDOMNode *pdn) { // fill out the item information LV_ITEM lvi = { 0 }; lvi.mask = LVIF_TEXT|LVIF_PARAM|LVIF_IMAGE; lvi.iItem = ListView_GetItemCount(hwnd); // always append! lvi.lParam = (LPARAM)pdn; lvi.pszText = LPSTR_TEXTCALLBACK; lvi.iImage = -1; // set to the default state // read the icon location and put that onto the item TCHAR szIcon[MAX_PATH]; if (SUCCEEDED(GetStrFromAttribute(pdn, ATTRIBUTE_ICONPATH, szIcon, ARRAYSIZE(szIcon)))) { int resid = PathParseIconLocation(szIcon); lvi.iImage = Shell_GetCachedImageIndex(szIcon, resid, 0x0); } else if (SUCCEEDED(GetStrFromAttribute(pdn, ATTRIBUTE_ICON, szIcon, ARRAYSIZE(szIcon)))) { lvi.iImage = _GetRemoteIcon(szIcon, TRUE); } // if that failed then lets try and compute a sensible default icon for us to use if (lvi.iImage == -1) { // under the provider key for the install lets see if there is a default icon that we // should be using. if not, or if that fails to extract then lets use the publishing one. HKEY hk; if (SUCCEEDED(_GetProviderKey(HKEY_LOCAL_MACHINE, KEY_READ, NULL, &hk))) { DWORD cb = ARRAYSIZE(szIcon)*sizeof(*szIcon); if (ERROR_SUCCESS == SHGetValue(hk, NULL, SZ_REGVAL_DEFAULTPROVIDERICON, NULL, szIcon, &cb)) { int resid = PathParseIconLocation(szIcon); lvi.iImage = Shell_GetCachedImageIndex(szIcon, resid, 0x0); // default to the publishing icon } RegCloseKey(hk); } if (lvi.iImage == -1) lvi.iImage = Shell_GetCachedImageIndex(TEXT("shell32.dll"), -244, 0x0); } int iResult = ListView_InsertItem(hwnd, &lvi); if (iResult != -1) { pdn->AddRef(); // it was added to the view, so take reference LVTILEINFO lvti; lvti.cbSize = sizeof(LVTILEINFO); lvti.iItem = iResult; lvti.cColumns = ARRAYSIZE(c_auTileSubItems); lvti.puColumns = (UINT*)c_auTileSubItems; ListView_SetTileInfo(hwnd, &lvti); } return iResult; } void CPublishingWizard::_PopulateProviderList(HWND hwnd) { BOOL fWebDavAvailable = IsWebDavAvailable(); HWND hwndList = GetDlgItem(hwnd, IDC_PUB_PROVIDERS); // setup the view with the tiles that we want to show and the // icon lists - shared with the shell. ListView_DeleteAllItems(hwndList); ListView_SetView(hwndList, LV_VIEW_TILE); for (int i=0; iget_readyState(&lReadyState); if (SUCCEEDED(hr) && (lReadyState == XMLDOC_COMPLETED)) { // lets merge in the local providers, these are local to this user, // we check for duplicates so this shouldn't present too much hardship. _MergeLocalProviders(); // format a query to return the providers that match our publishing scope, // this will allow the wizard to show different lists of providers for // web publishing vs. internet printing WCHAR szBuffer[MAX_PATH]; wnsprintf(szBuffer, ARRAYSIZE(szBuffer), FMT_PROVIDERS, _szProviderScope); IXMLDOMNodeList *pnl; hr = _pdocProviders->selectNodes(szBuffer, &pnl); if (hr == S_OK) { long cSelection; hr = pnl->get_length(&cSelection); if (SUCCEEDED(hr) && (cSelection > 0)) { // get the list of unique types from the selection we are going to try and publish HDPA hdpaUniqueTypes = NULL; _GetUniqueTypeList(FALSE, &hdpaUniqueTypes); // don't care if this fails - ptr is NULL // we need the default provider to highlight correctly, using this we can then // populate the list from the provider manfiest TCHAR szDefaultProvider[MAX_PATH] = {0}; _GetDefaultProvider(szDefaultProvider, ARRAYSIZE(szDefaultProvider)); int iDefault = 0; for (long lNode = 0; lNode != cSelection; lNode++) { IXMLDOMNode *pdn; hr = pnl->get_item(lNode, &pdn); if (SUCCEEDED(hr)) { // filter based on the list of types they support, this is optional // if they don't specify anything then they are in the list, // otherwise the format is assumed to be a file spec, eg *.bmp;*.jpg; etc. BOOL fSupported = TRUE; if (hdpaUniqueTypes) { hr = GetStrFromAttribute(pdn, ATTRIBUTE_SUPPORTEDTYPES, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { fSupported = FALSE; for (int i = 0; !fSupported && (i < DPA_GetPtrCount(hdpaUniqueTypes)); i++) { LPCTSTR pszExtension = (LPCTSTR)DPA_GetPtr(hdpaUniqueTypes, i); fSupported = PathMatchSpec(pszExtension, szBuffer); } } } // If WebDav isn't installed, we don't support providers that require webdav if (fSupported && !fWebDavAvailable) { hr = GetStrFromAttribute(pdn, ATTRIBUTE_REQUIRESWEBDAV, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { fSupported = FALSE; } } // if this is a supported item then lets add it to the list if (fSupported) { hr = GetStrFromAttribute(pdn, ATTRIBUTE_ID, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { int i = _AddProvider(hwndList, pdn); if ((i != -1) && (0 == StrCmpI(szBuffer, szDefaultProvider))) { iDefault = i; } } } pdn->Release(); } } ListView_SetItemState(hwndList, iDefault, LVIS_SELECTED, LVIS_SELECTED); ListView_EnsureVisible(hwndList, iDefault, FALSE); if (hdpaUniqueTypes) DPA_DestroyCallback(hdpaUniqueTypes, s_FreeStringProc, 0); } else { // we have no providers that match this criteria therefore lets // create a dummy one which shows this to the caller IXMLDOMElement *pdelProvider; hr = _pdocManifest->createElement(ELEMENT_FILE, &pdelProvider); if (SUCCEEDED(hr)) { IResourceMap *prm; hr = _GetResourceMap(&prm); if (SUCCEEDED(hr)) { // get the no providers string if (FAILED(_LoadMappedString(L"wp:selector", L"noprovider", szBuffer, ARRAYSIZE(szBuffer)))) LoadString(g_hinst, IDS_PUB_NOPROVIDER, szBuffer, ARRAYSIZE(szBuffer)); hr = SetAttributeFromStr(pdelProvider, ATTRIBUTE_DISPLAYNAME, szBuffer); // get the sub-text for the no providers if (SUCCEEDED(hr)) { if (FAILED(_LoadMappedString(L"wp:selector", L"noproviderdesc", szBuffer, ARRAYSIZE(szBuffer)))) LoadString(g_hinst, IDS_PUB_NOPROVIDERDESC, szBuffer, ARRAYSIZE(szBuffer)); hr = SetAttributeFromStr(pdelProvider, ATTRIBUTE_DESCRIPTION, szBuffer); } // lets put together a resource string for the icon we are going to show if (SUCCEEDED(hr)) { wnsprintf(szBuffer, ARRAYSIZE(szBuffer), TEXT("netplwiz.dll,-%d"), IDI_NOPROVIDERS); hr = SetAttributeFromStr(pdelProvider, ATTRIBUTE_ICONPATH, szBuffer); } // lets add a provider from the free standing node if (SUCCEEDED(hr)) { IXMLDOMNode *pdnProvider; hr = pdelProvider->QueryInterface(IID_PPV_ARG(IXMLDOMNode, &pdnProvider)); if (SUCCEEDED(hr)) { _AddProvider(hwndList, pdnProvider); pdnProvider->Release(); } } prm->Release(); } pdelProvider->Release(); } } pnl->Release(); } } } _fRepopulateProviders = FALSE; // providers have been populated } // handle next in the provider (destination) page HRESULT CPublishingWizard::_ProviderNext(HWND hwnd, HPROPSHEETPAGE *phPage) { HRESULT hr = E_FAIL; int iSelected = _GetSelectedItem(GetDlgItem(hwnd, IDC_PUB_PROVIDERS)); if (iSelected != -1) { LVITEM lvi = { 0 }; lvi.iItem = iSelected; lvi.mask = LVIF_PARAM; if (ListView_GetItem(GetDlgItem(hwnd, IDC_PUB_PROVIDERS), &lvi)) { IXMLDOMNode *pdn = (IXMLDOMNode*)lvi.lParam; // set the default provider from the node value _SetDefaultProvider(pdn); // now try and navigate to the web page, if no URL then show advanced path TCHAR szURL[INTERNET_MAX_URL_LENGTH]; if (SUCCEEDED(GetStrFromAttribute(pdn, ATTRIBUTE_HREF, szURL, ARRAYSIZE(szURL)))) { // get the folder creation flag from the site so that we can set the HTML wizard // into the correct state. note that the site doesn't need to specify this // and we will default to TRUE - eg. do folder creation, this allows the current // hosts to work without modification. hr = _InitPropertyBag(szURL); if (SUCCEEDED(hr)) { hr = _pwwe->GetFirstPage(phPage); } } else { // No URL was specified, so lets go through the advanced path where // the user gets to type a location and we create connection to that // (replaced the old Add Net Place functionality); *phPage = _aWizPages[WIZPAGE_LOCATION]; hr = S_OK; } } } return hr; } void CPublishingWizard::_ProviderGetDispInfo(LV_DISPINFO *plvdi) { if (plvdi->item.mask & LVIF_TEXT) { IXMLDOMNode *pdn = (IXMLDOMNode*)plvdi->item.lParam; switch (plvdi->item.iSubItem) { case TILE_DISPLAYNAME: _GetProviderString(pdn, ATTRIBUTE_DISPLAYNAME, plvdi->item.pszText, plvdi->item.cchTextMax); break; case TILE_DESCRIPTION: _GetProviderString(pdn, ATTRIBUTE_DESCRIPTION, plvdi->item.pszText, plvdi->item.cchTextMax); break; default: ASSERTMSG(0, "ListView is asking for wrong column in publishing wizard"); break; } } } void CPublishingWizard::_InitProvidersDialog(HWND hwnd) { // initial the dialog accordingly TCHAR szBuffer[MAX_PATH]; HRESULT hr = _LoadMappedString(L"wp:destination", L"providercaption", szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { SetDlgItemText(hwnd, IDC_PUB_PROVIDERSCAPTION, szBuffer); // lets size the caption area as needed, and move controls around as needed UINT ctls[] = { IDC_PUB_PROVIDERSLABEL, IDC_PUB_PROVIDERS}; int dy = SizeControlFromText(hwnd, IDC_PUB_PROVIDERSCAPTION, szBuffer); MoveControls(hwnd, ctls, ARRAYSIZE(ctls), 0, dy); // adjust the provider dialog size as needed RECT rc; GetWindowRect(GetDlgItem(hwnd, IDC_PUB_PROVIDERS), &rc); SetWindowPos(GetDlgItem(hwnd, IDC_PUB_PROVIDERS), NULL, 0, 0, RECTWIDTH(rc), RECTHEIGHT(rc)-dy, SWP_NOZORDER|SWP_NOMOVE); } // set the caption for the providers control _MapDlgItemText(hwnd, IDC_PUB_PROVIDERSLABEL, L"wp:destination", L"providerslabel"); // set the image list to the list view HIMAGELIST himlLarge, himlSmall; Shell_GetImageLists(&himlLarge, &himlSmall); ListView_SetImageList(GetDlgItem(hwnd, IDC_PUB_PROVIDERS), himlLarge, LVSIL_NORMAL); ListView_SetImageList(GetDlgItem(hwnd, IDC_PUB_PROVIDERS), himlSmall, LVSIL_SMALL); }; INT_PTR CPublishingWizard::_ProviderDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_INITDIALOG: _InitProvidersDialog(hwnd); return TRUE; case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case LVN_GETDISPINFO: _ProviderGetDispInfo((LV_DISPINFO*)pnmh); return TRUE; case LVN_ITEMCHANGED: _ProviderEnableNext(hwnd); return TRUE; case LVN_DELETEITEM: { NMLISTVIEW *nmlv = (NMLISTVIEW*)lParam; IXMLDOMNode *pdn = (IXMLDOMNode*)nmlv->lParam; pdn->Release(); return TRUE; } case PSN_SETACTIVE: { _fTransferComplete = FALSE; // we haven't started to tranfser yet _fShownCustomLocation = FALSE; // we haven't shown the custom location page if (_fRecomputeManifest) _BuildTransferManifest(); if (_fRepopulateProviders) _PopulateProviderList(hwnd); // if the manifest changes, so might the providers! _ProviderEnableNext(hwnd); return TRUE; } // when going back from the destination page, lets determine from the // site where we should be going. case PSN_WIZBACK: { if (_dwFlags & SHPWHF_NOFILESELECTOR) { if (_punkSite) { IWizardSite *pws; if (SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws)))) { HPROPSHEETPAGE hpage; if (SUCCEEDED(pws->GetPreviousPage(&hpage))) { PropSheet_SetCurSel(GetParent(hwnd), hpage, -1); } pws->Release(); } } SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)-1); } else { _WizardNext(hwnd, WIZPAGE_WHICHFILE); } return TRUE; } // when going forward lets query the next page, set the selection // and then let the foreground know whats going on. case PSN_WIZNEXT: { HPROPSHEETPAGE hpage; if (SUCCEEDED(_ProviderNext(hwnd, &hpage))) { PropSheet_SetCurSel(GetParent(hwnd), hpage, -1); } SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)-1); return TRUE; } // the item was activated, therefore we need to goto the next (in this case the page for the provider). case LVN_ITEMACTIVATE: { HPROPSHEETPAGE hpage; if (SUCCEEDED(_ProviderNext(hwnd, &hpage))) { PropSheet_SetCurSel(GetParent(hwnd), hpage, -1); } return TRUE; } } break; } } return FALSE; } // Resample/Resize dialog. This dialog is displayed when we determine that there // are images that need to be resized. INT_PTR CPublishingWizard::_ResizeDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_INITDIALOG: Button_SetCheck(GetDlgItem(hwnd, IDC_PUB_RESIZE), BST_CHECKED); Button_SetCheck(GetDlgItem(hwnd, IDC_PUB_RESIZESMALL), BST_CHECKED); return TRUE; case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case PSN_SETACTIVE: PropSheet_SetWizButtons(GetParent(hwnd), PSWIZB_BACK | PSWIZB_NEXT); return TRUE; case PSN_WIZBACK: { // if we went through the custom location stuff then navigate back into there. if (_fShownCustomLocation) return _WizardNext(hwnd, _fShownUserName ? WIZPAGE_FTPUSER:WIZPAGE_LOCATION); return _WizardNext(hwnd, WIZPAGE_PROVIDERS); } case PSN_WIZNEXT: { if (Button_GetCheck(GetDlgItem(hwnd, IDC_PUB_RESIZE)) == BST_CHECKED) { if (Button_GetCheck(GetDlgItem(hwnd, IDC_PUB_RESIZESMALL)) == BST_CHECKED) _ro = RESIZE_SMALL; else if (Button_GetCheck(GetDlgItem(hwnd, IDC_PUB_RESIZEMEDIUM)) == BST_CHECKED) _ro = RESIZE_MEDIUM; else _ro = RESIZE_LARGE; } else { _ro = RESIZE_NONE; } return _WizardNext(hwnd, WIZPAGE_COPYING); } } break; } case WM_COMMAND: { if ((HIWORD(wParam) == BN_CLICKED) && (LOWORD(wParam) == IDC_PUB_RESIZE)) { BOOL fEnable = Button_GetCheck(GetDlgItem(hwnd, IDC_PUB_RESIZE)) == BST_CHECKED; EnableWindow(GetDlgItem(hwnd, IDC_PUB_RESIZESMALL), fEnable); EnableWindow(GetDlgItem(hwnd, IDC_PUB_RESIZEMEDIUM), fEnable); EnableWindow(GetDlgItem(hwnd, IDC_PUB_RESIZELARGE), fEnable); } break; } } return FALSE; } // this is called before we transfer each item, we look at the IShellItem we have and // try to update either our stats, or the indicator that this is a new file we are processing. BOOL CPublishingWizard::_HasAttributes(IShellItem *psi, SFGAOF flags) { BOOL fReturn = FALSE; SFGAOF flagsOut; if (SUCCEEDED(psi->GetAttributes(flags, &flagsOut)) && (flags & flagsOut)) { fReturn = TRUE; } return fReturn; } HRESULT CPublishingWizard::PreOperation(const STGOP op, IShellItem *psiItem, IShellItem *psiDest) { if (psiItem && _HasAttributes(psiItem, SFGAO_STREAM)) { if (STGOP_COPY == op) { // lets fill in the details of the file LPOLESTR pstrName; HRESULT hr = psiItem->GetDisplayName(SIGDN_PARENTRELATIVEEDITING, &pstrName); if (SUCCEEDED(hr)) { SetDlgItemText(_hwndCopyingPage, IDC_PUB_COPYFILE, pstrName); CoTaskMemFree(pstrName); } // lets update the progress bar for the number of files we are transfering. _iFile++; SendDlgItemMessage(_hwndCopyingPage, IDC_PUB_TRANSPROGRESS, PBM_SETRANGE32, 0, (LPARAM)_cFiles); SendDlgItemMessage(_hwndCopyingPage, IDC_PUB_TRANSPROGRESS, PBM_SETPOS, (WPARAM)_iFile, 0); TCHAR szBuffer[MAX_PATH]; FormatMessageString(IDS_PUB_COPYINGFMT, szBuffer, ARRAYSIZE(szBuffer), _iFile, _cFiles); SetDlgItemText(_hwndCopyingPage, IDC_PUB_LABELTRANSPROG, szBuffer); // get the thumbnail and show it. IExtractImage *pei; hr = psiItem->BindToHandler(NULL, BHID_SFUIObject, IID_PPV_ARG(IExtractImage, &pei)); if (SUCCEEDED(hr)) { SIZE sz = {120,120}; WCHAR szImage[MAX_PATH]; DWORD dwFlags = 0; hr = pei->GetLocation(szImage, ARRAYSIZE(szImage), NULL, &sz, 24, &dwFlags); if (SUCCEEDED(hr)) { HBITMAP hbmp; hr = pei->Extract(&hbmp); if (SUCCEEDED(hr)) { if (!PostMessage(_hwndCopyingPage, PWM_UPDATEICON, (WPARAM)IMAGE_BITMAP, (LPARAM)hbmp)) { DeleteObject(hbmp); } } } pei->Release(); } // if that failed then lets get the icon for the file and place that into the dialog, // this is less likely to fail - I hope. if (FAILED(hr)) { IPersistIDList *ppid; hr = psiItem->QueryInterface(IID_PPV_ARG(IPersistIDList, &ppid)); if (SUCCEEDED(hr)) { LPITEMIDLIST pidl; hr = ppid->GetIDList(&pidl); if (SUCCEEDED(hr)) { SHFILEINFO sfi = {0}; if (SHGetFileInfo((LPCWSTR)pidl, -1, &sfi, sizeof(sfi), SHGFI_ICON|SHGFI_PIDL|SHGFI_ADDOVERLAYS)) { if (!PostMessage(_hwndCopyingPage, PWM_UPDATEICON, (WPARAM)IMAGE_ICON, (LPARAM)sfi.hIcon)) { DeleteObject(sfi.hIcon); } } ILFree(pidl); } ppid->Release(); } } } else if (STGOP_STATS == op) { _cFiles++; } } return S_OK; } // while we are moving the bits of the file ensure that we update the progress bar accordingly. void CPublishingWizard::_SetProgress(DWORD dwCompleted, DWORD dwTotal) { if (_dwTotal != dwTotal) _dwTotal = dwTotal; if (_dwCompleted != dwCompleted) _dwCompleted = dwCompleted; PostMessage(_hwndCopyingPage, PWM_UPDATE, (WPARAM)dwCompleted, (LPARAM)dwTotal); } HRESULT CPublishingWizard::OperationProgress(const STGOP op, IShellItem *psiItem, IShellItem *psiDest, ULONGLONG ulTotal, ULONGLONG ulComplete) { if (psiItem && (op == STGOP_COPY)) { ULARGE_INTEGER uliCompleted, uliTotal; uliCompleted.QuadPart = ulComplete; uliTotal.QuadPart = ulTotal; // If we are using the top 32 bits, scale both numbers down. // Note that I'm using the attribute that dwTotalHi is always larger than dwCompleted ASSERT(uliTotal.HighPart >= uliCompleted.HighPart); while (uliTotal.HighPart) { uliCompleted.QuadPart >>= 1; uliTotal.QuadPart >>= 1; } ASSERT((0 == uliCompleted.HighPart) && (0 == uliTotal.HighPart)); // Make sure we finished scaling down. _SetProgress(uliCompleted.LowPart, uliTotal.LowPart); } return S_OK; } // Method to invoke the transfer engine HRESULT CPublishingWizard::_BeginTransfer(HWND hwnd) { // initialize the dialog before we start the copy process. _dwCompleted = -1; // progress bars are reset _dwTotal = -1; _iPercentageComplete = -1; _cFiles = 0; // haven't transfered any files yet _iFile = 0; _hrFromTransfer = S_FALSE; _fCancelled = FALSE; // set the state of the controls ready to perform the transfer SetDlgItemText(hwnd, IDC_PUB_COPYFILE, TEXT("")); SendMessage(hwnd, PWM_UPDATE, 0, 0); PropSheet_SetWizButtons(GetParent(hwnd), 0x0); // initialize the transfer object ready to move the bits to the site ITransferAdviseSink *ptas; HRESULT hr = this->QueryInterface(IID_PPV_ARG(ITransferAdviseSink, &ptas)); if (SUCCEEDED(hr)) { // build the list of files for use to transfer to the site, this we // key of the transfer manifest which is stored in our property bag. IXMLDOMDocument *pdocManifest; hr = GetTransferManifest(NULL, &pdocManifest); if (SUCCEEDED(hr)) { TRANSFERINFO ti = {0}; ti.hwnd = hwnd; ti.dwFlags = _dwFlags; CDPA dpaItems; hr = _InitTransferInfo(pdocManifest, &ti, &dpaItems); if (SUCCEEDED(hr)) { if (ti.fUsePost) { hr = PublishViaPost(&ti, &dpaItems, ptas); } else { hr = PublishViaCopyEngine(&ti, &dpaItems, ptas); } } dpaItems.DestroyCallback(_FreeTransferItems, NULL); // will have been detached by thread if handled pdocManifest->Release(); } if (FAILED(hr)) PostMessage(hwnd, PWM_TRANSFERCOMPLETE, 0, (LPARAM)hr); ptas->Release(); } return hr; } // create a link back to the site, this is keyed off information stored in the manifest. HRESULT CPublishingWizard::_CreateFavorite(IXMLDOMNode *pdnUploadInfo) { // lets pick up the favorite element from the manifest, this should define all // that is needed for us to create a link in to the favorites menu. IXMLDOMNode *pdn; HRESULT hr = pdnUploadInfo->selectSingleNode(ELEMENT_FAVORITE, &pdn); if (S_OK == hr) { // we need an URL to create the link using. WCHAR szURL[INTERNET_MAX_URL_LENGTH] = {0}; hr = GetStrFromAttribute(pdn, ATTRIBUTE_HREF, szURL, ARRAYSIZE(szURL)); if (SUCCEEDED(hr)) { // we need a name to save the link as. WCHAR szName[MAX_PATH] = {0}; hr = GetStrFromAttribute(pdn, ATTRIBUTE_NAME, szName, ARRAYSIZE(szName)); if (SUCCEEDED(hr)) { IShellLink *psl; hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IShellLink, &psl)); if (SUCCEEDED(hr)) { hr = psl->SetPath(szURL); // set the target // if that works then lets try and put a comment onto the link - this is an optional // value for the element. if (SUCCEEDED(hr)) { WCHAR szComment[MAX_PATH] = {0}; if (SUCCEEDED(GetStrFromAttribute(pdn, ATTRIBUTE_COMMENT, szComment, ARRAYSIZE(szComment)))) { hr = psl->SetDescription(szComment); // set the comment } } // assuming all that works then lets persist the link into the users // favorites folder, this inturn will create it on their favaorites menu. if (SUCCEEDED(hr)) { WCHAR szFilename[MAX_PATH]; if (SHGetSpecialFolderPath(NULL, szFilename, CSIDL_FAVORITES, TRUE)) { PathAppend(szFilename, szName); PathRenameExtension(szFilename, TEXT(".lnk")); IPersistFile *ppf; hr = psl->QueryInterface(IID_PPV_ARG(IPersistFile, &ppf)); if (SUCCEEDED(hr)) { hr = ppf->Save(szFilename, TRUE); ppf->Release(); } } } psl->Release(); } } } pdn->Release(); } return hr; } // When transfer is complete we need to determine which page we are going to show // this will either come from the site or it will be a HTML page hosted // on the site. HPROPSHEETPAGE CPublishingWizard::_TransferComplete(HRESULT hrFromTransfer) { HPROPSHEETPAGE hpResult = NULL; // convert the HRESULT From something that will have come from the // transfer engine into something the outside world will understand. if (hrFromTransfer == STRESPONSE_CANCEL) hrFromTransfer = HRESULT_FROM_WIN32(ERROR_CANCELLED); // tag ourselves as in the "completed transfer" state, therefore the site knows where to // navigate to next. _fTransferComplete = TRUE; _hrFromTransfer = hrFromTransfer; // get the next page from the site, this will either be the done or // cancelled page based on the result of the site. IWizardSite *pws; HRESULT hr = _punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws)); if (SUCCEEDED(hr)) { if (_hrFromTransfer == HRESULT_FROM_WIN32(ERROR_CANCELLED)) { hr = pws->GetCancelledPage(&hpResult); } else { hr = pws->GetNextPage(&hpResult); } pws->Release(); } // lets put the result into the manifest that we we can read it back later. IXMLDOMDocument *pdocManifest; hr = GetTransferManifest(NULL, &pdocManifest); if (SUCCEEDED(hr)) { IXMLDOMNode *pdn; hr = pdocManifest->selectSingleNode(XPATH_UPLOADINFO, &pdn); if (hr == S_OK) { // if there is a success/failure page defined then lets handle it accordingly WCHAR szPageToShow[INTERNET_MAX_URL_LENGTH] = {0}; if (SUCCEEDED(_hrFromTransfer)) { hr = GetURLFromElement(pdn, ELEMENT_SUCCESSPAGE, szPageToShow, ARRAYSIZE(szPageToShow)); } else { if (_hrFromTransfer == HRESULT_FROM_WIN32(ERROR_CANCELLED)) hr = GetURLFromElement(pdn, ELEMENT_CANCELLEDPAGE, szPageToShow, ARRAYSIZE(szPageToShow)); if ((_hrFromTransfer != HRESULT_FROM_WIN32(ERROR_CANCELLED)) || FAILED(hr)) hr = GetURLFromElement(pdn, ELEMENT_FAILUREPAGE, szPageToShow, ARRAYSIZE(szPageToShow)); } // if we have the page then lets navigate to it, this will give us the succes // failure pages from the site. if (SUCCEEDED(hr) && szPageToShow[0]) { hr = _pwwe->SetInitialURL(szPageToShow); if (SUCCEEDED(hr)) { hr = _pwwe->GetFirstPage(&hpResult); } } // lets do the final processing of the transfer (creating net places, favorites etc) _CreateFavorite(pdn); pdn->Release(); } pdocManifest->Release(); } return hpResult; } // this is the copying dialog. this displays the progress bar and other information as // we transfer the files from the users m/c to the site. INT_PTR CPublishingWizard::_CopyDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch ( uMsg ) { case WM_INITDIALOG: _hwndCopyingPage = hwnd; return FALSE; case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case PSN_SETACTIVE: _BeginTransfer(hwnd); return TRUE; case PSN_QUERYCANCEL: { _fCancelled = TRUE; SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)TRUE); return TRUE; } } break; } case WM_CTLCOLORSTATIC: { // we want the preview filled with a white background. if (GetDlgCtrlID((HWND)lParam) == IDC_PUB_PREVIEW) { return (INT_PTR)(COLOR_3DHILIGHT+1); } return FALSE; } case PWM_TRANSFERCOMPLETE: { PropSheet_SetCurSel(GetParent(hwnd), _TransferComplete((HRESULT)lParam), -1); break; } case PWM_UPDATE: { DWORD dwTotal = (DWORD)lParam; DWORD dwCompleted = (DWORD)wParam; SendDlgItemMessage(hwnd, IDC_PUB_FILEPROGRESS, PBM_SETRANGE32, 0, (LPARAM)dwTotal); SendDlgItemMessage(hwnd, IDC_PUB_FILEPROGRESS, PBM_SETPOS, (WPARAM)dwCompleted, 0); // compute the percentage of the file copied. int iPercentage = 0; if (dwTotal > 0) iPercentage = (dwCompleted * 100) / dwTotal; if (_iPercentageComplete != iPercentage) { TCHAR szBuffer[MAX_PATH]; FormatMessageString(IDS_PUB_COMPLETEFMT, szBuffer, ARRAYSIZE(szBuffer), iPercentage); SetDlgItemText(_hwndCopyingPage, IDC_PUB_LABELFILEPROG, szBuffer); } break; } case PWM_UPDATEICON: { HWND hwndThumbnail = GetDlgItem(hwnd, IDC_PUB_PREVIEW); DWORD dwStyle = (DWORD)GetWindowLongPtr(hwndThumbnail, GWL_STYLE) & ~(SS_BITMAP|SS_ICON); if (wParam == IMAGE_BITMAP) { SetWindowLongPtr(hwndThumbnail, GWL_STYLE, dwStyle | SS_BITMAP); HBITMAP hbmp = (HBITMAP)SendMessage(hwndThumbnail, STM_SETIMAGE, wParam, lParam); if (hbmp) { DeleteObject(hbmp); } } else if (wParam == IMAGE_ICON) { SetWindowLongPtr(hwndThumbnail, GWL_STYLE, dwStyle | SS_ICON); HICON hIcon = (HICON)SendMessage(hwndThumbnail, STM_SETIMAGE, wParam, lParam); if (hIcon) { DeleteObject(hIcon); } } else { DeleteObject((HGDIOBJ)lParam); } break; } } return FALSE; } // Manage the list of file types HRESULT CPublishingWizard::_AddExtenisonToList(HDPA hdpa, LPCTSTR pszExtension) { UINT iItem = 0; UINT nItems = DPA_GetPtrCount(hdpa); BOOL fFound = FALSE; for ( ;(iItem < nItems) && !fFound; iItem++) { LPCTSTR pszExtensionInDPA = (LPCTSTR) DPA_GetPtr(hdpa, iItem); if (pszExtensionInDPA) { fFound = (0 == StrCmpI(pszExtension, pszExtensionInDPA)); } } HRESULT hr = S_OK; if (!fFound) { LPTSTR pszAlloc; hr = E_OUTOFMEMORY; pszAlloc = StrDup(pszExtension); if (pszAlloc) { if (DPA_ERR == DPA_AppendPtr(hdpa, (void*)pszAlloc)) { LocalFree(pszAlloc); } else { hr = S_OK; } } } return hr; } int CPublishingWizard::s_FreeStringProc(void* pFreeMe, void* pData) { LocalFree(pFreeMe); return 1; } HRESULT CPublishingWizard::_GetUniqueTypeList(BOOL fIncludeFolder, HDPA *phdpa) { *phdpa = NULL; HRESULT hr = (*phdpa = DPA_Create(10)) ? S_OK:E_OUTOFMEMORY; if (SUCCEEDED(hr)) { // check for the folders type - eg. we have folders if (fIncludeFolder) { IXMLDOMNode *pdn; hr = _pdocManifest->selectSingleNode(XPATH_FILESROOT, &pdn); if (hr == S_OK) { IXMLDOMElement *pdel; hr = pdn->QueryInterface(IID_PPV_ARG(IXMLDOMElement, &pdel)); if (SUCCEEDED(hr)) { VARIANT var; if (pdel->getAttribute(ATTRIBUTE_HASFOLDERS, &var) == S_OK) { if ((var.vt == VT_BOOL) && (var.boolVal == VARIANT_TRUE)) { hr = _AddExtenisonToList(*phdpa, TEXT("Folder")); } VariantClear(&var); } pdel->Release(); } pdn->Release(); } } // walk the file nodes building the extension list for us IXMLDOMNodeList *pnl; hr = _pdocManifest->selectNodes(XPATH_ALLFILESTOUPLOAD, &pnl); if (hr == S_OK) { long cSelection; hr = pnl->get_length(&cSelection); for (long lNode = 0; SUCCEEDED(hr) && (lNode != cSelection); lNode++) { IXMLDOMNode *pdn; hr = pnl->get_item(lNode, &pdn); if (SUCCEEDED(hr)) { TCHAR szBuffer[MAX_PATH]; hr = GetStrFromAttribute(pdn, ATTRIBUTE_EXTENSION, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { hr = _AddExtenisonToList(*phdpa, szBuffer); } pdn->Release(); } } pnl->Release(); } // clean up the type DPA if we failed.... if (FAILED(hr)) { DPA_DestroyCallback(*phdpa, s_FreeStringProc, 0); *phdpa = NULL; } } return hr; } // initialize the property bag we want to give to the site so that // they can display the correct HTML and direct the user in the // right direction. HRESULT CPublishingWizard::_InitPropertyBag(LPCTSTR pszURL) { HRESULT hr = S_OK; // lets initialize the wizard object so that we show the correct // pages, to determine this we need to if (pszURL) hr = _pwwe->SetInitialURL(pszURL); // now compile a list of the unique types, this will be placed into the // property bag. at this time we can also determine if there // are any images in our list, and therefore if we should prompt accordingly. _fOfferResize = FALSE; // no resize ATOMICRELEASE(_ppb); hr = SHCreatePropertyBagOnMemory(STGM_READWRITE, IID_PPV_ARG(IPropertyBag, &_ppb)); if (SUCCEEDED(hr)) { INT cExtensions = 0; // get the list of unique extensions and put those into the // property bag for the site to query - this should be removed in time and // we should have the site favor the file Manifest HDPA hdpa; hr = _GetUniqueTypeList(TRUE, &hdpa); if (SUCCEEDED(hr)) { for (int i = 0; (i < DPA_GetPtrCount(hdpa)) && (SUCCEEDED(hr)); i++) { LPCTSTR pszExtension = (LPCTSTR)DPA_GetPtr(hdpa, i); if (pszExtension) { if (!(_dwFlags & SHPWHF_NORECOMPRESS)) _fOfferResize = (_fOfferResize || PathIsImage(pszExtension)); TCHAR szProperty[255]; wnsprintf(szProperty, ARRAYSIZE(szProperty), PROPERTY_EXTENSION TEXT("%d"), PROPERTY_EXTENSION, i); hr = SHPropertyBag_WriteStr(_ppb, szProperty, pszExtension); if (SUCCEEDED(hr)) { cExtensions++; } } } DPA_DestroyCallback(hdpa, s_FreeStringProc, 0); } // initialize property bag with UI elements (ignoring the error from above, just won't have an // extension list to present) SHPropertyBag_WriteInt(_ppb, PROPERTY_EXTENSIONCOUNT, cExtensions); // we should always have a manifest object, therefore lets put it into the // property bag so that the site can extract it. IXMLDOMDocument *pdocManifest; hr = CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IXMLDOMDocument, &pdocManifest)); if (SUCCEEDED(hr)) { VARIANT varCurManifest = { VT_DISPATCH }; hr = _pdocManifest->QueryInterface(IID_PPV_ARG(IDispatch, &varCurManifest.pdispVal)); if (SUCCEEDED(hr)) { // load the manifest into the new document that we have. VARIANT_BOOL fSuccess; hr = pdocManifest->load(varCurManifest, &fSuccess); if ((fSuccess == VARIANT_TRUE) && (hr == S_OK)) { hr = s_SetPropertyFromDisp(_ppb, PROPERTY_TRANSFERMANIFEST, pdocManifest); } VariantClear(&varCurManifest); } } } return hr; } // handle building the file manifest from the IDataObject, this consists of walking the list of // files and putting together a class CPubWizardWalkCB : public INamespaceWalkCB { public: CPubWizardWalkCB(IXMLDOMDocument *pdocManifest); ~CPubWizardWalkCB(); // IUnknown STDMETHOD(QueryInterface)(REFIID riid, void **ppvObj); STDMETHOD_(ULONG,AddRef)(); STDMETHOD_(ULONG,Release)(); // INamespaceWalkCB STDMETHODIMP FoundItem(IShellFolder *psf, LPCITEMIDLIST pidl); STDMETHODIMP EnterFolder(IShellFolder *psf, LPCITEMIDLIST pidl); STDMETHODIMP LeaveFolder(IShellFolder *psf, LPCITEMIDLIST pidl); STDMETHODIMP InitializeProgressDialog(LPWSTR *ppszTitle, LPWSTR *ppszCancel) { *ppszTitle = NULL; *ppszCancel = NULL; return E_NOTIMPL; } private: LONG _cRef; // object lifetime count TCHAR _szWalkPath[MAX_PATH]; // path of the folder we are walking INT _idFile; // id of file we have walked IXMLDOMDocument *_pdocManifest; // manifest we are populating void _AddImageMetaData(IShellFolder2 *psf2, LPCITEMIDLIST pidl, IXMLDOMElement *pdel); }; CPubWizardWalkCB::CPubWizardWalkCB(IXMLDOMDocument *pdocManifest) : _cRef(1), _pdocManifest(pdocManifest) { _pdocManifest->AddRef(); _szWalkPath[0] = TEXT('\0'); // no path yet. } CPubWizardWalkCB::~CPubWizardWalkCB() { _pdocManifest->Release(); } // IUnknown ULONG CPubWizardWalkCB::AddRef() { return InterlockedIncrement(&_cRef); } ULONG CPubWizardWalkCB::Release() { ASSERT( 0 != _cRef ); ULONG cRef = InterlockedDecrement(&_cRef); if ( 0 == cRef ) { delete this; } return cRef; } HRESULT CPubWizardWalkCB::QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENT(CPubWizardWalkCB, INamespaceWalkCB), // IID_INamespaceWalkCB {0, 0 }, }; return QISearch(this, qit, riid, ppv); } void CPubWizardWalkCB::_AddImageMetaData(IShellFolder2 *psf2, LPCITEMIDLIST pidl, IXMLDOMElement *pdel) { struct { LPWSTR pszID; const SHCOLUMNID *pscid; } _aMetaData[] = { {L"cx", &SCID_ImageCX}, {L"cy", &SCID_ImageCY}, }; // eventually break this into a helper function, or read this from the info tip for (int i = 0; i < ARRAYSIZE(_aMetaData); i++) { VARIANT var = {0}; HRESULT hr = psf2->GetDetailsEx(pidl, _aMetaData[i].pscid, &var); if (hr == S_OK) { IXMLDOMElement *pdelProperty; hr = CreateAndAppendElement(_pdocManifest, pdel, ELEMENT_IMAGEDATA, &var, &pdelProperty); if (SUCCEEDED(hr)) { hr = SetAttributeFromStr(pdelProperty, ATTRIBUTE_ID, _aMetaData[i].pszID); pdelProperty->Release(); } VariantClear(&var); } } } // INamepsaceWalkCB HRESULT CPubWizardWalkCB::FoundItem(IShellFolder *psf, LPCITEMIDLIST pidl) { IXMLDOMNode *pdn; HRESULT hr = _pdocManifest->selectSingleNode(XPATH_FILESROOT, &pdn); if (hr == S_OK) { IXMLDOMElement *pdel; hr = _pdocManifest->createElement(ELEMENT_FILE, &pdel); if (SUCCEEDED(hr)) { TCHAR szBuffer[MAX_PATH]; VARIANT var; // pass out the unique IDs for each of the elements in the tree var.vt = VT_I4; var.lVal = _idFile++; pdel->setAttribute(ATTRIBUTE_ID, var); // must be able to get the path for the item so that we can hr = DisplayNameOf(psf, pidl, SHGDN_FORPARSING, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { // source path hr = SetAttributeFromStr(pdel, ATTRIBUTE_SOURCE, szBuffer); // extension = (extension to file) hr = SetAttributeFromStr(pdel, ATTRIBUTE_EXTENSION, PathFindExtension(szBuffer)); // lets put the content type TCHAR szContentType[MAX_PATH]; DWORD cch = ARRAYSIZE(szContentType); if (SUCCEEDED(AssocQueryString(0, ASSOCSTR_CONTENTTYPE, szBuffer, NULL, szContentType, &cch))) { hr = SetAttributeFromStr(pdel, ATTRIBUTE_CONTENTTYPE, szContentType); } } // put the proposed destination into the node hr = DisplayNameOf(psf, pidl, SHGDN_FORPARSING|SHGDN_INFOLDER, szBuffer, ARRAYSIZE(szBuffer)); if (SUCCEEDED(hr)) { TCHAR szPath[MAX_PATH]; PathCombine(szPath, _szWalkPath, szBuffer); hr = SetAttributeFromStr(pdel, ATTRIBUTE_DESTINATION, szBuffer); } // handle those properties we can get from the shell folder via GetDetailsEx IShellFolder2 *psf2; if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2)))) { // push the size into the attribute list for the item if (SUCCEEDED(psf2->GetDetailsEx(pidl, &SCID_SIZE, &var))) { pdel->setAttribute(ATTRIBUTE_SIZE, var); VariantClear(&var); } // lets inject the meta data IXMLDOMElement *pdelMetaData; hr = CreateAndAppendElement(_pdocManifest, pdel, ELEMENT_METADATA, NULL, &pdelMetaData); if (SUCCEEDED(hr)) { _AddImageMetaData(psf2, pidl, pdelMetaData); pdelMetaData->Release(); } psf2->Release(); } // append the node to the list that we already have hr = pdn->appendChild(pdel, NULL); pdel->Release(); } pdn->Release(); } return S_OK; } HRESULT CPubWizardWalkCB::EnterFolder(IShellFolder *psf, LPCITEMIDLIST pidl) { // build the name of the folder we have entered. TCHAR szBuffer[MAX_PATH]; if (SUCCEEDED(DisplayNameOf(psf, pidl, SHGDN_FORPARSING|SHGDN_INFOLDER|SHGDN_FORADDRESSBAR, szBuffer, ARRAYSIZE(szBuffer)))) { PathAppend(_szWalkPath, szBuffer); } // lets update the files root to indicate that we are going to be using folders. IXMLDOMNode *pdn; HRESULT hr = _pdocManifest->selectSingleNode(XPATH_FILESROOT, &pdn); if (hr == S_OK) { IXMLDOMElement *pdel; hr = pdn->QueryInterface(IID_PPV_ARG(IXMLDOMElement, &pdel)); if (SUCCEEDED(hr)) { VARIANT var; var.vt = VT_BOOL; var.boolVal = VARIANT_TRUE; hr = pdel->setAttribute(ATTRIBUTE_HASFOLDERS, var); pdel->Release(); } pdn->Release(); } // now update the folders list with the new folder that we have just entered, first // try to find the folder list, if not found then create it. IXMLDOMNode *pdnFolders; hr = _pdocManifest->selectSingleNode(XPATH_FOLDERSROOT, &pdnFolders); if (hr == S_FALSE) { IXMLDOMNode *pdnRoot; hr = _pdocManifest->selectSingleNode(XPATH_MANIFEST, &pdnRoot); if (hr == S_OK) { IXMLDOMElement *pdelRoot; hr = pdnRoot->QueryInterface(IID_PPV_ARG(IXMLDOMElement, &pdelRoot)); if (SUCCEEDED(hr)) { IXMLDOMElement *pdelFolders; hr = CreateAndAppendElement(_pdocManifest, pdelRoot, ELEMENT_FOLDERS, NULL, &pdelFolders); if (SUCCEEDED(hr)) { hr = pdelFolders->QueryInterface(IID_PPV_ARG(IXMLDOMNode, &pdnFolders)); pdelFolders->Release(); } pdelRoot->Release(); } pdnRoot->Release(); } } // assuming we now have the folder list, lets now create a new element for this folder. if (SUCCEEDED(hr) && pdnFolders) { IXMLDOMElement *pdelFolder; hr = _pdocManifest->createElement(ELEMENT_FOLDER, &pdelFolder); if (SUCCEEDED(hr)) { hr = SetAttributeFromStr(pdelFolder, ATTRIBUTE_DESTINATION, _szWalkPath); if (SUCCEEDED(hr)) { hr = pdnFolders->appendChild(pdelFolder, NULL); } pdelFolder->Release(); } } return S_OK; // always succeed so we can transfer folders } HRESULT CPubWizardWalkCB::LeaveFolder(IShellFolder *psf, LPCITEMIDLIST pidl) { PathRemoveFileSpec(_szWalkPath); return S_OK; } // construct the manifest based on the document we have HRESULT CPublishingWizard::_AddFilesToManifest(IXMLDOMDocument *pdocManifest) { HRESULT hr = S_OK; if (_pdo || _pdoSelection) { CWaitCursor cur; // might take some time INamespaceWalk *pnsw; hr = CoCreateInstance(CLSID_NamespaceWalker, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(INamespaceWalk, &pnsw)); if (SUCCEEDED(hr)) { InitClipboardFormats(); CPubWizardWalkCB *pwcb = new CPubWizardWalkCB(pdocManifest); if (pwcb) { hr = pnsw->Walk(_pdoSelection ? _pdoSelection:_pdo, NSWF_NONE_IMPLIES_ALL, 0, SAFECAST(pwcb, INamespaceWalkCB *)); if (SUCCEEDED(hr)) { hr = pnsw->GetIDArrayResult(&_cItems, &_aItems); } pwcb->Release(); } else { hr = E_OUTOFMEMORY; } pnsw->Release(); } } return hr; } HRESULT CPublishingWizard::_BuildTransferManifest() { _FreeTransferManifest(); HRESULT hr = CoCreateInstance(CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IXMLDOMDocument, &_pdocManifest)); if (SUCCEEDED(hr)) { IXMLDOMElement *pdelDoc; hr = CreateElement(_pdocManifest, ELEMENT_TRANSFERMANIFEST, NULL, &pdelDoc); if (SUCCEEDED(hr)) { hr = _pdocManifest->putref_documentElement(pdelDoc); if (SUCCEEDED(hr)) { hr = CreateAndAppendElement(_pdocManifest, pdelDoc, ELEMENT_FILES, NULL, NULL); if (SUCCEEDED(hr)) { hr = _AddFilesToManifest(_pdocManifest); } } pdelDoc->Release(); } } _fRecomputeManifest = FALSE; // the manifest has been recomputed, therefore we don't need to this again. _fRepopulateProviders = TRUE; // the provider list may have changed b/c the manifest changed. return hr; } void CPublishingWizard::_FreeTransferManifest() { ATOMICRELEASE(_pdocManifest); if (_aItems) { FreeIDListArray(_aItems, _cItems); _aItems = NULL; _cItems = 0; } } // Advanced location dialog, including the browse button.... typedef struct { LPTSTR pszPath; IDataObject *pdo; } BROWSEINIT; int _BrowseCallback(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData) { BROWSEINIT *pbi = (BROWSEINIT *)lpData; switch (uMsg) { case BFFM_INITIALIZED: { LPTSTR pszPath = pbi->pszPath; if (pszPath && pszPath[0]) { int i = lstrlen(pszPath) - 1; if ((pszPath[i] == TEXT('\\')) || (pszPath[i] == TEXT('/'))) { pszPath[i] = 0; } SendMessage(hwnd, BFFM_SETSELECTION, (WPARAM) TRUE, (LPARAM) (LPTSTR)pszPath); } else { LPITEMIDLIST pidl; HRESULT hr = SHGetSpecialFolderLocation(hwnd, CSIDL_NETWORK, &pidl); if (SUCCEEDED(hr)) { SendMessage(hwnd, BFFM_SETSELECTION, (WPARAM)FALSE, (LPARAM)((LPTSTR)pidl)); ILFree(pidl); } } break; } case BFFM_SELCHANGED: { BOOL fEnableOK = FALSE; LPCITEMIDLIST pidl = (LPCITEMIDLIST)lParam; // if we have a IDataObject then check to see if we can drop it onto the // destination we are given. this is used by the publishing process // to ensure that we enable/disable the OK. if (pbi->pdo) { IShellFolder *psf; LPCITEMIDLIST pidlChild; if (SUCCEEDED(SHBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild))) { IDropTarget *pdt; if (SUCCEEDED(psf->GetUIObjectOf(NULL, 1, &pidlChild, IID_PPV_ARG_NULL(IDropTarget, &pdt)))) { POINTL ptl = {0}; DWORD dwEffect = DROPEFFECT_COPY; if (SUCCEEDED(pdt->DragEnter(pbi->pdo, 0, ptl, &dwEffect))) { fEnableOK = (dwEffect & DROPEFFECT_COPY); pdt->DragLeave(); } pdt->Release(); } psf->Release(); } } else { ULONG rgInfo = SFGAO_STORAGE; if (SUCCEEDED(SHGetNameAndFlags(pidl, 0, NULL, 0, &rgInfo))) { fEnableOK = (rgInfo & SFGAO_STORAGE); } else { fEnableOK = TRUE; } } SendMessage(hwnd, BFFM_ENABLEOK, (WPARAM) 0, (LPARAM)fEnableOK); break; } } return 0; } void CPublishingWizard::_SetWaitCursor(BOOL bOn) { if (bOn) { _hCursor = SetCursor(LoadCursor(NULL, IDC_APPSTARTING)); } else if (_hCursor) { SetCursor(_hCursor); _hCursor = NULL; } } // Publishing location pages void CPublishingWizard::_ShowExampleTip(HWND hwnd) { TCHAR szTitle[256], szExamples[256]; LoadString(g_hinst, IDS_NETPLACE_EXAMPLES_TITLE, szTitle, ARRAYSIZE(szTitle)); LoadString(g_hinst, IDS_NETPLACE_EXAMPLES, szExamples, ARRAYSIZE(szExamples)); EDITBALLOONTIP ebt = {0}; ebt.cbStruct = sizeof(ebt); ebt.pszTitle = szTitle; ebt.pszText = szExamples; SetFocus(GetDlgItem(hwnd, IDC_FOLDER_EDIT)); // set focus before the balloon HWND hwndEdit = (HWND)SendDlgItemMessage(hwnd, IDC_FOLDER_EDIT, CBEM_GETEDITCONTROL, 0, 0L); Edit_ShowBalloonTip(hwndEdit, &ebt); } void CPublishingWizard::_LocationChanged(HWND hwnd) { if (_fValidating) { PropSheet_SetWizButtons(GetParent(hwnd), 0); } else { int cchLocation = FetchTextLength(hwnd, IDC_FOLDER_EDIT); PropSheet_SetWizButtons(GetParent(hwnd), PSWIZB_BACK|((cchLocation >0) ? PSWIZB_NEXT:0)); } } // auto complete bits #define SZ_REGKEY_AUTOCOMPLETE_TAB TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\AutoComplete") #define SZ_REGVALUE_AUTOCOMPLETE_TAB TEXT("Always Use Tab") #define REGSTR_PATH_AUTOCOMPLETE TEXT("Software\\Microsoft\\windows\\CurrentVersion\\Explorer\\AutoComplete") #define REGSTR_VAL_USEAUTOAPPEND TEXT("Append Completion") #define REGSTR_VAL_USEAUTOSUGGEST TEXT("AutoSuggest") #define BOOL_NOT_SET 0x00000005 DWORD CPublishingWizard::_GetAutoCompleteFlags(DWORD dwFlags) { DWORD dwACOptions = 0; if (!(SHACF_AUTOAPPEND_FORCE_OFF & dwFlags) && ((SHACF_AUTOAPPEND_FORCE_ON & dwFlags) || SHRegGetBoolUSValue(REGSTR_PATH_AUTOCOMPLETE, REGSTR_VAL_USEAUTOAPPEND, FALSE, FALSE))) { dwACOptions |= ACO_AUTOAPPEND; } if (!(SHACF_AUTOSUGGEST_FORCE_OFF & dwFlags) && ((SHACF_AUTOSUGGEST_FORCE_ON & dwFlags) || SHRegGetBoolUSValue(REGSTR_PATH_AUTOCOMPLETE, REGSTR_VAL_USEAUTOSUGGEST, FALSE, TRUE))) { dwACOptions |= ACO_AUTOSUGGEST; } if (SHACF_USETAB & dwFlags) dwACOptions |= ACO_USETAB; // Windows uses the TAB key to move between controls in a dialog. UNIX and other // operating systems that use AutoComplete have traditionally used the TAB key to // iterate thru the AutoComplete possibilities. We need to default to disable the // TAB key (ACO_USETAB) unless the caller specifically wants it. We will also // turn it on static BOOL s_fAlwaysUseTab = BOOL_NOT_SET; if (BOOL_NOT_SET == s_fAlwaysUseTab) s_fAlwaysUseTab = SHRegGetBoolUSValue(SZ_REGKEY_AUTOCOMPLETE_TAB, SZ_REGVALUE_AUTOCOMPLETE_TAB, FALSE, FALSE); if (s_fAlwaysUseTab) dwACOptions |= ACO_USETAB; return dwACOptions; } HRESULT CPublishingWizard::_InitAutoComplete() { HRESULT hr = CoCreateInstance(CLSID_AutoComplete, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IAutoComplete2, &_pac)); if (SUCCEEDED(hr)) { hr = CoCreateInstance(CLSID_ACLMulti, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &_punkACLMulti)); if (SUCCEEDED(hr)) { IObjMgr *pomMulti; hr = _punkACLMulti->QueryInterface(IID_PPV_ARG(IObjMgr, &pomMulti)); if (SUCCEEDED(hr)) { // add the file system auto complete object (for handling UNC's etc) IUnknown *punk; hr = CoCreateInstance(CLSID_ACListISF, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &punk)); if (SUCCEEDED(hr)) { pomMulti->Append(punk); punk->Release(); } // add the publishing wizard auto complete object (for handling HTTP etc) IUnknown *punkCustomACL; hr = CoCreateInstance(CLSID_ACLCustomMRU, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IUnknown, &punkCustomACL)); if (SUCCEEDED(hr)) { hr = punkCustomACL->QueryInterface(IID_PPV_ARG(IACLCustomMRU, &_pmru)); if (SUCCEEDED(hr)) { TCHAR szKey[MAX_PATH]; wnsprintf(szKey, ARRAYSIZE(szKey), (SZ_REGKEY_PUBWIZ TEXT("\\%s\\") SZ_REGVAL_MRU), _szProviderScope); hr = _pmru->Initialize(szKey, 26); if (SUCCEEDED(hr)) { hr = pomMulti->Append(punkCustomACL); } } punkCustomACL->Release(); } pomMulti->Release(); } } } return hr; } // handle MRU of places you can publish to void CPublishingWizard::_InitLocation(HWND hwnd) { // lets initialize the auto complete list of folders that we have HRESULT hr = _InitAutoComplete(); if (SUCCEEDED(hr)) { IEnumString *penum; hr = _pmru->QueryInterface(IID_PPV_ARG(IEnumString, &penum)); if (SUCCEEDED(hr)) { penum->Reset(); // reset the enumerator ready for us to populate the list LPOLESTR pszEntry; ULONG ulFetched; while ((penum->Next(1, &pszEntry, &ulFetched) == S_OK) && ulFetched == 1) { COMBOBOXEXITEM cbei = {0}; cbei.mask = CBEIF_TEXT; cbei.pszText = pszEntry; SendDlgItemMessage(hwnd, IDC_FOLDER_EDIT, CBEM_INSERTITEM, 0, (LPARAM)&cbei); CoTaskMemFree(pszEntry); } penum->Release(); } // enable auto complete for this control. HWND hwndEdit = (HWND)SendDlgItemMessage(hwnd, IDC_FOLDER_EDIT, CBEM_GETEDITCONTROL, 0, 0L); _pac->Init(hwndEdit, _punkACLMulti, NULL, NULL); _pac->SetOptions(_GetAutoCompleteFlags(0)); // limit text on the edit control ComboBox_LimitText(GetDlgItem(hwnd, IDC_FOLDER_EDIT), INTERNET_MAX_URL_LENGTH); // if the policy says no map drive etc, then lets remove it BOOL fHide = SHRestricted(REST_NOENTIRENETWORK) || SHRestricted(REST_NONETCONNECTDISCONNECT); ShowWindow(GetDlgItem(hwnd, IDC_BROWSE), fHide ? SW_HIDE:SW_SHOW); } } // validation thread, this is performed on a background thread to compute if // the resource is valid. #define PWM_VALIDATEDONE (WM_APP) // -> validate done (HRESULT passed in LPARAM) typedef struct { HWND hwnd; // parent HWND BOOL fAllowWebFolders; // allow web folders during validation TCHAR szFileTarget[INTERNET_MAX_URL_LENGTH]; // destination for file copy } VALIDATETHREADDATA; DWORD CALLBACK CPublishingWizard::s_ValidateThreadProc(void *pv) { VALIDATETHREADDATA *pvtd = (VALIDATETHREADDATA*)pv; HRESULT hr = E_FAIL; // validate the site CNetworkPlace np; hr = np.SetTarget(pvtd->hwnd, pvtd->szFileTarget, NPTF_VALIDATE | (pvtd->fAllowWebFolders ? NPTF_ALLOWWEBFOLDERS:0)); np.SetTarget(NULL, NULL, 0); PostMessage(pvtd->hwnd, PWM_VALIDATEDONE, 0, (LPARAM)hr); LocalFree(pvtd); return 0; } void CPublishingWizard::_TryToValidateDestination(HWND hwnd) { TCHAR szDestination[INTERNET_MAX_URL_LENGTH]; FetchText(hwnd, IDC_FOLDER_EDIT, szDestination, ARRAYSIZE(szDestination)); // lets walk the list source files and try to match to the destination we have. // we don't want to let source be the destination BOOL fHitItem = FALSE; LPITEMIDLIST pidl = ILCreateFromPath(szDestination); if (pidl) { BOOL fUNC = PathIsUNC(szDestination); //only if destination is UNC Path do we need to check if source is a mapped drive for (UINT iItem = 0; (iItem != _cItems) && !fHitItem; iItem++) { LPITEMIDLIST pidlSrcDir = ILClone(_aItems[iItem]); if (pidlSrcDir) { ILRemoveLastID(pidlSrcDir); fHitItem = ILIsEqual(pidlSrcDir, pidl) || (!ILIsEmpty(pidlSrcDir) && ILIsParent(pidlSrcDir, pidl, FALSE)); if (!fHitItem && fUNC) { WCHAR szPath[MAX_PATH]; if (SUCCEEDED(SHGetPathFromIDList(pidlSrcDir, szPath)) && !PathIsUNC(szPath)) { WCHAR szSource[MAX_PATH]; DWORD cchSource = ARRAYSIZE(szSource); DWORD dwType = SHWNetGetConnection(szPath, szSource, &cchSource); if ((dwType == NO_ERROR) || (dwType == ERROR_CONNECTION_UNAVAIL)) { fHitItem = (StrCmpNI(szSource, szDestination, lstrlen(szSource)) == 0); } } } ILFree(pidlSrcDir); } } ILFree(pidl); } // if we didn't get a hit that way then lets spin up a thread which will do the // validation of the server and the connection - this is a lengthy operation // and will post a result to the window. if (!fHitItem) { VALIDATETHREADDATA *pvtd = (VALIDATETHREADDATA*)LocalAlloc(LPTR, sizeof(*pvtd)); if (pvtd) { pvtd->hwnd = hwnd; pvtd->fAllowWebFolders = (_dwFlags & SHPWHF_VALIDATEVIAWEBFOLDERS) != 0; // fetch the user typed url StrCpyN(pvtd->szFileTarget, szDestination, ARRAYSIZE(pvtd->szFileTarget)); // we have the thread data read, so lets begin the validation // by creating the thread - our state is set to indicate we are in the // validate mode. _fValidating = TRUE; // we are going to begin validating _SetWaitCursor(TRUE); if (!SHCreateThread(s_ValidateThreadProc, pvtd, CTF_INSIST | CTF_COINIT, NULL)) { LocalFree(pvtd); _fValidating = FALSE; _SetWaitCursor(FALSE); } } } else { ShellMessageBox(g_hinst, hwnd, MAKEINTRESOURCE(IDS_PUB_SAMETARGET), NULL, MB_ICONEXCLAMATION | MB_OK); PostMessage(hwnd, PWM_VALIDATEDONE, 0, (LPARAM)E_FAIL); } // ensure the state of the controls reflects what we are trying to do. _LocationChanged(hwnd); EnableWindow(GetDlgItem(hwnd, IDC_FOLDER_EDIT), !_fValidating); EnableWindow(GetDlgItem(hwnd, IDC_BROWSE), !_fValidating); } // this is the dialog proc for the location dialog. INT_PTR CPublishingWizard::_LocationDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_INITDIALOG: { _MapDlgItemText(hwnd, IDC_PUB_LOCATIONCAPTION, L"wp:location", L"locationcaption"); _InitLocation(hwnd); return TRUE; } case WM_DESTROY: { ATOMICRELEASE(_pac); ATOMICRELEASE(_punkACLMulti); ATOMICRELEASE(_pmru); return FALSE; } case WM_COMMAND: { switch (LOWORD(wParam)) { case IDC_BROWSE: { LPITEMIDLIST pidl; if (SHGetSpecialFolderLocation(hwnd, CSIDL_NETWORK, &pidl) == S_OK) { TCHAR szPath[MAX_PATH]; FetchText(hwnd, IDC_FOLDER_EDIT, szPath, ARRAYSIZE(szPath)); TCHAR szTitle[MAX_PATH]; if (FAILED(_LoadMappedString(L"wp:location", L"browsecaption", szTitle, ARRAYSIZE(szTitle)))) { LoadString(g_hinst, IDS_PUB_BROWSETITLE, szTitle, ARRAYSIZE(szTitle)); } // lets initialize our state structure for the browse dialog. based on this we can then // attempt to select a network place. from here we will also pass the IDataObject // we have (there may not be one of course) BROWSEINIT binit = {szPath}; if (_pdoSelection) _pdoSelection->QueryInterface(IID_PPV_ARG(IDataObject, &binit.pdo)); else if (_pdo) _pdo->QueryInterface(IID_PPV_ARG(IDataObject, &binit.pdo)); BROWSEINFO bi = {0}; bi.hwndOwner = hwnd; bi.pidlRoot = pidl; bi.lpszTitle = szTitle; bi.ulFlags = BIF_NEWDIALOGSTYLE; bi.lpfn = _BrowseCallback; bi.lParam = (LPARAM)&binit; LPITEMIDLIST pidlReturned = SHBrowseForFolder(&bi); if (pidlReturned) { if (SUCCEEDED(SHGetNameAndFlags(pidlReturned, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL))) SetDlgItemText(hwnd, IDC_FOLDER_EDIT, szPath); ILFree(pidlReturned); } if (binit.pdo) binit.pdo->Release(); ILFree(pidl); } return TRUE; } case IDC_FOLDER_EDIT: if (HIWORD(wParam) == CBN_EDITCHANGE) { _LocationChanged(hwnd); } return TRUE; } break; } case WM_SETCURSOR: if (_fValidating) { SetCursor(LoadCursor(NULL, IDC_APPSTARTING)); return TRUE; } return FALSE; case PWM_VALIDATEDONE: { _fValidating = FALSE; _LocationChanged(hwnd); _SetWaitCursor(FALSE); HRESULT hr = _InitPropertyBag(NULL); if (SUCCEEDED(hr)) { TCHAR szBuffer[MAX_PATH], szURL[INTERNET_MAX_URL_LENGTH]; FetchText(hwnd, IDC_FOLDER_EDIT, szURL, ARRAYSIZE(szURL)); // push the destination site into the property bag, and then initialize // our site with the right information IXMLDOMDocument *pdocManifest; hr = GetTransferManifest(NULL, &pdocManifest); if (SUCCEEDED(hr)) { IXMLDOMNode *pdnRoot; hr = pdocManifest->selectSingleNode(XPATH_MANIFEST, &pdnRoot); if (hr == S_OK) { IXMLDOMElement *pdelRoot; hr = pdnRoot->QueryInterface(IID_PPV_ARG(IXMLDOMElement, &pdelRoot)); if (SUCCEEDED(hr)) { IXMLDOMElement *pdelUploadInfo; hr = CreateAndAppendElement(_pdocManifest, pdelRoot, ELEMENT_UPLOADINFO, NULL, &pdelUploadInfo); if (SUCCEEDED(hr)) { IXMLDOMElement *pdelTarget; hr = CreateAndAppendElement(_pdocManifest, pdelUploadInfo, ELEMENT_TARGET, NULL, &pdelTarget); if (SUCCEEDED(hr)) { hr = SetAttributeFromStr(pdelTarget, ATTRIBUTE_HREF, szURL); pdelTarget->Release(); } pdelUploadInfo->Release(); } pdelRoot->Release(); } pdnRoot->Release(); } pdocManifest->Release(); } // lets now process the result hr = (HRESULT)lParam; if (S_OK == hr) { BOOL fGotoNextPage = TRUE; // fake a return so auto complete can do its thing SendMessage(GetDlgItem(hwnd, IDC_FOLDER_EDIT), WM_KEYDOWN, VK_RETURN, 0x1c0001); // add the string to the MRU if (_pmru) _pmru->AddMRUString(szURL); // lets sniff the string they entered, if its a URL and its FTP // then we must special case the password in the URL, otherwise // we jump directly to the friendly name handling. URL_COMPONENTS urlComps = {0}; urlComps.dwStructSize = sizeof(urlComps); urlComps.lpszScheme = szBuffer; urlComps.dwSchemeLength = ARRAYSIZE(szBuffer); if (InternetCrackUrl(szURL, 0, ICU_DECODE, &urlComps) && (INTERNET_SCHEME_FTP == urlComps.nScheme)) { URL_COMPONENTS urlComps = {0}; urlComps.dwStructSize = sizeof(URL_COMPONENTS); urlComps.nScheme = INTERNET_SCHEME_FTP; urlComps.lpszUserName = szBuffer; urlComps.dwUserNameLength = ARRAYSIZE(szBuffer); // if the user specified a user name, if not then goto the FTP user // page (we known its a FTP location) if (!InternetCrackUrl(szURL, 0, 0, &urlComps) || !szBuffer[0]) { _WizardNext(hwnd, WIZPAGE_FTPUSER); fGotoNextPage = FALSE; } } if (fGotoNextPage) _WizardNext(hwnd, WIZPAGE_FRIENDLYNAME); } } EnableWindow(GetDlgItem(hwnd, IDC_FOLDER_EDIT), TRUE); EnableWindow(GetDlgItem(hwnd, IDC_BROWSE), TRUE); if (FAILED(((HRESULT)lParam))) _ShowExampleTip(hwnd); return TRUE; } case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case PSN_SETACTIVE: _fShownCustomLocation = TRUE; // so we navigate back to this page _fShownUserName = FALSE; _LocationChanged(hwnd); return TRUE; case PSN_WIZBACK: return _WizardNext(hwnd, WIZPAGE_PROVIDERS); case PSN_WIZNEXT: _TryToValidateDestination(hwnd); SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)-1); return TRUE; case NM_CLICK: case NM_RETURN: { if (pnmh->idFrom == IDC_EXAMPLESLINK) { _ShowExampleTip(hwnd); return TRUE; } } } break; } } return FALSE; } // FTP login dialog - handle the messages for this void CPublishingWizard::_UserNameChanged(HWND hwnd) { BOOL fAnonymousLogin = IsDlgButtonChecked(hwnd, IDC_PASSWORD_ANONYMOUS); ShowWindow(GetDlgItem(hwnd, IDC_USER), (fAnonymousLogin ? SW_HIDE : SW_SHOW)); ShowWindow(GetDlgItem(hwnd, IDC_USERNAME_LABEL), (fAnonymousLogin ? SW_HIDE : SW_SHOW)); ShowWindow(GetDlgItem(hwnd, IDC_ANON_USERNAME), (fAnonymousLogin ? SW_SHOW : SW_HIDE)); ShowWindow(GetDlgItem(hwnd, IDC_ANON_USERNAME_LABEL), (fAnonymousLogin ? SW_SHOW : SW_HIDE)); // Hide the "You will be prompted for the password when you connect to the FTP server" text on anonymous EnableWindow(GetDlgItem(hwnd, IDC_PWD_PROMPT), !fAnonymousLogin); ShowWindow(GetDlgItem(hwnd, IDC_PWD_PROMPT), (fAnonymousLogin ? SW_HIDE : SW_SHOW)); } INT_PTR CPublishingWizard::_UserNameDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_INITDIALOG: { CheckDlgButton(hwnd, IDC_PASSWORD_ANONYMOUS, BST_CHECKED); EnableWindow(GetDlgItem(hwnd, IDC_ANON_USERNAME), FALSE); EnableWindow(GetDlgItem(hwnd, IDC_ANON_USERNAME_LABEL), FALSE); SetWindowText(GetDlgItem(hwnd, IDC_ANON_USERNAME), TEXT("Anonymous")); return TRUE; } case WM_COMMAND: { switch (LOWORD(wParam)) { case IDC_PASSWORD_ANONYMOUS: _UserNameChanged(hwnd); return TRUE; } break; } case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case PSN_SETACTIVE: { _fShownUserName = TRUE; // so we can navigate back properly _UserNameChanged(hwnd); return TRUE; } case PSN_WIZBACK: return _WizardNext(hwnd, WIZPAGE_LOCATION); case PSN_WIZNEXT: { // if we can get a user name then lets push it into the property // bag, a NULL string == anonymous logon TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH] = {0}; if (!IsDlgButtonChecked(hwnd, IDC_PASSWORD_ANONYMOUS)) { FetchText(hwnd, IDC_USER, szUserName, ARRAYSIZE(szUserName)); } // get the sites property bag, and persist the string into it, // if we have done that then we can go to the next page. IXMLDOMDocument *pdocManifest; HRESULT hr = GetTransferManifest(NULL, &pdocManifest); if (SUCCEEDED(hr)) { IXMLDOMNode *pdn; hr = pdocManifest->selectSingleNode(XPATH_UPLOADTARGET, &pdn); if (hr == S_OK) { hr = SetAttributeFromStr(pdn, ATTRIBUTE_USERNAME, szUserName); pdn->Release(); } pdocManifest->Release(); } return _WizardNext(hwnd, WIZPAGE_FRIENDLYNAME); } } break; } } return FALSE; } // set the friendly name for the web place - if it doesn't already exist void CPublishingWizard::_FriendlyNameChanged(HWND hwnd) { int cchLocation = FetchTextLength(hwnd, IDC_NETPLNAME_EDIT); PropSheet_SetWizButtons(GetParent(hwnd), PSWIZB_BACK |((cchLocation >0) ? PSWIZB_NEXT:0)); } INT_PTR CPublishingWizard::_FriendlyNameDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { // lets get the limit information for the nethood folder case WM_INITDIALOG: { LPITEMIDLIST pidlNetHood; if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_NETHOOD, &pidlNetHood))) { IShellFolder *psf; if (SUCCEEDED(SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidlNetHood, &psf)))) { SHLimitInputEdit(GetDlgItem(hwnd, IDC_NETPLNAME_EDIT), psf); psf->Release(); } ILFree(pidlNetHood); } _FriendlyNameChanged(hwnd); break; } case WM_COMMAND: { switch (LOWORD(wParam)) { case IDC_NETPLNAME_EDIT: { if (HIWORD(wParam) == EN_CHANGE) { _FriendlyNameChanged(hwnd); return TRUE; } break; } } break; } case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch (pnmh->code) { case PSN_SETACTIVE: { // read from the manifest the target URL that we are going to be putting the // files to, from this we can compute the friendly name information. IXMLDOMDocument *pdocManifest; HRESULT hr = GetTransferManifest(NULL, &pdocManifest); if (SUCCEEDED(hr)) { IXMLDOMNode *pdn; hr = pdocManifest->selectSingleNode(XPATH_UPLOADTARGET, &pdn); if (hr == S_OK) { TCHAR szURL[INTERNET_MAX_URL_LENGTH]; hr = GetStrFromAttribute(pdn, ATTRIBUTE_HREF, szURL, ARRAYSIZE(szURL)); if (SUCCEEDED(hr)) { _npCustom.SetTarget(hwnd, szURL, (_dwFlags & SHPWHF_VALIDATEVIAWEBFOLDERS) ? NPTF_ALLOWWEBFOLDERS:0); TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH]; hr = GetStrFromAttribute(pdn, ATTRIBUTE_USERNAME, szUserName, ARRAYSIZE(szUserName)); if (SUCCEEDED(hr)) _npCustom.SetLoginInfo(szUserName, NULL); TCHAR szBuffer[MAX_PATH + INTERNET_MAX_URL_LENGTH]; if (FormatMessageString(IDS_COMPLETION_STATIC, szBuffer, ARRAYSIZE(szBuffer), szURL)) { SetDlgItemText(hwnd, IDC_COMPLETION_STATIC, szBuffer); } // Create a default name and display it hr = _npCustom.GetName(szBuffer, ARRAYSIZE(szBuffer)); SetDlgItemText(hwnd, IDC_NETPLNAME_EDIT, SUCCEEDED(hr) ? szBuffer:TEXT("")); // Update the button state for the page etc. _FriendlyNameChanged(hwnd); } pdn->Release(); } } return TRUE; } case PSN_WIZBACK: _WizardNext(hwnd, _fShownUserName ? WIZPAGE_FTPUSER:WIZPAGE_LOCATION); return TRUE; case PSN_WIZNEXT: { TCHAR szFriendlyName[MAX_PATH]; FetchText(hwnd, IDC_NETPLNAME_EDIT, szFriendlyName, ARRAYSIZE(szFriendlyName)); // set the name of the new place, if this fails then the name is already taken // and UI will have been displayed saying so, and they responded with a // NO to the overwrite prompt. HRESULT hr = _npCustom.SetName(hwnd, szFriendlyName); if (SUCCEEDED(hr)) { IXMLDOMDocument *pdocManifest; HRESULT hr = GetTransferManifest(NULL, &pdocManifest); if (SUCCEEDED(hr)) { IXMLDOMNode *pdn; hr = pdocManifest->selectSingleNode(XPATH_UPLOADINFO, &pdn); if (hr == S_OK) { hr = SetAttributeFromStr(pdn, ATTRIBUTE_FRIENDLYNAME, szFriendlyName); pdn->Release(); } pdocManifest->Release(); } // Clean up after our custom netplace now. // This way everything works for webfolders when the outer ANP netplace // creates the webfolder. DSheldon 387476 _npCustom.SetTarget(NULL, NULL, 0x0); if (_pdo) { _WizardNext(hwnd, _fOfferResize ? WIZPAGE_RESIZE:WIZPAGE_COPYING); } else { IWizardSite *pws; hr = _punkSite->QueryInterface(IID_PPV_ARG(IWizardSite, &pws)); if (SUCCEEDED(hr)) { HPROPSHEETPAGE hpage; hr = pws->GetNextPage(&hpage); if (SUCCEEDED(hr)) { PropSheet_SetCurSel(GetParent(hwnd), hpage, -1); } pws->Release(); } } } SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LPARAM)-1); return TRUE; } } break; } } return FALSE; }