treelistcontrol.cpp

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

				itemBounds.right_ = itemBounds.left_ + column->getWidth();
			}
			else {
				GraphicsContext* ctx = getContext();
				double w = ctx->getTextWidth( item->getCaption() );
				itemBounds.right_ = itemBounds.right_ + w + getCurrentIndent(item) ;
			}
		}
	}



	Rect intersect = itemBounds.makeIntersection( rect );

	if ( !intersect.isEmpty() && !intersect.isNull() ) {
		hitTestList.push_back( item );
	}

	if ( (false == item->isLeaf()) && (true == item->isExpanded()) ) {
		Enumerator<TreeItem*>* children = item->getChildren();
		while ( true == children->hasMoreElements() ) {
			TreeItem* child = children->nextElement();
			hitTest( rect, child, hitTestList );
		}
	}

	return result;
}

void TreeListControl::mouseMove( MouseEvent* event )
{
	CustomControl::mouseMove( event );
	if ( (true == event->hasLeftButton()) && (true == draggingSelectionRect_) ) {

		/**
		!!!!!!!HACK!!!!!!!
		
		We need to put this in the paint code and simply invalidate here!
		
		!!!!!!!HACK!!!!!!!
		*/
		GraphicsContext* context = getContext();
		DrawUIState state;
		state.setActive( true );
		context->drawThemeSelectionRect( &dragSelectionRect_, state );

		Point* pt = event->getPoint();
		dragSelectionRect_.setRect( dragPoint_.x_, dragPoint_.y_, pt->x_, pt->y_ );

		dragSelectionRect_.normalize();

		context->drawThemeSelectionRect( &dragSelectionRect_, state );

		bool needsRepaint = false;

		if ( !draggingSelectedItems_.empty() ) {
			std::vector<TreeItem*>::iterator it = draggingSelectedItems_.begin() ;
			while ( it != draggingSelectedItems_.end() ) {
				(*it)->setSelected( false );
				ItemEvent event( this, ITEM_EVENT_UNSELECTED );
				event.setUserData((void*)(*it));
				ItemSelected.fireEvent( &event );

				std::vector<TreeItem*>::iterator found = std::find( selectedItems_.begin(), selectedItems_.end(), *it ) ;
				if ( found != selectedItems_.end() ) {
					selectedItems_.erase( found );
				}

				it ++;
			}
			needsRepaint = true;
		}

		draggingSelectedItems_.clear();

		Enumerator<TreeItem*>* rootChildren = treeModel_->getRootItems();
		while ( rootChildren->hasMoreElements() ) {
			TreeItem* rootItem = rootChildren->nextElement();
			hitTest( &dragSelectionRect_, rootItem, draggingSelectedItems_ );
		}

		if ( !draggingSelectedItems_.empty() ) {
			std::vector<TreeItem*>::iterator it = draggingSelectedItems_.begin() ;
			while ( it != draggingSelectedItems_.end() ) {
				if ( false == (*it)->isSelected() ) {
					(*it)->setSelected( true );
					selectedItems_.push_back( *it );
				}
				it ++;
			}
			needsRepaint = true;
		}

		if ( needsRepaint ) {
			repaint();
		}
	}

}

void TreeListControl::mouseUp( MouseEvent* event )
{
	CustomControl::mouseUp( event );
	if ( (true == event->hasLeftButton()) && (true == draggingSelectionRect_) ) {
		GraphicsContext* context = getContext();
		DrawUIState state;
		state.setActive(true);
		context->drawThemeSelectionRect( &dragSelectionRect_, state );

		Point* pt = event->getPoint();
		dragSelectionRect_.setRect( dragPoint_.x_, dragPoint_.y_, pt->x_, pt->y_ );

		dragSelectionRect_.normalize();

		context->drawThemeSelectionRect( &dragSelectionRect_, state );
		context->drawThemeSelectionRect( &dragSelectionRect_, state );
		repaint();
	}
}

void TreeListControl::setImageList( ImageList* imageList )
{
	if ( NULL != imageList_ ) {
		imageList_->release();
	}

	imageList_ = imageList;

	if ( NULL != imageList_ ) {
		imageList_->addRef();

		itemHeight_ = maxVal<double>( itemHeight_, maxVal<double>( imageList_->getImageWidth(), imageList_->getImageHeight() ) );
	}
}

ImageList* TreeListControl::getImageList()
{
	return imageList_;
}

ImageList* TreeListControl::getStateImageList()
{
	return stateImageList_;
}

void TreeListControl::setStateImageList( ImageList* imageList )
{
	if ( NULL != stateImageList_ ) {
		stateImageList_->release();
	}

	stateImageList_ = imageList;

	if ( NULL != stateImageList_ ) {
		stateImageList_->addRef();
	}
}

