control.cpp

这是VCF框架的代码

	else {
		controlState_  &= ~Control::csEnabled;
	}

	if ( ! isDesigning() ) {
		peer_->setEnabled( enabled );
	}

	repaint();
}

void Control::mouseEnter( MouseEvent* event )
{

}

void Control::mouseDown( MouseEvent* event )
{
	setFocused();
}

void Control::mouseMove( MouseEvent* event )
{
	//probably want to put a modifier here for the scrollable to modify the coords ?

}

void Control::mouseUp( MouseEvent* event )
{

}

void Control::mouseLeave( MouseEvent* event )
{

}

void Control::keyDown( KeyboardEvent* event )
{

}

void Control::mouseClick(  MouseEvent* event )
{

}

void Control::mouseDblClick(  MouseEvent* event )
{

}

void Control::keyPressed( KeyboardEvent* event )
{

}

void Control::keyUp( KeyboardEvent* event )
{

}

void Control::sizeChange( ControlEvent* event )
{

}

void Control::positionChange( ControlEvent* event )
{

}

void Control::parentChange( ControlEvent* event )
{

}

void Control::gotFocus( FocusEvent* event )
{

}

void Control::lostFocus( FocusEvent* event )
{

}

void Control::translateToParent( Point* point )
{
	Control* parent = getParent();
	if ( NULL != parent ){
		Rect bounds = parent->getBounds();
		point->x_ += bounds.left_;
		point->y_ += bounds.top_;
	}
	else{
		//throw exception ?
	}
}

void Control::translateToLocal( Point* point )
{
	Control* parent = getParent();
	if ( NULL != parent ){
		Rect bounds = getBounds();
		point->x_ -= bounds.left_;
		point->y_ -= bounds.top_;
	}
	else{
		//throw exception ?
	}
}

void Control::beforeDestroy( ComponentEvent* event )
{
	Component::beforeDestroy( event );
}

bool Control::isLightWeight()
{
	return false;
}

Control* Control::getHeavyweightParent()
{
	Control* parent = NULL;
	Control* result = NULL;
	result = getParent();
	if ( result != NULL ) {
		while ( true == result->isLightWeight() ){
			parent = result;
			result = parent->getParent();
		}
	}

	return result;
}

Color* Control::getColor()
{
	return color_;
}

void Control::setColor( Color* color )
{
	color_->copy( color );
	if ( (isNormal() || isDesigning()) && (NULL != peer_) ) {
		repaint();
	}
}


Font* Control::getFont()
{
	return font_;
}

void Control::setFont( Font* font )
{
	if ( NULL != font ){
		font_->copy( font );
	}
	
	peer_->setFont( font_ );

}

bool Control::useParentFont()
{
	return (controlState_ & Control::csUseParentFont) ? true : false;
}

void Control::setUseParentFont( const bool& useParentFont )
{
	if ( useParentFont ) {
		controlState_  |= Control::csUseParentFont;
	}
	else {
		controlState_  &= ~Control::csUseParentFont;
	}
}

void Control::afterCreate( ComponentEvent* event )
{	
	
}

void Control::repaint( Rect* repaintRect )
{	
	peer_->repaint( repaintRect, false );
	if ( isUsingRenderBuffer() ) {
		context_->markRenderAreaDirty();
	}
}

void Control::repaintNow( Rect* repaintRect )
{
	peer_->repaint( repaintRect, true );
	if ( isUsingRenderBuffer() ) {
		context_->markRenderAreaDirty();
	}
}

bool Control::isDoubleBuffered()
{
	return (controlState_ & Control::csDoubleBuffered) ? true : false;
}

void Control::setDoubleBuffered( const bool& doubleBuffered )
{
	if ( doubleBuffered ) {
		controlState_  |= Control::csDoubleBuffered;
	}
	else {
		controlState_  &= ~Control::csDoubleBuffered;
	}
}

void Control::keepMouseEvents()
{
	controlState_  |= Control::csHasMouseCapture;
	Control::setCapturedMouseControl( this );
	peer_->keepMouseEvents();
}

void Control::releaseMouseEvents()
{
	controlState_  &= ~Control::csHasMouseCapture;
	Control::setCapturedMouseControl( NULL );
	peer_->releaseMouseEvents();
}

Control* Control::getCapturedMouseControl()
{
	return Control::capturedMouseControl;
}

void Control::setCapturedMouseControl( Control* control )
{
	Control::capturedMouseControl = control;
}

GraphicsContext* Control::getContext()
{
	return context_;
}

PopupMenu* Control::getPopupMenu()
{
	return popupMenu_;
}

void Control::setPopupMenu( PopupMenu* popupMenu )
{
	if ( NULL != popupMenu_ ){
		popupMenu_->setControl( NULL );
	}

	popupMenu_ = popupMenu;

	if ( NULL != popupMenu_ ){
		popupMenu_->setControl( this );
	}
}

View* Control::getView()
{
	return view_;
}

void Control::setView( View* view )
{
	if ( NULL != view_ ) {
		Object* obj = dynamic_cast<Object*>( view_ );
		if ( NULL != obj ) {
			obj->release();
		}
	}

	view_ = view;

	if ( NULL != view_ ) {
		view_->setViewControl( this );
		Object* obj = dynamic_cast<Object*>( view_ );
		if ( NULL != obj ) {
			obj->addRef();
		}
	}
}

