#include "priv.h"
#include "hlframe.h"
#include "dochost.h"
#include "bindcb.h"
#include "iface.h"
#include "resource.h"
#include "idhidden.h"
#include "shdocfl.h"
const ITEMIDLIST s_idNull = { {0} };
extern HRESULT VariantClearLazy(VARIANTARG *pvarg);
LPWSTR URLFindExtensionW(LPCWSTR pszURL, int * piLen);
#define DM_CACHETRACE 0
#define DM_ZONECROSSING 0
#define NAVMSG3(psz, x, y) TraceMsg(0, "NAV::%s %x %x", psz, x, y)
#define PAINTMSG(psz,x) TraceMsg(0, "TraceMsgPAINT::%s %x", psz, x)
#define JMPMSG(psz, psz2) TraceMsg(0, "TraceMsgCDOV::%s %s", psz, psz2)
#define JMPMSG2(psz, x) TraceMsg(0, "TraceMsgCDOV::%s %x", psz, x)
#define DOFMSG(psz) TraceMsg(0, "TraceMsgDOF::%s", psz)
#define DOFMSG2(psz, x) TraceMsg(0, "TraceMsgDOF::%s %x", psz, x)
#define URLMSG(psz) TraceMsg(0, "TraceMsgDOF::%s", psz)
#define URLMSG2(psz, x) TraceMsg(0, "TraceMsgDOF::%s %x", psz, x)
#define URLMSG3(psz, x, y) TraceMsg(0, "TraceMsgDOF::%s %x %x", psz, x, y)
#define BSCMSG(psz, i, j) TraceMsg(0, "TraceMsgBSC::%s %x %x", psz, i, j)
#define BSCMSG3(psz, i, j, k) TraceMsg(0, "TraceMsgBSC::%s %x %x %x", psz, i, j, k)
#define BSCMSG4(psz, i, j, k, l) TraceMsg(0, "TraceMsgBSC::%s %x %x %x %x", psz, i, j, k, l)
#define BSCMSGS(psz, sz) TraceMsg(0, "TraceMsgBSC::%s %s", psz, sz)
#define OIPSMSG(psz) TraceMsg(0, "TraceMsgOIPS::%s", psz)
#define OIPSMSG3(psz, sz, p) TraceMsg(0, "TraceMsgOIPS::%s %s,%x", psz, sz,p)
#define VIEWMSG(psz) TraceMsg(0, "CDOV::%s", psz)
#define VIEWMSG2(psz,xx) TraceMsg(0, "CDOV::%s %x", psz,xx)
#define CACHEMSG(psz, d) TraceMsg(0, "CDocObjectCtx::%s %d", psz, d)
#define OPENMSG(psz) TraceMsg(0, "OPENING %s", psz)
#define OPENMSG2(psz, x) TraceMsg(0, "OPENING %s %x", psz, x)
#define HFRMMSG(psz) TraceMsg(0, "HFRM::%s", psz)
#define HFRMMSG2(psz, x, y) TraceMsg(0, "HFRM::%s %x %x", psz, x, y)
#define MNKMSG(psz, psz2) TraceMsg(0, "MNK::%s (%s)", psz, psz2)
#define CHAINMSG(psz, x) TraceMsg(0, "CHAIN::%s %x", psz, x)
#define SHVMSG(psz, x, y) TraceMsg(0, "SHV::%s %x %x", psz, x, y)
#define HOMEMSG(psz, psz2, x) TraceMsg(0, "HOME::%s %s %x", psz, psz2, x)
#define SAVEMSG(psz, x) TraceMsg(0, "SAVE::%s %x", psz, x)
#define PERFMSG(psz, x) TraceMsg(TF_SHDPERF, "PERF::%s %d msec", psz, x)
// this saves the view information for this shell view class
typedef struct {
UINT cbSize;
BOOL fCoolbar:1;
BOOL fToolbar:1;
BOOL fStatusbar:1;
} IEVIEWINFO;
class CDocObjectView :
/* Group 1 */ public IShellView2, public IDropTarget
, public IViewObject, public IAdviseSink
, public IOleCommandTarget
, public IDocViewSite
, public IPrivateOleObject
, public IPersistFolder
, public IServiceProvider
{
protected:
CDocObjectHost* _pdoh;
IDocHostObject* _pdho;
UINT _cRef;
IShellFolder *_psf;
IShellBrowser* _psb;
IOleCommandTarget* _pctShellBrowser;
FOLDERSETTINGS _fs;
LPITEMIDLIST _pidl;
LPTSTR _pszLocation;
UINT _uiCP;
IShellView * _psvPrev;
// Advisory connection
IAdviseSink *_padvise;
DWORD _advise_aspect;
DWORD _advise_advf;
BOOL _fInHistory : 1;
BOOL _fSaveViewState : 1;
BOOL _fIsGet : 1;
BOOL _fCanCache : 1;
BOOL _fCanCacheFetched : 1;
BOOL _fPrevViewIsDocView : 1;
BOOL _fSelfDragging : 1; // DocObject is the drag source
SYSTEMTIME _stLastRefresh;
HWND _hwndParent;
UINT _uState;
// DragContext
DWORD _dwDragEffect;
~CDocObjectView();
void _RestoreViewSettings();
void _SaveViewState();
void _GetViewSettings(IEVIEWINFO* pievi);
int _ShowControl(UINT idControl, int idCmd);
void _CreateDocObjHost(IShellView * psvPrev);
void _CompleteDocHostPassing(IShellView *psvPrev, HRESULT hres);
BOOL _CanUseCache();
void _SetLastRefreshTime() { GetSystemTime(&_stLastRefresh); };
void _ConnectHostSink();
void _DisconnectHostSink();
public:
CDocObjectView(LPCITEMIDLIST pidl, IShellFolder *psf);
// *** IUnknown methods ***
STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObj);
STDMETHODIMP_(ULONG) AddRef(void) ;
STDMETHODIMP_(ULONG) Release(void);
// *** IOleWindow methods ***
STDMETHODIMP GetWindow(HWND * lphwnd);
STDMETHODIMP ContextSensitiveHelp(BOOL fEnterMode);
// *** IShellView methods ***
STDMETHODIMP TranslateAccelerator(LPMSG lpmsg);
STDMETHODIMP EnableModelessSV(BOOL fEnable);
STDMETHODIMP UIActivate(UINT uState);
STDMETHODIMP Refresh();
STDMETHODIMP CreateViewWindow(IShellView *lpPrevView,
LPCFOLDERSETTINGS lpfs, IShellBrowser * psb,
RECT * prcView, HWND *phWnd);
STDMETHODIMP DestroyViewWindow();
STDMETHODIMP GetCurrentInfo(LPFOLDERSETTINGS lpfs);
STDMETHODIMP AddPropertySheetPages(DWORD dwReserved,
LPFNADDPROPSHEETPAGE lpfn, LPARAM lparam);
STDMETHODIMP SaveViewState();
STDMETHODIMP SelectItem(LPCITEMIDLIST pidlItem, UINT uFlags);
STDMETHODIMP GetItemObject(UINT uItem, REFIID riid, void **ppv);
STDMETHODIMP GetView(SHELLVIEWID* pvid, ULONG uView) ;
STDMETHODIMP CreateViewWindow2(LPSV2CVW2_PARAMS lpParams) ;
STDMETHODIMP HandleRename(LPCITEMIDLIST pidl) ;
STDMETHODIMP SelectAndPositionItem(LPCITEMIDLIST pidlItem, UINT uFlags, POINT *ppt) {
return E_NOTIMPL;
}
// IViewObject
STDMETHODIMP Draw(DWORD, LONG, void *, DVTARGETDEVICE *, HDC, HDC,
const RECTL *, const RECTL *, BOOL (*)(ULONG_PTR), ULONG_PTR);
STDMETHODIMP GetColorSet(DWORD, LONG, void *, DVTARGETDEVICE *,
HDC, LOGPALETTE **);
STDMETHODIMP Freeze(DWORD, LONG, void *, DWORD *);
STDMETHODIMP Unfreeze(DWORD);
STDMETHODIMP SetAdvise(DWORD, DWORD, IAdviseSink *);
STDMETHODIMP GetAdvise(DWORD *, DWORD *, IAdviseSink **);
// IAdviseSink
STDMETHODIMP_(void) OnDataChange(FORMATETC *, STGMEDIUM *);
STDMETHODIMP_(void) OnViewChange(DWORD dwAspect, LONG lindex);
STDMETHODIMP_(void) OnRename(IMoniker *);
STDMETHODIMP_(void) OnSave();
STDMETHODIMP_(void) OnClose();
// IOleCommandTarget
STDMETHODIMP QueryStatus(const GUID *pguidCmdGroup,
ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext);
STDMETHODIMP Exec(const GUID *pguidCmdGroup,
DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut);
// IDropTarget
STDMETHODIMP DragEnter(
IDataObject *pdtobj,
DWORD grfKeyState,
POINTL pt,
DWORD *pdwEffect);
STDMETHODIMP DragOver(
DWORD grfKeyState,
POINTL pt,
DWORD *pdwEffect);
STDMETHODIMP DragLeave(void);
STDMETHODIMP Drop(
IDataObject *pdtobj,
DWORD grfKeyState,
POINTL pt,
DWORD *pdwEffect);
// IDocViewSite
STDMETHODIMP OnSetTitle(VARIANTARG *pvTitle);
// IPrivateOleObject
STDMETHODIMP SetExtent( DWORD dwDrawAspect, SIZEL *psizel);
STDMETHODIMP GetExtent( DWORD dwDrawAspect, SIZEL *psizel);
// IPersist methods
STDMETHODIMP GetClassID(CLSID *pclsid);
// IPersistFolder methods
STDMETHODIMP Initialize(LPCITEMIDLIST pidl);
// IServiceProvider methods
STDMETHODIMP QueryService(REFGUID guidService, REFIID riid, void ** ppvObj);
};
//--------------------------------------------------------------------------
// Detecting a memory leak
//--------------------------------------------------------------------------
CDocObjectView::~CDocObjectView()
{
// just in case
DestroyViewWindow();
if (_pidl)
{
ILFree(_pidl);
_pidl = NULL;
}
ATOMICRELEASE(_psf);
if (_pszLocation)
{
LocalFree(_pszLocation);
_pszLocation = NULL;
}
ATOMICRELEASE(_padvise);
ATOMICRELEASE(_psvPrev);
TraceMsg(TF_SHDLIFE, "dtor CDocObjectView(%x) being destructed", this);
}
CDocObjectView::CDocObjectView(LPCITEMIDLIST pidl, IShellFolder* psf) :
_psf(psf),
_cRef(1)
{
TraceMsg(TF_SHDLIFE, "ctor CDocObjectView(%x) being constructed", this);
_dwDragEffect = DROPEFFECT_NONE;
if (pidl)
{
_pidl = ILClone(pidl);
if (_pidl)
{
#ifndef UNIX
WCHAR wszPath[MAX_URL_STRING];
#else
WCHAR wszPath[MAX_URL_STRING] = TEXT("");
#endif
if(IEILGetFragment(_pidl, wszPath, SIZECHARS(wszPath)))
{
_pszLocation = StrDup(wszPath);
}
_uiCP = IEILGetCP(_pidl);
}
}
ASSERT(psf);
if (_psf) {
_psf->AddRef();
}
}
HRESULT CDocObjectView_Create(IShellView** ppvOut, IShellFolder * psf, LPCITEMIDLIST pidl)
{
*ppvOut = new CDocObjectView(pidl, psf);
return (*ppvOut) ? S_OK : E_OUTOFMEMORY;
}
HRESULT CDocObjectView::GetWindow(HWND * lphwnd)
{
*lphwnd = NULL;
if (_pdoh)
return _pdoh->GetWindow(lphwnd);
return S_OK;
}
HRESULT CDocObjectView::ContextSensitiveHelp(BOOL fEnterMode)
{
// NOTES: This is optional
return E_NOTIMPL; // As specified in Kraig's document (optional)
}
// IShellView::TranslateAccelerator
// From Browser -> DocView -> DocObject
HRESULT CDocObjectView::TranslateAccelerator(LPMSG lpmsg)
{
HRESULT hres = S_FALSE;
if (_pdoh)
hres = _pdoh->_xao.TranslateAccelerator(lpmsg);
if (hres == S_FALSE && lpmsg->message == WM_KEYDOWN) {
HWND hwndFocus = GetFocus();
HWND hwndView = NULL;
if(_pdoh) //WARNING ZEKEL i found this NULL
_pdoh->GetWindow(&hwndView);
if (hwndView && IsChildOrSelf(hwndView, hwndFocus) == S_OK) {
switch (lpmsg->wParam) {
case VK_BACK:
TranslateMessage(lpmsg);
DispatchMessage(lpmsg);
hres = NOERROR;
break;
}
}
}
return hres;
}
// IShellView::EnableModelessSV
// From Browser -> DocView -> DocObject
HRESULT CDocObjectView::EnableModelessSV(BOOL fEnable)
{
HRESULT hres = S_OK;
// We have no modeless window to be enabled/disabled
TraceMsg(0, "sdv TR - ::EnableModelessSV(%d) called", fEnable);
if (_pdoh) {
hres = _pdoh->_xao.EnableModeless(fEnable);
TraceMsg(0, "sdv TR - _piact->EnableModeless returned %x", hres);
}
return hres;
}
HRESULT CDocObjectView::UIActivate(UINT uState)
{
HRESULT hres = E_FAIL;
if (_pdoh)
{
hres = _pdoh->UIActivate(uState, _fPrevViewIsDocView);
}
_uState = uState;
return hres;
}
HRESULT CDocObjectView::Refresh()
{
if (_pdoh)
{
VARIANT v = {0};
v.vt = VT_I4;
v.lVal = OLECMDIDF_REFRESH_NO_CACHE;
// send this to exec so that it will update last refresh time.
// all refresh to dochost should go through our own exec
return Exec(NULL, OLECMDID_REFRESH, OLECMDEXECOPT_PROMPTUSER, &v, NULL);
}
return S_OK;
}
// Return:
// S_OK: It is a folder shortcut and ppidlTarget is filled out if provided.
// S_FALSE: It is not a folder shortcut and ppidlTarget is filled with NULL if provided.
// FAILED: An error occured trying to detect.
//
// Don't use this function if there is a better way. Look into using
// IBrowserFrameOptions. -BryanSt
HRESULT IsFolderShortcutPidl(IN LPCITEMIDLIST pidl)
{
IShellFolder * psf = NULL;
HRESULT hr = IEBindToObject(pidl, &psf);
if (SUCCEEDED(hr))
{
IShellLinkA * psl;
hr = psf->QueryInterface(IID_PPV_ARG(IShellLinkA, &psl));
if (SUCCEEDED(hr))
{
hr = S_OK;
psl->Release();
}
else
hr = S_FALSE; // It's not a folder shortcut.
psf->Release();
}
return hr;
}
// WARNING: This function explicitely creates URLMON monikers
// because that's what the caller needs. Some NSEs will
// support IShellFolder::BindToObject(IMoniker)
// but this function doesn't use that logic intentionally.
//
STDAPI _URLMONMonikerFromPidl(LPCITEMIDLIST pidl, IMoniker** ppmk, BOOL* pfFileProtocol)
{
TCHAR szPath[MAX_URL_STRING];
HRESULT hres = E_UNEXPECTED;
*ppmk = NULL;
*pfFileProtocol = FALSE;
MNKMSG(TEXT("_URLMONMonikerFromPidl"), TEXT("called"));
AssertMsg((S_OK != IsFolderShortcutPidl(pidl)), TEXT("We shouldn't get Folder Shortcuts here because we don't deref them to get the target. And we should never need to."));
// Is this a child of the "Internet Explorer" name space?
if (!IsURLChild(pidl, TRUE))
{
// No, so we want to get the display name to use to
// create the moniker. We will try to turn it into
// an URL if it isn't already an URL.
// NOTE: We don't try IEBindToObject(pidl, IID_IMoniker)
// because the caller requires that this
// IMoniker come from URLMON.
HRESULT hrTemp = SHGetPathFromIDList(pidl, szPath);
AssertMsg(SUCCEEDED(hrTemp), TEXT("_URLMONMonikerFromPidl() failed SHGetPathFromIDList() which is really bad because we probably won't be able to create a moniker from it. We will try to create a URLMON moniker below."));
if (SUCCEEDED(hrTemp))
{
// this should never be a fully qualified URL
DWORD cchPath = ARRAYSIZE(szPath);
ASSERT(URL_SCHEME_INVALID == GetUrlScheme(szPath));
if(SUCCEEDED(hres = UrlCreateFromPath(szPath, szPath, &cchPath, 0)))
{
MNKMSG(TEXT("_URLMONMonikerFromPidl Creating File Moniker"), szPath);
}
*pfFileProtocol = TRUE;
}
}
else
{
// Yes so we are guaranteed this is from the "Internet Explorer"
// name space so remove Fragment hidden itemID.
// We do this because we navigate to the fragment later,
// after the page is downloaded. This is also needed
// for delegates of the IE name space. (FTP is one example of
// a delegate).
ASSERT(pidl);
ASSERT(!ILIsEmpty(_ILNext(pidl))); // Make sure it's not the start page URL.
LPITEMIDLIST pidlClone = ILClone(pidl);
if (pidlClone)
{
// we dont want to pass the fragment into URLMON
// so we pull it off before calling into GDN.
// Note that pidlClone needs to be the pidlTarget
// of folder shortcuts or the dislpay name will
// be the file system path of the folder shortcut
// if at the top level.
ILRemoveHiddenID(pidlClone, IDLHID_URLFRAGMENT);
IEGetDisplayName(pidlClone, szPath, SHGDN_FORPARSING);
hres = S_OK;
ILFree(pidlClone);
}
}
if (SUCCEEDED(hres))
{
if (szPath[0])
{
hres = MonikerFromString(szPath, ppmk);
}
else
{
ASSERT(FALSE);
hres = E_UNEXPECTED;
}
}
return hres;
}
HRESULT CDocObjectView::HandleRename(LPCITEMIDLIST pidl)
{
return E_NOTIMPL;
}
HRESULT CDocObjectView::CreateViewWindow(IShellView *psvPrev,
LPCFOLDERSETTINGS lpfs, IShellBrowser * psb,
RECT * prcView, HWND *phWnd)
{
SV2CVW2_PARAMS cParams;
cParams.cbSize = SIZEOF(SV2CVW2_PARAMS);
cParams.psvPrev = psvPrev;
cParams.pfs = lpfs;
cParams.psbOwner = psb;
cParams.prcView = prcView;
cParams.pvid = NULL;
HRESULT hres = CreateViewWindow2(&cParams);
*phWnd = cParams.hwndView;
IOleWindow *pOleWindow;
// need top level frame available for D&D
HRESULT hr = IUnknown_QueryService(_psb, SID_STopLevelBrowser, IID_PPV_ARG(IOleWindow, &pOleWindow));
if(SUCCEEDED(hr))
{
ASSERT(pOleWindow);
pOleWindow->GetWindow(&_hwndParent);
pOleWindow->Release();
}
return(hres);
}
void CDocObjectView::_CompleteDocHostPassing(IShellView * psvPrev, HRESULT hresBinding)
{
BOOL fPassedSV = FALSE;
// If there was a previous shell view, see if it was our class.
//
if (psvPrev)
{
CDocObjectView * pdovPrev;
HRESULT hres = psvPrev->QueryInterface(CLSID_CDocObjectView, (void **)&pdovPrev);
if (SUCCEEDED(hres))
{
// Previous shell view is also an instance of CDocObjectView,
// Remember that for optimization later.
//
_fPrevViewIsDocView = TRUE;
// it was, and we have the same doc host as they do.
// we've succeeded in taking over, so null them out if we
// succeeeded in our bind. null ourselves out if we failed
//
if (pdovPrev->_pdoh == _pdoh)
{
if (SUCCEEDED(hresBinding))
{
pdovPrev->_DisconnectHostSink(); // just in case
_ConnectHostSink(); // just in case
ATOMICRELEASET(pdovPrev->_pdoh, CDocObjectHost);
}
else
{
_DisconnectHostSink(); // unhook
pdovPrev->_ConnectHostSink(); // kick other guy
ATOMICRELEASET(_pdoh, CDocObjectHost);
}
fPassedSV = TRUE;
}
pdovPrev->Release();
}
}
if (!fPassedSV)
{
if (FAILED(hresBinding))
{
DestroyViewWindow();
}
}
}
BOOL CDocObjectView::_CanUseCache()
{
// NOTE: this function is more like _DontHaveToHitTheNet()
// the name is legacy from the objectcache.
if (!_fCanCacheFetched)
{
_fCanCache = TRUE;
_fCanCacheFetched = TRUE;
_fIsGet = TRUE;
IServiceProvider *psp;
_psb->QueryInterface(IID_PPV_ARG(IServiceProvider, &psp));
if (psp)
{
IBindStatusCallback *pbsc;
if (SUCCEEDED(GetTopLevelBindStatusCallback(psp, &pbsc)))
{
BINDINFO binfo;
ZeroMemory(&binfo, sizeof(BINDINFO));
binfo.cbSize = sizeof(BINDINFO);
DWORD grfBINDF = BINDF_ASYNCHRONOUS;
HRESULT hr = pbsc->GetBindInfo(&grfBINDF, &binfo);
if (SUCCEEDED(hr))
{
if (grfBINDF & (BINDF_GETNEWESTVERSION | BINDF_RESYNCHRONIZE))
{
_fCanCache = FALSE;
}
_fIsGet = (binfo.dwBindVerb == BINDVERB_GET);
ReleaseBindInfo(&binfo);
}
pbsc->Release();
}
// I believe that failing to get the Bindstatuscallback should
// not happen since we no longer use the object cache.
// and if it does, then we no that we didnt have to repost
// or something similar
psp->Release();
}
}
return _fCanCache;
}
void CDocObjectView::_ConnectHostSink()
{
if (_pdoh)
{
IAdviseSink *pSink;
if (FAILED(_pdoh->GetAdvise(NULL, NULL, &pSink)))
pSink = NULL;
if (pSink != (IAdviseSink *)this)
_pdoh->SetAdvise(DVASPECT_CONTENT, ADVF_PRIMEFIRST, this);
if (pSink)
pSink->Release();
}
}
void CDocObjectView::_DisconnectHostSink()
{
IAdviseSink *pSink;
// paranoia: only blow away the advise sink if it is still us
if (_pdoh && SUCCEEDED(_pdoh->GetAdvise(NULL, NULL, &pSink)) && pSink)
{
if (pSink == (IAdviseSink *)this)
_pdoh->SetAdvise(0, 0, NULL);
pSink->Release();
}
OnViewChange(DVASPECT_CONTENT, -1);
}
#if 0
BOOL _SameLocations(LPSTR pszLoc1, LPSTR pszLoc2)
{
// if they're both the same pointer (null)
// or if they both exist and have the same string, then
// they are the same location
if (pszLoc1 == pszLoc2 ||
(pszLoc1 && pszLoc2 &&
!lstrcmp(pszLoc1, pszLoc2))) {
return TRUE;
}
return FALSE;
}
#endif
//
// This function either (1) Create a new CDocObjectHost or (2) reuse it from
// the previous view. If also returns the DisplayName of previous moniker.
//
void CDocObjectView::_CreateDocObjHost(IShellView * psvPrev)
{
BOOL fWindowOpen = FALSE;
// if there was a previous shell view, see if it was our class.
if (psvPrev)
{
CDocObjectView * pdovPrev = NULL;
HRESULT hres = psvPrev->QueryInterface(CLSID_CDocObjectView, (void **)&pdovPrev);
if (SUCCEEDED(hres))
{
CDocObjectHost * pPrevDOH = pdovPrev->_pdoh;
ASSERT(_psb);
ASSERT(_psb == pdovPrev->_psb);
// find out if we should be saving the view state when we close
// if the one we're coming from says yes, then we'll take over that
// job instead of them.
//
_fSaveViewState = pdovPrev->_fSaveViewState;
pdovPrev->_fSaveViewState = FALSE;
//
// if this is a local anchor navigation,
// we treat it substantially differently.
// we can reuse the DOH and the OLE Object that
// it holds. - zekel - 31-JUL-97
//
// WARNING: we should not reuse these objects for any other
// reason than a local anchor (fragment) navigation.
// we used to be a lot more lenient about reusing the DOH
// but i think this was mostly because of the old object cache.
//
// we check for equal pidls so that we know we are on
// the same URL. we require that _pszLocation be set.
// this is for Netscape compat. this means that anytime
// we get a navigate to ourself it will refresh completely
// if there was no fragment. we also check to make sure that
// the binding does not require us to hit the net for
// this request.
//
// 08-11-1999 (scotrobe): We now reuse the DOH if the
// hosted document has indicated that it knows how to
// navigate on its own.
//
if (_pidl && pdovPrev->_pidl && pPrevDOH &&
(pPrevDOH->_fDocCanNavigate
|| ( _pszLocation && IEILIsEqual(_pidl, pdovPrev->_pidl, TRUE)
&& _CanUseCache())))
{
IBrowserService *pbs;
if (SUCCEEDED(_psb->QueryInterface(IID_PPV_ARG(IBrowserService, &pbs))))
{
DWORD dwFlags = 0;
// If the document doesn't know how to navigate, then this may
// mean that this navigation was delegated from the document.
// In that case, if we have gotten this far, that means that
// _pszLocation is set. If it is and this is a delegated navigation
// (i.e., the navigation wasn't due to a link in a non-html document)
// we must create a new document.
//
if (!pPrevDOH->_fDocCanNavigate)
{
pbs->GetFlags(&dwFlags);
}
if (!(dwFlags & BSF_DELEGATEDNAVIGATION))
{
//
// if SetHistoryObject() fails, then that means there is already
// an object there for us to use. this means that we should
// not treat this as a local anchor navigation. and
// we shouldnt reuse the DOH even though the pidl is identical
//
// TRUE is passed to SetHistoryObject even if this is not a
// local anchor. In the case that this is not a local anchor,
// the document (Trident) handles the navigation. Therefore,
// the document will take care of updating the travel log and
// the fIsLocalAnchor flag is ignored.
//
if (SUCCEEDED(pbs->SetHistoryObject(pPrevDOH->_pole,
!pPrevDOH->_fDocCanNavigate ? TRUE : FALSE)))
{
TraceMsg(TF_TRAVELLOG, "CDOV::CreateDocObjHost reusing current DOH on local anchor navigate");
//
// we cant update in ActivateNow because at that point
// we have already switched the dochost over to the new
// (reused) view. so we need to update the entry now
//
// The fact that the hosted document can navigate on its own,
// implies that it will take care of updating the travel log.
//
if (!pPrevDOH->_fDocCanNavigate)
{
ITravelLog * ptl;
pbs->GetTravelLog(&ptl);
if (ptl)
{
ptl->UpdateEntry(pbs, TRUE);
ptl->Release();
}
}
pdovPrev->_DisconnectHostSink(); // we will connect below
// same target! pass the docobj host
_pdoh = pPrevDOH;
_pdoh->AddRef();
if (_pdoh->_fDocCanNavigate)
{
_pdoh->OnInitialUpdate();
}
if ((_pdoh->_dwAppHack & BROWSERFLAG_SUPPORTTOP) && !_pszLocation)
{
// if there's no location for us to go to, and
// we're traversing in the same document,
// assume top.
//
_pszLocation = StrDup(TEXT("#top"));
_uiCP = CP_ACP;
}
}
pbs->Release();
}
}
}
// In the case where we are opening a non-html mime type
// in a new window, we need to pass the _fWindowOpen
// flag from the previous docobject host to the new
// docobject host. This is needed so that if we are opening
// a file outside of IE in a new window, we'll know to close
// the newly created IE afterwards.
// The problem is that there isn't really a good place to
// clear this flag since it has to remain set from one
// instance of the docobject host to the next. This causes
// us to get into the situation where we'll close the browser
// window if we click on a link to a file that opens outside
// of IE after opening a new window for an html file.
// The bottom line is that we only need to pass this flag to
// the new docobject host if we opening an non-html mime type
// in a new window.
//
if (!_pdoh && pPrevDOH && pPrevDOH->_fDelegatedNavigation)
{
fWindowOpen = pPrevDOH->_fWindowOpen;
}
//
// FEATURE: We should take care of _pibscNC as well
// to 'chain' the IBindStatusCallback.
//
pdovPrev->Release();
}
}
// if we didn't pass the docobj host, create a new one and
// pass the doc context
if (!_pdoh)
{
ASSERT(_psb);
_pdoh = new CDocObjectHost(fWindowOpen);
// Reset host navigation flag in the browser
//
IUnknown_Exec(_psb,
&CGID_DocHostCmdPriv,
DOCHOST_DOCCANNAVIGATE,
0, NULL, NULL);
}
if (_pdoh)
{
_ConnectHostSink();
}
}
extern HRESULT TargetQueryService(IUnknown *punk, REFIID riid, void **ppvObj);
HRESULT CDocObjectView::CreateViewWindow2(LPSV2CVW2_PARAMS lpParams)
{
HRESULT hres = S_OK;
IShellView * psvPrev = lpParams->psvPrev;
LPCFOLDERSETTINGS lpfs = lpParams->pfs;
IShellBrowser * psb = lpParams->psbOwner;
RECT * prcView = lpParams->prcView;
HWND UNALIGNED * phWnd = &lpParams->hwndView;
if (_pdoh || !_pidl)
{
*phWnd = NULL;
ASSERT(0);
return E_UNEXPECTED;
}
_fs = *lpfs;
ASSERT(_psb==NULL);
_psb = psb;
psb->AddRef();
ASSERT(_pctShellBrowser==NULL);
_psb->QueryInterface(IID_IOleCommandTarget, (void **)&_pctShellBrowser);
//if somebody that is not a ShellBrowser (like the FileOpenBrowser)
// tries to use us, we want to block them. we will fault later on
// if we dont have the right stuff.
if (!_pctShellBrowser)
return E_UNEXPECTED;
// prime the cache bit. this needs to be done while we're *the* guy navigating.
// otherwise, if we ask later when there's a different pending navigation,
// we'll get his info
_CanUseCache();
_SetLastRefreshTime();
// Either create a new CDocObjectHost or reuse it from the previous view
// and set it in _pdoh.
_CreateDocObjHost(psvPrev);
if (!_pdoh || !_pdoh->InitHostWindow(this, psb, prcView))
{
ATOMICRELEASE(_psb);
_pctShellBrowser->Release();
_pctShellBrowser = NULL;
return E_OUTOFMEMORY;
}
_pdoh->GetWindow(phWnd);
ASSERT(NULL == _pdho);
_pdoh->QueryInterface(IID_IDocHostObject, (void **)&_pdho);
IMoniker* pmk = NULL;
BOOL fFileProtocol;
hres = ::_URLMONMonikerFromPidl(_pidl, &pmk, &fFileProtocol);
if (SUCCEEDED(hres) && EVAL(pmk))
{
hres = _pdoh->SetTarget(pmk, _uiCP, _pszLocation, _pidl, psvPrev, fFileProtocol);
_psvPrev = psvPrev;
if (_psvPrev)
_psvPrev->AddRef();
#ifdef NON_NATIVE_FRAMES
_CompleteDocHostPassing(psvPrev, hres);
#endif
pmk->Release();
}
return hres;
}
void CDocObjectView::_GetViewSettings(IEVIEWINFO* pievi)
{
DWORD dwType, dwSize;
// REVIEW: Currently, we have on setting for all docobj class views
// (everything hosted by shdocvw). we may want to subclassify them by clsid
// of the docobj or maybe special case mshtml...
dwSize = sizeof(IEVIEWINFO);
if (SHGetValueGoodBoot(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Internet Explorer\\Main"),
TEXT("ViewSettings"), &dwType, (PBYTE)pievi, &dwSize) == ERROR_SUCCESS)
{
if (pievi->cbSize != sizeof(IEVIEWINFO))
{
goto DefaultInfo;
}
}
else
{
DefaultInfo:
// can't count on 0 init because registry could have read stuff, but
// of the wrong size (corruption)
pievi->fToolbar = FALSE;
pievi->fCoolbar = TRUE;
pievi->fStatusbar = TRUE;
}
}
void CDocObjectView::_SaveViewState()
{
IEVIEWINFO ievi;
int id;
// First ask up if it is ok for us to save view state. If we get the return value of
// S_FALSE bail as we were told no.
if (_pctShellBrowser &&
(_pctShellBrowser->Exec(&CGID_Explorer, SBCMDID_MAYSAVEVIEWSTATE, 0, NULL, NULL) == S_FALSE))
return;
// first load to preserve things we're not going to set
_GetViewSettings(&ievi);
ievi.cbSize = sizeof(ievi);
id = _ShowControl(FCW_STATUS, SBSC_QUERY);
// bail if it's not supported
if (id == -1)
return;
ievi.fStatusbar = (id == SBSC_SHOW);
id = _ShowControl(FCW_TOOLBAR, SBSC_QUERY);
if (id != -1) {
// this is allowed to fail if toolbar isn't supported (ie30 case)
ievi.fToolbar = (id == SBSC_SHOW);
}
id = _ShowControl(FCW_INTERNETBAR, SBSC_QUERY);
if (id != -1) {
// this is allowed to fail if coolbar isn't supported
ievi.fCoolbar = (id == SBSC_SHOW);
}
SHSetValue(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Internet Explorer\\Main"),
TEXT("ViewSettings"), REG_BINARY, (const BYTE *)&ievi, sizeof(ievi));
}
int CDocObjectView::_ShowControl(UINT idControl, int idCmd)
{
VARIANTARG var;
VariantInit(&var);
var.vt = VT_I4;
var.lVal = MAKELONG(idControl, idCmd);
if (_pctShellBrowser &&
SUCCEEDED(_pctShellBrowser->Exec(&CGID_Explorer, SBCMDID_SHOWCONTROL, OLECMDEXECOPT_DODEFAULT,
&var, &var)))
return var.lVal;
return -1;
}
HRESULT CDocObjectView::DestroyViewWindow()
{
ATOMICRELEASE(_pdho);
if (_pdoh)
{
BOOL fDestroyHost = TRUE;
if (_psb && _pdoh->_pwb)
{
DWORD dwFlags;
_pdoh->_pwb->GetFlags(&dwFlags);
if (dwFlags & BSF_HTMLNAVCANCELED)
{
IShellView * psvCur;
HRESULT hr = _psb->QueryActiveShellView(&psvCur);
if (S_OK == hr)
{
CDocObjectView * pdovCur;
hr = psvCur->QueryInterface(CLSID_CDocObjectView, (void**)&pdovCur);
if (S_OK == hr)
{
ASSERT(this != pdovCur);
if (_pdoh == pdovCur->_pdoh)
{
fDestroyHost = FALSE;
}
pdovCur->Release();
}
psvCur->Release();
}
}
}
if (fDestroyHost)
{
TraceMsg(DM_WARNING, "CDocObjectView::DestroyViewWindow(): Destroying Host Window");
_DisconnectHostSink();
if (_fSaveViewState)
_SaveViewState();
_pdoh->DestroyHostWindow();
}
ATOMICRELEASET(_pdoh, CDocObjectHost);
}
ATOMICRELEASE(_pctShellBrowser);
// Note that we should release _psb at the very end.
ATOMICRELEASE(_psb);
return S_OK;
}
HRESULT CDocObjectView::GetCurrentInfo(LPFOLDERSETTINGS lpfs)
{
*lpfs = _fs;
return S_OK;
}
HRESULT CDocObjectView::AddPropertySheetPages(DWORD dwReserved,
LPFNADDPROPSHEETPAGE lpfn, LPARAM lParam)
{
if (_pdoh)
return _pdoh->AddPages(lpfn, lParam);
return E_FAIL;
}
HRESULT CDocObjectView::SaveViewState()
{
// No viewsate to be saved
return S_OK;
}
HRESULT CDocObjectView::SelectItem(LPCITEMIDLIST pidlItem, UINT uFlags)
{
// No item
return E_FAIL;
}
//
// IShellView::GetItemObject
//
// For this IShellView object, the only valid uItem is SVGIO_BACKGROUND,
// which allows the browser to access an interface pointer to the
// currently active document object.
//
// Notes:
// The browser should be aware that IShellView::CreateViewWindow might be
// asynchronous. This method will fail with E_FAIL if the document is not
// instanciated yet.
//
HRESULT CDocObjectView::GetItemObject(UINT uItem, REFIID riid, void **ppv)
{
HRESULT hres = E_INVALIDARG;
*ppv = NULL; // assumes error
switch(uItem)
{
case SVGIO_BACKGROUND:
if (_pdoh)
{
if (_pdoh->_pole)
{
hres = _pdoh->_pole->QueryInterface(riid, ppv);
break;
}
else if (_pdoh->_punkPending)
{
hres = _pdoh->_punkPending->QueryInterface(riid, ppv);
break;
}
}
// fall through on the else's
default:
hres = E_FAIL;
break;
}
return hres;
}
HRESULT CDocObjectView::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
_fSelfDragging = FALSE;
//
// Check if this is a self-dragging or not.
//
if (_pdoh && _pdoh->_pmsot) {
VARIANT var = { 0 };
HRESULT hresT = _pdoh->_pmsot->Exec(
&CGID_ShellDocView, SHDVID_ISDRAGSOURCE, 0, NULL, &var);
if (SUCCEEDED(hresT) && var.vt==VT_I4 && var.lVal) {
_fSelfDragging = TRUE;
}
VariantClearLazy(&var);
}
ASSERT(pdtobj);
_DragEnter(_hwndParent, ptl, pdtobj);
_dwDragEffect = CommonDragEnter(pdtobj, grfKeyState, ptl);
return DragOver(grfKeyState, ptl, pdwEffect);
}
HRESULT CDocObjectView::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
*pdwEffect &= _dwDragEffect;
_DragMove(_hwndParent, ptl);
if (_fSelfDragging && _pdoh && _pdoh->_hwnd) {
RECT rc;
GetClientRect(_pdoh->_hwnd, &rc);
POINT ptMap = { ptl.x, ptl.y };
MapWindowPoints(HWND_DESKTOP, _pdoh->_hwnd, &ptMap, 1);
if (PtInRect(&rc, ptMap)) {
*pdwEffect = DROPEFFECT_NONE;
}
}
return S_OK;
}
HRESULT CDocObjectView::DragLeave(void)
{
DAD_DragLeave();
return S_OK;
}
HRESULT CDocObjectView::Drop(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
LPITEMIDLIST pidlTarget;
HRESULT hr = SHPidlFromDataObject(pdtobj, &pidlTarget, NULL, 0);
if (SUCCEEDED(hr)) {
ASSERT(pidlTarget);
if((!ILIsWeb(pidlTarget) && _pdoh && SHIsRestricted2W(_pdoh->_hwnd, REST_NOFILEURL, NULL, 0)) ||
(_pdoh && !IEIsLinkSafe(_pdoh->_hwnd, pidlTarget, ILS_NAVIGATE)))
{
ILFree(pidlTarget);
hr = E_ACCESSDENIED;
}
else
{
DWORD flags = GetKeyState(VK_CONTROL) < 0 ?
(SBSP_NEWBROWSER | SBSP_ABSOLUTE) :
(SBSP_SAMEBROWSER | SBSP_ABSOLUTE);
hr = _psb->BrowseObject(pidlTarget, flags);
HFRMMSG2(TEXT("::Drop _psb->BrowseObject returned"), hr, 0);
ILFree(pidlTarget);
}
}
if (SUCCEEDED(hr))
{
*pdwEffect &= _dwDragEffect;
}
DAD_DragLeave();
return hr;
}
ULONG CDocObjectView::AddRef()
{
_cRef++;
TraceMsg(TF_SHDREF, "CDocObjectView(%x)::AddRef called new _cRef=%d", this, _cRef);
return _cRef;
}
ULONG CDocObjectView::Release()
{
_cRef--;
TraceMsg(TF_SHDREF, "CDocObjectView(%x)::Release called new _cRef=%d", this, _cRef);
if (_cRef > 0)
return _cRef;
delete this;
return 0;
}
HRESULT CDocObjectView::GetView(SHELLVIEWID* pvid, ULONG uView)
{
return E_NOTIMPL;
}
#ifdef DEBUG
#define _AddRef(psz) { ++_cRef; TraceMsg(TF_SHDREF, "CDocObjectView(%x)::QI(%s) is AddRefing _cRef=%d", this, psz, _cRef); }
#else
#define _AddRef(psz) ++_cRef
#endif
HRESULT CDocObjectView::QueryInterface(REFIID riid, void ** ppvObj)
{
HRESULT hres;
static const QITAB qit[] = {
QITABENT(CDocObjectView, IShellView2),
QITABENTMULTI(CDocObjectView, IShellView, IShellView2),
QITABENTMULTI(CDocObjectView, IOleWindow, IShellView2),
QITABENT(CDocObjectView, IDropTarget),
QITABENT(CDocObjectView, IViewObject),
QITABENT(CDocObjectView, IAdviseSink),
QITABENT(CDocObjectView, IOleCommandTarget),
QITABENT(CDocObjectView, IDocViewSite),
QITABENT(CDocObjectView, IPrivateOleObject ),
QITABENT(CDocObjectView, IPersistFolder),
QITABENTMULTI(CDocObjectView, IPersist, IPersistFolder),
QITABENT(CDocObjectView, IServiceProvider),
{ 0 },
};
hres = QISearch(this, qit, riid, ppvObj);
if (S_OK != hres)
{
if (IsEqualIID(riid, CLSID_CDocObjectView))
{
*ppvObj = (void*)this;
_AddRef(TEXT("CLSID_CDocObjectView"));
return S_OK;
}
}
return hres;
}
/// ***** IViewObject ******
HRESULT CDocObjectView::GetColorSet(DWORD dwAspect, LONG lindex,
void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev,
LOGPALETTE **ppColorSet)
{
if (_pdoh)
{
return _pdoh->GetColorSet(dwAspect, lindex, pvAspect, ptd,
hicTargetDev, ppColorSet);
}
if (ppColorSet)
*ppColorSet = NULL;
return S_FALSE;
}
HRESULT CDocObjectView::Freeze(DWORD, LONG, void *, DWORD *pdwFreeze)
{
return E_NOTIMPL;
}
HRESULT CDocObjectView::Unfreeze(DWORD)
{
return E_NOTIMPL;
}
HRESULT CDocObjectView::SetAdvise(DWORD dwAspect, DWORD advf,
IAdviseSink *pSink)
{
if (dwAspect != DVASPECT_CONTENT)
return DV_E_DVASPECT;
if (advf & ~(ADVF_PRIMEFIRST | ADVF_ONLYONCE))
return E_INVALIDARG;
if (pSink != _padvise)
{
ATOMICRELEASE(_padvise);
_padvise = pSink;
if (_padvise)
_padvise->AddRef();
}
if (_padvise)
{
_advise_aspect = dwAspect;
_advise_advf = advf;
if (advf & ADVF_PRIMEFIRST)
OnViewChange(dwAspect, -1);
}
else
_advise_aspect = _advise_advf = 0;
return S_OK;
}
HRESULT CDocObjectView::GetAdvise(DWORD *pdwAspect, DWORD *padvf,
IAdviseSink **ppSink)
{
if (pdwAspect)
*pdwAspect = _advise_aspect;
if (padvf)
*padvf = _advise_advf;
if (ppSink)
{
if (_padvise)
_padvise->AddRef();
*ppSink = _padvise;
}
return S_OK;
}
HRESULT CDocObjectView::Draw(DWORD dwDrawAspect, LONG lindex, void *pvAspect,
DVTARGETDEVICE *ptd, HDC hicTargetDev, HDC hdcDraw,
const RECTL *lprcBounds, const RECTL *lprcWBounds,
BOOL (*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue)
{
if (_pdoh) {
return _pdoh->Draw(dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev,
hdcDraw, lprcBounds, lprcWBounds, pfnContinue, dwContinue);
}
return OLE_E_BLANK;
}
// IAdviseSink
void CDocObjectView::OnDataChange(FORMATETC *, STGMEDIUM *)
{
}
void CDocObjectView::OnViewChange(DWORD dwAspect, LONG lindex)
{
dwAspect &= _advise_aspect;
if (dwAspect && _padvise)
{
IAdviseSink *pSink = _padvise;
IUnknown *punkRelease;
if (_advise_advf & ADVF_ONLYONCE)
{
punkRelease = pSink;
_padvise = NULL;
_advise_aspect = _advise_advf = 0;
}
else
punkRelease = NULL;
pSink->OnViewChange(dwAspect, lindex);
if (punkRelease)
punkRelease->Release();
}
}
void CDocObjectView::OnRename(IMoniker *)
{
}
void CDocObjectView::OnSave()
{
}
void CDocObjectView::OnClose()
{
//
// the doc object host went away so tell anybody above what happened
//
OnViewChange(_advise_aspect, -1);
}
HRESULT CDocObjectView::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext)
{
HRESULT hres = OLECMDERR_E_UNKNOWNGROUP;
if (_pdho && _pdoh)
hres = _pdho->QueryStatusDown(pguidCmdGroup, cCmds, rgCmds, pcmdtext);
return hres;
}
HRESULT CDocObjectView::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
{
HRESULT hres = OLECMDERR_E_UNKNOWNGROUP;
if (!pguidCmdGroup)
{
switch (nCmdID)
{
case OLECMDID_REFRESH:
_SetLastRefreshTime();
break;
default:
break;
}
}
else if (IsEqualGUID(CGID_ShellDocView, *pguidCmdGroup))
{
switch(nCmdID)
{
case SHDVID_UPDATEDOCHOSTSTATE:
if (_pdoh)
{
DOCHOSTUPDATEDATA * pdhud;
ASSERT(pvarargIn && pvarargIn->vt == VT_PTR);
pdhud = (DOCHOSTUPDATEDATA *) V_BYREF(pvarargIn);
return _pdoh->_UpdateState(pdhud->_pidl, pdhud->_fIsErrorUrl);
}
return S_OK;
case SHDVID_COMPLETEDOCHOSTPASSING:
_CompleteDocHostPassing(_psvPrev, S_OK);
ATOMICRELEASE(_psvPrev);
return S_OK;
case SHDVID_NAVSTART:
if (_pdoh)
{
_pdoh->_Init();
}
return S_OK;
default:
break;
}
}
// only forward on if we aren't 'stolen'.
// FEATURE ie4: clean this up to steal _pdho along w/ _pdoh.
if (_pdho && _pdoh)
hres = _pdho->ExecDown(pguidCmdGroup, nCmdID, nCmdexecopt, pvarargIn, pvarargOut);
// REVIEW: if _pdoh->ExecDown fails && pguidCmdGroup==NULL && nCmdID is
// OLECMDID_STOP or OLECMDID_REFRESH, then we are lying
// by returning a failure error code.
return hres;
}
HRESULT CDocObjectView::OnSetTitle(VARIANTARG *pvTitle)
{
return E_NOTIMPL;
}
HRESULT CDocObjectView::SetExtent( DWORD dwDrawAspect, SIZEL *psizel)
{
if ( _pdoh && _pdoh->GetOleObject() )
{
return _pdoh->GetOleObject()->SetExtent( dwDrawAspect, psizel );
}
return E_NOTIMPL;
}
HRESULT CDocObjectView::GetExtent( DWORD dwDrawAspect, SIZEL *psizel)
{
if ( _pdoh && _pdoh->GetOleObject() )
{
return _pdoh->GetOleObject()->GetExtent( dwDrawAspect, psizel );
}
return E_NOTIMPL;
}
HRESULT CDocObjectView::GetClassID(CLSID *pclsid)
{
if (pclsid)
{
*pclsid = CLSID_CDocObjectView;
return S_OK;
}
return E_INVALIDARG;
}
HRESULT CDocObjectView::Initialize(LPCITEMIDLIST pidl)
{
HRESULT hres = E_OUTOFMEMORY;
LPITEMIDLIST pidlClone = ILClone(pidl);
if (pidlClone)
{
IShellFolder* psf;
if (SUCCEEDED(IEBindToObject(_pidl, &psf)))
{
ILFree(_pidl);
ATOMICRELEASE(_psf);
_pidl = pidlClone;
_psf = psf;
hres = S_OK;
}
else
{
ILFree(pidlClone);
}
}
return hres;
}
HRESULT CDocObjectView::QueryService(REFGUID guidService, REFIID riid, void **ppvObj)
{
if( _pdoh && IsEqualGUID(guidService, IID_IElementNamespaceTable) )
{
return _pdoh->QueryService( guidService, riid, ppvObj);
}
else
return E_FAIL;
}