able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/oleutest/letest/outline/linking.c

2158 lines
58 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*************************************************************************
**
** OLE 2 Sample Code
**
** linking.c
**
** This file contains the major interfaces, methods and related support
** functions for implementing linking to items. The code
** contained in this file is used by BOTH the Container and Server
** (Object) versions of the Outline sample code.
**
** As a server SVROUTL supports linking to the whole document object
** (either a file-based document or as an embedded object). It also
** supports linking to ranges (or PseudoObjects).
**
** As a container CNTROUTL supports linking to embedded objects.
** (see file svrpsobj.c for Pseudo Object implementation)
**
** OleDoc Object
** exposed interfaces:
** IPersistFile
** IOleItemContainer
** IExternalConnection
**
** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
**
*************************************************************************/
#include "outline.h"
OLEDBGDATA
extern LPOUTLINEAPP g_lpApp;
STDMETHODIMP OleDoc_ItemCont_GetObjectA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR*lplpvObject
);
STDMETHODIMP OleDoc_ItemCont_GetObjectStorageA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR*lplpvStorage
);
#if defined(OLE_CNTR)
STDMETHODIMP OleDoc_ItemCont_IsRunningA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem
);
HRESULT ContainerDoc_IsRunningA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem);
HRESULT ContainerDoc_GetObjectA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
REFIID riid,
LPVOID FAR*lplpvObject
);
HRESULT ContainerDoc_GetObjectStorageA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
LPSTORAGE FAR*lplpStg);
#endif // OLE_CNTR
#if defined(OLE_SERVER)
HRESULT ServerDoc_IsRunningA(LPSERVERDOC lpServerDoc, LPSTR lpszItem);
HRESULT ServerDoc_GetObjectA(
LPSERVERDOC lpServerDoc,
LPSTR lpszItem,
REFIID riid,
LPVOID FAR*lplpvObject);
#endif // OLE_SERVER
/*************************************************************************
** OleDoc::IPersistFile interface implementation
*************************************************************************/
// IPersistFile::QueryInterface
STDMETHODIMP OleDoc_PFile_QueryInterface(
LPPERSISTFILE lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
return OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj);
}
// IPersistFile::AddRef
STDMETHODIMP_(ULONG) OleDoc_PFile_AddRef(LPPERSISTFILE lpThis)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
OleDbgAddRefMethod(lpThis, "IPersistFile");
return OleDoc_AddRef(lpOleDoc);
}
// IPersistFile::Release
STDMETHODIMP_(ULONG) OleDoc_PFile_Release (LPPERSISTFILE lpThis)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
OleDbgReleaseMethod(lpThis, "IPersistFile");
return OleDoc_Release(lpOleDoc);
}
// IPersistFile::GetClassID
STDMETHODIMP OleDoc_PFile_GetClassID (
LPPERSISTFILE lpThis,
CLSID FAR* lpclsid
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
OleDbgOut2("OleDoc_PFile_GetClassID\r\n");
#if defined( OLE_SERVER ) && defined( SVR_TREATAS )
/* OLE2NOTE: we must be carefull to return the correct CLSID here.
** if we are currently preforming a "TreatAs (aka. ActivateAs)"
** operation then we need to return the class of the object
** written in the storage of the object. otherwise we would
** return our own class id.
*/
return ServerDoc_GetClassID((LPSERVERDOC)lpOleDoc, lpclsid);
#else
*lpclsid = CLSID_APP;
#endif
return NOERROR;
}
// IPersistFile::IsDirty
STDMETHODIMP OleDoc_PFile_IsDirty(LPPERSISTFILE lpThis)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
OleDbgOut2("OleDoc_PFile_IsDirty\r\n");
if (OutlineDoc_IsModified((LPOUTLINEDOC)lpOleDoc))
return NOERROR;
else
return ResultFromScode(S_FALSE);
}
// IPersistFile::Load
STDMETHODIMP OleDoc_PFile_LoadA(
LPPERSISTFILE lpThis,
LPCSTR lpszFileName,
DWORD grfMode
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
SCODE sc;
OLEDBG_BEGIN2("OleDoc_PFile_Load\r\n")
/* OLE2NOTE: grfMode passed from the caller indicates if the caller
** needs Read or ReadWrite permissions. if appropriate the
** callee should open the file with the requested permissions.
** the caller will normally not impose sharing permissions.
**
** the sample code currently always opens its file ReadWrite.
*/
if (OutlineDoc_LoadFromFile((LPOUTLINEDOC)lpOleDoc, (LPSTR)lpszFileName))
sc = S_OK;
else
sc = E_FAIL;
OLEDBG_END2
return ResultFromScode(sc);
}
// IPersistFile::Load
STDMETHODIMP OleDoc_PFile_Load (
LPPERSISTFILE lpThis,
LPCOLESTR lpszFileName,
DWORD grfMode
)
{
CREATESTR(lpsz, lpszFileName)
HRESULT hr = OleDoc_PFile_LoadA(lpThis, lpsz, grfMode);
FREESTR(lpsz)
return hr;
}
// IPersistFile::Save
STDMETHODIMP OleDoc_PFile_SaveA (
LPPERSISTFILE lpThis,
LPCSTR lpszFileName,
BOOL fRemember
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
SCODE sc;
OLEDBG_BEGIN2("OleDoc_PFile_Save\r\n")
/* OLE2NOTE: it is only legal to perform a Save or SaveAs operation
** on a file-based document. if the document is an embedded
** object then we can not be changed to a file-base object.
**
** fRemember lpszFileName Type of Save
** ----------------------------------------------
** TRUE NULL SAVE
** TRUE ! NULL SAVE AS
** FALSE ! NULL SAVE COPY AS
** FALSE NULL ***error***
*/
if ( (lpszFileName==NULL || (lpszFileName != NULL && fRemember))
&& ((lpOutlineDoc->m_docInitType != DOCTYPE_FROMFILE
&& lpOutlineDoc->m_docInitType != DOCTYPE_NEW)) ) {
OLEDBG_END2
return ResultFromScode(E_INVALIDARG);
}
if (OutlineDoc_SaveToFile(
(LPOUTLINEDOC)lpOleDoc,
lpszFileName,
lpOutlineDoc->m_cfSaveFormat,
fRemember)) {
sc = S_OK;
} else
sc = E_FAIL;
OLEDBG_END2
return ResultFromScode(sc);
}
// IPersistFile::Save
STDMETHODIMP OleDoc_PFile_Save(
LPPERSISTFILE lpThis,
LPCOLESTR lpszFileName,
BOOL fRemember
)
{
CREATESTR(lpsz, lpszFileName)
HRESULT hr = OleDoc_PFile_SaveA(lpThis, lpsz, fRemember);
FREESTR(lpsz)
return hr;
}
// IPersistFile::SaveCompleted
STDMETHODIMP OleDoc_PFile_SaveCompletedA (
LPPERSISTFILE lpThis,
LPCSTR lpszFileName
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
OleDbgOut2("OleDoc_PFile_SaveCompleted\r\n");
/* This method is called after IPersistFile::Save is called. during
** the period between Save and SaveCompleted the object must
** consider itself in NOSCRIBBLE mode (ie. it is NOT allowed to
** write to its file. here the object can clear its NOSCRIBBLE
** mode flag. the outline app never scribbles to its storage, so
** we have nothing to do.
*/
return NOERROR;
}
STDMETHODIMP OleDoc_PFile_SaveCompleted (
LPPERSISTFILE lpThis,
LPCOLESTR lpszFileName
)
{
CREATESTR(lpsz, lpszFileName)
HRESULT hr = OleDoc_PFile_SaveCompletedA(lpThis, lpsz);
FREESTR(lpsz)
return hr;
}
// IPersistFile::GetCurFile
STDMETHODIMP OleDoc_PFile_GetCurFileA (
LPPERSISTFILE lpThis,
LPSTR FAR* lplpszFileName
)
{
LPOLEDOC lpOleDoc = ((struct CDocPersistFileImpl FAR*)lpThis)->lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
LPMALLOC lpMalloc;
LPSTR lpsz;
SCODE sc;
OleDbgOut2("OleDoc_PFile_GetCurFile\r\n");
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpszFileName = NULL;
/*********************************************************************
** OLE2NOTE: memory returned for the lplpszFileName must be
** allocated appropriately using the current registered IMalloc
** interface. the allows the ownership of the memory to be
** passed to the caller (even if in another process).
*********************************************************************/
CoGetMalloc(MEMCTX_TASK, &lpMalloc);
if (! lpMalloc) {
return ResultFromScode(E_FAIL);
}
if (lpOutlineDoc->m_docInitType == DOCTYPE_FROMFILE) {
/* valid filename associated; return file name */
lpsz = (LPSTR)lpMalloc->lpVtbl->Alloc(
lpMalloc,
lstrlen((LPSTR)lpOutlineDoc->m_szFileName)+1
);
if (! lpsz) {
sc = E_OUTOFMEMORY;
goto error;
}
lstrcpy(lpsz, (LPSTR)lpOutlineDoc->m_szFileName);
sc = S_OK;
} else {
/* no file associated; return default file name prompt */
lpsz=(LPSTR)lpMalloc->lpVtbl->Alloc(lpMalloc, sizeof(DEFEXTENSION)+3);
wsprintf(lpsz, "*.%s", DEFEXTENSION);
sc = S_FALSE;
}
error:
OleStdRelease((LPUNKNOWN)lpMalloc);
*lplpszFileName = lpsz;
return ResultFromScode(sc);
}
STDMETHODIMP OleDoc_PFile_GetCurFile (
LPPERSISTFILE lpThis,
LPOLESTR FAR* lplpszFileName
)
{
LPSTR lpsz;
HRESULT hr = OleDoc_PFile_GetCurFileA(lpThis, &lpsz);
CopyAndFreeSTR(lpsz, lplpszFileName);
return hr;
}
/*************************************************************************
** OleDoc::IOleItemContainer interface implementation
*************************************************************************/
// IOleItemContainer::QueryInterface
STDMETHODIMP OleDoc_ItemCont_QueryInterface(
LPOLEITEMCONTAINER lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
return OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj);
}
// IOleItemContainer::AddRef
STDMETHODIMP_(ULONG) OleDoc_ItemCont_AddRef(LPOLEITEMCONTAINER lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OleDbgAddRefMethod(lpThis, "IOleItemContainer");
return OleDoc_AddRef((LPOLEDOC)lpOleDoc);
}
// IOleItemContainer::Release
STDMETHODIMP_(ULONG) OleDoc_ItemCont_Release(LPOLEITEMCONTAINER lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OleDbgReleaseMethod(lpThis, "IOleItemContainer");
return OleDoc_Release((LPOLEDOC)lpOleDoc);
}
// IOleItemContainer::ParseDisplayName
STDMETHODIMP OleDoc_ItemCont_ParseDisplayNameA(
LPOLEITEMCONTAINER lpThis,
LPBC lpbc,
LPSTR lpszDisplayName,
ULONG FAR* lpchEaten,
LPMONIKER FAR* lplpmkOut
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
char szItemName[MAXNAMESIZE];
LPUNKNOWN lpUnk;
HRESULT hrErr;
OleDbgOut2("OleDoc_ItemCont_ParseDisplayName\r\n");
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpmkOut = NULL;
*lpchEaten = OleStdGetItemToken(
lpszDisplayName,
szItemName,
sizeof(szItemName)
);
/* OLE2NOTE: get a pointer to a running instance of the object. we
** should force the object to go running if necessary (even if
** this means launching its server EXE). this is the meaining of
** BINDSPEED_INDEFINITE. Parsing a Moniker is known to be an
** "EXPENSIVE" operation.
*/
hrErr = OleDoc_ItemCont_GetObjectA(
lpThis,
szItemName,
BINDSPEED_INDEFINITE,
lpbc,
&IID_IUnknown,
(LPVOID FAR*)&lpUnk
);
if (hrErr == NOERROR) {
OleStdRelease(lpUnk); // item name FOUND; don't need obj ptr.
CreateItemMonikerA(OLESTDDELIM, szItemName, lplpmkOut);
} else
*lpchEaten = 0; // item name is NOT valid
return hrErr;
}
STDMETHODIMP OleDoc_ItemCont_ParseDisplayName(
LPOLEITEMCONTAINER lpThis,
LPBC lpbc,
LPOLESTR lpszDisplayName,
ULONG FAR* lpchEaten,
LPMONIKER FAR* lplpmkOut
)
{
CREATESTR(lpsz, lpszDisplayName)
HRESULT hr = OleDoc_ItemCont_ParseDisplayNameA(lpThis, lpbc,
lpsz, lpchEaten, lplpmkOut);
FREESTR(lpsz);
return hr;
}
// IOleItemContainer::EnumObjects
STDMETHODIMP OleDoc_ItemCont_EnumObjects(
LPOLEITEMCONTAINER lpThis,
DWORD grfFlags,
LPENUMUNKNOWN FAR* lplpenumUnknown
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OLEDBG_BEGIN2("OleDoc_ItemCont_EnumObjects\r\n")
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpenumUnknown = NULL;
/* OLE2NOTE: this method should be implemented to allow programatic
** clients the ability to what elements the container holds.
** this method is NOT called in the standard linking scenarios.
**
** grfFlags can be one of the following:
** OLECONTF_EMBEDDINGS -- enumerate embedded objects
** OLECONTF_LINKS -- enumerate linked objects
** OLECONTF_OTHERS -- enumerate non-OLE compound doc objs
** OLECONTF_ONLYUSER -- enumerate only objs named by user
** OLECONTF_ONLYIFRUNNING-- enumerate only objs in running state
*/
OleDbgAssertSz(0, "NOT YET IMPLEMENTED!");
OLEDBG_END2
return ResultFromScode(E_NOTIMPL);
}
// IOleItemContainer::LockContainer
STDMETHODIMP OleDoc_ItemCont_LockContainer(
LPOLEITEMCONTAINER lpThis,
BOOL fLock
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
HRESULT hrErr;
OLEDBG_BEGIN2("OleDoc_ItemCont_LockContainer\r\n")
#if defined( _DEBUG )
if (fLock) {
++lpOleDoc->m_cCntrLock;
OleDbgOutRefCnt3(
"OleDoc_ItemCont_LockContainer: cLock++\r\n",
lpOleDoc,
lpOleDoc->m_cCntrLock
);
} else {
/* OLE2NOTE: when there are no open documents and the app is not
** under the control of the user and there are no outstanding
** locks on the app, then revoke our ClassFactory to enable the
** app to shut down.
*/
--lpOleDoc->m_cCntrLock;
OleDbgAssertSz (
lpOleDoc->m_cCntrLock >= 0,
"OleDoc_ItemCont_LockContainer(FALSE) called with cLock == 0"
);
if (lpOleDoc->m_cCntrLock == 0) {
OleDbgOutRefCnt2(
"OleDoc_ItemCont_LockContainer: UNLOCKED\r\n",
lpOleDoc, lpOleDoc->m_cCntrLock);
} else {
OleDbgOutRefCnt3(
"OleDoc_ItemCont_LockContainer: cLock--\r\n",
lpOleDoc, lpOleDoc->m_cCntrLock);
}
}
#endif // _DEBUG
/* OLE2NOTE: in order to hold the document alive we call
** CoLockObjectExternal to add a strong reference to our Doc
** object. this will keep the Doc alive when all other external
** references release us. whenever an embedded object goes
** running a LockContainer(TRUE) is called. when the embedded
** object shuts down (ie. transitions from running to loaded)
** LockContainer(FALSE) is called. if the user issues File.Close
** the document will shut down in any case ignoring any
** outstanding LockContainer locks because CoDisconnectObject is
** called in OleDoc_Close. this will forceably break any
** existing strong reference counts including counts that we add
** ourselves by calling CoLockObjectExternal and guarantee that
** the Doc object gets its final release (ie. cRefs goes to 0).
*/
hrErr = OleDoc_Lock(lpOleDoc, fLock, TRUE /* fLastUnlockReleases */);
OLEDBG_END2
return hrErr;
}
// IOleItemContainer::GetObject
STDMETHODIMP OleDoc_ItemCont_GetObjectA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
HRESULT hrErr;
OLEDBG_BEGIN2("OleDoc_ItemCont_GetObject\r\n")
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpvObject = NULL;
#if defined( OLE_SERVER )
/* OLE2NOTE: SERVER ONLY version should return PseudoObjects with
** BINDSPEED_IMMEDIATE, thus the dwSpeedNeeded is not important
** in the case of a pure server.
*/
hrErr = ServerDoc_GetObjectA(
(LPSERVERDOC)lpOleDoc, lpszItem,riid,lplpvObject);
#endif
#if defined( OLE_CNTR )
/* OLE2NOTE: dwSpeedNeeded indicates how long the caller is willing
** to wait for us to get the object:
** BINDSPEED_IMMEDIATE -- only if obj already loaded && IsRunning
** BINDSPEED_MODERATE -- load obj if necessary && if IsRunning
** BINDSPEED_INDEFINITE-- force obj to load and run if necessary
*/
hrErr = ContainerDoc_GetObjectA(
(LPCONTAINERDOC)lpOleDoc,lpszItem,dwSpeedNeeded,riid,lplpvObject);
#endif
OLEDBG_END2
return hrErr;
}
STDMETHODIMP OleDoc_ItemCont_GetObject(
LPOLEITEMCONTAINER lpThis,
LPOLESTR lpszItem,
DWORD dwSpeedNeeded,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = OleDoc_ItemCont_GetObjectA(lpThis, lpsz, dwSpeedNeeded, lpbc,
riid, lplpvObject);
FREESTR(lpsz)
return hr;
}
// IOleItemContainer::GetObjectStorage
STDMETHODIMP OleDoc_ItemCont_GetObjectStorageA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvStorage
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
OleDbgOut2("OleDoc_ItemCont_GetObjectStorage\r\n");
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpvStorage = NULL;
#if defined( OLE_SERVER )
/* OLE2NOTE: in the SERVER ONLY version, item names identify pseudo
** objects. pseudo objects, do NOT have identifiable storage.
*/
return ResultFromScode(E_FAIL);
#endif
#if defined( OLE_CNTR )
// We can only return an IStorage* type pointer
if (! IsEqualIID(riid, &IID_IStorage))
return ResultFromScode(E_FAIL);
return ContainerDoc_GetObjectStorageA(
(LPCONTAINERDOC)lpOleDoc,
lpszItem,
(LPSTORAGE FAR*)lplpvStorage
);
#endif
}
STDMETHODIMP OleDoc_ItemCont_GetObjectStorage(
LPOLEITEMCONTAINER lpThis,
LPOLESTR lpszItem,
LPBINDCTX lpbc,
REFIID riid,
LPVOID FAR* lplpvStorage
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = OleDoc_ItemCont_GetObjectStorageA(lpThis, lpsz, lpbc,
riid, lplpvStorage);
FREESTR(lpsz)
return hr;
}
// IOleItemContainer::IsRunning
STDMETHODIMP OleDoc_ItemCont_IsRunningA(
LPOLEITEMCONTAINER lpThis,
LPSTR lpszItem
)
{
LPOLEDOC lpOleDoc =
((struct CDocOleItemContainerImpl FAR*)lpThis)->lpOleDoc;
HRESULT hrErr;
OLEDBG_BEGIN2("OleDoc_ItemCont_IsRunning\r\n")
/* OLE2NOTE: Check if item name is valid. if so then return if
** Object is running. PseudoObjects in the Server version are
** always considered running. Ole objects in the container must
** be checked if they are running.
*/
#if defined( OLE_SERVER )
hrErr = ServerDoc_IsRunningA((LPSERVERDOC)lpOleDoc, lpszItem);
#endif
#if defined( OLE_CNTR )
hrErr = ContainerDoc_IsRunningA((LPCONTAINERDOC)lpOleDoc, lpszItem);
#endif
OLEDBG_END2
return hrErr;
}
STDMETHODIMP OleDoc_ItemCont_IsRunning(
LPOLEITEMCONTAINER lpThis,
LPOLESTR lpszItem
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = OleDoc_ItemCont_IsRunningA(lpThis,lpsz);
FREESTR(lpsz)
return hr;
}
/*************************************************************************
** OleDoc::IExternalConnection interface implementation
*************************************************************************/
// IExternalConnection::QueryInterface
STDMETHODIMP OleDoc_ExtConn_QueryInterface(
LPEXTERNALCONNECTION lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
return OleDoc_QueryInterface(lpOleDoc, riid, lplpvObj);
}
// IExternalConnection::AddRef
STDMETHODIMP_(ULONG) OleDoc_ExtConn_AddRef(LPEXTERNALCONNECTION lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
OleDbgAddRefMethod(lpThis, "IExternalConnection");
return OleDoc_AddRef(lpOleDoc);
}
// IExternalConnection::Release
STDMETHODIMP_(ULONG) OleDoc_ExtConn_Release (LPEXTERNALCONNECTION lpThis)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
OleDbgReleaseMethod(lpThis, "IExternalConnection");
return OleDoc_Release(lpOleDoc);
}
// IExternalConnection::AddConnection
STDMETHODIMP_(DWORD) OleDoc_ExtConn_AddConnection(
LPEXTERNALCONNECTION lpThis,
DWORD extconn,
DWORD reserved
)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
if( extconn & EXTCONN_STRONG ) {
#if defined( _DEBUG )
OleDbgOutRefCnt3(
"OleDoc_ExtConn_AddConnection: dwStrongExtConn++\r\n",
lpOleDoc,
lpOleDoc->m_dwStrongExtConn + 1
);
#endif
return ++(lpOleDoc->m_dwStrongExtConn);
} else
return 0;
}
// IExternalConnection::ReleaseConnection
STDMETHODIMP_(DWORD) OleDoc_ExtConn_ReleaseConnection(
LPEXTERNALCONNECTION lpThis,
DWORD extconn,
DWORD reserved,
BOOL fLastReleaseCloses
)
{
LPOLEDOC lpOleDoc =
((struct CDocExternalConnectionImpl FAR*)lpThis)->lpOleDoc;
if( extconn & EXTCONN_STRONG ){
DWORD dwSave = --(lpOleDoc->m_dwStrongExtConn);
#if defined( _DEBUG )
OLEDBG_BEGIN2( (fLastReleaseCloses ?
"OleDoc_ExtConn_ReleaseConnection(TRUE)\r\n" :
"OleDoc_ExtConn_ReleaseConnection(FALSE)\r\n") )
OleDbgOutRefCnt3(
"OleDoc_ExtConn_ReleaseConnection: dwStrongExtConn--\r\n",
lpOleDoc,
lpOleDoc->m_dwStrongExtConn
);
OleDbgAssertSz (
lpOleDoc->m_dwStrongExtConn >= 0,
"OleDoc_ExtConn_ReleaseConnection called with dwStrong == 0"
);
#endif // _DEBUG
if( lpOleDoc->m_dwStrongExtConn == 0 && fLastReleaseCloses )
OleDoc_Close(lpOleDoc, OLECLOSE_SAVEIFDIRTY);
OLEDBG_END2
return dwSave;
} else
return 0;
}
/*************************************************************************
** OleDoc Common Support Functions
*************************************************************************/
/* OleDoc_GetFullMoniker
** ---------------------
** Return the full, absolute moniker of the document.
**
** NOTE: the caller must release the pointer returned when done.
*/
LPMONIKER OleDoc_GetFullMoniker(LPOLEDOC lpOleDoc, DWORD dwAssign)
{
LPMONIKER lpMoniker = NULL;
OLEDBG_BEGIN3("OleDoc_GetFullMoniker\r\n")
if (lpOleDoc->m_lpSrcDocOfCopy) {
/* CASE I: this document was created for a copy or drag/drop
** operation. generate the moniker which identifies the
** source document of the original copy.
*/
if (! lpOleDoc->m_fLinkSourceAvail)
goto done; // we already know a moniker is not available
lpMoniker=OleDoc_GetFullMoniker(lpOleDoc->m_lpSrcDocOfCopy, dwAssign);
}
else if (lpOleDoc->m_lpFileMoniker) {
/* CASE II: this document is a top-level user document (either
** file-based or untitled). return the FileMoniker stored
** with the document; it uniquely identifies the document.
*/
// we must AddRef the moniker to pass out a ptr
lpOleDoc->m_lpFileMoniker->lpVtbl->AddRef(lpOleDoc->m_lpFileMoniker);
lpMoniker = lpOleDoc->m_lpFileMoniker;
}
#if defined( OLE_SERVER )
else if (((LPSERVERDOC)lpOleDoc)->m_lpOleClientSite) {
/* CASE III: this document is an embedded object, ask our
** container for our moniker.
*/
OLEDBG_BEGIN2("IOleClientSite::GetMoniker called\r\n");
((LPSERVERDOC)lpOleDoc)->m_lpOleClientSite->lpVtbl->GetMoniker(
((LPSERVERDOC)lpOleDoc)->m_lpOleClientSite,
dwAssign,
OLEWHICHMK_OBJFULL,
&lpMoniker
);
OLEDBG_END2
}
#endif
else {
lpMoniker = NULL;
}
done:
OLEDBG_END3
return lpMoniker;
}
/* OleDoc_DocRenamedUpdate
** -----------------------
** Update the documents registration in the running object table (ROT).
** Also inform all embedded OLE objects (container only) and/or psedudo
** objects (server only) that the name of the document has changed.
*/
void OleDoc_DocRenamedUpdate(LPOLEDOC lpOleDoc, LPMONIKER lpmkDoc)
{
OLEDBG_BEGIN3("OleDoc_DocRenamedUpdate\r\n")
OleDoc_AddRef(lpOleDoc);
/* OLE2NOTE: we must re-register ourselves as running when we
** get a new moniker assigned (ie. when we are renamed).
*/
OLEDBG_BEGIN3("OleStdRegisterAsRunning called\r\n")
OleStdRegisterAsRunning(
(LPUNKNOWN)&lpOleDoc->m_Unknown,
lpmkDoc,
&lpOleDoc->m_dwRegROT
);
OLEDBG_END3
#if defined( OLE_SERVER )
{
LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpOleDoc;
/* OLE2NOTE: inform any linking clients that the document has been
** renamed.
*/
ServerDoc_SendAdvise (
lpServerDoc,
OLE_ONRENAME,
lpmkDoc,
0 /* advf -- not relevant here */
);
/* OLE2NOTE: inform any clients of pseudo objects
** within our document, that our document's
** Moniker has changed.
*/
ServerNameTable_InformAllPseudoObjectsDocRenamed(
(LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable, lpmkDoc);
}
#endif
#if defined( OLE_CNTR )
{
LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOleDoc;
/* OLE2NOTE: must tell all OLE objects that our container
** moniker changed.
*/
ContainerDoc_InformAllOleObjectsDocRenamed(
lpContainerDoc,
lpmkDoc
);
}
#endif
OleDoc_Release(lpOleDoc); // release artificial AddRef above
OLEDBG_END3
}
#if defined( OLE_SERVER )
/*************************************************************************
** ServerDoc Supprt Functions Used by Server versions
*************************************************************************/
/* ServerDoc_PseudoObjLockDoc
** --------------------------
** Add a lock on the Doc on behalf of the PseudoObject. the Doc may not
** close while the Doc exists.
**
** when a pseudo object is first created, it calls this method to
** guarantee that the document stays alive (PseudoObj_Init).
** when a pseudo object is destroyed, it call
** ServerDoc_PseudoObjUnlockDoc to release this hold on the document.
*/
void ServerDoc_PseudoObjLockDoc(LPSERVERDOC lpServerDoc)
{
LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
ULONG cPseudoObj;
cPseudoObj = ++lpServerDoc->m_cPseudoObj;
#if defined( _DEBUG )
OleDbgOutRefCnt3(
"ServerDoc_PseudoObjLockDoc: cPseudoObj++\r\n",
lpServerDoc,
cPseudoObj
);
#endif
OleDoc_Lock(lpOleDoc, TRUE /* fLock */, 0 /* not applicable */);
return;
}
/* ServerDoc_PseudoObjUnlockDoc
** ----------------------------
** Release the lock on the Doc on behalf of the PseudoObject. if this was
** the last lock on the Doc, then it will shutdown.
*/
void ServerDoc_PseudoObjUnlockDoc(
LPSERVERDOC lpServerDoc,
LPPSEUDOOBJ lpPseudoObj
)
{
ULONG cPseudoObj;
LPOLEDOC lpOleDoc = (LPOLEDOC)lpServerDoc;
OLEDBG_BEGIN3("ServerDoc_PseudoObjUnlockDoc\r\n")
/* OLE2NOTE: when there are no active pseudo objects in the Doc and
** the Doc is not visible, and if there are no outstanding locks
** on the Doc, then this is a "silent update"
** situation. our Doc is being used programatically by some
** client; it is NOT accessible to the user because it is
** NOT visible. thus since all Locks have been released, we
** will close the document. if the app is only running due
** to the presence of this document, then the app will now
** also shut down.
*/
cPseudoObj = --lpServerDoc->m_cPseudoObj;
#if defined( _DEBUG )
OleDbgAssertSz (
lpServerDoc->m_cPseudoObj >= 0,
"PseudoObjUnlockDoc called with cPseudoObj == 0"
);
OleDbgOutRefCnt3(
"ServerDoc_PseudoObjUnlockDoc: cPseudoObj--\r\n",
lpServerDoc,
cPseudoObj
);
#endif
OleDoc_Lock(lpOleDoc, FALSE /* fLock */, TRUE /* fLastUnlockReleases */);
OLEDBG_END3
return;
}
/* ServerDoc_GetObject
** -------------------
**
** Return a pointer to an object identified by an item string
** (lpszItem). For a server-only app, the object returned will be a
** pseudo object.
*/
HRESULT ServerDoc_GetObjectA(
LPSERVERDOC lpServerDoc,
LPSTR lpszItem,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
LPPSEUDOOBJ lpPseudoObj;
LPSERVERNAMETABLE lpServerNameTable =
(LPSERVERNAMETABLE)((LPOUTLINEDOC)lpServerDoc)->m_lpNameTable;
*lplpvObject = NULL;
/* Get the PseudoObj which corresponds to an item name. if the item
** name does NOT exist in the name table then NO object is
** returned. the ServerNameTable_GetPseudoObj routine finds a
** name entry corresponding to the item name, it then checks if
** a PseudoObj has already been allocated. if so, it returns the
** existing object, otherwise it allocates a new PseudoObj.
*/
lpPseudoObj = ServerNameTable_GetPseudoObj(
lpServerNameTable,
lpszItem,
lpServerDoc
);
if (! lpPseudoObj) {
*lplpvObject = NULL;
return ResultFromScode(MK_E_NOOBJECT);
}
// return the desired interface pointer of the pseudo object.
return PseudoObj_QueryInterface(lpPseudoObj, riid, lplpvObject);
}
HRESULT ServerDoc_GetObject(
LPSERVERDOC lpServerDoc,
LPOLESTR lpszItem,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
CREATESTR(pstr, lpszItem)
HRESULT hr = ServerDoc_GetObjectA(lpServerDoc, pstr, riid, lplpvObject);
FREESTR(pstr)
return hr;
}
/* ServerDoc_IsRunning
** -------------------
**
** Check if the object identified by an item string (lpszItem) is in
** the running state. For a server-only app, if the item name exists in
** in the NameTable then the item name is considered running.
** IOleItemContainer::GetObject would succeed.
*/
HRESULT ServerDoc_IsRunningA(LPSERVERDOC lpServerDoc, LPSTR lpszItem)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
((LPOUTLINEDOC)lpServerDoc)->m_lpNameTable;
LPSERVERNAME lpServerName;
lpServerName = (LPSERVERNAME)OutlineNameTable_FindName(
lpOutlineNameTable,
lpszItem
);
if (lpServerName)
return NOERROR;
else
return ResultFromScode(MK_E_NOOBJECT);
}
/* ServerDoc_GetSelRelMoniker
** --------------------------
** Retrieve the relative item moniker which identifies the given
** selection (lplrSel).
**
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ServerDoc_GetSelRelMoniker(
LPSERVERDOC lpServerDoc,
LPLINERANGE lplrSel,
DWORD dwAssign
)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)lpServerDoc;
LPSERVERNAMETABLE lpServerNameTable =
(LPSERVERNAMETABLE)lpOutlineDoc->m_lpNameTable;
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LPMONIKER lpmk;
lpOutlineName=OutlineNameTable_FindNamedRange(lpOutlineNameTable,lplrSel);
if (lpOutlineName) {
/* the selection range already has a name assigned */
CreateItemMonikerA(OLESTDDELIM, lpOutlineName->m_szName, &lpmk);
} else {
char szbuf[MAXNAMESIZE];
switch (dwAssign) {
case GETMONIKER_FORCEASSIGN:
/* Force the assignment of the name. This is called when a
** Paste Link actually occurs. At this point we want to
** create a Name and add it to the NameTable in order to
** track the source of the link. This name (as all
** names) will be updated upon editing of the document.
*/
wsprintf(
szbuf,
"%s %ld",
(LPSTR)DEFRANGENAMEPREFIX,
++(lpServerDoc->m_nNextRangeNo)
);
lpOutlineName = OutlineApp_CreateName(lpOutlineApp);
if (lpOutlineName) {
lstrcpy(lpOutlineName->m_szName, szbuf);
lpOutlineName->m_nStartLine = lplrSel->m_nStartLine;
lpOutlineName->m_nEndLine = lplrSel->m_nEndLine;
OutlineDoc_AddName(lpOutlineDoc, lpOutlineName);
} else {
// REVIEW: do we need "Out-of-Memory" error message here?
}
break;
case GETMONIKER_TEMPFORUSER:
/* Create a name to show to the user in the Paste
** Special dialog but do NOT yet incur the overhead
** of adding a Name to the NameTable. The Moniker
** generated should be useful to display to the user
** to indicate the source of the copy, but will NOT
** be used to create a link directly (the caller
** should ask again for a moniker specifying FORCEASSIGN).
** we will generate the name that would be the next
** auto-generated range name, BUT will NOT actually
** increment the range counter.
*/
wsprintf(
szbuf,
"%s %ld",
(LPSTR)DEFRANGENAMEPREFIX,
(lpServerDoc->m_nNextRangeNo)+1
);
break;
case GETMONIKER_ONLYIFTHERE:
/* the caller only wants a name if one has already been
** assigned. we have already above checked if the
** current selection has a name, so we will simply
** return NULL here.
*/
return NULL; // no moniker is assigned
default:
return NULL; // unknown flag given
}
CreateItemMonikerA(OLESTDDELIM, szbuf, &lpmk);
}
return lpmk;
}
/* ServerDoc_GetSelFullMoniker
** ---------------------------
** Retrieve the full absolute moniker which identifies the given
** selection (lplrSel).
** this moniker is created as a composite of the absolute moniker for
** the entire document appended with an item moniker which identifies
** the selection relative to the document.
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ServerDoc_GetSelFullMoniker(
LPSERVERDOC lpServerDoc,
LPLINERANGE lplrSel,
DWORD dwAssign
)
{
LPMONIKER lpmkDoc = NULL;
LPMONIKER lpmkItem = NULL;
LPMONIKER lpmkFull = NULL;
lpmkDoc = OleDoc_GetFullMoniker(
(LPOLEDOC)lpServerDoc,
dwAssign
);
if (! lpmkDoc) return NULL;
lpmkItem = ServerDoc_GetSelRelMoniker(
lpServerDoc,
lplrSel,
dwAssign
);
if (lpmkItem) {
CreateGenericComposite(lpmkDoc, lpmkItem, (LPMONIKER FAR*)&lpmkFull);
OleStdRelease((LPUNKNOWN)lpmkItem);
}
if (lpmkDoc)
OleStdRelease((LPUNKNOWN)lpmkDoc);
return lpmkFull;
}
/* ServerNameTable_EditLineUpdate
* -------------------------------
*
* Update the table when a line at nEditIndex is edited.
*/
void ServerNameTable_EditLineUpdate(
LPSERVERNAMETABLE lpServerNameTable,
int nEditIndex
)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LINERANGE lrSel;
LPPSEUDOOBJ lpPseudoObj;
int i;
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpOutlineName=OutlineNameTable_GetName(lpOutlineNameTable, i);
lpPseudoObj = ((LPSERVERNAME)lpOutlineName)->m_lpPseudoObj;
/* if there is a pseudo object associated with this name, then
** check if the line that was modified is included within
** the named range.
*/
if (lpPseudoObj) {
OutlineName_GetSel(lpOutlineName, &lrSel);
if(((int)lrSel.m_nStartLine <= nEditIndex) &&
((int)lrSel.m_nEndLine >= nEditIndex)) {
// inform linking clients data has changed
PseudoObj_SendAdvise(
lpPseudoObj,
OLE_ONDATACHANGE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- no flags necessary */
);
}
}
}
}
/* ServerNameTable_InformAllPseudoObjectsDocRenamed
* ------------------------------------------------
*
* Inform all pseudo object clients that the name of the pseudo
* object has changed.
*/
void ServerNameTable_InformAllPseudoObjectsDocRenamed(
LPSERVERNAMETABLE lpServerNameTable,
LPMONIKER lpmkDoc
)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LPPSEUDOOBJ lpPseudoObj;
LPMONIKER lpmkObj;
int i;
OLEDBG_BEGIN2("ServerNameTable_InformAllPseudoObjectsDocRenamed\r\n");
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpOutlineName=OutlineNameTable_GetName(lpOutlineNameTable, i);
lpPseudoObj = ((LPSERVERNAME)lpOutlineName)->m_lpPseudoObj;
/* if there is a pseudo object associated with this name, then
** send OnRename advise to its linking clients.
*/
if (lpPseudoObj &&
((lpmkObj=PseudoObj_GetFullMoniker(lpPseudoObj,lpmkDoc))!=NULL)) {
// inform the clients that the name has changed
PseudoObj_SendAdvise (
lpPseudoObj,
OLE_ONRENAME,
lpmkObj,
0 /* advf -- not relevant here */
);
}
}
OLEDBG_END2
}
/* ServerNameTable_InformAllPseudoObjectsDocSaved
* ------------------------------------------------
*
* Inform all pseudo object clients that the name of the pseudo
* object has changed.
*/
void ServerNameTable_InformAllPseudoObjectsDocSaved(
LPSERVERNAMETABLE lpServerNameTable,
LPMONIKER lpmkDoc
)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPOUTLINENAME lpOutlineName;
LPPSEUDOOBJ lpPseudoObj;
LPMONIKER lpmkObj;
int i;
OLEDBG_BEGIN2("ServerNameTable_InformAllPseudoObjectsDocSaved\r\n");
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpOutlineName=OutlineNameTable_GetName(lpOutlineNameTable, i);
lpPseudoObj = ((LPSERVERNAME)lpOutlineName)->m_lpPseudoObj;
/* if there is a pseudo object associated with this name, then
** send OnSave advise to its linking clients.
*/
if (lpPseudoObj &&
((lpmkObj=PseudoObj_GetFullMoniker(lpPseudoObj,lpmkDoc))!=NULL)) {
// inform the clients that the name has been saved
PseudoObj_SendAdvise (
lpPseudoObj,
OLE_ONSAVE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- not relevant here */
);
}
}
OLEDBG_END2
}
/* ServerNameTable_SendPendingAdvises
* ----------------------------------
*
* Send any pending change notifications for pseudo objects.
* while ReDraw is diabled on the ServerDoc, then change advise
* notifications are not sent to pseudo object clients.
*/
void ServerNameTable_SendPendingAdvises(LPSERVERNAMETABLE lpServerNameTable)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPSERVERNAME lpServerName;
int i;
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpServerName = (LPSERVERNAME)OutlineNameTable_GetName(
lpOutlineNameTable,
i
);
ServerName_SendPendingAdvises(lpServerName);
}
}
/* ServerNameTable_GetPseudoObj
** ----------------------------
**
** Return a pointer to a pseudo object identified by an item string
** (lpszItem). if the pseudo object already exists, then return the
** existing object, otherwise allocate a new pseudo object.
*/
LPPSEUDOOBJ ServerNameTable_GetPseudoObj(
LPSERVERNAMETABLE lpServerNameTable,
LPSTR lpszItem,
LPSERVERDOC lpServerDoc
)
{
LPSERVERNAME lpServerName;
lpServerName = (LPSERVERNAME)OutlineNameTable_FindName(
(LPOUTLINENAMETABLE)lpServerNameTable,
lpszItem
);
if (lpServerName)
return ServerName_GetPseudoObj(lpServerName, lpServerDoc);
else
return NULL;
}
/* ServerNameTable_CloseAllPseudoObjs
* ----------------------------------
*
* Force all pseudo objects to close. this results in sending OnClose
* notification to each pseudo object's linking clients.
*/
void ServerNameTable_CloseAllPseudoObjs(LPSERVERNAMETABLE lpServerNameTable)
{
LPOUTLINENAMETABLE lpOutlineNameTable =
(LPOUTLINENAMETABLE)lpServerNameTable;
LPSERVERNAME lpServerName;
int i;
OLEDBG_BEGIN3("ServerNameTable_CloseAllPseudoObjs\r\n")
for(i = 0; i < lpOutlineNameTable->m_nCount; i++) {
lpServerName = (LPSERVERNAME)OutlineNameTable_GetName(
lpOutlineNameTable,
i
);
ServerName_ClosePseudoObj(lpServerName);
}
OLEDBG_END3
}
/* ServerName_SetSel
* -----------------
*
* Change the line range of a name.
*/
void ServerName_SetSel(
LPSERVERNAME lpServerName,
LPLINERANGE lplrSel,
BOOL fRangeModified
)
{
LPOUTLINENAME lpOutlineName = (LPOUTLINENAME)lpServerName;
BOOL fPseudoObjChanged = fRangeModified;
if (lpOutlineName->m_nStartLine != lplrSel->m_nStartLine) {
lpOutlineName->m_nStartLine = lplrSel->m_nStartLine;
fPseudoObjChanged = TRUE;
}
if (lpOutlineName->m_nEndLine != lplrSel->m_nEndLine) {
lpOutlineName->m_nEndLine = lplrSel->m_nEndLine;
fPseudoObjChanged = TRUE;
}
/* OLE2NOTE: if the range of an active pseudo object has
** changed, then inform any linking clients that the object
** has changed.
*/
if (lpServerName->m_lpPseudoObj && fPseudoObjChanged) {
PseudoObj_SendAdvise(
lpServerName->m_lpPseudoObj,
OLE_ONDATACHANGE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- no flags necessary */
);
}
}
/* ServerName_SendPendingAdvises
* -----------------------------
*
* Send any pending change notifications for the associated
* pseudo objects for this name (if one exists).
* while ReDraw is diabled on the ServerDoc, then change advise
* notifications are not sent to pseudo object clients.
*/
void ServerName_SendPendingAdvises(LPSERVERNAME lpServerName)
{
if (! lpServerName->m_lpPseudoObj)
return; // no associated pseudo object
if (lpServerName->m_lpPseudoObj->m_fDataChanged)
PseudoObj_SendAdvise(
lpServerName->m_lpPseudoObj,
OLE_ONDATACHANGE,
NULL, /* lpmkDoc -- not relevant here */
0 /* advf -- no flags necessary */
);
}
/* ServerName_GetPseudoObj
** -----------------------
**
** Return a pointer to a pseudo object associated to a ServerName.
** if the pseudo object already exists, then return the
** existing object, otherwise allocate a new pseudo object.
**
** NOTE: the PseudoObj is returned with a 0 refcnt if first created,
** else the existing refcnt is unchanged.
*/
LPPSEUDOOBJ ServerName_GetPseudoObj(
LPSERVERNAME lpServerName,
LPSERVERDOC lpServerDoc
)
{
// Check if a PseudoObj already exists
if (lpServerName->m_lpPseudoObj)
return lpServerName->m_lpPseudoObj;
// A PseudoObj does NOT already exist, allocate a new one.
lpServerName->m_lpPseudoObj=(LPPSEUDOOBJ) New((DWORD)sizeof(PSEUDOOBJ));
if (lpServerName->m_lpPseudoObj == NULL) {
OleDbgAssertSz(lpServerName->m_lpPseudoObj != NULL, "Error allocating PseudoObj");
return NULL;
}
PseudoObj_Init(lpServerName->m_lpPseudoObj, lpServerName, lpServerDoc);
return lpServerName->m_lpPseudoObj;
}
/* ServerName_ClosePseudoObj
* -------------------------
*
* if there is an associated pseudo objects for this name (if one
* exists), then close it. this results in sending OnClose
* notification to the pseudo object's linking clients.
*/
void ServerName_ClosePseudoObj(LPSERVERNAME lpServerName)
{
if (!lpServerName || !lpServerName->m_lpPseudoObj)
return; // no associated pseudo object
PseudoObj_Close(lpServerName->m_lpPseudoObj);
}
#endif // OLE_SERVER
#if defined( OLE_CNTR )
/*************************************************************************
** ContainerDoc Supprt Functions Used by Container versions
*************************************************************************/
/* ContainerLine_GetRelMoniker
** ---------------------------
** Retrieve the relative item moniker which identifies the OLE object
** relative to the container document.
**
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ContainerLine_GetRelMoniker(
LPCONTAINERLINE lpContainerLine,
DWORD dwAssign
)
{
LPMONIKER lpmk = NULL;
/* OLE2NOTE: we should only give out a moniker for the OLE object
** if the object is allowed to be linked to from the inside. if
** so we are allowed to give out a moniker which binds to the
** running OLE object). if the object is an OLE 2.0 embedded
** object then it is allowed to be linked to from the inside. if
** the object is either an OleLink or an OLE 1.0 embedding
** then it can not be linked to from the inside.
** if we were a container/server app then we could offer linking
** to the outside of the object (ie. a pseudo object within our
** document). we are a container only app that does not support
** linking to ranges of its data.
*/
switch (dwAssign) {
case GETMONIKER_FORCEASSIGN:
/* Force the assignment of the name. This is called when a
** Paste Link actually occurs. From now on we want
** to inform the OLE object that its moniker is
** assigned and is thus necessary to register itself
** in the RunningObjectTable.
*/
CreateItemMonikerA(
OLESTDDELIM, lpContainerLine->m_szStgName, &lpmk);
/* OLE2NOTE: if the OLE object is already loaded and it
** is being assigned a moniker for the first time,
** then we need to inform it that it now has a moniker
** assigned by calling IOleObject::SetMoniker. this
** will force the OLE object to register in the
** RunningObjectTable when it enters the running
** state. if the object is not currently loaded,
** SetMoniker will be called automatically later when
** the object is loaded by the function
** ContainerLine_LoadOleObject.
*/
if (! lpContainerLine->m_fMonikerAssigned) {
/* we must remember forever more that this object has a
** moniker assigned.
*/
lpContainerLine->m_fMonikerAssigned = TRUE;
// we are now dirty and must be saved
OutlineDoc_SetModified(
(LPOUTLINEDOC)lpContainerLine->m_lpDoc,
TRUE, /* fModified */
FALSE, /* fDataChanged--N/A for container ver. */
FALSE /* fSizeChanged--N/A for container ver. */
);
if (lpContainerLine->m_lpOleObj) {
OLEDBG_BEGIN2("IOleObject::SetMoniker called\r\n")
lpContainerLine->m_lpOleObj->lpVtbl->SetMoniker(
lpContainerLine->m_lpOleObj,
OLEWHICHMK_OBJREL,
lpmk
);
OLEDBG_END2
}
}
break;
case GETMONIKER_ONLYIFTHERE:
/* If the OLE object currently has a moniker assigned,
** then return it.
*/
if (lpContainerLine->m_fMonikerAssigned) {
CreateItemMonikerA(
OLESTDDELIM,
lpContainerLine->m_szStgName,
&lpmk
);
}
break;
case GETMONIKER_TEMPFORUSER:
/* Return the moniker that would be used for the OLE
** object but do NOT force moniker assignment at
** this point. Since our strategy is to use the
** storage name of the object as its item name, we
** can simply create the corresponding ItemMoniker
** (indepenedent of whether the moniker is currently
** assigned or not).
*/
CreateItemMonikerA(
OLESTDDELIM,
lpContainerLine->m_szStgName,
&lpmk
);
break;
case GETMONIKER_UNASSIGN:
lpContainerLine->m_fMonikerAssigned = FALSE;
break;
}
return lpmk;
}
/* ContainerLine_GetFullMoniker
** ----------------------------
** Retrieve the full absolute moniker which identifies the OLE object
** in the container document.
** this moniker is created as a composite of the absolute moniker for
** the entire document appended with an item moniker which identifies
** the OLE object relative to the document.
** Returns NULL if a moniker can NOT be created.
*/
LPMONIKER ContainerLine_GetFullMoniker(
LPCONTAINERLINE lpContainerLine,
DWORD dwAssign
)
{
LPMONIKER lpmkDoc = NULL;
LPMONIKER lpmkItem = NULL;
LPMONIKER lpmkFull = NULL;
lpmkDoc = OleDoc_GetFullMoniker(
(LPOLEDOC)lpContainerLine->m_lpDoc,
dwAssign
);
if (! lpmkDoc) return NULL;
lpmkItem = ContainerLine_GetRelMoniker(lpContainerLine, dwAssign);
if (lpmkItem) {
CreateGenericComposite(lpmkDoc, lpmkItem, (LPMONIKER FAR*)&lpmkFull);
OleStdRelease((LPUNKNOWN)lpmkItem);
}
if (lpmkDoc)
OleStdRelease((LPUNKNOWN)lpmkDoc);
return lpmkFull;
}
/* ContainerDoc_InformAllOleObjectsDocRenamed
** ------------------------------------------
** Inform all OLE objects that the name of the ContainerDoc has changed.
*/
void ContainerDoc_InformAllOleObjectsDocRenamed(
LPCONTAINERDOC lpContainerDoc,
LPMONIKER lpmkDoc
)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
/* OLE2NOTE: if the OLE object is already loaded AND the
** object already has a moniker assigned, then we need
** to inform it that the moniker of the ContainerDoc has
** changed. of course, this means the full moniker of
** the object has changed. to do this we call
** IOleObject::SetMoniker. this will force the OLE
** object to re-register in the RunningObjectTable if it
** is currently in the running state. it is not in the
** running state, the object handler can make not that
** the object has a new moniker. if the object is not
** currently loaded, SetMoniker will be called
** automatically later when the object is loaded by the
** function ContainerLine_LoadOleObject.
** also if the object is a linked object, we always want
** to call SetMoniker on the link so that in case the
** link source is contained within our same container,
** the link source will be tracked. the link rebuilds
** its absolute moniker if it has a relative moniker.
*/
if (lpContainerLine->m_lpOleObj) {
if (lpContainerLine->m_fMonikerAssigned ||
lpContainerLine->m_dwLinkType != 0) {
OLEDBG_BEGIN2("IOleObject::SetMoniker called\r\n")
lpContainerLine->m_lpOleObj->lpVtbl->SetMoniker(
lpContainerLine->m_lpOleObj,
OLEWHICHMK_CONTAINER,
lpmkDoc
);
OLEDBG_END2
}
/* OLE2NOTE: we must call IOleObject::SetHostNames so
** any open objects can update their window titles.
*/
OLEDBG_BEGIN2("IOleObject::SetHostNames called\r\n")
CallIOleObjectSetHostNamesA(
lpContainerLine->m_lpOleObj,
APPNAME,
((LPOUTLINEDOC)lpContainerDoc)->m_lpszDocTitle
);
OLEDBG_END2
}
}
}
}
/* ContainerDoc_GetObject
** ----------------------
** Return a pointer to the desired interface of an object identified
** by an item string (lpszItem). the object returned will be an OLE
** object (either link or embedding).
**
** OLE2NOTE: we must force the object to run because we are
** REQUIRED to return a pointer the OLE object in the
** RUNNING state.
**
** dwSpeedNeeded indicates how long the caller is willing
** to wait for us to get the object:
** BINDSPEED_IMMEDIATE -- only if obj already loaded && IsRunning
** BINDSPEED_MODERATE -- load obj if necessary && if IsRunning
** BINDSPEED_INDEFINITE-- force obj to load and run if necessary
*/
HRESULT ContainerDoc_GetObjectA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
DWORD dwSpeedNeeded,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
BOOL fMatchFound = FALSE;
DWORD dwStatus;
HRESULT hrErr;
*lplpvObject = NULL;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
if (lstrcmp(lpContainerLine->m_szStgName, lpszItem) == 0) {
fMatchFound = TRUE; // valid item name
// check if object is loaded.
if (lpContainerLine->m_lpOleObj == NULL) {
// if BINDSPEED_IMMEDIATE is requested, object must
// ALREADY be loadded.
if (dwSpeedNeeded == BINDSPEED_IMMEDIATE)
return ResultFromScode(MK_E_EXCEEDEDDEADLINE);
ContainerLine_LoadOleObject(lpContainerLine);
if (! lpContainerLine->m_lpOleObj)
return ResultFromScode(E_OUTOFMEMORY);
}
/* OLE2NOTE: check if the object is allowed to be linked
** to from the inside (ie. we are allowed to
** give out a moniker which binds to the running
** OLE object). if the object is an OLE
** 2.0 embedded object then it is allowed to be
** linked to from the inside. if the object is
** either an OleLink or an OLE 1.0 embedding
** then it can not be linked to from the inside.
** if we were a container/server app then we
** could offer linking to the outside of the
** object (ie. a pseudo object within our
** document). we are a container only app that
** does not support linking to ranges of its data.
*/
OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n");
lpContainerLine->m_lpOleObj->lpVtbl->GetMiscStatus(
lpContainerLine->m_lpOleObj,
DVASPECT_CONTENT, /* aspect is not important */
(LPDWORD)&dwStatus
);
OLEDBG_END2
if (dwStatus & OLEMISC_CANTLINKINSIDE)
return ResultFromScode(MK_E_NOOBJECT);
// check if object is running.
if (! OleIsRunning(lpContainerLine->m_lpOleObj)) {
// if BINDSPEED_MODERATE is requested, object must
// ALREADY be running.
if (dwSpeedNeeded == BINDSPEED_MODERATE)
return ResultFromScode(MK_E_EXCEEDEDDEADLINE);
/* OLE2NOTE: we have found a match for the item name.
** now we must return a pointer to the desired
** interface on the RUNNING object. we must
** carefully load the object and initially ask for
** an interface that we are sure the loaded form of
** the object supports. if we immediately ask the
** loaded object for the desired interface, the
** QueryInterface call might fail if it is an
** interface that is supported only when the object
** is running. thus we force the object to load and
** return its IUnknown*. then we force the object to
** run, and then finally, we can ask for the
** actually requested interface.
*/
hrErr = ContainerLine_RunOleObject(lpContainerLine);
if (hrErr != NOERROR) {
return hrErr;
}
}
// Retrieve the requested interface
*lplpvObject = OleStdQueryInterface(
(LPUNKNOWN)lpContainerLine->m_lpOleObj, riid);
break; // Match FOUND!
}
}
}
if (*lplpvObject != NULL) {
return NOERROR;
} else
return (fMatchFound ? ResultFromScode(E_NOINTERFACE)
: ResultFromScode(MK_E_NOOBJECT));
}
HRESULT ContainerDoc_GetObject(
LPCONTAINERDOC lpContainerDoc,
LPOLESTR lpszItem,
DWORD dwSpeedNeeded,
REFIID riid,
LPVOID FAR* lplpvObject
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = ContainerDoc_GetObjectA(lpContainerDoc, lpsz, dwSpeedNeeded,
riid, lplpvObject);
FREESTR(lpsz)
return hr;
}
/* ContainerDoc_GetObjectStorage
** -----------------------------
** Return a pointer to the IStorage* used by the object identified
** by an item string (lpszItem). the object identified could be either
** an OLE object (either link or embedding).
*/
HRESULT ContainerDoc_GetObjectStorageA(
LPCONTAINERDOC lpContainerDoc,
LPSTR lpszItem,
LPSTORAGE FAR* lplpStg
)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
*lplpStg = NULL;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
if (lstrcmp(lpContainerLine->m_szStgName, lpszItem) == 0) {
*lplpStg = lpContainerLine->m_lpStg;
break; // Match FOUND!
}
}
}
if (*lplpStg != NULL) {
return NOERROR;
} else
return ResultFromScode(MK_E_NOOBJECT);
}
HRESULT ContainerDoc_GetObjectStorage(
LPCONTAINERDOC lpContainerDoc,
LPOLESTR lpszItem,
LPSTORAGE FAR* lplpStg
)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = ContainerDoc_GetObjectStorageA(lpContainerDoc, lpsz, lplpStg);
FREESTR(lpsz)
return hr;
}
/* ContainerDoc_IsRunning
** ----------------------
** Check if the object identified by an item string (lpszItem) is in
** the running state.
** For a container-only app, a check is made if the OLE object
** associated with the item name is running.
*/
HRESULT ContainerDoc_IsRunningA(LPCONTAINERDOC lpContainerDoc, LPSTR lpszItem)
{
LPLINELIST lpLL = &((LPOUTLINEDOC)lpContainerDoc)->m_LineList;
int i;
LPLINE lpLine;
DWORD dwStatus;
for (i = 0; i < lpLL->m_nNumLines; i++) {
lpLine=LineList_GetLine(lpLL, i);
if (lpLine && (Line_GetLineType(lpLine)==CONTAINERLINETYPE)) {
LPCONTAINERLINE lpContainerLine = (LPCONTAINERLINE)lpLine;
if (lstrcmp(lpContainerLine->m_szStgName, lpszItem) == 0) {
/* OLE2NOTE: we have found a match for the item name.
** now we must check if the OLE object is running.
** we will load the object if not already loaded.
*/
if (! lpContainerLine->m_lpOleObj) {
ContainerLine_LoadOleObject(lpContainerLine);
if (! lpContainerLine->m_lpOleObj)
return ResultFromScode(E_OUTOFMEMORY);
}
/* OLE2NOTE: check if the object is allowed to be linked
** to from the inside (ie. we are allowed to
** give out a moniker which binds to the running
** OLE object). if the object is an OLE
** 2.0 embedded object then it is allowed to be
** linked to from the inside. if the object is
** either an OleLink or an OLE 1.0 embedding
** then it can not be linked to from the inside.
** if we were a container/server app then we
** could offer linking to the outside of the
** object (ie. a pseudo object within our
** document). we are a container only app that
** does not support linking to ranges of its data.
*/
OLEDBG_BEGIN2("IOleObject::GetMiscStatus called\r\n")
lpContainerLine->m_lpOleObj->lpVtbl->GetMiscStatus(
lpContainerLine->m_lpOleObj,
DVASPECT_CONTENT, /* aspect is not important */
(LPDWORD)&dwStatus
);
OLEDBG_END2
if (dwStatus & OLEMISC_CANTLINKINSIDE)
return ResultFromScode(MK_E_NOOBJECT);
if (OleIsRunning(lpContainerLine->m_lpOleObj))
return NOERROR;
else
return ResultFromScode(S_FALSE);
}
}
}
// no object was found corresponding to the item name
return ResultFromScode(MK_E_NOOBJECT);
}
HRESULT ContainerDoc_IsRunning(LPCONTAINERDOC lpContainerDoc, LPOLESTR lpszItem)
{
CREATESTR(lpsz, lpszItem)
HRESULT hr = ContainerDoc_IsRunningA(lpContainerDoc, lpsz);
FREESTR(lpsz)
return hr;
}
#endif // OLE_CNTR
Reference in a new issue Copy permalink