Fruttenboel: about the GTK language extension.

GTK is an abbreviation and it means GIMP ToolKit. The GIMP is the GNU Image Manipulation Program, the open source equivalent to PhotoShop and similar software. In order to make the GIMP, the programmers needed a lot of graphic functionality in their software routines and then the GTK was born.
The GIMP is now in a stable state, but the GTK is still developing further since many other applications could be made with it.

Advantages of the GIMP are, to name only a few:

no restrictive licence as with Qt
written in C, not in C++
ports to other languages are possible and realized
fast and flexible
relatively easy to remember names and reserved words
TYPE checking introduced in C

There are also disadvantages:

very long function names
very few differences in long function names
only lowercase letters in function names
explicit TYPE casting in all functions
TYPEs are checked in runtime, not in compiletime
you need many lines of code to do something

All in all, the GTK is quite difficult to use. You can do fabulous things, like making the Epiphany webbrowser, but you need to be very patient to understand it all.

Below is a first piece of GTK source. It is 'easy C'. GTK shields the user from the difficult and tricky parts. See if you can understand what's going on in it:

#include <gtk/gtk.h>

gint  CloseAppWindow (GtkWidget *widget, gpointer gdata)
  
{
   g_print ("Cheerio..... \n");
   gtk_main_quit ();
   return (FALSE);
}


void  button_was_clicked (GtkWidget *widget, gpointer data)
  
{
   g_print ("OUCH! You pressed too hard on my button.\n");
}


void  button_enter (GtkWidget *widget, gpointer data)
  
{
   g_print ("Nice to see you on my button!\n");
}


void  button_left (GtkWidget *widget, gpointer data)
  
{
   g_print ("WHERE do YOU think you are going? My button aches for your attention...\n");
}


int  main (int argc, char **argv)
  
{
   GtkWidget *window;
   GtkWidget *button;
   
   gtk_init (&argc, &argv);
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_signal_connect (GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (CloseAppWindow), NULL);
   gtk_container_border_width (GTK_CONTAINER (window), 15);
   
   button = gtk_button_new_with_label ("Click me!, Pleazzze..");
   
   gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (button_was_clicked), NULL);
   gtk_signal_connect (GTK_OBJECT (button), "enter", GTK_SIGNAL_FUNC (button_enter), NULL);
   gtk_signal_connect (GTK_OBJECT (button), "leave", GTK_SIGNAL_FUNC (button_left), NULL);
   gtk_container_add (GTK_CONTAINER (window), button);
   gtk_widget_show (button);
   gtk_widget_show (window);
   gtk_main ();
   return (0);
}

Compile this with the line:

 gcc -Wall -g lis33.c -o lis33 `gtk-config --cflags` `gtk-config --libs`

to make an executable called 'lis33' out of the sourcefile 'lis33.c'.

This is always possible. In most cases, you need to (re)install the GTK and GLIB libraries and executables. This is quite easy:

Log on as root
Go to www.gtk.org and download a gtk/glib combination
Put the tar.gz files in the root directory
change directory to /root
enter: gzip -d glib and press TAB followed by ENTER
enter: gzip -d gtk and press TAB followed by ENTER
enter: tar xvf gli and press TAB followed by ENTER
enter: tar xvf gtk and press TAB followed by ENTER
cd into the glib directory: cd glib TAB ENTER
enter the command: ./configure
enter the command: make
enter the command: make install
run the command: ldconfig
cd into the gtk directory: cd ../gtk TAB ENTER
repeat steps 10, 11, 12 and 13.

That's it. You now have the GTK system of your choice. I run all my examples with the 1.2.10 version of GTK and GLIB.

Now try again to compile your sources. If it still doesn't work, have an expert check your system.

Below you will find another, this time slightly more complex sample program with the GTK. In the download section, you can find both source and executable of this 'packbox' example. Due to my intrinsic lazyness, I abbreviated the name of the source to 'pb.c'.

/* example-start packbox packbox.c */

#include <stdio.h>
#include <stdlib.h>
#include "gtk/gtk.h"

gint delete_event (GtkWidget *widget,
		   GdkEvent  *event,
		   gpointer   data )

{
   gtk_main_quit();
   return(FALSE);
}

