defaultmenuitem.cpp

来自「这是VCF框架的代码」· C++ 代码 · 共 985 行 · 第 1/2 页

//DefaultMenuItem.cpp

/*
Copyright 2000-2004 The VCF Project.
Please see License.txt in the top level directory
where you installed the VCF.
*/


#include "vcf/ApplicationKit/ApplicationKit.h"
#include "vcf/ApplicationKit/MenuItemPeer.h"
#include "vcf/ApplicationKit/Action.h"
#include "vcf/ApplicationKit/ActionEvent.h"
#include "vcf/ApplicationKit/MenuManager.h"


using namespace VCF;

static DefaultMenuItem* previousSelectedItem = NULL;

DefaultMenuItem::DefaultMenuItem():
	//peer_(NULL),
	//index_(0),
	data_(NULL),
	menuOwner_(NULL),
	parent_(NULL),
	imageIndex_(-1),
	currentAccelerator_(NULL)
{
	init();
}

DefaultMenuItem::DefaultMenuItem( const String& caption, MenuItem* parent, Menu* menuOwner ):
	//peer_(NULL),
	//index_(0),
	data_(NULL),
	menuOwner_(NULL),
	parent_(NULL),
	imageIndex_(-1),
	currentAccelerator_(NULL)
{
	init();

	setCaption( caption );	
	
	if ( NULL != parent ){
		parent->addChild( this );
	}

	setMenuOwner( menuOwner );
}

DefaultMenuItem::~DefaultMenuItem()
{

	if ( NULL != currentAccelerator_ ) {
		UIToolkit::removeAccelerator( (VirtualKeyCode)currentAccelerator_->getKeyCode(),
																currentAccelerator_->getModifierMask(), this );
	}

	if ( this == previousSelectedItem )	{
		previousSelectedItem = NULL;
	}
	else if ( NULL == getParent() ) {
		previousSelectedItem = NULL;
	}

	//delete peer_;
	//peer_ = NULL;

	menuItems_.clear();
}

void DefaultMenuItem::init()
{
	setTag(-1);

	//peer_ = UIToolkit::createMenuItemPeer( this );

	itemState_ |= MenuItem::mdsEnabled;
	itemState_ |= MenuItem::mdsVisible;

	//if ( NULL == peer_ ){
		//throw exception
	//	throw InvalidPeer(MAKE_ERROR_MSG(NO_PEER), __LINE__);
	//}

	//peer_->setMenuItem( this );

	container_.initContainer( menuItems_ );

	EventHandler* ev = new GenericEventHandler<DefaultMenuItem> ( this, &DefaultMenuItem::handleEvent, "DefaultMenuItem::handleEvent" );

	ComponentAdded += ev;
	ComponentRemoved += ev;
}

bool DefaultMenuItem::containsPoint( Point * pt )
{
	return true;
}

unsigned long DefaultMenuItem::getIndex()
{
	Menu* owner = getMenuOwner();
	if ( NULL == owner ) {
		return MenuItem::InvalidMenuIndex;
	}
	return owner->getItemIndex( this );
}

void DefaultMenuItem::setIndex( const unsigned long& index ){}
//{
//	index_ = index;
//}

void* DefaultMenuItem::getData()
{
	return data_;
}

void DefaultMenuItem::setData( void* data )
{
	data_ = data;
}

void DefaultMenuItem::paint( GraphicsContext* context, Rect* paintRect )
{
	//StringUtils::trace( "DefaultMenuItem::paint " + paintRect->toString() +"\n" );
	bounds_ = *paintRect;

	String text = caption_;
	if ( this->getUseLocaleStrings() ) {
		text = System::getCurrentThreadLocale()->translate( caption_ );
	}

	context->textAt( paintRect->left_, paintRect->top_, text );
}

bool DefaultMenuItem::isSelected()
{
	return (itemState_ & MenuItem::mdsSelected) ? true : false;
}

void DefaultMenuItem::setSelected( const bool& selected )
{
	if ( (NULL != previousSelectedItem) && (previousSelectedItem != this) ) {
		previousSelectedItem->setSelected( false );
	}

	if ( selected ) {
		itemState_ |= MenuItem::mdsSelected;

		//ItemEvent event( this, ITEM_EVENT_SELECTED );
		//ItemSelected.fireEvent( &event );

		getMenuOwner()->itemChanged( MenuItem::miSelected, this );
	}
	else {
		itemState_ &= ~MenuItem::mdsSelected;
	}	
	
	previousSelectedItem = this;
}

