uitoolkit.cpp

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

	AcceleratorKey::Value key( event->getKeyMask(), event->getVirtualCode() );

	typedef std::multimap<ulong32,AcceleratorKey*>::iterator AccelMapIter;
	std::pair<AccelMapIter, AccelMapIter> range = acceleratorMap_.equal_range( key );

	//look for accelerator in control then app
	AcceleratorKey* accelerator = NULL;
	Control* control = (Control*)event->getSource();


	AccelMapIter it = range.first;
	if ( control ) {
		if ( control->areParentsEnabled() ) {

			while ( it != range.second ) {

				AcceleratorKey* accel = it->second;
				// check if the control associated to this accelerator is the same having the focus
				if ( accel->getAssociatedControl() == control ) {
					accelerator = accel;
					break;
				}

				it ++;
			}
		}
	}




	//if accelerator is still null try and find the first matching menu item
	if ( NULL == accelerator ) {
		it = range.first;
		while ( it != range.second ) {
			AcceleratorKey* accel = it->second;
			if ( accel->getAssociatedMenuItem() != NULL ) {
				accelerator = accel;
				//check to make sure the menu item's frame is enabled!
				if ( NULL != accel ) {
					MenuItem* mi = accel->getAssociatedMenuItem();
					mi->update();
				}
				break;
			}

			it ++;
		}
	}

	//if accelerator is still null try and find the first matching object
	if ( NULL == accelerator ) {
		it = range.first;
		while ( it != range.second ) {

			AcceleratorKey* accel = it->second;
			if ( accel->getAssociatedObject() != NULL ) {
				accelerator = accel;
				break;
			}

			it ++;
		}
	}


	if ( NULL != accelerator ) {

		EventHandler* ev = NULL;

		if ( accelerator->isMnemonic() ) {
			ev = acceleratorMnemonicHandler_;
		}
		else {
			ev = accelerator->getEventHandler();
		}

		if ( NULL != ev ) {
			if ( accelerator->isEnabled() ) {
				KeyboardEvent* acceleratorEvent = new KeyboardEvent( accelerator, Control::KEYBOARD_ACCELERATOR,
																	event->getRepeatCount(),
																	event->getKeyMask(),
																	event->getKeyValue(),
																	event->getVirtualCode() );

				postEvent( ev, acceleratorEvent, false );
			}

			//KeyboardEvent acceleratorEvent( accelerator, Control::KEYBOARD_ACCELERATOR,
			//														event->getRepeatCount(),
			//														event->getKeyMask(),
			//														event->getKeyValue(),
			//														event->getVirtualCode() );

			//ev->invoke( &acceleratorEvent );


			// as the event has been processed, we don't let it to be forwarded further to any other controls
			event->setConsumed( true );
		}
	}
	else if ( NULL != control ) {

		VirtualKeyCode keyCode = event->getVirtualCode();
		/**
		as per bug [ 585087 ] Get rid of arrow key tabbing
		I am commenting the arrow key tabbing out - will
		work out something better !
		*/
		switch( keyCode ) {

			case vkTab : /*case vkUpArrow : case vkDownArrow : case vkLeftArrow : case vkRightArrow :*/{
				handleTabKeyboardEvent( event );
			}
			break;

			case vkReturn :{

				if ( false == control->keepReturnCharacter() ) {
					//event->setConsumed( true );

					Button* button = getDefaultButton();

					Event* e = (Event*)event->clone();
					e->setUserData( button );

					postEvent( new StaticEventHandlerInstance<Event>(internal_handleKeyboardButtonEvent),
								e );

					/*
					if ( NULL != button ) {
						button->click();
					}
					*/
				}
			}
			break;
		}
	}
}

