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

2990 lines
99 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*************************************************************************
**
** OLE 2 Sample Code
**
** oleapp.c
**
** This file contains functions and methods that are common to
** server and the client version of the app. This includes the class
** factory methods and all OleApp functions.
**
** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
**
*************************************************************************/
#include "outline.h"
#include <ole2ver.h>
OLEDBGDATA
extern LPOUTLINEAPP g_lpApp;
extern IUnknownVtbl g_OleApp_UnknownVtbl;
extern IUnknownVtbl g_OleDoc_UnknownVtbl;
extern IPersistFileVtbl g_OleDoc_PersistFileVtbl;
extern IOleItemContainerVtbl g_OleDoc_OleItemContainerVtbl;
extern IExternalConnectionVtbl g_OleDoc_ExternalConnectionVtbl;
extern IDataObjectVtbl g_OleDoc_DataObjectVtbl;
#if defined( USE_DRAGDROP )
extern IDropTargetVtbl g_OleDoc_DropTargetVtbl;
extern IDropSourceVtbl g_OleDoc_DropSourceVtbl;
#endif // USE_DRAGDROP
#if defined( OLE_SERVER )
extern IOleObjectVtbl g_SvrDoc_OleObjectVtbl;
extern IPersistStorageVtbl g_SvrDoc_PersistStorageVtbl;
#if defined( SVR_TREATAS )
extern IStdMarshalInfoVtbl g_SvrDoc_StdMarshalInfoVtbl;
#endif // SVR_TREATAS
extern IUnknownVtbl g_PseudoObj_UnknownVtbl;
extern IOleObjectVtbl g_PseudoObj_OleObjectVtbl;
extern IDataObjectVtbl g_PseudoObj_DataObjectVtbl;
#if defined( INPLACE_SVR )
extern IOleInPlaceObjectVtbl g_SvrDoc_OleInPlaceObjectVtbl;
extern IOleInPlaceActiveObjectVtbl g_SvrDoc_OleInPlaceActiveObjectVtbl;
#endif // INPLACE_SVR
#endif // OLE_SERVER
#if defined( OLE_CNTR )
extern IOleUILinkContainerVtbl g_CntrDoc_OleUILinkContainerVtbl;
extern IUnknownVtbl g_CntrLine_UnknownVtbl;
extern IOleClientSiteVtbl g_CntrLine_OleClientSiteVtbl;
extern IAdviseSinkVtbl g_CntrLine_AdviseSinkVtbl;
#if defined( INPLACE_CNTR )
extern IOleInPlaceSiteVtbl g_CntrLine_OleInPlaceSiteVtbl;
extern IOleInPlaceFrameVtbl g_CntrApp_OleInPlaceFrameVtbl;
extern BOOL g_fInsideOutContainer;
#endif // INPLACE_CNTR
#endif // OLE_CNTR
// REVIEW: these are NOT useful end-user messages
static char ErrMsgCreateCF[] = "Can't create Class Factory!";
static char ErrMsgRegCF[] = "Can't register Class Factory!";
static char ErrMsgRegMF[] = "Can't register Message Filter!";
extern UINT g_uMsgHelp;
/* OleApp_InitInstance
* -------------------
*
* Initialize the app instance by creating the main frame window and
* performing app instance specific initializations
* (eg. initializing interface Vtbls).
*
* RETURNS: TRUE if the memory could be allocated, and the server app
* was properly initialized.
* FALSE otherwise
*
*/
BOOL OleApp_InitInstance(LPOLEAPP lpOleApp, HINSTANCE hInst, int nCmdShow)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
HRESULT hrErr;
DWORD dwBuildVersion = OleBuildVersion();
LPMALLOC lpMalloc = NULL;
OLEDBG_BEGIN3("OleApp_InitInstance\r\n")
lpOleApp->m_fOleInitialized = FALSE;
/* OLE2NOTE: check if the build version of the OLE2 DLL's match
** what our application is expecting.
*/
if (HIWORD(dwBuildVersion) != rmm || LOWORD(dwBuildVersion) < rup) {
OleDbgAssertSz(0, "ERROR: OLE 2.0 DLL's are NOT compatible!");
#if !defined( _DEBUG )
return FALSE; // Wrong version of DLL's
#endif
}
#if defined( _DEBUG )
/* OLE2NOTE: Use a special debug allocator to help track down
** memory leaks.
*/
OleStdCreateDbAlloc(0, &lpMalloc);
#endif
/* OLE2NOTE: the OLE libraries must be properly initialized before
** making any calls. OleInitialize automatically calls
** CoInitialize. we will use the default task memory allocator
** therefore we pass NULL to OleInitialize.
*/
OLEDBG_BEGIN2("OleInitialize called\r\n")
hrErr = OleInitialize(lpMalloc);
if (FAILED(hrErr))
{
// Replacing the allocator may not be legal - try initializing
// without overriding the allocator
hrErr = OleInitialize(NULL);
}
OLEDBG_END2
#if defined( _DEBUG )
/* OLE2NOTE: release the special debug allocator so that only OLE is
** holding on to it. later when OleUninitialize is called, then
** the debug allocator object will be destroyed. when the debug
** allocator object is destoyed, it will report (to the Output
** Debug Terminal) whether there are any memory leaks.
*/
if (lpMalloc) lpMalloc->lpVtbl->Release(lpMalloc);
#endif
if (hrErr != NOERROR) {
OutlineApp_ErrorMessage(lpOutlineApp,"OLE initialization failed!");
goto error;
}
/*****************************************************************
** OLE2NOTE: we must remember the fact that OleInitialize has
** been call successfully. the very last thing an app must
** be do is properly shut down OLE by calling
** OleUninitialize. This call MUST be guarded! it is only
** allowable to call OleUninitialize if OleInitialize has
** been called SUCCESSFULLY.
*****************************************************************/
lpOleApp->m_fOleInitialized = TRUE;
// Initialize the OLE 2.0 interface method tables.
if (! OleApp_InitVtbls(lpOleApp))
goto error;
// Register OLE 2.0 clipboard formats.
lpOleApp->m_cfEmbedSource = RegisterClipboardFormat(CF_EMBEDSOURCE);
lpOleApp->m_cfEmbeddedObject = RegisterClipboardFormat(
CF_EMBEDDEDOBJECT
);
lpOleApp->m_cfLinkSource = RegisterClipboardFormat(CF_LINKSOURCE);
lpOleApp->m_cfFileName = RegisterClipboardFormat(CF_FILENAME);
lpOleApp->m_cfObjectDescriptor =
RegisterClipboardFormat(CF_OBJECTDESCRIPTOR);
lpOleApp->m_cfLinkSrcDescriptor =
RegisterClipboardFormat(CF_LINKSRCDESCRIPTOR);
lpOleApp->m_cRef = 0;
lpOleApp->m_cDoc = 0;
lpOleApp->m_fUserCtrl = FALSE;
lpOleApp->m_dwRegClassFac = 0;
lpOleApp->m_lpClassFactory = NULL;
lpOleApp->m_cModalDlgActive = 0;
INIT_INTERFACEIMPL(
&lpOleApp->m_Unknown,
&g_OleApp_UnknownVtbl,
lpOleApp
);
#if defined( USE_DRAGDROP )
// delay before dragging should start, in milliseconds
lpOleApp->m_nDragDelay = GetProfileInt(
"windows",
"DragDelay",
DD_DEFDRAGDELAY
);
// minimum distance (radius) before drag should start, in pixels
lpOleApp->m_nDragMinDist = GetProfileInt(
"windows",
"DragMinDist",
DD_DEFDRAGMINDIST
);
// delay before scrolling, in milliseconds
lpOleApp->m_nScrollDelay = GetProfileInt(
"windows",
"DragScrollDelay",
DD_DEFSCROLLDELAY
);
// inset-width of the hot zone, in pixels
lpOleApp->m_nScrollInset = GetProfileInt(
"windows",
"DragScrollInset",
DD_DEFSCROLLINSET
);
// scroll interval, in milliseconds
lpOleApp->m_nScrollInterval = GetProfileInt(
"windows",
"DragScrollInterval",
DD_DEFSCROLLINTERVAL
);
#if defined( IF_SPECIAL_DD_CURSORS_NEEDED )
// This would be used if the app wanted to have custom drag/drop cursors
lpOleApp->m_hcursorDragNone = LoadCursor ( hInst, "DragNoneCur" );
lpOleApp->m_hcursorDragCopy = LoadCursor ( hInst, "DragCopyCur" );
lpOleApp->m_hcursorDragMove = LoadCursor ( hInst, "DragMoveCur" );
lpOleApp->m_hcursorDragLink = LoadCursor ( hInst, "DragLinkCur" );
#endif // IF_SPECIAL_DD_CURSORS_NEEDED
#endif // USE_DRAGDROP
lpOleApp->m_lpMsgFilter = NULL;
#if defined( USE_MSGFILTER )
/* OLE2NOTE: Register our message filter upon app startup. the
** message filter is used to handle concurrency.
** we will use a standard implementation of IMessageFilter that
** is included as part of the OLE2UI library.
*/
lpOleApp->m_lpMsgFilter = NULL;
if (! OleApp_RegisterMessageFilter(lpOleApp))
goto error;
/* OLE2NOTE: because our app is initially INVISIBLE, we must
** DISABLE the busy dialog. we should NOT put up any dialogs if
** our app is invisible. when our app window is made visible,
** then the busy dialog will be enabled.
*/
OleStdMsgFilter_EnableBusyDialog(lpOleApp->m_lpMsgFilter, FALSE);
#endif // USE_MSGFILTER
#if defined( OLE_SERVER )
/* OLE2NOTE: perform initialization specific for an OLE server */
if (! ServerApp_InitInstance((LPSERVERAPP)lpOutlineApp, hInst, nCmdShow))
goto error;
#endif
#if defined( OLE_CNTR )
/* OLE2NOTE: perform initialization specific for an OLE container */
// Register help message
g_uMsgHelp = RegisterWindowMessage(SZOLEUI_MSG_HELP);
if (! ContainerApp_InitInstance((LPCONTAINERAPP)lpOutlineApp, hInst, nCmdShow))
goto error;
#endif
#if defined( OLE_CNTR )
lpOleApp->m_hStdPal = OleStdCreateStandardPalette();
#endif
OLEDBG_END3
return TRUE;
error:
OLEDBG_END3
return FALSE;
}
/*
* OleApp_TerminateApplication
* ---------------------------
* Perform proper OLE application cleanup before shutting down
*/
void OleApp_TerminateApplication(LPOLEAPP lpOleApp)
{
OLEDBG_BEGIN3("OleApp_TerminateApplication\r\n")
/* OLE2NOTE: perform a clean shut down for OLE. at this point our
** App refcnt should be 0, or else we should never have reached
** this point!
*/
OleDbgAssertSz(lpOleApp->m_cRef == 0, "App NOT shut down properly");
if(lpOleApp->m_fOleInitialized) {
OLEDBG_BEGIN2("OleUninitialize called\r\n")
OleUninitialize();
OLEDBG_END2
}
OLEDBG_END3
}
/* OleApp_ParseCmdLine
* -------------------
*
* Parse the command line for any execution flags/arguments.
* OLE2NOTE: check if "-Embedding" switch is given.
*/
BOOL OleApp_ParseCmdLine(LPOLEAPP lpOleApp, LPSTR lpszCmdLine, int nCmdShow)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
char szFileName[256]; /* buffer for filename in command line */
BOOL fStatus = TRUE;
BOOL fEmbedding = FALSE;
OLEDBG_BEGIN3("OleApp_ParseCmdLine\r\n")
szFileName[0] = '\0';
ParseCmdLine(lpszCmdLine, &fEmbedding, (LPSTR)szFileName);
#if defined( MDI_VERSION )
/* OLE2NOTE: an MDI app would ALWAYS register its ClassFactory. it
** can handle multiple objects at the same time, while an SDI
** application can only handle a single embedded or file-based
** object at a time.
*/
fStatus = OleApp_RegisterClassFactory(lpOleApp);
#endif
if(fEmbedding) {
if (szFileName[0] == '\0') {
/*****************************************************************
** App was launched with /Embedding.
** We must register our ClassFactory with OLE, remain hidden
** (the app window is initially created not visible), and
** wait for OLE to call IClassFactory::CreateInstance
** method. We do not automatically create a document as we
** do when the app is launched by the user from the
** FileManager. We must NOT make our app window visible
** until told to do so by our container.
**
** OLE2NOTE: Because we are an SDI app, we only register our
** ClassFactory if we are launched with the /Embedding
** flag WITHOUT a filename. an MDI app would ALWAYS
** register its ClassFactory. it can handle multiple
** objects at the same time, while an SDI application
** can only handle a single embedded or file-based
** object at a time.
*****************************************************************/
#if defined( SDI_VERSION )
fStatus = OleApp_RegisterClassFactory(lpOleApp);
#endif
} else {
/*****************************************************************
** App was launched with /Embedding <Filename>.
** We must create a document and load the file and
** register it in the RunningObjectTable BEFORE we
** enter our GetMessage loop (ie. before we yield).
** One way to perform these tasks is to call the same
** interface methods that OLE 2.0 calls for linking to a
** file:
** IClassFactory::CreateInstance
** IPersistFile::Load
**
** We must NOT make our app window visible until told to
** do so by our container. An application will be
** launched in this manner by an OLE 1.0 application
** link situation (eg. double clicking a linked object
** or OleCreateLinkFromFile called).
**
** OLE2NOTE: Because we are an SDI app, we should NOT
** register our ClassFactory when we are launched with the
** /Embedding <Filename> flag. our SDI instance can only
** handle a single embedded or file-based object.
** an MDI app WOULD register its ClassFactory at all
** times because it can handle multiple objects.
*****************************************************************/
// allocate a new document object
lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE);
if (! lpOutlineApp->m_lpDoc) {
OLEDBG_END3
return FALSE;
}
/* OLE2NOTE: initially the Doc object is created with a 0 ref
** count. in order to have a stable Doc object during the
** process of initializing the new Doc instance,
** we intially AddRef the Doc ref cnt and later
** Release it. This initial AddRef is artificial; it is simply
** done to guarantee that a harmless QueryInterface followed by
** a Release does not inadvertantly force our object to destroy
** itself prematurely.
*/
OleDoc_AddRef((LPOLEDOC)lpOutlineApp->m_lpDoc);
/* OLE2NOTE: OutlineDoc_LoadFromFile will register our document
** in the RunningObjectTable. this registration will
** AddRef our document. therefore our document will not
** be destroyed when we release the artificial AddRef
*/
fStatus = OutlineDoc_LoadFromFile(
lpOutlineApp->m_lpDoc, (LPSTR)szFileName);
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc); // rel AddRef
OLEDBG_END3
return fStatus;
}
} else {
/*****************************************************************
** App was launched by the user (without /Embedding) and
** therefore is marked to be under user control.
** In this case, because we are an SDI app, we do NOT
** register our ClassFactory with OLE. This app instance can
** only manage one document at a time (either a user
** document or an embedded object document). An MDI app
** would register its ClassFactory here.
**
** We must create a document for the user (either
** initialized from a file given on the command line or
** initialized as an untitled document. We must also make
** our app window visible to the user.
*****************************************************************/
// allocate a new document object
lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE);
if (! lpOutlineApp->m_lpDoc) goto error;
/* OLE2NOTE: initially the Doc object is created with a 0 ref
** count. in order to have a stable Doc object during the
** process of initializing the new Doc instance,
** we intially AddRef the Doc ref cnt and later
** Release it. This initial AddRef is artificial; it is simply
** done to guarantee that a harmless QueryInterface followed by
** a Release does not inadvertantly force our object to destroy
** itself prematurely.
*/
OleDoc_AddRef((LPOLEDOC)lpOutlineApp->m_lpDoc);
if(*szFileName) {
// initialize the document from the specified file
if (! OutlineDoc_LoadFromFile(lpOutlineApp->m_lpDoc, szFileName))
goto error;
} else {
// set the doc to an (Untitled) doc.
if (! OutlineDoc_InitNewFile(lpOutlineApp->m_lpDoc))
goto error;
}
// position and size the new doc window
OutlineApp_ResizeWindows(lpOutlineApp);
OutlineDoc_ShowWindow(lpOutlineApp->m_lpDoc); // calls OleDoc_Lock
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc);// rel AddRef above
// show main app window
ShowWindow(lpOutlineApp->m_hWndApp, nCmdShow);
UpdateWindow(lpOutlineApp->m_hWndApp);
#if defined( OLE_CNTR )
ContainerDoc_UpdateLinks((LPCONTAINERDOC)lpOutlineApp->m_lpDoc);
#endif
}
OLEDBG_END3
return fStatus;
error:
// REVIEW: should load string from string resource
OutlineApp_ErrorMessage(
lpOutlineApp,
"Could not create document--Out of Memory"
);
if (lpOutlineApp->m_lpDoc) // rel artificial AddRef above
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc);
OLEDBG_END3
return FALSE;
}
/* OleApp_CloseAllDocsAndExitCommand
* ---------------------------------
*
* Close all active documents and exit the app.
* Because this is an SDI, there is only one document
* If the doc was modified, prompt the user if he wants to save it.
*
* Returns:
* TRUE if the app is successfully closed
* FALSE if failed or aborted
*
* OLE2NOTE: in the OLE version, we can NOT directly
* destroy the App object. we can only take all
* necessary actions to ensure that our object receives
* all of its Releases from clients holding onto
* pointers (eg. closing all docs and flushing the
* clipboard) and then we must hide our window and wait
* actually for our refcnt to reach 0. when it reaches 0,
* our destructor (OutlineApp_Destroy) will be called.
* each document addref's the app object in order to
* guarentee that the app does not shut down while the doc
* is still open. closing all docs, will release these
* refcnt's. if there are now more open documents AND the
* app is not under the control of the user (ie. launched by
* OLE) then the app will now shut down. the OleApp_Release
* function executes this shut down procedure. after closing
* all docs, then releasing the user refcnt will force the
* app to shut down.
*/
BOOL OleApp_CloseAllDocsAndExitCommand(
LPOLEAPP lpOleApp,
BOOL fForceEndSession
)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
DWORD dwSaveOption = (fForceEndSession ?
OLECLOSE_NOSAVE : OLECLOSE_PROMPTSAVE);
/* OLE2NOTE: in order to have a stable App object during the
** process of closing, we intially AddRef the App ref cnt and
** later Release it. This initial AddRef is artificial; it is
** simply done to guarantee that our App object does not
** destroy itself until the end of this routine.
*/
OleApp_AddRef(lpOleApp);
/* Because this is an SDI app, there is only one document.
** Close the doc. if it is successfully closed and the app will
** not automatically exit, then also exit the app.
** if this were an MDI app, we would loop through and close all
** open MDI child documents.
*/
#if defined( OLE_SERVER )
if (!fForceEndSession &&
lpOutlineApp->m_lpDoc->m_docInitType == DOCTYPE_EMBEDDED)
dwSaveOption = OLECLOSE_SAVEIFDIRTY;
#endif
if (! OutlineDoc_Close(lpOutlineApp->m_lpDoc, dwSaveOption)) {
OleApp_Release(lpOleApp);
return FALSE; // User Aborted shutdown
}
#if defined( _DEBUG )
OleDbgAssertSz(
lpOutlineApp->m_lpDoc==NULL,
"Closed doc NOT properly destroyed"
);
#endif
#if defined( OLE_CNTR )
/* if we currently have data on the clipboard then we must tell
** the clipboard to release our clipboard data object
** (document)
*/
if (lpOutlineApp->m_lpClipboardDoc)
OleApp_FlushClipboard(lpOleApp);
#endif
OleApp_HideWindow(lpOleApp);
/* OLE2NOTE: this call forces all external connections to our
** object to close down and therefore guarantees that we receive
** all releases associated with those external connections.
*/
OLEDBG_BEGIN2("CoDisconnectObject(lpApp) called\r\n")
CoDisconnectObject((LPUNKNOWN)&lpOleApp->m_Unknown, 0);
OLEDBG_END2
OleApp_Release(lpOleApp); // release artificial AddRef above
return TRUE;
}
/* OleApp_ShowWindow
* -----------------
*
* Show the window of the app to the user.
* make sure app window is visible and bring the app to the top.
* IF fGiveUserCtrl == TRUE
* THEN give the user the control over the life-time of the app.
*/
void OleApp_ShowWindow(LPOLEAPP lpOleApp, BOOL fGiveUserCtrl)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
OLEDBG_BEGIN3("OleApp_ShowWindow\r\n")
/* OLE2NOTE: while the application is visible and under user
** control, we do NOT want it to be prematurely destroyed when
** the user closes a document. thus we must inform OLE to hold
** an external lock on our application on behalf of the user.
** this arranges that OLE holds at least 1 reference to our
** application that will NOT be released until we release this
** external lock. later, when the application window is hidden, we
** will release this external lock.
*/
if (fGiveUserCtrl && ! lpOleApp->m_fUserCtrl) {
lpOleApp->m_fUserCtrl = TRUE;
OleApp_Lock(lpOleApp, TRUE /* fLock */, 0 /* not applicable */);
}
// we must show our App window and force it to have input focus
ShowWindow(lpOutlineApp->m_hWndApp, SW_SHOWNORMAL);
SetFocus(lpOutlineApp->m_hWndApp);
/* OLE2NOTE: because our app is now visible, we can enable the busy
** dialog. we should NOT put up any dialogs if our app is
** invisible.
*/
OleApp_EnableBusyDialogs(lpOleApp, TRUE, TRUE);
OLEDBG_END3
}
/* OleApp_HideWindow
* -----------------
*
* Hide the window of the app from the user.
* take away the control of the app by the user.
*/
void OleApp_HideWindow(LPOLEAPP lpOleApp)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
OLEDBG_BEGIN3("OleApp_HideWindow\r\n")
/* OLE2NOTE: the application is now being hidden, so we must release
** the external lock that was made on behalf of the user.
** if this is that last external lock on our application, thus
** enabling our application to complete its shutdown operation.
*/
if (lpOleApp->m_fUserCtrl) {
lpOleApp->m_fUserCtrl = FALSE;
OleApp_Lock(lpOleApp, FALSE /*fLock*/, TRUE /*fLastUnlockReleases*/);
}
ShowWindow(lpOutlineApp->m_hWndApp, SW_HIDE);
/* OLE2NOTE: because our app is now INVISIBLE, we must DISABLE the busy
** dialog. we should NOT put up any dialogs if our app is
** invisible.
*/
OleApp_EnableBusyDialogs(lpOleApp, FALSE, FALSE);
OLEDBG_END3
}
/* OleApp_Lock
** -----------
** Lock/Unlock the App object. if the last lock is unlocked and
** fLastUnlockReleases == TRUE, then the app object will shut down
** (ie. it will recieve its final release and its refcnt will go to 0).
*/
HRESULT OleApp_Lock(LPOLEAPP lpOleApp, BOOL fLock, BOOL fLastUnlockReleases)
{
HRESULT hrErr;
#if defined( _DEBUG )
if (fLock) {
OLEDBG_BEGIN2("CoLockObjectExternal(lpApp,TRUE) called\r\n")
} else {
if (fLastUnlockReleases)
OLEDBG_BEGIN2("CoLockObjectExternal(lpApp,FALSE,TRUE) called\r\n")
else
OLEDBG_BEGIN2("CoLockObjectExternal(lpApp,FALSE,FALSE) called\r\n")
}
#endif // _DEBUG
OleApp_AddRef(lpOleApp); // artificial AddRef to make object stable
hrErr = CoLockObjectExternal(
(LPUNKNOWN)&lpOleApp->m_Unknown, fLock, fLastUnlockReleases);
OleApp_Release(lpOleApp); // release artificial AddRef above
OLEDBG_END2
return hrErr;
}
/* OleApp_Destroy
* --------------
*
* Free all OLE related resources that had been allocated for the app.
*/
void OleApp_Destroy(LPOLEAPP lpOleApp)
{
// OLE2NOTE: Revoke our message filter upon app shutdown.
OleApp_RevokeMessageFilter(lpOleApp);
// OLE2NOTE: Revoke our ClassFactory upon app shutdown.
OleApp_RevokeClassFactory(lpOleApp);
#if defined( IF_SPECIAL_DD_CURSORS_NEEDED )
// This would be used if the app wanted to have custom drag/drop cursors
DestroyCursor(lpOleApp->m_hcursorDragNone);
DestroyCursor(lpOleApp->m_hcursorDragCopy);
DestroyCursor(lpOleApp->m_hcursorDragLink);
DestroyCursor(lpOleApp->m_hcursorDragMove);
#endif // IF_SPECIAL_DD_CURSORS_NEEDED
#if defined( OLE_CNTR )
if (lpOleApp->m_hStdPal) {
DeleteObject(lpOleApp->m_hStdPal);
lpOleApp->m_hStdPal = NULL;
}
#endif
}
/* OleApp_DocLockApp
** -----------------
** Add a lock on the App on behalf of the Doc. the App may not close
** while the Doc exists.
**
** when a document is first created, it calls this method to
** guarantee that the application stays alive (OleDoc_Init).
** when a document is destroyed, it calls
** OleApp_DocUnlockApp to release this hold on the app.
*/
void OleApp_DocLockApp(LPOLEAPP lpOleApp)
{
ULONG cDoc;
OLEDBG_BEGIN3("OleApp_DocLockApp\r\n")
cDoc = ++lpOleApp->m_cDoc;
OleDbgOutRefCnt3("OleApp_DocLockApp: cDoc++\r\n", lpOleApp, cDoc);
OleApp_Lock(lpOleApp, TRUE /* fLock */, 0 /* not applicable */);
OLEDBG_END3
return;
}
/* OleApp_DocUnlockApp
** -------------------
** Forget all references to a closed document.
** Release the lock on the App on behalf of the Doc. if this was the
** last lock on the app, then it will shutdown.
*/
void OleApp_DocUnlockApp(LPOLEAPP lpOleApp, LPOUTLINEDOC lpOutlineDoc)
{
ULONG cDoc;
OLEDBG_BEGIN3("OleApp_DocUnlockApp\r\n")
/* OLE2NOTE: when there are no open documents and the app is not
** under the control of the user then revoke our ClassFactory to
** enable the app to shut down.
*/
cDoc = --lpOleApp->m_cDoc;
#if defined( _DEBUG )
OleDbgAssertSz (
lpOleApp->m_cDoc >= 0, "DocUnlockApp called with cDoc == 0");
OleDbgOutRefCnt3(
"OleApp_DocUnlockApp: cDoc--\r\n", lpOleApp, cDoc);
#endif
OleApp_Lock(lpOleApp, FALSE /* fLock */, TRUE /* fLastUnlockReleases */);
OLEDBG_END3
return;
}
/* OleApp_HideIfNoReasonToStayVisible
** ----------------------------------
**
** if there are no more documents visible to the user and the app
** itself is not under user control, then it has no reason to stay
** visible. we thus should hide the app. we can not directly destroy
** the app, because it may be validly being used programatically by
** another client application and should remain running. the app
** should simply be hidden from the user.
*/
void OleApp_HideIfNoReasonToStayVisible(LPOLEAPP lpOleApp)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
LPOUTLINEDOC lpOutlineDoc;
OLEDBG_BEGIN3("OleApp_HideIfNoReasonToStayVisible\r\n")
if (lpOleApp->m_fUserCtrl) {
OLEDBG_END3
return; // remain visible; user in control of app
}
/* Because this is an SDI app, there is only one user document.
** check if it is visible to the user. an MDI app would loop over
** all open MDI child documents to see if any are visible.
*/
lpOutlineDoc = (LPOUTLINEDOC)lpOutlineApp->m_lpDoc;
if (lpOutlineDoc && IsWindowVisible(lpOutlineDoc->m_hWndDoc))
return; // remain visible; the doc is visible to the user
// if we reached here, the app should be hidden
OleApp_HideWindow(lpOleApp);
OLEDBG_END3
}
/* OleApp_AddRef
** -------------
**
** increment the ref count of the App object.
**
** Returns the new ref count on the object
*/
ULONG OleApp_AddRef(LPOLEAPP lpOleApp)
{
++lpOleApp->m_cRef;
#if defined( _DEBUG )
OleDbgOutRefCnt4(
"OleApp_AddRef: cRef++\r\n",
lpOleApp,
lpOleApp->m_cRef
);
#endif
return lpOleApp->m_cRef;
}
/* OleApp_Release
** --------------
**
** decrement the ref count of the App object.
** if the ref count goes to 0, then the app object is destroyed.
**
** Returns the remaining ref count on the object
*/
ULONG OleApp_Release (LPOLEAPP lpOleApp)
{
ULONG cRef;
cRef = --lpOleApp->m_cRef;
#if defined( _DEBUG )
OleDbgAssertSz (lpOleApp->m_cRef >= 0, "Release called with cRef == 0");
OleDbgOutRefCnt4(
"OleApp_AddRef: cRef--\r\n", lpOleApp, cRef);
#endif // _DEBUG
/*********************************************************************
** OLE2NOTE: when the ClassFactory refcnt == 0, then destroy it. **
** otherwise the ClassFactory is still in use. **
*********************************************************************/
if(cRef == 0)
OutlineApp_Destroy((LPOUTLINEAPP)lpOleApp);
return cRef;
}
/* OleApp_QueryInterface
** ---------------------
**
** Retrieve a pointer to an interface on the app object.
**
** OLE2NOTE: this function will AddRef the ref cnt of the object.
**
** Returns NOERROR if interface is successfully retrieved.
** E_NOINTERFACE if the interface is not supported
*/
HRESULT OleApp_QueryInterface (
LPOLEAPP lpOleApp,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
SCODE sc;
/* OLE2NOTE: we must make sure to set all out ptr parameters to NULL. */
*lplpvObj = NULL;
if (IsEqualIID(riid, &IID_IUnknown)) {
OleDbgOut4("OleApp_QueryInterface: IUnknown* RETURNED\r\n");
*lplpvObj = (LPVOID) &lpOleApp->m_Unknown;
OleApp_AddRef(lpOleApp);
sc = S_OK;
}
else {
sc = E_NOINTERFACE;
}
OleDbgQueryInterfaceMethod(*lplpvObj);
return ResultFromScode(sc);
}
/* OleApp_RejectInComingCalls
** -------------------------
** Reject/Handle in coming OLE (LRPC) calls.
**
** OLE2NOTE: if the app is in a state when it can NOT handle in
** coming OLE method calls from an external process (eg. the app has
** an application modal dialog up), then it should call
** OleApp_RejectInComingCalls(TRUE). in this state the
** IMessageFilter::HandleInComingCall method will return
** SERVERCALL_RETRYLATER. this tells the caller to try again in a
** little while. normally the calling app will put up a dialog (see
** OleUIBusy dialog) in this situation informing the user of the
** situation. the user then is normally given the option to
** "Switch To..." the busy application, retry, or cancel the
** operation. when the app is ready to continue processing such
** calls, it should call OleApp_RejectInComingCalls(FALSE). in this
** state, SERVERCALL_ISHANDLED is returned by
** IMessageFilter::HandleInComingCall.
*/
void OleApp_RejectInComingCalls(LPOLEAPP lpOleApp, BOOL fReject)
{
#if defined( _DEBUG )
if (fReject)
OleDbgOut3("OleApp_RejectInComingCalls(TRUE)\r\n");
else
OleDbgOut3("OleApp_RejectInComingCalls(FALSE)\r\n");
#endif // _DEBUG
OleDbgAssert(lpOleApp->m_lpMsgFilter != NULL);
if (! lpOleApp->m_lpMsgFilter)
return;
OleStdMsgFilter_SetInComingCallStatus(
lpOleApp->m_lpMsgFilter,
(fReject ? SERVERCALL_RETRYLATER : SERVERCALL_ISHANDLED)
);
}
/* OleApp_DisableBusyDialogs
** -------------------------
** Disable the Busy and NotResponding dialogs.
**
** Returns previous enable state so that it can be restored by
** calling OleApp_ReEnableBusyDialogs.
*/
void OleApp_DisableBusyDialogs(
LPOLEAPP lpOleApp,
BOOL FAR* lpfPrevBusyEnable,
BOOL FAR* lpfPrevNREnable
)
{
if (lpOleApp->m_lpMsgFilter) {
*lpfPrevNREnable = OleStdMsgFilter_EnableNotRespondingDialog(
lpOleApp->m_lpMsgFilter, FALSE);
*lpfPrevBusyEnable = OleStdMsgFilter_EnableBusyDialog(
lpOleApp->m_lpMsgFilter, FALSE);
}
}
/* OleApp_EnableBusyDialogs
** ------------------------
** Set the enable state of the Busy and NotResponding dialogs.
**
** This function is typically used after a call to
** OleApp_DisableBusyDialogs in order to restore the previous enable
** state of the dialogs.
*/
void OleApp_EnableBusyDialogs(
LPOLEAPP lpOleApp,
BOOL fPrevBusyEnable,
BOOL fPrevNREnable
)
{
if (lpOleApp->m_lpMsgFilter) {
OleStdMsgFilter_EnableNotRespondingDialog(
lpOleApp->m_lpMsgFilter, fPrevNREnable);
OleStdMsgFilter_EnableBusyDialog(
lpOleApp->m_lpMsgFilter, fPrevBusyEnable);
}
}
/* OleApp_PreModalDialog
** ---------------------
** Keep track that a modal dialog is about to be brought up.
**
** while a modal dialog is up we need to take special actions:
** 1. we do NOT want to initialize our tool bar buttons on
** WM_ACTIVATEAPP. the tool bar is not accessible.
** 2. we want to reject new top-level, incoming LRPC calls
** (return SERVERCALL_RETRYLATER from IMessageFilter::
** HandleInComingCall).
** 3. (IN-PLACE SERVER) tell our in-place container to disable
** modeless dialogs by calling IOleInPlaceFrame::
** EnableModeless(FALSE).
** 4. (IN-PLACE CONTAINER) tell our UIActive in-place object to
** disable modeless dialogs by calling IOleInPlaceActiveObject::
** EnableModeless(FALSE).
*/
void OleApp_PreModalDialog(LPOLEAPP lpOleApp, LPOLEDOC lpOleDoc)
{
if (lpOleApp->m_cModalDlgActive == 0) {
// top-level modal dialog is being brought up
#if defined( USE_FRAMETOOLS )
LPFRAMETOOLS lptb;
if (lpOleDoc)
lptb = ((LPOUTLINEDOC)lpOleDoc)->m_lpFrameTools;
else
lptb = OutlineApp_GetFrameTools((LPOUTLINEAPP)lpOleApp);
if (lptb)
FrameTools_EnableWindow(lptb, FALSE);
#endif // USE_FRAMETOOLS
OleApp_RejectInComingCalls(lpOleApp, TRUE);
#if defined( INPLACE_SVR )
{
LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
/* if the document bringing up the modal dialog is
** currently a UIActive in-place object, then tell the
** top-level in-place frame to disable its modeless
** dialogs.
*/
if (lpServerDoc && lpServerDoc->m_fUIActive &&
lpServerDoc->m_lpIPData &&
lpServerDoc->m_lpIPData->lpFrame) {
OLEDBG_BEGIN2("IOleInPlaceFrame::EnableModless(FALSE) called\r\n");
lpServerDoc->m_lpIPData->lpFrame->lpVtbl->EnableModeless(
lpServerDoc->m_lpIPData->lpFrame, FALSE);
OLEDBG_END2
}
}
#endif // INPLACE_SVR
#if defined( INPLACE_CNTR )
{
LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)lpOleApp;
/* if the document bringing up the modal dialog is an
** in-place container that has a UIActive object, then
** tell the UIActive object to disable its modeless
** dialogs.
*/
if (lpContainerApp->m_lpIPActiveObj) {
OLEDBG_BEGIN2("IOleInPlaceActiveObject::EnableModless(FALSE) called\r\n");
lpContainerApp->m_lpIPActiveObj->lpVtbl->EnableModeless(
lpContainerApp->m_lpIPActiveObj, FALSE);
OLEDBG_END2
}
}
#endif // INPLACE_CNTR
}
lpOleApp->m_cModalDlgActive++;
}
/* OleApp_PostModalDialog
** ----------------------
** Keep track that a modal dialog is being brought down. this call
** balances the OleApp_PreModalDialog call.
*/
void OleApp_PostModalDialog(LPOLEAPP lpOleApp, LPOLEDOC lpOleDoc)
{
lpOleApp->m_cModalDlgActive--;
if (lpOleApp->m_cModalDlgActive == 0) {
// last modal dialog is being brought down
#if defined( USE_FRAMETOOLS )
LPFRAMETOOLS lptb;
if (lpOleDoc)
lptb = ((LPOUTLINEDOC)lpOleDoc)->m_lpFrameTools;
else
lptb = OutlineApp_GetFrameTools((LPOUTLINEAPP)lpOleApp);
if (lptb) {
FrameTools_EnableWindow(lptb, TRUE);
FrameTools_UpdateButtons(lptb, (LPOUTLINEDOC)lpOleDoc);
}
#endif // USE_FRAMETOOLS
OleApp_RejectInComingCalls(lpOleApp, FALSE);
#if defined( INPLACE_SVR )
{
LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc;
/* if the document bringing down the modal dialog is
** currently a UIActive in-place object, then tell the
** top-level in-place frame it can re-enable its
** modeless dialogs.
*/
if (lpServerDoc && lpServerDoc->m_fUIActive &&
lpServerDoc->m_lpIPData &&
lpServerDoc->m_lpIPData->lpFrame) {
OLEDBG_BEGIN2("IOleInPlaceFrame::EnableModless(TRUE) called\r\n");
lpServerDoc->m_lpIPData->lpFrame->lpVtbl->EnableModeless(
lpServerDoc->m_lpIPData->lpFrame, TRUE);
OLEDBG_END2
}
}
#endif // INPLACE_SVR
#if defined( INPLACE_CNTR )
{
LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)lpOleApp;
/* if the document bringing down the modal dialog is an
** in-place container that has a UIActive object, then
** tell the UIActive object it can re-enable its
** modeless dialogs.
*/
if (lpContainerApp->m_lpIPActiveObj) {
OLEDBG_BEGIN2("IOleInPlaceActiveObject::EnableModless(TRUE) called\r\n");
lpContainerApp->m_lpIPActiveObj->lpVtbl->EnableModeless(
lpContainerApp->m_lpIPActiveObj, TRUE);
OLEDBG_END2
}
}
#endif // INPLACE_CNTR
}
}
/* OleApp_InitVtbls
* ----------------
*
* initialize the methods in all of the interface Vtbl's
*
* OLE2NOTE: we only need one copy of each Vtbl. When an object which
* exposes an interface is instantiated, its lpVtbl is intialized
* to point to the single copy of the Vtbl.
*
*/
BOOL OleApp_InitVtbls (LPOLEAPP lpOleApp)
{
BOOL fStatus;
// OleApp::IUnknown method table
OleStdInitVtbl(&g_OleApp_UnknownVtbl, sizeof(IUnknownVtbl));
g_OleApp_UnknownVtbl.QueryInterface = OleApp_Unk_QueryInterface;
g_OleApp_UnknownVtbl.AddRef = OleApp_Unk_AddRef;
g_OleApp_UnknownVtbl.Release = OleApp_Unk_Release;
fStatus = OleStdCheckVtbl(
&g_OleApp_UnknownVtbl,
sizeof(IUnknownVtbl),
"IUnknown"
);
if (! fStatus) return FALSE;
// OleDoc::IUnknown method table
OleStdInitVtbl(&g_OleDoc_UnknownVtbl, sizeof(IUnknownVtbl));
g_OleDoc_UnknownVtbl.QueryInterface = OleDoc_Unk_QueryInterface;
g_OleDoc_UnknownVtbl.AddRef = OleDoc_Unk_AddRef;
g_OleDoc_UnknownVtbl.Release = OleDoc_Unk_Release;
fStatus = OleStdCheckVtbl(
&g_OleDoc_UnknownVtbl,
sizeof(IUnknownVtbl),
"IUnknown"
);
if (! fStatus) return FALSE;
// OleDoc::IPersistFile method table
OleStdInitVtbl(&g_OleDoc_PersistFileVtbl, sizeof(IPersistFileVtbl));
g_OleDoc_PersistFileVtbl.QueryInterface = OleDoc_PFile_QueryInterface;
g_OleDoc_PersistFileVtbl.AddRef = OleDoc_PFile_AddRef;
g_OleDoc_PersistFileVtbl.Release = OleDoc_PFile_Release;
g_OleDoc_PersistFileVtbl.GetClassID = OleDoc_PFile_GetClassID;
g_OleDoc_PersistFileVtbl.IsDirty = OleDoc_PFile_IsDirty;
g_OleDoc_PersistFileVtbl.Load = OleDoc_PFile_Load;
g_OleDoc_PersistFileVtbl.Save = OleDoc_PFile_Save;
g_OleDoc_PersistFileVtbl.SaveCompleted = OleDoc_PFile_SaveCompleted;
g_OleDoc_PersistFileVtbl.GetCurFile = OleDoc_PFile_GetCurFile;
fStatus = OleStdCheckVtbl(
&g_OleDoc_PersistFileVtbl,
sizeof(IPersistFileVtbl),
"IPersistFile"
);
if (! fStatus) return FALSE;
// OleDoc::IOleItemContainer method table
OleStdInitVtbl(&g_OleDoc_OleItemContainerVtbl, sizeof(IOleItemContainerVtbl));
g_OleDoc_OleItemContainerVtbl.QueryInterface =
OleDoc_ItemCont_QueryInterface;
g_OleDoc_OleItemContainerVtbl.AddRef = OleDoc_ItemCont_AddRef;
g_OleDoc_OleItemContainerVtbl.Release = OleDoc_ItemCont_Release;
g_OleDoc_OleItemContainerVtbl.ParseDisplayName =
OleDoc_ItemCont_ParseDisplayName;
g_OleDoc_OleItemContainerVtbl.EnumObjects= OleDoc_ItemCont_EnumObjects;
g_OleDoc_OleItemContainerVtbl.LockContainer =
OleDoc_ItemCont_LockContainer;
g_OleDoc_OleItemContainerVtbl.GetObject = OleDoc_ItemCont_GetObject;
g_OleDoc_OleItemContainerVtbl.GetObjectStorage =
OleDoc_ItemCont_GetObjectStorage;
g_OleDoc_OleItemContainerVtbl.IsRunning = OleDoc_ItemCont_IsRunning;
fStatus = OleStdCheckVtbl(
&g_OleDoc_OleItemContainerVtbl,
sizeof(IOleItemContainerVtbl),
"IOleItemContainer"
);
if (! fStatus) return FALSE;
// OleDoc::IExternalConnection method table
OleStdInitVtbl(
&g_OleDoc_ExternalConnectionVtbl,sizeof(IExternalConnectionVtbl));
g_OleDoc_ExternalConnectionVtbl.QueryInterface =
OleDoc_ExtConn_QueryInterface;
g_OleDoc_ExternalConnectionVtbl.AddRef = OleDoc_ExtConn_AddRef;
g_OleDoc_ExternalConnectionVtbl.Release = OleDoc_ExtConn_Release;
g_OleDoc_ExternalConnectionVtbl.AddConnection =
OleDoc_ExtConn_AddConnection;
g_OleDoc_ExternalConnectionVtbl.ReleaseConnection =
OleDoc_ExtConn_ReleaseConnection;
fStatus = OleStdCheckVtbl(
&g_OleDoc_ExternalConnectionVtbl,
sizeof(IExternalConnectionVtbl),
"IExternalConnection"
);
if (! fStatus) return FALSE;
// OleDoc::IDataObject method table
OleStdInitVtbl(&g_OleDoc_DataObjectVtbl, sizeof(IDataObjectVtbl));
g_OleDoc_DataObjectVtbl.QueryInterface = OleDoc_DataObj_QueryInterface;
g_OleDoc_DataObjectVtbl.AddRef = OleDoc_DataObj_AddRef;
g_OleDoc_DataObjectVtbl.Release = OleDoc_DataObj_Release;
g_OleDoc_DataObjectVtbl.GetData = OleDoc_DataObj_GetData;
g_OleDoc_DataObjectVtbl.GetDataHere = OleDoc_DataObj_GetDataHere;
g_OleDoc_DataObjectVtbl.QueryGetData = OleDoc_DataObj_QueryGetData;
g_OleDoc_DataObjectVtbl.GetCanonicalFormatEtc =
OleDoc_DataObj_GetCanonicalFormatEtc;
g_OleDoc_DataObjectVtbl.SetData = OleDoc_DataObj_SetData;
g_OleDoc_DataObjectVtbl.EnumFormatEtc = OleDoc_DataObj_EnumFormatEtc;
g_OleDoc_DataObjectVtbl.DAdvise = OleDoc_DataObj_DAdvise;
g_OleDoc_DataObjectVtbl.DUnadvise = OleDoc_DataObj_DUnadvise;
g_OleDoc_DataObjectVtbl.EnumDAdvise = OleDoc_DataObj_EnumDAdvise;
fStatus = OleStdCheckVtbl(
&g_OleDoc_DataObjectVtbl,
sizeof(IDataObjectVtbl),
"IDataObject"
);
if (! fStatus) return FALSE;
#if defined( USE_DRAGDROP )
// OleDoc::IDropTarget method table
OleStdInitVtbl(&g_OleDoc_DropTargetVtbl, sizeof(IDropTargetVtbl));
g_OleDoc_DropTargetVtbl.QueryInterface= OleDoc_DropTarget_QueryInterface;
g_OleDoc_DropTargetVtbl.AddRef = OleDoc_DropTarget_AddRef;
g_OleDoc_DropTargetVtbl.Release = OleDoc_DropTarget_Release;
g_OleDoc_DropTargetVtbl.DragEnter = OleDoc_DropTarget_DragEnter;
g_OleDoc_DropTargetVtbl.DragOver = OleDoc_DropTarget_DragOver;
g_OleDoc_DropTargetVtbl.DragLeave = OleDoc_DropTarget_DragLeave;
g_OleDoc_DropTargetVtbl.Drop = OleDoc_DropTarget_Drop;
fStatus = OleStdCheckVtbl(
&g_OleDoc_DropTargetVtbl,
sizeof(IDropTargetVtbl),
"IDropTarget"
);
if (! fStatus)
return FALSE;
// OleDoc::IDropSource method table
OleStdInitVtbl(&g_OleDoc_DropSourceVtbl, sizeof(IDropSourceVtbl));
g_OleDoc_DropSourceVtbl.QueryInterface =
OleDoc_DropSource_QueryInterface;
g_OleDoc_DropSourceVtbl.AddRef = OleDoc_DropSource_AddRef;
g_OleDoc_DropSourceVtbl.Release = OleDoc_DropSource_Release;
g_OleDoc_DropSourceVtbl.QueryContinueDrag =
OleDoc_DropSource_QueryContinueDrag;
g_OleDoc_DropSourceVtbl.GiveFeedback = OleDoc_DropSource_GiveFeedback;
fStatus = OleStdCheckVtbl(
&g_OleDoc_DropSourceVtbl,
sizeof(IDropSourceVtbl),
"IDropSource"
);
if (! fStatus) return FALSE;
#endif // USE_DRAGDROP
#if defined( OLE_SERVER )
// Initialize the server specific interface method tables.
if (! ServerApp_InitVtbls((LPSERVERAPP)lpOleApp))
return FALSE;
#endif
#if defined( OLE_CNTR )
// Initialize the container specific interface method tables.
if (! ContainerApp_InitVtbls((LPCONTAINERAPP)lpOleApp))
return FALSE;
#endif
return TRUE;
};
/* OleApp_InitMenu
* ---------------
*
* Enable or Disable menu items depending on the state of
* the appliation.
* The OLE versions of the Outline sample app add a PasteSpecial command.
* Also, the container version add InsertObject and ObjectVerb menu items.
*/
void OleApp_InitMenu(
LPOLEAPP lpOleApp,
LPOLEDOC lpOleDoc,
HMENU hMenu
)
{
BOOL bMsgFilterInstalled = FALSE;
BOOL bRejecting = FALSE;
if (!lpOleApp || !hMenu)
return;
OLEDBG_BEGIN3("OleApp_InitMenu\r\n")
/*
** Enable/disable menu items for Message Filter
*/
bMsgFilterInstalled = (lpOleApp->m_lpMsgFilter != NULL);
bRejecting = bMsgFilterInstalled &&
OleStdMsgFilter_GetInComingCallStatus(lpOleApp->m_lpMsgFilter) != SERVERCALL_ISHANDLED;
CheckMenuItem(hMenu,
IDM_D_INSTALLMSGFILTER,
bMsgFilterInstalled ? MF_CHECKED : MF_UNCHECKED);
EnableMenuItem(hMenu,
IDM_D_REJECTINCOMING,
bMsgFilterInstalled ? MF_ENABLED : MF_GRAYED);
CheckMenuItem(hMenu,
IDM_D_REJECTINCOMING,
bRejecting ? MF_CHECKED : MF_UNCHECKED);
#if defined( OLE_CNTR )
{
LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOleDoc;
BOOL fShowObject;
fShowObject = ContainerDoc_GetShowObjectFlag(lpContainerDoc);
CheckMenuItem(
hMenu,
IDM_O_SHOWOBJECT,
(fShowObject ? MF_CHECKED : MF_UNCHECKED)
);
#if defined( INPLACE_CNTR ) && defined( _DEBUG )
CheckMenuItem(
hMenu,
IDM_D_INSIDEOUT,
g_fInsideOutContainer ? MF_CHECKED:MF_UNCHECKED);
#endif // INPLACE_CNTR && _DEBUG
}
#endif // OLE_CNTR
OLEDBG_END3
}
/* OleApp_UpdateEditMenu
* ---------------------
*
* Purpose:
* Update the Edit menuitems of the App according to the state of
* OutlineDoc
*
* Parameter:
* lpOutlineDoc pointer to the document
* hMenuEdit edit menu handle
*/
void OleApp_UpdateEditMenu(
LPOLEAPP lpOleApp,
LPOUTLINEDOC lpOutlineDoc,
HMENU hMenuEdit
)
{
int nFmtEtc;
UINT uEnablePaste = MF_GRAYED;
UINT uEnablePasteLink = MF_GRAYED;
LPDATAOBJECT lpClipboardDataObj;
LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineDoc;
HRESULT hrErr;
BOOL fPrevEnable1;
BOOL fPrevEnable2;
if (!lpOleApp || !lpOutlineDoc || !hMenuEdit)
return;
if (!OleDoc_GetUpdateEditMenuFlag(lpOleDoc))
/* OLE2NOTE: if the flag is not set, we don't have to update
** the edit menu again. This blocks repetitive updating when
** the user move the mouse across Edit menu while holding
** down the button
*/
return;
OLEDBG_BEGIN3("OleApp_InitEditMenu\r\n")
/* OLE2NOTE: we do not want to ever give the busy dialog when we
** are trying to put up our menus. eg. even if the source of
** data on the clipboard is busy, we do not want put up the busy
** dialog. thus we will disable the dialog and at the end
** re-enable it.
*/
OleApp_DisableBusyDialogs(lpOleApp, &fPrevEnable1, &fPrevEnable2);
// check if there is data on the clipboard that we can paste/paste link
OLEDBG_BEGIN2("OleGetClipboard called\r\n")
hrErr = OleGetClipboard((LPDATAOBJECT FAR*)&lpClipboardDataObj);
OLEDBG_END2
if (hrErr == NOERROR) {
nFmtEtc = OleStdGetPriorityClipboardFormat(
lpClipboardDataObj,
lpOleApp->m_arrPasteEntries,
lpOleApp->m_nPasteEntries
);
if (nFmtEtc >= 0)
uEnablePaste = MF_ENABLED; // there IS a format we like
OLEDBG_BEGIN2("OleQueryLinkFromData called\r\n")
hrErr = OleQueryLinkFromData(lpClipboardDataObj);
OLEDBG_END2
if(hrErr == NOERROR)
uEnablePasteLink = MF_ENABLED;
OleStdRelease((LPUNKNOWN)lpClipboardDataObj);
}
EnableMenuItem(hMenuEdit, IDM_E_PASTE, uEnablePaste);
EnableMenuItem(hMenuEdit, IDM_E_PASTESPECIAL, uEnablePaste);
#if defined( OLE_CNTR )
if (ContainerDoc_GetNextLink((LPCONTAINERDOC)lpOutlineDoc, NULL))
EnableMenuItem(hMenuEdit, IDM_E_EDITLINKS, MF_ENABLED);
else
EnableMenuItem(hMenuEdit, IDM_E_EDITLINKS, MF_GRAYED);
{
LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)lpOleApp;
HMENU hMenuVerb = NULL;
LPOLEOBJECT lpOleObj = NULL;
LPCONTAINERLINE lpContainerLine = NULL;
BOOL fSelIsOleObject;
EnableMenuItem(hMenuEdit, IDM_E_PASTELINK, uEnablePasteLink);
/* check if selection is a single line that contains an OleObject */
fSelIsOleObject = ContainerDoc_IsSelAnOleObject(
(LPCONTAINERDOC)lpOutlineDoc,
&IID_IOleObject,
(LPUNKNOWN FAR*)&lpOleObj,
NULL, /* we don't need the line index */
(LPCONTAINERLINE FAR*)&lpContainerLine
);
if (hMenuEdit != NULL) {
/* If the current line is an ContainerLine, add the object
** verb sub menu to the Edit menu. if the line is not an
** ContainerLine, (lpOleObj==NULL) then disable the
** Edit.Object command. this helper API takes care of
** building the verb menu as appropriate.
*/
OleUIAddVerbMenu(
(LPOLEOBJECT)lpOleObj,
(lpContainerLine ? lpContainerLine->m_lpszShortType:NULL),
hMenuEdit,
POS_OBJECT,
IDM_E_OBJECTVERBMIN,
0, // no uIDVerbMax enforced
TRUE, // Add Convert menu item
IDM_E_CONVERTVERB, // ID for Convert menu item
(HMENU FAR*) &hMenuVerb
);
#if defined( USE_STATUSBAR_LATER )
/* setup status messages for the object verb menu */
if (hMenuVerb) {
// REVIEW: this string should come from a string resource.
// REVIEW: this doesn't work for dynamically created menus
AssignPopupMessage(
hMenuVerb,
"Open, edit or interact with an object"
);
}
#endif // USE_STATUSBAR_LATER
}
if (lpOleObj)
OleStdRelease((LPUNKNOWN)lpOleObj);
}
#endif // OLE_CNTR
// re-enable the Busy/NotResponding dialogs
OleApp_EnableBusyDialogs(lpOleApp, fPrevEnable1, fPrevEnable2);
OleDoc_SetUpdateEditMenuFlag(lpOleDoc, FALSE);
OLEDBG_END3
}
/* OleApp_RegisterClassFactory
* ---------------------------
*
* Register our app's ClassFactory with OLE.
*
*/
BOOL OleApp_RegisterClassFactory(LPOLEAPP lpOleApp)
{
HRESULT hrErr;
if (lpOleApp->m_lpClassFactory)
return TRUE; // already registered
OLEDBG_BEGIN3("OleApp_RegisterClassFactory\r\n")
/******************************************************************
** An SDI app must register its ClassFactory if it is launched
** for embedding (/Embedding command line option specified).
** An MDI app must register its ClassFactory in all cases,
******************************************************************/
lpOleApp->m_lpClassFactory = AppClassFactory_Create();
if (! lpOleApp->m_lpClassFactory) {
OutlineApp_ErrorMessage(g_lpApp, ErrMsgCreateCF);
goto error;
}
OLEDBG_BEGIN2("CoRegisterClassObject called\r\n")
hrErr = CoRegisterClassObject(
&CLSID_APP,
(LPUNKNOWN)lpOleApp->m_lpClassFactory,
CLSCTX_LOCAL_SERVER,
REGCLS_SINGLEUSE,
&lpOleApp->m_dwRegClassFac
);
OLEDBG_END2
if(hrErr != NOERROR) {
OleDbgOutHResult("CoRegisterClassObject returned", hrErr);
OutlineApp_ErrorMessage(g_lpApp, ErrMsgRegCF);
goto error;
}
OLEDBG_END3
return TRUE;
error:
if (lpOleApp->m_lpClassFactory) {
OleStdRelease((LPUNKNOWN)lpOleApp->m_lpClassFactory);
lpOleApp->m_lpClassFactory = NULL;
}
OLEDBG_END3
return FALSE;
}
/* OleApp_RevokeClassFactory
* -------------------------
*
* Revoke our app's ClassFactory.
*
*/
void OleApp_RevokeClassFactory(LPOLEAPP lpOleApp)
{
HRESULT hrErr;
if (lpOleApp->m_lpClassFactory) {
OLEDBG_BEGIN2("CoRevokeClassObject called\r\n")
hrErr = CoRevokeClassObject(lpOleApp->m_dwRegClassFac);
OLEDBG_END2
#if defined( _DEBUG )
if (hrErr != NOERROR) {
OleDbgOutHResult("CoRevokeClassObject returned", hrErr);
}
#endif
// we just release here; other folks may still have
// a pointer to our class factory, so we can't
// do any checks on the reference count.
OleStdRelease((LPUNKNOWN)lpOleApp->m_lpClassFactory);
lpOleApp->m_lpClassFactory = NULL;
}
}
#if defined( USE_MSGFILTER )
/* OleApp_RegisterMessageFilter
* ----------------------------
* Register our IMessageFilter*. the message filter is used to handle
* concurrency. we will use a standard implementation of IMessageFilter
* that is included as part of the OLE2UI library.
*/
BOOL OleApp_RegisterMessageFilter(LPOLEAPP lpOleApp)
{
HRESULT hrErr;
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
if (lpOleApp->m_lpMsgFilter == NULL) {
// Register our message filter.
lpOleApp->m_lpfnMsgPending = (MSGPENDINGPROC)MessagePendingProc;
lpOleApp->m_lpMsgFilter = OleStdMsgFilter_Create(
g_lpApp->m_hWndApp,
(LPSTR)APPNAME,
lpOleApp->m_lpfnMsgPending,
NULL /* Busy dialog callback hook function */
);
OLEDBG_BEGIN2("CoRegisterMessageFilter called\r\n")
hrErr = CoRegisterMessageFilter(
lpOleApp->m_lpMsgFilter,
NULL /* don't need previous message filter */
);
OLEDBG_END2
if(hrErr != NOERROR) {
OutlineApp_ErrorMessage(lpOutlineApp, ErrMsgRegMF);
return FALSE;
}
}
return TRUE;
}
/* OleApp_RevokeMessageFilter
* --------------------------
* Revoke our IMessageFilter*. the message filter is used to handle
* concurrency. we will use a standard implementation of IMessageFilter
* that is included as part of the OLE2UI library.
*/
void OleApp_RevokeMessageFilter(LPOLEAPP lpOleApp)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
if (lpOleApp->m_lpMsgFilter != NULL) {
// Revoke our message filter
OLEDBG_BEGIN2("CoRegisterMessageFilter(NULL) called\r\n")
CoRegisterMessageFilter(NULL, NULL);
OLEDBG_END2
if (lpOleApp->m_lpfnMsgPending) {
lpOleApp->m_lpfnMsgPending = NULL;
}
OleStdVerifyRelease(
(LPUNKNOWN)lpOleApp->m_lpMsgFilter,
"Release MessageFilter FAILED!"
);
lpOleApp->m_lpMsgFilter = NULL;
}
}
/* MessagePendingProc
* ------------------
*
* Callback function for the IMessageFilter::MessagePending procedure. This
* function is called when a message is received by our application while
* we are waiting for an OLE call to complete. We are essentially
* blocked at this point, waiting for a response from the other OLE application.
* We should not process any messages which might cause another OLE call
* to become blocked, or any other call which might cause re-entrancy problems.
*
* For this application, only process WM_PAINT messages. A more sophisticated
* application might allow certain menu messages and menu items to be processed
* also.
*
* RETURNS: TRUE if we processed the message, FALSE if we did not.
*/
BOOL FAR PASCAL EXPORT MessagePendingProc(MSG FAR *lpMsg)
{
// Our application is only handling WM_PAINT messages when we are blocked
switch (lpMsg->message) {
case WM_PAINT:
OleDbgOut2("WM_PAINT dispatched while blocked\r\n");
DispatchMessage(lpMsg);
break;
}
return FALSE; // return PENDINGMSG_WAITDEFPROCESS from MessagePending
}
#endif // USE_MSGFILTER
/* OleApp_FlushClipboard
* ---------------------
*
* Force the Windows clipboard to release our clipboard DataObject.
*/
void OleApp_FlushClipboard(LPOLEAPP lpOleApp)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
LPOLEDOC lpClipboardDoc = (LPOLEDOC)lpOutlineApp->m_lpClipboardDoc;
OLEDBG_BEGIN3("OleApp_FlushClipboard\r\n")
/* OLE2NOTE: if for some reason our clipboard data transfer
** document is still held on to by an external client, we want
** to forceably break all external connections.
*/
OLEDBG_BEGIN2("CoDisconnectObject called\r\n")
CoDisconnectObject((LPUNKNOWN)&lpClipboardDoc->m_Unknown, 0);
OLEDBG_END2
OLEDBG_BEGIN2("OleFlushClipboard called\r\n")
OleFlushClipboard();
OLEDBG_END2
lpOutlineApp->m_lpClipboardDoc = NULL;
OLEDBG_END3
}
/* OleApp_NewCommand
* -----------------
*
* Start a new untitled document (File.New command).
*/
void OleApp_NewCommand(LPOLEAPP lpOleApp)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
LPOUTLINEDOC lpOutlineDoc = lpOutlineApp->m_lpDoc;
if (! OutlineDoc_Close(lpOutlineDoc, OLECLOSE_PROMPTSAVE))
return;
OleDbgAssertSz(lpOutlineApp->m_lpDoc==NULL,"Closed doc NOT properly destroyed");
lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE);
if (! lpOutlineApp->m_lpDoc) goto error;
/* OLE2NOTE: initially the Doc object is created with a 0 ref
** count. in order to have a stable Doc object during the
** process of initializing the new Doc instance,
** we intially AddRef the Doc ref cnt and later
** Release it. This initial AddRef is artificial; it is simply
** done to guarantee that a harmless QueryInterface followed by
** a Release does not inadvertantly force our object to destroy
** itself prematurely.
*/
OleDoc_AddRef((LPOLEDOC)lpOutlineApp->m_lpDoc);
// set the doc to an (Untitled) doc.
if (! OutlineDoc_InitNewFile(lpOutlineApp->m_lpDoc))
goto error;
// position and size the new doc window
OutlineApp_ResizeWindows(lpOutlineApp);
OutlineDoc_ShowWindow(lpOutlineApp->m_lpDoc); // calls OleDoc_Lock
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc); // rel artificial AddRef
return;
error:
// REVIEW: should load string from string resource
OutlineApp_ErrorMessage(lpOutlineApp, "Could not create new document");
if (lpOutlineApp->m_lpDoc) {
// releasing the artificial AddRef above will destroy the document
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc);
lpOutlineApp->m_lpDoc = NULL;
}
return;
}
/* OleApp_OpenCommand
* ------------------
*
* Load a document from file (File.Open command).
*/
void OleApp_OpenCommand(LPOLEAPP lpOleApp)
{
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpOleApp;
LPOUTLINEDOC lpOutlineDoc = lpOutlineApp->m_lpDoc;
OPENFILENAME ofn;
char szFilter[]=APPFILENAMEFILTER;
char szFileName[256];
UINT i;
DWORD dwSaveOption = OLECLOSE_PROMPTSAVE;
BOOL fStatus = TRUE;
if (! OutlineDoc_CheckSaveChanges(lpOutlineDoc, &dwSaveOption))
return; // abort opening new doc
for(i=0; szFilter[i]; i++)
if(szFilter[i]=='|') szFilter[i]='\0';
_fmemset((LPOPENFILENAME)&ofn,0,sizeof(OPENFILENAME));
szFileName[0]='\0';
ofn.lStructSize=sizeof(OPENFILENAME);
ofn.hwndOwner=lpOutlineApp->m_hWndApp;
ofn.lpstrFilter=(LPSTR)szFilter;
ofn.lpstrFile=(LPSTR)szFileName;
ofn.nMaxFile=sizeof(szFileName);
ofn.Flags=OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
ofn.lpstrDefExt=DEFEXTENSION;
OleApp_PreModalDialog(lpOleApp, (LPOLEDOC)lpOutlineApp->m_lpDoc);
fStatus = GetOpenFileName((LPOPENFILENAME)&ofn);
OleApp_PostModalDialog(lpOleApp, (LPOLEDOC)lpOutlineApp->m_lpDoc);
if(! fStatus)
return; // user canceled file open dialog
OutlineDoc_Close(lpOutlineDoc, OLECLOSE_NOSAVE);
OleDbgAssertSz(lpOutlineApp->m_lpDoc==NULL,"Closed doc NOT properly destroyed");
lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE);
if (! lpOutlineApp->m_lpDoc) goto error;
/* OLE2NOTE: initially the Doc object is created with a 0 ref
** count. in order to have a stable Doc object during the
** process of initializing the new Doc instance,
** we intially AddRef the Doc ref cnt and later
** Release it. This initial AddRef is artificial; it is simply
** done to guarantee that a harmless QueryInterface followed by
** a Release does not inadvertantly force our object to destroy
** itself prematurely.
*/
OleDoc_AddRef((LPOLEDOC)lpOutlineApp->m_lpDoc);
fStatus=OutlineDoc_LoadFromFile(lpOutlineApp->m_lpDoc, (LPSTR)szFileName);
if (! fStatus) {
// loading the doc failed; create an untitled instead
// releasing the artificial AddRef above will destroy the document
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc);
lpOutlineApp->m_lpDoc = OutlineApp_CreateDoc(lpOutlineApp, FALSE);
if (! lpOutlineApp->m_lpDoc) goto error;
OleDoc_AddRef((LPOLEDOC)lpOutlineApp->m_lpDoc);
if (! OutlineDoc_InitNewFile(lpOutlineApp->m_lpDoc))
goto error;
}
// position and size the new doc window
OutlineApp_ResizeWindows(lpOutlineApp);
OutlineDoc_ShowWindow(lpOutlineApp->m_lpDoc);
#if defined( OLE_CNTR )
UpdateWindow(lpOutlineApp->m_hWndApp);
ContainerDoc_UpdateLinks((LPCONTAINERDOC)lpOutlineApp->m_lpDoc);
#endif
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc); // rel artificial AddRef
return;
error:
// REVIEW: should load string from string resource
OutlineApp_ErrorMessage(lpOutlineApp, "Could not create new document");
if (lpOutlineApp->m_lpDoc) {
// releasing the artificial AddRef above will destroy the document
OleDoc_Release((LPOLEDOC)lpOutlineApp->m_lpDoc);
lpOutlineApp->m_lpDoc = NULL;
}
return;
}
#if defined( OLE_CNTR )
/* OLE2NOTE: forward the WM_QUERYNEWPALETTE message (via
** SendMessage) to UIActive in-place object if there is one.
** this gives the UIActive object the opportunity to select
** and realize its color palette as the FOREGROUND palette.
** this is optional for in-place containers. if a container
** prefers to force its color palette as the foreground
** palette then it should NOT forward the this message. or
** the container can give the UIActive object priority; if
** the UIActive object returns 0 from the WM_QUERYNEWPALETTE
** message (ie. it did not realize its own palette), then
** the container can realize its palette.
** (see ContainerDoc_ForwardPaletteChangedMsg for more info)
**
** (It is a good idea for containers to use the standard
** palette even if they do not use colors themselves. this
** will allow embedded object to get a good distribution of
** colors when they are being drawn by the container)
**
*/
LRESULT OleApp_QueryNewPalette(LPOLEAPP lpOleApp)
{
#if defined( INPLACE_CNTR )
LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)lpOleApp;
if (lpContainerApp && lpContainerApp->m_hWndUIActiveObj) {
if (SendMessage(lpContainerApp->m_hWndUIActiveObj, WM_QUERYNEWPALETTE,
(WPARAM)0, (LPARAM)0)) {
/* Object selected its palette as foreground palette */
return (LRESULT)1;
}
}
#endif // INPLACE_CNTR
return wSelectPalette(((LPOUTLINEAPP)lpOleApp)->m_hWndApp,
lpOleApp->m_hStdPal, FALSE/*fBackground*/);
}
#endif // OLE_CNTR
/* This is just a helper routine */
LRESULT wSelectPalette(HWND hWnd, HPALETTE hPal, BOOL fBackground)
{
HDC hdc;
HPALETTE hOldPal;
UINT iPalChg = 0;
if (hPal == 0)
return (LRESULT)0;
hdc = GetDC(hWnd);
hOldPal = SelectPalette(hdc, hPal, fBackground);
iPalChg = RealizePalette(hdc);
SelectPalette(hdc, hOldPal, TRUE /*fBackground*/);
ReleaseDC(hWnd, hdc);
if (iPalChg > 0)
InvalidateRect(hWnd, NULL, TRUE);
return (LRESULT)1;
}
/*************************************************************************
** OleApp::IUnknown interface implementation
*************************************************************************/
STDMETHODIMP OleApp_Unk_QueryInterface(
LPUNKNOWN lpThis,
REFIID riid,
LPVOID FAR* lplpvObj
)
{
LPOLEAPP lpOleApp = ((struct CAppUnknownImpl FAR*)lpThis)->lpOleApp;
return OleApp_QueryInterface(lpOleApp, riid, lplpvObj);
}
STDMETHODIMP_(ULONG) OleApp_Unk_AddRef(LPUNKNOWN lpThis)
{
LPOLEAPP lpOleApp = ((struct CAppUnknownImpl FAR*)lpThis)->lpOleApp;
OleDbgAddRefMethod(lpThis, "IUnknown");
return OleApp_AddRef(lpOleApp);
}
STDMETHODIMP_(ULONG) OleApp_Unk_Release (LPUNKNOWN lpThis)
{
LPOLEAPP lpOleApp = ((struct CAppUnknownImpl FAR*)lpThis)->lpOleApp;
OleDbgReleaseMethod(lpThis, "IUnknown");
return OleApp_Release(lpOleApp);
}
#if defined( OLE_SERVER )
/*************************************************************************
** ServerDoc Supprt Functions Used by Server versions
*************************************************************************/
/* ServerApp_InitInstance
* ----------------------
*
* Initialize the app instance by creating the main frame window and
* performing app instance specific initializations
* (eg. initializing interface Vtbls).
*
* RETURNS: TRUE if the memory could be allocated, and the server app
* was properly initialized.
* FALSE otherwise
*
*/
BOOL ServerApp_InitInstance(
LPSERVERAPP lpServerApp,
HINSTANCE hInst,
int nCmdShow
)
{
LPOLEAPP lpOleApp = (LPOLEAPP)lpServerApp;
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpServerApp;
/* Setup arrays used by IDataObject::EnumFormatEtc.
**
** OLE2NOTE: The order that the formats are listed for GetData is very
** significant. It should be listed in order of highest fidelity
** formats to least fidelity formats. A common ordering will be:
** 1. private app formats
** 2. EmbedSource
** 3. lower fidelity interchange formats
** 4. pictures (metafile, dib, etc.)
** (graphic-related apps offer pictures 1st!)
** 5. LinkSource
*/
/* m_arrDocGetFmts array enumerates the formats that a ServerDoc
** DataTransferDoc object can offer (give) through a
** IDataObject::GetData call. a ServerDoc DataTransferDoc offers
** data formats in the following order:
** 1. CF_OUTLINE
** 2. CF_EMBEDSOURCE
** 3. CF_OBJECTDESCRIPTOR
** 4. CF_TEXT
** 5. CF_METAFILEPICT
** 6. CF_LINKSOURCE *
** 7. CF_LINKSRCDESCRIPTOR *
**
** * NOTE: CF_LINKSOURCE and CF_LINKSRCDESCRIPTOR is only
** offered if the doc is able to give
** a Moniker which references the data. CF_LINKSOURCE is
** deliberately listed last in this array of possible formats.
** if the doc does not have a Moniker then the last element of
** this array is not used. (see SvrDoc_DataObj_EnumFormatEtc).
**
** NOTE: The list of formats that a USER ServerDoc document can
** offer is a static list and is registered in the registration
** database for the SVROUTL class. The
** IDataObject::EnumFormatEtc method returns OLE_S_USEREG in the
** case the document is a user docuemt (ie. created via
** File.New, File.Open, InsertObject in a container, or
** IPersistFile::Load during binding a link source). this tells
** OLE to enumerate the formats automatically using the data the
** the REGDB.
*/
lpOleApp->m_arrDocGetFmts[0].cfFormat = lpOutlineApp->m_cfOutline;
lpOleApp->m_arrDocGetFmts[0].ptd = NULL;
lpOleApp->m_arrDocGetFmts[0].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[0].tymed = TYMED_HGLOBAL;
lpOleApp->m_arrDocGetFmts[0].lindex = -1;
lpOleApp->m_arrDocGetFmts[1].cfFormat = lpOleApp->m_cfEmbedSource;
lpOleApp->m_arrDocGetFmts[1].ptd = NULL;
lpOleApp->m_arrDocGetFmts[1].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[1].tymed = TYMED_ISTORAGE;
lpOleApp->m_arrDocGetFmts[1].lindex = -1;
lpOleApp->m_arrDocGetFmts[2].cfFormat = CF_TEXT;
lpOleApp->m_arrDocGetFmts[2].ptd = NULL;
lpOleApp->m_arrDocGetFmts[2].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[2].tymed = TYMED_HGLOBAL;
lpOleApp->m_arrDocGetFmts[2].lindex = -1;
lpOleApp->m_arrDocGetFmts[3].cfFormat = CF_METAFILEPICT;
lpOleApp->m_arrDocGetFmts[3].ptd = NULL;
lpOleApp->m_arrDocGetFmts[3].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[3].tymed = TYMED_MFPICT;
lpOleApp->m_arrDocGetFmts[3].lindex = -1;
lpOleApp->m_arrDocGetFmts[4].cfFormat = lpOleApp->m_cfObjectDescriptor;
lpOleApp->m_arrDocGetFmts[4].ptd = NULL;
lpOleApp->m_arrDocGetFmts[4].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[4].tymed = TYMED_HGLOBAL;
lpOleApp->m_arrDocGetFmts[4].lindex = -1;
lpOleApp->m_arrDocGetFmts[5].cfFormat = lpOleApp->m_cfLinkSource;
lpOleApp->m_arrDocGetFmts[5].ptd = NULL;
lpOleApp->m_arrDocGetFmts[5].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[5].tymed = TYMED_ISTREAM;
lpOleApp->m_arrDocGetFmts[5].lindex = -1;
lpOleApp->m_arrDocGetFmts[6].cfFormat = lpOleApp->m_cfLinkSrcDescriptor;
lpOleApp->m_arrDocGetFmts[6].ptd = NULL;
lpOleApp->m_arrDocGetFmts[6].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[6].tymed = TYMED_HGLOBAL;
lpOleApp->m_arrDocGetFmts[6].lindex = -1;
lpOleApp->m_nDocGetFmts = 7;
/* m_arrPasteEntries array enumerates the formats that a ServerDoc
** object can accept (get) from the clipboard.
** The formats are listed in priority order.
** ServerDoc accept data formats in the following order:
** 1. CF_OUTLINE
** 2. CF_TEXT
*/
// REVIEW: strings should be loaded from string resource
lpOleApp->m_arrPasteEntries[0].fmtetc.cfFormat =lpOutlineApp->m_cfOutline;
lpOleApp->m_arrPasteEntries[0].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[0].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[0].fmtetc.tymed = TYMED_HGLOBAL;
lpOleApp->m_arrPasteEntries[0].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[0].lpstrFormatName = "Outline Data";
lpOleApp->m_arrPasteEntries[0].lpstrResultText = "Outline Data";
lpOleApp->m_arrPasteEntries[0].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_arrPasteEntries[1].fmtetc.cfFormat = CF_TEXT;
lpOleApp->m_arrPasteEntries[1].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[1].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[1].fmtetc.tymed = TYMED_HGLOBAL;
lpOleApp->m_arrPasteEntries[1].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[1].lpstrFormatName = "Text";
lpOleApp->m_arrPasteEntries[1].lpstrResultText = "text";
lpOleApp->m_arrPasteEntries[1].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_nPasteEntries = 2;
/** m_arrLinkTypes array enumerates the link types that a ServerDoc
** object can accept from the clipboard. ServerDoc does NOT
** accept any type of link from the clipboard. ServerDoc can
** only be the source of a link. it can not contain links.
*/
lpOleApp->m_nLinkTypes = 0;
#if defined( INPLACE_SVR )
lpServerApp->m_hAccelBaseApp = NULL;
lpServerApp->m_hAccelIPSvr = LoadAccelerators(
hInst,
"InPlaceSvrOutlAccel"
);
lpServerApp->m_lpIPData = NULL;
lpServerApp->m_hMenuEdit = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_EDITMENU
);
lpServerApp->m_hMenuLine = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_LINEMENU
);
lpServerApp->m_hMenuName = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_NAMEMENU
);
lpServerApp->m_hMenuOptions = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_OPTIONSMENU
);
lpServerApp->m_hMenuDebug = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_DEBUGMENU
);
lpServerApp->m_hMenuHelp = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_HELPMENU
);
#endif // INPLACE_SVR
return TRUE;
}
/* ServerApp_InitVtbls
* -------------------
*
* initialize the methods in all of the interface Vtbl's
*
* OLE2NOTE: we only need one copy of each Vtbl. When an object which
* exposes an interface is instantiated, its lpVtbl is intialized
* to point to the single copy of the Vtbl.
*
*/
BOOL ServerApp_InitVtbls (LPSERVERAPP lpServerApp)
{
BOOL fStatus;
// ServerDoc::IOleObject method table
OleStdInitVtbl(&g_SvrDoc_OleObjectVtbl, sizeof(IOleObjectVtbl));
g_SvrDoc_OleObjectVtbl.QueryInterface = SvrDoc_OleObj_QueryInterface;
g_SvrDoc_OleObjectVtbl.AddRef = SvrDoc_OleObj_AddRef;
g_SvrDoc_OleObjectVtbl.Release = SvrDoc_OleObj_Release;
g_SvrDoc_OleObjectVtbl.SetClientSite = SvrDoc_OleObj_SetClientSite;
g_SvrDoc_OleObjectVtbl.GetClientSite = SvrDoc_OleObj_GetClientSite;
g_SvrDoc_OleObjectVtbl.SetHostNames = SvrDoc_OleObj_SetHostNames;
g_SvrDoc_OleObjectVtbl.Close = SvrDoc_OleObj_Close;
g_SvrDoc_OleObjectVtbl.SetMoniker = SvrDoc_OleObj_SetMoniker;
g_SvrDoc_OleObjectVtbl.GetMoniker = SvrDoc_OleObj_GetMoniker;
g_SvrDoc_OleObjectVtbl.InitFromData = SvrDoc_OleObj_InitFromData;
g_SvrDoc_OleObjectVtbl.GetClipboardData = SvrDoc_OleObj_GetClipboardData;
g_SvrDoc_OleObjectVtbl.DoVerb = SvrDoc_OleObj_DoVerb;
g_SvrDoc_OleObjectVtbl.EnumVerbs = SvrDoc_OleObj_EnumVerbs;
g_SvrDoc_OleObjectVtbl.Update = SvrDoc_OleObj_Update;
g_SvrDoc_OleObjectVtbl.IsUpToDate = SvrDoc_OleObj_IsUpToDate;
g_SvrDoc_OleObjectVtbl.GetUserClassID = SvrDoc_OleObj_GetUserClassID;
g_SvrDoc_OleObjectVtbl.GetUserType = SvrDoc_OleObj_GetUserType;
g_SvrDoc_OleObjectVtbl.SetExtent = SvrDoc_OleObj_SetExtent;
g_SvrDoc_OleObjectVtbl.GetExtent = SvrDoc_OleObj_GetExtent;
g_SvrDoc_OleObjectVtbl.Advise = SvrDoc_OleObj_Advise;
g_SvrDoc_OleObjectVtbl.Unadvise = SvrDoc_OleObj_Unadvise;
g_SvrDoc_OleObjectVtbl.EnumAdvise = SvrDoc_OleObj_EnumAdvise;
g_SvrDoc_OleObjectVtbl.GetMiscStatus = SvrDoc_OleObj_GetMiscStatus;
g_SvrDoc_OleObjectVtbl.SetColorScheme = SvrDoc_OleObj_SetColorScheme;
fStatus = OleStdCheckVtbl(
&g_SvrDoc_OleObjectVtbl,
sizeof(IOleObjectVtbl),
"IOleObject"
);
if (! fStatus) return FALSE;
// ServerDoc::IPersistStorage method table
OleStdInitVtbl(&g_SvrDoc_PersistStorageVtbl, sizeof(IPersistStorageVtbl));
g_SvrDoc_PersistStorageVtbl.QueryInterface = SvrDoc_PStg_QueryInterface;
g_SvrDoc_PersistStorageVtbl.AddRef = SvrDoc_PStg_AddRef;
g_SvrDoc_PersistStorageVtbl.Release = SvrDoc_PStg_Release;
g_SvrDoc_PersistStorageVtbl.GetClassID = SvrDoc_PStg_GetClassID;
g_SvrDoc_PersistStorageVtbl.IsDirty = SvrDoc_PStg_IsDirty;
g_SvrDoc_PersistStorageVtbl.InitNew = SvrDoc_PStg_InitNew;
g_SvrDoc_PersistStorageVtbl.Load = SvrDoc_PStg_Load;
g_SvrDoc_PersistStorageVtbl.Save = SvrDoc_PStg_Save;
g_SvrDoc_PersistStorageVtbl.SaveCompleted = SvrDoc_PStg_SaveCompleted;
g_SvrDoc_PersistStorageVtbl.HandsOffStorage = SvrDoc_PStg_HandsOffStorage;
fStatus = OleStdCheckVtbl(
&g_SvrDoc_PersistStorageVtbl,
sizeof(IPersistStorageVtbl),
"IPersistStorage"
);
if (! fStatus) return FALSE;
#if defined( SVR_TREATAS )
// ServerDoc::IStdMarshalInfo method table
OleStdInitVtbl(
&g_SvrDoc_StdMarshalInfoVtbl, sizeof(IStdMarshalInfoVtbl));
g_SvrDoc_StdMarshalInfoVtbl.QueryInterface =
SvrDoc_StdMshl_QueryInterface;
g_SvrDoc_StdMarshalInfoVtbl.AddRef = SvrDoc_StdMshl_AddRef;
g_SvrDoc_StdMarshalInfoVtbl.Release = SvrDoc_StdMshl_Release;
g_SvrDoc_StdMarshalInfoVtbl.GetClassForHandler =
SvrDoc_StdMshl_GetClassForHandler;
fStatus = OleStdCheckVtbl(
&g_SvrDoc_StdMarshalInfoVtbl,
sizeof(IStdMarshalInfoVtbl),
"IStdMarshalInfo"
);
if (! fStatus) return FALSE;
#endif // SVR_TREATAS
#if defined( INPLACE_SVR )
// ServerDoc::IOleInPlaceObject method table
OleStdInitVtbl(
&g_SvrDoc_OleInPlaceObjectVtbl,
sizeof(IOleInPlaceObjectVtbl)
);
g_SvrDoc_OleInPlaceObjectVtbl.QueryInterface
= SvrDoc_IPObj_QueryInterface;
g_SvrDoc_OleInPlaceObjectVtbl.AddRef
= SvrDoc_IPObj_AddRef;
g_SvrDoc_OleInPlaceObjectVtbl.Release
= SvrDoc_IPObj_Release;
g_SvrDoc_OleInPlaceObjectVtbl.GetWindow
= SvrDoc_IPObj_GetWindow;
g_SvrDoc_OleInPlaceObjectVtbl.ContextSensitiveHelp
= SvrDoc_IPObj_ContextSensitiveHelp;
g_SvrDoc_OleInPlaceObjectVtbl.InPlaceDeactivate
= SvrDoc_IPObj_InPlaceDeactivate;
g_SvrDoc_OleInPlaceObjectVtbl.UIDeactivate
= SvrDoc_IPObj_UIDeactivate;
g_SvrDoc_OleInPlaceObjectVtbl.SetObjectRects
= SvrDoc_IPObj_SetObjectRects;
g_SvrDoc_OleInPlaceObjectVtbl.ReactivateAndUndo
= SvrDoc_IPObj_ReactivateAndUndo;
fStatus = OleStdCheckVtbl(
&g_SvrDoc_OleInPlaceObjectVtbl,
sizeof(IOleInPlaceObjectVtbl),
"IOleInPlaceObject"
);
if (! fStatus) return FALSE;
// ServerDoc::IOleInPlaceActiveObject method table
OleStdInitVtbl(
&g_SvrDoc_OleInPlaceActiveObjectVtbl,
sizeof(IOleInPlaceActiveObjectVtbl)
);
g_SvrDoc_OleInPlaceActiveObjectVtbl.QueryInterface
= SvrDoc_IPActiveObj_QueryInterface;
g_SvrDoc_OleInPlaceActiveObjectVtbl.AddRef
= SvrDoc_IPActiveObj_AddRef;
g_SvrDoc_OleInPlaceActiveObjectVtbl.Release
= SvrDoc_IPActiveObj_Release;
g_SvrDoc_OleInPlaceActiveObjectVtbl.GetWindow
= SvrDoc_IPActiveObj_GetWindow;
g_SvrDoc_OleInPlaceActiveObjectVtbl.ContextSensitiveHelp
= SvrDoc_IPActiveObj_ContextSensitiveHelp;
g_SvrDoc_OleInPlaceActiveObjectVtbl.TranslateAccelerator
= SvrDoc_IPActiveObj_TranslateAccelerator;
g_SvrDoc_OleInPlaceActiveObjectVtbl.OnFrameWindowActivate
= SvrDoc_IPActiveObj_OnFrameWindowActivate;
g_SvrDoc_OleInPlaceActiveObjectVtbl.OnDocWindowActivate
= SvrDoc_IPActiveObj_OnDocWindowActivate;
g_SvrDoc_OleInPlaceActiveObjectVtbl.ResizeBorder
= SvrDoc_IPActiveObj_ResizeBorder;
g_SvrDoc_OleInPlaceActiveObjectVtbl.EnableModeless
= SvrDoc_IPActiveObj_EnableModeless;
fStatus = OleStdCheckVtbl(
&g_SvrDoc_OleInPlaceActiveObjectVtbl,
sizeof(IOleInPlaceActiveObjectVtbl),
"IOleInPlaceActiveObject"
);
if (! fStatus) return FALSE;
#endif
// PseudoObj::IUnknown method table
OleStdInitVtbl(&g_PseudoObj_UnknownVtbl, sizeof(IUnknownVtbl));
g_PseudoObj_UnknownVtbl.QueryInterface = PseudoObj_Unk_QueryInterface;
g_PseudoObj_UnknownVtbl.AddRef = PseudoObj_Unk_AddRef;
g_PseudoObj_UnknownVtbl.Release = PseudoObj_Unk_Release;
fStatus = OleStdCheckVtbl(
&g_PseudoObj_UnknownVtbl,
sizeof(IUnknownVtbl),
"IUnknown"
);
if (! fStatus) return FALSE;
// PseudoObj::IOleObject method table
OleStdInitVtbl(&g_PseudoObj_OleObjectVtbl, sizeof(IOleObjectVtbl));
g_PseudoObj_OleObjectVtbl.QueryInterface= PseudoObj_OleObj_QueryInterface;
g_PseudoObj_OleObjectVtbl.AddRef = PseudoObj_OleObj_AddRef;
g_PseudoObj_OleObjectVtbl.Release = PseudoObj_OleObj_Release;
g_PseudoObj_OleObjectVtbl.SetClientSite = PseudoObj_OleObj_SetClientSite;
g_PseudoObj_OleObjectVtbl.GetClientSite = PseudoObj_OleObj_GetClientSite;
g_PseudoObj_OleObjectVtbl.SetHostNames = PseudoObj_OleObj_SetHostNames;
g_PseudoObj_OleObjectVtbl.Close = PseudoObj_OleObj_Close;
g_PseudoObj_OleObjectVtbl.SetMoniker = PseudoObj_OleObj_SetMoniker;
g_PseudoObj_OleObjectVtbl.GetMoniker = PseudoObj_OleObj_GetMoniker;
g_PseudoObj_OleObjectVtbl.InitFromData = PseudoObj_OleObj_InitFromData;
g_PseudoObj_OleObjectVtbl.GetClipboardData =
PseudoObj_OleObj_GetClipboardData;
g_PseudoObj_OleObjectVtbl.DoVerb = PseudoObj_OleObj_DoVerb;
g_PseudoObj_OleObjectVtbl.EnumVerbs = PseudoObj_OleObj_EnumVerbs;
g_PseudoObj_OleObjectVtbl.Update = PseudoObj_OleObj_Update;
g_PseudoObj_OleObjectVtbl.IsUpToDate = PseudoObj_OleObj_IsUpToDate;
g_PseudoObj_OleObjectVtbl.GetUserType = PseudoObj_OleObj_GetUserType;
g_PseudoObj_OleObjectVtbl.GetUserClassID= PseudoObj_OleObj_GetUserClassID;
g_PseudoObj_OleObjectVtbl.SetExtent = PseudoObj_OleObj_SetExtent;
g_PseudoObj_OleObjectVtbl.GetExtent = PseudoObj_OleObj_GetExtent;
g_PseudoObj_OleObjectVtbl.Advise = PseudoObj_OleObj_Advise;
g_PseudoObj_OleObjectVtbl.Unadvise = PseudoObj_OleObj_Unadvise;
g_PseudoObj_OleObjectVtbl.EnumAdvise = PseudoObj_OleObj_EnumAdvise;
g_PseudoObj_OleObjectVtbl.GetMiscStatus = PseudoObj_OleObj_GetMiscStatus;
g_PseudoObj_OleObjectVtbl.SetColorScheme= PseudoObj_OleObj_SetColorScheme;
fStatus = OleStdCheckVtbl(
&g_PseudoObj_OleObjectVtbl,
sizeof(IOleObjectVtbl),
"IOleObject"
);
if (! fStatus) return FALSE;
// ServerDoc::IDataObject method table
OleStdInitVtbl(&g_PseudoObj_DataObjectVtbl, sizeof(IDataObjectVtbl));
g_PseudoObj_DataObjectVtbl.QueryInterface =
PseudoObj_DataObj_QueryInterface;
g_PseudoObj_DataObjectVtbl.AddRef = PseudoObj_DataObj_AddRef;
g_PseudoObj_DataObjectVtbl.Release = PseudoObj_DataObj_Release;
g_PseudoObj_DataObjectVtbl.GetData = PseudoObj_DataObj_GetData;
g_PseudoObj_DataObjectVtbl.GetDataHere = PseudoObj_DataObj_GetDataHere;
g_PseudoObj_DataObjectVtbl.QueryGetData = PseudoObj_DataObj_QueryGetData;
g_PseudoObj_DataObjectVtbl.GetCanonicalFormatEtc =
PseudoObj_DataObj_GetCanonicalFormatEtc;
g_PseudoObj_DataObjectVtbl.SetData = PseudoObj_DataObj_SetData;
g_PseudoObj_DataObjectVtbl.EnumFormatEtc= PseudoObj_DataObj_EnumFormatEtc;
g_PseudoObj_DataObjectVtbl.DAdvise = PseudoObj_DataObj_DAdvise;
g_PseudoObj_DataObjectVtbl.DUnadvise = PseudoObj_DataObj_DUnadvise;
g_PseudoObj_DataObjectVtbl.EnumDAdvise = PseudoObj_DataObj_EnumAdvise;
fStatus = OleStdCheckVtbl(
&g_PseudoObj_DataObjectVtbl,
sizeof(IDataObjectVtbl),
"IDataObject"
);
if (! fStatus) return FALSE;
return TRUE;
}
#endif // OLE_SERVER
#if defined( OLE_CNTR )
/*************************************************************************
** ContainerDoc Supprt Functions Used by Container versions
*************************************************************************/
/* ContainerApp_InitInstance
* -------------------------
*
* Initialize the app instance by creating the main frame window and
* performing app instance specific initializations
* (eg. initializing interface Vtbls).
*
* RETURNS: TRUE if the memory could be allocated, and the server app
* was properly initialized.
* FALSE otherwise
*
*/
BOOL ContainerApp_InitInstance(
LPCONTAINERAPP lpContainerApp,
HINSTANCE hInst,
int nCmdShow
)
{
LPOLEAPP lpOleApp = (LPOLEAPP)lpContainerApp;
LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)lpContainerApp;
lpContainerApp->m_cfCntrOutl=RegisterClipboardFormat(CONTAINERDOCFORMAT);
if(! lpContainerApp->m_cfCntrOutl) {
// REVIEW: should load string from string resource
OutlineApp_ErrorMessage(lpOutlineApp, "Can't register clipboard format!");
return FALSE;
}
#if defined( INPLACE_CNTR )
lpContainerApp->m_fPendingUIDeactivate = FALSE;
lpContainerApp->m_fMustResizeClientArea = FALSE;
lpContainerApp->m_lpIPActiveObj = NULL;
lpContainerApp->m_hWndUIActiveObj = NULL;
lpContainerApp->m_hAccelIPCntr = LoadAccelerators(
hInst,
"InPlaceCntrOutlAccel"
);
lpContainerApp->m_hMenuFile = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_FILEMENU
);
lpContainerApp->m_hMenuView = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_VIEWMENU
);
lpContainerApp->m_hMenuDebug = GetSubMenu (
lpOutlineApp->m_hMenuApp,
POS_DEBUGMENU
);
INIT_INTERFACEIMPL(
&lpContainerApp->m_OleInPlaceFrame,
&g_CntrApp_OleInPlaceFrameVtbl,
lpContainerApp
);
#endif
/* Setup arrays used by IDataObject::EnumFormatEtc. This is used to
** support copy/paste and drag/drop operations.
**
** OLE2NOTE: The order that the formats are listed for GetData is very
** significant. It should be listed in order of highest fidelity
** formats to least fidelity formats. A common ordering will be:
** 1. private app formats
** 2. CF_EMBEDSOURCE or CF_EMBEDOBJECT (as appropriate)
** 3. lower fidelity interchange formats
** 4. CF_METAFILEPICT
** (graphic-related apps might offer picture 1st!)
** 5. CF_OBJECTDESCRIPTOR
** 6. CF_LINKSOURCE
** 6. CF_LINKSRCDESCRIPTOR
*/
/* m_arrDocGetFmts array enumerates the formats that a ContainerDoc
** object can offer (give) through a IDataObject::GetData call
** when the selection copied is NOT a single embedded object.
** when a single embedded object this list of formats available
** is built dynamically depending on the object copied. (see
** ContainerDoc_SetupDocGetFmts).
** The formats are listed in priority order.
** ContainerDoc objects accept data formats in the following order:
** 1. CF_CNTROUTL
** 2. CF_OUTLINE
** 3. CF_TEXT
** 4. CF_OBJECTDESCRIPTOR
**
** OLE2NOTE: CF_OBJECTDESCRIPTOR format is used to describe the
** data on the clipboard. this information is intended to be
** used, for example, to drive the PasteSpecial dialog. it is
** useful to render CF_OBJECTDESCRIPTOR format even when the
** data on the clipboard does NOT include CF_EMBEDDEDOBJECT
** format or CF_EMBEDSOURCE format as when a selection that is
** not a single OLE object is copied from the container only
** version CNTROUTL. by rendering CF_OBJECTDESCRIPTOR format the
** app can indicate a useful string to identifiy the source of
** the copy to the user.
*/
lpOleApp->m_arrDocGetFmts[0].cfFormat = lpContainerApp->m_cfCntrOutl;
lpOleApp->m_arrDocGetFmts[0].ptd = NULL;
lpOleApp->m_arrDocGetFmts[0].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[0].tymed = TYMED_ISTORAGE;
lpOleApp->m_arrDocGetFmts[0].lindex = -1;
lpOleApp->m_arrDocGetFmts[1].cfFormat = lpOutlineApp->m_cfOutline;
lpOleApp->m_arrDocGetFmts[1].ptd = NULL;
lpOleApp->m_arrDocGetFmts[1].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[1].tymed = TYMED_HGLOBAL;
lpOleApp->m_arrDocGetFmts[1].lindex = -1;
lpOleApp->m_arrDocGetFmts[2].cfFormat = CF_TEXT;
lpOleApp->m_arrDocGetFmts[2].ptd = NULL;
lpOleApp->m_arrDocGetFmts[2].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[2].tymed = TYMED_HGLOBAL;
lpOleApp->m_arrDocGetFmts[2].lindex = -1;
lpOleApp->m_arrDocGetFmts[3].cfFormat = lpOleApp->m_cfObjectDescriptor;
lpOleApp->m_arrDocGetFmts[3].ptd = NULL;
lpOleApp->m_arrDocGetFmts[3].dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrDocGetFmts[3].tymed = TYMED_HGLOBAL;
lpOleApp->m_arrDocGetFmts[3].lindex = -1;
lpOleApp->m_nDocGetFmts = 4;
/* m_arrSingleObjGetFmts array enumerates the formats that a
** ContainerDoc object can offer (give) through a
** IDataObject::GetData call when the selection copied IS a
** single OLE object.
** ContainerDoc objects accept data formats in the following order:
** 1. CF_CNTROUTL
** 2. CF_EMBEDDEDOBJECT
** 3. CF_OBJECTDESCRIPTOR
** 4. CF_METAFILEPICT (note DVASPECT will vary)
** 5. CF_LINKSOURCE *
** 6. CF_LINKSRCDESCRIPTOR *
**
** * OLE2NOTE: CF_LINKSOURCE and CF_LINKSRCDESCRIPTOR is only
** offered if the OLE 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), then we want to offer
** CF_LINKSOURCE format. 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.
** the simplest way to determine if an object can be linked to
** on the inside is to call IOleObject::GetMiscStatus and test
** to see if the OLEMISC_CANTLINKINSIDE bit is NOT set.
**
** OLE2NOTE: optionally, a container that wants to have a
** potentially richer data transfer, can enumerate the data
** formats from the OLE object's cache and offer them too. if
** the object has a special handler, then it might be able to
** render additional data formats.
*/
lpContainerApp->m_arrSingleObjGetFmts[0].cfFormat =
lpContainerApp->m_cfCntrOutl;
lpContainerApp->m_arrSingleObjGetFmts[0].ptd = NULL;
lpContainerApp->m_arrSingleObjGetFmts[0].dwAspect = DVASPECT_CONTENT;
lpContainerApp->m_arrSingleObjGetFmts[0].tymed = TYMED_ISTORAGE;
lpContainerApp->m_arrSingleObjGetFmts[0].lindex = -1;
lpContainerApp->m_arrSingleObjGetFmts[1].cfFormat =
lpOleApp->m_cfEmbeddedObject;
lpContainerApp->m_arrSingleObjGetFmts[1].ptd = NULL;
lpContainerApp->m_arrSingleObjGetFmts[1].dwAspect = DVASPECT_CONTENT;
lpContainerApp->m_arrSingleObjGetFmts[1].tymed = TYMED_ISTORAGE;
lpContainerApp->m_arrSingleObjGetFmts[1].lindex = -1;
lpContainerApp->m_arrSingleObjGetFmts[2].cfFormat =
lpOleApp->m_cfObjectDescriptor;
lpContainerApp->m_arrSingleObjGetFmts[2].ptd = NULL;
lpContainerApp->m_arrSingleObjGetFmts[2].dwAspect = DVASPECT_CONTENT;
lpContainerApp->m_arrSingleObjGetFmts[2].tymed = TYMED_HGLOBAL;
lpContainerApp->m_arrSingleObjGetFmts[2].lindex = -1;
lpContainerApp->m_arrSingleObjGetFmts[3].cfFormat = CF_METAFILEPICT;
lpContainerApp->m_arrSingleObjGetFmts[3].ptd = NULL;
lpContainerApp->m_arrSingleObjGetFmts[3].dwAspect = DVASPECT_CONTENT;
lpContainerApp->m_arrSingleObjGetFmts[3].tymed = TYMED_MFPICT;
lpContainerApp->m_arrSingleObjGetFmts[3].lindex = -1;
lpContainerApp->m_arrSingleObjGetFmts[4].cfFormat =
lpOleApp->m_cfLinkSource;
lpContainerApp->m_arrSingleObjGetFmts[4].ptd = NULL;
lpContainerApp->m_arrSingleObjGetFmts[4].dwAspect = DVASPECT_CONTENT;
lpContainerApp->m_arrSingleObjGetFmts[4].tymed = TYMED_ISTREAM;
lpContainerApp->m_arrSingleObjGetFmts[4].lindex = -1;
lpContainerApp->m_arrSingleObjGetFmts[5].cfFormat =
lpOleApp->m_cfLinkSrcDescriptor;
lpContainerApp->m_arrSingleObjGetFmts[5].ptd = NULL;
lpContainerApp->m_arrSingleObjGetFmts[5].dwAspect = DVASPECT_CONTENT;
lpContainerApp->m_arrSingleObjGetFmts[5].tymed = TYMED_HGLOBAL;
lpContainerApp->m_arrSingleObjGetFmts[5].lindex = -1;
lpContainerApp->m_nSingleObjGetFmts = 6;
/* NOTE: the Container-Only version of Outline does NOT offer
** IDataObject interface from its User documents and the
** IDataObject interface available from DataTransferDoc's do NOT
** support SetData. IDataObject interface is required by objects
** which can be embedded or linked. the Container-only app only
** allows linking to its contained objects, NOT the data of the
** container itself.
*/
/* m_arrPasteEntries array enumerates the formats that a ContainerDoc
** object can accept from the clipboard. this array is used to
** support the PasteSpecial dialog.
** The formats are listed in priority order.
** ContainerDoc objects accept data formats in the following order:
** 1. CF_CNTROUTL
** 2. CF_OUTLINE
** 3. CF_EMBEDDEDOBJECT
** 4. CF_TEXT
** 5. CF_METAFILEPICT
** 6. CF_DIB
** 7. CF_BITMAP
** 8. CF_LINKSOURCE
**
** NOTE: specifying CF_EMBEDDEDOBJECT in the PasteEntry array
** indicates that the caller is interested in pasting OLE
** objects (ie. the caller calls OleCreateFromData). the
** OleUIPasteSpecial dialog and OleStdGetPriorityClipboardFormat
** call OleQueryCreateFromData to see if an OLE object format is
** available. thus, in fact if CF_EMBEDSOURCE or CF_FILENAME are
** available from the data source then and OLE object can be
** created and this entry will be matched. the caller should
** only specify one object type format.
** CF_FILENAME format (as generated by copying a file to
** the clipboard from the FileManager) is considered an object
** format; OleCreatFromData creates an object if the file has an
** associated class (see GetClassFile API) or if no class it
** creates an OLE 1.0 Package object. this format can also be
** paste linked by calling OleCreateLinkFromData.
*/
// REVIEW: strings should be loaded from string resource
lpOleApp->m_arrPasteEntries[0].fmtetc.cfFormat =
lpContainerApp->m_cfCntrOutl;
lpOleApp->m_arrPasteEntries[0].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[0].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[0].fmtetc.tymed = TYMED_ISTORAGE;
lpOleApp->m_arrPasteEntries[0].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[0].lpstrFormatName = "Container Outline Data";
lpOleApp->m_arrPasteEntries[0].lpstrResultText =
"Container Outline Data";
lpOleApp->m_arrPasteEntries[0].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_arrPasteEntries[1].fmtetc.cfFormat =lpOutlineApp->m_cfOutline;
lpOleApp->m_arrPasteEntries[1].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[1].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[1].fmtetc.tymed = TYMED_HGLOBAL;
lpOleApp->m_arrPasteEntries[1].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[1].lpstrFormatName = "Outline Data";
lpOleApp->m_arrPasteEntries[1].lpstrResultText = "Outline Data";
lpOleApp->m_arrPasteEntries[1].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_arrPasteEntries[2].fmtetc.cfFormat =
lpOleApp->m_cfEmbeddedObject;
lpOleApp->m_arrPasteEntries[2].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[2].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[2].fmtetc.tymed = TYMED_ISTORAGE;
lpOleApp->m_arrPasteEntries[2].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[2].lpstrFormatName = "%s";
lpOleApp->m_arrPasteEntries[2].lpstrResultText = "%s";
lpOleApp->m_arrPasteEntries[2].dwFlags =
OLEUIPASTE_PASTE | OLEUIPASTE_ENABLEICON;
lpOleApp->m_arrPasteEntries[3].fmtetc.cfFormat = CF_TEXT;
lpOleApp->m_arrPasteEntries[3].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[3].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[3].fmtetc.tymed = TYMED_HGLOBAL;
lpOleApp->m_arrPasteEntries[3].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[3].lpstrFormatName = "Text";
lpOleApp->m_arrPasteEntries[3].lpstrResultText = "text";
lpOleApp->m_arrPasteEntries[3].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_arrPasteEntries[4].fmtetc.cfFormat = CF_METAFILEPICT;
lpOleApp->m_arrPasteEntries[4].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[4].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[4].fmtetc.tymed = TYMED_MFPICT;
lpOleApp->m_arrPasteEntries[4].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[4].lpstrFormatName = "Picture (Metafile)";
lpOleApp->m_arrPasteEntries[4].lpstrResultText = "a static picture";
lpOleApp->m_arrPasteEntries[4].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_arrPasteEntries[5].fmtetc.cfFormat = CF_DIB;
lpOleApp->m_arrPasteEntries[5].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[5].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[5].fmtetc.tymed = TYMED_HGLOBAL;
lpOleApp->m_arrPasteEntries[5].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[5].lpstrFormatName = "Picture (DIB)";
lpOleApp->m_arrPasteEntries[5].lpstrResultText = "a static picture";
lpOleApp->m_arrPasteEntries[5].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_arrPasteEntries[6].fmtetc.cfFormat = CF_BITMAP;
lpOleApp->m_arrPasteEntries[6].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[6].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[6].fmtetc.tymed = TYMED_GDI;
lpOleApp->m_arrPasteEntries[6].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[6].lpstrFormatName = "Picture (Bitmap)";
lpOleApp->m_arrPasteEntries[6].lpstrResultText = "a static picture";
lpOleApp->m_arrPasteEntries[6].dwFlags = OLEUIPASTE_PASTEONLY;
lpOleApp->m_arrPasteEntries[7].fmtetc.cfFormat = lpOleApp->m_cfLinkSource;
lpOleApp->m_arrPasteEntries[7].fmtetc.ptd = NULL;
lpOleApp->m_arrPasteEntries[7].fmtetc.dwAspect = DVASPECT_CONTENT;
lpOleApp->m_arrPasteEntries[7].fmtetc.tymed = TYMED_ISTREAM;
lpOleApp->m_arrPasteEntries[7].fmtetc.lindex = -1;
lpOleApp->m_arrPasteEntries[7].lpstrFormatName = "%s";
lpOleApp->m_arrPasteEntries[7].lpstrResultText = "%s";
lpOleApp->m_arrPasteEntries[7].dwFlags =
OLEUIPASTE_LINKTYPE1 | OLEUIPASTE_ENABLEICON;
lpOleApp->m_nPasteEntries = 8;
/* m_arrLinkTypes array enumerates the link types that a ContainerDoc
** object can accept from the clipboard
*/
lpOleApp->m_arrLinkTypes[0] = lpOleApp->m_cfLinkSource;
lpOleApp->m_nLinkTypes = 1;
return TRUE;
}
/* ContainerApp_InitVtbls
** ----------------------
**
** initialize the interface Vtbl's used to support the OLE 2.0
** Container functionality.
*/
BOOL ContainerApp_InitVtbls(LPCONTAINERAPP lpApp)
{
BOOL fStatus;
// ContainerDoc::IOleUILinkContainer method table
OleStdInitVtbl(
&g_CntrDoc_OleUILinkContainerVtbl,
sizeof(IOleUILinkContainerVtbl)
);
g_CntrDoc_OleUILinkContainerVtbl.QueryInterface =
CntrDoc_LinkCont_QueryInterface;
g_CntrDoc_OleUILinkContainerVtbl.AddRef = CntrDoc_LinkCont_AddRef;
g_CntrDoc_OleUILinkContainerVtbl.Release = CntrDoc_LinkCont_Release;
g_CntrDoc_OleUILinkContainerVtbl.GetNextLink =
CntrDoc_LinkCont_GetNextLink;
g_CntrDoc_OleUILinkContainerVtbl.SetLinkUpdateOptions =
CntrDoc_LinkCont_SetLinkUpdateOptions;
g_CntrDoc_OleUILinkContainerVtbl.GetLinkUpdateOptions =
CntrDoc_LinkCont_GetLinkUpdateOptions;
g_CntrDoc_OleUILinkContainerVtbl.SetLinkSource =
CntrDoc_LinkCont_SetLinkSource;
g_CntrDoc_OleUILinkContainerVtbl.GetLinkSource =
CntrDoc_LinkCont_GetLinkSource;
g_CntrDoc_OleUILinkContainerVtbl.OpenLinkSource =
CntrDoc_LinkCont_OpenLinkSource;
g_CntrDoc_OleUILinkContainerVtbl.UpdateLink =
CntrDoc_LinkCont_UpdateLink;
g_CntrDoc_OleUILinkContainerVtbl.CancelLink =
CntrDoc_LinkCont_CancelLink;
fStatus = OleStdCheckVtbl(
&g_CntrDoc_OleUILinkContainerVtbl,
sizeof(IOleUILinkContainerVtbl),
"IOleUILinkContainer"
);
if (! fStatus) return FALSE;
#if defined( INPLACE_CNTR )
// ContainerApp::IOleInPlaceFrame interface method table
OleStdInitVtbl(
&g_CntrApp_OleInPlaceFrameVtbl,
sizeof(g_CntrApp_OleInPlaceFrameVtbl)
);
g_CntrApp_OleInPlaceFrameVtbl.QueryInterface
= CntrApp_IPFrame_QueryInterface;
g_CntrApp_OleInPlaceFrameVtbl.AddRef
= CntrApp_IPFrame_AddRef;
g_CntrApp_OleInPlaceFrameVtbl.Release
= CntrApp_IPFrame_Release;
g_CntrApp_OleInPlaceFrameVtbl.GetWindow
= CntrApp_IPFrame_GetWindow;
g_CntrApp_OleInPlaceFrameVtbl.ContextSensitiveHelp
= CntrApp_IPFrame_ContextSensitiveHelp;
g_CntrApp_OleInPlaceFrameVtbl.GetBorder
= CntrApp_IPFrame_GetBorder;
g_CntrApp_OleInPlaceFrameVtbl.RequestBorderSpace
= CntrApp_IPFrame_RequestBorderSpace;
g_CntrApp_OleInPlaceFrameVtbl.SetBorderSpace
= CntrApp_IPFrame_SetBorderSpace;
g_CntrApp_OleInPlaceFrameVtbl.SetActiveObject
= CntrApp_IPFrame_SetActiveObject;
g_CntrApp_OleInPlaceFrameVtbl.InsertMenus
= CntrApp_IPFrame_InsertMenus;
g_CntrApp_OleInPlaceFrameVtbl.SetMenu
= CntrApp_IPFrame_SetMenu;
g_CntrApp_OleInPlaceFrameVtbl.RemoveMenus
= CntrApp_IPFrame_RemoveMenus;
g_CntrApp_OleInPlaceFrameVtbl.SetStatusText
= CntrApp_IPFrame_SetStatusText;
g_CntrApp_OleInPlaceFrameVtbl.EnableModeless
= CntrApp_IPFrame_EnableModeless;
g_CntrApp_OleInPlaceFrameVtbl.TranslateAccelerator
= CntrApp_IPFrame_TranslateAccelerator;
fStatus = OleStdCheckVtbl(
&g_CntrApp_OleInPlaceFrameVtbl,
sizeof(g_CntrApp_OleInPlaceFrameVtbl),
"IOleInPlaceFrame"
);
if (! fStatus) return FALSE;
#endif // INPLACE_CNTR
// ContainerLine::IUnknown interface method table
OleStdInitVtbl(
&g_CntrLine_UnknownVtbl,
sizeof(g_CntrLine_UnknownVtbl)
);
g_CntrLine_UnknownVtbl.QueryInterface = CntrLine_Unk_QueryInterface;
g_CntrLine_UnknownVtbl.AddRef = CntrLine_Unk_AddRef;
g_CntrLine_UnknownVtbl.Release = CntrLine_Unk_Release;
fStatus = OleStdCheckVtbl(
&g_CntrLine_UnknownVtbl,
sizeof(g_CntrLine_UnknownVtbl),
"IUnknown"
);
if (! fStatus) return FALSE;
// ContainerLine::IOleClientSite interface method table
OleStdInitVtbl(
&g_CntrLine_OleClientSiteVtbl,
sizeof(g_CntrLine_OleClientSiteVtbl)
);
g_CntrLine_OleClientSiteVtbl.QueryInterface =
CntrLine_CliSite_QueryInterface;
g_CntrLine_OleClientSiteVtbl.AddRef = CntrLine_CliSite_AddRef;
g_CntrLine_OleClientSiteVtbl.Release = CntrLine_CliSite_Release;
g_CntrLine_OleClientSiteVtbl.SaveObject = CntrLine_CliSite_SaveObject;
g_CntrLine_OleClientSiteVtbl.GetMoniker = CntrLine_CliSite_GetMoniker;
g_CntrLine_OleClientSiteVtbl.GetContainer = CntrLine_CliSite_GetContainer;
g_CntrLine_OleClientSiteVtbl.ShowObject = CntrLine_CliSite_ShowObject;
g_CntrLine_OleClientSiteVtbl.OnShowWindow = CntrLine_CliSite_OnShowWindow;
g_CntrLine_OleClientSiteVtbl.RequestNewObjectLayout =
CntrLine_CliSite_RequestNewObjectLayout;
fStatus = OleStdCheckVtbl(
&g_CntrLine_OleClientSiteVtbl,
sizeof(g_CntrLine_OleClientSiteVtbl),
"IOleClientSite"
);
if (! fStatus) return FALSE;
// ContainerLine::IAdviseSink interface method table
OleStdInitVtbl(
&g_CntrLine_AdviseSinkVtbl,
sizeof(g_CntrLine_AdviseSinkVtbl)
);
g_CntrLine_AdviseSinkVtbl.QueryInterface= CntrLine_AdvSink_QueryInterface;
g_CntrLine_AdviseSinkVtbl.AddRef = CntrLine_AdvSink_AddRef;
g_CntrLine_AdviseSinkVtbl.Release = CntrLine_AdvSink_Release;
g_CntrLine_AdviseSinkVtbl.OnDataChange = CntrLine_AdvSink_OnDataChange;
g_CntrLine_AdviseSinkVtbl.OnViewChange = CntrLine_AdvSink_OnViewChange;
g_CntrLine_AdviseSinkVtbl.OnRename = CntrLine_AdvSink_OnRename;
g_CntrLine_AdviseSinkVtbl.OnSave = CntrLine_AdvSink_OnSave;
g_CntrLine_AdviseSinkVtbl.OnClose = CntrLine_AdvSink_OnClose;
fStatus = OleStdCheckVtbl(
&g_CntrLine_AdviseSinkVtbl,
sizeof(g_CntrLine_AdviseSinkVtbl),
"IAdviseSink"
);
if (! fStatus) return FALSE;
#if defined( INPLACE_CNTR )
// ContainerLine::IOleInPlaceSite interface method table
OleStdInitVtbl(
&g_CntrLine_OleInPlaceSiteVtbl,
sizeof(g_CntrLine_OleInPlaceSiteVtbl)
);
g_CntrLine_OleInPlaceSiteVtbl.QueryInterface
= CntrLine_IPSite_QueryInterface;
g_CntrLine_OleInPlaceSiteVtbl.AddRef
= CntrLine_IPSite_AddRef;
g_CntrLine_OleInPlaceSiteVtbl.Release
= CntrLine_IPSite_Release;
g_CntrLine_OleInPlaceSiteVtbl.GetWindow
= CntrLine_IPSite_GetWindow;
g_CntrLine_OleInPlaceSiteVtbl.ContextSensitiveHelp
= CntrLine_IPSite_ContextSensitiveHelp;
g_CntrLine_OleInPlaceSiteVtbl.CanInPlaceActivate
= CntrLine_IPSite_CanInPlaceActivate;
g_CntrLine_OleInPlaceSiteVtbl.OnInPlaceActivate
= CntrLine_IPSite_OnInPlaceActivate;
g_CntrLine_OleInPlaceSiteVtbl.OnUIActivate
= CntrLine_IPSite_OnUIActivate;
g_CntrLine_OleInPlaceSiteVtbl.GetWindowContext
= CntrLine_IPSite_GetWindowContext;
g_CntrLine_OleInPlaceSiteVtbl.Scroll
= CntrLine_IPSite_Scroll;
g_CntrLine_OleInPlaceSiteVtbl.OnUIDeactivate
= CntrLine_IPSite_OnUIDeactivate;
g_CntrLine_OleInPlaceSiteVtbl.OnInPlaceDeactivate
= CntrLine_IPSite_OnInPlaceDeactivate;
g_CntrLine_OleInPlaceSiteVtbl.DiscardUndoState
= CntrLine_IPSite_DiscardUndoState;
g_CntrLine_OleInPlaceSiteVtbl.DeactivateAndUndo
= CntrLine_IPSite_DeactivateAndUndo;
g_CntrLine_OleInPlaceSiteVtbl.OnPosRectChange
= CntrLine_IPSite_OnPosRectChange;
fStatus = OleStdCheckVtbl(
&g_CntrLine_OleInPlaceSiteVtbl,
sizeof(g_CntrLine_OleInPlaceSiteVtbl),
"IOleInPlaceSite"
);
if (! fStatus) return FALSE;
#endif // INPLACE_CNTR
return TRUE;
}
#endif // OLE_CNTR
Reference in a new issue Copy permalink