/************************************************************************* ** ** OLE 2 Sample Code ** ** main.c ** ** This file contains initialization functions which are WinMain, ** WndProc, and OutlineApp_InitalizeMenu. ** ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved ** *************************************************************************/ #include "outline.h" #if defined( USE_STATUSBAR ) #include "status.h" #endif #if !defined( WIN32 ) #if defined( USE_CTL3D ) #include "ctl3d.h" #endif // USE_CTL3D #endif // !WIN32 #include "initguid.h" // forces our GUIDs to be initialized #include "defguid.h" // OLETEST driver window handler HWND g_hwndDriver; #if defined( OLE_CNTR ) //************************************************************************* #if defined( INPLACE_CNTR ) OLEDBGDATA_MAIN("ICNTR") #else OLEDBGDATA_MAIN("CNTR") #endif CONTAINERAPP g_OutlineApp; // Global App object maintains app instance state /* Global 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 one of these global Vtbl's. */ IUnknownVtbl g_OleApp_UnknownVtbl; IClassFactoryVtbl g_OleApp_ClassFactoryVtbl; IMessageFilterVtbl g_OleApp_MessageFilterVtbl; IUnknownVtbl g_OleDoc_UnknownVtbl; IPersistFileVtbl g_OleDoc_PersistFileVtbl; IOleItemContainerVtbl g_OleDoc_OleItemContainerVtbl; IExternalConnectionVtbl g_OleDoc_ExternalConnectionVtbl; IDataObjectVtbl g_OleDoc_DataObjectVtbl; #if defined( USE_DRAGDROP ) IDropSourceVtbl g_OleDoc_DropSourceVtbl; IDropTargetVtbl g_OleDoc_DropTargetVtbl; #endif // USE_DRAGDROP IOleUILinkContainerVtbl g_CntrDoc_OleUILinkContainerVtbl; IOleClientSiteVtbl g_CntrLine_UnknownVtbl; IOleClientSiteVtbl g_CntrLine_OleClientSiteVtbl; IAdviseSinkVtbl g_CntrLine_AdviseSinkVtbl; #if defined( INPLACE_CNTR ) IOleInPlaceSiteVtbl g_CntrLine_OleInPlaceSiteVtbl; IOleInPlaceFrameVtbl g_CntrApp_OleInPlaceFrameVtbl; BOOL g_fInsideOutContainer = FALSE; // default to outside-in activation #endif // INPLACE_CNTR //************************************************************************* #endif // OLE_CNTR #if defined( OLE_SERVER ) //************************************************************************* #if defined( INPLACE_SVR ) OLEDBGDATA_MAIN("ISVR") #else OLEDBGDATA_MAIN("SVR") #endif SERVERAPP g_OutlineApp; // Global App object maintains app instance state /* Global 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 one of these global Vtbl's. */ IUnknownVtbl g_OleApp_UnknownVtbl; IClassFactoryVtbl g_OleApp_ClassFactoryVtbl; IMessageFilterVtbl g_OleApp_MessageFilterVtbl; IUnknownVtbl g_OleDoc_UnknownVtbl; IPersistFileVtbl g_OleDoc_PersistFileVtbl; IOleItemContainerVtbl g_OleDoc_OleItemContainerVtbl; IExternalConnectionVtbl g_OleDoc_ExternalConnectionVtbl; IDataObjectVtbl g_OleDoc_DataObjectVtbl; #if defined( USE_DRAGDROP ) IDropSourceVtbl g_OleDoc_DropSourceVtbl; IDropTargetVtbl g_OleDoc_DropTargetVtbl; #endif // USE_DRAGDROP IOleObjectVtbl g_SvrDoc_OleObjectVtbl; IPersistStorageVtbl g_SvrDoc_PersistStorageVtbl; #if defined( SVR_TREATAS ) IStdMarshalInfoVtbl g_SvrDoc_StdMarshalInfoVtbl; #endif // SVR_TREATAS #if defined( INPLACE_SVR ) IOleInPlaceObjectVtbl g_SvrDoc_OleInPlaceObjectVtbl; IOleInPlaceActiveObjectVtbl g_SvrDoc_OleInPlaceActiveObjectVtbl; #endif // INPLACE_SVR IUnknownVtbl g_PseudoObj_UnknownVtbl; IOleObjectVtbl g_PseudoObj_OleObjectVtbl; IDataObjectVtbl g_PseudoObj_DataObjectVtbl; //************************************************************************* #endif // OLE_SVR #if !defined( OLE_VERSION ) OLEDBGDATA_MAIN("OUTL") OUTLINEAPP g_OutlineApp; // Global App object maintains app instance state #endif LPOUTLINEAPP g_lpApp=(LPOUTLINEAPP)&g_OutlineApp; // ptr to global app obj RECT g_rectNull = {0, 0, 0, 0}; UINT g_uMsgHelp = 0; // help msg from ole2ui dialogs BOOL g_fAppActive = FALSE; /* WinMain ** ------- ** Main routine for the Windows application. */ int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) { LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp; MSG msg; /* MSG structure to store your messages */ LPSTR pszTemp; #if defined( OLE_VERSION ) /* OLE2NOTE: it is recommended that all OLE applications to set ** their message queue size to 96. this improves the capacity ** and performance of OLE's LRPC mechanism. */ int cMsg = 96; // recommend msg queue size for OLE while (cMsg && ! SetMessageQueue(cMsg)) // take largest size we can get. cMsg -= 8; if (! cMsg) return -1; // ERROR: we got no message queue #endif #if defined( USE_CTL3D ) Ctl3dRegister(hInstance); Ctl3dAutoSubclass(hInstance); #endif if(! hPrevInstance) { /* register window classes if first instance of application */ if(! OutlineApp_InitApplication(lpOutlineApp, hInstance)) return 0; } /* Create App Frame window */ if (! OutlineApp_InitInstance(lpOutlineApp, hInstance, nCmdShow)) return 0; if( (pszTemp = strstr(lpszCmdLine, "-driver")) ) { //we were launched by the test driver g_hwndDriver = (HWND)strtoul(pszTemp+8, &lpszCmdLine, 10); } else { g_hwndDriver = NULL; } if (! OutlineApp_ParseCmdLine(lpOutlineApp, lpszCmdLine, nCmdShow)) return 0; lpOutlineApp->m_hAccelApp = LoadAccelerators(hInstance, APPACCEL); lpOutlineApp->m_hAccelFocusEdit = LoadAccelerators(hInstance, FB_EDIT_ACCEL); lpOutlineApp->m_hAccel = lpOutlineApp->m_hAccelApp; lpOutlineApp->m_hWndAccelTarget = lpOutlineApp->m_hWndApp; if( g_hwndDriver ) { PostMessage(g_hwndDriver, WM_TESTREG, (WPARAM)lpOutlineApp->m_hWndApp, 0); } // Main message loop while(GetMessage(&msg, NULL, 0, 0)) { /* Until WM_QUIT message */ if(!MyTranslateAccelerator(&msg)) { TranslateMessage(&msg); DispatchMessage(&msg); } } #if defined( OLE_VERSION ) OleApp_TerminateApplication((LPOLEAPP)lpOutlineApp); #else /* OLE2NOTE: CoInitialize() is called in OutlineApp_InitInstance ** and therefore we need to uninitialize it when exit. */ CoUninitialize(); #endif #if defined( USE_CTL3D ) Ctl3dUnregister(hInstance); #endif return msg.wParam; } /* End of WinMain */ BOOL MyTranslateAccelerator(LPMSG lpmsg) { // if it's not a keystroke it can not be an accelerator if (lpmsg->message < WM_KEYFIRST || lpmsg->message > WM_KEYLAST) return FALSE; if (g_lpApp->m_hWndAccelTarget && TranslateAccelerator(g_lpApp->m_hWndAccelTarget, g_lpApp->m_hAccel,lpmsg)) return TRUE; #if defined( INPLACE_SVR ) /* OLE2NOTE: if we are in-place active and we did not translate the ** accelerator, we need to give the top-level (frame) in-place ** container a chance to translate the accelerator. ** we ONLY need to call OleTranslateAccelerator API if the ** message is a keyboard message. otherwise it is harmless but ** unnecessary. ** ** NOTE: even a in-place server that does NOT have any ** Accelerators must still call OleTranslateAccelerator for all ** keyboard messages so that the server's OWN menu mneumonics ** (eg. &Edit -- Alt-e) function properly. ** ** NOTE: an in-place server MUST check that the accelerator is ** NOT one of its own accelerators BEFORE calling ** OleTranslateAccelerator which tries to see if it is a ** container accelerator. if this is a server accelerator that ** was not translateed because the associated menu command was ** disabled, we MUST NOT call OleTranslateAccelerator. The ** IsAccelerator helper API has been added to assist with this ** check. */ if (g_OutlineApp.m_lpIPData && !IsAccelerator(g_lpApp->m_hAccel, GetAccelItemCount(g_lpApp->m_hAccel), lpmsg,NULL) && OleTranslateAccelerator(g_OutlineApp.m_lpIPData->lpFrame, (LPOLEINPLACEFRAMEINFO)&g_OutlineApp.m_lpIPData->frameInfo, lpmsg) == NOERROR) { return TRUE; } #endif return FALSE; } /************************************************************************/ /* */ /* Main Window Procedure */ /* */ /* This procedure provides service routines for the Windows events */ /* (messages) that Windows sends to the window, as well as the user */ /* initiated events (messages) that are generated when the user selects */ /* the action bar and pulldown menu controls or the corresponding */ /* keyboard accelerators. */ /* */ /************************************************************************/ LRESULT FAR PASCAL AppWndProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam) { LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)GetWindowLong(hWnd, 0); LPOUTLINEDOC lpOutlineDoc = NULL; #if defined( OLE_VERSION ) LPOLEAPP lpOleApp = (LPOLEAPP)lpOutlineApp; #endif #if defined( OLE_CNTR ) LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)lpOutlineApp; #endif HWND hWndDoc = NULL; #if defined( USE_FRAMETOOLS ) LPFRAMETOOLS lptb = OutlineApp_GetFrameTools(lpOutlineApp); #endif if (lpOutlineApp) { lpOutlineDoc = OutlineApp_GetActiveDoc(lpOutlineApp); if (lpOutlineDoc) hWndDoc = OutlineDoc_GetWindow(lpOutlineDoc); } switch (Message) { case WM_TEST1: StartClipboardTest1(lpOutlineApp); break; case WM_TEST2: ContinueClipboardTest1(lpOutlineApp); break; case WM_COMMAND: { #ifdef WIN32 WORD wID = LOWORD(wParam); #else WORD wID = wParam; #endif #if defined( INPLACE_CNTR ) LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc; LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineDoc; /* OLE2NOTE: see context sensitive help technote (CSHELP.DOC) ** m_fMenuHelpMode flag is set when F1 is pressed when a ** menu item is selected. this flag is set in ** IOleInPlaceFrame::ContextSensitveHelp method. ** m_fCSHelpMode flag is set when SHIFT-F1 context ** sensitive help is entered. this flag is set in ** IOleInPlaceSite::ContextSensitiveHelp method. ** if either of these flags are set then the WM_COMMAND ** message is received then, the corresponding command ** should NOT executed; help can be given (if desired). ** also the context sensitve help mode should be exited. ** the two different cases have their own way to exit ** the mode (please refer to the technote). */ if (lpOleDoc && (lpContainerApp->m_fMenuHelpMode||lpOleDoc->m_fCSHelpMode) && (wID > IDM_FILE) /* min wID for app command */ && (wID!=IDM_FB_EDIT) /* special wID to control FormulaBar */ ) { if ((lpContainerApp->m_fMenuHelpMode)) { LPOLEINPLACEACTIVEOBJECT lpIPActiveObj = lpContainerApp->m_lpIPActiveObj; lpContainerApp->m_fMenuHelpMode = FALSE; // inform the in-place active object that we handled the // menu help mode (F1) selection. if (lpIPActiveObj) { OLEDBG_BEGIN2("IOleInPlaceActiveObject::ContextSensitiveHelp(FALSE) called\r\n") lpIPActiveObj->lpVtbl->ContextSensitiveHelp( lpIPActiveObj, FALSE); OLEDBG_END2 } } if ((lpOleDoc->m_fCSHelpMode)) { LPOLEINPLACEOBJECT lpIPObj; LPCONTAINERLINE lpLastIpActiveLine = lpContainerDoc->m_lpLastIpActiveLine; lpOleDoc->m_fCSHelpMode = FALSE; /* inform immediate in-place container parent and, ** if we were a container/server, immediate ** in-place object children that we handled the ** context sensitive help mode. */ if (lpLastIpActiveLine && (lpIPObj=lpLastIpActiveLine->m_lpOleIPObj)!=NULL){ OLEDBG_BEGIN2("IOleInPlaceObject::ContextSensitiveHelp(FALSE) called\r\n") lpIPObj->lpVtbl->ContextSensitiveHelp(lpIPObj, FALSE); OLEDBG_END2 } } // if we provided help, we would do it here... // remove context sensitive help cursor SetCursor(LoadCursor(NULL,IDC_ARROW)); return 0L; } #endif // INPLACE_CNTR switch (wID) { case IDM_F_NEW: OleDbgIndent(-2); // Reset debug output indent level OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_NewCommand\r\n") OutlineApp_NewCommand(lpOutlineApp); OLEDBG_END3 #if defined( OLE_CNTR ) /* OLE2NOTE: this call will attempt to recover ** resources by unloading DLL's that were loaded ** by OLE and are no longer being used. it is a ** good idea to call this API now and then if ** your app tends to run for a long time. ** otherwise these DLL's will be unloaded when ** the app exits. some apps may want to call ** this as part of idle-time processing. this ** call is optional. */ OLEDBG_BEGIN2("CoFreeUnusedLibraries called\r\n") CoFreeUnusedLibraries(); OLEDBG_END2 #endif #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons( OutlineApp_GetActiveDoc(lpOutlineApp)); #endif break; case IDM_F_OPEN: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_OpenCommand\r\n") OutlineApp_OpenCommand(lpOutlineApp); OLEDBG_END3 #if defined( OLE_CNTR ) /* OLE2NOTE: this call will attempt to recover ** resources by unloading DLL's that were loaded ** by OLE and are no longer being used. it is a ** good idea to call this API now and then if ** your app tends to run for a long time. ** otherwise these DLL's will be unloaded when ** the app exits. some apps may want to call ** this as part of idle-time processing. this ** call is optional. */ OLEDBG_BEGIN2("CoFreeUnusedLibraries called\r\n") CoFreeUnusedLibraries(); OLEDBG_END2 #endif #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons( OutlineApp_GetActiveDoc(lpOutlineApp)); #endif break; case IDM_F_SAVE: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_SaveCommand\r\n") OutlineApp_SaveCommand(lpOutlineApp); OLEDBG_END3 break; case IDM_F_SAVEAS: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_SaveAsCommand\r\n") OutlineApp_SaveAsCommand(lpOutlineApp); OLEDBG_END3 break; case IDM_F_PRINT: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_PrintCommand\r\n") OutlineApp_PrintCommand(lpOutlineApp); OLEDBG_END3 break; case IDM_F_PRINTERSETUP: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_PrinterSetupCommand\r\n") OutlineApp_PrinterSetupCommand(lpOutlineApp); OLEDBG_END3 break; case IDM_F_EXIT: SendMessage(hWnd, WM_CLOSE, 0, 0L); break; case IDM_H_ABOUT: OutlineApp_AboutCommand(lpOutlineApp); break; #if defined( INPLACE_CNTR ) case IDM_ESCAPE: { /* ESCAPE key pressed */ LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc; /* OLE2NOTE: The standard OLE 2.0 UI convention ** is to have ESCAPE key exit in-place ** activation (ie. UIDeactivate). If ** possible it is recommended for both ** in-place servers AND in-place containers ** to take responsibility to handle the ** ESCAPE key accelerator. The server has ** the first crack at handling accelerator ** keys and normally the server should do ** the UIDeactivation. It is a good idea for ** in-place containers, in order to ** guarantee consistent behavior, to also ** handle the ESCAPE key and UIDeactivate ** the object in case the object does not do ** it itself. normally this should be ** unnecessary. */ if (lpContainerDoc->m_lpLastUIActiveLine && lpContainerDoc->m_lpLastUIActiveLine->m_fUIActive) { ContainerLine_UIDeactivate( lpContainerDoc->m_lpLastUIActiveLine); } break; } #endif // INPLACE_CNTR default: // forward message to document window if (hWndDoc) { return DocWndProc(hWndDoc, Message,wParam,lParam); } } break; /* End of WM_COMMAND */ } case WM_INITMENU: OutlineApp_InitMenu(lpOutlineApp, lpOutlineDoc, (HMENU)wParam); break; #if defined( OLE_VERSION ) /* OLE2NOTE: WM_INITMENUPOPUP is trapped primarily for the Edit ** menu. We didn't update the Edit menu until it is popped ** up to avoid the overheads of the OLE calls which are ** required to initialize some Edit menu items. */ case WM_INITMENUPOPUP: { HMENU hMenuEdit = GetSubMenu(lpOutlineApp->m_hMenuApp, 1); #if defined( INPLACE_CNTR ) LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc; /* OLE2NOTE: we must check if there is an object currently ** in-place UIActive. if so, then our edit menu is not ** on the menu; we do not want to bother updating the ** edit menu when it is not even there. */ if (lpContainerDoc && lpContainerDoc->m_lpLastUIActiveLine && lpContainerDoc->m_lpLastUIActiveLine->m_fUIActive) break; // an object is in-place UI active #endif if ((HMENU)wParam == hMenuEdit && (LOWORD(lParam) == POS_EDITMENU) && OleDoc_GetUpdateEditMenuFlag((LPOLEDOC)lpOutlineDoc)) { OleApp_UpdateEditMenu(lpOleApp, lpOutlineDoc, hMenuEdit); } break; } #endif // OLE_VERSION case WM_SIZE: if (wParam != SIZE_MINIMIZED) OutlineApp_ResizeWindows(lpOutlineApp); break; case WM_ACTIVATEAPP: #if defined (OLE_CNTR) if (g_fAppActive = (BOOL) wParam) OleApp_QueryNewPalette(lpOleApp); #endif #if defined( INPLACE_CNTR ) { BOOL fActivate = (BOOL)wParam; LPOLEINPLACEACTIVEOBJECT lpIPActiveObj = lpContainerApp->m_lpIPActiveObj; /* OLE2NOTE: the in-place container MUST inform the ** inner most in-place active object (this is NOT ** necessarily our immediate child if there are ** nested levels of embedding) of the WM_ACTIVATEAPP ** status. */ if (lpIPActiveObj) { #if defined( _DEBUG ) OLEDBG_BEGIN2((fActivate ? "IOleInPlaceActiveObject::OnFrameWindowActivate(TRUE) called\r\n" : "IOleInPlaceActiveObject::OnFrameWindowActivate(FALSE) called\r\n")) #endif // _DEUBG lpIPActiveObj->lpVtbl->OnFrameWindowActivate( lpIPActiveObj, fActivate); OLEDBG_END2 } } #endif // INPLACE_CNTR // OLE2NOTE: We can't call OutlineDoc_UpdateFrameToolButtons // right away which // would generate some OLE calls and eventually // WM_ACTIVATEAPP and a loop was formed. Therefore, we // should delay the frame tool initialization until // WM_ACTIVATEAPP is finished by posting a message // to ourselves. // we want to ignore the WM_ACTIVATEAPP that comes // as we bring up a modal dialog. /* Update enable/disable state of buttons in toolbar */ if (wParam #if defined( OLE_VERSION ) && lpOleApp->m_cModalDlgActive == 0 #endif ) { PostMessage(hWnd, WM_U_INITFRAMETOOLS, 0, 0L); } return 0L; case WM_SETFOCUS: SetFocus(hWndDoc); break; #if defined( OLE_CNTR ) case WM_QUERYNEWPALETTE: if (!g_fAppActive) return 0L; return OleApp_QueryNewPalette(lpOleApp); case WM_PALETTECHANGED: { HWND hWndPalChg = (HWND) wParam; static BOOL fInPaletteChanged = FALSE; if (fInPaletteChanged) // Guard against recursion return 0L; fInPaletteChanged = TRUE; if (hWnd != hWndPalChg) wSelectPalette(hWnd, lpOleApp->m_hStdPal,TRUE/*fBackground*/); #if defined( INPLACE_CNTR ) /* OLE2NOTE: always forward the WM_PALETTECHANGED message (via ** SendMessage) to any in-place objects that currently have ** their window visible. this gives these objects the chance ** to select their palettes. this is ** REQUIRED by all in-place containers independent of ** whether they use color palettes themselves--their objects ** may use color palettes. ** (see ContainerDoc_ForwardPaletteChangedMsg for more info) */ if (lpOutlineDoc){ ContainerDoc_ForwardPaletteChangedMsg( (LPCONTAINERDOC)lpOutlineDoc, hWndPalChg); } #endif // INPLACE_CNTR fInPaletteChanged = FALSE; return 0L; } #endif // OLE_CNTR case WM_DESTROY: PostQuitMessage(0); break; case WM_CLOSE: /* close the window */ /* Close all active documents. if successful, then exit */ OleDbgOutNoPrefix2("\r\n"); OutlineApp_CloseAllDocsAndExitCommand(lpOutlineApp, FALSE); break; case WM_QUERYENDSESSION: { #if defined( OLE_CNTR ) /* OLE2NOTE: we are not able to make OLE LRPC calls when ** WM_QUERYENDSESSION is recieved (this is a ** SendMessage). this means, for example, that we are ** NOT able to ask objects to save. thus the most we can ** do is ask the user if he wants to exit with ** discarding changes or else abort shutting down. */ int nResponse = MessageBox( hWnd, "Discard changes?", APPNAME, MB_ICONQUESTION | MB_OKCANCEL ); if(nResponse == IDOK) return 1L; /* can terminate */ #endif #if defined( OLE_SERVER ) /* OLE2NOTE: an embedded object should never prompt whether ** it should be saved (according the OLE 2.0 User ** Model). therefore, an embedded object will never ** complain that it needs to be saved. it will always ** allow the QueryEndSession to proceed. */ if (lpOutlineApp->m_lpDoc->m_docInitType == DOCTYPE_EMBEDDED) return 1L; /* can terminate */ else #endif { /* this is not an embedded object; it is a user ** document. we will prompt if the user wants to ** save the document now in WM_QUERYENDSESSION. if ** the user cancels then that would abort the ** shutdown. if the user does not abort, then later ** in WM_ENDSESSION the document will be actually ** closed. ** ** Because this is an SDI app, there is only one ** document. An MDI would need to loop through all ** open documents. */ DWORD dwSaveOption = OLECLOSE_PROMPTSAVE; if (OutlineDoc_CheckSaveChanges( lpOutlineApp->m_lpDoc, &dwSaveOption)) return 1L; /* can terminate */ } /* else: can't terminate now */ break; } #if defined( OLE_VERSION) case WM_ENDSESSION: { BOOL fEndSession = (BOOL)wParam; if (fEndSession) { OutlineApp_CloseAllDocsAndExitCommand(lpOutlineApp, TRUE); return 0L; } } break; #endif // OLE_VERSION #if defined( USE_STATUSBAR ) case WM_MENUSELECT: { LPSTR lpszMessage; #ifdef WIN32 UINT fuFlags = (UINT)HIWORD(wParam); UINT uItem = (UINT)LOWORD(wParam); #else UINT fuFlags = (UINT)LOWORD(lParam); UINT uItem = (UINT)wParam; #endif if (uItem == 0 && fuFlags == (UINT)-1) { GetControlMessage(STATUS_READY, &lpszMessage); OutlineApp_SetStatusText(lpOutlineApp, lpszMessage); } else if (fuFlags & MF_POPUP) { #ifdef WIN32 HMENU hMainMenu = (HMENU)lParam; HMENU hPopupMenu = GetSubMenu(hMainMenu,uItem); #else HMENU hPopupMenu = (HMENU)wParam; #endif GetPopupMessage(hPopupMenu, &lpszMessage); OutlineApp_SetStatusText(lpOutlineApp, lpszMessage); } else if (fuFlags & MF_SYSMENU) { GetSysMenuMessage(uItem, &lpszMessage); OutlineApp_SetStatusText(lpOutlineApp, lpszMessage); } else if (uItem != 0) { // Command Item GetItemMessage(uItem, &lpszMessage); OutlineApp_SetStatusText(lpOutlineApp, lpszMessage); } else { GetControlMessage(STATUS_BLANK, &lpszMessage); OutlineApp_SetStatusText(lpOutlineApp, lpszMessage); } break; } #endif // USE_STATUSBAR #if defined( USE_FRAMETOOLS ) case WM_U_INITFRAMETOOLS: OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); break; #endif default: /* For any message for which you don't specifically provide a */ /* service routine, you should return the message to Windows */ /* for default message processing. */ return DefWindowProc(hWnd, Message, wParam, lParam); } return (LRESULT)0; } /* End of AppWndProc */ /************************************************************************/ /* */ /* Document Window Procedure */ /* */ /* The Document Window is the parent of the OwnerDraw Listbox which */ /* maintains the list of lines in the current document. This window */ /* receives the ownerdraw callback messages from the list box. */ /************************************************************************/ LRESULT FAR PASCAL DocWndProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam) { LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp; LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC)GetWindowLong(hWnd, 0); LPLINELIST lpLL = OutlineDoc_GetLineList(lpOutlineDoc); LPSCALEFACTOR lpscale = OutlineDoc_GetScaleFactor(lpOutlineDoc); #if defined( OLE_VERSION ) LPOLEAPP lpOleApp = (LPOLEAPP)lpOutlineApp; LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineDoc; #if defined( OLE_CNTR ) LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc; #endif #if defined( OLE_SERVER ) LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc; #endif #if defined( INPLACE_CNTR ) LPCONTAINERAPP lpContainerApp = (LPCONTAINERAPP)lpOutlineApp; #endif #endif // OLE_VERSION switch(Message) { #if defined( INPLACE_SVR ) /* OLE2NOTE: ISVROTL doesn't use color palettes. The inplace objects ** that use color palettes must implement the following ** lines of code. ** case WM_QUERYNEWPALETTE: return wSelectPalette(hWnd, hPal, FALSE); // foreground case WM_PALETTECHANGED: if (hWnd != (HWND) wParam) wSelectPalette(hWnd, hPal, TRUE); // background break; ** ** ** */ #endif case WM_MEASUREITEM: { LPMEASUREITEMSTRUCT lpmis = ((LPMEASUREITEMSTRUCT)lParam); switch (wParam) { case IDC_LINELIST: { HDC hDC = LineList_GetDC(lpLL); UINT uHeight; uHeight=Line_GetHeightInHimetric((LPLINE)lpmis->itemData); uHeight = XformHeightInHimetricToPixels(hDC, uHeight); uHeight = (UINT) (uHeight * lpscale->dwSyN / lpscale->dwSyD); if (uHeight >LISTBOX_HEIGHT_LIMIT) uHeight = LISTBOX_HEIGHT_LIMIT; lpmis->itemHeight = uHeight; LineList_ReleaseDC(lpLL, hDC); break; } case IDC_NAMETABLE: { // NOTE: NameTable is never made visible. do nothing. break; } #if defined( USE_HEADING ) case IDC_ROWHEADING: { UINT uHeight; uHeight = LOWORD(lpmis->itemData); uHeight = (UINT) (uHeight * lpscale->dwSyN / lpscale->dwSyD); if (uHeight >LISTBOX_HEIGHT_LIMIT) uHeight = LISTBOX_HEIGHT_LIMIT; lpmis->itemHeight = uHeight; break; } case IDC_COLHEADING: { UINT uHeight; uHeight = LOWORD(lpmis->itemData); uHeight = (UINT) (uHeight * lpscale->dwSyN / lpscale->dwSyD); if (uHeight > LISTBOX_HEIGHT_LIMIT) uHeight = LISTBOX_HEIGHT_LIMIT; lpmis->itemHeight = uHeight; break; } #endif // USE_HEADING } return (LRESULT)TRUE; } case WM_DRAWITEM: { LPDRAWITEMSTRUCT lpdis = ((LPDRAWITEMSTRUCT)lParam); switch (lpdis->CtlID) { case IDC_LINELIST: { RECT rcClient; RECT rcDevice; HWND hWndLL = LineList_GetWindow(lpLL); LPLINE lpLine = (LPLINE)lpdis->itemData; // NOTE: When itemID == -1, the listbox is empty. // We are supposed to draw focus rect only // But it is not done in this app. If this line is // removed, the app will crash in Line_DrawToScreen // because of invalid lpLine. if (lpdis->itemID == -1) break; GetClientRect(hWndLL, &rcClient); rcDevice = lpdis->rcItem; // shift the item rect to account for horizontal scrolling rcDevice.left += rcClient.right - lpdis->rcItem.right; #if defined( OLE_CNTR ) /* we need to remember the horizontal scroll offset ** needed for the in-place object's window. ** (this is specific to ICNTROTL) */ if(lpdis->itemAction & ODA_DRAWENTIRE) { if (Line_GetLineType(lpLine) == CONTAINERLINETYPE) ((LPCONTAINERLINE)lpLine)->m_nHorizScrollShift = rcDevice.left; } #endif // OLE_CNTR // shift rect for left margin rcDevice.left += (int)(XformWidthInHimetricToPixels(NULL, LOWORD(OutlineDoc_GetMargin(lpOutlineDoc))) * lpscale->dwSxN / lpscale->dwSxD); rcDevice.right = rcDevice.left + (int)(XformWidthInHimetricToPixels(lpdis->hDC, Line_GetWidthInHimetric(lpLine)) * lpscale->dwSxN / lpscale->dwSxD); Line_DrawToScreen( lpLine, lpdis->hDC, &lpdis->rcItem, lpdis->itemAction, lpdis->itemState, &rcDevice ); #if defined( USE_FRAMETOOLS ) if (lpdis->itemState & ODS_FOCUS) OutlineDoc_SetFormulaBarEditText(lpOutlineDoc,lpLine); #endif break; } case IDC_NAMETABLE: { // NOTE: NameTable is never made visible. do nothing break; } #if defined( USE_HEADING ) case IDC_ROWHEADING: { LPHEADING lphead; // Last dummy item shouldn't be drawn if (lpdis->itemID == (UINT)LineList_GetCount(lpLL)) break; // only DrawEntire need be trapped as window is disabled if (lpdis->itemAction == ODA_DRAWENTIRE) { lphead = OutlineDoc_GetHeading(lpOutlineDoc); Heading_RH_Draw(lphead, lpdis); } break; } case IDC_COLHEADING: { RECT rect; RECT rcDevice; RECT rcLogical; LPHEADING lphead; // only DrawEntire need be trapped as window is disabled if (lpdis->itemAction == ODA_DRAWENTIRE) { lphead = OutlineDoc_GetHeading(lpOutlineDoc); GetClientRect(lpdis->hwndItem, &rect); rcDevice = lpdis->rcItem; // shift the item rect to account for // horizontal scrolling rcDevice.left = -(rcDevice.right - rect.right); // shift rect for left margin rcDevice.left += (int)(XformWidthInHimetricToPixels( NULL, LOWORD(OutlineDoc_GetMargin(lpOutlineDoc))) * lpscale->dwSxN / lpscale->dwSxD); rcDevice.right = rcDevice.left + (int)lpscale->dwSxN; rcLogical.left = 0; rcLogical.bottom = 0; rcLogical.right = (int)lpscale->dwSxD; rcLogical.top = LOWORD(lpdis->itemData); Heading_CH_Draw(lphead, lpdis, &rcDevice, &rcLogical); } break; } #endif // USE_HEADING } return (LRESULT)TRUE; } case WM_SETFOCUS: if (lpLL) SetFocus(LineList_GetWindow(lpLL)); break; #if !defined( OLE_VERSION ) case WM_RENDERFORMAT: { LPOUTLINEDOC lpClipboardDoc = lpOutlineApp->m_lpClipboardDoc; if (lpClipboardDoc) OutlineDoc_RenderFormat(lpClipboardDoc, wParam); break; } case WM_RENDERALLFORMATS: { LPOUTLINEDOC lpClipboardDoc = lpOutlineApp->m_lpClipboardDoc; if (lpClipboardDoc) OutlineDoc_RenderAllFormats(lpClipboardDoc); break; } case WM_DESTROYCLIPBOARD: if (g_lpApp->m_lpClipboardDoc) { OutlineDoc_Destroy(g_lpApp->m_lpClipboardDoc); g_lpApp->m_lpClipboardDoc = NULL; } break; #endif // OLE_VERSION #if defined( OLE_CNTR ) case WM_U_UPDATEOBJECTEXTENT: { /* Update the extents of any OLE object that is marked that ** its size may have changed. when an ** IAdviseSink::OnViewChange notification is received, ** the corresponding ContainerLine is marked ** (m_fDoGetExtent==TRUE) and a message ** (WM_U_UPDATEOBJECTEXTENT) is posted to the document ** indicating that there are dirty objects. */ ContainerDoc_UpdateExtentOfAllOleObjects(lpContainerDoc); break; } #endif // OLE_CNTR #if defined( INPLACE_SVR ) || defined( INPLACE_CNTR ) /* OLE2NOTE: Any window that is used during in-place activation ** must handle the WM_SETCURSOR message or else the cursor ** of the in-place parent will be used. if WM_SETCURSOR is ** not handled, then DefWindowProc sends the message to the ** window's parent. ** ** see context sensitive help technote (CSHELP.DOC). ** m_fCSHelpMode flag is set when SHIFT-F1 context ** sensitive help is entered. ** if this flag is set then the context sensitive help ** cursor should be shown. */ case WM_SETCURSOR: if (lpOleDoc->m_fCSHelpMode) SetCursor(UICursorLoad(IDC_CONTEXTHELP)); else SetCursor(LoadCursor(NULL, IDC_ARROW) ); return (LRESULT)TRUE; #endif // INPLACE_SVR || INPLACE_CNTR #if defined( INPLACE_SVR ) /* OLE2NOTE: when the in-place active, our in-place server ** document window (passed to IOleInPlaceFrame::SetMenu) ** will receive the WM_INITMENU and WM_INITMENUPOPUP messages. */ case WM_INITMENU: OutlineApp_InitMenu(lpOutlineApp, lpOutlineDoc, (HMENU)wParam); break; /* OLE2NOTE: WM_INITMENUPOPUP is trapped primarily for the Edit ** menu. We didn't update the Edit menu until it is popped ** up to avoid the overheads of the OLE calls which are ** required to initialize some Edit menu items. */ case WM_INITMENUPOPUP: { HMENU hMenuEdit = GetSubMenu(lpOutlineApp->m_hMenuApp, 1); if ((HMENU)wParam == hMenuEdit && (LOWORD(lParam) == POS_EDITMENU) && OleDoc_GetUpdateEditMenuFlag((LPOLEDOC)lpOutlineDoc)) { OleApp_UpdateEditMenu( (LPOLEAPP)lpOutlineApp, lpOutlineDoc, hMenuEdit); } break; } #endif // INPLACE_SVR #if defined( INPLACE_SVR ) && defined( USE_STATUSBAR ) /* OLE2NOTE: when the server is in-place active the ** WM_MENUSELECT message is sent to the object's window and ** not the server app's frame window. processing this ** message allows there in-place server to give status bar ** help text for menu commands. */ case WM_MENUSELECT: { LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOleDoc; LPSTR lpszMessage; #ifdef WIN32 UINT fuFlags = (UINT)HIWORD(wParam); UINT uItem = (UINT)LOWORD(wParam); #else UINT fuFlags = (UINT)LOWORD(lParam); UINT uItem = (UINT)wParam; #endif if (uItem == 0 && fuFlags == (UINT)-1) { GetControlMessage(STATUS_READY, &lpszMessage); ServerDoc_SetStatusText(lpServerDoc, lpszMessage); } else if (fuFlags & MF_POPUP) { #ifdef WIN32 HMENU hMainMenu = (HMENU)lParam; HMENU hPopupMenu = GetSubMenu(hMainMenu,uItem); #else HMENU hPopupMenu = (HMENU)wParam; #endif GetPopupMessage(hPopupMenu, &lpszMessage); ServerDoc_SetStatusText(lpServerDoc, lpszMessage); } else if (uItem != 0) { // Command Item GetItemMessage(uItem, &lpszMessage); ServerDoc_SetStatusText(lpServerDoc, lpszMessage); } else { GetControlMessage(STATUS_BLANK, &lpszMessage); ServerDoc_SetStatusText(lpServerDoc, lpszMessage); } break; } #endif // INPLACE_SVR && USE_STATUSBAR #if defined( INPLACE_SVR ) && defined( USE_FRAMETOOLS ) case WM_U_INITFRAMETOOLS: OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); break; #endif // INPLACE_SVR && USE_FRAMETOOLS case WM_COMMAND: { #ifdef WIN32 WORD wNotifyCode = HIWORD(wParam); WORD wID = LOWORD(wParam); HWND hwndCtl = (HWND) lParam; #else WORD wNotifyCode = HIWORD(lParam); WORD wID = wParam; HWND hwndCtl = (HWND) LOWORD(lParam); #endif #if defined( INPLACE_SVR ) /* OLE2NOTE: see context sensitive help technote (CSHELP.DOC) ** m_fMenuHelpMode flag is set when F1 is pressed when a ** menu item is selected. this flag is set in ** IOleInPlaceActiveObject::ContextSensitveHelp method. ** m_fCSHelpMode flag is set when SHIFT-F1 context ** sensitive help is entered. this flag is set in ** IOleInPlaceObject::ContextSensitiveHelp method. ** if either of these flags are set then the WM_COMMAND ** message is received then, the corresponding command ** should NOT executed; help can be given (if desired). ** also the context sensitve help mode should be exited. ** the two different cases have their own way to exit ** the mode (please refer to the technote). */ if (lpOleDoc && (lpServerDoc->m_fMenuHelpMode||lpOleDoc->m_fCSHelpMode) && (wID > IDM_FILE) /* min wID for app command */ && (wID!=IDM_FB_EDIT) /* special wID to control FormulaBar */ ) { if ((lpServerDoc->m_fMenuHelpMode)) { LPOLEINPLACEFRAME lpFrame; lpServerDoc->m_fMenuHelpMode = FALSE; // inform top-level frame that we handled the // menu help mode (F1) selection. if (lpServerDoc->m_lpIPData && (lpFrame=lpServerDoc->m_lpIPData->lpFrame)!=NULL){ OLEDBG_BEGIN2("IOleInPlaceFrame::ContextSensitiveHelp(FALSE) called\r\n") lpFrame->lpVtbl->ContextSensitiveHelp(lpFrame, FALSE); OLEDBG_END2 } } if ((lpOleDoc->m_fCSHelpMode)) { LPOLEINPLACESITE lpSite; lpOleDoc->m_fCSHelpMode = FALSE; /* inform immediate in-place container parent and, ** if we were a container/server, immediate ** in-place object children that we handled the ** context sensitive help mode. */ if (lpServerDoc->m_lpIPData && (lpSite=lpServerDoc->m_lpIPData->lpSite) !=NULL) { OLEDBG_BEGIN2("IOleInPlaceSite::ContextSensitiveHelp(FALSE) called\r\n") lpSite->lpVtbl->ContextSensitiveHelp(lpSite, FALSE); OLEDBG_END2 } } // if we provided help, we would do it here... // remove context sensitive help cursor SetCursor(LoadCursor(NULL,IDC_ARROW)); return 0L; } #endif // INPLACE_SVR #if defined( INPLACE_CNTR ) /* OLE2NOTE: see context sensitive help technote (CSHELP.DOC) ** m_fMenuHelpMode flag is set when F1 is pressed when a ** menu item is selected. this flag is set in ** IOleInPlaceFrame::ContextSensitveHelp method. ** m_fCSHelpMode flag is set when SHIFT-F1 context ** sensitive help is entered. this flag is set in ** IOleInPlaceSite::ContextSensitiveHelp method. ** if either of these flags are set then the WM_COMMAND ** message is received then, the corresponding command ** should NOT executed; help can be given (if desired). ** also the context sensitve help mode should be exited. ** the two different cases have their own way to exit ** the mode (please refer to the technote). */ if (lpOleDoc && (lpContainerApp->m_fMenuHelpMode||lpOleDoc->m_fCSHelpMode) && (wID > IDM_FILE) /* min wID for app command */ && (wID!=IDM_FB_EDIT) /* special wID to control FormulaBar */ ) { if ((lpContainerApp->m_fMenuHelpMode)) { LPOLEINPLACEACTIVEOBJECT lpIPActiveObj = lpContainerApp->m_lpIPActiveObj; lpContainerApp->m_fMenuHelpMode = FALSE; // inform the in-place active object that we handled the // menu help mode (F1) selection. if (lpIPActiveObj) { OLEDBG_BEGIN2("IOleInPlaceActiveObject::ContextSensitiveHelp(FALSE) called\r\n") lpIPActiveObj->lpVtbl->ContextSensitiveHelp( lpIPActiveObj, FALSE); OLEDBG_END2 } } if ((lpOleDoc->m_fCSHelpMode)) { LPOLEINPLACEOBJECT lpIPObj; LPCONTAINERLINE lpLastIpActiveLine = lpContainerDoc->m_lpLastIpActiveLine; lpOleDoc->m_fCSHelpMode = FALSE; /* inform immediate in-place container parent and, ** if we were a container/server, immediate ** in-place object children that we handled the ** context sensitive help mode. */ if (lpLastIpActiveLine && (lpIPObj=lpLastIpActiveLine->m_lpOleIPObj)!=NULL){ OLEDBG_BEGIN2("IOleInPlaceObject::ContextSensitiveHelp(FALSE) called\r\n") lpIPObj->lpVtbl->ContextSensitiveHelp(lpIPObj, FALSE); OLEDBG_END2 } } // if we provided help, we would do it here... // remove context sensitive help cursor SetCursor(LoadCursor(NULL,IDC_ARROW)); return 0L; } #endif // INPLACE_CNTR switch (wID) { /********************************************************* ** File new, open, save and print as well as Help about ** are duplicated in this switch statement and they are ** used to trap the message from the toolbar ** *********************************************************/ case IDM_F_NEW: OleDbgIndent(-2); // Reset debug output indent level OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_NewCommand\r\n") OutlineApp_NewCommand(lpOutlineApp); OLEDBG_END3 #if defined( OLE_CNTR ) /* OLE2NOTE: this call will attempt to recover ** resources by unloading DLL's that were loaded ** by OLE and are no longer being used. it is a ** good idea to call this API now and then if ** your app tends to run for a long time. ** otherwise these DLL's will be unloaded when ** the app exits. some apps may want to call ** this as part of idle-time processing. this ** call is optional. */ OLEDBG_BEGIN2("CoFreeUnusedLibraries called\r\n") CoFreeUnusedLibraries(); OLEDBG_END2 #endif #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons( OutlineApp_GetActiveDoc(lpOutlineApp)); #endif break; case IDM_F_OPEN: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_OpenCommand\r\n") OutlineApp_OpenCommand(lpOutlineApp); OLEDBG_END3 #if defined( OLE_CNTR ) /* OLE2NOTE: this call will attempt to recover ** resources by unloading DLL's that were loaded ** by OLE and are no longer being used. it is a ** good idea to call this API now and then if ** your app tends to run for a long time. ** otherwise these DLL's will be unloaded when ** the app exits. some apps may want to call ** this as part of idle-time processing. this ** call is optional. */ OLEDBG_BEGIN2("CoFreeUnusedLibraries called\r\n") CoFreeUnusedLibraries(); OLEDBG_END2 #endif #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons( OutlineApp_GetActiveDoc(lpOutlineApp)); #endif break; case IDM_F_SAVE: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_SaveCommand\r\n") OutlineApp_SaveCommand(lpOutlineApp); OLEDBG_END3 break; case IDM_F_PRINT: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineApp_PrintCommand\r\n") OutlineApp_PrintCommand(lpOutlineApp); OLEDBG_END3 break; case IDM_E_UNDO: // SORRY. NOT IMPLEMENTED break; case IDM_E_CUT: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_CutCommand\r\n") OutlineDoc_CutCommand(lpOutlineDoc); OLEDBG_END3 #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); #endif break; case IDM_E_COPY: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_CopyCommand\r\n") OutlineDoc_CopyCommand(lpOutlineDoc); OLEDBG_END3 #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); #endif break; case IDM_E_PASTE: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_PasteCommand\r\n") OutlineDoc_PasteCommand(lpOutlineDoc); OLEDBG_END3 #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); #endif break; #if defined( OLE_VERSION ) case IDM_E_PASTESPECIAL: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OleDoc_PasteSpecialCommand\r\n") OleDoc_PasteSpecialCommand((LPOLEDOC)lpOutlineDoc); OLEDBG_END3 #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); #endif break; #endif // OLE_VERSION case IDM_E_CLEAR: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_ClearCommand\r\n") OutlineDoc_ClearCommand(lpOutlineDoc); OLEDBG_END3 #if defined( OLE_CNTR ) /* OLE2NOTE: this call will attempt to recover ** resources by unloading DLL's that were loaded ** by OLE and are no longer being used. it is a ** good idea to call this API now and then if ** your app tends to run for a long time. ** otherwise these DLL's will be unloaded when ** the app exits. some apps may want to call ** this as part of idle-time processing. this ** call is optional. */ OLEDBG_BEGIN2("CoFreeUnusedLibraries called\r\n") CoFreeUnusedLibraries(); OLEDBG_END2 #endif #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); #endif break; case IDM_L_ADDLINE: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_AddTextLineCommand\r\n") OutlineDoc_AddTextLineCommand(lpOutlineDoc); OLEDBG_END3 #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); SetFocus(LineList_GetWindow(lpLL)); #endif break; case IDM_L_EDITLINE: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_EditLineCommand\r\n") OutlineDoc_EditLineCommand(lpOutlineDoc); OLEDBG_END3 SetFocus(LineList_GetWindow(lpLL)); break; case IDM_L_INDENTLINE: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_IndentCommand\r\n") OutlineDoc_IndentCommand(lpOutlineDoc); OLEDBG_END3 break; case IDM_L_UNINDENTLINE: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_UnindentCommand\r\n") OutlineDoc_UnindentCommand(lpOutlineDoc); OLEDBG_END3 break; case IDM_L_SETLINEHEIGHT: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_SetLineHeight\r\n") OutlineDoc_SetLineHeightCommand(lpOutlineDoc); OLEDBG_END3 break; case IDM_E_SELECTALL: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_SelectAllCommand\r\n") OutlineDoc_SelectAllCommand(lpOutlineDoc); OLEDBG_END3 break; #if defined( OLE_CNTR ) case IDM_E_INSERTOBJECT: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("ContainerDoc_InsertOleObjectCommand\r\n") ContainerDoc_InsertOleObjectCommand(lpContainerDoc); OLEDBG_END3 #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); #endif break; case IDM_E_EDITLINKS: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("ContainerDoc_EditLinksCommand\r\n") ContainerDoc_EditLinksCommand(lpContainerDoc); OLEDBG_END3 break; case IDM_E_CONVERTVERB: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("ContainerDoc_ConvertCommand\r\n") ContainerDoc_ConvertCommand( lpContainerDoc, FALSE /*fMustActivate*/); OLEDBG_END3 break; case IDM_E_PASTELINK: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("ContainerDoc_PasteLinkCommand\r\n") ContainerDoc_PasteLinkCommand(lpContainerDoc); OLEDBG_END3 #if defined( USE_FRAMETOOLS ) OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); #endif break; #endif // OLE_CNTR case IDM_N_DEFINENAME: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_DefineNameCommand\r\n") OutlineDoc_DefineNameCommand(lpOutlineDoc); OLEDBG_END3 break; case IDM_N_GOTONAME: OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("OutlineDoc_GotoNameCommand\r\n") OutlineDoc_GotoNameCommand(lpOutlineDoc); OLEDBG_END3 break; #if defined( USE_FRAMETOOLS ) case IDM_O_BB_TOP: FrameTools_BB_SetState( lpOutlineDoc->m_lpFrameTools, BARSTATE_TOP); OutlineDoc_AddFrameLevelTools(lpOutlineDoc); break; case IDM_O_BB_BOTTOM: FrameTools_BB_SetState( lpOutlineDoc->m_lpFrameTools, BARSTATE_BOTTOM); OutlineDoc_AddFrameLevelTools(lpOutlineDoc); break; case IDM_O_BB_POPUP: FrameTools_BB_SetState( lpOutlineDoc->m_lpFrameTools, BARSTATE_POPUP); OutlineDoc_AddFrameLevelTools(lpOutlineDoc); break; case IDM_O_BB_HIDE: FrameTools_BB_SetState( lpOutlineDoc->m_lpFrameTools, BARSTATE_HIDE); OutlineDoc_AddFrameLevelTools(lpOutlineDoc); break; case IDM_O_FB_TOP: FrameTools_FB_SetState( lpOutlineDoc->m_lpFrameTools, BARSTATE_TOP); OutlineDoc_AddFrameLevelTools(lpOutlineDoc); break; case IDM_O_FB_BOTTOM: FrameTools_FB_SetState( lpOutlineDoc->m_lpFrameTools, BARSTATE_BOTTOM); OutlineDoc_AddFrameLevelTools(lpOutlineDoc); break; case IDM_O_FB_POPUP: FrameTools_FB_SetState( lpOutlineDoc->m_lpFrameTools, BARSTATE_POPUP); OutlineDoc_AddFrameLevelTools(lpOutlineDoc); break; case IDM_FB_EDIT: switch (wNotifyCode) { case EN_SETFOCUS: OutlineDoc_SetFormulaBarEditFocus( lpOutlineDoc, TRUE); OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); break; case EN_KILLFOCUS: OutlineDoc_SetFormulaBarEditFocus( lpOutlineDoc, FALSE); OutlineDoc_UpdateFrameToolButtons(lpOutlineDoc); break; } break; case IDM_FB_CANCEL: SetFocus(hWnd); break; case IDM_F2: SendMessage(hWnd, WM_COMMAND, (WPARAM)IDM_FB_EDIT, MAKELONG(0, EN_SETFOCUS)); break; #endif // USE_FRAMETOOLS case IDM_ESCAPE: /* ESCAPE key pressed */ #if defined( USE_FRAMETOOLS ) if (OutlineDoc_IsEditFocusInFormulaBar(lpOutlineDoc)) SendMessage( hWnd, WM_COMMAND,(WPARAM)IDM_FB_CANCEL,(LPARAM)0); #endif // USE_FRAMETOOLS #if defined( INPLACE_SVR ) else { LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc; /* OLE2NOTE: The standard OLE 2.0 UI convention ** is to have ESCAPE key exit in-place ** activation (ie. UIDeactivate). If ** possible it is recommended for both ** in-place servers AND in-place containers ** to take responsibility to handle the ** ESCAPE key accelerator. The server has ** the first crack at handling accelerator ** keys and normally the server should do ** the UIDeactivation. */ if (lpServerDoc->m_fUIActive) { SvrDoc_IPObj_UIDeactivate( (LPOLEINPLACEOBJECT)& lpServerDoc->m_OleInPlaceObject); } } #endif // INPLACE_SVR break; #if defined( USE_HEADING ) case IDC_BUTTON: if (wNotifyCode == BN_CLICKED) { SendMessage(hWnd, WM_COMMAND, IDM_E_SELECTALL, 0L); SetFocus(hWnd); } break; case IDM_O_HEAD_SHOW: OutlineDoc_ShowHeading(lpOutlineDoc, TRUE); break; case IDM_O_HEAD_HIDE: OutlineDoc_ShowHeading(lpOutlineDoc, FALSE); break; #endif // USE_HEADING #if defined( OLE_CNTR ) case IDM_O_SHOWOBJECT: { LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc; BOOL fShowObject; fShowObject = !ContainerDoc_GetShowObjectFlag( lpContainerDoc); ContainerDoc_SetShowObjectFlag( lpContainerDoc, fShowObject); LineList_ForceRedraw(lpLL, TRUE); break; } #endif // OLE_CNTR #if !defined( OLE_CNTR ) // Container does not allow zoom factors > 100% case IDM_V_ZOOM_400: case IDM_V_ZOOM_300: case IDM_V_ZOOM_200: #endif // !OLE_CNTR case IDM_V_ZOOM_100: case IDM_V_ZOOM_75: case IDM_V_ZOOM_50: case IDM_V_ZOOM_25: OutlineDoc_SetCurrentZoomCommand(lpOutlineDoc, wID); break; case IDM_V_SETMARGIN_0: case IDM_V_SETMARGIN_1: case IDM_V_SETMARGIN_2: case IDM_V_SETMARGIN_3: case IDM_V_SETMARGIN_4: OutlineDoc_SetCurrentMarginCommand(lpOutlineDoc, wID); break; case IDM_V_ADDTOP_1: case IDM_V_ADDTOP_2: case IDM_V_ADDTOP_3: case IDM_V_ADDTOP_4: { UINT nHeightInHimetric; switch (wID) { case IDM_V_ADDTOP_1: nHeightInHimetric = 1000; break; case IDM_V_ADDTOP_2: nHeightInHimetric = 2000; break; case IDM_V_ADDTOP_3: nHeightInHimetric = 3000; break; case IDM_V_ADDTOP_4: nHeightInHimetric = 4000; break; } OutlineDoc_AddTopLineCommand( lpOutlineDoc, nHeightInHimetric); break; } case IDM_H_ABOUT: OutlineApp_AboutCommand(lpOutlineApp); break; case IDM_D_DEBUGLEVEL: SetDebugLevelCommand(); break; #if defined( OLE_VERSION ) case IDM_D_INSTALLMSGFILTER: InstallMessageFilterCommand(); break; case IDM_D_REJECTINCOMING: RejectIncomingCommand(); break; #endif // OLE_VERSION #if defined( INPLACE_CNTR ) case IDM_D_INSIDEOUT: g_fInsideOutContainer = !g_fInsideOutContainer; // force all object to unload so they can start new // activation behavior. ContainerDoc_UnloadAllOleObjectsOfClass( (LPCONTAINERDOC)lpOutlineDoc, &CLSID_NULL, OLECLOSE_SAVEIFDIRTY ); OutlineDoc_ForceRedraw(lpOutlineDoc, TRUE); break; #endif // INPLACE_CNTR #if defined( OLE_CNTR ) case IDC_LINELIST: { if (wNotifyCode == LBN_DBLCLK) { /* OLE2NOTE: a container should execute the ** OLEIVERB_PRIMARY verb on an OLE object ** when the user DBLCLK's the object. */ int nIndex = LineList_GetFocusLineIndex(lpLL); LPLINE lpLine = LineList_GetLine(lpLL, nIndex); if (lpLine && Line_GetLineType(lpLine)==CONTAINERLINETYPE) { MSG msg; _fmemset((LPMSG)&msg,0,sizeof(msg)); msg.hwnd = hWnd; msg.message = Message; msg.wParam = wParam; msg.lParam = lParam; ContainerLine_DoVerb( (LPCONTAINERLINE)lpLine, OLEIVERB_PRIMARY, (LPMSG)&msg, TRUE, TRUE ); } #if defined( INPLACE_CNTR ) { // BEGIN BLOCK LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC) lpOutlineDoc; if (lpContainerDoc->m_fAddMyUI) { /* OLE2NOTE: fAddMyUI is TRUE when ** there was previously an in-place ** active object which got ** UIDeactivated as a result of this ** DBLCLK AND the DBLCLK did NOT ** result in in-place activating ** another object. ** (see IOleInPlaceSite::OnUIActivate and ** IOleInPlaceSite::OnUIDeactivate ** methods). */ /* OLE2NOTE: You need to generate ** QueryNewPalette only if you own ** the top level frame (ie. you are ** a top-level inplace container). */ OleApp_QueryNewPalette((LPOLEAPP)g_lpApp); #if defined( USE_DOCTOOLS ) ContainerDoc_AddDocLevelTools(lpContainerDoc); #endif #if defined( USE_FRAMETOOLS ) ContainerDoc_AddFrameLevelUI(lpContainerDoc); #endif lpContainerDoc->m_fAddMyUI = FALSE; } } // END BLOCK #endif // INPLACE_CNTR } break; } #endif // OLE_CNTR default: #if defined( OLE_CNTR ) if (wID >= IDM_E_OBJECTVERBMIN) { OleDbgOutNoPrefix2("\r\n"); OLEDBG_BEGIN3("ContainerDoc_ContainerLineDoVerbCommand\r\n") ContainerDoc_ContainerLineDoVerbCommand( (LPCONTAINERDOC)lpOutlineDoc, (LONG)(wID-IDM_E_OBJECTVERBMIN) ); OLEDBG_END3 break; } #endif // OLE_CNTR return DefWindowProc(hWnd, Message, wParam, lParam); } break; /* End of WM_COMMAND */ } default: if (Message == g_uMsgHelp) { /* Handle OLE2UI dialog's help messages. ** We get the hDlg of the dialog that called us in the wParam ** and the dialog type in the LOWORD of the lParam, ** so we pass this along to our help function. */ OutlineDoc_DialogHelp((HWND)wParam, LOWORD(lParam)); break; } /* For any message for which you don't specifically provide a */ /* service routine, you should return the message to Windows */ /* for default message processing. */ return DefWindowProc(hWnd, Message, wParam, lParam); } return (LRESULT)0; } /* End of DocWndProc */ //*********************************************************************** //* //* LineListWndProc() Drag and Drop Listbox Window Proc Sub-Class //* //* Sub Class the Ownerdraw list box in order to activate the drag drop. //*********************************************************************** LRESULT FAR PASCAL LineListWndProc( HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam ) { HWND hwndParent = GetParent ( hWnd ); LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp; LPOUTLINEDOC lpOutlineDoc = (LPOUTLINEDOC) GetWindowLong( hwndParent, 0 ); LPLINELIST lpLL = OutlineDoc_GetLineList(lpOutlineDoc); #if defined( OLE_VERSION ) LPOLEAPP lpOleApp = (LPOLEAPP)lpOutlineApp; LPOLEDOC lpOleDoc = (LPOLEDOC)lpOutlineDoc; #endif // OLE_VERSION #if defined( INPLACE_SVR ) LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc; static BOOL fUIActivateClick = FALSE; static BOOL fInWinPosChged = FALSE; #endif // INPLACE_SVR #if defined( INPLACE_CNTR ) LPCONTAINERAPP lpContainerApp=(LPCONTAINERAPP)lpOutlineApp; LPCONTAINERDOC lpContainerDoc=(LPCONTAINERDOC)lpOutlineDoc; #endif // INPLACE_CNTR switch (Message) { case WM_KILLFOCUS: /* OLE2NOTE: when our window looses focus we ** should not display any active selection */ #if defined( INPLACE_CNTR ) if (! lpContainerApp->m_fPendingUIDeactivate) #endif // INPLACE_CNTR LineList_RemoveSel(lpLL); break; case WM_SETFOCUS: #if defined( INPLACE_CNTR ) { HWND hWndObj=ContainerDoc_GetUIActiveWindow(lpContainerDoc); /* OLE2NOTE: if there is a UIActive in-place object, we must ** forward focus to its window as long as there is ** not a pending UIDeactivate. if the mouse is ** clicked outside of the object and the object is ** about to be deactivated then we do NOT want to ** forward focus to the object. we do NOT want it to ** restore its selection feedback. */ if (lpContainerApp->m_fPendingUIDeactivate) break; else if (hWndObj) { SetFocus(hWndObj); break; // do not restore containers selection state } } #endif // INPLACE_CNTR /* OLE2NOTE: when our window gains focus we ** should restore the previous selection */ LineList_RestoreSel(lpLL); break; #if defined( INPLACE_SVR ) case WM_MOUSEACTIVATE: { if (lpServerDoc->m_fInPlaceActive && !lpServerDoc->m_fUIActive) { fUIActivateClick = TRUE; }; break; } #endif // INPLACE_SVR #if defined( USE_FRAMETOOLS ) case WM_CHAR: { OutlineDoc_SetFormulaBarEditFocus(lpOutlineDoc, TRUE); FrameTools_FB_SetEditText(lpOutlineDoc->m_lpFrameTools, NULL); FrameTools_FB_SendMessage( lpOutlineDoc->m_lpFrameTools, IDM_FB_EDIT, Message, wParam, lParam ); return (LRESULT)0; // don't do default listbox processing } #endif // USE_FRAMETOOLS #if defined( INPLACE_CNTR ) case WM_VSCROLL: { if (wParam == SB_ENDSCROLL) { /* OLE2NOTE: after scrolling finishes, update position of ** in-place visible windows. ** (ICNTROTL specific) we first let the ListBox ** perform it normal processing with the EndScroll ** message. also we let the ListBox handle all other ** scroll messages. */ LRESULT lResult = CallWindowProc( (WNDPROC)lpOutlineApp->m_ListBoxWndProc, hWnd, Message, wParam, lParam ); ContainerDoc_UpdateInPlaceObjectRects(lpContainerDoc, 0); return lResult; } break; } #endif // INPLACR_CNTR #if defined( USE_HEADING ) case WM_HSCROLL: { LPHEADING lphead = OutlineDoc_GetHeading(lpOutlineDoc); Heading_CH_SendMessage(lphead, Message, wParam, lParam); break; } /* NOTE: WM_PAINT trapped in order to track vertical scrolling ** that has taken place so the row headings can be ** coordinated with the LineList. we wanted to trap instead ** but it is not generated from scrolling without using ** scroll bar (e.g. use keyboard). */ case WM_PAINT: { Heading_RH_Scroll(OutlineDoc_GetHeading(lpOutlineDoc), hWnd); break; } #endif // USE_HEADING case WM_LBUTTONUP: { #if defined( USE_DRAGDROP ) if (lpOleDoc->m_fPendingDrag) { /* ButtonUP came BEFORE distance/time threshholds were ** exceeded. clear fPendingDrag state. */ ReleaseCapture(); KillTimer(hWnd, 1); lpOleDoc->m_fPendingDrag = FALSE; } #endif // USE_DRAGDROP #if defined( INPLACE_SVR ) if (fUIActivateClick) { fUIActivateClick = FALSE; ServerDoc_UIActivate((LPSERVERDOC) lpOleDoc); } #endif // INPLACE_SVR #if defined( INPLACE_CNTR ) { /* check if a UIDeactivate is pending. ** (see comment in WM_LBUTTONDOWN) */ if ( lpContainerApp->m_fPendingUIDeactivate ) { ContainerLine_UIDeactivate( lpContainerDoc->m_lpLastUIActiveLine); lpContainerApp->m_fPendingUIDeactivate = FALSE; } } #endif // INPLACE_CNTR break; } case WM_LBUTTONDOWN: { POINT pt; pt.x = (int)(short)LOWORD (lParam ); pt.y = (int)(short)HIWORD (lParam ); #if defined( INPLACE_SVR ) || defined( INPLACE_CNTR ) /* OLE2NOTE: see context sensitive help technote (CSHELP.DOC) ** m_fCSHelpMode flag is set when SHIFT-F1 context ** sensitive help is entered. ** if this flag is set then the button click should not ** cause any action. if the application implements a ** help system, then context sensitive help should be ** given for the location clicked by the user. */ if (lpOleDoc->m_fCSHelpMode) { return (LRESULT)0; // eat the button click because we do // not give any help. } #endif // INPLACE_SVR || INPLACE_CNTR #if defined( INPLACE_CNTR ) { /* OLE2NOTE: both inside-out and outside-in style ** containers must check if the mouse click is ** outside of the current UIActive object (if ** any). If so, then set the flag indicating that ** there is a pending UIDeactivate needed. We do NOT ** want to do it now, ** because that would result in un-wanted movement of ** the data on the screen as frame adornments (eg. ** toolbar) and/or object adornments (eg. ruler) would ** be removed from the screen. we want to defer the ** UIDeactivate till the mouse up event. The listbox's ** default processing captures the mouse on button down ** so that it is sure to get the button up message. ** ** SPECIAL NOTE: there is potential interaction here ** with Drag/Drop. if this button down event actually ** starts a Drag/Drop operation, then OLE does the mouse ** capture. in this situation we will NOT get our button ** up event. we must instead perform the UIDeactivate ** when the drop operation finishes */ lpContainerApp->m_fPendingUIDeactivate = ContainerDoc_IsUIDeactivateNeeded(lpContainerDoc, pt); } #endif // INPLACE_CNTR #if defined( USE_DRAGDROP ) /* OLE2NOTE: check if this is a button down on the region ** that is a handle to start a drag operation. for us, ** this this the top/bottom border of the selection. ** do NOT want to start a drag immediately; we want to ** wait until the mouse moves a certain threshold. if ** LButtonUp comes before mouse move to start drag, then ** the fPendingDrag state is cleared. we must capture ** the mouse to ensure the modal state is handled ** properly. */ if ( OleDoc_QueryDrag(lpOleDoc, pt.y) ) { lpOleDoc->m_fPendingDrag = TRUE; lpOleDoc->m_ptButDown = pt; SetTimer(hWnd, 1, lpOleApp->m_nDragDelay, NULL); SetCapture(hWnd); /* We do NOT want to do the listbox's default ** processing which would be to capture the mouse ** and enter a modal multiple selection state until ** a mouse up occurs. we have just finished a modal ** drag/drop operation where OLE has captured the ** mouse. thus by now the mouse up has already occured. */ return (LRESULT)0; // don't do default listbox processing } #endif // USE_DRAGDROP break; } case WM_MOUSEMOVE: { #if defined( USE_DRAGDROP ) int x = (int)(short)LOWORD (lParam ); int y = (int)(short)HIWORD (lParam ); POINT pt = lpOleDoc->m_ptButDown; int nDragMinDist = lpOleApp->m_nDragMinDist; if (lpOleDoc->m_fPendingDrag) { if (! ( ((pt.x - nDragMinDist) <= x) && (x <= (pt.x + nDragMinDist)) && ((pt.y - nDragMinDist) <= y) && (y <= (pt.y + nDragMinDist)) ) ) { DWORD dwEffect; // mouse moved beyond threshhold to start drag ReleaseCapture(); KillTimer(hWnd, 1); lpOleDoc->m_fPendingDrag = FALSE; // perform the modal drag/drop operation. dwEffect = OleDoc_DoDragDrop( lpOleDoc ); #if defined( INPLACE_CNTR ) { /* if necessary UIDeactive the in-place object. ** this applies to outside-in style ** container only. ** (see comment above) */ if (lpContainerApp->m_fPendingUIDeactivate) { lpContainerApp->m_fPendingUIDeactivate = FALSE; // do not UIDeactivate if drag/drop was canceled if (dwEffect != DROPEFFECT_NONE) ContainerLine_UIDeactivate( lpContainerDoc->m_lpLastUIActiveLine ); } } #endif // INPLACE_CNTR return (LRESULT)0; // don't do default listbox process } else { /* cursor did not move from initial mouse down ** (pending drag) point. */ return (LRESULT)0; // don't do default listbox process } } #endif // USE_DRAGDROP #if defined( INPLACE_CNTR ) { // BEGIN BLOCK if (lpContainerDoc->m_fAddMyUI) { /* OLE2NOTE: fAddMyUI is TRUE when ** there was previously an in-place ** active object which got ** UIDeactivated as a result of a ** DBLCLK AND the DBLCLK did NOT ** result in in-place activating ** another object. ** (see IOleInPlaceSite::OnUIActivate and ** IOleInPlaceSite::OnUIDeactivate ** methods). */ #if defined( USE_DOCTOOLS ) ContainerDoc_AddDocLevelTools(lpContainerDoc); #endif #if defined( USE_FRAMETOOLS ) ContainerDoc_AddFrameLevelUI(lpContainerDoc); #endif lpContainerDoc->m_fAddMyUI = FALSE; } } // END BLOCK #endif // INPLACE_CNTR break; } #if defined( USE_DRAGDROP ) case WM_TIMER: { DWORD dwEffect; // drag time delay threshhold exceeded -- start drag ReleaseCapture(); KillTimer(hWnd, 1); lpOleDoc->m_fPendingDrag = FALSE; // perform the modal drag/drop operation. dwEffect = OleDoc_DoDragDrop( lpOleDoc ); #if defined( INPLACE_CNTR ) /* if necessary UIDeactive the in-place object. ** this applies to outside-in style ** container only. ** (see comment above) */ if (lpContainerApp->m_fPendingUIDeactivate) { lpContainerApp->m_fPendingUIDeactivate = FALSE; // do not UIDeactivate if drag/drop was canceled if (dwEffect != DROPEFFECT_NONE) ContainerLine_UIDeactivate( lpContainerDoc->m_lpLastUIActiveLine); } #endif // INPLACE_CNTR break; } #endif // USE_DRAGDROP case WM_SETCURSOR: { RECT rc; POINT ptCursor; #if defined( INPLACE_SVR ) || defined( INPLACE_CNTR ) /* OLE2NOTE: see context sensitive help technote (CSHELP.DOC) ** m_fCSHelpMode flag is set when SHIFT-F1 context ** sensitive help is entered. ** if this flag is set then the context sensitive help ** cursor should be shown. */ if (lpOleDoc->m_fCSHelpMode) { SetCursor(UICursorLoad(IDC_CONTEXTHELP)); return (LRESULT)TRUE; } #endif // INPLACE_SVR || INPLACE_CNTR GetCursorPos((POINT FAR*)&ptCursor); ScreenToClient(hWnd, (POINT FAR*)&ptCursor); GetClientRect(hWnd, (LPRECT)&rc); // use arrow cursor if in scroll bar if (! PtInRect((LPRECT)&rc, ptCursor) ) SetCursor(LoadCursor(NULL, IDC_ARROW) ); #if defined( USE_DRAGDROP ) // use arrow cursor if on drag handle (top/bottom of selection) else if ( OleDoc_QueryDrag ( lpOleDoc, ptCursor.y) ) SetCursor(LoadCursor(NULL, IDC_ARROW) ); #endif // USE_DRAGDROP else SetCursor(lpOutlineApp->m_hcursorSelCur); return (LRESULT)TRUE; } #if defined( INPLACE_SVR ) /* The handling of WM_WINDOWPOSCHANGED message is ISVROTL ** application specific. The nature of the owner-draw list ** box used by the ISVROTL application causes a recursive ** call to this message in some situations when in-place ** active. in order not to crash this recursive call must be ** guarded. */ case WM_WINDOWPOSCHANGED: { WINDOWPOS FAR* lpWinPos = (WINDOWPOS FAR*) lParam; LRESULT lResult; // guard against recursive call if (fInWinPosChged) return (LRESULT)0; fInWinPosChged = TRUE; lResult = CallWindowProc( (WNDPROC)lpOutlineApp->m_ListBoxWndProc, hWnd, Message, wParam, lParam ); fInWinPosChged = FALSE; return lResult; } #endif // INPLACE_SVR } return CallWindowProc( (WNDPROC)lpOutlineApp->m_ListBoxWndProc, hWnd, Message, wParam, lParam ); } // Utility function to count the number of accelerator items in an // accelerator table. A number of OLE APIs need this count, so // this can be quite handy. // (code shamelessly stolen from the Microsoft Foundation Classes) int GetAccelItemCount(HACCEL hAccel) { #if defined( WIN32 ) return CopyAcceleratorTable(hAccel, NULL, 0); #else #pragma pack(1) typedef struct tagACCELERATOR { BYTE fFlags; WORD wEvent; WORD wID; } ACCELERATOR; #pragma pack() // attempt to lock down the accelerator resource ACCELERATOR FAR* pAccel; int cAccelItems = 1; if (hAccel == NULL || (pAccel = (ACCELERATOR FAR*)LockResource((HGLOBAL)hAccel)) == NULL) { // NULL accerator table or LockResource failed on the HACCEL, // no accelerators return 0; } // otherwise, count them -- last entry in accel table has 0x80 bit set while ((pAccel->fFlags & 0x80) == 0) { ++cAccelItems; ++pAccel; } UnlockResource((HGLOBAL)hAccel); return cAccelItems; #endif }