void UIToolkit::handleTabKeyboardEvent( KeyboardEvent* event )
{
	Control* control = (Control*) event->getSource();

	if ( !control->keepsTabKey() ) {
		bool goForward = !event->hasShiftKey();

		Control* currentFocused = Control::getCurrentFocusedControl();
		if ( NULL == currentFocused ) {
			currentFocused = control;
		}
		Frame* parentFrame = currentFocused->getParentFrame();

		std::vector<Control*> tabList;
		Control::buildTabList( parentFrame, tabList );

		Control* newFocusedControl = NULL;
		std::vector<Control*>::iterator found = std::find( tabList.begin(), tabList.end(), currentFocused );
		long index = -1;
		if ( found != tabList.end() ) {
			index = found - tabList.begin();
		}
		if ( goForward ) {
			index ++;

			if ( index >= tabList.size() ) {
				index = 0;
			}

			if ( index >= 0 ) {
				while ( index < tabList.size() ) {
					Control* c = tabList[index];
					if ( c->canAcceptFocus() ) {
						if ( c->getTabStop() ) {
							break;
						}
					}
					index++;
				}
			}

			if ( index >= tabList.size() ) {
				index = 0;
			}

		}
		else {
			index --;

			if ( index <= 0 ) {
				index = tabList.size()-1;
			}

			if ( index < tabList.size() ) {
				while ( index > -1 ) {
					Control* c = tabList[index];
					if ( c->canAcceptFocus() ) {
						if ( c->getTabStop() ) {
							break;
						}
					}
					index--;
				}
			}

			if ( index <= 0 ) {
				index = tabList.size()-1;
			}
		}


		newFocusedControl = tabList[index];
		newFocusedControl->setFocused();

		event->consume();
	}
}

const Image* UIToolkit::internal_getStandardStopImage()
{
	return stopImage_;
}

const Image* UIToolkit::internal_getStandardWarningImage()
{
	return warningImage_;
}

const Image* UIToolkit::internal_getStandardQuestionImage()
{
	return questionImage_;
}

const Image* UIToolkit::internal_getStandardInformationImage()
{
	return informationImage_;
}

void UIToolkit::onAcceleratorMnemonic( KeyboardEvent* event )
{
	 AcceleratorKey* accelerator = (AcceleratorKey*)event->getSource();
	 if ( NULL != accelerator ) {
		Control* control = accelerator->getAssociatedControl();
		if ( NULL != control ) {
			control->mnemonicActivate();
		}
	}
}

VirtualKeyCode UIToolkit::internal_findMnemonic( const String& caption )
{
	VirtualKeyCode result = vkUndefined;

#if (! defined _MSC_VER) || ( (_MSC_VER < 1300) || defined ( STLPORT ) )
	const VCFChar* P = caption.c_str();
#else
	const VCFChar* P = caption.c_str();
#endif
	const VCFChar* start = P;
	int size = caption.size();

	while ( (P - start) < size ) {
		if ( (*P == '&') && (((P - start)+1) < size) ) {
			VCFChar nextChar = *(P+1);
			//this is not locale or Unicode safe !
			if ( ((nextChar >= 'A') && (nextChar <= 'Z')) || ((nextChar >= 'a') && (nextChar <= 'z')) ) {
				if ( (nextChar >= 'A') && (nextChar <= 'Z') ) {
					result = (VirtualKeyCode)(vkLetterA + (nextChar - 'A'));
				}
				else {
					result = (VirtualKeyCode)(vkLetterA + (nextChar - 'a'));
				}
				break;
			}
			else if ( (nextChar >= '0') && (nextChar <= '9') ) {
				result = (VirtualKeyCode)(vkNumber0 + (nextChar - '0'));

				break;
			}
		}
		P++;
	}

	return result;
}

VCF::Button* UIToolkit::internal_getDefaultButton()
{
	Button* result = NULL;
	if ( ! defaultButtonList_.empty() ) {
		result = *defaultButtonList_.begin();
	}
	return result;
}

void UIToolkit::internal_setDefaultButton( Button* defaultButton )
{
	if ( true == defaultButtonList_.empty() ) {
		defaultButtonList_.push_back( defaultButton );
	}
	else {
		defaultButtonList_.insert( defaultButtonList_.begin(), defaultButton );
	}
}

void UIToolkit::onDefaultButton( KeyboardEvent* event )
{
	//Control* control = (Control*)event->getSource();
	/*
	Control* buttonControl = dynamic_cast<Control*>(control);
	if ( (buttonControl == Control::getCurrentFocusedControl()) && (NULL != temporaryDefaultButton_) ) {
		temporaryDefaultButton_->click();
	}
	else if ( NULL != defaultButton_ ) {
		defaultButton_->click();
	}

  */

}

