windows-server-2003/com/oleutest/letest/outline/frametls.c

/*************************************************************************
**
**    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);
}