mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2989 lines
99 KiB
2989 lines
99 KiB
/*************************************************************************
|
|
**
|
|
** 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
|