gtkuitoolkit.cpp

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

}

void GTKUIToolkit::internal_unregisterTimerHandler( EventHandler* handler )
{
	std::map<EventHandler*, TimeOutHandler>::iterator found = timeoutHandlers_.find( handler );
	if ( found != timeoutHandlers_.end() ) {
		TimeOutHandler & tmHandler = found->second;
		gtk_timeout_remove ( tmHandler.timerID_ );

		timeoutHandlers_.erase( found );
	}
}

gboolean GTKUIToolkit::gtkTimeOutHandler( gpointer data )
{
	EventHandler * handler = ( EventHandler* ) data;

	GTKUIToolkit* toolkit = ( GTKUIToolkit* ) UIToolkit::internal_getDefaultUIToolkit();

	std::map<EventHandler*, TimeOutHandler>::iterator found = toolkit->timeoutHandlers_.find( handler );
	if ( found != toolkit->timeoutHandlers_.end() ) {
		TimeOutHandler & tmHandler = found->second;


		TimerEvent event( tmHandler.source_, TIMER_EVENT_PULSE );
		tmHandler.handler_->invoke( &event );
	}

	return TRUE;
}

void GTKUIToolkit::internal_gdkEventHandler( GdkEvent *gdkEvent, gpointer data )
{
	Application * runningApp = Application::getRunningInstance();
	GTKUIToolkit* toolkit = ( GTKUIToolkit* ) data;


	if ( toolkit->handleGdkEvent( gdkEvent ) ) {
		gtk_main_do_event( gdkEvent );
	}
}

gboolean GTKUIToolkit::internal_gdkIdleHandler( gpointer data )
{
	/*
	This fucntion is currently causing hte app to run with 100% CPU utilization
	need to fix this...
	*/
	Application * runningApp = Application::getRunningInstance();
	GTKUIToolkit* toolkit = ( GTKUIToolkit* ) data;

	if ( NULL != runningApp ) {
		runningApp->idleTime();
	}

	//check library apps;
	Enumerator<LibraryApplication*>* registeredLibs = LibraryApplication::getRegisteredLibraries();
	while ( true == registeredLibs->hasMoreElements() ) {

		LibraryApplication * libraryApp = registeredLibs->nextElement();
		libraryApp->idleTime();
	}

	return TRUE;
}


bool GTKUIToolkit::handleGdkEvent( GdkEvent* gdkEvent )
{
	bool result = true;
	AbstractGTKControl* gtkControl = NULL;
	if ( NULL != gdkEvent ) {

		switch ( gdkEvent->type ) {
			case GDK_CLIENT_EVENT : {

					GdkEventClient * clientEvent = ( GdkEventClient* ) gdkEvent;
					if ( gdk_atom_intern( VCF_GTK_POST_EVENT, FALSE ) == clientEvent->message_type ) {

						result = false;

						EventHandler* eventHandler = ( EventHandler* ) ( unsigned long ) clientEvent->data.l[ 0 ];
						Event* event = ( Event* ) ( unsigned long ) clientEvent->data.l[ 1 ];
						bool deleteHandler = ( clientEvent->data.l[ 2 ] == TRUE ) ? true : false;

						if ( NULL != eventHandler ) {
							eventHandler->invoke( event );
						}

						delete event;
						if ( deleteHandler ) {
							delete eventHandler;
						}
					}
				}
				break;

			case GDK_KEY_PRESS :
			case GDK_KEY_RELEASE : {
					GtkWidget* gtkWidget = gtk_get_event_widget( gdkEvent );
					gtkControl = AbstractGTKControl::getGTKControlFromWidget( gtkWidget );

					GdkEventKey* gdkKeyEvent = ( GdkEventKey* ) gdkEvent;

					StringUtils::trace( "GTKUIToolkit::handleGdkEvent() GDK_KEY_PRESS/GDK_KEY_RELEASE\n" );
					KeyboardMasks modifierKey = ( KeyboardMasks ) translateKeyMask( ( GdkModifierType ) gdkKeyEvent->state );
					VirtualKeyCode vkCode = translateKeyCode( gdkKeyEvent->keyval );

					if ( NULL != gtkControl ) {
						Control * control = gtkControl->getControl();
						Control* currentFocusedControl = Control::getCurrentFocusedControl();
						if ( NULL != currentFocusedControl ) {
							if ( ( control != currentFocusedControl ) && ( currentFocusedControl->isLightWeight() ) ) {
								control = currentFocusedControl;
							}
						}
						VCFChar keyChar = '0';
						if ( gdkKeyEvent->length > 0 ) {
							keyChar = gdkKeyEvent->string[ 0 ];
						}
						KeyboardEvent event( control, Control::KEYBOARD_ACCELERATOR, 1,
						                     modifierKey, keyChar, vkCode );

						StringUtils::traceWithArgs( "control: %p, keyChar: %c\n", control, keyChar );
						handleKeyboardEvent( &event );
						if ( event.isConsumed() ) {
							result = false;
						}
					}
				}
				break;
		}
	}
	/*
		if ( (result) && (NULL != gtkControl) ) {
			gtkControl->handleEvent( gdkEvent );
		}
	*/ 
	return result;
}

