GTK v1.2 Tutorial(英文)

2.4 Events

　　In addition to the signal mechanism described above, there is a set of events that reflect the X event mechanism. Callbacks may also be attached to these events. These events are:

event 
button_press_event 
button_release_event 
motion_notify_event 
delete_event 
destroy_event 
expose_event 
key_press_event 
key_release_event 
enter_notify_event 
leave_notify_event 
configure_event 
focus_in_event 
focus_out_event 
map_event 
unmap_event 
property_notify_event 
selection_clear_event 
selection_request_event 
selection_notify_event 
proximity_in_event 
proximity_out_event 
drag_begin_event 
drag_request_event 
drag_end_event 
drop_enter_event 
drop_leave_event 
drop_data_available_event 
other_event 

　　In order to connect a callback function to one of these events, you use the function gtk_signal_connect, as described above, using one of the above event names as the name parameter. The callback function for events has a slightly different form than that for signals:

void callback_func( GtkWidget *widget,
GdkEvent*event,
gpointer callback_data );

　　GdkEvent is a C union structure whose type will depend upon which of the above events has occurred. In order for us to tell which event has been issued each of the possible alternatives has a type parameter which reflects the event being issued. The other components of the event structure will depend upon the type of the event. Possible values for the type are:

GDK_NOTHING
GDK_DELETE
GDK_DESTROY
GDK_EXPOSE
GDK_MOTION_NOTIFY
GDK_BUTTON_PRESS
GDK_2BUTTON_PRESS
GDK_3BUTTON_PRESS
GDK_BUTTON_RELEASE
GDK_KEY_PRESS
GDK_KEY_RELEASE
GDK_ENTER_NOTIFY
GDK_LEAVE_NOTIFY
GDK_FOCUS_CHANGE
GDK_CONFIGURE
GDK_MAP
GDK_UNMAP
GDK_PROPERTY_NOTIFY
GDK_SELECTION_CLEAR
GDK_SELECTION_REQUEST
GDK_SELECTION_NOTIFY
GDK_PROXIMITY_IN
GDK_PROXIMITY_OUT
GDK_DRAG_BEGIN
GDK_DRAG_REQUEST
GDK_DROP_ENTER
GDK_DROP_LEAVE
GDK_DROP_DATA_AVAIL
GDK_CLIENT_EVENT
GDK_VISIBILITY_NOTIFY
GDK_NO_EXPOSE
GDK_OTHER_EVENT /* Deprecated, use filters instead */

　　So, to connect a callback function to one of these events we would use something like:

gtk_signal_connect( GTK_OBJECT(button), "button_press_event",
GTK_SIGNAL_FUNC(button_press_callback), 
NULL);

　　This assumes that button is a Button widget. Now, when the mouse is over the button and a mouse button is pressed, the function button_press_callback will be called. This function may be declared as:

static gint button_press_callback( GtkWidget*widget, 
 GdkEventButton *event,
 gpointerdata );

　　Note that we can declare the second argument as type GdkEventButton as we know what type of event will occur for this function to be called.

　　The value returned from this function indicates whether the event should be propagated further by the GTK event handling mechanism. Returning TRUE indicates that the event has been handled, and that it should not propagate further. Returning FALSE continues the normal event handling. See the section on Advanced Event and Signal Handling for more details on this propagation process.

　　For details on the GdkEvent data types, see the appendix entitled GDK Event Types.

2.5 Stepping Through Hello World

　　Now that we know the theory behind this, let's clarify by walking through the example helloworld program.

　　Here is the callback function that will be called when the button is "clicked". We ignore both the widget and the data in this example, but it is not hard to do things with them. The next example will use the data argument to tell us which button was pressed.

void hello( GtkWidget *widget,
gpointer data )
{
g_print ("Hello World
");
}

　　The next callback is a bit special. The "delete_event" occurs when the window manager sends this event to the application. We have a choice here as to what to do about these events. We can ignore them, make some sort of response, or simply quit the application.

　　The value you return in this callback lets GTK know what action to take. By returning TRUE, we let it know that we don't want to have the "destroy" signal emitted, keeping our application running. By returning FALSE, we ask that "destroy" be emitted, which in turn will call our "destroy" signal handler.