abstractgtkcontrol.cpp

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

	gboolean result = FALSE;

	if ( gtkEvent->type == GDK_EXPOSE ) {
		GdkEventExpose * gdkExposeEvent = ( GdkEventExpose* ) gtkEvent;

		GraphicsContext* gc = control_->getContext();

		gc->getPeer() ->setContextID( wndHandle_->window );

		if ( GTK_WIDGET_NO_WINDOW( wndHandle_ ) ) {

			gc->setOrigin( bounds_.left_, bounds_.top_ );
		}

		control_->paint( gc );
		repainted_ = false;

		return FALSE;
	} else if ( gtkEvent->type == GDK_CONFIGURE ) {
		//handle this explicitly here

		int i = 0;
		i++;

		GdkEventConfigure* configEv = ( GdkEventConfigure* ) gtkEvent;

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

		VCF::ControlEvent posEvent( control_, pt );

		VCF::Size sz( configEv->width, configEv->height );

		VCF::ControlEvent szEvent( control_, sz );


		control_->handleEvent( &posEvent );

		control_->handleEvent( &szEvent );



	} else {
		GTKEventMsg eventMsg( gtkEvent, this->control_ );


		Event* event = UIToolkit::createEventFromNativeOSEventData( ( void* ) & eventMsg );

		if ( NULL != event ) {
			control_->handleEvent( event );
			event->free();
			//result = TRUE;
		}
	}

	return result;
}

AbstractGTKControl* AbstractGTKControl::getGTKControlFromWidget( GtkWidget* wndHandle )
{
	AbstractGTKControl * result = NULL;

	AbstractGTKControl::GTKControlMap::iterator found = AbstractGTKControl::gtkControlMap.find( wndHandle );
	if ( found != AbstractGTKControl::gtkControlMap.end() ) {
		result = found->second;
	}

	return result;
}

void AbstractGTKControl_onCreateEvent( ComponentEvent* e )
{
	if ( NULL != e ) {
		Control * control = ( Control* ) e->getSource();

		GtkWidget* widget = ( GtkWidget* ) control->getPeer() ->getHandleID();
		gtk_widget_set_name( widget, control->getClassName().ansi_c_str() );

		control->handleEvent( e );
	}
}

void AbstractGTKControl::registerGTKControl( AbstractGTKControl* gtkControl )
{
	if ( NULL == gtkControl->wndHandle_ ) {
		throw InvalidPointerException( MAKE_ERROR_MSG_2( "Attemtping to register an invalid GtkWidget handle" ) );
	}


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

	AbstractGTKControl::gtkControlMap[ gtkControl->wndHandle_ ] = gtkControl;
	gtkControl->initGdkEventHandlers();

	toolkit->postEvent( new StaticEventHandlerInstance<ComponentEvent>( &AbstractGTKControl_onCreateEvent, gtkControl, "AbstractGTKControl_onCreateEvent" ),
	                    new VCF::ComponentEvent( gtkControl->getControl() , Component::COMPONENT_CREATED ),
	                    true );
}

void AbstractGTKControl::unRegisterGTKControl( AbstractGTKControl* gtkControl )
{
	AbstractGTKControl::GTKControlMap::iterator found = AbstractGTKControl::gtkControlMap.find( gtkControl->wndHandle_ );
	if ( found != AbstractGTKControl::gtkControlMap.end() ) {
		AbstractGTKControl::gtkControlMap.erase( found );
	}
}

void AbstractGTKControl::translateToScreenCoords( Point* pt )
{
	//gtk_widget_translate_coordinates


}


void AbstractGTKControl::translateFromScreenCoords( Point* pt )
{
}

void AbstractGTKControl::initGdkEventHandlers()
{
	gtk_widget_add_events( wndHandle_, GDK_ALL_EVENTS_MASK );

	g_signal_connect ( G_OBJECT ( wndHandle_ ), "event",
	                   G_CALLBACK ( AbstractGTKControl::onGdkEvent ),
	                   ( gpointer ) this );
}

gboolean AbstractGTKControl::onGdkEvent( GtkWidget *widget, GdkEvent *event, gpointer user_data )
{
	AbstractGTKControl * thisPtr = AbstractGTKControl::getGTKControlFromWidget( widget );

	if ( NULL == thisPtr ) {
		return FALSE;
	}

	//AbstractGTKControl* thisPtr = (AbstractGTKControl*)user_data;
	if ( widget != thisPtr->wndHandle_ ) {
		throw RuntimeException( MAKE_ERROR_MSG_2( "Gdk event received for a widget that doesn't match the AbstractGTKControl's widget" ) );
	}

	return thisPtr->handleEvent( event );
}













