You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1459 lines
38 KiB
1459 lines
38 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1995.
|
|
//
|
|
// File: srvhndlr.cpp
|
|
//
|
|
// Contents:
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 9-18-95 JohannP Created
|
|
// 10-30-96 rogerg Changed to New Embed ServerHandler Model.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
#include <le2int.h>
|
|
|
|
#include <ole2int.h>
|
|
#include <stdid.hxx> // CStdIdentity
|
|
#include <marshal.hxx> // CStdMarshal
|
|
#include <idtable.hxx> // Indentity Table
|
|
#include <ipidtbl.hxx> // IpidTable.
|
|
#include "xmit.hxx"
|
|
|
|
#include "srvhndlr.h"
|
|
#include "clthndlr.h"
|
|
#include "defhndlr.h"
|
|
|
|
extern HRESULT UnMarshalHelper(MInterfacePointer *pIFP, REFIID riid, void **ppv);
|
|
extern INTERNAL_(BOOL) ChkIfLocalOID(OBJREF &objref, CStdIdentity **ppStdId);
|
|
|
|
// TODO: All Marshaling and set up for Run, DoVerb, SetClientSite should be moved
|
|
// Into the EmbHelper so all DefHndlr has to do is call the Function as normal.
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CreateEmbeddingServerHandler
|
|
//
|
|
// Synopsis: Creates a New Instance of the Embedded Server Handler.
|
|
//
|
|
// Arguments:
|
|
// pStdId - Pointer to StandardIdentity for Object
|
|
// ppunkESHandler - PlaceHolder to Return the New serverHandler.
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
HRESULT CreateEmbeddingServerHandler(CStdIdentity *pStdId,IUnknown **ppunkESHandler)
|
|
{
|
|
*ppunkESHandler = new CServerHandler(pStdId);
|
|
|
|
return *ppunkESHandler ? NOERROR : E_FAIL;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::CServerHandler
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments:
|
|
// pStdId - Pointer to StandardIdentity for Object
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CServerHandler::CServerHandler(CStdIdentity *pStdid)
|
|
{
|
|
_cRefs = 1; // this is the first addref for the serverhandler interface
|
|
m_pStdId = pStdid;
|
|
|
|
if (m_pStdId)
|
|
m_pStdId->AddRef();
|
|
|
|
m_pOleEmbServerClientSite = NULL;
|
|
m_pCEmbServerClientSite = NULL;
|
|
|
|
return;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::~CServerHandler
|
|
//
|
|
// Synopsis: Destructor
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CServerHandler::~CServerHandler()
|
|
{
|
|
Win4Assert(NULL == m_pStdId);
|
|
Win4Assert(NULL == m_pOleEmbServerClientSite);
|
|
Win4Assert(NULL == m_pCEmbServerClientSite);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::QueryInterface
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [riid] --
|
|
// [ppv] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 9-18-95 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CServerHandler::QueryInterface( REFIID riid, void **ppv )
|
|
{
|
|
HRESULT hresult = NOERROR;
|
|
VDATEHEAP();
|
|
|
|
LEDebugOut((DEB_TRACE,
|
|
"%p _IN CServerHandler::QueryInterface "
|
|
"( %p , %p )\n", this, riid, ppv));
|
|
|
|
if ( IsEqualIID(riid, IID_IUnknown)
|
|
|| IsEqualIID(riid, IID_IServerHandler) )
|
|
{
|
|
*ppv = (void FAR *)this;
|
|
AddRef();
|
|
}
|
|
else
|
|
{
|
|
hresult = E_NOINTERFACE;
|
|
*ppv = NULL;
|
|
}
|
|
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CServerHandler::QueryInterface ( %lx ) "
|
|
"[ %p ]\n", this, hresult, *ppv));
|
|
|
|
return hresult;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::AddRef
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [void] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 9-18-95 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CServerHandler::AddRef( void )
|
|
{
|
|
VDATEHEAP();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CServerHandler::AddRef ( )\n", this));
|
|
|
|
InterlockedIncrement((long *)&_cRefs);
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CServerHandler::AddRef ( %ld ) ", this,
|
|
_cRefs));
|
|
|
|
return _cRefs;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::Release
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [void] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 9-18-95 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CServerHandler::Release( void )
|
|
{
|
|
ULONG cRefs;
|
|
|
|
VDATEHEAP();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CServerHandler::Release ( )\n", this));
|
|
|
|
if (0 == (cRefs = InterlockedDecrement( (long*) &_cRefs)) )
|
|
{
|
|
ReleaseObject();
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CDefObject::Release ( %ld ) ", this,
|
|
cRefs));
|
|
|
|
return cRefs;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::ReleaseObject
|
|
//
|
|
// Synopsis: Releases any references on StdIdentity or Real Object.
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(void) CServerHandler::ReleaseObject()
|
|
{
|
|
LPUNKNOWN lpUnkForSafeRelease;
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CServerHandler::ReleaseObject ( )\n", this));
|
|
|
|
if (m_pOleEmbServerClientSite)
|
|
{
|
|
lpUnkForSafeRelease = (LPUNKNOWN) m_pOleEmbServerClientSite;
|
|
m_pOleEmbServerClientSite = NULL;
|
|
lpUnkForSafeRelease->Release();
|
|
}
|
|
|
|
if (m_pCEmbServerClientSite)
|
|
{
|
|
CEmbServerClientSite *pEmbServerClientSite = m_pCEmbServerClientSite;
|
|
|
|
m_pCEmbServerClientSite = NULL;
|
|
pEmbServerClientSite->Release();
|
|
}
|
|
|
|
if (m_pStdId)
|
|
{
|
|
CStdIdentity* pUnkObj = m_pStdId;
|
|
|
|
m_pStdId = NULL;
|
|
pUnkObj->Release();
|
|
}
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _Out CServerHandler::ReleaseObject ( )\n", this));
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::QueryServerInterface
|
|
//
|
|
// Synopsis: Gets Requested Interface from the Server.
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
INTERNAL CServerHandler::QueryServerInterface(REFIID riid,void ** ppInterface)
|
|
{
|
|
IPIDEntry *pIPIDEntry;
|
|
HRESULT hrDisconnect;
|
|
HRESULT hr = E_NOINTERFACE;
|
|
|
|
// TODO: Other option is for Stdid to hold onto EmbServerHandler and then has the Stdid
|
|
// Call ReleaseObject, Release on the EmbServerHandler in its when the real server object
|
|
// is being released or Disconnected. This option should be tried and if it works would
|
|
// be preferred.
|
|
|
|
if (m_pStdId)
|
|
{
|
|
LOCK(gComLock);
|
|
|
|
m_pStdId->LockServer();
|
|
|
|
if (SUCCEEDED(hr = m_pStdId->FindIPIDEntry(riid,&pIPIDEntry)) )
|
|
{
|
|
UNLOCK(gComLock);
|
|
}
|
|
else
|
|
{
|
|
hrDisconnect = m_pStdId->PreventDisconnect();
|
|
if (SUCCEEDED(hrDisconnect))
|
|
{
|
|
hr = m_pStdId->MarshalIPID(riid,1 /*cRefs */,MSHLFLAGS_NORMAL, &pIPIDEntry);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_pStdId->DecSrvIPIDCnt(pIPIDEntry,1, 0, NULL, MSHLFLAGS_NORMAL); // release Marshaled Ipid.
|
|
}
|
|
|
|
}
|
|
|
|
UNLOCK(gComLock);
|
|
m_pStdId->HandlePendingDisconnect(hrDisconnect);
|
|
}
|
|
|
|
|
|
if ( FAILED(hr) || (IPIDF_DISCONNECTED & pIPIDEntry->dwFlags) )
|
|
{
|
|
m_pStdId->UnLockServer();
|
|
hr = (NOERROR == hr) ? RPC_E_DISCONNECTED : E_NOINTERFACE;
|
|
*ppInterface = NULL;
|
|
}
|
|
else
|
|
{
|
|
*ppInterface = pIPIDEntry->pv;
|
|
}
|
|
}
|
|
|
|
ASSERT_LOCK_NOT_HELD(gComLock);
|
|
|
|
return hr;
|
|
}
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::ReleaseServerInterface
|
|
//
|
|
// Synopsis: Releases Lock in Interface obtained from QueryServerInterface
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
INTERNAL CServerHandler::ReleaseServerInterface(void * pInterface)
|
|
{
|
|
|
|
if (m_pStdId)
|
|
{
|
|
m_pStdId->UnLockServer();
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::Run
|
|
//
|
|
// Synopsis: Server Handler side of invoked when ::Run is Called.
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns:
|
|
//
|
|
// Comments: To be as identical to the ::Run in the Defhndlr as possible
|
|
// ::Run ignores errors if it fails to get the Interfaces and also
|
|
// any error value that is returned from ::SetClientSite.
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CServerHandler::Run(DWORD dwDHFlags,
|
|
REFIID riidClientInterface,
|
|
MInterfacePointer* pIRDClientInterface,
|
|
BOOL fHasIPSite,
|
|
LPOLESTR szContainerApp,
|
|
LPOLESTR szContainerObj,
|
|
IStorage * pStg,
|
|
IAdviseSink* pAdvSink,
|
|
DWORD *pdwConnection,
|
|
HRESULT *hresultClsidUser,
|
|
CLSID *pContClassID,
|
|
HRESULT *hresultContentMiscStatus,
|
|
DWORD *pdwMiscStatus)
|
|
|
|
{
|
|
IPersistStorage *pIStorage = NULL;
|
|
IOleObject *pIOleObject = NULL;
|
|
HRESULT hresult = NOERROR;
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CServerHandler::Run\n", this));
|
|
|
|
*pdwConnection = 0; // make sure dwConnection is 0 on an error.
|
|
|
|
QueryServerInterface(IID_IOleObject,(void **) &pIOleObject);
|
|
|
|
if (pStg && (NOERROR == QueryServerInterface(IID_IPersistStorage,(void **) &pIStorage)) )
|
|
{
|
|
Win4Assert(pIStorage);
|
|
|
|
if (DH_INIT_NEW & dwDHFlags)
|
|
{
|
|
hresult = pIStorage->InitNew(pStg);
|
|
}
|
|
else
|
|
{
|
|
hresult = pIStorage->Load(pStg);
|
|
}
|
|
}
|
|
|
|
Win4Assert(NULL == m_pOleEmbServerClientSite);
|
|
if ( (NOERROR == hresult) && pIRDClientInterface && pIOleObject)
|
|
{
|
|
hresult = GetClientSiteFromMInterfacePtr(riidClientInterface,pIRDClientInterface,fHasIPSite,&m_pOleEmbServerClientSite);
|
|
|
|
if (SUCCEEDED(hresult))
|
|
{
|
|
hresult = pIOleObject->SetClientSite(m_pOleEmbServerClientSite);
|
|
}
|
|
|
|
hresult = NOERROR; // !!! don't fail on SetClientSite Failure.
|
|
}
|
|
|
|
if ((NOERROR == hresult) && (NULL != szContainerApp) && pIOleObject)
|
|
{
|
|
hresult = pIOleObject->SetHostNames(szContainerApp,szContainerObj);
|
|
}
|
|
|
|
if ( (NOERROR == hresult) && pAdvSink && pIOleObject )
|
|
{
|
|
hresult = pIOleObject->Advise(pAdvSink,pdwConnection);
|
|
}
|
|
|
|
if ( (NOERROR == hresult) && pIOleObject )
|
|
{
|
|
*hresultClsidUser = pIOleObject->GetUserClassID(pContClassID);
|
|
*hresultContentMiscStatus = pIOleObject->GetMiscStatus(DVASPECT_CONTENT,pdwMiscStatus);
|
|
}
|
|
|
|
// m_pOleEmbServerClientSite gets set by SetClientSite called above.
|
|
if ( (NOERROR == hresult) && (m_pOleEmbServerClientSite) && pIOleObject)
|
|
{
|
|
LPMONIKER pmk = NULL;
|
|
|
|
if( m_pOleEmbServerClientSite->GetMoniker
|
|
(OLEGETMONIKER_ONLYIFTHERE,
|
|
OLEWHICHMK_OBJREL, &pmk) == NOERROR)
|
|
{
|
|
AssertOutPtrIface(NOERROR, pmk);
|
|
|
|
// SetMoniker Failure doesn't result in a ::Run Failure
|
|
pIOleObject->SetMoniker(OLEWHICHMK_OBJREL, pmk);
|
|
|
|
pmk->Release();
|
|
}
|
|
}
|
|
|
|
if (pIStorage)
|
|
ReleaseServerInterface((void *) pIStorage);
|
|
|
|
if (pIOleObject)
|
|
ReleaseServerInterface((void *) pIOleObject);
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CServerHandler::Run "
|
|
"( %lx )\n", this, hresult));
|
|
|
|
return hresult;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::DoVerb
|
|
//
|
|
// Synopsis: Server Handler side of invoked when ::DoVerb is Called.
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CServerHandler::DoVerb (LONG iVerb, LPMSG lpmsg,BOOL fUseRunClientSite, IOleClientSite* pIOleClientSite,
|
|
LONG lindex,HWND hwndParent,LPCRECT lprcPosRect)
|
|
{
|
|
IOleObject *pIOleObject = NULL;
|
|
IOleClientSite *pDoVerbClientSite = NULL;
|
|
HRESULT hr = NOERROR;
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CServerHandler::DoVerb "
|
|
"( %ld , %p , %p , %ld , %lx , %p )\n", this,
|
|
iVerb, lpmsg, pIOleClientSite, lindex, hwndParent, lprcPosRect));
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IOleObject,(void **) &pIOleObject)) )
|
|
{
|
|
Win4Assert(pIOleObject);
|
|
|
|
if (fUseRunClientSite)
|
|
{
|
|
|
|
pDoVerbClientSite = m_pOleEmbServerClientSite;
|
|
|
|
// inform client site of operation what interfaces to support
|
|
// Todo: Send in Prefetched info for DoVerb here.
|
|
if (m_pCEmbServerClientSite)
|
|
{
|
|
m_pCEmbServerClientSite->SetDoVerbState(TRUE);
|
|
}
|
|
|
|
// put addref on Clientsite so liveness is the same as if marshaled by DoVerb
|
|
// TODO: This isn't really necessayr since Handler also holds a ref.
|
|
if (m_pOleEmbServerClientSite)
|
|
{
|
|
m_pOleEmbServerClientSite->AddRef();
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
pDoVerbClientSite = pIOleClientSite;
|
|
|
|
}
|
|
|
|
hr = pIOleObject->DoVerb(iVerb,lpmsg,pDoVerbClientSite,lindex,hwndParent,lprcPosRect);
|
|
|
|
if (fUseRunClientSite)
|
|
{
|
|
if (m_pCEmbServerClientSite)
|
|
{
|
|
m_pCEmbServerClientSite->SetDoVerbState(FALSE);
|
|
}
|
|
|
|
if (m_pOleEmbServerClientSite)
|
|
{
|
|
m_pOleEmbServerClientSite->Release();
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pIOleObject)
|
|
ReleaseServerInterface((void *) pIOleObject);
|
|
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CServerHandler::Run "
|
|
"( %lx )\n", this, hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
// helper function for creating ClientSite Handler
|
|
INTERNAL CServerHandler::GetClientSiteFromMInterfacePtr(REFIID riidClientInterface,
|
|
MInterfacePointer* pIRDClientSite, BOOL fHasIPSite, LPOLECLIENTSITE* ppOleClientSite)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
|
|
*ppOleClientSite = NULL;
|
|
|
|
Win4Assert(NULL != pIRDClientSite);
|
|
|
|
if (pIRDClientSite)
|
|
{
|
|
CXmitRpcStream Stm( (InterfaceData *) pIRDClientSite);
|
|
|
|
if (IsEqualIID(IID_IClientSiteHandler,riidClientInterface))
|
|
{
|
|
OBJREF objref;
|
|
CEmbServerClientSite *pCEmbServerClientSite;
|
|
|
|
// If there is a ClientSide Handler, set up server side.
|
|
if (SUCCEEDED(hr = ReadObjRef(&Stm, objref)))
|
|
{
|
|
|
|
Win4Assert(IsEqualIID(objref.iid, IID_IClientSiteHandler));
|
|
|
|
pCEmbServerClientSite = new CEmbServerClientSite(NULL);
|
|
|
|
if (pCEmbServerClientSite)
|
|
{
|
|
if (NOERROR == (hr = pCEmbServerClientSite->Initialize(objref,fHasIPSite)))
|
|
{
|
|
m_pCEmbServerClientSite = pCEmbServerClientSite; // set up member variable.
|
|
|
|
// TODO: should be a QI for the ClientSite.
|
|
*ppOleClientSite = (LPOLECLIENTSITE) pCEmbServerClientSite;
|
|
(*ppOleClientSite)->AddRef();
|
|
}
|
|
else
|
|
{
|
|
pCEmbServerClientSite->Release();
|
|
}
|
|
|
|
}
|
|
|
|
FreeObjRef(objref);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
m_pCEmbServerClientSite = NULL; // make sure EmbClientSite member var is NULL.
|
|
|
|
// Didn't wrap ClientSite with ClientSiteHandler, just UnMarshal and hand back.
|
|
hr = CoUnmarshalInterface(&Stm,IID_IOleClientSite, (void **) ppOleClientSite);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
*ppOleClientSite = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CServerHandler::SetClientSite
|
|
//
|
|
// Synopsis: Sets the client site for the object
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [pClientSite] -- pointer to the client site
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CServerHandler::SetClientSite(IOleClientSite* pOleClientSite)
|
|
{
|
|
HRESULT hresult = NOERROR;
|
|
IOleObject *pIOleObject = NULL;
|
|
|
|
if (NOERROR == (hresult = QueryServerInterface(IID_IOleObject,(void **) &pIOleObject)) )
|
|
{
|
|
if (NOERROR == hresult)
|
|
{
|
|
hresult = pIOleObject->SetClientSite(pOleClientSite);
|
|
}
|
|
}
|
|
|
|
if (pIOleObject)
|
|
ReleaseServerInterface(pIOleObject);
|
|
|
|
return hresult;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: Delagatory IDataObject impl facing container
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-17-95 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CServerHandler::GetData(FORMATETC *pformatetcIn,STGMEDIUM *pmedium)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->GetData(pformatetcIn,pmedium);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::GetDataHere(FORMATETC *pformatetc,STGMEDIUM *pmedium)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->GetDataHere(pformatetc,pmedium);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::QueryGetData(FORMATETC *pformatetc)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->QueryGetData(pformatetc);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::GetCanonicalFormatEtc(FORMATETC *pformatetcIn,FORMATETC *pformatetcOut)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->GetCanonicalFormatEtc(pformatetcIn,pformatetcOut);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::SetData(FORMATETC *pformatetc,STGMEDIUM *pmedium,BOOL fRelease)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->SetData(pformatetc,pmedium,fRelease);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::EnumFormatEtc(DWORD dwDirection,IEnumFORMATETC **ppenumFormatEtc)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->EnumFormatEtc(dwDirection,ppenumFormatEtc);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::DAdvise(FORMATETC *pformatetc,DWORD advf, IAdviseSink *pAdvSink,
|
|
DWORD *pdwConnection)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->DAdvise(pformatetc,
|
|
advf, (IAdviseSink *)
|
|
pAdvSink,pdwConnection);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::DUnadvise(DWORD dwConnection)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->DUnadvise(dwConnection);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CServerHandler::EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
|
|
{
|
|
LPDATAOBJECT pDataObject = NULL;
|
|
HRESULT hr;
|
|
|
|
if (NOERROR == (hr = QueryServerInterface(IID_IDataObject,(void **) &pDataObject)) )
|
|
{
|
|
hr = pDataObject->EnumDAdvise(ppenumAdvise);
|
|
ReleaseServerInterface(pDataObject);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//////////////////////
|
|
|
|
// rogerg, wrapper object for ServerHandler on the ClientSide.
|
|
|
|
//////////////////////
|
|
|
|
// CEmbServerWrapper implementation for Server Handler.
|
|
|
|
CEmbServerWrapper* CreateEmbServerWrapper(IUnknown *pUnkOuter,IServerHandler *ServerHandler)
|
|
{
|
|
return new CEmbServerWrapper(pUnkOuter,ServerHandler);
|
|
}
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CEmbServerWrapper::CEmbServerWrapper
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments:
|
|
// pStdId - Pointer to StandardIdentity for Object
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CEmbServerWrapper::CEmbServerWrapper (IUnknown *pUnkOuter,IServerHandler *pServerHandler)
|
|
{
|
|
VDATEHEAP();
|
|
|
|
Win4Assert(pServerHandler);
|
|
|
|
if (!pUnkOuter)
|
|
{
|
|
pUnkOuter = &m_Unknown;
|
|
}
|
|
|
|
m_pUnkOuter = pUnkOuter;
|
|
m_Unknown.m_EmbServerWrapper = this;
|
|
|
|
if(pServerHandler)
|
|
{
|
|
m_ServerHandler = pServerHandler;
|
|
m_ServerHandler->AddRef();
|
|
}
|
|
|
|
m_cRefs = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::~CServerHandler
|
|
//
|
|
// Synopsis: Destructor
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CEmbServerWrapper::~CEmbServerWrapper()
|
|
{
|
|
Win4Assert(NULL == m_ServerHandler);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CEmbServerWrapper::CPrivUnknown::QueryInterface
|
|
//
|
|
// Synopsis: Returns a pointer to one of the supported interfaces.
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [iid] -- the requested interface ID
|
|
// [ppv] -- where to put the iface pointer
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CEmbServerWrapper::CPrivUnknown::QueryInterface(REFIID iid,
|
|
LPLPVOID ppv)
|
|
{
|
|
HRESULT hresult;
|
|
|
|
VDATEHEAP();
|
|
|
|
Win4Assert(m_EmbServerWrapper);
|
|
|
|
LEDebugOut((DEB_TRACE,
|
|
"%p _IN CDefObject::CUnknownImpl::QueryInterface "
|
|
"( %p , %p )\n", m_EmbServerWrapper, iid, ppv));
|
|
|
|
if (IsEqualIID(iid, IID_IUnknown))
|
|
{
|
|
*ppv = (void FAR *)this;
|
|
}
|
|
else if (IsEqualIID(iid, IID_IDataObject))
|
|
{
|
|
*ppv = (void FAR *)(IDataObject *) m_EmbServerWrapper;
|
|
}
|
|
else if(m_EmbServerWrapper->m_ServerHandler)
|
|
{
|
|
|
|
Win4Assert(0 && "QI for non-Wrapped interface");
|
|
|
|
hresult = m_EmbServerWrapper->m_ServerHandler->QueryInterface(iid,(void **) ppv);
|
|
|
|
|
|
LEDebugOut((DEB_TRACE,
|
|
"%p OUT CDefObject::CUnknownImpl::QueryInterface "
|
|
"( %lx ) [ %p ]\n", m_EmbServerWrapper, hresult,
|
|
(ppv) ? *ppv : 0 ));
|
|
|
|
return hresult;
|
|
}
|
|
else
|
|
{
|
|
// Don't have a ServerHandler.
|
|
*ppv = NULL;
|
|
|
|
LEDebugOut((DEB_TRACE,
|
|
"%p OUT CDefObject::CUnkownImpl::QueryInterface "
|
|
"( %lx ) [ %p ]\n", m_EmbServerWrapper, CO_E_OBJNOTCONNECTED,
|
|
0 ));
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
// this indirection is important since there are different
|
|
// implementationsof AddRef (this unk and the others).
|
|
((IUnknown FAR*) *ppv)->AddRef();
|
|
|
|
LEDebugOut((DEB_TRACE,
|
|
"%p OUT CDefObject::CUnknownImpl::QueryInterface "
|
|
"( %lx ) [ %p ]\n", m_EmbServerWrapper, NOERROR, *ppv));
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CEmbServerWrapper::CPrivUnknown::AddRef
|
|
//
|
|
// Synopsis: Increments the reference count.
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: void
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: ULONG (the new reference count)
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation: IUnkown
|
|
//
|
|
// Algorithm:
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 03-Nov-93 alexgo 32bit port
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CEmbServerWrapper::CPrivUnknown::AddRef( void )
|
|
{
|
|
ULONG cRefs;
|
|
|
|
VDATEHEAP();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CDefObject::CPrivUnknown::AddRef "
|
|
"( )\n", m_EmbServerWrapper));
|
|
|
|
Win4Assert(m_EmbServerWrapper->m_cRefs != 0);
|
|
Win4Assert(m_EmbServerWrapper);
|
|
|
|
// we need to keep track of the hander's reference count separately
|
|
// from the handler/advise sink combination in order to handle
|
|
// our running/stopped state transitions.
|
|
|
|
cRefs = InterlockedIncrement((long *) &(m_EmbServerWrapper->m_cRefs));
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CDefObject::CPrivUnknown::AddRef "
|
|
"( %lu )\n", m_EmbServerWrapper, m_EmbServerWrapper->m_cRefs));
|
|
|
|
return cRefs;
|
|
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CEmbServerWrapper::CPrivUnknown::Release
|
|
//
|
|
// Synopsis: Decrements the ref count, cleaning up and deleting the
|
|
// object if necessary
|
|
//
|
|
// Effects: May delete the object (and potentially objects to which the
|
|
// handler has pointer)
|
|
//
|
|
// Arguments: void
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: ULONG--the new ref count
|
|
//
|
|
// Signals:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation:
|
|
//
|
|
// Algorithm:
|
|
//
|
|
// History: dd-mmm-yy Author Comment
|
|
// 03-Nov-93 alexgo 32bit port
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CEmbServerWrapper::CPrivUnknown::Release( void )
|
|
{
|
|
|
|
VDATEHEAP();
|
|
|
|
ULONG refcount;
|
|
|
|
Win4Assert(m_EmbServerWrapper);
|
|
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CDefObject::CPrivUnknown::Release "
|
|
"( )\n", m_EmbServerWrapper));
|
|
|
|
refcount = InterlockedDecrement((long *) &(m_EmbServerWrapper->m_cRefs));
|
|
|
|
if (0 == refcount)
|
|
{
|
|
if (m_EmbServerWrapper->m_ServerHandler)
|
|
{
|
|
IServerHandler *pServerHandler = m_EmbServerWrapper->m_ServerHandler;
|
|
|
|
m_EmbServerWrapper->m_ServerHandler = NULL;
|
|
pServerHandler->Release();
|
|
}
|
|
|
|
delete m_EmbServerWrapper;
|
|
|
|
}
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CDefObject::CPrivUnknown::Release "
|
|
"( %lu )\n", m_EmbServerWrapper, refcount));
|
|
|
|
return refcount;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CEmbServerWrapper::QueryInterface
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [riid] --
|
|
// [ppv] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 9-18-95 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CEmbServerWrapper::QueryInterface( REFIID riid, void **ppv )
|
|
{
|
|
HRESULT hresult;
|
|
|
|
VDATEHEAP();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CDefObject::QueryInterface ( %lx , "
|
|
"%p )\n", this, riid, ppv));
|
|
|
|
Assert(m_pUnkOuter);
|
|
|
|
hresult = m_pUnkOuter->QueryInterface(riid, ppv);
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CDefObject::QueryInterface ( %lx ) "
|
|
"[ %p ]\n", this, hresult, *ppv));
|
|
|
|
return hresult;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CEmbServerWrapper::AddRef
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [void] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 9-18-95 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CEmbServerWrapper::AddRef( void )
|
|
{
|
|
ULONG crefs;;
|
|
|
|
VDATEHEAP();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CDefObject::AddRef ( )\n", this));
|
|
|
|
Assert(m_pUnkOuter);
|
|
|
|
crefs = m_pUnkOuter->AddRef();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CDefObject::AddRef ( %ld ) ", this,
|
|
crefs));
|
|
|
|
return crefs;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CEmbServerClientSite::Release
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [void] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 9-18-95 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP_(ULONG) CEmbServerWrapper::Release( void )
|
|
{
|
|
ULONG crefs;;
|
|
|
|
VDATEHEAP();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p _IN CDefObject::Release ( )\n", this));
|
|
|
|
Assert(m_pUnkOuter);
|
|
|
|
crefs = m_pUnkOuter->Release();
|
|
|
|
LEDebugOut((DEB_TRACE, "%p OUT CDefObject::Release ( %ld ) ", this,
|
|
crefs));
|
|
|
|
return crefs;
|
|
}
|
|
|
|
// IServerHandler Implementation
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::Run
|
|
//
|
|
// Synopsis: Server Handler side of invoked when ::Run is Called.
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CEmbServerWrapper::Run(DWORD dwDHFlags,
|
|
REFIID riidClientInterface,
|
|
MInterfacePointer* pIRDClientInterface,
|
|
BOOL fHasIPSite,
|
|
LPOLESTR szContainerApp,
|
|
LPOLESTR szContainerObj,
|
|
IStorage * pStg,
|
|
IAdviseSink* pAdvSink,
|
|
DWORD *pdwConnection,
|
|
HRESULT *hresultClsidUser,
|
|
CLSID *pContClassID,
|
|
HRESULT *hresultContentMiscStatus,
|
|
DWORD *pdwMiscStatus)
|
|
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->Run(dwDHFlags,riidClientInterface,pIRDClientInterface, fHasIPSite, szContainerApp,
|
|
szContainerObj,pStg,pAdvSink,pdwConnection,
|
|
hresultClsidUser,pContClassID,hresultContentMiscStatus,
|
|
pdwMiscStatus);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CServerHandler::DoVerb
|
|
//
|
|
// Synopsis: Server Handler side of invoked when ::DoVerb is Called.
|
|
//
|
|
// Arguments:
|
|
//
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-30-96 rogerg Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CEmbServerWrapper::DoVerb (LONG iVerb, LPMSG lpmsg,BOOL fUseRunClientSite,
|
|
IOleClientSite* pIRDClientSite,LONG lindex,HWND hwndParent,
|
|
LPCRECT lprcPosRect)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->DoVerb(iVerb,lpmsg,fUseRunClientSite,pIRDClientSite,
|
|
lindex,hwndParent,lprcPosRect);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CServerHandler::SetClientSite
|
|
//
|
|
// Synopsis: Sets the client site for the object
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: [pClientSite] -- pointer to the client site
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CEmbServerWrapper::SetClientSite(IOleClientSite* pOleClientSite)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->SetClientSite(pOleClientSite);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
|
|
// IDataObject implementation.
|
|
|
|
STDMETHODIMP CEmbServerWrapper::GetData(FORMATETC *pformatetcIn,STGMEDIUM *pmedium)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->GetData(pformatetcIn,pmedium);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::GetDataHere(FORMATETC *pformatetc,STGMEDIUM *pmedium)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->GetDataHere(pformatetc,pmedium);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::QueryGetData(FORMATETC *pformatetc)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->QueryGetData(pformatetc);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::GetCanonicalFormatEtc(FORMATETC *pformatetcIn,FORMATETC *pformatetcOut)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
return m_ServerHandler->GetCanonicalFormatEtc(pformatetcIn,pformatetcOut);
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::SetData(FORMATETC *pformatetc,STGMEDIUM *pmedium,BOOL fRelease)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->SetData(pformatetc,pmedium,fRelease);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::EnumFormatEtc(DWORD dwDirection,IEnumFORMATETC **ppenumFormatEtc)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->EnumFormatEtc(dwDirection,ppenumFormatEtc);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::DAdvise(FORMATETC *pformatetc,DWORD advf,
|
|
IAdviseSink *pAdvSink,DWORD *pdwConnection)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->DAdvise(pformatetc,
|
|
advf, (IAdviseSink *)
|
|
pAdvSink,pdwConnection);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::DUnadvise(DWORD dwConnection)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->DUnadvise(dwConnection);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|
|
STDMETHODIMP CEmbServerWrapper::EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
|
|
{
|
|
HRESULT hresult = RPC_E_DISCONNECTED;
|
|
|
|
Win4Assert(m_ServerHandler);
|
|
|
|
if (m_ServerHandler)
|
|
{
|
|
hresult = m_ServerHandler->EnumDAdvise(ppenumAdvise);
|
|
}
|
|
|
|
return hresult;
|
|
}
|
|
|