haiku.git

//--------------------------------------------------------------------
//	
//	MenuView.cpp
//
//	Written by: Owen Smith
//	
//--------------------------------------------------------------------

/*
	Copyright 1999, Be Incorporated.   All Rights Reserved.
	This file may be used under the terms of the Be Sample Code License.
*/

#include <Alert.h>
#include <Button.h>
#include <CheckBox.h>
#include <Menu.h>
#include <MenuItem.h>
#include <OutlineListView.h>
#include <ScrollView.h>
#include <TextControl.h>
#include <List.h>
#include <string.h>

#include "constants.h"
#include "MenuView.h"
#include "MenuWindow.h"
#include "PostDispatchInvoker.h"
#include "stddlg.h"
#include "ViewLayoutFactory.h"


//====================================================================
//	MenuView Implementation


//--------------------------------------------------------------------
//	MenuView constructors, destructors, operators

MenuView::MenuView(uint32 resizingMode)
	: BView(BRect(0, 0, 0, 0), "Menu View", resizingMode,
		B_WILL_DRAW)
{
	ViewLayoutFactory aFactory; // for semi-intelligent layout
	
	SetViewColor(BKG_GREY);

	// "hide user menus" check box
	float fCheck_x = 20.0f;
	float fCheck_y = 100.0f;
	m_pHideUserCheck = aFactory.MakeCheckBox("Hide User Menus",
		STR_HIDE_USER_MENUS, MSG_WIN_HIDE_USER_MENUS,
		BPoint(fCheck_x, fCheck_y));
	m_pHideUserCheck->SetValue(B_CONTROL_OFF);
	AddChild(m_pHideUserCheck);
	
	// "large test icons" check box
	fCheck_y = m_pHideUserCheck->Frame().bottom + 10;
	m_pLargeTestIconCheck = aFactory.MakeCheckBox("Large Test Icons",
		STR_LARGE_TEST_ICONS, MSG_WIN_LARGE_TEST_ICONS,
		BPoint(fCheck_x, fCheck_y));
	m_pLargeTestIconCheck->SetValue(B_CONTROL_OFF);
	AddChild(m_pLargeTestIconCheck);
	
	// "add menu", "add item", "delete" buttons
	BList buttons;
	float fButton_x = m_pHideUserCheck->Frame().right + 15;
	float fButton_y = m_pHideUserCheck->Frame().top;
	
	m_pAddMenuButton = aFactory.MakeButton("Add Menu Bar", STR_ADD_MENU,
		MSG_VIEW_ADD_MENU, BPoint(fButton_x, fButton_y));
	AddChild(m_pAddMenuButton);
	buttons.AddItem(m_pAddMenuButton);
	
	// for purposes of size calculation, use the longest piece
	// of text we're going to stuff into the button
	const char* addItemText;
	float itemLen, sepLen;
	itemLen = be_plain_font->StringWidth(STR_ADD_ITEM);
	sepLen = be_plain_font->StringWidth(STR_ADD_SEP);
	addItemText = (itemLen > sepLen) ? STR_ADD_ITEM : STR_ADD_SEP;
	m_pAddItemButton = aFactory.MakeButton("Add Item To Menu",
		addItemText, MSG_VIEW_ADD_ITEM,
		BPoint(fButton_x, fButton_y));
	m_pAddItemButton->SetEnabled(false);
	AddChild(m_pAddItemButton);
	buttons.AddItem(m_pAddItemButton);
	
	m_pDelButton = aFactory.MakeButton("Delete Menu Bar", STR_DELETE_MENU,
		MSG_VIEW_DELETE_MENU, BPoint(fButton_x, fButton_y));
	m_pDelButton->SetEnabled(false);
	AddChild(m_pDelButton);
	buttons.AddItem(m_pDelButton);
	
	// now resize list of buttons to max width
	aFactory.ResizeToListMax(buttons, RECT_WIDTH);
	
	// now align buttons along left side
	aFactory.Align(buttons, ALIGN_LEFT,
		m_pAddItemButton->Frame().Height() + 15);
		
	// now make add menu the default, AFTER we've
	// laid out the buttons, since the button bloats
	// when it's the default
	m_pAddMenuButton->MakeDefault(true);

	// item "label" control
	float fEdit_left = 20.0f, fEdit_bottom = m_pHideUserCheck->Frame().top - 20;
	float fEdit_right = m_pAddItemButton->Frame().right;
	
	m_pLabelCtrl = aFactory.MakeTextControl("Menu Bar Control",
		STR_LABEL_CTRL, NULL, BPoint(fEdit_left, fEdit_bottom),
		fEdit_right - fEdit_left, CORNER_BOTTOMLEFT);
	AddChild(m_pLabelCtrl);
	
	// menu outline view
	BRect r;
	r.left = m_pAddItemButton->Frame().right + 30;
	r.top = 20.0f;
	r.right = r.left + 200 - B_V_SCROLL_BAR_WIDTH;
	// API quirk here: <= 12 (hscroll height - 2) height
	// results in scrollbar drawing error
	r.bottom = r.top + 100 - B_H_SCROLL_BAR_HEIGHT;

	m_pMenuOutlineView = new BOutlineListView(r, "Menu Outline",
		B_SINGLE_SELECTION_LIST, B_FOLLOW_ALL);
	m_pMenuOutlineView->SetSelectionMessage(
		new BMessage(MSG_MENU_OUTLINE_SEL));
	
	// wrap outline view in scroller
	m_pScrollView = new BScrollView("Menu Outline Scroller",
		m_pMenuOutlineView, B_FOLLOW_LEFT | B_FOLLOW_TOP, 0,
		true, true);
	m_pScrollView->SetViewColor(BKG_GREY);
	AddChild(m_pScrollView);
	
}