void UIToolkit::internal_removeDefaultButton( Button* defaultButton )
{
	std::vector<Button*>::iterator found = std::find( defaultButtonList_.begin(), defaultButtonList_.end(), defaultButton );
	if ( found != defaultButtonList_.end() ) {
		defaultButtonList_.erase( found );
	}
}

void UIToolkit::internal_removeAccelerator( const VirtualKeyCode& keyCode, const ulong32& modifierMask, Object* src )
{

	AcceleratorKey::Value key( modifierMask, keyCode );

	typedef std::multimap<ulong32,AcceleratorKey*>::iterator AccelMapIter;

	std::pair<AccelMapIter, AccelMapIter> range = acceleratorMap_.equal_range( key );	

	std::vector<AccelMapIter> removeAccels;

	AccelMapIter it = range.first;
	while ( it != range.second ) {
		AcceleratorKey* accel = it->second;
		if ( (accel->getAssociatedControl() == src) || 
			(accel->getAssociatedMenuItem() == src) ||
			(accel->getAssociatedObject() == src) ) {
			accel->release();
			removeAccels.push_back( it );
		}

		it ++;
	}

	std::vector<AccelMapIter>::iterator it2 = removeAccels.begin();
	while ( it2 != removeAccels.end() ) {
		acceleratorMap_.erase( *it2 );
		it2 ++;
	}
}

void UIToolkit::internal_removeAcceleratorKeysForControl( Control* control )
{
	typedef std::multimap<ulong32,AcceleratorKey*>::iterator accel_iter;

	std::vector<accel_iter> removeAccels;

	accel_iter it = acceleratorMap_.begin();

	while ( it != acceleratorMap_.end() ) {
		AcceleratorKey* accel = it->second;
		if ( accel->getAssociatedControl() == control ) {
			accel->release();
			removeAccels.push_back( it );
		}
		it ++;
	}

	std::vector<accel_iter>::iterator it2 = removeAccels.begin();
	while ( it2 != removeAccels.end() ) {
		acceleratorMap_.erase( *it2 );
		it2 ++;
	}

}

void UIToolkit::internal_removeAcceleratorKeysForMenuItem( MenuItem* menuItem )
{
	typedef std::multimap<ulong32,AcceleratorKey*>::iterator accel_iter;

	std::vector<accel_iter> removeAccels;

	accel_iter it = acceleratorMap_.begin();

	while ( it != acceleratorMap_.end() ) {
		AcceleratorKey* accel = it->second;
		if ( accel->getAssociatedMenuItem() == menuItem ) {
			accel->release();
			removeAccels.push_back( it );
		}
		it ++;
	}

	std::vector<accel_iter>::iterator it2 = removeAccels.begin();
	while ( it2 != removeAccels.end() ) {
		acceleratorMap_.erase( *it2 );
		it2 ++;
	}
}

void UIToolkit::internal_removeAcceleratorKeysForObject( Object* src )
{
	typedef std::multimap<ulong32,AcceleratorKey*>::iterator accel_iter;

	std::vector<accel_iter> removeAccels;

	accel_iter it = acceleratorMap_.begin();

	while ( it != acceleratorMap_.end() ) {
		AcceleratorKey* accel = it->second;
		if ( accel->getAssociatedObject() == src ) {
			accel->release();
			removeAccels.push_back( it );
		}
		it ++;
	}

	std::vector<accel_iter>::iterator it2 = removeAccels.begin();
	while ( it2 != removeAccels.end() ) {
		acceleratorMap_.erase( *it2 );
		it2 ++;
	}
}


void UIToolkit::addToUpdateList( Component* component )
{
	UIToolkit::toolKitInstance->internal_addToUpdateList( component );
}

void UIToolkit::removeFromUpdateList( Component* component )
{
	UIToolkit::toolKitInstance->internal_removeFromUpdateList( component );
}

void UIToolkit::setUpdateTimerSpeed( const unsigned long& milliseconds )
{
	UIToolkit::toolKitInstance->internal_setUpdateTimerSpeed( milliseconds );
}

void UIToolkit::internal_addToUpdateList( Component* component )
{