void GTKUIToolkit::internal_runEventLoop()
{
	StringUtils::trace( "starting GTKUIToolkit runEventLoop()...\n" );
	gtk_main ();
}


UIToolkit::ModalReturnType GTKUIToolkit::internal_runModalEventLoopFor( Control* control )
{
	UIToolkit::ModalReturnType result = UIToolkit::mrFalse;
	printf( "starting GTKUIToolkit runModalEventLoopFor( %p )...\n", control );

	gtk_main ();

	return result;
}

void GTKUIToolkit::internal_quitCurrentEventLoop()
{
	gtk_main_quit ();
}

/**
*@param void* in this implementation, the eventData represents a
*pointer to an GTK XEvent structure.
*/
VCF::Event* GTKUIToolkit::internal_createEventFromNativeOSEventData( void* eventData )
{
	GTKEventMsg * eventMsg = ( GTKEventMsg* ) eventData;

	Event* event = NULL;

	switch ( eventMsg->gdkEvent_->type ) {
		case GDK_DELETE : {}
			break;

		case GDK_DESTROY : {
				event = new VCF::ComponentEvent( eventMsg->control_, Component::COMPONENT_DELETED );
			}
			break;

		case GDK_MOTION_NOTIFY	: {
				GdkEventMotion* gdkMotionEvent = ( GdkEventMotion* ) eventMsg->gdkEvent_;
				KeyboardMasks modifierKey = ( KeyboardMasks ) translateKeyMask( ( GdkModifierType ) gdkMotionEvent->state );
				translateButtonMask( ( GdkModifierType ) gdkMotionEvent->state );

				VCF::Point pt( gdkMotionEvent->x, gdkMotionEvent->y );
				event = new VCF::MouseEvent ( eventMsg->control_, Control::MOUSE_MOVE,
				                              translateButtonMask( ( GdkModifierType ) gdkMotionEvent->state ),
				                              translateKeyMask( ( GdkModifierType ) gdkMotionEvent->state ), &pt );

			}
			break;

		case GDK_BUTTON_PRESS :
		case GDK_2BUTTON_PRESS :
		case GDK_3BUTTON_PRESS : {
				StringUtils::traceWithArgs( "GDK_BUTTON_PRESS, %p\n", eventMsg->control_ );
				GdkEventButton* gdkBtnEvent = ( GdkEventButton* ) eventMsg->gdkEvent_;

				VCF::Point pt( gdkBtnEvent->x, gdkBtnEvent->y );
				event = new VCF::MouseEvent ( eventMsg->control_, Control::MOUSE_DOWN,
				                              translateButtonMask( ( GdkModifierType ) gdkBtnEvent->state ),
				                              translateKeyMask( ( GdkModifierType ) gdkBtnEvent->state ), &pt );
			}
			break;

		case GDK_BUTTON_RELEASE : {
				GdkEventButton* gdkBtnEvent = ( GdkEventButton* ) eventMsg->gdkEvent_;

				VCF::Point pt( gdkBtnEvent->x, gdkBtnEvent->y );

				ulong32 buttonMask = 0;
				if ( 1 == gdkBtnEvent->button ) {
					buttonMask |= VCF::mbmLeftButton;
				}

				if ( 2 == gdkBtnEvent->button ) {
					buttonMask |= VCF::mbmMiddleButton;
				}

				if ( 3 == gdkBtnEvent->button ) {
					buttonMask |= VCF::mbmRightButton;
				}

				event = new VCF::MouseEvent ( eventMsg->control_, Control::MOUSE_UP, buttonMask,
				                              translateKeyMask( ( GdkModifierType ) gdkBtnEvent->state ), &pt );
			}
			break;

		case GDK_KEY_PRESS :
		case GDK_KEY_RELEASE : {
				GdkEventKey* gdkKeyEvent = ( GdkEventKey* ) eventMsg->gdkEvent_;
				KeyboardMasks modifierKey = ( KeyboardMasks ) translateKeyMask( ( GdkModifierType ) gdkKeyEvent->state );
				VirtualKeyCode vkCode = translateKeyCode( gdkKeyEvent->keyval );
				VCFChar keyChar = '0';
				if ( gdkKeyEvent->length > 0 ) {
					keyChar = gdkKeyEvent->string[ 0 ];
				}

				event = new KeyboardEvent( eventMsg->control_,
				                           ( eventMsg->gdkEvent_->type == GDK_KEY_PRESS ) ?
				                           Control::KEYBOARD_DOWN : Control::KEYBOARD_UP,
				                           1, modifierKey, keyChar, vkCode );


			}
			break;

		case GDK_ENTER_NOTIFY :
		case GDK_LEAVE_NOTIFY : {
				GdkEventCrossing* gdkCrossingEvent = ( GdkEventCrossing * ) eventMsg->gdkEvent_;
				VCF::Point pt( gdkCrossingEvent->x, gdkCrossingEvent->y );
				ulong32 eventType = ( gdkCrossingEvent->type == GDK_ENTER_NOTIFY ) ? Control::MOUSE_ENTERED : Control::MOUSE_LEAVE;
				//the peer will fill out the button and key masks
				event = new VCF::MouseEvent ( eventMsg->control_, eventType,
				                              translateButtonMask( ( GdkModifierType ) gdkCrossingEvent->state ),
				                              translateKeyMask( ( GdkModifierType ) gdkCrossingEvent->state ), &pt );
			}
			break;

		case GDK_FOCUS_CHANGE : {
				GdkEventFocus* gdkFocusEvent = ( GdkEventFocus* ) eventMsg->gdkEvent_;
				event = new VCF::FocusEvent ( eventMsg->control_, gdkFocusEvent->in ? Control::FOCUS_GAINED : Control::FOCUS_LOST );
			}
			break;

		case GDK_CONFIGURE : {
				//we are going to return NULL here -
				//the problem is that there are two separate VCF event objects that
				//need to be created, so we are going to let the AbstractGTKControl deal
				//with this directly
			}
			break;

		case GDK_MAP : {}
			break;

		case GDK_UNMAP : {}
			break;

		case GDK_VISIBILITY_NOTIFY : {}
			break;


	}
	return event;
}