Enumerator<MenuItem*>* DefaultMenuItem::getChildren()
{
	return container_.getEnumerator();
}

void DefaultMenuItem::addChild( MenuItem* child )
{
	menuItems_.push_back( child );

	child->setParent( this );

	if ( NULL == child->getOwner() ) {
		addComponent( child );
	}

	//child->setIndex( menuItems_.size() - 1 );

	child->setMenuOwner( getMenuOwner() );

	//peer_->addChild( child );

	//ItemEvent event( this, ITEM_EVENT_ADDED );
	//ItemAdded.fireEvent( &event );
	Menu* owner = getMenuOwner();
	if ( NULL != owner ) {
		owner->itemChanged( MenuItem::miAdded, child );
	}
}

void DefaultMenuItem::insertChild( const unsigned long& index, MenuItem* child )
{
	menuItems_.insert( menuItems_.begin() + index, child );

	if ( NULL == child->getOwner() ) {
		addComponent( child );
	}

	/*
	std::vector<MenuItem*>::iterator it = menuItems_.begin() + index;
	unsigned long newIndex = index;
	while ( it != menuItems_.end() ) {
		(*it)->setIndex( newIndex );		
		it ++;
		newIndex ++;
	}
	*/

	child->setParent( this );

	child->setMenuOwner( getMenuOwner() );

	//peer_->insertChild( index, child );

	//ItemEvent event( this, ITEM_EVENT_ADDED );
	//ItemAdded.fireEvent( &event );
	Menu* owner = getMenuOwner();
	if ( NULL != owner ) {
		owner->itemChanged( MenuItem::miAdded, child );
	}	
}

void DefaultMenuItem::deleteChild( MenuItem* child )
{
	std::vector<MenuItem*>::iterator found = std::find( menuItems_.begin(), menuItems_.end(), child );
	if ( found != menuItems_.end() ){
		unsigned long index = found - menuItems_.begin();
	
		itemState_ &= ~MenuItem::mdsBoundToMenuPeer;

		Menu* owner = getMenuOwner();
		if ( NULL != owner ) {
			owner->itemChanged( MenuItem::miRemoved, child );
		}

		removeComponent( child );

		menuItems_.erase( found );
		child->free();
		child = NULL;	
	}
}

void DefaultMenuItem::deleteChild( const unsigned long& index )
{
	//peer_->deleteChild( index );

	std::vector<MenuItem*>::iterator found = menuItems_.begin() + index;
	if ( found != menuItems_.end() ){

		itemState_ &= ~MenuItem::mdsBoundToMenuPeer;

		Menu* owner = getMenuOwner();
		if ( NULL != owner ) {
			owner->itemChanged( MenuItem::miRemoved, *found );
		}

		removeComponent( *found );

        (*found)->free();
		menuItems_.erase( found );
	}
}

void DefaultMenuItem::clearChildren()
{
	std::vector<MenuItem*>::iterator it = menuItems_.begin();
	while ( it != menuItems_.end() ){
		removeComponent( *it );
		(*it)->free();
		it++;
	}
	menuItems_.clear();

	//peer_->clearChildren();
}

bool DefaultMenuItem::isChecked()
{
	return ((itemState_ & MenuItem::mdsChecked) == MenuItem::mdsChecked) ? true : false;// peer_->isChecked();
}

void DefaultMenuItem::setChecked( const bool& checked )
{
	//peer_->setChecked( checked );
	if ( checked ) {
		itemState_ &= ~MenuItem::mdsUnChecked;
		itemState_ |= MenuItem::mdsChecked;
	}
	else {
		itemState_ &= ~MenuItem::mdsChecked;
		itemState_ |= MenuItem::mdsUnChecked;
	}

	Menu* owner = getMenuOwner();
	if ( NULL != owner ) {
		owner->itemChanged( MenuItem::miCheckStateChanged, this );
	}
}

bool DefaultMenuItem::hasParent()
{

	return (parent_ != NULL);
}

MenuItem* DefaultMenuItem::getParent()
{
	return parent_;
}

void DefaultMenuItem::setParent( MenuItem* parent )
{
	parent_ = parent;
}

MenuItem* DefaultMenuItem::getChildAt( const unsigned long& index )
{
	if ( index >= menuItems_.size() ) {
		throw OutOfBoundsException(MAKE_ERROR_MSG(OUT_OF_BOUNDS_EXCEPTION), __LINE__);
	}
	return menuItems_[index];
}