void Control::setScrollable( Scrollable* scrollable )
{
	scrollable_ = scrollable;
	if ( NULL != scrollable_ ) {
		scrollable_->setScrollableControl( this );
		scrollable_->recalcScrollPositions();
	}
}

void Control::setToolTipText( const String& tooltip )
{
	toolTip_ = tooltip;
}

void Control::setCursorID( const long& cursorID )
{
	cursorID_ = cursorID;
	cursor_ = CursorManager::getCursorManager()->getCursor( cursorID_ );
}

void Control::setAnchor( const unsigned long& anchor )
{
	anchor_ = anchor;
	aligment_ = AlignNone;
	updateAnchorDeltas();

	Control* parent = getParent();
	if ( NULL != parent ){
		Container* container = parent->getContainer();
		if ( NULL != container ){
			container->resizeChildren(NULL);//this);
		}
	}
}

void Control::updateAnchorDeltas() {
	if ( AnchorNone == anchor_ ) {
		anchorDeltas_[ANCHOR_DTOP] = 0.0f;
		anchorDeltas_[ANCHOR_DLEFT] = 0.0f;
		anchorDeltas_[ANCHOR_DBOTTOM] = 0.0f;
		anchorDeltas_[ANCHOR_DRIGHT] = 0.0f;
	}
	else {
		Control* parent = getParent();
		if ( NULL != parent ) {
			Rect parentBounds = parent->getClientBounds();
			Rect bounds = getBounds();
			anchorDeltas_[ANCHOR_DTOP] = (float) bounds.top_;
			anchorDeltas_[ANCHOR_DLEFT] = (float) bounds.left_;
			anchorDeltas_[ANCHOR_DBOTTOM] = (float) parentBounds.bottom_ -  bounds.bottom_;
			anchorDeltas_[ANCHOR_DRIGHT] = (float) parentBounds.right_ -  bounds.right_;
		}
	}
}

AcceleratorKey* Control::getAccelerator( const VirtualKeyCode& keyCode, const ulong32& modifierMask )
{
	return UIToolkit::getAccelerator( keyCode, modifierMask, this );
}

void Control::addAcceleratorKey( const VirtualKeyCode& keyCode, const ulong32& modifierMask, EventHandler* eventHandler )
{
	if ( NULL == eventHandler ) {
		throw InvalidPointerException( MAKE_ERROR_MSG_2("The Event handler passed in for the accelerator is NULL!") );
	}

	AcceleratorKey* newAccelKey = new AcceleratorKey( this, keyCode, modifierMask, eventHandler );

	addAcceleratorKey( newAccelKey );
}

void Control::addAcceleratorKey( const VirtualKeyCode& keyCode, const ulong32& modifierMask, Action* action )
{
	if ( NULL == action ) {
		throw InvalidPointerException( MAKE_ERROR_MSG_2("The action instance passed in for the accelerator is NULL!") );
	}

	addAcceleratorKey( keyCode, modifierMask, action->getAcceleratorEventHandler() );
}

void Control::addAcceleratorKey( AcceleratorKey* accelerator )
{
	UIToolkit::registerAccelerator( accelerator );
}

void Control::setTabStop( const bool& tabStop )
{
	if ( tabStop ) {
		controlState_  |= Control::csTabStop;
	}
	else {
		controlState_  &= ~Control::csTabStop;
	}
}

void Control::setTabOrder( const long& tabOrder )
{
	if ( tabOrder_ == tabOrder ) {
		return ;
	}

	Control* parent = getParent();
	if ( NULL != parent ) {
		Container* container = parent->getContainer();
		if ( NULL != container ) {
			ulong32 tmp = tabOrder;
			container->updateTabOrder( this, tmp );

			tabOrder_ = tmp;
		}
	}
}


Control* Control::getCurrentFocusedControl()
{
	return Control::currentFocusedControl;
}

void Control::mnemonicActivate()
{
	setFocused();
}

Control* Control::getPreviousMouseOverControl()
{
	return Control::previousMouseOverControl;
}

void Control::setPreviousMouseOverControl( Control* control )
{
	Control::previousMouseOverControl = control;
}


void Control::translateToScreenCoords( Point* pt )
{
	peer_->translateToScreenCoords( pt );
}

void Control::translateToScreenCoords( Rect* rect )
{
	Point pt ( rect->left_, rect->top_ );

	peer_->translateToScreenCoords( &pt );
	rect->left_ = pt.x_;
	rect->top_ = pt.y_;

	pt.x_ = rect->right_;
	pt.y_ = rect->bottom_;

	peer_->translateToScreenCoords( &pt );

	rect->right_ = pt.x_;
	rect->bottom_ = pt.y_;
}

void Control::translateFromScreenCoords( Point* pt )
{
	peer_->translateFromScreenCoords( pt );
}

void Control::translateFromScreenCoords( Rect* rect )
{
	Point pt ( rect->left_, rect->top_ );

	peer_->translateFromScreenCoords( &pt );
	rect->left_ = pt.x_;
	rect->top_ = pt.y_;