Size GTKUIToolkit::internal_getDragDropDelta()
{
	//this is completely arbitrary - need to read this from a file
	Size result( 4, 4 );

	return result;
}


void GTKUIToolkit::createDefaultParentWnd()
{
	defaultParent_ = gtk_window_new( GTK_WINDOW_TOPLEVEL );
	gtk_widget_realize ( defaultParent_ );
}



VirtualKeyCode GTKUIToolkit::translateKeyCode( guint code )
{
	VirtualKeyCode result;


	//please note: all codes from gdk/gdkkeysym.h

	switch ( code ) {

		case GDK_F1 : {
				result = VCF::vkF1;
			}
			break;

		case GDK_F2 : {
				result = VCF::vkF2;
			}
			break;

		case GDK_F3 : {
				result = VCF::vkF3;
			}
			break;

		case GDK_F4 : {
				result = VCF::vkF4;
			}
			break;

		case GDK_F5 : {
				result = VCF::vkF5;
			}
			break;

		case GDK_F6 : {
				result = VCF::vkF6;
			}
			break;

		case GDK_F7 : {
				result = VCF::vkF7;
			}
			break;

		case GDK_F8 : {
				result = VCF::vkF8;
			}
			break;

		case GDK_F9 : {
				result = VCF::vkF9;
			}
			break;

		case GDK_F10 : {
				result = VCF::vkF10;
			}
			break;

		case GDK_F11 : {
				result = VCF::vkF11;
			}
			break;

		case GDK_F12 : {
				result = VCF::vkF12;
			}
			break;

		case GDK_KP_Up :
		case GDK_Up : {
				result = VCF::vkUpArrow;
			}
			break;

		case GDK_KP_Down :
		case GDK_Down : {
				result = VCF::vkDownArrow;
			}
			break;

		case GDK_KP_Left :
		case GDK_Left : {
				result = VCF::vkLeftArrow;
			}
			break;

		case GDK_KP_Right :
		case GDK_Right : {
				result = VCF::vkRightArrow;
			}
			break;

		case GDK_Delete : {
				result = VCF::vkDelete;
			}
			break;

		case GDK_Return : {
				result = VCF::vkReturn;
			}
			break;

		case GDK_BackSpace : {
				result = VCF::vkBackSpace;
			}
			break;

		case GDK_space : {
				result = VCF::vkSpaceBar;
			}
			break;

		case GDK_Escape : {
				result = VCF::vkEscape;
			}
			break;

		case GDK_Page_Down : {
				result = VCF::vkPgDown;
			}
			break;

		case GDK_Page_Up : {
				result = VCF::vkPgUp;
			}
			break;

		case GDK_Home : {
				result = VCF::vkHome;
			}
			break;

		case GDK_End : {
				result = VCF::vkEnd;
			}
			break;

		case GDK_Control_R :
		case GDK_Control_L : {
				result = VCF::vkCtrl;
			}
			break;

		case GDK_Alt_R :
		case GDK_Alt_L : {
				result = VCF::vkAlt;
			}
			break;

		case GDK_Shift_R :
		case GDK_Shift_L : {
				result = VCF::vkShift;
			}
			break;

		case GDK_Tab : {
				result = VCF::vkTab;
			}
			break;

		case GDK_0 :
		case GDK_KP_0 : {
				result = VCF::vkNumber0;
			}
			break;

		case GDK_1 :
		case GDK_KP_1 : {
				result = VCF::vkNumber1;
			}
			break;

		case GDK_2 :
		case GDK_KP_2 : {