defaulttreeitem.cpp

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

//DefaultTreeItem.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/DefaultTreeItem.h"
#include "vcf/ApplicationKit/TreeModel.h"

using namespace VCF;

DefaultTreeItem::DefaultTreeItem()
{
	init();
}

DefaultTreeItem::DefaultTreeItem( const String& caption )
{
	init();
	caption_ = caption;
}

DefaultTreeItem::DefaultTreeItem( const String& caption, Control* owningControl, TreeModel* model )
{
	init();
	owningControl_ = owningControl;
	model_ = dynamic_cast<Model*>(model);
	setCaption( caption );
}

DefaultTreeItem::~DefaultTreeItem()
{
	std::vector<TreeItem::SubItem*>::iterator subIt = subItems_.begin();
	while ( subIt != subItems_.end() ) {
		(*subIt)->release();
		subIt++;
	}
	subItems_.clear();

	std::vector<TreeItem*>::iterator it = childNodeItems_.begin();
	while ( it != childNodeItems_.end() ){
		delete *it;
		it++;
	}
	childNodeItems_.clear();
}

void DefaultTreeItem::init()
{
	imageIndex_ = 0;
	isExpanded_ = false;
	tag_ = -1;
	selectedImageIndex_ = -1;
	expandedImageIndex_ = -1;
	stateImageIndex_ = -1;

	selected_ = false;

	itemState_ = Item::idsNone;

	bounds_.setRect(0.0,0.0,0.0,0.0);
	owningControl_ = NULL;
	caption_ = "";
	childNodeItems_.clear();
	parent_ = NULL;
	textBold_ = false;

	TextColor_ = *GraphicsToolkit::getSystemColor( SYSCOLOR_WINDOW_TEXT );

	userData_ = NULL;
	enumContainer_.initContainer( childNodeItems_ );

	enumSubItemsContainer_.initContainer( subItems_ );

}

bool DefaultTreeItem::containsPoint( Point * pt )
{
	return bounds_.containsPt( pt );
}


unsigned long DefaultTreeItem::getIndex()
{
	return index_;
}

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

void* DefaultTreeItem::getData()
{
	return userData_;
}

void DefaultTreeItem::setData( void* data )
{
	userData_ = data;
	ItemEvent event( this );
	ItemChanged.fireEvent( &event );
}

Color* DefaultTreeItem::getTextColor()
{
	return &TextColor_;
}

void DefaultTreeItem::setTextColor(Color* color)
{
	TextColor_ = *color;
	ItemEvent event( this );
	ItemChanged.fireEvent( &event );
}

void DefaultTreeItem::setTextBold(const bool& bold)
{
	textBold_ = bold;
	ItemEvent event( this );
	ItemChanged.fireEvent( &event );
}

bool DefaultTreeItem::getTextBold()
{
	return textBold_;
}

bool DefaultTreeItem::isRoot()
{
	return ( NULL == parent_ );
}

bool DefaultTreeItem::isLeaf()
{
	return  childNodeItems_.empty();
}

TreeItem* DefaultTreeItem::getParent()
{
	return parent_;
}

void DefaultTreeItem::setParent( TreeItem* parent )
{
	parent_ = parent;
	ItemEvent event( this );
	ItemChanged.fireEvent( &event );
}

TreeItem* DefaultTreeItem::getNextChildNodeItem()
{
	if ( NULL != parent_ ) {
		DefaultTreeItem* dtParent = dynamic_cast<DefaultTreeItem*>(parent_);
		if ( NULL != dtParent ) {
			std::vector<TreeItem*>::iterator it = std::find( dtParent->childNodeItems_.begin(),
															 dtParent->childNodeItems_.end(),
															 this );

			it ++;
			if ( it != dtParent->childNodeItems_.end() ) {
				return *it;
			}
		}
	}
	return NULL;
}

TreeItem* DefaultTreeItem::getPrevChildNodeItem()
{
	if ( NULL != parent_ ) {
		DefaultTreeItem* dtParent = dynamic_cast<DefaultTreeItem*>(parent_);
		if ( (NULL != dtParent) && (index_ > 0) ) {
			std::vector<TreeItem*>::iterator it = std::find( dtParent->childNodeItems_.begin(),
															 dtParent->childNodeItems_.end(),
															 this );
			it --;

			if ( (it != dtParent->childNodeItems_.end()) && ( it >= dtParent->childNodeItems_.begin() ) ) {
				return *it;
			}
		}
	}
	return NULL;
}