GType AbstractGTKControl::getGTKType ()
{
	static GType container_type = 0;

	if ( !container_type ) {
		static const GTypeInfo container_info = {
		                                            sizeof ( AbstractGTKControl::ContainerClass ),
		                                            NULL,
		                                            NULL,
		                                            ( GClassInitFunc ) AbstractGTKControl::ContainerClass::init,
		                                            NULL,
		                                            NULL,
		                                            sizeof ( AbstractGTKControl::Container ),
		                                            0,
		                                            ( GInstanceInitFunc ) AbstractGTKControl::Container::init,
		                                        };

		container_type = g_type_register_static ( GTK_TYPE_CONTAINER, "AbstractGTKControl_Container", &container_info, ( GTypeFlags ) 0 );
	}

	return container_type;
}


void AbstractGTKControl::Container::move( GtkWidget* widget,
                                          int x,
                                          int y,
                                          int width,
                                          int height )
{
	/*
	container->x = x;
	container->y = y;
	container->width = width;
	container->height = height;
	*/

	Rect bounds( x, y, x + width, y + height );

	AbstractGTKControl* peer = AbstractGTKControl::Container::getControlPeer( widget );
	if ( NULL == peer ) {
		throw RuntimeException( MAKE_ERROR_MSG_2( "no AbstractGTKControl instance associated with this widget!" ) );
	}
	peer->internal_setBounds( bounds );

	if ( !GTK_IS_VCF_CONTAINER ( widget ) ) {
		widget->allocation.x = int( bounds.left_ );
		widget->allocation.y = int( bounds.top_ );
		widget->allocation.width = int( bounds.getWidth() );
		widget->allocation.height = int( bounds.getHeight() );
	}

	if ( GTK_WIDGET_REALIZED ( widget ) ) {
		GtkWidget * gdkParent = gtk_widget_get_parent ( widget );
		gtk_widget_queue_resize( gdkParent );
	}
}


GtkWidget* AbstractGTKControl::Container::create( GtkAdjustment *adjustment, AbstractGTKControl* gtkControlPeer )
{
	AbstractGTKControl::Container * container;

	container = ( AbstractGTKControl::Container* ) g_object_new ( AbstractGTKControl::getGTKType (), NULL );

	if ( !adjustment )
		adjustment = ( GtkAdjustment* ) gtk_adjustment_new ( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 );

	AbstractGTKControl::Container::setAdjustment( container, adjustment );

	container->gtkControlPeer_ = gtkControlPeer;

	return GTK_WIDGET ( container );
}

/*
GtkAdjustment* AbstractGTKControl::Container::getAdjustment( AbstractGTKControl::Container *container )
{
 
}
*/

void AbstractGTKControl::Container::setUpdatePolicy( AbstractGTKControl::Container *container,
                                                     GtkUpdateType policy )
{
}

void AbstractGTKControl::Container::setAdjustment( AbstractGTKControl::Container *container,
                                                   GtkAdjustment *adjustment )
{
	g_return_if_fail ( container != NULL );
	g_return_if_fail ( GTK_IS_VCF_CONTAINER ( container ) );

	if ( container->adjustment ) {
		g_signal_handlers_disconnect_by_func ( GTK_OBJECT ( container->adjustment ),
		                                       NULL,
		                                       ( gpointer ) container );

		g_object_unref ( GTK_OBJECT ( container->adjustment ) );
	}

	container->adjustment = adjustment;
	g_object_ref ( GTK_OBJECT ( container->adjustment ) );

	g_signal_connect ( GTK_OBJECT ( adjustment ), "changed",
	                   GTK_SIGNAL_FUNC ( AbstractGTKControl::Container::adjustmentChanged ),
	                   ( gpointer ) container );
	g_signal_connect ( GTK_OBJECT ( adjustment ), "value_changed",
	                   GTK_SIGNAL_FUNC ( AbstractGTKControl::Container::adjustmentValueChanged ),
	                   ( gpointer ) container );
}

void AbstractGTKControl::Container::init( AbstractGTKControl::Container *container )
{
	container->gtkControlPeer_ = NULL;
}


void AbstractGTKControl::Container::destroy ( GtkObject *object )
{
	AbstractGTKControl::Container * container;

	g_return_if_fail ( object != NULL );
	g_return_if_fail ( GTK_IS_VCF_CONTAINER ( object ) );



	container = GTK_VCF_CONTAINER ( object );

	if ( container->adjustment ) {
		g_object_unref ( GTK_OBJECT ( container->adjustment ) );
		container->adjustment = NULL;
	}

	if ( GTK_OBJECT_CLASS ( internalVCFParentClass ) ->destroy ) {
		( * GTK_OBJECT_CLASS ( internalVCFParentClass ) ->destroy ) ( object );
	}
}

