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.
1075 lines
27 KiB
1075 lines
27 KiB
/*************************************************************************
|
|
**
|
|
** OLE 2 Server Sample Code
|
|
**
|
|
** frametls.c
|
|
**
|
|
** This file contains all FrameTools methods and related support
|
|
** functions. The FrameTools object is an encapsulation of the apps
|
|
** formula bar and button bar.
|
|
**
|
|
** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
|
|
**
|
|
*************************************************************************/
|
|
|
|
#include "outline.h"
|
|
|
|
OLEDBGDATA
|
|
|
|
/* private function prototype */
|
|
static void Bar_Move(LPBAR lpbar, LPRECT lprcClient, LPRECT lprcPopup);
|
|
static void FB_ResizeEdit(LPBAR lpbar);
|
|
|
|
extern LPOUTLINEAPP g_lpApp;
|
|
extern RECT g_rectNull;
|
|
|
|
/*
|
|
* FrameToolsRegisterClass
|
|
*
|
|
* Purpose:
|
|
* Register the popup toolbar window class
|
|
*
|
|
* Parameters:
|
|
* hInst Process instance
|
|
*
|
|
* Return Value:
|
|
* TRUE if successful
|
|
* FALSE if failed
|
|
*
|
|
*/
|
|
BOOL FrameToolsRegisterClass(HINSTANCE hInst)
|
|
{
|
|
WNDCLASS wc;
|
|
|
|
// Register Tool Palette Class
|
|
wc.style = CS_BYTEALIGNWINDOW;
|
|
wc.lpfnWndProc = FrameToolsWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 4;
|
|
wc.hInstance = hInst;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = CLASS_PALETTE;
|
|
|
|
if (!RegisterClass(&wc))
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static BOOL FrameTools_CreatePopupPalette(LPFRAMETOOLS lpft, HWND hWndFrame)
|
|
{
|
|
if (lpft->m_hWndPopupPalette)
|
|
DestroyWindow(lpft->m_hWndPopupPalette);
|
|
|
|
lpft->m_hWndPopupPalette = CreateWindow(
|
|
CLASS_PALETTE,
|
|
"Tool Palette",
|
|
WS_POPUP | WS_CAPTION | WS_CLIPCHILDREN,
|
|
CW_USEDEFAULT, 0, 0, 0,
|
|
hWndFrame,
|
|
(HMENU)NULL,
|
|
g_lpApp->m_hInst,
|
|
0L
|
|
);
|
|
|
|
if (!lpft->m_hWndPopupPalette)
|
|
return FALSE;
|
|
|
|
SetWindowLong(lpft->m_hWndPopupPalette, 0, (LONG)lpft);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_Init
|
|
*
|
|
* Purpose:
|
|
* Init and create the toolbar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* hWndParent The window which owns the toolbar
|
|
* hInst Process instance
|
|
*
|
|
* Return Value:
|
|
* TRUE if successful
|
|
* FALSE if failed
|
|
*
|
|
*/
|
|
BOOL FrameTools_Init(LPFRAMETOOLS lpft, HWND hWndParent, HINSTANCE hInst)
|
|
{
|
|
RECT rc;
|
|
UINT uPos;
|
|
UINT dx;
|
|
UINT dy;
|
|
|
|
if (!lpft || !hWndParent || !hInst)
|
|
return FALSE;
|
|
|
|
//Get BTTNCUR's display information
|
|
UIToolConfigureForDisplay(&lpft->m_tdd);
|
|
|
|
dx=lpft->m_tdd.cxButton;
|
|
dy=lpft->m_tdd.cyButton;
|
|
|
|
// 15 is calculated from the total number of buttons and separators
|
|
lpft->m_uPopupWidth = dx * 15;
|
|
|
|
lpft->m_hWndApp = hWndParent;
|
|
lpft->m_ButtonBar.m_nState = BARSTATE_TOP;
|
|
lpft->m_FormulaBar.m_nState = BARSTATE_TOP;
|
|
lpft->m_fInFormulaBar = FALSE;
|
|
|
|
lpft->m_fToolsDisabled = FALSE;
|
|
|
|
lpft->m_ButtonBar.m_uHeight = lpft->m_tdd.cyBar;
|
|
lpft->m_FormulaBar.m_uHeight = lpft->m_tdd.cyBar;
|
|
|
|
|
|
//Get our image bitmaps for the display type we're on
|
|
if (72 == lpft->m_tdd.uDPI)
|
|
lpft->m_hBmp = LoadBitmap(hInst, (LPCSTR)"Image72");
|
|
if (96 == lpft->m_tdd.uDPI)
|
|
lpft->m_hBmp = LoadBitmap(hInst, (LPCSTR)"Image96");
|
|
if (120 == lpft->m_tdd.uDPI)
|
|
lpft->m_hBmp = LoadBitmap(hInst, (LPCSTR)"Image120");
|
|
|
|
if (!lpft->m_hBmp)
|
|
return FALSE;
|
|
|
|
/* Create Popup Tool Palette window */
|
|
lpft->m_hWndPopupPalette = NULL;
|
|
if (! FrameTools_CreatePopupPalette(lpft, hWndParent))
|
|
return FALSE;
|
|
|
|
uPos = 0;
|
|
//Create the GizmoBar and the client area window
|
|
GetClientRect(hWndParent, &rc);
|
|
lpft->m_ButtonBar.m_hWnd = CreateWindow(
|
|
CLASS_GIZMOBAR,
|
|
"ButtonBar",
|
|
WS_CHILD | WS_VISIBLE,
|
|
0, 0, rc.right-rc.left, lpft->m_tdd.cyBar,
|
|
hWndParent,
|
|
(HMENU)IDC_GIZMOBAR,
|
|
hInst,
|
|
0L
|
|
);
|
|
|
|
if (!lpft->m_ButtonBar.m_hWnd)
|
|
return FALSE;
|
|
|
|
|
|
SendMessage(lpft->m_ButtonBar.m_hWnd, WM_SETREDRAW, FALSE, 0L);
|
|
|
|
//File new, open, save, print
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_F_NEW, dx, dy, NULL, NULL, TOOLIMAGE_FILENEW, GIZMO_NORMAL);
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_F_OPEN, dx, dy, NULL, NULL, TOOLIMAGE_FILEOPEN, GIZMO_NORMAL);
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_F_SAVE, dx, dy, NULL, NULL, TOOLIMAGE_FILESAVE, GIZMO_NORMAL);
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_F_PRINT, dx, dy, NULL, NULL, TOOLIMAGE_FILEPRINT, GIZMO_NORMAL);
|
|
|
|
// separator
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_SEPARATOR, uPos++, 0, dx/2, dy, NULL, NULL, 0, GIZMO_NORMAL);
|
|
|
|
// Edit cut, copy, paste
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_E_CUT, dx, dy, NULL, NULL, TOOLIMAGE_EDITCUT, GIZMO_NORMAL);
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_E_COPY, dx, dy, NULL, NULL, TOOLIMAGE_EDITCOPY, GIZMO_NORMAL);
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_E_PASTE, dx, dy, NULL, NULL, TOOLIMAGE_EDITPASTE, GIZMO_NORMAL);
|
|
|
|
// separator
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_SEPARATOR, uPos++, 0, dx/2, dy, NULL, NULL, 0, GIZMO_NORMAL);
|
|
|
|
// Line indent, unindent
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_L_UNINDENTLINE, dx, dy, NULL, lpft->m_hBmp, IDB_UNINDENTLINE, GIZMO_NORMAL);
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_L_INDENTLINE, dx, dy, NULL, lpft->m_hBmp, IDB_INDENTLINE, GIZMO_NORMAL);
|
|
|
|
// separator
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_SEPARATOR, uPos++, 0, dx/2, dy, NULL, NULL, 0, GIZMO_NORMAL);
|
|
|
|
// Help
|
|
GBGizmoAdd(lpft->m_ButtonBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_H_ABOUT, dx, dy, NULL, NULL, TOOLIMAGE_HELP, GIZMO_NORMAL);
|
|
|
|
SendMessage(lpft->m_ButtonBar.m_hWnd, WM_SETREDRAW, TRUE, 0L);
|
|
|
|
|
|
uPos = 0;
|
|
lpft->m_FormulaBar.m_hWnd = CreateWindow(
|
|
CLASS_GIZMOBAR,
|
|
"FormulaBar",
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
|
|
0, lpft->m_tdd.cyBar, rc.right-rc.left, lpft->m_tdd.cyBar,
|
|
hWndParent,
|
|
(HMENU)IDC_FORMULABAR,
|
|
hInst,
|
|
0L
|
|
);
|
|
|
|
if (!lpft->m_FormulaBar.m_hWnd)
|
|
return FALSE;
|
|
|
|
SendMessage(lpft->m_FormulaBar.m_hWnd, WM_SETREDRAW, FALSE, 0L);
|
|
|
|
// Line add line
|
|
GBGizmoAdd(lpft->m_FormulaBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_L_ADDLINE, dx, dy, NULL, lpft->m_hBmp, IDB_ADDLINE, GIZMO_NORMAL);
|
|
|
|
// separator
|
|
GBGizmoAdd(lpft->m_FormulaBar.m_hWnd, GIZMOTYPE_SEPARATOR, uPos++, 0, dx/2, dy, NULL, NULL, 0, GIZMO_NORMAL);
|
|
|
|
// Line edit line, Cancel
|
|
GBGizmoAdd(lpft->m_FormulaBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_L_EDITLINE, dx, dy, NULL, lpft->m_hBmp, IDB_EDITLINE, GIZMO_NORMAL);
|
|
GBGizmoAdd(lpft->m_FormulaBar.m_hWnd, GIZMOTYPE_BUTTONCOMMAND, uPos++, IDM_FB_CANCEL, dx, dy, NULL, lpft->m_hBmp, IDB_CANCEL, GIZMO_NORMAL);
|
|
|
|
// separator
|
|
GBGizmoAdd(lpft->m_FormulaBar.m_hWnd, GIZMOTYPE_SEPARATOR, uPos++, 0, dx/2, dy, NULL, NULL, 0, GIZMO_NORMAL);
|
|
|
|
// Edit control for line input
|
|
GBGizmoAdd(lpft->m_FormulaBar.m_hWnd, GIZMOTYPE_EDIT, uPos++, IDM_FB_EDIT, dx*10, lpft->m_tdd.cyBar-5, NULL, NULL, 0, GIZMO_NORMAL);
|
|
|
|
|
|
SendMessage(lpft->m_FormulaBar.m_hWnd, WM_SETREDRAW, TRUE, 0L);
|
|
|
|
// Limit the text lenght of edit control
|
|
GBGizmoSendMessage(lpft->m_FormulaBar.m_hWnd, IDM_FB_EDIT, EM_LIMITTEXT,
|
|
(WPARAM)MAXSTRLEN, 0L);
|
|
|
|
//Set the GizmoBar's associate to be this client window
|
|
GBHwndAssociateSet(lpft->m_ButtonBar.m_hWnd, hWndParent);
|
|
|
|
//Set the FormulaBar's associate to be this client window
|
|
GBHwndAssociateSet(lpft->m_FormulaBar.m_hWnd, hWndParent);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void FrameTools_AttachToFrame(LPFRAMETOOLS lpft, HWND hWndFrame)
|
|
{
|
|
if (! lpft)
|
|
return;
|
|
|
|
if (hWndFrame == NULL)
|
|
hWndFrame = OutlineApp_GetFrameWindow((LPOUTLINEAPP)g_lpApp);
|
|
|
|
if (lpft->m_hWndApp == hWndFrame)
|
|
return; // already have this parent frame
|
|
|
|
lpft->m_hWndApp = hWndFrame;
|
|
|
|
/* parent the tool bars to the frame so we can safely
|
|
** destroy/recreate the palette window.
|
|
*/
|
|
SetParent(lpft->m_ButtonBar.m_hWnd, hWndFrame);
|
|
SetParent(lpft->m_FormulaBar.m_hWnd, hWndFrame);
|
|
|
|
// recreate popup palette so that it is owned by the hWndFrame
|
|
FrameTools_CreatePopupPalette(lpft, hWndFrame);
|
|
|
|
// restore the correct parent for the tool bars
|
|
FrameTools_BB_SetState(lpft, lpft->m_ButtonBar.m_nState);
|
|
FrameTools_FB_SetState(lpft, lpft->m_FormulaBar.m_nState);
|
|
}
|
|
|
|
|
|
void FrameTools_AssociateDoc(LPFRAMETOOLS lpft, LPOUTLINEDOC lpOutlineDoc)
|
|
{
|
|
HWND hWnd = OutlineDoc_GetWindow(lpOutlineDoc);
|
|
|
|
if (! lpft)
|
|
return;
|
|
|
|
// if no Doc is given, then associate with the App's frame window.
|
|
if (lpOutlineDoc)
|
|
hWnd = OutlineDoc_GetWindow(lpOutlineDoc);
|
|
else
|
|
hWnd = OutlineApp_GetWindow((LPOUTLINEAPP)g_lpApp);
|
|
|
|
//Set the GizmoBar's associate to be this client window
|
|
GBHwndAssociateSet(lpft->m_ButtonBar.m_hWnd, hWnd);
|
|
|
|
//Set the FormulaBar's associate to be this client window
|
|
GBHwndAssociateSet(lpft->m_FormulaBar.m_hWnd, hWnd);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_Destroy
|
|
*
|
|
* Purpose:
|
|
* Destroy the toolbar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_Destroy(LPFRAMETOOLS lpft)
|
|
{
|
|
if (!lpft)
|
|
return;
|
|
|
|
if (IsWindow(lpft->m_ButtonBar.m_hWnd))
|
|
DestroyWindow(lpft->m_ButtonBar.m_hWnd);
|
|
if (IsWindow(lpft->m_FormulaBar.m_hWnd))
|
|
DestroyWindow(lpft->m_FormulaBar.m_hWnd);
|
|
if (IsWindow(lpft->m_hWndPopupPalette))
|
|
DestroyWindow(lpft->m_hWndPopupPalette);
|
|
|
|
if (lpft->m_hBmp)
|
|
DeleteObject(lpft->m_hBmp);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_Move
|
|
*
|
|
* Purpose:
|
|
* Move and resize the toolbar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* lprc Pointer to client rectangle
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_Move(LPFRAMETOOLS lpft, LPRECT lprcClient)
|
|
{
|
|
RECT rcPopup;
|
|
LPRECT lprcPopup = (LPRECT)&rcPopup;
|
|
int nCmdShow = SW_HIDE;
|
|
|
|
if (!lpft || lpft->m_fToolsDisabled)
|
|
return;
|
|
|
|
lprcPopup->left = 0;
|
|
lprcPopup->top = 0;
|
|
lprcPopup->right = lpft->m_uPopupWidth;
|
|
lprcPopup->bottom = lpft->m_ButtonBar.m_uHeight +
|
|
lpft->m_FormulaBar.m_uHeight;
|
|
|
|
switch (lpft->m_ButtonBar.m_nState) {
|
|
case BARSTATE_HIDE:
|
|
case BARSTATE_POPUP:
|
|
case BARSTATE_TOP:
|
|
Bar_Move(&lpft->m_ButtonBar, lprcClient, lprcPopup);
|
|
Bar_Move(&lpft->m_FormulaBar, lprcClient, lprcPopup);
|
|
break;
|
|
|
|
case BARSTATE_BOTTOM:
|
|
Bar_Move(&lpft->m_FormulaBar, lprcClient, lprcPopup);
|
|
Bar_Move(&lpft->m_ButtonBar, lprcClient, lprcPopup);
|
|
break;
|
|
}
|
|
|
|
if (lprcPopup->top) {
|
|
SetWindowPos(lpft->m_hWndPopupPalette, NULL, 0, 0, lprcPopup->right,
|
|
lprcPopup->top + GetSystemMetrics(SM_CYCAPTION),
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
}
|
|
else
|
|
ShowWindow(lpft->m_hWndPopupPalette, SW_HIDE);
|
|
|
|
FB_ResizeEdit(&lpft->m_FormulaBar);
|
|
|
|
InvalidateRect(lpft->m_ButtonBar.m_hWnd, NULL, TRUE);
|
|
InvalidateRect(lpft->m_FormulaBar.m_hWnd, NULL, TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_PopupTools
|
|
*
|
|
* Purpose:
|
|
* Put both formula bar and button bar in Popup Window.
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_PopupTools(LPFRAMETOOLS lpft)
|
|
{
|
|
if (! lpft)
|
|
return;
|
|
|
|
FrameTools_BB_SetState(lpft, BARSTATE_POPUP);
|
|
FrameTools_FB_SetState(lpft, BARSTATE_POPUP);
|
|
FrameTools_Move(lpft, NULL);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_Enable
|
|
*
|
|
* Purpose:
|
|
* Enable/Disable(hide) all the tools of the toolbar.
|
|
* this will hide both the buttonbar and the
|
|
* formulabar independent of whether they are floating or anchored.
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* fEnable
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_Enable(LPFRAMETOOLS lpft, BOOL fEnable)
|
|
{
|
|
lpft->m_fToolsDisabled = !fEnable;
|
|
if (lpft->m_fToolsDisabled) {
|
|
ShowWindow(lpft->m_hWndPopupPalette, SW_HIDE);
|
|
ShowWindow(lpft->m_ButtonBar.m_hWnd, SW_HIDE);
|
|
ShowWindow(lpft->m_FormulaBar.m_hWnd, SW_HIDE);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_EnableWindow
|
|
*
|
|
* Purpose:
|
|
* EnableWindow for all the tools of the toolbar.
|
|
* this enables/disables mouse and keyboard input to the tools.
|
|
* while a modal dialog is up, it is inportant to disable the
|
|
* floating tool windows.
|
|
* this will NOT hide any windows; it will only call EnableWindow.
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* fEnable
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_EnableWindow(LPFRAMETOOLS lpft, BOOL fEnable)
|
|
{
|
|
EnableWindow(lpft->m_hWndPopupPalette, fEnable);
|
|
EnableWindow(lpft->m_ButtonBar.m_hWnd, fEnable);
|
|
EnableWindow(lpft->m_FormulaBar.m_hWnd, fEnable);
|
|
}
|
|
|
|
|
|
#if defined( INPLACE_CNTR ) || defined( INPLACE_SVR )
|
|
|
|
/*
|
|
* FrameTools_NegotiateForSpaceAndShow
|
|
*
|
|
* Purpose:
|
|
* Negotiate for space for the toolbar tools with the given frame window.
|
|
* and make them visible.
|
|
* Negotiation steps:
|
|
* 1. try to get enough space at top/bottom of window
|
|
* 2. float the tools as a palette if space not available
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* none
|
|
*/
|
|
void FrameTools_NegotiateForSpaceAndShow(
|
|
LPFRAMETOOLS lpft,
|
|
LPRECT lprcFrameRect,
|
|
LPOLEINPLACEFRAME lpTopIPFrame
|
|
)
|
|
{
|
|
BORDERWIDTHS borderwidths;
|
|
RECT rectBorder;
|
|
HRESULT hrErr;
|
|
|
|
if (lprcFrameRect)
|
|
rectBorder = *lprcFrameRect;
|
|
else {
|
|
/* OLE2NOTE: by calling GetBorder, the server can find out the
|
|
** size of the frame window. it can use this information to
|
|
** make decisions about how to orient/organize it tools (eg.
|
|
** if window is taller than wide put tools vertically at
|
|
** left edge).
|
|
*/
|
|
OLEDBG_BEGIN2("IOleInPlaceFrame::GetBorder called\r\n")
|
|
hrErr = lpTopIPFrame->lpVtbl->GetBorder(
|
|
lpTopIPFrame,
|
|
(LPRECT)&rectBorder
|
|
);
|
|
OLEDBG_END2
|
|
}
|
|
|
|
/* Try SetBorderSpace() with the space that you need. If it fails then
|
|
** you can negotiate for space and then do the SetBorderSpace().
|
|
*/
|
|
FrameTools_GetRequiredBorderSpace(lpft,(LPBORDERWIDTHS)&borderwidths);
|
|
OLEDBG_BEGIN2("IOleInPlaceFrame::SetBorderSpace called\r\n")
|
|
hrErr = lpTopIPFrame->lpVtbl->SetBorderSpace(
|
|
lpTopIPFrame,
|
|
(LPCBORDERWIDTHS)&borderwidths
|
|
);
|
|
OLEDBG_END2
|
|
|
|
#if defined( LATER )
|
|
if (hrErr != NOERROR) {
|
|
/* Frame did not give the toolsspace that we want. So negotiate */
|
|
|
|
// REVIEW: try a different placement of the tools here
|
|
|
|
OLEDBG_BEGIN2("IOleInPlaceFrame::RequestBorderSpace called\r\n")
|
|
hrErr = lpTopIPFrame->lpVtbl->RequestBorderSpace(
|
|
lpTopIPFrame,
|
|
(LPCBORDERWIDTHS)&borderwidths
|
|
);
|
|
OLEDBG_END2
|
|
|
|
if (hrErr == NOERROR) {
|
|
OLEDBG_BEGIN2("IOleInPlaceFrame::SetBorderSpace called\r\n")
|
|
hrErr = lpTopIPFrame->lpVtbl->SetBorderSpace(
|
|
lpTopIPFrame,
|
|
(LPCBORDERWIDTHS)&borderwidths
|
|
);
|
|
OLEDBG_END2
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (hrErr == NOERROR) {
|
|
FrameTools_Move(lpft, (LPRECT)&rectBorder); // we got what we wanted
|
|
} else {
|
|
/* We did not get tool space, so POP them up.
|
|
/* OLE2NOTE: since we are poping up our tools, we MUST inform
|
|
** the top in-place frame window that we need NO tool space
|
|
** BUT that it should NOT put its own tools up. if we were
|
|
** to pass NULL instead of (0,0,0,0), then the container
|
|
** would have the option to leave its own tools up.
|
|
*/
|
|
OLEDBG_BEGIN2("IOleInPlaceFrame::SetBorderSpace(NULL) called\r\n")
|
|
hrErr = lpTopIPFrame->lpVtbl->SetBorderSpace(
|
|
lpTopIPFrame,
|
|
(LPCBORDERWIDTHS)&g_rectNull
|
|
);
|
|
OLEDBG_END2
|
|
FrameTools_PopupTools(lpft);
|
|
}
|
|
}
|
|
|
|
#endif // INPLACE_CNTR || INPLACE_SVR
|
|
|
|
|
|
/*
|
|
* FrameTools_GetRequiredBorderSpace
|
|
*
|
|
* Purpose:
|
|
* Calculate the desired space for the toolbar tools.
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* lpBorderWidths Widths required at top,bottom,left,right
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_GetRequiredBorderSpace(LPFRAMETOOLS lpft, LPBORDERWIDTHS lpBorderWidths)
|
|
{
|
|
*lpBorderWidths = g_rectNull;
|
|
|
|
switch (lpft->m_ButtonBar.m_nState) {
|
|
case BARSTATE_TOP:
|
|
lpBorderWidths->top += lpft->m_ButtonBar.m_uHeight;
|
|
break;
|
|
|
|
case BARSTATE_BOTTOM:
|
|
lpBorderWidths->bottom += lpft->m_ButtonBar.m_uHeight;
|
|
break;
|
|
}
|
|
|
|
switch (lpft->m_FormulaBar.m_nState) {
|
|
case BARSTATE_TOP:
|
|
lpBorderWidths->top += lpft->m_FormulaBar.m_uHeight;
|
|
break;
|
|
|
|
case BARSTATE_BOTTOM:
|
|
lpBorderWidths->bottom += lpft->m_FormulaBar.m_uHeight;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* FrameTools_UpdateButtons
|
|
*
|
|
* Purpose:
|
|
* Enable/disable individual buttons of the toolbar according to the
|
|
* state of the app
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_UpdateButtons(LPFRAMETOOLS lpft, LPOUTLINEDOC lpOutlineDoc)
|
|
{
|
|
BOOL fEnable;
|
|
|
|
#if defined( OLE_VERSION )
|
|
LPDATAOBJECT lpClipboardDataObj;
|
|
HRESULT hrErr;
|
|
LPOLEAPP lpOleApp = (LPOLEAPP)g_lpApp;
|
|
BOOL fPrevEnable1;
|
|
BOOL fPrevEnable2;
|
|
#endif
|
|
|
|
if (!lpft)
|
|
return;
|
|
|
|
#if defined( INPLACE_CNTR )
|
|
{
|
|
LPCONTAINERDOC lpContainerDoc = (LPCONTAINERDOC)lpOutlineDoc;
|
|
if (lpContainerDoc->m_lpLastUIActiveLine &&
|
|
lpContainerDoc->m_lpLastUIActiveLine->m_fUIActive) {
|
|
|
|
/* if there is a UIActive object, then we should disable
|
|
** all of our "active editor" commands. we should enable
|
|
** only those commands that are "workspace" commands.
|
|
*/
|
|
if (lpft->m_FormulaBar.m_nState != BARSTATE_HIDE) {
|
|
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd,IDM_L_EDITLINE,FALSE);
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd,IDM_L_ADDLINE,FALSE);
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd,IDM_FB_CANCEL,FALSE);
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd,IDM_L_EDITLINE,FALSE);
|
|
}
|
|
|
|
if (lpft->m_ButtonBar.m_nState != BARSTATE_HIDE)
|
|
{
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_CUT, FALSE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_COPY, FALSE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_PASTE, FALSE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd,IDM_L_INDENTLINE,FALSE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_L_UNINDENTLINE, FALSE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_H_ABOUT, FALSE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_FB_EDIT, FALSE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_F_NEW, TRUE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_F_OPEN, TRUE);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_F_SAVE, TRUE);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
#endif // INPLACE_CNTR
|
|
|
|
fEnable = (BOOL)OutlineDoc_GetLineCount(lpOutlineDoc);
|
|
|
|
if (lpft->m_FormulaBar.m_nState != BARSTATE_HIDE) {
|
|
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd, IDM_L_EDITLINE, fEnable);
|
|
|
|
if (! lpft->m_fInFormulaBar) {
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd, IDM_L_ADDLINE, FALSE);
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd, IDM_FB_CANCEL, FALSE);
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd, IDM_L_EDITLINE, FALSE);
|
|
if (!fEnable) {
|
|
GBGizmoTextSet(lpft->m_FormulaBar.m_hWnd, IDM_FB_EDIT, "");
|
|
}
|
|
} else {
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd, IDM_L_ADDLINE, TRUE);
|
|
GBGizmoEnable(lpft->m_FormulaBar.m_hWnd, IDM_FB_CANCEL, TRUE);
|
|
}
|
|
}
|
|
|
|
if (lpft->m_ButtonBar.m_nState != BARSTATE_HIDE)
|
|
{
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_CUT, fEnable);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_COPY, fEnable);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_L_INDENTLINE, fEnable);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_L_UNINDENTLINE, fEnable);
|
|
|
|
#if defined( OLE_SERVER )
|
|
|
|
{
|
|
LPSERVERDOC lpServerDoc = (LPSERVERDOC)lpOutlineDoc;
|
|
|
|
#if defined( INPLACE_SVR )
|
|
fEnable = ((lpServerDoc->m_fUIActive) ? FALSE : TRUE);
|
|
#else
|
|
fEnable = (lpOutlineDoc->m_docInitType != DOCTYPE_EMBEDDED);
|
|
#endif // INPLACE_SVR
|
|
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_F_NEW, fEnable);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_F_OPEN, fEnable);
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_F_SAVE, fEnable);
|
|
}
|
|
|
|
#endif // OLE_SERVER
|
|
|
|
#if defined( OLE_VERSION )
|
|
|
|
/* OLE2NOTE: we do not want to ever give the busy dialog when we
|
|
** are trying to enable or disable our tool bar buttons 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);
|
|
|
|
/* OLE2NOTE: perform OLE specific menu initialization.
|
|
** the OLE versions use the OleGetClipboard mechanism for
|
|
** clipboard handling. thus, they determine if the Paste
|
|
** command should be enabled in an OLE specific manner.
|
|
*/
|
|
fEnable = FALSE;
|
|
hrErr = OleGetClipboard((LPDATAOBJECT FAR*)&lpClipboardDataObj);
|
|
|
|
if (hrErr == NOERROR) {
|
|
int nFmtEtc;
|
|
|
|
nFmtEtc = OleStdGetPriorityClipboardFormat(
|
|
lpClipboardDataObj,
|
|
lpOleApp->m_arrPasteEntries,
|
|
lpOleApp->m_nPasteEntries
|
|
);
|
|
|
|
fEnable = (nFmtEtc >= 0); // there IS a format we like
|
|
|
|
OleStdRelease((LPUNKNOWN)lpClipboardDataObj);
|
|
}
|
|
|
|
// re-enable the busy dialog
|
|
OleApp_EnableBusyDialogs(lpOleApp, fPrevEnable1, fPrevEnable2);
|
|
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_PASTE, fEnable);
|
|
|
|
#else
|
|
|
|
// Base Outline version uses standard Windows clipboard handling
|
|
if(IsClipboardFormatAvailable(g_lpApp->m_cfOutline) ||
|
|
IsClipboardFormatAvailable(CF_TEXT))
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_PASTE, TRUE);
|
|
else
|
|
GBGizmoEnable(lpft->m_ButtonBar.m_hWnd, IDM_E_PASTE, FALSE);
|
|
|
|
#endif // OLE_VERSION
|
|
|
|
}
|
|
}
|
|
|
|
/*
|
|
* FrameTools_FB_SetEditText
|
|
*
|
|
* Purpose:
|
|
* Set text in the edit control in FormulaBar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* lpsz pointer to string to be set
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_FB_SetEditText(LPFRAMETOOLS lpft, LPSTR lpsz)
|
|
{
|
|
GBGizmoTextSet(lpft->m_FormulaBar.m_hWnd, IDM_FB_EDIT, lpsz);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_FB_GetEditText
|
|
*
|
|
* Purpose:
|
|
* Get text from the edit control in FormulaBar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* lpsz pointer to buffer to receive the text
|
|
* cch buffer size
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_FB_GetEditText(LPFRAMETOOLS lpft, LPSTR lpsz, UINT cch)
|
|
{
|
|
GBGizmoTextGet(lpft->m_FormulaBar.m_hWnd, IDM_FB_EDIT, lpsz, cch);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_FB_FocusEdit
|
|
*
|
|
* Purpose:
|
|
* Set the focus in the edit control of FormulaBar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_FB_FocusEdit(LPFRAMETOOLS lpft)
|
|
{
|
|
GBGizmoFocusSet(lpft->m_FormulaBar.m_hWnd, IDM_FB_EDIT);
|
|
|
|
// select the whole text in the edit control
|
|
GBGizmoSendMessage(lpft->m_FormulaBar.m_hWnd, IDM_FB_EDIT, EM_SETSEL,
|
|
(WPARAM)TRUE, MAKELPARAM(0, -1));
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_FB_SendMessage
|
|
*
|
|
* Purpose:
|
|
* Send a message to the FormulaBar window gizmo
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* uID gizmo ID
|
|
* msg
|
|
* wParam
|
|
* lParam
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_FB_SendMessage(LPFRAMETOOLS lpft, UINT uID, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
GBGizmoSendMessage(lpft->m_FormulaBar.m_hWnd, uID, msg, wParam, lParam);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_FB_ForceRedraw
|
|
*
|
|
* Purpose:
|
|
* Force the toolbar to draw itself
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_ForceRedraw(LPFRAMETOOLS lpft)
|
|
{
|
|
InvalidateRect(lpft->m_ButtonBar.m_hWnd, NULL, TRUE);
|
|
InvalidateRect(lpft->m_FormulaBar.m_hWnd, NULL, TRUE);
|
|
InvalidateRect(lpft->m_hWndPopupPalette, NULL, TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_BB_SetState
|
|
*
|
|
* Purpose:
|
|
* Set display state of ButtonBar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* nState new display state
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
void FrameTools_BB_SetState(LPFRAMETOOLS lpft, int nState)
|
|
{
|
|
if (!lpft) {
|
|
return;
|
|
}
|
|
|
|
lpft->m_ButtonBar.m_nState = nState;
|
|
|
|
if (nState == BARSTATE_POPUP)
|
|
SetParent(lpft->m_ButtonBar.m_hWnd, lpft->m_hWndPopupPalette);
|
|
else
|
|
SetParent(lpft->m_ButtonBar.m_hWnd, lpft->m_hWndApp);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_BB_GetState
|
|
*
|
|
* Purpose:
|
|
* Get display state of ButtonBar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* nState current display state
|
|
*/
|
|
int FrameTools_BB_GetState(LPFRAMETOOLS lpft)
|
|
{
|
|
return lpft->m_ButtonBar.m_nState;
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_FB_SetState
|
|
*
|
|
* Purpose:
|
|
* Set display state of FormulaBar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
* nState new display state
|
|
*
|
|
* Return Value:
|
|
4 * nil
|
|
*/
|
|
void FrameTools_FB_SetState(LPFRAMETOOLS lpft, int nState)
|
|
{
|
|
if (!lpft) {
|
|
return;
|
|
}
|
|
|
|
lpft->m_FormulaBar.m_nState = nState;
|
|
|
|
if (nState == BARSTATE_POPUP)
|
|
SetParent(lpft->m_FormulaBar.m_hWnd, lpft->m_hWndPopupPalette);
|
|
|
|
#if defined( INPLACE_SVR )
|
|
/* OLE2NOTE: it is dangerous for an in-place server to hide its
|
|
** toolbar window and leave it parented to the hWndFrame of the
|
|
** in-place container. if the in-place container call
|
|
** ShowOwnedPopups, then it could inadvertantly be made visible.
|
|
** to avoid this we will parent the toolbar window back to our
|
|
** own application main window. if we are not in-place active
|
|
** then this is the same as lpft->m_hWndApp.
|
|
*/
|
|
else if (nState == BARSTATE_HIDE)
|
|
SetParent(lpft->m_FormulaBar.m_hWnd, g_lpApp->m_hWndApp);
|
|
#endif
|
|
|
|
else
|
|
SetParent(lpft->m_FormulaBar.m_hWnd, lpft->m_hWndApp);
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameTools_FB_GetState
|
|
*
|
|
* Purpose:
|
|
* Get display state of FormulaBar
|
|
*
|
|
* Parameters:
|
|
* lpft FrameTools object
|
|
*
|
|
* Return Value:
|
|
* nState current display state
|
|
*/
|
|
int FrameTools_FB_GetState(LPFRAMETOOLS lpft)
|
|
{
|
|
return lpft->m_FormulaBar.m_nState;
|
|
}
|
|
|
|
|
|
/*
|
|
* FrameToolsWndProc
|
|
*
|
|
* Purpose:
|
|
* WndProc for toolbar window
|
|
*
|
|
* Parameters:
|
|
* hWnd
|
|
* Message
|
|
* wParam
|
|
* lParam
|
|
*
|
|
* Return Value:
|
|
* message dependent
|
|
*/
|
|
LRESULT FAR PASCAL FrameToolsWndProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LPFRAMETOOLS lpft = (LPFRAMETOOLS)GetWindowLong(hWnd, 0);
|
|
|
|
switch (Message) {
|
|
|
|
case WM_MOUSEACTIVATE:
|
|
return MA_NOACTIVATE;
|
|
|
|
default:
|
|
return DefWindowProc(hWnd, Message, wParam, lParam);
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
|
|
/*
|
|
* Bar_Move
|
|
*
|
|
* Purpose:
|
|
* Resize and reposition a bar
|
|
*
|
|
* Parameters:
|
|
* lpbar Bar object
|
|
* lprcClient pointer to Client rect
|
|
* lprcPopup pointer to Popup rect
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
static void Bar_Move(LPBAR lpbar, LPRECT lprcClient, LPRECT lprcPopup)
|
|
{
|
|
if (lpbar->m_nState == BARSTATE_HIDE) {
|
|
ShowWindow(lpbar->m_hWnd, SW_HIDE);
|
|
}
|
|
else {
|
|
ShowWindow(lpbar->m_hWnd, SW_SHOW);
|
|
switch (lpbar->m_nState) {
|
|
case BARSTATE_POPUP:
|
|
MoveWindow(lpbar->m_hWnd, lprcPopup->left, lprcPopup->top,
|
|
lprcPopup->right - lprcPopup->left, lpbar->m_uHeight,
|
|
TRUE);
|
|
lprcPopup->top += lpbar->m_uHeight;
|
|
break;
|
|
|
|
case BARSTATE_TOP:
|
|
MoveWindow(lpbar->m_hWnd, lprcClient->left, lprcClient->top,
|
|
lprcClient->right - lprcClient->left,
|
|
lpbar->m_uHeight, TRUE);
|
|
lprcClient->top += lpbar->m_uHeight;
|
|
break;
|
|
|
|
case BARSTATE_BOTTOM:
|
|
MoveWindow(lpbar->m_hWnd, lprcClient->left,
|
|
lprcClient->bottom - lpbar->m_uHeight,
|
|
lprcClient->right - lprcClient->left,
|
|
lpbar->m_uHeight, TRUE);
|
|
lprcClient->bottom -= lpbar->m_uHeight;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* FB_ResizeEdit
|
|
*
|
|
* Purpose:
|
|
* Resize the edit control in FormulaBar
|
|
*
|
|
* Parameters:
|
|
* lpft Bar object
|
|
*
|
|
* Return Value:
|
|
* nil
|
|
*/
|
|
static void FB_ResizeEdit(LPBAR lpbar)
|
|
{
|
|
RECT rcClient;
|
|
RECT rcEdit;
|
|
HWND hwndEdit;
|
|
|
|
GetClientRect(lpbar->m_hWnd, (LPRECT)&rcClient);
|
|
hwndEdit = GetDlgItem(lpbar->m_hWnd, IDM_FB_EDIT);
|
|
GetWindowRect(hwndEdit, (LPRECT)&rcEdit);
|
|
ScreenToClient(lpbar->m_hWnd, (LPPOINT)&rcEdit.left);
|
|
ScreenToClient(lpbar->m_hWnd, (LPPOINT)&rcEdit.right);
|
|
|
|
SetWindowPos(hwndEdit, NULL, 0, 0, rcClient.right - rcEdit.left - SPACE,
|
|
rcEdit.bottom - rcEdit.top, SWP_NOMOVE | SWP_NOZORDER);
|
|
}
|