haiku.git

//--------------------------------------------------------------------
//	
//	MenuWindow.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 <Application.h>
#include <Box.h>
#include <CheckBox.h>
#include <Menu.h>
#include <MenuBar.h>
#include <MenuItem.h>
#include <StringView.h>
#include <stdio.h>
#include <string.h>

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

//====================================================================
//	MenuWindow Implementation

#define MAX_TEST_STATUS_CHARS 25


//--------------------------------------------------------------------
//	MenuWindow constructors, destructors, operators

MenuWindow::MenuWindow(const char* name)
	: BWindow(BRect(60,60,60,60), name, B_TITLED_WINDOW,
		B_NOT_RESIZABLE | B_NOT_ZOOMABLE)
{
	m_bUsingFullMenuBar = true;
	
	// menu bars
	BRect dummyFrame(0, 0, 0, 0);
	m_pFullMenuBar = new BMenuBar(dummyFrame, "Full Menu Bar");
	m_pHiddenMenuBar = new BMenuBar(dummyFrame, "Menu Bar w. Hidden User Menus");
	
	// File menu
	BMenu* pMenu = BuildFileMenu();
	if (pMenu) {
		m_pFullMenuBar->AddItem(pMenu);
	}
	pMenu = BuildFileMenu();
	if (pMenu) {
		m_pHiddenMenuBar->AddItem(pMenu);
	}
	
	// Test menu
	pMenu = m_testMenuBuilder.BuildTestMenu(B_MINI_ICON);
	if (pMenu) {
		m_pFullMenuBar->AddItem(pMenu);
	}
	pMenu = m_testMenuBuilder.BuildTestMenu(B_MINI_ICON);
	if (pMenu) {
		m_pHiddenMenuBar->AddItem(pMenu);
	}
	 
	// add child after menus are added so its initially
	// calculated app_server bounds take added menus into
	// account
	AddChild(m_pFullMenuBar);
	
	float menuHeight = m_pFullMenuBar->Bounds().Height();
	
	// Menu view
	m_pMenuView = new MenuView(B_FOLLOW_NONE); // don't follow window just yet!
	m_pMenuView->MoveBy(0, menuHeight + 1);
	AddChild(m_pMenuView);

	// Status view	
	BRect menuViewRect = m_pMenuView->Frame();
	float top = menuViewRect.bottom + 1;
	font_height plainHeight;
	be_plain_font->GetHeight(&plainHeight);
	
	// Simulate a vertical divider by making a BBox where only the top side
	// can be seen in the window.
	BRect boxFrame;
	boxFrame.Set(menuViewRect.left - 2, 
		top,
		menuViewRect.right + 2,
		top + plainHeight.ascent + plainHeight.descent + plainHeight.leading + 4);
	
	BBox* pStatusBox = new BBox(boxFrame);
	AddChild(pStatusBox);

	BRect statusFrame = pStatusBox->Bounds();
	statusFrame.InsetBy(2,2);	
	m_pStatusView = new BStringView(statusFrame, "Status View", STR_STATUS_DEFAULT,
		B_FOLLOW_ALL); // don't follow window just yet!
	m_pStatusView->SetViewColor(BKG_GREY);
	pStatusBox->AddChild(m_pStatusView);
	
	// Resize window dynamically to fit MenuView (and Status View)
	float windowWidth = m_pMenuView->Frame().right;
	float windowHeight = boxFrame.bottom - 4;
	ResizeTo(windowWidth, windowHeight);
}



//--------------------------------------------------------------------
//	MenuWindow virtual function overrides

void MenuWindow::MenusBeginning(void)
{
	if ((! Valid()) || (! m_bUsingFullMenuBar)) {
		return;
	}

	int32 len = m_pFullMenuBar->CountItems();
	for (int32 i = 2; i < len; i++) // skipping File and Test menus
	{
		BMenu* pMenu = m_pFullMenuBar->SubmenuAt(i);
		if (pMenu) {
			m_pMenuView->PopulateUserMenu(pMenu, i - 2);
		}
	}
}

void MenuWindow::MessageReceived(BMessage* message)
{
	switch (message->what) {
	case MSG_WIN_ADD_MENU:
		AddMenu(message);
		break;
	case MSG_WIN_DELETE_MENU:
		DeleteMenu(message);
		break;
	case MSG_TEST_ITEM:
		TestMenu(message);
		break;
	case MSG_USER_ITEM:
		UserMenu(message);
		break;
	case MSG_WIN_HIDE_USER_MENUS:
		ToggleUserMenus(message);
		break;
	case MSG_WIN_LARGE_TEST_ICONS:
		ToggleTestIcons(message);
		break;
	default:
		BWindow::MessageReceived(message);
		break;
	}
}

bool MenuWindow::QuitRequested(void)
{
	be_app->PostMessage(B_QUIT_REQUESTED);
	return true;
}



//--------------------------------------------------------------------
//	MenuWindow operations

void MenuWindow::UpdateStatus(const char* str1, const char* str2)
{
	uint32 lenTotal = 0, len1 = 0, len2 = 0;
	
	if (str1)
		len1 = strlen(str1);
	if (str2)
		len2 = strlen(str2);
	
	lenTotal = len1 + len2;	
	char* updateText = new char[lenTotal+1];
	updateText[0] = '\0'; // in case str1 and str2 are both NULL

	if (str1)
		strcpy(updateText, str1);
	if (str2)
		strcpy(updateText + len1, str2);
	
	if (Lock() && Valid()) {
		m_pStatusView->SetText(updateText);
		Unlock();
	}
	
	delete [] updateText;
}