long TreeListControl::getDisplayOptions()
{
	return displayOptions_;
}

void TreeListControl::setDisplayOptions( const long& displayOptions )
{
	displayOptions_ = displayOptions;

	if ( displayOptions_ & TreeListControl::tdoShowColumnHeader ) {
		header_->setHeight( columnHeight_ );
	}
	else {
		header_->setHeight( 0.0 );
	}

	repaint();
}

TreeItem* TreeListControl::isPtOverItem(Point* point)
{
	TreeItem* result = NULL;
	std::vector<TreeItem*> visibleItems;

	populateVisiblityList( visibleItems );

	std::vector<TreeItem*>::iterator it = visibleItems.begin();
	while ( it != visibleItems.end() ) {
		TreeItem* item = *it;
		if ( item->containsPoint( point ) ) {
			result = item;
			break;
		}
		it ++;
	}

	return result;
}


TreeItem* TreeListControl::getSelectedItem()
{
	TreeItem* result = NULL;

	if ( false == selectedItems_.empty() ) {
		result = selectedItems_[0];
	}

	return result;
}

bool TreeListControl::getAllowLabelEditing()
{
	return allowLabelEditing_;
}

void TreeListControl::setAllowLabelEditing( const bool& allowLabelEditing )
{
	allowLabelEditing_ = allowLabelEditing;
}


void TreeListControl::onColumnWidthChanged( ItemEvent* event )
{
	ColumnItem* item = (ColumnItem*)event->getSource();

	if ( item->getIndex() == 0 ) {
		double width = item->getWidth();
		double minWidth = (itemIndent_ + stateItemIndent_) * 1.5;
		if ( width < minWidth ) {
			item->setWidth( minWidth );
		}
	}


	repaint();
}

void TreeListControl::setAllowsMultipleSelection( const bool& multiSelect )
{
	if ( (false == multiSelect) && (false == selectedItems_.empty() ) ) {

		TreeItem* first = NULL;
		if ( ! selectedItems_.empty() ) {
			first = selectedItems_[0];
		}

		clearSelectedItems();

		if ( NULL != first ) {
			selectedItems_.push_back( first );
			first->setSelected( true );
		}

		repaint();
	}
	allowMultipleSelection_ = multiSelect;
}

void TreeListControl::setSelectedItem( TreeItem* item, const bool& isSelected )
{
	if ( true == allowMultipleSelection_ ) {
		std::vector<TreeItem*>::iterator found = std::find( selectedItems_.begin(), selectedItems_.end(),
																item );
		if ( (true == isSelected) && (found == selectedItems_.end()) ) {
			selectedItems_.push_back( item );
		}
		else if ( found != selectedItems_.end() ) {
			if ( false == isSelected ) {
				selectedItems_.erase( found );
			}
		}
	}
	else {
		if ( true == isSelected ) {
			std::vector<TreeItem*>::iterator found = std::find( selectedItems_.begin(), selectedItems_.end(), item );
			if ( found == selectedItems_.end() ) {
				selectedItems_.push_back( item );
			}
		}
		else {
			clearSelectedItems();
		}
	}

	item->setSelected( isSelected );

	if ( true == isSelected ) {
		ItemEvent event( this, ITEM_EVENT_SELECTED );
		event.setUserData( (void*)item );
		ItemSelected.fireEvent( &event );
	}
	else
	{
		ItemEvent event( this, ITEM_EVENT_UNSELECTED );
		event.setUserData( (void*)item );
		ItemSelected.fireEvent( &event );
	}
}

Enumerator<TreeItem*>* TreeListControl::getSelectedItems()
{
	return selectedItemContainer_.getEnumerator();
}

bool TreeListControl::listVisibleItems( std::vector<TreeItem*>& items, TreeItem* itemToSearch, const double& top, const double& bottom )
{
	bool result = false;
	if ( NULL != itemToSearch ) {

		Rect* bounds = itemToSearch->getBounds();
		if ( bounds->isNull() || bounds->isEmpty() ) {
			bounds->setRect( 1, itemHeight_ * items.size(), getWidth()-1, itemHeight_ * items.size() + itemHeight_ );			
		}
		if ( (bounds->bottom_ >= top) || (bounds->top_ < bottom) ){
			items.push_back( itemToSearch );
			result = true;
			if ( (!itemToSearch->isLeaf()) && (itemToSearch->isExpanded()) ) {
				//check children
				Enumerator<TreeItem*>* children = itemToSearch->getChildren();
				while ( children->hasMoreElements() ) {
					TreeItem* child = children->nextElement();
					if ( false == listVisibleItems( items, child, top, bottom ) ) {
						break;
					}
				}
			}
		}
	}

	return result;
}