/* Make a new hbox filled with button-labels. Arguments for the 
 * variables we're interested are passed in to this function. 
 * We do not show the box, but do show everything inside. */

GtkWidget *make_box (gint homogeneous,
		     gint spacing,
		     gint expand,
		     gint fill,
		     gint padding ) 

{
   GtkWidget *box;
   GtkWidget *button;
   char padstr[80];
              
   /* Create a new hbox with the appropriate homogeneous
    * and spacing settings */
   box = gtk_hbox_new (homogeneous, spacing);
              
   /* Create a series of buttons with the appropriate settings */
   button = gtk_button_new_with_label ("gtk_box_pack");
   gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
   gtk_widget_show (button);
              
   button = gtk_button_new_with_label ("(box,");
   gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
   gtk_widget_show (button);
              
   button = gtk_button_new_with_label ("button,");
   gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
   gtk_widget_show (button);
              
   /* Create a button with the label depending on the value of expand. */
   if (expand == TRUE)
     button = gtk_button_new_with_label ("TRUE,");
   else
     button = gtk_button_new_with_label ("FALSE,");
   
   gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
   gtk_widget_show (button);
   
   /* This is the same as the button creation for "expand" above, but uses the 
    * shorthand form. */
   button = gtk_button_new_with_label (fill ? "TRUE," : "FALSE,");
   gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
   gtk_widget_show (button);
              
   sprintf (padstr, "%d);", padding);
   
   button = gtk_button_new_with_label (padstr);
   gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
   gtk_widget_show (button);
              
   return box;
}

int main (int   argc,
	  char *argv[]) 