//--------------------------------------------------------------------
//	MenuView virtual function overrides

void MenuView::MessageReceived(BMessage* message)
{
	switch (message->what) {
	case MSG_VIEW_ADD_MENU:
		AddMenu(message);
		break;
	case MSG_VIEW_DELETE_MENU:
		DeleteMenu(message);
		break;
	case MSG_VIEW_ADD_ITEM:
		AddMenuItem(message);
		break;
	case MSG_MENU_OUTLINE_SEL:
		MenuSelectionChanged(message);
		break;
	case MSG_LABEL_EDIT:
		SetButtonState();
		break;
	default:
		BView::MessageReceived(message);
		break;
	}
}

void MenuView::AllAttached(void)
{
	if (! Valid()) {
		return;
	}

	// Set button and view targets (now that window looper is available).
	m_pAddMenuButton->SetTarget(this);
	m_pDelButton->SetTarget(this);
	m_pAddItemButton->SetTarget(this);
	m_pMenuOutlineView->SetTarget(this);
	
	// Set button's initial state
	SetButtonState();
	
	// Wrap a message filter/invoker around the label control's text field
	// that will post us B_LABEL_EDIT msg after the text field processes a
	// B_KEY_DOWN message.
	m_pLabelCtrl->TextView()->AddFilter(
		new PostDispatchInvoker(B_KEY_DOWN, new BMessage(MSG_LABEL_EDIT), this));
	
	// Get one item's height by adding a dummy item to
	// the BOutlineListView and calculating its height.
	m_pMenuOutlineView->AddItem(new BStringItem("Dummy"));
	float itemHeight = m_pMenuOutlineView->ItemFrame(0).Height();
	itemHeight++;	// account for 1-pixel offset between items
					// which eliminates overlap
	delete m_pMenuOutlineView->RemoveItem((int32)0);
	
	// Resize outline list view to integral item height.
	// fudge factor of 4 comes from 2-pixel space between
	// scrollview and outline list view on top & bottom
	float viewHeight = 16*itemHeight;
	m_pScrollView->ResizeTo(m_pScrollView->Frame().Width(),
		viewHeight + B_H_SCROLL_BAR_HEIGHT + 4);
	BScrollBar *pBar = m_pScrollView->ScrollBar(B_HORIZONTAL);
	if (pBar) {
		pBar->SetRange(0, 300);
	}
	
	// Resize view to surround contents.
	ViewLayoutFactory aFactory;
	aFactory.ResizeAroundChildren(*this, BPoint(20,20));	
}



