The GTK+ main loop's primary role is to listen for events
on a file descriptor connected to the X server, and forward
them to widgets.
the section called Receiving GDK Events in GTK+ in
the chapter called GDK Basics describes the main
loop's event handling in more detail. This section explains
the main loop in general terms, and describes how to add
new functionality to the main loop: callbacks to be invoked
when the loop is idle, at a specified interval, when a file
descriptor is ready for reading or writing, and when the
main loop exits.
The main loop is primarily implemented by glib, which has
a generic main loop abstraction. GTK+ attaches the glib
main loop to GDK's X server connection, and presents a
convenient interface (the glib loop is slightly
lower-level than the GTK+ loop). The core GTK+ main loop
interface is shown in Figure 28.
gtk_main() runs the main loop.
gtk_main() will not return
until gtk_main_quit() is
called. gtk_main() can be
called recursively; each call to
gtk_main_quit() exits one instance of gtk_main().
gtk_main_level() returns the level of recursion;
that is, it returns 0 if no
gtk_main() is on the stack, 1 if one gtk_main() is running, etc.
All instances of gtk_main() are
functionally identical; they are all watching the same
connection to the X server and working from the same
event queue. gtk_main()
instances are used to block, halting a function's flow of
control until some conditions are met. All GTK+ programs
use this technique to keep
main() from exiting while the application is
running. The gnome_dialog_run()
function (see the section
called Modal Dialogs in the chapter called User
Communication: Dialogs) uses a recursive main
loop, so it doesn't return until the user clicks a dialog
button.
Sometimes you want to process a few events, without
handing the flow of control to
gtk_main(). You can perform a single iteration of
the main loop by calling
gtk_main_iteration(). This might process a single
event, for example; it depends on what tasks are pending.
You can check whether any events need to be processed by
calling the
gtk_events_pending() predicate. Together, these two
functions allow you to temporarily return control to
GTK+, so the GUI can "catch up." For example, during a
long computation, you will want to display a progress
bar; you must allow the GTK+ main loop to run
periodically, so GTK+ can redraw the progress bar. Use
this code:
while (gtk_events_pending())
gtk_main_iteration();
|
