uitoolkit.cpp

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

const Image* UIToolkit::getStandardStopImage()
{
	return UIToolkit::toolKitInstance->internal_getStandardStopImage();
}

const Image* UIToolkit::getStandardWarningImage()
{
	return UIToolkit::toolKitInstance->internal_getStandardWarningImage();
}

const Image* UIToolkit::getStandardQuestionImage()
{
	return UIToolkit::toolKitInstance->internal_getStandardQuestionImage();
}

const Image* UIToolkit::getStandardInformationImage()
{
	return UIToolkit::toolKitInstance->internal_getStandardInformationImage();
}

void UIToolkit::registerComponentInfo( const String& componentUUID, ComponentInfo* info )
{
	UIToolkit::toolKitInstance->internal_registerComponentInfo( componentUUID, info );
}

void UIToolkit::removeComponentInfo( ComponentInfo* info )
{
	UIToolkit::toolKitInstance->internal_removeComponentInfo( info );
}

void UIToolkit::registerAccelerator( AcceleratorKey* accelerator )
{
	UIToolkit::toolKitInstance->internal_registerAccelerator( accelerator );
}

void UIToolkit::removeAccelerator( const VirtualKeyCode& keyCode, const ulong32& modifierMask, Object* src )
{
	UIToolkit::toolKitInstance->internal_removeAccelerator( keyCode, modifierMask, src );
}

VCF::Button* UIToolkit::getDefaultButton()
{
	return UIToolkit::toolKitInstance->internal_getDefaultButton();
}

void UIToolkit::setDefaultButton( Button* defaultButton )
{
	UIToolkit::toolKitInstance->internal_setDefaultButton( defaultButton );
}

void UIToolkit::removeDefaultButton( Button* defaultButton )
{
	UIToolkit::toolKitInstance->internal_removeDefaultButton( defaultButton );
}

AcceleratorKey* UIToolkit::getAccelerator( const VirtualKeyCode& keyCode, const ulong32& modifierMask, Object* src )
{
	return UIToolkit::toolKitInstance->internal_getAccelerator( keyCode, modifierMask, src );
}

bool UIToolkit::findMatchingAccelerators( AcceleratorKey* key, std::vector<AcceleratorKey*>& matchingAccelerators )
{
	return UIToolkit::toolKitInstance->internal_findMatchingAccelerators( key, matchingAccelerators );
}

void UIToolkit::removeAcceleratorKeysForControl( Control* control )
{
	UIToolkit::toolKitInstance->internal_removeAcceleratorKeysForControl( control );
}

void UIToolkit::removeAcceleratorKeysForMenuItem( MenuItem* item )
{
	UIToolkit::toolKitInstance->internal_removeAcceleratorKeysForMenuItem( item );
}

void UIToolkit::removeAcceleratorKeysForObject( Object* src )
{
	UIToolkit::toolKitInstance->internal_removeAcceleratorKeysForObject( src );
}


void UIToolkit::handleKeyboardEvent( KeyboardEvent* event )
{
	UIToolkit::toolKitInstance->internal_handleKeyboardEvent( event );
}

VirtualKeyCode UIToolkit::findMnemonic( const String& caption )
{
	return UIToolkit::toolKitInstance->internal_findMnemonic( caption );
}

ComponentInfo* UIToolkit::getComponentInfo( const String& componentUUID )
{
	return UIToolkit::toolKitInstance->internal_getComponentInfo( componentUUID );
}

ComponentInfo* UIToolkit::getComponentInfo( Class* componentClass )
{
	return UIToolkit::toolKitInstance->internal_getComponentInfo( componentClass );
}

UIMetricsManager* UIToolkit::getUIMetricsManager()
{
	return UIToolkit::toolKitInstance->internal_getUIMetricsManager();
}

double UIToolkit::getUIMetricValue( const UIMetricsManager::MetricType& type, const String& text )
{
	return UIToolkit::toolKitInstance->internal_getUIMetricsManager()->getValue( type, text );
}

VCF::Size UIToolkit::getUIMetricSize( const UIMetricsManager::MetricType& type, const String& text )
{
	return UIToolkit::toolKitInstance->internal_getUIMetricsManager()->getSize( type, text );
}

VCF::Rect UIToolkit::getUIMetricRect( const UIMetricsManager::MetricType& type, VCF::Rect* rect )
{
	return UIToolkit::toolKitInstance->internal_getUIMetricsManager()->getRect( type, rect );
}

UIPolicyManager* UIToolkit::getUIPolicyManager()
{
	return UIToolkit::toolKitInstance->internal_getUIPolicyManager();
}