//--------------------------------------------------------------------
//	MenuView operations

void MenuView::PopulateUserMenu(BMenu* pMenu, int32 index)
{
	if ((! pMenu) || (! Valid())) {
		return;
	}
		
	// blow away all menu items
	BMenuItem* pMenuItem = pMenu->RemoveItem((int32)0);
	while(pMenuItem) {
		delete pMenuItem;
		pMenuItem = pMenu->RemoveItem((int32)0);
	}
	
	// build menu up from outline list view	
	BListItem* pListItem = m_pMenuOutlineView->ItemUnderAt(NULL, true, index);
	
	// recursive buildup of menu items
	BuildMenuItems(pMenu, pListItem, m_pMenuOutlineView);
}



//--------------------------------------------------------------------
//	MenuView message handlers

void MenuView::AddMenu(BMessage* message)
{
	if (! Valid()) {
		return;
	}
	
	const char* menuName = m_pLabelCtrl->Text();
	if ((! menuName) || (! *menuName)) {
		BAlert* pAlert = new BAlert("Add menu alert",
			"Please specify the menu name first.", "OK");
		pAlert->Go();
		return;
	}
	
	m_pMenuOutlineView->AddItem(new BStringItem(menuName));	
	
	// add some info and pass to window
	BMessage newMsg(MSG_WIN_ADD_MENU);
	newMsg.AddString("Menu Name", menuName);
	BWindow* pWin = Window();
	if (pWin) {
		pWin->PostMessage(&newMsg);
	}
	
	// Reset the label control and buttons
	m_pLabelCtrl->SetText("");
	SetButtonState();
}

void MenuView::DeleteMenu(BMessage* message)
{
	if (! Valid())
		return;

	int32 itemCount;	
	int32 selected = m_pMenuOutlineView->CurrentSelection();
	if (selected < 0)
		return;
	
	BStringItem* pSelItem = dynamic_cast<BStringItem*>
		(m_pMenuOutlineView->ItemAt(selected));
	if (! pSelItem)
		return;
	
	if (pSelItem->OutlineLevel() == 0) {
		// get index of item among items in 0 level
		itemCount = m_pMenuOutlineView->CountItemsUnder(NULL, true);
		int32 i;
		for (i=0; i<itemCount; i++) {
			BListItem* pItem = m_pMenuOutlineView->ItemUnderAt(NULL, true, i);
			if (pItem == pSelItem) {
				break;
			}
		}
		
		// Stuff the index into the message and pass along to
		// the window.
		BMessage newMsg(MSG_WIN_DELETE_MENU);
		newMsg.AddInt32("Menu Index", i);
		BWindow* pWin = Window();
		if (pWin) {
			pWin->PostMessage(&newMsg);
		}
	}			
				
	// Find & record all subitems of selection, because we'll
	// have to delete them after they're removed from the list.
	BList subItems;
	int32 j;
	itemCount = m_pMenuOutlineView->CountItemsUnder(pSelItem, false);
	for (j=0; j<itemCount; j++) {
		BListItem* pItem = m_pMenuOutlineView->ItemUnderAt(pSelItem, false, j);
		subItems.AddItem(pItem);
	}
	
	// Note the superitem for reference just below
	BStringItem* pSuperitem = dynamic_cast<BStringItem*>
		(m_pMenuOutlineView->Superitem(pSelItem));
		
	// Remove selected item and all subitems from
	// the outline list view.
	m_pMenuOutlineView->RemoveItem(pSelItem); // removes super- and subitems
	
	// Update window status
	MenuWindow* pWin = dynamic_cast<MenuWindow*>(Window());
	if (pWin) {
		const char* itemName = pSelItem->Text();
		if (strcmp(itemName, STR_SEPARATOR)) {
			pWin->UpdateStatus(STR_STATUS_DELETE_ITEM, itemName);
		} else {
			pWin->UpdateStatus(STR_STATUS_DELETE_SEPARATOR);
		}
	}

	// Delete the selected item and all subitems	
	for (j=0; j<itemCount; j++) {
		BListItem* pItem = reinterpret_cast<BListItem*>(subItems.ItemAt(j));
		delete pItem; // deletes subitems
	}
	delete pSelItem; // deletes superitem
	
	if (pSuperitem) {
		// There's a bug in outline list view which does not
		// update the superitem correctly. The only way to do so
		// is to remove and add a brand-new superitem afresh.
		if (! m_pMenuOutlineView->CountItemsUnder(pSuperitem, true))
		{
			int32 index = m_pMenuOutlineView->FullListIndexOf(pSuperitem);
			m_pMenuOutlineView->RemoveItem(pSuperitem);
			BStringItem* pCloneItem = new BStringItem(
				pSuperitem->Text(), pSuperitem->OutlineLevel());
			m_pMenuOutlineView->AddItem(pCloneItem, index);
			delete pSuperitem;
		}
	}
}

