GTK+ -- from knowing nothing to knowing something (2)

Getting Started

 Nearly all basic introductions of coding related stuff begin with a Hello World program. Let's not be an exception this time. The following is copied directly from the GTK tutorial available on the official website.

 

#include <gtk/gtk.h>

/**//* This is a callback function. The data arguments are ignored
 * in this example. More on callbacks below. */
static void hello( GtkWidget *widget,
                   gpointer   data )
...{
    g_print ("Hello World ");
}

static gboolean delete_event( GtkWidget *widget,
                              GdkEvent  *event,
                              gpointer   data )
...{
    /**//* If you return FALSE in the "delete_event" signal handler,
     * GTK will emit the "destroy" signal. Returning TRUE means
     * you don't want the window to be destroyed.
     * This is useful for popping up 'are you sure you want to quit?'
     * type dialogs. */

    g_print ("delete event occurred ");

    /**//* Change TRUE to FALSE and the main window will be destroyed with
     * a "delete_event". */

    return TRUE;
}

/**//* Another callback */
static void destroy( GtkWidget *widget,
                     gpointer   data )
...{
    gtk_main_quit ();
}

int main( int   argc,
          char *argv[] )
...{
    /**//* GtkWidget is the storage type for widgets */
    GtkWidget *window;
    GtkWidget *button;
    
    /**//* This is called in all GTK applications. Arguments are parsed
     * from the command line and are returned to the application. */
    gtk_init (&argc, &argv);
    
    /**//* create a new window */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    /**//* When the window is given the "delete_event" signal (this is given
     * by the window manager, usually by the "close" option, or on the
     * titlebar), we ask it to call the delete_event () function
     * as defined above. The data passed to the callback
     * function is NULL and is ignored in the callback function. */
    g_signal_connect (G_OBJECT (window), "delete_event",
              G_CALLBACK (delete_event), NULL);
    
    /**//* Here we connect the "destroy" event to a signal handler.  
     * This event occurs when we call gtk_widget_destroy() on the window,
     * or if we return FALSE in the "delete_event" callback. */
    g_signal_connect (G_OBJECT (window), "destroy",
              G_CALLBACK (destroy), NULL);
    
    /**//* Sets the border width of the window. */
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    /**//* Creates a new button with the label "Hello World". */
    button = gtk_button_new_with_label ("Hello World");
    
    /**//* When the button receives the "clicked" signal, it will call the
     * function hello() passing it NULL as its argument.  The hello()
     * function is defined above. */
    g_signal_connect (G_OBJECT (button), "clicked",
              G_CALLBACK (hello), NULL);
    
    /**//* This will cause the window to be destroyed by calling
     * gtk_widget_destroy(window) when "clicked".  Again, the destroy
     * signal could come from here, or the window manager. */
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
                  G_CALLBACK (gtk_widget_destroy),
                              G_OBJECT (window));
    
    /**//* This packs the button into the window (a gtk container). */
    gtk_container_add (GTK_CONTAINER (window), button);
    
    /**//* The final step is to display this newly created widget. */
    gtk_widget_show (button);
    
    /**//* and the window */
    gtk_widget_show (window);
    
    /**//* All GTK applications must have a gtk_main(). Control ends here
     * and waits for an event to occur (like a key press or
     * mouse event). */
    gtk_main ();
    
    return 0;
}

 

Not the mormal 3-4 lines "Hello World",  looks a bit scary, isn't it? However when you look deeper into it, it is actually quite simple. This piece of code implement a window with a single button on it. When you press the button, "Hello World" will be printed out on the standard output device(ex. your monitor). The tutorial is using C language to demonstrate the usage of GTK, but I think if you get accustomed to it in C, it would not be difficult to switch to other languages.

Now let's start talking about the structure of this piece of code. A few callbacks were written, for calling when a specific "signal" is emitted. Then the main function was written. In the main function, there are two lines you have to write in every of your GTK programs: gtk_init (&argc, &argv); and gtk_main();. (For explanation, see comments in the code area. ) The rest depends on what you want to display on the interface. You usually do it like this:

1. Create something (ex. a widget) by calling xxxx_new function.
2. Call gtk_widget_show function on that widget so that the user can see it. (Remember, a child widget will not be showed untill its parent is showed; when you hide a parent widget, you also hide all of its child widgets)
3. If any signal processing is required (ex. a button clicked signal), call g_signal_connect or g_signal_swapped, while the latter one accepts only one argument for its callback.

Tha't almost all of it. Simple, isn't it? For line by line explanation and api introductions, please refer to comments in the code area and GTK documents. They explain those issues better than I do, so I'd better not repeat them here.

Before we start to write our own code, some understanding about layout and some references are neccessary. Such stuff will be discussed in the next post.