Tue Mar 31 15:41:57 PST 1998 Shawn T. Amundson

        * Makefile.am:
	* examples/*: added the rest of the tutorial examples

37 files changed, 2423 insertions, 0 deletions

diff --git a/examples/entry/Makefile b/examples/entry/Makefile
new file mode 100644
index 0000000000..130ec03676
--- /dev/null
+++ b/examples/entry/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+entry: entry.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` entry.c -o entry
+
+clean: 
+	rm -f *.o entry
diff --git a/examples/entry/entry.c b/examples/entry/entry.c
new file mode 100644
index 0000000000..d341538893
--- /dev/null
+++ b/examples/entry/entry.c
@@ -0,0 +1,92 @@
+/* This file extracted from the GTK tutorial. */
+
+/* entry.c */
+
+#include <gtk/gtk.h>
+
+void enter_callback(GtkWidget *widget, GtkWidget *entry)
+{
+  gchar *entry_text;
+  entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
+  printf("Entry contents: %s\n", entry_text);
+}
+
+void entry_toggle_editable (GtkWidget *checkbutton,
+				   GtkWidget *entry)
+{
+  gtk_entry_set_editable(GTK_ENTRY(entry),
+			 GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+void entry_toggle_visibility (GtkWidget *checkbutton,
+				   GtkWidget *entry)
+{
+  gtk_entry_set_visibility(GTK_ENTRY(entry),
+			 GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+int main (int argc, char *argv[])
+{
+
+    GtkWidget *window;
+    GtkWidget *vbox, *hbox;
+    GtkWidget *entry;
+    GtkWidget *button;
+    GtkWidget *check;
+
+    gtk_init (&argc, &argv);
+
+    /* create a new window */
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
+    gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
+    gtk_signal_connect(GTK_OBJECT (window), "delete_event",
+                       (GtkSignalFunc) gtk_exit, NULL);
+
+    vbox = gtk_vbox_new (FALSE, 0);
+    gtk_container_add (GTK_CONTAINER (window), vbox);
+    gtk_widget_show (vbox);
+
+    entry = gtk_entry_new_with_max_length (50);
+    gtk_signal_connect(GTK_OBJECT(entry), "activate",
+		       GTK_SIGNAL_FUNC(enter_callback),
+		       entry);
+    gtk_entry_set_text (GTK_ENTRY (entry), "hello");
+    gtk_entry_append_text (GTK_ENTRY (entry), " world");
+    gtk_entry_select_region (GTK_ENTRY (entry),
+			     0, GTK_ENTRY(entry)->text_length);
+    gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
+    gtk_widget_show (entry);
+
+    hbox = gtk_hbox_new (FALSE, 0);
+    gtk_container_add (GTK_CONTAINER (vbox), hbox);
+    gtk_widget_show (hbox);
+                                  
+    check = gtk_check_button_new_with_label("Editable");
+    gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
+    gtk_signal_connect (GTK_OBJECT(check), "toggled",
+			GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
+    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
+    gtk_widget_show (check);
+    
+    check = gtk_check_button_new_with_label("Visible");
+    gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
+    gtk_signal_connect (GTK_OBJECT(check), "toggled",
+			GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
+    gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
+    gtk_widget_show (check);
+                                   
+    button = gtk_button_new_with_label ("Close");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC(gtk_exit),
+			       GTK_OBJECT (window));
+    gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
+    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+    gtk_widget_grab_default (button);
+    gtk_widget_show (button);
+    
+    gtk_widget_show(window);
+
+    gtk_main();
+    return(0);
+}
diff --git a/examples/eventbox/Makefile b/examples/eventbox/Makefile
new file mode 100644
index 0000000000..e010b9c2d9
--- /dev/null
+++ b/examples/eventbox/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+eventbox: eventbox.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` eventbox.c -o eventbox
+
+clean: 
+	rm -f *.o eventbox
diff --git a/examples/eventbox/eventbox.c b/examples/eventbox/eventbox.c
new file mode 100644
index 0000000000..c3ec105eef
--- /dev/null
+++ b/examples/eventbox/eventbox.c
@@ -0,0 +1,55 @@
+/* This file extracted from the GTK tutorial. */
+
+/* eventbox.c */
+
+#include <gtk/gtk.h>
+
+int 
+main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *event_box;
+    GtkWidget *label;
+    
+    gtk_init (&argc, &argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_window_set_title (GTK_WINDOW (window), "Event Box");
+    
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    /* Create an EventBox and add it to our toplevel window */
+    
+    event_box = gtk_event_box_new ();
+    gtk_container_add (GTK_CONTAINER(window), event_box);
+    gtk_widget_show (event_box);
+    
+    /* Create a long label */
+    
+    label = gtk_label_new ("Click here to quit, quit, quit, quit, quit");
+    gtk_container_add (GTK_CONTAINER (event_box), label);
+    gtk_widget_show (label);
+    
+    /* Clip it short. */
+    gtk_widget_set_usize (label, 110, 20);
+    
+    /* And bind an action to it */
+    gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
+    gtk_signal_connect (GTK_OBJECT(event_box), "button_press_event",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+    
+    /* Yet one more thing you need an X window for ... */
+    
+    gtk_widget_realize (event_box);
+    gdk_window_set_cursor (event_box->window, gdk_cursor_new (GDK_HAND1));
+    
+    gtk_widget_show (window);
+    
+    gtk_main ();
+    
+    return 0;
+}
diff --git a/examples/filesel/Makefile b/examples/filesel/Makefile
new file mode 100644
index 0000000000..7df5a5d7f8
--- /dev/null
+++ b/examples/filesel/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+filesel: filesel.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` filesel.c -o filesel
+
+clean: 
+	rm -f *.o filesel
diff --git a/examples/filesel/filesel.c b/examples/filesel/filesel.c
new file mode 100644
index 0000000000..5a19392b00
--- /dev/null
+++ b/examples/filesel/filesel.c
@@ -0,0 +1,46 @@
+/* This file extracted from the GTK tutorial. */
+
+/* filesel.c */
+
+#include <gtk/gtk.h>
+
+/* Get the selected filename and print it to the console */
+void file_ok_sel (GtkWidget *w, GtkFileSelection *fs)
+{
+    g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
+}
+
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *filew;
+    
+    gtk_init (&argc, &argv);
+    
+    /* Create a new file selection widget */
+    filew = gtk_file_selection_new ("File selection");
+    
+    gtk_signal_connect (GTK_OBJECT (filew), "destroy",
+			(GtkSignalFunc) destroy, &filew);
+    /* Connect the ok_button to file_ok_sel function */
+    gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
+			"clicked", (GtkSignalFunc) file_ok_sel, filew );
+    
+    /* Connect the cancel_button to destroy the widget */
+    gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
+			       "clicked", (GtkSignalFunc) gtk_widget_destroy,
+			       GTK_OBJECT (filew));
+    
+    /* Lets set the filename, as if this were a save dialog, and we are giving
+     a default filename */
+    gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew), 
+				     "penguin.png");
+    
+    gtk_widget_show(filew);
+    gtk_main ();
+    return 0;
+}
diff --git a/examples/list/Makefile b/examples/list/Makefile
new file mode 100644
index 0000000000..0888dc8668
--- /dev/null
+++ b/examples/list/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+list: list.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` list.c -o list
+
+clean: 
+	rm -f *.o list
diff --git a/examples/list/list.c b/examples/list/list.c
new file mode 100644
index 0000000000..6bed623605
--- /dev/null
+++ b/examples/list/list.c
@@ -0,0 +1,284 @@
+/* This file extracted from the GTK tutorial. */
+
+/* list.c */
+
+/* include the gtk+ header files
+ * include stdio.h, we need that for the printf() function
+ */
+#include        <gtk/gtk.h>
+#include        <stdio.h>
+
+/* this is our data identification string to store
+ * data in list items
+ */
+const   gchar   *list_item_data_key="list_item_data";
+
+
+/* prototypes for signal handler that we are going to connect
+ * to the GtkList widget
+ */
+static  void    sigh_print_selection    (GtkWidget      *gtklist,
+                                         gpointer       func_data);
+static  void    sigh_button_event       (GtkWidget      *gtklist,
+                                         GdkEventButton *event,
+                                         GtkWidget      *frame);
+
+
+/* main function to set up the user interface */
+
+gint main (int argc, gchar *argv[])
+{                                  
+    GtkWidget       *separator;
+    GtkWidget       *window;
+    GtkWidget       *vbox;
+    GtkWidget       *scrolled_window;
+    GtkWidget       *frame;
+    GtkWidget       *gtklist;
+    GtkWidget       *button;
+    GtkWidget       *list_item;
+    GList           *dlist;
+    guint           i;
+    gchar           buffer[64];
+    
+    
+    /* initialize gtk+ (and subsequently gdk) */
+
+    gtk_init(&argc, &argv);
+    
+    
+    /* create a window to put all the widgets in
+     * connect gtk_main_quit() to the "destroy" event of
+     * the window to handle window manager close-window-events
+     */
+    window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW(window), "GtkList Example");
+    gtk_signal_connect(GTK_OBJECT(window),
+		       "destroy",
+		       GTK_SIGNAL_FUNC(gtk_main_quit),
+		       NULL);
+    
+    
+    /* inside the window we need a box to arrange the widgets
+     * vertically */
+    vbox=gtk_vbox_new(FALSE, 5);
+    gtk_container_border_width(GTK_CONTAINER(vbox), 5);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+    gtk_widget_show(vbox);
+    
+    /* this is the scolled window to put the GtkList widget inside */
+    scrolled_window=gtk_scrolled_window_new(NULL, NULL);
+    gtk_widget_set_usize(scrolled_window, 250, 150);
+    gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
+    gtk_widget_show(scrolled_window);
+    
+    /* create the GtkList widget
+     * connect the sigh_print_selection() signal handler
+     * function to the "selection_changed" signal of the GtkList
+     * to print out the selected items each time the selection
+     * has changed */
+    gtklist=gtk_list_new();
+    gtk_container_add(GTK_CONTAINER(scrolled_window), gtklist);
+    gtk_widget_show(gtklist);
+    gtk_signal_connect(GTK_OBJECT(gtklist),
+		       "selection_changed",
+		       GTK_SIGNAL_FUNC(sigh_print_selection),
+		       NULL);
+    
+    /* we create a "Prison" to put a list item in ;)
+     */
+    frame=gtk_frame_new("Prison");
+    gtk_widget_set_usize(frame, 200, 50);
+    gtk_container_border_width(GTK_CONTAINER(frame), 5);
+    gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
+    gtk_container_add(GTK_CONTAINER(vbox), frame);
+    gtk_widget_show(frame);
+    
+    /* connect the sigh_button_event() signal handler to the GtkList
+     * wich will handle the "arresting" of list items
+     */
+    gtk_signal_connect(GTK_OBJECT(gtklist),
+		       "button_release_event",
+		       GTK_SIGNAL_FUNC(sigh_button_event),
+		       frame);
+    
+    /* create a separator
+     */
+    separator=gtk_hseparator_new();
+    gtk_container_add(GTK_CONTAINER(vbox), separator);
+    gtk_widget_show(separator);
+    
+    /* finaly create a button and connect it´s "clicked" signal
+     * to the destroyment of the window
+     */
+    button=gtk_button_new_with_label("Close");
+    gtk_container_add(GTK_CONTAINER(vbox), button);
+    gtk_widget_show(button);
+    gtk_signal_connect_object(GTK_OBJECT(button),
+			      "clicked",
+			      GTK_SIGNAL_FUNC(gtk_widget_destroy),
+			      GTK_OBJECT(window));
+    
+    
+    /* now we create 5 list items, each having it´s own
+     * label and add them to the GtkList using gtk_container_add()
+     * also we query the text string from the label and
+     * associate it with the list_item_data_key for each list item
+     */
+    for (i=0; i<5; i++) {
+	GtkWidget       *label;
+	gchar           *string;
+	
+	sprintf(buffer, "ListItemContainer with Label #%d", i);
+	label=gtk_label_new(buffer);
+	list_item=gtk_list_item_new();
+	gtk_container_add(GTK_CONTAINER(list_item), label);
+	gtk_widget_show(label);
+	gtk_container_add(GTK_CONTAINER(gtklist), list_item);
+	gtk_widget_show(list_item);
+	gtk_label_get(GTK_LABEL(label), &string);
+	gtk_object_set_data(GTK_OBJECT(list_item),
+			    list_item_data_key,
+			    string);
+    }
+    /* here, we are creating another 5 labels, this time
+     * we use gtk_list_item_new_with_label() for the creation
+     * we can´t query the text string from the label because
+     * we don´t have the labels pointer and therefore
+     * we just associate the list_item_data_key of each
+     * list item with the same text string
+     * for adding of the list items we put them all into a doubly
+     * linked list (GList), and then add them by a single call to
+     * gtk_list_append_items()
+     * because we use g_list_prepend() to put the items into the
+     * doubly linked list, their order will be descending (instead
+     * of ascending when using g_list_append())
+     */
+    dlist=NULL;
+    for (; i<10; i++) {
+	sprintf(buffer, "List Item with Label %d", i);
+	list_item=gtk_list_item_new_with_label(buffer);
+	dlist=g_list_prepend(dlist, list_item);
+	gtk_widget_show(list_item);
+	gtk_object_set_data(GTK_OBJECT(list_item),
+			    list_item_data_key,
+			    "ListItem with integrated Label");
+    }
+    gtk_list_append_items(GTK_LIST(gtklist), dlist);
+    
+    /* finaly we want to see the window, don´t we? ;)
+     */
+    gtk_widget_show(window);
+    
+    /* fire up the main event loop of gtk
+     */
+    gtk_main();
+    
+    /* we get here after gtk_main_quit() has been called which
+     * happens if the main window gets destroyed
+     */
+    return 0;
+}
+
+/* this is the signal handler that got connected to button
+ * press/release events of the GtkList
+ */
+void
+sigh_button_event       (GtkWidget      *gtklist,
+                         GdkEventButton *event,
+                         GtkWidget      *frame)
+{
+    /* we only do something if the third (rightmost mouse button
+     * was released
+     */
+    if (event->type==GDK_BUTTON_RELEASE &&
+	event->button==3) {
+	GList           *dlist, *free_list;
+	GtkWidget       *new_prisoner;
+	
+	/* fetch the currently selected list item which
+	 * will be our next prisoner ;)
+	 */
+	dlist=GTK_LIST(gtklist)->selection;
+	if (dlist)
+		new_prisoner=GTK_WIDGET(dlist->data);
+	else
+		new_prisoner=NULL;
+	
+	/* look for already prisoned list items, we
+	 * will put them back into the list
+	 * remember to free the doubly linked list that
+	 * gtk_container_children() returns
+	 */
+	dlist=gtk_container_children(GTK_CONTAINER(frame));
+	free_list=dlist;
+	while (dlist) {
+	    GtkWidget       *list_item;
+	    
+	    list_item=dlist->data;
+	    
+	    gtk_widget_reparent(list_item, gtklist);
+	    
+	    dlist=dlist->next;
+	}
+	g_list_free(free_list);
+	
+	/* if we have a new prisoner, remove him from the
+	 * GtkList and put him into the frame "Prison"
+	 * we need to unselect the item before
+	 */
+	if (new_prisoner) {
+	    GList   static_dlist;
+	    
+	    static_dlist.data=new_prisoner;
+	    static_dlist.next=NULL;
+	    static_dlist.prev=NULL;
+	    
+	    gtk_list_unselect_child(GTK_LIST(gtklist),
+				    new_prisoner);
+	    gtk_widget_reparent(new_prisoner, frame);
+	}
+    }
+}
+
+/* this is the signal handler that gets called if GtkList
+ * emits the "selection_changed" signal
+ */
+void
+sigh_print_selection    (GtkWidget      *gtklist,
+                         gpointer       func_data)
+{
+    GList   *dlist;
+    
+    /* fetch the doubly linked list of selected items
+     * of the GtkList, remember to treat this as read-only!
+     */
+    dlist=GTK_LIST(gtklist)->selection;
+    
+    /* if there are no selected items there is nothing more
+     * to do than just telling the user so
+     */
+    if (!dlist) {
+	g_print("Selection cleared\n");
+	return;
+    }
+    /* ok, we got a selection and so we print it
+     */
+    g_print("The selection is a ");
+    
+    /* get the list item from the doubly linked list
+     * and then query the data associated with list_item_data_key
+     * we then just print it
+     */
+    while (dlist) {
+	GtkObject       *list_item;
+	gchar           *item_data_string;
+	
+	list_item=GTK_OBJECT(dlist->data);
+	item_data_string=gtk_object_get_data(list_item,
+					     list_item_data_key);
+	g_print("%s ", item_data_string);
+	
+	dlist=dlist->next;
+    }
+    g_print("\n");
+}
diff --git a/examples/menu/Makefile b/examples/menu/Makefile
new file mode 100644
index 0000000000..630d3f297e
--- /dev/null
+++ b/examples/menu/Makefile
@@ -0,0 +1,19 @@
+
+CC = gcc
+
+all: menu menufactory
+
+menu: menu.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` menu.c -o menu
+
+menufactory: menufactory.o mfmain.o
+	$(CC) `gtk-config --libs` menufactory.o mfmain.o -o menufactory
+
+menufactory.o:
+	$(CC) `gtk-config --cflags` -c menufactory.c -o menufactory.o
+
+mfmain.o:
+	$(CC) `gtk-config --cflags` -c mfmain.c -o mfmain.o
+
+clean: 
+	rm -f *.o menu menufactory
diff --git a/examples/menu/menu.c b/examples/menu/menu.c
new file mode 100644
index 0000000000..4053fab7b6
--- /dev/null
+++ b/examples/menu/menu.c
@@ -0,0 +1,134 @@
+/* This file extracted from the GTK tutorial. */
+
+/* menu.c */
+
+#include <gtk/gtk.h>
+
+static gint button_press (GtkWidget *, GdkEvent *);
+static void menuitem_response (gchar *);
+
+int main (int argc, char *argv[])
+{
+
+    GtkWidget *window;
+    GtkWidget *menu;
+    GtkWidget *menu_bar;
+    GtkWidget *root_menu;
+    GtkWidget *menu_items;
+    GtkWidget *vbox;
+    GtkWidget *button;
+    char buf[128];
+    int i;
+
+    gtk_init (&argc, &argv);
+
+    /* create a new window */
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
+    gtk_window_set_title(GTK_WINDOW (window), "GTK Menu Test");
+    gtk_signal_connect(GTK_OBJECT (window), "delete_event",
+                       (GtkSignalFunc) gtk_exit, NULL);
+
+    /* Init the menu-widget, and remember -- never
+     * gtk_show_widget() the menu widget!! 
+     * This is the menu that holds the menu items, the one that
+     * will pop up when you click on the "Root Menu" in the app */
+    menu = gtk_menu_new();
+
+    /* Next we make a little loop that makes three menu-entries for "test-menu".
+     * Notice the call to gtk_menu_append.  Here we are adding a list of
+     * menu items to our menu.  Normally, we'd also catch the "clicked"
+     * signal on each of the menu items and setup a callback for it,
+     * but it's omitted here to save space. */
+
+    for(i = 0; i < 3; i++)
+        {
+            /* Copy the names to the buf. */
+            sprintf(buf, "Test-undermenu - %d", i);
+
+            /* Create a new menu-item with a name... */
+            menu_items = gtk_menu_item_new_with_label(buf);
+
+            /* ...and add it to the menu. */
+            gtk_menu_append(GTK_MENU (menu), menu_items);
+
+	    /* Do something interesting when the menuitem is selected */
+	    gtk_signal_connect_object(GTK_OBJECT(menu_items), "activate",
+		GTK_SIGNAL_FUNC(menuitem_response), (gpointer) g_strdup(buf));
+
+            /* Show the widget */
+            gtk_widget_show(menu_items);
+        }
+
+    /* This is the root menu, and will be the label
+     * displayed on the menu bar.  There won't be a signal handler attached,
+     * as it only pops up the rest of the menu when pressed. */
+    root_menu = gtk_menu_item_new_with_label("Root Menu");
+
+    gtk_widget_show(root_menu);
+
+    /* Now we specify that we want our newly created "menu" to be the menu
+     * for the "root menu" */
+    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
+
+    /* A vbox to put a menu and a button in: */
+    vbox = gtk_vbox_new(FALSE, 0);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+    gtk_widget_show(vbox);
+
+    /* Create a menu-bar to hold the menus and add it to our main window */
+    menu_bar = gtk_menu_bar_new();
+    gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
+    gtk_widget_show(menu_bar);
+
+    /* Create a button to which to attach menu as a popup */
+    button = gtk_button_new_with_label("press me");
+    gtk_signal_connect_object(GTK_OBJECT(button), "event",
+	GTK_SIGNAL_FUNC (button_press), GTK_OBJECT(menu));
+    gtk_box_pack_end(GTK_BOX(vbox), button, TRUE, TRUE, 2);
+    gtk_widget_show(button);
+
+    /* And finally we append the menu-item to the menu-bar -- this is the
+     * "root" menu-item I have been raving about =) */
+    gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), root_menu);
+
+    /* always display the window as the last step so it all splashes on
+     * the screen at once. */
+    gtk_widget_show(window);
+
+    gtk_main ();
+
+    return 0;
+}
+
+
+
+/* Respond to a button-press by posting a menu passed in as widget.
+ *
+ * Note that the "widget" argument is the menu being posted, NOT
+ * the button that was pressed.
+ */
+
+static gint button_press (GtkWidget *widget, GdkEvent *event)
+{
+
+    if (event->type == GDK_BUTTON_PRESS) {
+        GdkEventButton *bevent = (GdkEventButton *) event; 
+        gtk_menu_popup (GTK_MENU(widget), NULL, NULL, NULL, NULL,
+                        bevent->button, bevent->time);
+        /* Tell calling code that we have handled this event; the buck
+         * stops here. */
+        return TRUE;
+    }
+
+    /* Tell calling code that we have not handled this event; pass it on. */
+    return FALSE;
+}
+
+
+/* Print a string when a menu item is selected */
+
+static void menuitem_response (gchar *string)
+{
+    printf("%s\n", string);
+}
diff --git a/examples/menu/menufactory.c b/examples/menu/menufactory.c
new file mode 100644
index 0000000000..9f72e1e925
--- /dev/null
+++ b/examples/menu/menufactory.c
@@ -0,0 +1,151 @@
+/* This file extracted from the GTK tutorial. */
+
+/* menufactory.c */
+
+#include <gtk/gtk.h>
+#include <strings.h>
+
+#include "mfmain.h"
+
+
+static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path);
+static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path);
+void menus_init(void);
+void menus_create(GtkMenuEntry * entries, int nmenu_entries);
+
+
+/* this is the GtkMenuEntry structure used to create new menus.  The
+ * first member is the menu definition string.  The second, the
+ * default accelerator key used to access this menu function with
+ * the keyboard.  The third is the callback function to call when
+ * this menu item is selected (by the accelerator key, or with the
+ * mouse.) The last member is the data to pass to your callback function.
+ */
+
+static GtkMenuEntry menu_items[] =
+{
+	{"<Main>/File/New", "<control>N", NULL, NULL},
+	{"<Main>/File/Open", "<control>O", NULL, NULL},
+	{"<Main>/File/Save", "<control>S", NULL, NULL},
+	{"<Main>/File/Save as", NULL, NULL, NULL},
+	{"<Main>/File/<separator>", NULL, NULL, NULL},
+	{"<Main>/File/Quit", "<control>Q", file_quit_cmd_callback, "OK, I'll quit"},
+	{"<Main>/Options/Test", NULL, NULL, NULL}
+};
+
+/* calculate the number of menu_item's */
+static int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
+
+static int initialize = TRUE;
+static GtkMenuFactory *factory = NULL;
+static GtkMenuFactory *subfactory[1];
+static GHashTable *entry_ht = NULL;
+
+void get_main_menu(GtkWidget ** menubar, GtkAcceleratorTable ** table)
+{
+    if (initialize)
+	    menus_init();
+    
+    if (menubar)
+	    *menubar = subfactory[0]->widget;
+    if (table)
+	    *table = subfactory[0]->table;
+}
+
+void menus_init(void)
+{
+    if (initialize) {
+	initialize = FALSE;
+	
+	factory = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
+	subfactory[0] = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
+	
+	gtk_menu_factory_add_subfactory(factory, subfactory[0], "<Main>");
+	menus_create(menu_items, nmenu_items);
+    }
+}
+
+void menus_create(GtkMenuEntry * entries, int nmenu_entries)
+{
+    char *accelerator;
+    int i;
+    
+    if (initialize)
+	    menus_init();
+    
+    if (entry_ht)
+	    for (i = 0; i < nmenu_entries; i++) {
+		accelerator = g_hash_table_lookup(entry_ht, entries[i].path);
+		if (accelerator) {
+		    if (accelerator[0] == '\0')
+			    entries[i].accelerator = NULL;
+		    else
+			    entries[i].accelerator = accelerator;
+		}
+	    }
+    gtk_menu_factory_add_entries(factory, entries, nmenu_entries);
+    
+    for (i = 0; i < nmenu_entries; i++)
+	    if (entries[i].widget) {
+		gtk_signal_connect(GTK_OBJECT(entries[i].widget), "install_accelerator",
+				   (GtkSignalFunc) menus_install_accel,
+				   entries[i].path);
+		gtk_signal_connect(GTK_OBJECT(entries[i].widget), "remove_accelerator",
+				   (GtkSignalFunc) menus_remove_accel,
+				   entries[i].path);
+	    }
+}
+
+static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path)
+{
+    char accel[64];
+    char *t1, t2[2];
+    
+    accel[0] = '\0';
+    if (modifiers & GDK_CONTROL_MASK)
+	    strcat(accel, "<control>");
+    if (modifiers & GDK_SHIFT_MASK)
+	    strcat(accel, "<shift>");
+    if (modifiers & GDK_MOD1_MASK)
+	    strcat(accel, "<alt>");
+    
+    t2[0] = key;
+    t2[1] = '\0';
+    strcat(accel, t2);
+    
+    if (entry_ht) {
+	t1 = g_hash_table_lookup(entry_ht, path);
+	g_free(t1);
+    } else
+	    entry_ht = g_hash_table_new(g_str_hash, g_str_equal);
+    
+    g_hash_table_insert(entry_ht, path, g_strdup(accel));
+    
+    return TRUE;
+}
+
+static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path)
+{
+    char *t;
+    
+    if (entry_ht) {
+	t = g_hash_table_lookup(entry_ht, path);
+	g_free(t);
+	
+	g_hash_table_insert(entry_ht, path, g_strdup(""));
+    }
+}
+
+void menus_set_sensitive(char *path, int sensitive)
+{
+    GtkMenuPath *menu_path;
+    
+    if (initialize)
+	    menus_init();
+    
+    menu_path = gtk_menu_factory_find(factory, path);
+    if (menu_path)
+	    gtk_widget_set_sensitive(menu_path->widget, sensitive);
+    else
+	    g_warning("Unable to set sensitivity for menu which doesn't exist: %s", path);
+}
diff --git a/examples/menu/menufactory.h b/examples/menu/menufactory.h
new file mode 100644
index 0000000000..e1569dae4c
--- /dev/null
+++ b/examples/menu/menufactory.h
@@ -0,0 +1,19 @@
+/* This file extracted from the GTK tutorial. */
+
+/* menufactory.h */
+
+#ifndef __MENUFACTORY_H__
+#define __MENUFACTORY_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+void get_main_menu (GtkWidget **menubar, GtkAcceleratorTable **table);
+void menus_create(GtkMenuEntry *entries, int nmenu_entries);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MENUFACTORY_H__ */
diff --git a/examples/menu/mfmain.c b/examples/menu/mfmain.c
new file mode 100644
index 0000000000..cbe0c58408
--- /dev/null
+++ b/examples/menu/mfmain.c
@@ -0,0 +1,52 @@
+/* This file extracted from the GTK tutorial. */
+
+/* mfmain.c */
+
+#include <gtk/gtk.h>
+
+#include "mfmain.h"
+#include "menufactory.h"
+
+
+int main(int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *main_vbox;
+    GtkWidget *menubar;
+    
+    GtkAcceleratorTable *accel;
+    
+    gtk_init(&argc, &argv);
+    
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_signal_connect(GTK_OBJECT(window), "destroy", 
+		       GTK_SIGNAL_FUNC(file_quit_cmd_callback), 
+		       "WM destroy");
+    gtk_window_set_title(GTK_WINDOW(window), "Menu Factory");
+    gtk_widget_set_usize(GTK_WIDGET(window), 300, 200);
+    
+    main_vbox = gtk_vbox_new(FALSE, 1);
+    gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
+    gtk_container_add(GTK_CONTAINER(window), main_vbox);
+    gtk_widget_show(main_vbox);
+    
+    get_main_menu(&menubar, &accel);
+    gtk_window_add_accelerator_table(GTK_WINDOW(window), accel);
+    gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
+    gtk_widget_show(menubar);
+    
+    gtk_widget_show(window);
+    gtk_main();
+    
+    return(0);
+}
+
+/* This is just to demonstrate how callbacks work when using the
+ * menufactory.  Often, people put all the callbacks from the menus
+ * in a separate file, and then have them call the appropriate functions
+ * from there.  Keeps it more organized. */
+void file_quit_cmd_callback (GtkWidget *widget, gpointer data)
+{
+    g_print ("%s\n", (char *) data);
+    gtk_exit(0);
+}
diff --git a/examples/menu/mfmain.h b/examples/menu/mfmain.h
new file mode 100644
index 0000000000..fe481b0c1f
--- /dev/null
+++ b/examples/menu/mfmain.h
@@ -0,0 +1,19 @@
+/* This file extracted from the GTK tutorial. */
+
+/* mfmain.h */
+
+#ifndef __MFMAIN_H__
+#define __MFMAIN_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+void file_quit_cmd_callback(GtkWidget *widget, gpointer data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MFMAIN_H__ */
diff --git a/examples/notebook/Makefile b/examples/notebook/Makefile
new file mode 100644
index 0000000000..2b676aee20
--- /dev/null
+++ b/examples/notebook/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+notebook: notebook.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` notebook.c -o notebook
+
+clean: 
+	rm -f *.o notebook
diff --git a/examples/notebook/notebook.c b/examples/notebook/notebook.c
new file mode 100644
index 0000000000..f7e06d38f7
--- /dev/null
+++ b/examples/notebook/notebook.c
@@ -0,0 +1,174 @@
+/* This file extracted from the GTK tutorial. */
+
+/* notebook.c */
+
+#include <gtk/gtk.h>
+
+/* This function rotates the position of the tabs */
+void rotate_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
+}
+
+/* Add/Remove the page tabs and the borders */
+void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gint tval = FALSE;
+    gint bval = FALSE;
+    if (notebook->show_tabs == 0)
+	    tval = TRUE; 
+    if (notebook->show_border == 0)
+	    bval = TRUE;
+    
+    gtk_notebook_set_show_tabs (notebook, tval);
+    gtk_notebook_set_show_border (notebook, bval);
+}
+
+/* Remove a page from the notebook */
+void remove_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gint page;
+    
+    page = gtk_notebook_current_page(notebook);
+    gtk_notebook_remove_page (notebook, page);
+    /* Need to refresh the widget -- 
+     This forces the widget to redraw itself. */
+    gtk_widget_draw(GTK_WIDGET(notebook), NULL);
+}
+
+void delete (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *table;
+    GtkWidget *notebook;
+    GtkWidget *frame;
+    GtkWidget *label;
+    GtkWidget *checkbutton;
+    int i;
+    char bufferf[32];
+    char bufferl[32];
+    
+    gtk_init (&argc, &argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    table = gtk_table_new(2,6,TRUE);
+    gtk_container_add (GTK_CONTAINER (window), table);
+    
+    /* Create a new notebook, place the position of the tabs */
+    notebook = gtk_notebook_new ();
+    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
+    gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
+    gtk_widget_show(notebook);
+    
+    /* lets append a bunch of pages to the notebook */
+    for (i=0; i < 5; i++) {
+	sprintf(bufferf, "Append Frame %d", i+1);
+	sprintf(bufferl, "Page %d", i+1);
+	
+	frame = gtk_frame_new (bufferf);
+	gtk_container_border_width (GTK_CONTAINER (frame), 10);
+	gtk_widget_set_usize (frame, 100, 75);
+	gtk_widget_show (frame);
+	
+	label = gtk_label_new (bufferf);
+	gtk_container_add (GTK_CONTAINER (frame), label);
+	gtk_widget_show (label);
+	
+	label = gtk_label_new (bufferl);
+	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
+    }
+    
+    
+    /* now lets add a page to a specific spot */
+    checkbutton = gtk_check_button_new_with_label ("Check me please!");
+    gtk_widget_set_usize(checkbutton, 100, 75);
+    gtk_widget_show (checkbutton);
+    
+    label = gtk_label_new ("Add spot");
+    gtk_container_add (GTK_CONTAINER (checkbutton), label);
+    gtk_widget_show (label);
+    label = gtk_label_new ("Add page");
+    gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
+    
+    /* Now finally lets prepend pages to the notebook */
+    for (i=0; i < 5; i++) {
+	sprintf(bufferf, "Prepend Frame %d", i+1);
+	sprintf(bufferl, "PPage %d", i+1);
+	
+	frame = gtk_frame_new (bufferf);
+	gtk_container_border_width (GTK_CONTAINER (frame), 10);
+	gtk_widget_set_usize (frame, 100, 75);
+	gtk_widget_show (frame);
+	
+	label = gtk_label_new (bufferf);
+	gtk_container_add (GTK_CONTAINER (frame), label);
+	gtk_widget_show (label);
+	
+	label = gtk_label_new (bufferl);
+	gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
+    }
+    
+    /* Set what page to start at (page 4) */
+    gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);
+    
+    
+    /* create a bunch of buttons */
+    button = gtk_button_new_with_label ("close");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (delete), NULL);
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("next page");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_notebook_next_page,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("prev page");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_notebook_prev_page,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("tab position");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("tabs/border on/off");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) tabsborder_book,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("remove page");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) remove_book,
+			       GTK_OBJECT(notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
+    gtk_widget_show(button);
+    
+    gtk_widget_show(table);
+    gtk_widget_show(window);
+    
+    gtk_main ();
+    
+    return 0;
+}
diff --git a/examples/packbox/Makefile b/examples/packbox/Makefile
new file mode 100644
index 0000000000..0c72412366
--- /dev/null
+++ b/examples/packbox/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+packbox: packbox.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` packbox.c -o packbox
+
+clean: 
+	rm -f *.o packbox
diff --git a/examples/packbox/packbox.c b/examples/packbox/packbox.c
new file mode 100644
index 0000000000..009d33b557
--- /dev/null
+++ b/examples/packbox/packbox.c
@@ -0,0 +1,285 @@
+/* This file extracted from the GTK tutorial. */
+
+/* packbox.c */
+
+#include "gtk/gtk.h"
+
+void
+delete_event (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+/* 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 destroy 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_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 = FALSE, 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 are 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 destroy the window.  Remember that this will send
+     * the "destroy" signal to the window which will be caught by our signal
+     * handler as defined above. */
+    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;
+}
diff --git a/examples/pixmap/Makefile b/examples/pixmap/Makefile
new file mode 100644
index 0000000000..c3cd24cb69
--- /dev/null
+++ b/examples/pixmap/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+pixmap: pixmap.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` pixmap.c -o pixmap
+
+clean: 
+	rm -f *.o pixmap
diff --git a/examples/pixmap/pixmap.c b/examples/pixmap/pixmap.c
new file mode 100644
index 0000000000..4a4c295002
--- /dev/null
+++ b/examples/pixmap/pixmap.c
@@ -0,0 +1,85 @@
+/* This file extracted from the GTK tutorial. */
+
+/* pixmap.c */
+
+#include <gtk/gtk.h>
+
+
+/* XPM data of Open-File icon */
+static const char * xpm_data[] = {
+"16 16 3 1",
+"       c None",
+".      c #000000000000",
+"X      c #FFFFFFFFFFFF",
+"                ",
+"   ......       ",
+"   .XXX.X.      ",
+"   .XXX.XX.     ",
+"   .XXX.XXX.    ",
+"   .XXX.....    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .........    ",
+"                ",
+"                "};
+
+
+/* when invoked (via signal delete_event), terminates the application.
+ */
+void close_application( GtkWidget *widget, gpointer *data ) {
+    gtk_main_quit();
+}
+
+
+/* is invoked when the button is clicked.  It just prints a message.
+ */
+void button_clicked( GtkWidget *widget, gpointer *data ) {
+    printf( "button clicked\n" );
+}
+
+int main( int argc, char *argv[] )
+{
+    /* GtkWidget is the storage type for widgets */
+    GtkWidget *window, *pixmapwid, *button;
+    GdkPixmap *pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+    
+    /* create the main window, and attach delete_event signal to terminating
+       the application */
+    gtk_init( &argc, &argv );
+    window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
+    gtk_signal_connect( GTK_OBJECT (window), "delete_event",
+                        GTK_SIGNAL_FUNC (close_application), NULL );
+    gtk_container_border_width( GTK_CONTAINER (window), 10 );
+    gtk_widget_show( window );
+
+    /* now for the pixmap from gdk */
+    style = gtk_widget_get_style( window );
+    pixmap = gdk_pixmap_create_from_xpm_d( window->window,  &mask,
+                                           &style->bg[GTK_STATE_NORMAL],
+                                           (gchar **)xpm_data );
+
+    /* a pixmap widget to contain the pixmap */
+    pixmapwid = gtk_pixmap_new( pixmap, mask );
+    gtk_widget_show( pixmapwid );
+
+    /* a button to contain the pixmap widget */
+    button = gtk_button_new();
+    gtk_container_add( GTK_CONTAINER(button), pixmapwid );
+    gtk_container_add( GTK_CONTAINER(window), button );
+    gtk_widget_show( button );
+
+    gtk_signal_connect( GTK_OBJECT(button), "clicked",
+                        GTK_SIGNAL_FUNC(button_clicked), NULL );
+
+    /* show the window */
+    gtk_main ();
+          
+    return 0;
+}
diff --git a/examples/progressbar/Makefile b/examples/progressbar/Makefile
new file mode 100644
index 0000000000..0379710345
--- /dev/null
+++ b/examples/progressbar/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+progressbar: progressbar.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` progressbar.c -o progressbar
+
+clean: 
+	rm -f *.o progressbar
diff --git a/examples/progressbar/progressbar.c b/examples/progressbar/progressbar.c
new file mode 100644
index 0000000000..2494b66fe0
--- /dev/null
+++ b/examples/progressbar/progressbar.c
@@ -0,0 +1,93 @@
+/* This file extracted from the GTK tutorial. */
+
+/* progressbar.c */
+
+#include <gtk/gtk.h>
+
+static int ptimer = 0;
+int pstat = TRUE;
+
+/* This function increments and updates the progress bar, it also resets
+ the progress bar if pstat is FALSE */
+gint progress (gpointer data)
+{
+    gfloat pvalue;
+    
+    /* get the current value of the progress bar */
+    pvalue = GTK_PROGRESS_BAR (data)->percentage;
+    
+    if ((pvalue >= 1.0) || (pstat == FALSE)) {
+	pvalue = 0.0;
+	pstat = TRUE;
+    }
+    pvalue += 0.01;
+    
+    gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
+    
+    return TRUE;
+}
+
+/* This function signals a reset of the progress bar */
+void progress_r (void)
+{  
+    pstat = FALSE;  
+}
+
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *label;
+    GtkWidget *table;
+    GtkWidget *pbar;
+    
+    gtk_init (&argc, &argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    table = gtk_table_new(3,2,TRUE);
+    gtk_container_add (GTK_CONTAINER (window), table);
+    
+    label = gtk_label_new ("Progress Bar Example");
+    gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
+    gtk_widget_show(label);
+    
+    /* Create a new progress bar, pack it into the table, and show it */
+    pbar = gtk_progress_bar_new ();
+    gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
+    gtk_widget_show (pbar);
+    
+    /* Set the timeout to handle automatic updating of the progress bar */
+    ptimer = gtk_timeout_add (100, progress, pbar);
+    
+    /* This button signals the progress bar to be reset */
+    button = gtk_button_new_with_label ("Reset");
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (progress_r), NULL);
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Cancel");
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
+    gtk_widget_show (button);
+    
+    gtk_widget_show(table);
+    gtk_widget_show(window);
+    
+    gtk_main ();
+    
+    return 0;
+}
diff --git a/examples/radiobuttons/Makefile b/examples/radiobuttons/Makefile
new file mode 100644
index 0000000000..96d0a19ca2
--- /dev/null
+++ b/examples/radiobuttons/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+radiobuttons: radiobuttons.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` radiobuttons.c -o radiobuttons
+
+clean: 
+	rm -f *.o radiobuttons
diff --git a/examples/radiobuttons/radiobuttons.c b/examples/radiobuttons/radiobuttons.c
new file mode 100644
index 0000000000..88038acc2f
--- /dev/null
+++ b/examples/radiobuttons/radiobuttons.c
@@ -0,0 +1,76 @@
+/* This file extracted from the GTK tutorial. */
+
+/* radiobuttons.c */
+
+#include <gtk/gtk.h>
+#include <glib.h>
+
+void close_application( GtkWidget *widget, gpointer *data ) {
+  gtk_main_quit();
+}
+
+int main(int argc,char *argv[])
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *box1;
+  GtkWidget *box2;
+  GtkWidget *button;
+  GtkWidget *separator;
+  GSList *group;
+  
+  gtk_init(&argc,&argv);          
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  
+  gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+		      GTK_SIGNAL_FUNC(close_application),
+		      NULL);
+
+  gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
+  gtk_container_border_width (GTK_CONTAINER (window), 0);
+
+  box1 = gtk_vbox_new (FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (window), box1);
+  gtk_widget_show (box1);
+
+  box2 = gtk_vbox_new (FALSE, 10);
+  gtk_container_border_width (GTK_CONTAINER (box2), 10);
+  gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
+  gtk_widget_show (box2);
+
+  button = gtk_radio_button_new_with_label (NULL, "button1");
+  gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+  gtk_widget_show (button);
+
+  group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
+  button = gtk_radio_button_new_with_label(group, "button2");
+  gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+  gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+  gtk_widget_show (button);
+
+  group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
+  button = gtk_radio_button_new_with_label(group, "button3");
+  gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+  gtk_widget_show (button);
+
+  separator = gtk_hseparator_new ();
+  gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
+  gtk_widget_show (separator);
+
+  box2 = gtk_vbox_new (FALSE, 10);
+  gtk_container_border_width (GTK_CONTAINER (box2), 10);
+  gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
+  gtk_widget_show (box2);
+
+  button = gtk_button_new_with_label ("close");
+  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			     GTK_SIGNAL_FUNC(close_application),
+			     GTK_OBJECT (window));
+  gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+  GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+  gtk_widget_grab_default (button);
+  gtk_widget_show (button);
+  gtk_widget_show (window);
+          
+  gtk_main();
+  return(0);
+}
diff --git a/examples/rulers/Makefile b/examples/rulers/Makefile
new file mode 100644
index 0000000000..f304afcd9b
--- /dev/null
+++ b/examples/rulers/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+rulers: rulers.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` rulers.c -o rulers
+
+clean: 
+	rm -f *.o rulers
diff --git a/examples/rulers/rulers.c b/examples/rulers/rulers.c
new file mode 100644
index 0000000000..ebefa14776
--- /dev/null
+++ b/examples/rulers/rulers.c
@@ -0,0 +1,75 @@
+/* This file extracted from the GTK tutorial. */
+
+/* rulers.c */
+
+#include <gtk/gtk.h>
+
+#define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x
+
+#define XSIZE  600
+#define YSIZE  400
+
+/* this routine gets control when the close button is clicked
+ */
+void close_application( GtkWidget *widget, gpointer *data ) {
+    gtk_main_quit();
+}
+
+
+/* the main routine
+ */
+int main( int argc, char *argv[] ) {
+    GtkWidget *window, *table, *area, *hrule, *vrule;
+
+    /* initialize gtk and create the main window */
+    gtk_init( &argc, &argv );
+
+    window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+            GTK_SIGNAL_FUNC( close_application ), NULL);
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+    /* create a table for placing the ruler and the drawing area */
+    table = gtk_table_new( 3, 2, FALSE );
+    gtk_container_add( GTK_CONTAINER(window), table );
+
+    area = gtk_drawing_area_new();
+    gtk_drawing_area_size( (GtkDrawingArea *)area, XSIZE, YSIZE );
+    gtk_table_attach( GTK_TABLE(table), area, 1, 2, 1, 2,
+                      GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0 );
+    gtk_widget_set_events( area, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK );
+
+    /* The horizontal ruler goes on top.  As the mouse moves across the drawing area,
+       a motion_notify_event is passed to the appropriate event handler for the ruler. */
+    hrule = gtk_hruler_new();
+    gtk_ruler_set_metric( GTK_RULER(hrule), GTK_PIXELS );
+    gtk_ruler_set_range( GTK_RULER(hrule), 7, 13, 0, 20 );
+    gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
+                               (GtkSignalFunc)EVENT_METHOD(hrule, motion_notify_event),
+                               GTK_OBJECT(hrule) );
+    /*  GTK_WIDGET_CLASS(GTK_OBJECT(hrule)->klass)->motion_notify_event, */
+    gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
+                      GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );
+    
+    /* The vertical ruler goes on the left.  As the mouse moves across the drawing area,
+       a motion_notify_event is passed to the appropriate event handler for the ruler. */
+    vrule = gtk_vruler_new();
+    gtk_ruler_set_metric( GTK_RULER(vrule), GTK_PIXELS );
+    gtk_ruler_set_range( GTK_RULER(vrule), 0, YSIZE, 10, YSIZE );
+    gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
+                               (GtkSignalFunc)
+                                  GTK_WIDGET_CLASS(GTK_OBJECT(vrule)->klass)->motion_notify_event,
+                               GTK_OBJECT(vrule) );
+    gtk_table_attach( GTK_TABLE(table), vrule, 0, 1, 1, 2,
+                      GTK_FILL, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0 );
+
+    /* now show everything */
+    gtk_widget_show( area );
+    gtk_widget_show( hrule );
+    gtk_widget_show( vrule );
+    gtk_widget_show( table );
+    gtk_widget_show( window );
+    gtk_main();
+
+    return 0;
+}
diff --git a/examples/scrolledwin/Makefile b/examples/scrolledwin/Makefile
new file mode 100644
index 0000000000..d35a03a55b
--- /dev/null
+++ b/examples/scrolledwin/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+scrolledwin: scrolledwin.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` scrolledwin.c -o scrolledwin
+
+clean: 
+	rm -f *.o scrolledwin
diff --git a/examples/scrolledwin/scrolledwin.c b/examples/scrolledwin/scrolledwin.c
new file mode 100644
index 0000000000..9ec879e4c4
--- /dev/null
+++ b/examples/scrolledwin/scrolledwin.c
@@ -0,0 +1,94 @@
+/* This file extracted from the GTK tutorial. */
+
+/* scrolledwin.c */
+
+#include <gtk/gtk.h>
+
+void destroy(GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit();
+}
+
+int main (int argc, char *argv[])
+{
+    static GtkWidget *window;
+    GtkWidget *scrolled_window;
+    GtkWidget *table;
+    GtkWidget *button;
+    char buffer[32];
+    int i, j;
+    
+    gtk_init (&argc, &argv);
+    
+    /* Create a new dialog window for the scrolled window to be
+     * packed into.  A dialog is just like a normal window except it has a 
+     * vbox and a horizontal seperator packed into it.  It's just a shortcut
+     * for creating dialogs */
+    window = gtk_dialog_new ();
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			(GtkSignalFunc) destroy, NULL);
+    gtk_window_set_title (GTK_WINDOW (window), "dialog");
+    gtk_container_border_width (GTK_CONTAINER (window), 0);
+    gtk_widget_set_usize(window, 300, 300);
+    
+    /* create a new scrolled window. */
+    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
+    
+    /* the policy is one of GTK_POLICY AUTOMATIC, or GTK_POLICY_ALWAYS.
+     * GTK_POLICY_AUTOMATIC will automatically decide whether you need
+     * scrollbars, wheras GTK_POLICY_ALWAYS will always leave the scrollbars
+     * there.  The first one is the horizontal scrollbar, the second, 
+     * the vertical. */
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+    /* The dialog window is created with a vbox packed into it. */								
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window, 
+			TRUE, TRUE, 0);
+    gtk_widget_show (scrolled_window);
+    
+    /* create a table of 10 by 10 squares. */
+    table = gtk_table_new (10, 10, FALSE);
+    
+    /* set the spacing to 10 on x and 10 on y */
+    gtk_table_set_row_spacings (GTK_TABLE (table), 10);
+    gtk_table_set_col_spacings (GTK_TABLE (table), 10);
+    
+    /* pack the table into the scrolled window */
+    gtk_container_add (GTK_CONTAINER (scrolled_window), table);
+    gtk_widget_show (table);
+    
+    /* this simply creates a grid of toggle buttons on the table
+     * to demonstrate the scrolled window. */
+    for (i = 0; i < 10; i++)
+	    for (j = 0; j < 10; j++) {
+		sprintf (buffer, "button (%d,%d)\n", i, j);
+		button = gtk_toggle_button_new_with_label (buffer);
+		gtk_table_attach_defaults (GTK_TABLE (table), button,
+					   i, i+1, j, j+1);
+		gtk_widget_show (button);
+	    }
+    
+    /* Add a "close" button to the bottom of the dialog */
+    button = gtk_button_new_with_label ("close");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_widget_destroy,
+			       GTK_OBJECT (window));
+    
+    /* this makes it so the button is the default. */
+    
+    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
+    
+    /* This grabs this button to be the default button. Simply hitting
+     * the "Enter" key will cause this button to activate. */
+    gtk_widget_grab_default (button);
+    gtk_widget_show (button);
+    
+    gtk_widget_show (window);
+    
+    gtk_main();
+    
+    return(0);
+}
diff --git a/examples/selection/Makefile b/examples/selection/Makefile
new file mode 100644
index 0000000000..de7aaf708a
--- /dev/null
+++ b/examples/selection/Makefile
@@ -0,0 +1,13 @@
+
+CC = gcc
+
+all: gettargets setselection
+
+gettargets: gettargets.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` gettargets.c -o gettargets
+
+setselection: setselection.c
+	$(CC) `gtk-config --cflags` `gtk-config --libs` setselection.c -o setselection
+ 
+clean: 
+	rm -f *.o gettargets setselection
diff --git a/examples/selection/gettargets.c b/examples/selection/gettargets.c
new file mode 100644
index 0000000000..47f7adbb7c
--- /dev/null
+++ b/examples/selection/gettargets.c
@@ -0,0 +1,98 @@
+/* This file extracted from the GTK tutorial. */
+
+/* gettargets.c */
+
+#include <gtk/gtk.h>
+
+void selection_received (GtkWidget *widget, 
+			 GtkSelectionData *selection_data, 
+			 gpointer data);
+
+/* Signal handler invoked when user clicks on the "Get Targets" button */
+void
+get_targets (GtkWidget *widget, gpointer data)
+{
+  static GdkAtom targets_atom = GDK_NONE;
+
+  /* Get the atom corresonding to the string "TARGETS" */
+  if (targets_atom == GDK_NONE)
+    targets_atom = gdk_atom_intern ("TARGETS", FALSE);
+
+  /* And request the "TARGETS" target for the primary selection */
+  gtk_selection_convert (widget, GDK_SELECTION_PRIMARY, targets_atom,
+			 GDK_CURRENT_TIME);
+}
+
+/* Signal handler called when the selections owner returns the data */
+void
+selection_received (GtkWidget *widget, GtkSelectionData *selection_data, 
+		    gpointer data)
+{
+  GdkAtom *atoms;
+  GList *item_list;
+  int i;
+
+  /* **** IMPORTANT **** Check to see if retrieval succeeded  */
+  if (selection_data->length < 0)
+    {
+      g_print ("Selection retrieval failed\n");
+      return;
+    }
+  /* Make sure we got the data in the expected form */
+  if (selection_data->type != GDK_SELECTION_TYPE_ATOM)
+    {
+      g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
+      return;
+    }
+  
+  /* Print out the atoms we received */
+  atoms = (GdkAtom *)selection_data->data;
+
+  item_list = NULL;
+  for (i=0; i<selection_data->length/sizeof(GdkAtom); i++)
+    {
+      char *name;
+      name = gdk_atom_name (atoms[i]);
+      if (name != NULL)
+	g_print ("%s\n",name);
+      else
+	g_print ("(bad atom)\n");
+    }
+
+  return;
+}
+
+int 
+main (int argc, char *argv[])
+{
+  GtkWidget *window;
+  GtkWidget *button;
+  
+  gtk_init (&argc, &argv);
+
+  /* Create the toplevel window */
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Event Box");
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+  /* Create a button the user can click to get targets */
+
+  button = gtk_button_new_with_label ("Get Targets");
+  gtk_container_add (GTK_CONTAINER (window), button);
+
+  gtk_signal_connect (GTK_OBJECT(button), "clicked",
+		      GTK_SIGNAL_FUNC (get_targets), NULL);
+  gtk_signal_connect (GTK_OBJECT(button), "selection_received",
+		      GTK_SIGNAL_FUNC (selection_received), NULL);
+
+  gtk_widget_show (button);
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
diff --git a/examples/selection/setselection.c b/examples/selection/setselection.c
new file mode 100644
index 0000000000..c3e784b8ab
--- /dev/null
+++ b/examples/selection/setselection.c
@@ -0,0 +1,106 @@
+/* This file extracted from the GTK tutorial. */
+
+/* setselection.c */
+
+#include <gtk/gtk.h>
+#include <time.h>
+
+/* Callback when the user toggles the selection */
+void
+selection_toggled (GtkWidget *widget, gint *have_selection)
+{
+  if (GTK_TOGGLE_BUTTON(widget)->active)
+    {
+      *have_selection = gtk_selection_owner_set (widget,
+						 GDK_SELECTION_PRIMARY,
+						 GDK_CURRENT_TIME);
+      /* if claiming the selection failed, we return the button to
+	 the out state */
+      if (!*have_selection)
+	gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
+    }
+  else
+    {
+      if (*have_selection)
+	{
+	  /* Before clearing the selection by setting the owner to NULL,
+	     we check if we are the actual owner */
+	  if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
+	    gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY,
+				     GDK_CURRENT_TIME);
+	  *have_selection = FALSE;
+	}
+    }
+}
+
+/* Called when another application claims the selection */
+gint
+selection_clear (GtkWidget *widget, GdkEventSelection *event,
+		 gint *have_selection)
+{
+  *have_selection = FALSE;
+  gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
+
+  return TRUE;
+}
+
+/* Supplies the current time as the selection. */
+void
+selection_handle (GtkWidget *widget, 
+		  GtkSelectionData *selection_data,
+		  gpointer data)
+{
+  gchar *timestr;
+  time_t current_time;
+
+  current_time = time (NULL);
+  timestr = asctime (localtime(&current_time)); 
+  /* When we return a single string, it should not be null terminated.
+     That will be done for us */
+
+  gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
+			  8, timestr, strlen(timestr));
+}
+
+int
+main (int argc, char *argv[])
+{
+  GtkWidget *window;
+
+  GtkWidget *selection_button;
+
+  static int have_selection = FALSE;
+  
+  gtk_init (&argc, &argv);
+
+  /* Create the toplevel window */
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Event Box");
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+  /* Create a toggle button to act as the selection */
+
+  selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
+  gtk_container_add (GTK_CONTAINER (window), selection_button);
+  gtk_widget_show (selection_button);
+
+  gtk_signal_connect (GTK_OBJECT(selection_button), "toggled",
+		      GTK_SIGNAL_FUNC (selection_toggled), &have_selection);
+  gtk_signal_connect (GTK_OBJECT(selection_button), "selection_clear_event",
+		      GTK_SIGNAL_FUNC (selection_clear), &have_selection);
+
+  gtk_selection_add_handler (selection_button, GDK_SELECTION_PRIMARY,
+			     GDK_SELECTION_TYPE_STRING,
+			     selection_handle, NULL);
+
+  gtk_widget_show (selection_button);
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
diff --git a/examples/statusbar/Makefile b/examples/statusbar/Makefile
new file mode 100644
index 0000000000..bedfd77ef5
--- /dev/null
+++ b/examples/statusbar/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+statusbar: statusbar.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` statusbar.c -o statusbar
+
+clean: 
+	rm -f *.o statusbar
diff --git a/examples/statusbar/statusbar.c b/examples/statusbar/statusbar.c
new file mode 100644
index 0000000000..f4d96e5695
--- /dev/null
+++ b/examples/statusbar/statusbar.c
@@ -0,0 +1,74 @@
+/* This file extracted from the GTK tutorial. */
+
+/* statusbar.c (Tony Gale) */
+
+#include <gtk/gtk.h>
+#include <glib.h>
+
+GtkWidget *status_bar;
+
+void push_item (GtkWidget *widget, gpointer *data)
+{
+  static int count = 1;
+  char buff[20];
+
+  g_snprintf(buff, 20, "Item %d", count++);
+  gtk_statusbar_push( GTK_STATUSBAR(status_bar), (guint) &data, buff);
+
+  return;
+}
+
+void pop_item (GtkWidget *widget, gpointer *data)
+{
+  gtk_statusbar_pop( GTK_STATUSBAR(status_bar), (guint) &data );
+  return;
+}
+
+int main (int argc, char *argv[])
+{
+
+    GtkWidget *window;
+    GtkWidget *vbox;
+    GtkWidget *button;
+
+    int context_id;
+
+    gtk_init (&argc, &argv);
+
+    /* create a new window */
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
+    gtk_window_set_title(GTK_WINDOW (window), "GTK Statusbar Example");
+    gtk_signal_connect(GTK_OBJECT (window), "delete_event",
+                       (GtkSignalFunc) gtk_exit, NULL);
+ 
+    vbox = gtk_vbox_new(FALSE, 1);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+    gtk_widget_show(vbox);
+          
+    status_bar = gtk_statusbar_new();      
+    gtk_box_pack_start (GTK_BOX (vbox), status_bar, TRUE, TRUE, 0);
+    gtk_widget_show (status_bar);
+
+    context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR(status_bar), "Statusbar example");
+
+    button = gtk_button_new_with_label("push item");
+    gtk_signal_connect(GTK_OBJECT(button), "clicked",
+        GTK_SIGNAL_FUNC (push_item), &context_id);
+    gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
+    gtk_widget_show(button);              
+
+    button = gtk_button_new_with_label("pop last item");
+    gtk_signal_connect(GTK_OBJECT(button), "clicked",
+        GTK_SIGNAL_FUNC (pop_item), &context_id);
+    gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
+    gtk_widget_show(button);              
+
+    /* always display the window as the last step so it all splashes on
+     * the screen at once. */
+    gtk_widget_show(window);
+
+    gtk_main ();
+
+    return 0;
+}
diff --git a/examples/table/Makefile b/examples/table/Makefile
new file mode 100644
index 0000000000..550c82036a
--- /dev/null
+++ b/examples/table/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+table: table.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` table.c -o table
+
+clean: 
+	rm -f *.o table
diff --git a/examples/table/table.c b/examples/table/table.c
new file mode 100644
index 0000000000..3243ae2965
--- /dev/null
+++ b/examples/table/table.c
@@ -0,0 +1,94 @@
+/* This file extracted from the GTK tutorial. */
+
+/* table.c */
+#include <gtk/gtk.h>
+
+/* our callback.
+ * the data passed to this function is printed to stdout */
+void callback (GtkWidget *widget, gpointer *data)
+{
+    g_print ("Hello again - %s was pressed\n", (char *) data);
+}
+
+/* this callback quits the program */
+void delete_event (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *table;
+
+    gtk_init (&argc, &argv);
+
+    /* create a new window */
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+    /* set the window title */
+    gtk_window_set_title (GTK_WINDOW (window), "Table");
+
+    /* set a handler for delete_event that immediately
+     * exits GTK. */
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+                        GTK_SIGNAL_FUNC (delete_event), NULL);
+
+    /* sets the border width of the window. */
+    gtk_container_border_width (GTK_CONTAINER (window), 20);
+
+    /* create a 2x2 table */
+    table = gtk_table_new (2, 2, TRUE);
+
+    /* put the table in the main window */
+    gtk_container_add (GTK_CONTAINER (window), table);
+
+    /* create first button */
+    button = gtk_button_new_with_label ("button 1");
+
+    /* when the button is clicked, we call the "callback" function
+     * with a pointer to "button 1" as it's argument */
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+              GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");
+
+
+    /* insert button 1 into the upper left quadrant of the table */
+    gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1);
+
+    gtk_widget_show (button);
+
+    /* create second button */
+
+    button = gtk_button_new_with_label ("button 2");
+
+    /* when the button is clicked, we call the "callback" function
+     * with a pointer to "button 2" as it's argument */
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+              GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
+    /* insert button 2 into the upper right quadrant of the table */
+    gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1);
+
+    gtk_widget_show (button);
+
+    /* create "Quit" button */
+    button = gtk_button_new_with_label ("Quit");
+
+    /* when the button is clicked, we call the "delete_event" function
+     * and the program exits */
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+                        GTK_SIGNAL_FUNC (delete_event), NULL);
+
+    /* insert the quit button into the both 
+     * lower quadrants of the table */
+    gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2);
+
+    gtk_widget_show (button);
+
+    gtk_widget_show (table);
+    gtk_widget_show (window);
+
+    gtk_main ();
+
+    return 0;
+}
diff --git a/examples/wheelbarrow/Makefile b/examples/wheelbarrow/Makefile
new file mode 100644
index 0000000000..e2a7cac8a9
--- /dev/null
+++ b/examples/wheelbarrow/Makefile
@@ -0,0 +1,8 @@
+
+CC = gcc
+
+wheelbarrow: wheelbarrow.c 
+	$(CC) `gtk-config --cflags` `gtk-config --libs` wheelbarrow.c -o wheelbarrow
+
+clean: 
+	rm -f *.o wheelbarrow
diff --git a/examples/wheelbarrow/wheelbarrow.c b/examples/wheelbarrow/wheelbarrow.c
new file mode 100644
index 0000000000..3d3a60dd28
--- /dev/null
+++ b/examples/wheelbarrow/wheelbarrow.c
@@ -0,0 +1,173 @@
+/* This file extracted from the GTK tutorial. */
+
+/* wheelbarrow.c */
+
+#include <gtk/gtk.h>
+
+/* XPM */
+static char * WheelbarrowFull_xpm[] = {
+"48 48 64 1",
+"       c None",
+".      c #DF7DCF3CC71B",
+"X      c #965875D669A6",
+"o      c #71C671C671C6",
+"O      c #A699A289A699",
+"+      c #965892489658",
+"@      c #8E38410330C2",
+"#      c #D75C7DF769A6",
+"$      c #F7DECF3CC71B",
+"%      c #96588A288E38",
+"&      c #A69992489E79",
+"*      c #8E3886178E38",
+"=      c #104008200820",
+"-      c #596510401040",
+";      c #C71B30C230C2",
+":      c #C71B9A699658",
+">      c #618561856185",
+",      c #20811C712081",
+"<      c #104000000000",
+"1      c #861720812081",
+"2      c #DF7D4D344103",
+"3      c #79E769A671C6",
+"4      c #861782078617",
+"5      c #41033CF34103",
+"6      c #000000000000",
+"7      c #49241C711040",
+"8      c #492445144924",
+"9      c #082008200820",
+"0      c #69A618611861",
+"q      c #B6DA71C65144",
+"w      c #410330C238E3",
+"e      c #CF3CBAEAB6DA",
+"r      c #71C6451430C2",
+"t      c #EFBEDB6CD75C",
+"y      c #28A208200820",
+"u      c #186110401040",
+"i      c #596528A21861",
+"p      c #71C661855965",
+"a      c #A69996589658",
+"s      c #30C228A230C2",
+"d      c #BEFBA289AEBA",
+"f      c #596545145144",
+"g      c #30C230C230C2",
+"h      c #8E3882078617",
+"j      c #208118612081",
+"k      c #38E30C300820",
+"l      c #30C2208128A2",
+"z      c #38E328A238E3",
+"x      c #514438E34924",
+"c      c #618555555965",
+"v      c #30C2208130C2",
+"b      c #38E328A230C2",
+"n      c #28A228A228A2",
+"m      c #41032CB228A2",
+"M      c #104010401040",
+"N      c #492438E34103",
+"B      c #28A2208128A2",
+"V      c #A699596538E3",
+"C      c #30C21C711040",
+"Z      c #30C218611040",
+"A      c #965865955965",
+"S      c #618534D32081",
+"D      c #38E31C711040",
+"F      c #082000000820",
+"                                                ",
+"          .XoO                                  ",
+"         +@#$%o&                                ",
+"         *=-;#::o+                              ",
+"           >,<12#:34                            ",
+"             45671#:X3                          ",
+"               +89<02qwo                        ",
+"e*                >,67;ro                       ",
+"ty>                 459@>+&&                    ",
+"$2u+                  ><ipas8*                  ",
+"%$;=*                *3:.Xa.dfg>                ",
+"Oh$;ya             *3d.a8j,Xe.d3g8+             ",
+" Oh$;ka          *3d$a8lz,,xxc:.e3g54           ",
+"  Oh$;kO       *pd$%svbzz,sxxxxfX..&wn>         ",
+"   Oh$@mO    *3dthwlsslszjzxxxxxxx3:td8M4       ",
+"    Oh$@g& *3d$XNlvvvlllm,mNwxxxxxxxfa.:,B*     ",
+"     Oh$@,Od.czlllllzlmmqV@V#V@fxxxxxxxf:%j5&   ",
+"      Oh$1hd5lllslllCCZrV#r#:#2AxxxxxxxxxcdwM*  ",
+"       OXq6c.%8vvvllZZiqqApA:mq:Xxcpcxxxxxfdc9* ",
+"        2r<6gde3bllZZrVi7S@SV77A::qApxxxxxxfdcM ",
+"        :,q-6MN.dfmZZrrSS:#riirDSAX@Af5xxxxxfevo",
+"         +A26jguXtAZZZC7iDiCCrVVii7Cmmmxxxxxx%3g",
+"          *#16jszN..3DZZZZrCVSA2rZrV7Dmmwxxxx&en",
+"           p2yFvzssXe:fCZZCiiD7iiZDiDSSZwwxx8e*>",
+"           OA1<jzxwwc:$d%NDZZZZCCCZCCZZCmxxfd.B ",
+"            3206Bwxxszx%et.eaAp77m77mmmf3&eeeg* ",
+"             @26MvzxNzvlbwfpdettttttttttt.c,n&  ",
+"             *;16=lsNwwNwgsvslbwwvccc3pcfu<o    ",
+"              p;<69BvwwsszslllbBlllllllu<5+     ",
+"              OS0y6FBlvvvzvzss,u=Blllj=54       ",
+"               c1-699Blvlllllu7k96MMMg4         ",
+"               *10y8n6FjvllllB<166668           ",
+"                S-kg+>666<M<996-y6n<8*          ",
+"                p71=4 m69996kD8Z-66698&&        ",
+"                &i0ycm6n4 ogk17,0<6666g         ",
+"                 N-k-<>     >=01-kuu666>        ",
+"                 ,6ky&      &46-10ul,66,        ",
+"                 Ou0<>       o66y<ulw<66&       ",
+"                  *kk5       >66By7=xu664       ",
+"                   <<M4      466lj<Mxu66o       ",
+"                   *>>       +66uv,zN666*       ",
+"                              566,xxj669        ",
+"                              4666FF666>        ",
+"                               >966666M         ",
+"                                oM6668+         ",
+"                                  *4            ",
+"                                                ",
+"                                                "};
+
+
+/* when invoked (via signal delete_event), terminates the application.
+ */
+void close_application( GtkWidget *widget, gpointer *data ) {
+    gtk_main_quit();
+}
+
+int main (int argc, char *argv[])
+{
+    /* GtkWidget is the storage type for widgets */
+    GtkWidget *window, *pixmap, *fixed;
+    GdkPixmap *gdk_pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+    GdkGC *gc;
+    
+    /* create the main window, and attach delete_event signal to terminate
+       the application.  Note that the main window will not have a titlebar
+       since we're making it a popup. */
+    gtk_init (&argc, &argv);
+    window = gtk_window_new( GTK_WINDOW_POPUP );
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+                        GTK_SIGNAL_FUNC (close_application), NULL);
+    gtk_widget_show (window);
+
+    /* now for the pixmap and the pixmap widget */
+    style = gtk_widget_get_default_style();
+    gc = style->black_gc;
+    gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
+                                             &style->bg[GTK_STATE_NORMAL],
+                                             WheelbarrowFull_xpm );
+    pixmap = gtk_pixmap_new( gdk_pixmap, mask );
+    gtk_widget_show( pixmap );
+
+    /* To display the pixmap, we use a fixed widget to place the pixmap */
+    fixed = gtk_fixed_new();
+    gtk_widget_set_usize( fixed, 200, 200 );
+    gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
+    gtk_container_add( GTK_CONTAINER(window), fixed );
+    gtk_widget_show( fixed );
+
+    /* This masks out everything except for the image itself */
+    gtk_widget_shape_combine_mask( window, mask, 0, 0 );
+    
+    /* show the window */
+    gtk_widget_set_uposition( window, 20, 400 );
+    gtk_widget_show( window );
+    gtk_main ();
+          
+    return 0;
+}