void TreeListControl::populateVisiblityList( std::vector<TreeItem*>& items, Rect* bounds )
{
	Enumerator<TreeItem*>* rootItems = treeModel_->getRootItems();
	Rect clientBounds;
	if ( NULL != bounds ) {
		clientBounds = *bounds;
	}
	else {
		clientBounds = getClientBounds();
		
		clientBounds.top_ += header_->getHeight();
		
		Scrollable* scrollable = getScrollable();
		if ( NULL != scrollable ) {
			clientBounds.offset( 0, scrollable->getVerticalPosition() );
		}
	}
	while ( rootItems->hasMoreElements() ) {
		TreeItem* child = rootItems->nextElement();
		if ( false == listVisibleItems( items, child, clientBounds.top_, clientBounds.bottom_ ) ) {
			break;
		}
	}	
}

double TreeListControl::getCurrentIndent( TreeItem* item )
{
	double result = getItemIndent() * item->getLevel();

	result += EXPANDER_SPACER*2;  //scootch over for the expander
	//determine if we have an image list present
	if ( NULL != imageList_ ) {
		result += imageList_->getImageWidth();
	}

	if ( Item::idsNone != item->getState() ) {
		if ( NULL != stateImageList_ ) {
			result += stateImageList_->getImageWidth();
		}
		else {
			result += stateItemIndent_;
		}
	}

	return result;
}

double TreeListControl::getDefaultItemHeight()
{
	double result = itemHeight_;
	if ( NULL != imageList_ ) {
		result = maxVal<double>( result, imageList_->getImageHeight() );
	}

	return result;
}

void TreeListControl::setDefaultItemHeight( const double& defaultItemHeight )
{
	itemHeight_ = defaultItemHeight;
}

Rect TreeListControl::getStateRect( TreeItem* item, const double& indent )
{
	Rect result;

	if ( item->getState() != Item::idsNone ) {
		Rect* itemBounds = item->getBounds();

		result = *itemBounds;

		result.left_ += indent;
		if ( NULL != stateImageList_ ) {
			result.right_ = result.left_ + stateImageList_->getImageWidth();
			result.top_ = itemBounds->top_ + (itemBounds->getHeight()/2.0 - stateImageList_->getImageHeight()/2.0);
			result.bottom_ = result.top_ + stateImageList_->getImageHeight();
		}
		else {
			result.right_ = result.left_ + stateItemIndent_;
			result.top_ = itemBounds->top_ + (itemBounds->getHeight()/2.0 - (minVal<double>(stateItemIndent_,itemHeight_)/2.0));
			result.bottom_ = result.top_ + (minVal<double>(stateItemIndent_,itemHeight_));
		}

		if ( NULL != imageList_ ) {
			if ( NULL != stateImageList_ ) {
				result.offset( -(maxVal<double>( imageList_->getImageWidth(), stateImageList_->getImageWidth() )), 0 );
			}
			else {
				result.offset( -(maxVal<double>( imageList_->getImageWidth(), stateItemIndent_ )), 0 );
			}
		}
		else {
			if ( NULL != stateImageList_ ) {
				result.offset( -(maxVal<double>( stateItemIndent_, stateImageList_->getImageWidth() )), 0 );
			}
			else {
				//result.offset( -stateItemIndent_, 0 );
			}
		}

	}
	return result;
}

void TreeListControl::showHierarchyLines( const bool& show )
{
	if ( true == show ) {
		displayOptions_ |= TreeListControl::tdoShowHierarchyLines;
	}
	else {
		displayOptions_ &= ~TreeListControl::tdoShowHierarchyLines;
	}
	repaint();
}

void TreeListControl::showRowLines( const bool& show )
{
	if ( true == show ) {
		displayOptions_ |= TreeListControl::tdoShowRowLines;
	}
	else {
		displayOptions_ &= ~TreeListControl::tdoShowRowLines;
	}
	repaint();
}

void TreeListControl::showColumnLines( const bool& show )
{
	if ( true == show ) {
		displayOptions_ |= TreeListControl::tdoShowColumnLines;
	}
	else {
		displayOptions_ &= ~TreeListControl::tdoShowColumnLines;
	}

	repaint();
}

void TreeListControl::showFullRowSelection( const bool& show )
{
	if ( true == show ) {
		displayOptions_ |= TreeListControl::tdoShowFullRowSelection;
	}
	else {
		displayOptions_ &= ~TreeListControl::tdoShowFullRowSelection;
	}