//--------------------------------------------------------------------
//	MenuWindow message handlers

void MenuWindow::AddMenu(BMessage* message)
{
	if (! Valid()) {
		return;
	}
	
	const char* menuName;
	if (message->FindString("Menu Name", &menuName) == B_OK) {
		m_pFullMenuBar->AddItem(new BMenu(menuName));
		UpdateStatus(STR_STATUS_ADD_MENU, menuName);
	}
}

void MenuWindow::DeleteMenu(BMessage* message)
{
	if (! Valid()) {
		return;
	}		
	
	int32 i; 
	if (message->FindInt32("Menu Index", &i) == B_OK) {
		BMenuItem* pItem = m_pFullMenuBar->ItemAt(i+2);
		if (pItem) {
			// menu index is the above index + 2 (for File and Test menus)
			m_pFullMenuBar->RemoveItem(pItem);
			UpdateStatus(STR_STATUS_DELETE_MENU, pItem->Label());
			delete pItem;
		}
	}
}

void MenuWindow::TestMenu(BMessage* message)
{
	if (! Valid()) {
		return;
	}
	
	int32 i;
	if (message->FindInt32("Item Index", &i) == B_OK) {
		char numText[3];
		sprintf(numText, "%ld", i);
		UpdateStatus(STR_STATUS_TEST, numText);
	}
}

void MenuWindow::UserMenu(BMessage* message)
{
	if (! Valid()) {
		return;
	}
	
	const char* itemName;
	if (message->FindString("Item Name", &itemName) == B_OK) {
		UpdateStatus(STR_STATUS_USER, itemName);
	}
}

void MenuWindow::ToggleUserMenus(BMessage* message)
{
	if (! Valid()) {
		return;
	}
	
	void* pSrc;
	bool useFullMenus = false;
	
	if (message->FindPointer("source", &pSrc) == B_OK) {
		BCheckBox* pCheckBox = reinterpret_cast<BCheckBox*>(pSrc);
		useFullMenus = (pCheckBox->Value() == B_CONTROL_OFF);
	}
	
	if ((! useFullMenus) && m_bUsingFullMenuBar) {
		RemoveChild(m_pFullMenuBar);
		AddChild(m_pHiddenMenuBar);
		m_bUsingFullMenuBar = false;
	} else if (useFullMenus && (! m_bUsingFullMenuBar)) {
		RemoveChild(m_pHiddenMenuBar);
		AddChild(m_pFullMenuBar);
		m_bUsingFullMenuBar = true;
	}
}

void MenuWindow::ToggleTestIcons(BMessage* message)
{
	if (! Valid()) {
		return;
	}
	
	void* pSrc;
	icon_size size = B_MINI_ICON;
	
	if (message->FindPointer("source", &pSrc) == B_OK) {
		BCheckBox* pCheckBox = reinterpret_cast<BCheckBox*>(pSrc);
		size = (pCheckBox->Value() == B_CONTROL_ON) ? B_LARGE_ICON : B_MINI_ICON;
	}
	
	ReplaceTestMenu(m_pFullMenuBar, size);
	ReplaceTestMenu(m_pHiddenMenuBar, size);	
}



//--------------------------------------------------------------------
//	MenuWindow implementation member functions

bool MenuWindow::Valid(void) const
{
	if (! m_pFullMenuBar) {
		ierror(STR_NO_FULL_MENU_BAR);
		return false;
	}
	if (! m_pHiddenMenuBar) {
		ierror(STR_NO_HIDDEN_MENU_BAR);
		return false;
	}
	if (! m_pMenuView) {
		ierror(STR_NO_MENU_VIEW);
		return false;
	}
	if (! m_pStatusView) {
		ierror(STR_NO_STATUS_VIEW);
		return false;
	}
	return true;		
}

BMenu* MenuWindow::BuildFileMenu(void) const
{
	BMenu* pMenu = new BMenu(STR_MNU_FILE);
	
	BMenuItem* pAboutItem = new BMenuItem(STR_MNU_FILE_ABOUT,
		new BMessage(B_ABOUT_REQUESTED));
	pAboutItem->SetTarget(NULL, be_app);
	pMenu->AddItem(pAboutItem);
	
	pMenu->AddSeparatorItem();
	
	pMenu->AddItem(new BMenuItem(STR_MNU_FILE_CLOSE,
		new BMessage(B_QUIT_REQUESTED), CMD_FILE_CLOSE));
		
	return pMenu;
}

void MenuWindow::ReplaceTestMenu(BMenuBar* pMenuBar, icon_size size)
{
	if (! pMenuBar) {
		return;
	}
	
	BMenu* pTestMenu = m_testMenuBuilder.BuildTestMenu(size);
	if (pTestMenu) {
		BMenuItem* pPrevItem = pMenuBar->RemoveItem(1);
		if (pPrevItem) {
			delete pPrevItem;
		}
		pMenuBar->AddItem(pTestMenu, 1);
	}
}