treelistcontrol.cpp

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

{
	bool result = false;

	TreeItem* foundItem = NULL;
	Enumerator<TreeItem*>* rootChildren = treeModel_->getRootItems();
	TreeItem* prevSelectedItem = getSelectedItem();

	while ( rootChildren->hasMoreElements() ) {
		TreeItem* rootItem = rootChildren->nextElement();
		foundItem = hitTest( event->getPoint(), rootItem );
		if ( NULL != foundItem ) {

			Rect expanderRect;

			ulong32 level = foundItem->getLevel();
			expanderRect = *foundItem->getBounds();
			expanderRect.left_ += (level * itemIndent_);
			expanderRect.right_ = expanderRect.left_ + itemIndent_;

			//currentSelectedItem_ = foundItem;

			if ( expanderRect.containsPt( event->getPoint() ) ) {
				foundItem->expand( !foundItem->isExpanded() );
				ItemEvent event( this, ITEM_EVENT_CHANGED );
				ItemExpanded.fireEvent( &event );

				recalcScrollable();

				if ( !foundItem->isExpanded() ) {
					if ( NULL != prevSelectedItem ) {
						if ( prevSelectedItem->getParent() == foundItem ) {
							setSelectedItem( prevSelectedItem, false );
							setSelectedItem( foundItem, true );							
							result = true;
							repaint();
						}
					}
				}
			}
			else if ( stateHitTest( event->getPoint(), foundItem ) ) {
				long state = foundItem->getState();
				//probably need to come up with better id's
				//for enum values so that we can mask together
				//as opposed to doing a direct
				//assignment
				if ( Item::idsChecked == state ) {
					state = Item::idsUnChecked;
				}
				else if ( Item::idsUnChecked == state ) {
					state = Item::idsChecked;
				}

				foundItem->setState( state );
				ItemEvent event( foundItem, TreeListControl::ITEM_STATECHANGE_REQUESTED );
				ItemStateChangeRequested.fireEvent( &event );
			}
			else {

				if ( prevSelectedItem != NULL ) {
					if ( prevSelectedItem != foundItem ) {
						setSelectedItem( prevSelectedItem, false );
					}
				}

				result = (prevSelectedItem != foundItem);

				setSelectedItem( foundItem, true );
			}
			repaint();
			break;
		}
	}

	if ( NULL == foundItem ) {
		if ( prevSelectedItem != NULL ) {
			if ( prevSelectedItem != foundItem ) {
				setSelectedItem( prevSelectedItem, false );
			}
		}
	}
	
	return result;
}

Rect TreeListControl::getBoundsForEdit( TreeItem* item, int column )
{
	Rect result;

	if ( column == -1 ) {
		return result;
	}


	ColumnModel* cm = header_->getColumnModel();
	Enumerator<ColumnItem*>* columnItems = cm->getItems();

	result = *item->getBounds();

	int index = 0;
	while ( columnItems->hasMoreElements() ) {
		ColumnItem* col = columnItems->nextElement();
		result.right_ = result.left_ + col->getWidth();

		if ( index == column ) {

			if ( 0 == column ) {
				//adjust for state and image icons
				Rect expanderRect = getExpanderRect( item );
		
				if ( !item->isLeaf() ) {
					result.left_ = expanderRect.right_;
				}

				Rect stateRect = getStateRect( item, getCurrentIndent( item ) );

				if ( !stateRect.isEmpty() && !stateRect.isNull() ) {
					result.left_ = maxVal<>( stateRect.right_, result.left_ );
				}
			}

			//adjust for scrollers
			Scrollable* scrollable = getScrollable();
			if ( NULL != scrollable ) {
				result.offset( -scrollable->getHorizontalPosition(), -scrollable->getVerticalPosition());
				Rect clientBounds = getClientBounds();
				double w = clientBounds.getWidth();
				double h = clientBounds.getHeight();

				if ( scrollable->isVerticalScrollbarVisible() ) {
					result.right_ = minVal<>( result.right_, 
											w - scrollable->getVerticalScrollbarWidth() );
				}
				
				if ( scrollable->isHorizontalScrollbarVisible() ) {
					result.bottom_ = minVal<>( result.bottom_, 
											h - scrollable->getHorizontalScrollbarHeight() );
				}
			}

			break;
		}
		result.left_ += col->getWidth();
		index++;
	}

	return result;
}