void MenuView::AddMenuItem(BMessage* message)
{
	if (! Valid()) {
		return;
	}		
	
	// Add item to outline list view but DON'T update the
	// window right away; the actual menu items will be
	// created dynamically later on.
	int32 selected = m_pMenuOutlineView->CurrentSelection();
	if (selected >= 0) {
		BListItem* pSelItem = m_pMenuOutlineView->ItemAt(selected);
		if (pSelItem) {		

			int32 level = pSelItem->OutlineLevel() + 1;
			int32 index = m_pMenuOutlineView->FullListIndexOf(pSelItem)
				+ m_pMenuOutlineView->CountItemsUnder(pSelItem, false) + 1;
			const char* itemName = m_pLabelCtrl->Text();
			bool bIsSeparator = IsSeparator(itemName);

			if (bIsSeparator) {
				m_pMenuOutlineView->AddItem(new BStringItem(STR_SEPARATOR, level),
					index);
			} else {
				m_pMenuOutlineView->AddItem(new BStringItem(itemName, level),
					index);
			}

			MenuWindow* pWin = dynamic_cast<MenuWindow*>(Window());
			if (pWin) {
				if (! bIsSeparator) {
					pWin->UpdateStatus(STR_STATUS_ADD_ITEM, itemName);
				} else {
					pWin->UpdateStatus(STR_STATUS_ADD_SEPARATOR);
				}
			}

			m_pMenuOutlineView->Invalidate();	// outline view doesn't
												// invalidate correctly
			
			// Reset the label control the buttons
			m_pLabelCtrl->SetText("");
			SetButtonState();
		}
	}	
}

void MenuView::MenuSelectionChanged(BMessage* message)
{
	SetButtonState();
}



//--------------------------------------------------------------------
//	MenuView implementation member functions