void UIToolkit::systemSettingsChanged()
{
	GraphicsToolkit::systemSettingsChanged();

	UIToolkit::toolKitInstance->internal_systemSettingsChanged();
}


void getHelpInfo( String& helpBookName, String& helpDirectory )
{
	Application* app = Application::getRunningInstance();

	if ( NULL != app ) {		
		app->getHelpInfo( helpBookName, helpDirectory );		
	}	

	if ( helpBookName.empty() || helpDirectory.empty() ) {
		ProgramInfo* info = System::getResourceBundle()->getProgramInfo();
		if ( NULL != info ) {
			if ( helpDirectory.empty() ) {
				helpDirectory = info->getHelpDirectory();
			}
			if ( helpBookName.empty() ) {
				helpBookName = info->getHelpName();
			}
			delete info;
		}
	}

	if ( helpBookName.empty() || helpDirectory.empty() ) {
		//damn, we're STILL not finished - now try 
		//and assume the stuff is in the res directory
		//and the help name is the app name

		if ( helpBookName.empty() ) {
			if ( NULL != app ) {
				helpBookName = app->getName();
			}
			else {
				FilePath fp = FoundationKit::getCommandLine().getArgument(0);
				helpBookName = fp.getBaseName();
			}
		}

		if ( helpDirectory.empty() ) {
			helpDirectory = "Help";
		}
	}	
}

void UIToolkit::displayHelpContents()
{
	Application* app = Application::getRunningInstance();
	bool helpDisplayed = false;
	if ( NULL != app ) {
		helpDisplayed = app->displayHelpContents();
	}

	if ( !helpDisplayed ) {
		String helpBookName;
		String helpDirectory;
		getHelpInfo( helpBookName, helpDirectory );
		UIToolkit::toolKitInstance->internal_displayHelpContents(helpBookName,helpDirectory);
	}	
}

void UIToolkit::displayHelpIndex()
{
	Application* app = Application::getRunningInstance();
	bool helpDisplayed = false;
	
	if ( NULL != app ) {
		helpDisplayed = app->displayHelpIndex();
	}

	if ( !helpDisplayed ) {
		String helpBookName;
		String helpDirectory;
		getHelpInfo( helpBookName, helpDirectory );
		UIToolkit::toolKitInstance->internal_displayHelpIndex(helpBookName, helpDirectory);
	}
}

void UIToolkit::displayHelpSection( const String& helpSection, const String& helpBookName, const String& helpDirectory )
{	
	String helpBookNameTmp;
	String helpDirectoryTmp;
	getHelpInfo( helpBookNameTmp, helpDirectoryTmp );
	if ( !helpBookName.empty() ) {
		helpBookNameTmp = helpBookName;
	}

	if ( !helpDirectory.empty() ) {
		helpDirectoryTmp = helpDirectory;
	}

	UIToolkit::toolKitInstance->internal_displayHelpSection(helpBookNameTmp, helpDirectoryTmp,helpSection);
}

void UIToolkit::displayContextHelpForControl( Control* control )
{
	String helpBookName;
	String helpDirectory;
	getHelpInfo( helpBookName, helpDirectory );

	String whatsThis = control->getWhatsThisHelpString();


	if ( !UIToolkit::toolKitInstance->internal_displayContextHelpForControl( control, helpBookName, helpDirectory ) ) {
		//oops - this control didn't have any immediate what's up help. Lets start walking the parent chain
		//and notifying delegates that a context help event is happening and see if we can get
		//some help there

		HelpEvent event(control);
		
		control->HelpRequested.fireEvent( &event );

		String helpSection = event.helpSection;
		String helpBook = event.helpBook;
		String helpDir = event.helpDirectory;
		if ( helpSection.empty() ) {
			//start searching the up the parent chain...
			Control* parent = control->getParent();
			while ( NULL != parent ) {
				HelpEvent event2(parent);
				parent->HelpRequested.fireEvent( &event2 );
				
				helpSection = event.helpSection;
				helpBook = event.helpBook;
				helpDir = event.helpDirectory;

				if ( !helpSection.empty() ) {
					break;
				}

				parent = parent->getParent();
			}
		}

		if ( !helpSection.empty() ) {
			UIToolkit::displayHelpSection( helpSection, helpBook, helpDir );
		}
	}
}








Clipboard* UIToolkit::internal_getSystemClipboard()
{
	return systemClipboard_;
}



ContextPeer* UIToolkit::internal_createContextPeer( OSHandleID contextID )
{
	if ( NULL == graphicsToolKit_ ){
		//throw exception
	}
	return graphicsToolKit_->createContextPeer( contextID );
}