int TreeListControl::hitTestForEditColumn( Point* pt )
{
	int result = -1;

	TreeItem* item = hitTest( pt );
	if ( NULL != item ) {
		if ( item->getSubItemCount() > 0 ) {

			result = 0;
				 
			ColumnModel* cm = header_->getColumnModel();
			Enumerator<ColumnItem*>* columnItems = cm->getItems();

			Rect subItemRect = *item->getBounds();
			subItemRect.right_ = subItemRect.left_ + cm->getItemFromIndex( 0 )->getWidth();

			if ( !subItemRect.containsPt( pt ) ) {
				subItemRect.left_ += cm->getItemFromIndex( 0 )->getWidth();
				result ++;


				bool found = false;
				Enumerator<TreeItem::SubItem*>* subItems = item->getSubItems();
				while ( columnItems->hasMoreElements() && subItems->hasMoreElements() ) {
					TreeItem::SubItem* subItem = subItems->nextElement();
					ColumnItem* column = columnItems->nextElement();				
					
					subItemRect.right_ = subItemRect.left_ + column->getWidth();
					
					if ( subItemRect.containsPt( pt ) ) {
						found = true;
						break;
					}
					
					subItemRect.left_ += column->getWidth();
					
					result++;
				}
				
				if ( !found ) {
					result = -1;
				}
			}
		}
		else {
			result = 0;
		}
	}

	return result;
}

TreeItem* TreeListControl::getNextItem( TreeItem* item, bool skipChildren )
{
	TreeModel* tm = getTreeModel();
	TreeItem* result = NULL;

	if ( NULL != item ) {
		TreeItem* nextItem = NULL;		
		
		if ( !item->isLeaf() && item->isExpanded() && !skipChildren ) {
			Enumerator<TreeItem*>* items = item->getChildren();
			//get first item!
			if ( items->hasMoreElements() ) {
				nextItem = items->nextElement();
			}
		}
		else if ( item->getParent() == NULL ) {
			Enumerator<TreeItem*>* items = tm->getRootItems();				
			while ( items->hasMoreElements() ) {
				nextItem = items->nextElement();
				if ( nextItem == item ) {
					//skip one more if possible
					if ( items->hasMoreElements() ) {
						nextItem = items->nextElement();								
					}
					break;
				}
			}
		}
		else {
			nextItem = item->getNextChildNodeItem();
			while ( nextItem == NULL ) {
				TreeItem* parent = item->getParent();
				if ( NULL != parent ) {
					nextItem = getNextItem( parent, true );
				}
				else { 
					nextItem = item;
					break; //use item!
				}
			}
		}
		
		result = nextItem;
	}
	else {
		Enumerator<TreeItem*>* items = tm->getRootItems();
		//get first item!
		if ( items->hasMoreElements() ) {
			result = items->nextElement();
		}
	}
	
	return result;
}

TreeItem* TreeListControl::getPrevItem( TreeItem* item )
{
	TreeItem* result = NULL;

	TreeModel* tm = getTreeModel();

	if ( NULL != item ) {
		TreeItem* prevItem = item->getPrevChildNodeItem();

		if ( NULL == prevItem ) {
			if ( item->getParent() ) {
				prevItem = item->getParent();
			}
			else {
				Enumerator<TreeItem*>* items = tm->getRootItems();
				TreeItem* nextItem = NULL;
				if ( items->hasMoreElements() ) {
					prevItem = items->nextElement();
				}

				while ( items->hasMoreElements() ) {					
					nextItem = items->nextElement();

					if ( nextItem == item ) {						
						break;
					}

					if ( prevItem == item ) { //first element, return the parent
						prevItem = item->getParent();
						break;
					}

					prevItem = nextItem;
				}
			}
		}

		result = prevItem;
	}
	else {
		Enumerator<TreeItem*>* items = tm->getRootItems();
		//get first item!
		if ( items->hasMoreElements() ) {
			result = items->nextElement();
		}
	}

	return result;
}