void MenuView::BuildMenuItems(BMenu* pMenu, BListItem* pSuperitem,
	BOutlineListView* pView)
{
	if ((! pMenu) || (! pSuperitem) || (! pView)) {
		return;
	}
	
	int32 len = pView->CountItemsUnder(pSuperitem, true);
	if (len == 0) {
		BMenuItem* pEmptyItem = new BMenuItem(STR_MNU_EMPTY_ITEM, NULL);
		pEmptyItem->SetEnabled(false);
		pMenu->AddItem(pEmptyItem);
	}
	
	for (int32 i=0; i<len; i++) {
		BStringItem* pItem = dynamic_cast<BStringItem*>
			(pView->ItemUnderAt(pSuperitem, true, i));
		if (pItem) {
			if (pView->CountItemsUnder(pItem, true) > 0) {
				// add a submenu & fill it
				BMenu* pNewMenu = new BMenu(pItem->Text());
				BuildMenuItems(pNewMenu, pItem, pView);
				pMenu->AddItem(pNewMenu);
			} else {
				if (strcmp(pItem->Text(), STR_SEPARATOR)) {
					// add a string item
					BMessage* pMsg = new BMessage(MSG_USER_ITEM);
					pMsg->AddString("Item Name", pItem->Text());
					pMenu->AddItem(new BMenuItem(pItem->Text(), pMsg));
				} else {
					// add a separator item
					pMenu->AddItem(new BSeparatorItem());
				}
			}
		}
	}
}

bool MenuView::IsSeparator(const char* text) const
{
	if (! text) {
		return true;
	}
	
	if (! *text) {
		return true;
	}
	
	int32 len = strlen(text);
	for (int32 i = 0; i < len; i++) {
		char ch = text[i];
		if ((ch != ' ') && (ch != '-')) {
			return false;
		}
	}
	
	return true;
}

void MenuView::SetButtonState(void)
{
	if (! Valid()) {
		return;
	}

	// See if an item in the outline list is selected
	int32 index = m_pMenuOutlineView->CurrentSelection();
	bool bIsSelected = (index >= 0);
	
	// If an item is selected, see if the selected
	// item is a separator
	bool bSeparatorSelected = false;
	if (bIsSelected) {
		BStringItem* pItem = dynamic_cast<BStringItem*>
			(m_pMenuOutlineView->ItemAt(index));
		if (pItem) {
			bSeparatorSelected = (! strcmp(pItem->Text(), STR_SEPARATOR));
		}
	}

	// Delete: enable if anything is selected
	m_pDelButton->SetEnabled(bIsSelected);
	
	// Add Item: enable if anything but a separator is selected	
	bool bEnableAddItem = bIsSelected && (! bSeparatorSelected);
	m_pAddItemButton->SetEnabled(bEnableAddItem);

	// Add Menu: enable if there's any text in the label field
	const char* labelText = m_pLabelCtrl->Text();
	m_pAddMenuButton->SetEnabled(labelText && (*labelText));
		
	// Add Item: text says Add Separator if button is enabled
	// and the label field contains separator text,
	// Add Item otherwise
	const char* itemText;
	if (bEnableAddItem && IsSeparator(labelText)) {
		itemText = STR_ADD_SEP;
	} else {
		itemText = STR_ADD_ITEM;
	}
	m_pAddItemButton->SetLabel(itemText);

	// If add item button is enabled, it should be the default	
	if (bEnableAddItem) {
		m_pAddItemButton->MakeDefault(true);
	} else {
		m_pAddMenuButton->MakeDefault(true);
	}
}

bool MenuView::Valid(void)
{
	if (! m_pLabelCtrl) {
		ierror(STR_NO_LABEL_CTRL);
		return false;
	}
	if (! m_pHideUserCheck) {
		ierror(STR_NO_HIDE_USER_CHECK);
		return false;
	}
	if (! m_pLargeTestIconCheck) {
		ierror(STR_NO_LARGE_ICON_CHECK);
		return false;
	}
	if (! m_pAddMenuButton) {
		ierror(STR_NO_ADDMENU_BUTTON);
		return false;
	}
	if (! m_pAddItemButton) {
		ierror(STR_NO_ADDITEM_BUTTON);
		return false;
	}
	if (! m_pDelButton) {
		ierror(STR_NO_DELETE_BUTTON);
		return false;
	}
	if (! m_pMenuOutlineView) {
		ierror(STR_NO_MENU_OUTLINE);
		return false;
	}
	if (! m_pScrollView) {
		ierror(STR_NO_MENU_SCROLL_VIEW);
		return false;
	}
	return true;		
}