bool DefaultMenuItem::isEnabled()
{
	bool result = (itemState_ & MenuItem::mdsEnabled) ? true : false;

	if ( result ) {
		MenuBar* menuBar = dynamic_cast<MenuBar*>( menuOwner_ );
		if ( NULL != menuBar ) {
			Frame* frame = menuBar->getFrame();
			if ( NULL != frame ) {
				result = frame->isEnabled();
			}
		}
	}
	return result;
}

void DefaultMenuItem::setEnabled( const bool& enabled )
{
	if ( enabled ) {
		itemState_ |= MenuItem::mdsEnabled;
	}
	else {
		itemState_ &= ~MenuItem::mdsEnabled;
	}

	//peer_->setEnabled( enabled );

	AcceleratorKey* accel = getAccelerator();
	if ( NULL != accel ) {
		accel->setEnabled( enabled );
	}

	//ItemEvent event( this, ITEM_EVENT_CHANGED );
	//ItemChanged.fireEvent( &event );
	Menu* owner = getMenuOwner();
	if ( NULL != owner ) {
		owner->itemChanged( MenuItem::miEnabledStateChanged, this );
	}
}

bool DefaultMenuItem::isVisible()
{
	return (itemState_ & MenuItem::mdsVisible) ? true : false;
}

void DefaultMenuItem::setVisible( const bool& visible )
{
	if ( visible ) {
		itemState_ |= MenuItem::mdsVisible;
	}
	else {
		itemState_ &= ~MenuItem::mdsVisible;
	}

	//peer_->setVisible( visible );

	//ItemEvent event( this, ITEM_EVENT_CHANGED );
	//ItemChanged.fireEvent( &event );
	Menu* owner = getMenuOwner();
	if ( NULL != owner ) {
		owner->itemChanged( MenuItem::miVisibleStateChanged, this );
	}
}

bool DefaultMenuItem::getRadioItem()
{
	return (itemState_ & MenuItem::mdsRadioItem) ? true : false;
}

void DefaultMenuItem::setRadioItem( const bool& value )
{
	if ( value ) {
		itemState_ |= MenuItem::mdsRadioItem;
	}
	else {
		itemState_ &= ~MenuItem::mdsRadioItem;
	}
	
	//peer_->setRadioItem( value );

	//ItemEvent event( this, ITEM_EVENT_CHANGED );
	//ItemChanged.fireEvent( &event );
	Menu* owner = getMenuOwner();
	if ( NULL != owner ) {
		owner->itemChanged( MenuItem::miRadioStateChanged, this );
	}
}

void DefaultMenuItem::setCaption( const String& caption )
{
	caption_ = caption;

	//peer_->setCaption( caption_ );

	//ItemEvent event( this, ITEM_EVENT_TEXT_CHANGED );
	//ItemChanged.fireEvent( &event );
	Menu* owner = getMenuOwner();
	if ( NULL != owner ) {
		owner->itemChanged( MenuItem::miCaptionChanged, this );
	}
}

String DefaultMenuItem::getCaption()
{
	return caption_;
}

MenuItemPeer* DefaultMenuItem::getPeer()
{
	return MenuManager::getMenuItemPeer(this); //peer_;
}

bool DefaultMenuItem::hasChildren()
{
	return ! menuItems_.empty();
}

void DefaultMenuItem::click()
{
	if ( ! isEnabled() ) {
		return;
	}

	MenuItemEvent event( this, MENU_ITEM_EVENT_CLICKED );

	Action* action = getAction();
	if ( NULL != action ) {
		action->perform( &event );
	}
	else {		
		MenuItemClicked.fireEvent( &event );
	}
}

void DefaultMenuItem::update()
{
	Action* action = getAction();
	if ( NULL != action ) {
		action->update();
	}
	else {
		MenuItemEvent event( this, MENU_ITEM_EVENT_UPDATED );
		MenuItemUpdate.fireEvent( &event );
	}
}

Menu* DefaultMenuItem::getMenuOwner()
{
	return menuOwner_;
}

void DefaultMenuItem::setMenuOwner( Menu* menuOwner )
{
	menuOwner_ = menuOwner;
	std::vector<MenuItem*>::iterator it = menuItems_.begin();
	while ( it != menuItems_.end() ){
		MenuItem* child = *it;
		if ( NULL != child ) {
			Menu* prevOwner = child->getMenuOwner();
			child->setMenuOwner( menuOwner );
		}
		it++;
	}
}