{
   GtkWidget *window;
   GtkWidget *button;
   GtkWidget *box1;
   GtkWidget *box2;
   GtkWidget *separator;
   GtkWidget *label;
   GtkWidget *quitbox;
   int which;
              
   /* Our init, don't forget this! :) */
   gtk_init (&argc, &argv);
   
   if (argc != 2) 
     {
	fprintf (stderr, "usage: packbox num, where num is 1, 2, or 3.\n");
	/* This just does cleanup in GTK and exits with an exit status of 1. */
	gtk_exit (1);
     }
   
   which = atoi (argv[1]);
   
   /* Create our window */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   
   /* You should always remember to connect the delete_event signal
    * to the main window. This is very important for proper intuitive
    * behavior */
   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
		       GTK_SIGNAL_FUNC (delete_event), NULL);
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
   
   /* We create a vertical box (vbox) to pack the horizontal boxes into.
    * This allows us to stack the horizontal boxes filled with buttons one
    * on top of the other in this vbox. */
   box1 = gtk_vbox_new (FALSE, 0);
              
   /* which example to show. These correspond to the pictures above. */
   switch (which) 
     {
      case 1:
	/* create a new label. */
	label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
	
	/* Align the label to the left side.  We'll discuss this function and 
	 * others in the section on Widget Attributes. */
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
	
	/* Pack the label into the vertical box (vbox box1).  Remember that 
	 * widgets added to a vbox will be packed one on top of the other in
	 * order. */
	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
		                
	/* Show the label */
	gtk_widget_show (label);
	
	/* Call our make box function - homogeneous = FALSE, spacing = 0,
	 * expand = FALSE, fill = FALSE, padding = 0 */
	box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
		 
	/* Call our make box function - homogeneous = FALSE, spacing = 0,
	 * expand = TRUE, fill = FALSE, padding = 0 */
	box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
		                
	/* Args are: homogeneous, spacing, expand, fill, padding */
	box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
		                
	/* Creates a separator, we'll learn more about these later, 
	 * but they are quite simple. */
	separator = gtk_hseparator_new ();
		                
	/* Pack the separator into the vbox. Remember each of these
	 * widgets is being packed into a vbox, so they'll be stacked
	 * vertically. */
	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
	gtk_widget_show (separator);
		                
	/* Create another new label, and show it. */
	label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
	gtk_widget_show (label);
	
	/* Args are: homogeneous, spacing, expand, fill, padding */
	box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
	
	/* Args are: homogeneous, spacing, expand, fill, padding */
	box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
		                
	/* Another new separator. */
	separator = gtk_hseparator_new ();
	/* The last 3 arguments to gtk_box_pack_start are:
	 * expand, fill, padding. */
	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
	gtk_widget_show (separator);
		                
	break;
	
      case 2:
	/* Create a new label, remember box1 is a vbox as created 
	 * near the beginning of main() */
	label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
	gtk_widget_show (label);
		                
	/* Args are: homogeneous, spacing, expand, fill, padding */
	box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
	
	/* Args are: homogeneous, spacing, expand, fill, padding */
	box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
		                
	separator = gtk_hseparator_new ();
	/* The last 3 arguments to gtk_box_pack_start are:
	 * expand, fill, padding. */
	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
	gtk_widget_show (separator);
		                
	label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
	gtk_widget_show (label);
		                
	/* Args are: homogeneous, spacing, expand, fill, padding */
	box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
		                
	/* Args are: homogeneous, spacing, expand, fill, padding */
	box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
		                
	separator = gtk_hseparator_new ();
	/* The last 3 arguments to gtk_box_pack_start are: expand, fill, padding. */
	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
	gtk_widget_show (separator);
	break;
	
      case 3:
		 
	/* This demonstrates the ability to use gtk_box_pack_end() to
	 * right justify widgets. First, we create a new box as before. */
	box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
		 
	/* Create the label that will be put at the end. */
	label = gtk_label_new ("end");
	/* Pack it using gtk_box_pack_end(), so it is put on the right
	 * side of the hbox created in the make_box() call. */
	gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
	/* Show the label. */
	gtk_widget_show (label);
	
	/* Pack box2 into box1 (the vbox remember ? :) */
	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
	gtk_widget_show (box2);
	
	/* A separator for the bottom. */
	separator = gtk_hseparator_new ();
	/* This explicitly sets the separator to 400 pixels wide by 5 pixels
	 * high. This is so the hbox we created will also be 400 pixels wide,
	 * and the "end" label will be separated from the other labels in the
	 * hbox. Otherwise, all the widgets in the hbox would be packed as
	 * close together as possible. */
	gtk_widget_set_usize (separator, 400, 5);
	/* pack the separator into the vbox (box1) created near the start 
	 * of main() */
	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
	gtk_widget_show (separator);    
     }
              
   /* Create another new hbox.. remember we can use as many as we need! */
   quitbox = gtk_hbox_new (FALSE, 0);
   
   /* Our quit button. */
   button = gtk_button_new_with_label ("Quit");
   
   /* Setup the signal to terminate the program when the button is clicked */
   gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
			      GTK_SIGNAL_FUNC (gtk_main_quit),
					                                       GTK_OBJECT (window));
   /* Pack the button into the quitbox.
    * The last 3 arguments to gtk_box_pack_start are:
    * expand, fill, padding. */
   gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
   /* pack the quitbox into the vbox (box1) */
   gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
   
   /* Pack the vbox (box1) which now contains all our widgets, into the
    * main window. */
   gtk_container_add (GTK_CONTAINER (window), box1);
              
   /* And show everything left */
   gtk_widget_show (button);
   gtk_widget_show (quitbox);
   
   gtk_widget_show (box1);
   /* Showing the window last so everything pops up at once. */
   gtk_widget_show (window);
   
   /* And of course, our main function. */
   gtk_main ();
   
   /* Control returns here when gtk_main_quit() is called, but not when 
    * gtk_exit is used. */
              
   return(0);
}
/* example-end */

GTK is nice and powerful, but you need very good typing skills and you also need very sharp eyes. Sometimes the differences between function names is only one character, in a functionname of 30 characters or more. Furthermore, you need to issue lots of 'gtk_widget_show' calls to enable thingies on screen.
The runtime TYPE checking is a definite advantage. The only drawback is that the types are checked in runtime, not during compilation.

What I particularly dislike is the multitude of instances where no decent descriptive enumerated TYPE is used. Instead, the used values are BOOLEAN variables, resulting in functioncalls like the following:

   /* Args are:  homogeneous, spacing, expand, fill, padding */
   box2 = make_box (FALSE,      0,      TRUE,  TRUE,   0);

This is a pity. Now you always need to remember what property is TRUE or a lie, which is not easy when the function calls are all so similarly looking.

All in all, the overhead to use GTK for programming is too high for me. Especially the fact that many functions have similar names, makes learning quite difficult to me. So I decided to restart my Qt learning project.

Page created July 2004,

Page equipped with FroogleBuster technology