Rect AbstractGTKControl::Container::getBounds( GtkWidget* widget )
{
	Rect result;

	if ( GTK_IS_VCF_CONTAINER ( widget ) ) {
		AbstractGTKControl::Container * container = GTK_VCF_CONTAINER ( widget );
		result = container->gtkControlPeer_->internal_getBounds();
	} else {
		AbstractGTKControl* control = AbstractGTKControl::getGTKControlFromWidget( widget );
		if ( NULL == control ) {
			throw RuntimeException( MAKE_ERROR_MSG_2( "AbstractGTKControl::getGTKControlFromWidget() returned NULL - no control associated with this GTK widget!" ) );
		}
		result = control->internal_getBounds();
	}

	return result;
}

void AbstractGTKControl::Container::moveChild( AbstractGTKControl::Container *container,
                                               GtkWidget* child,
                                               int x,
                                               int y,
                                               int width,
                                               int height )
{
	g_return_if_fail ( container != NULL );
	g_return_if_fail ( GTK_IS_VCF_CONTAINER ( container ) );
	g_return_if_fail ( child != NULL );

	printf( "AbstractGTKControl::Container::moveChild called\n" );


	GList *children = container->children;
	ContainerChild* childObj = NULL;
	while ( children ) {
		childObj = ( ContainerChild* ) children->data;

		if ( childObj->widget == child ) {
			childObj->x = x;
			childObj->y = y;
			childObj->width = width;
			childObj->height = height;

			Rect bounds( x, y, x + width, y + height );

			AbstractGTKControl* peer = AbstractGTKControl::Container::getControlPeer( child );
			if ( NULL == peer ) {
				//throw RuntimeException( MAKE_ERROR_MSG_2("no AbstractGTKControl instance associated with this widget!") );
			}

			if ( NULL != peer ) {
				peer->internal_setBounds( bounds );
			}

			gtk_widget_queue_resize ( GTK_WIDGET ( child ) );

			break;
		}

		children = children->next;
	}
}

Rect AbstractGTKControl::Container::getChildBounds( AbstractGTKControl::Container *container, GtkWidget* child )
{
	Rect result;

	GList *children = container->children;
	ContainerChild* childObj = NULL;
	while ( children ) {
		childObj = ( ContainerChild* ) children->data;

		if ( childObj->widget == child ) {
			result.left_ = childObj->x;
			result.top_ = childObj->y;
			result.right_ = result.left_ + childObj->width;
			result.bottom_ = result.top_ + childObj->height;

			break;
		}

		children = children->next;
	}

	return result;
}

AbstractGTKControl* AbstractGTKControl::Container::getControlPeer( GtkWidget* widget )
{
	AbstractGTKControl * result = NULL;

	if ( GTK_IS_VCF_CONTAINER ( widget ) ) {
		AbstractGTKControl::Container * container = GTK_VCF_CONTAINER ( widget );
		result = container->gtkControlPeer_;
	} else {
		result = AbstractGTKControl::getGTKControlFromWidget( widget );
	}

	return result;
}

void AbstractGTKControl::Container::realize( GtkWidget *widget )
{
	AbstractGTKControl::Container * container;
	//printf( "gtk_absolute_container_realize\n" );

	GdkWindowAttr attributes;
	gint attributes_mask;

	g_return_if_fail ( widget != NULL );
	g_return_if_fail ( GTK_IS_VCF_CONTAINER ( widget ) );

	GTK_WIDGET_SET_FLAGS ( widget, GTK_REALIZED );
	container = GTK_VCF_CONTAINER ( widget );

	attributes.x = widget->allocation.x;
	attributes.y = widget->allocation.y;
	attributes.width = widget->allocation.width;
	attributes.height = widget->allocation.height;
	attributes.wclass = GDK_INPUT_OUTPUT;
	attributes.window_type = GDK_WINDOW_CHILD;
	attributes.event_mask = gtk_widget_get_events ( widget ) |
	                        GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
	                        GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
	                        GDK_POINTER_MOTION_HINT_MASK;
	attributes.visual = gtk_widget_get_visual ( widget );
	attributes.colormap = gtk_widget_get_colormap ( widget );

	attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
	widget->window = gdk_window_new ( widget->parent->window, &attributes, attributes_mask );

	widget->style = gtk_style_attach ( widget->style, widget->window );

	gdk_window_set_user_data ( widget->window, widget );

	gtk_style_set_background ( widget->style, widget->window, GTK_STATE_ACTIVE );
}

void AbstractGTKControl::Container::sizeRequest( GtkWidget *widget, GtkRequisition *requisition )
{
	//printf( "gtk_absolute_container_size_request\n" );
	g_return_if_fail ( widget != NULL );
	g_return_if_fail ( GTK_IS_VCF_CONTAINER ( widget ) );
	g_return_if_fail ( requisition != NULL );

	StringUtils::traceWithArgs( "Container::sizeRequest widget: %p, name:%s\n", widget, widget->name );


	Rect bounds = AbstractGTKControl::Container::getBounds( widget );

	requisition->width = int( bounds.getWidth() );