ContextPeer* UIToolkit::internal_createContextPeer( Control* component )
{
	if ( NULL == graphicsToolKit_ ){
		//throw exception
	}
	return NULL;//graphicsToolKit_->createContextPeer( component );
}

ContextPeer* UIToolkit::internal_createContextPeer( const unsigned long& width, const unsigned long& height )
{
	if ( NULL == graphicsToolKit_ ){
		//throw exception
	}
	return graphicsToolKit_->createContextPeer( width, height );
}


void UIToolkit::internal_registerComponentInfo( const String& componentUUID, ComponentInfo* info )
{
	if ( componentUUID != info->getComponentUUID() ) {
		throw RuntimeException( "Attempting to register a component's info with a mismatched UUID." );
	}
	componentInfoMap_[ componentUUID ] = info;
}

ComponentInfo* UIToolkit::internal_getComponentInfo( const String& componentUUID )
{
	ComponentInfo* result = NULL;
	std::map< String,ComponentInfo*>::iterator found = componentInfoMap_.find( componentUUID );
	if ( found != componentInfoMap_.end() ) {
		result = found->second;
	}
	return result;
}

ComponentInfo* UIToolkit::internal_getComponentInfo( Class* componentClass )
{
	if ( NULL == componentClass ) {
		throw RuntimeException( "Can't get Component information from a NULL Class." );
	}
	return getComponentInfo( componentClass->getID() );
}

void UIToolkit::internal_removeComponentInfo( ComponentInfo* info )
{
	std::map< String,ComponentInfo*>::iterator found = componentInfoMap_.find( info->getComponentUUID() );
	if ( found != componentInfoMap_.end() ) {
		componentInfoMap_.erase( found );
	}
}

void UIToolkit::internal_registerAccelerator( AcceleratorKey* accelerator )
{
	AcceleratorKey::Value key;
	key = accelerator;	


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

	std::multimap<ulong32,AcceleratorKey*>::iterator it = range.first;
	while ( it != range.second ) {
		AcceleratorKey* accel = it->second;

		if ( (accelerator->getAssociatedControl() == accel->getAssociatedControl()) && 
				(accelerator->getAssociatedMenuItem() == accel->getAssociatedMenuItem()) && 
				(accelerator->getAssociatedObject() == accel->getAssociatedObject()) ) {

			accel->free();
			//remove old entry!
			acceleratorMap_.erase( it );
			break;
		}

		it ++;
	}

	std::pair<ulong32,AcceleratorKey*> item(key,accelerator);
	acceleratorMap_.insert( item );
}

bool UIToolkit::internal_findMatchingAccelerators( AcceleratorKey* key, std::vector<AcceleratorKey*>& matchingAccelerators )
{
	matchingAccelerators.clear();

	AcceleratorKey::Value keyVal;
	keyVal = key;

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

	std::multimap<ulong32,AcceleratorKey*>::iterator it = range.first;
	while ( it != range.second ) {
		AcceleratorKey* accel = it->second;

		// we don't need to put in the list the accelerator (key) to which all the others are matching.
		if ( (accel->getEventHandler() == key->getEventHandler()) && 
				(accel != key) ) {
			matchingAccelerators.push_back( accel );
		}

		it ++;
	}

	return !matchingAccelerators.empty();
}

AcceleratorKey* UIToolkit::internal_getAccelerator( const VirtualKeyCode& keyCode, const ulong32& modifierMask, Object* src )
{
	AcceleratorKey* result = NULL;

	AcceleratorKey::Value key( modifierMask, keyCode );


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

	std::multimap<ulong32,AcceleratorKey*>::iterator it = range.first;
	while ( it != range.second ) {
		AcceleratorKey* accel = it->second;

		if ( (src == accel->getAssociatedControl()) || 
				(src == accel->getAssociatedMenuItem()) || 
				(src == accel->getAssociatedObject()) ) {

			result = accel;
			break;
		}

		it ++;
	}

	return result;
}

void internal_handleKeyboardButtonEvent ( Event* e )
{
	VCF::Button* button = (VCF::Button*)e->getUserData();

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

void UIToolkit::internal_handleKeyboardEvent( KeyboardEvent* event )
{
	if ( vkEscape == event->getVirtualCode() ) {
		Frame* frame = Frame::getActiveFrame();
		if ( NULL != frame ) {
			Event* e = (Event*)event->clone();
			e->setType( Control::KEYBOARD_DOWN );
			frame->handleEvent( e );
			if ( e->isConsumed() ) {
				e->free();
				return;
			}
			e->free();
		}
	}