void TreeListControl::scrollToNextItem( TreeItem* item, bool scrollDown )
{
	Scrollable* scrollable = getScrollable();
	if ( NULL != scrollable ) {
		Rect clientBounds = getClientBounds();
		Rect itemBounds = *item->getBounds();
		
		
		double virtualHeight = scrollable->getVirtualViewHeight();

		if ( scrollDown ) {
			//skip at least one item ahead, so double the item height
			double adjustedBottom = (itemBounds.getHeight()*2 + itemBounds.top_) - scrollable->getVerticalPosition();

			if ( adjustedBottom > clientBounds.bottom_ ) {
				double newPos = item->getBounds()->getHeight() + 
					scrollable->getVerticalPosition();
				if ( (adjustedBottom - clientBounds.bottom_) < (itemBounds.getHeight()*2) ) {
					newPos += ((itemBounds.getHeight()*2) - (adjustedBottom - clientBounds.bottom_));
				}
				
				newPos = minVal<double>( newPos, virtualHeight );
				
				//move the scroll down
				scrollable->setVerticalPosition( newPos );
			}
		}
		else {
			double adjustedTop = (itemBounds.top_ - itemBounds.getHeight()*2 ) - scrollable->getVerticalPosition();

			if ( adjustedTop < clientBounds.top_ ) {
				double newPos = scrollable->getVerticalPosition() -
									item->getBounds()->getHeight();
/*
				adjustedTop = abs(adjustedTop);
				if ( (adjustedTop - clientBounds.top_) < (itemBounds.getHeight()*2) ) {
					newPos += ((itemBounds.getHeight()*2) + (adjustedTop - clientBounds.top_));
				}
*/
				newPos = maxVal<double>( newPos, 0 );

				scrollable->setVerticalPosition( newPos );
			}
		}
	}
}

void TreeListControl::keyDown( KeyboardEvent* e )
{
	CustomControl::keyDown( e );

	switch( e->getVirtualCode() ) {
		case vkReturn : {

			//editCell( clickCell_, Point() );

		}
		break;

		case vkDownArrow : {
			

			TreeItem* item = getSelectedItem();
			TreeItem* prevItem = item;

			item = getNextItem( prevItem );

			if ( (NULL != prevItem) && (!e->hasShiftKey() || !getAllowsMultipleSelection()) ) {
				setSelectedItem( prevItem, false );
			}
			if ( NULL != item ) {
				scrollToNextItem( item, true );
				setSelectedItem( item, true );				
			}			
		}
		break;

		case vkLeftArrow : {
			TreeItem* item = getSelectedItem();	
			if ( NULL != item ) {
				if ( item->isExpanded() ) {
					item->expand( false );
					recalcScrollable();
				}
				else {
					if ( NULL != item->getParent() ) {
						setSelectedItem( item, false );
						setSelectedItem( item->getParent(), true );
					}
				}
			}
		}
		break;

		case vkRightArrow : {
			TreeItem* item = getSelectedItem();	
			if ( NULL != item ) {
				if ( item->isExpanded() ) {
					Enumerator<TreeItem*>* items = item->getChildren();
					//get first item!
					if ( items->hasMoreElements() ) {
						setSelectedItem( item, false );
						setSelectedItem( items->nextElement(), true );
					}
				}
				else {
					item->expand( true );
					recalcScrollable();
				}
			}
		}
		break;

		case vkUpArrow : {
			TreeItem* item = getSelectedItem();
			
			TreeItem* prevItem = item;

			item = getPrevItem( prevItem );

			if ( (!e->hasShiftKey() || !getAllowsMultipleSelection()) && (NULL != prevItem) ) {
				setSelectedItem( prevItem, false );
			}

			if ( NULL != item ) {
				scrollToNextItem( item, false );
				setSelectedItem( item, true );				
			}
		}
		break;
	}
}

void TreeListControl::mouseDown( MouseEvent* event )
{
	CustomControl::mouseDown( event );

	finishEditing();

	draggingSelectionRect_ = false;
	Point pt = *event->getPoint();
	draggingSelectedItems_.clear();	

	if ( event->hasLeftButton() ) {
		allowMultipleSelection_ = (event->hasControlKey()  || event->hasShiftKey() );
		//setAllowsMultipleSelection(  );

		if ( allowMultipleSelection_ ) {
			multiSelectionChange( event );
		}
		else {
			singleSelectionChange( event );
		}
	}	
}


bool TreeListControl::hitTest( Rect* rect, TreeItem* item, std::vector<TreeItem*>& hitTestList )
{
	bool result = false;
	TreeItem* foundItem = NULL;

	Rect itemBounds = *item->getBounds();

	if ( ! (displayOptions_ & TreeListControl::tdoShowFullRowSelection) ) {
		ColumnItem* column = header_->getColumnModel()->getItemFromIndex(0);

		if (NULL != column)
		{
			itemBounds.right_ = itemBounds.left_ + column->getWidth();

			if ( displayOptions_ & TreeListControl::tdoShowColumnHeader ) {
				//ColumnItem* column = header_->getColumnModel()->getItemFromIndex(0);