String DefaultTreeItem::getCaption()
{
	Control* control = getControl();
	if ( getUseLocaleStrings() && (NULL != control) && (control->getUseLocaleStrings()) ) {
		return System::getCurrentThreadLocale()->translate( caption_ );
	}

	return caption_;
}

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

	changed( ITEM_EVENT_TEXT_CHANGED );
}

uint32 DefaultTreeItem::getChildCount()
{
	return childNodeItems_.size();
}

Enumerator<TreeItem*>* DefaultTreeItem::getChildren()
{
	return enumContainer_.getEnumerator();
}

void DefaultTreeItem::addChild( TreeItem* child )
{
//	StringUtils::trace( "Adding child " + child->getCaption() + "\n" );
	childNodeItems_.push_back( child );
	child->setParent( this );
	ItemEvent event( this, ITEM_EVENT_ADDED );
	ItemAdded.fireEvent( &event );
}

void DefaultTreeItem::insertChild( const unsigned long& index, TreeItem* child )
{
	std::vector<TreeItem*>::iterator it = childNodeItems_.begin();
	childNodeItems_.insert( it + index, child );
	child->setParent( this );
	ItemEvent event( this, ITEM_EVENT_ADDED );
	ItemAdded.fireEvent( &event );
	it = childNodeItems_.begin() + index;
	int i = index;
	while ( it != childNodeItems_.end() ) {
		TreeItem* item = *it;
		item->setIndex( i );
		it ++;
		i++;
	}
}

void DefaultTreeItem::deleteChild( TreeItem* child )
{
	std::vector<TreeItem*>::iterator found = std::find( childNodeItems_.begin(), childNodeItems_.end(), child );
	if ( found != childNodeItems_.end() ) {
		int index = found - childNodeItems_.begin();
		TreeItem* item = *found;
		ItemEvent event( child, ITEM_EVENT_DELETED );
		ItemDeleted.fireEvent( &event );
		delete item;
		item = NULL;
		childNodeItems_.erase ( found );
		int i = index;
		std::vector<TreeItem*>::iterator it = childNodeItems_.begin() + index;
		while ( it != childNodeItems_.end() ) {
			item = *it;
			item->setIndex( i );
			it ++;
			i ++;
		}
	}
}

void DefaultTreeItem::deleteChildAtIndex( const unsigned long& index )
{
	std::vector<TreeItem*>::iterator found =  childNodeItems_.begin() + index;
	if ( found != childNodeItems_.end() ) {
		TreeItem* item = *found;
		ItemEvent event( item, ITEM_EVENT_DELETED );
		ItemDeleted.fireEvent( &event );
		childNodeItems_.erase ( found );
		delete item;
		item = NULL;
		int i = index;
		std::vector<TreeItem*>::iterator it = childNodeItems_.begin() + index;
		while ( it != childNodeItems_.end() ) {
			item = *it;
			item->setIndex( i );
			it ++;
			i ++;
		}
	}
}

void DefaultTreeItem::clearChildren()
{
	for (std::vector<TreeItem*>::iterator it = childNodeItems_.begin(); it != childNodeItems_.end(); it ++ ){
		TreeItem* item = *it;
		item->clearChildren();
		ItemEvent deleteEvent( item, ITEM_EVENT_DELETED );
		ItemDeleted.fireEvent( &deleteEvent );
		delete item;
	}
	childNodeItems_.clear();

	ItemEvent event( this );
	ItemChanged.fireEvent( &event );
}


void DefaultTreeItem::setModel( Model* model )
{
	Item::setModel( model );
	for (std::vector<TreeItem*>::iterator it = childNodeItems_.begin(); it != childNodeItems_.end(); it ++ ){
		(*it)->setModel( model );
	}
}

void DefaultTreeItem::paint( GraphicsContext* context, Rect* paintRect )
{
	bounds_ = *paintRect;

	ItemEvent event( this, context );
	ItemPaint.fireEvent( &event );
}

bool DefaultTreeItem::isSelected()