X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=tests%2Ftestgtk.c;h=fb0e54409e93936d16038a25a50c33178ac96c5a;hb=a516adebbed6d4c7ed9b8b4c3719ae623f989b01;hp=f893412e7222c2ffcad4be0815161af5429b1935;hpb=c860866dd794b8abb0d185802d0a0dd17c5005ac;p=~andy%2Fgtk

diff --git a/tests/testgtk.c b/tests/testgtk.c
index f893412e7..fb0e54409 100644
--- a/tests/testgtk.c
+++ b/tests/testgtk.c
@@ -24,7 +24,9 @@
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
 
-#include "config.h"
+#undef GTK_DISABLE_DEPRECATED
+
+#include <config.h>
 
 #undef	G_LOG_DOMAIN
 
@@ -61,19 +63,20 @@ file_exists (const char *filename)
 }
 
 GtkWidget *
-shape_create_icon (char     *xpm_file,
-		   gint      x,
-		   gint      y,
-		   gint      px,
-		   gint      py,
-		   gint      window_type);
+shape_create_icon (GdkScreen *screen,
+		   char      *xpm_file,
+		   gint       x,
+		   gint       y,
+		   gint       px,
+		   gint       py,
+		   gint       window_type);
 
 static GtkWidget *
-build_option_menu (gchar    *items[],
-		   gint      num_items,
-		   gint      history,
-		   void    (*func)(GtkWidget *widget, gpointer data),
-		   gpointer  data);
+build_option_menu (gchar           *items[],
+		   gint             num_items,
+		   gint             history,
+		   void           (*func)(GtkWidget *widget, gpointer data),
+		   gpointer         data);
 
 /* macro, structure and variables used by tree window demos */
 #define DEFAULT_NUMBER_OF_ITEM  3
@@ -100,11 +103,11 @@ typedef struct sTreeButtons {
 /* end of tree section */
 
 static GtkWidget *
-build_option_menu (gchar     *items[],
-		   gint       num_items,
-		   gint       history,
-		   void     (*func)(GtkWidget *widget, gpointer data),
-		   gpointer   data)
+build_option_menu (gchar           *items[],
+		   gint             num_items,
+		   gint             history,
+		   void           (*func)(GtkWidget *widget, gpointer data),
+		   gpointer         data)
 {
   GtkWidget *omenu;
   GtkWidget *menu;
@@ -113,8 +116,8 @@ build_option_menu (gchar     *items[],
   gint i;
 
   omenu = gtk_option_menu_new ();
-  gtk_signal_connect (GTK_OBJECT (omenu), "changed",
-		      GTK_SIGNAL_FUNC (func), data);
+  g_signal_connect (omenu, "changed",
+		    G_CALLBACK (func), data);
       
   menu = gtk_menu_new ();
   group = NULL;
@@ -122,7 +125,7 @@ build_option_menu (gchar     *items[],
   for (i = 0; i < num_items; i++)
     {
       menu_item = gtk_radio_menu_item_new_with_label (group, items[i]);
-      group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
+      group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menu_item));
       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
       if (i == history)
 	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
@@ -138,8 +141,8 @@ build_option_menu (gchar     *items[],
 static void
 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
 {
-  GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
-  gtk_object_unref (GTK_OBJECT (tt));
+  GtkTooltips *tt = g_object_get_data (G_OBJECT (*window), "tooltips");
+  g_object_unref (tt);
   *window = NULL;
 }
 
@@ -166,7 +169,7 @@ pattern_expose (GtkWidget      *widget,
 			  event->area.x, event->area.y,
 			  event->area.width, event->area.height);
 
-      g_object_unref (G_OBJECT (tmp_gc));
+      g_object_unref (tmp_gc);
     }
 
   return FALSE;
@@ -183,7 +186,7 @@ pattern_set_bg (GtkWidget   *widget,
     { 0, 0xaaaa, 0xaaaa, 0xffff }
   };
     
-  g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer)&colors[level]);
+  g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer) &colors[level]);
   gdk_window_set_user_data (child, widget);
 }
 
@@ -280,7 +283,7 @@ pattern_realize (GtkWidget *widget,
 }
 
 static void 
-create_big_windows (void)
+create_big_windows (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *darea, *table, *scrollbar;
@@ -289,7 +292,7 @@ create_big_windows (void)
   GtkAdjustment *vadj;
   static gint current_x;
   static gint current_y;
-
+ 
   if (!window)
     {
       current_x = 0;
@@ -300,16 +303,19 @@ create_big_windows (void)
                                             GTK_STOCK_CLOSE,
                                             GTK_RESPONSE_NONE,
                                             NULL);
+ 
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
       gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
-      gtk_signal_connect (GTK_OBJECT (window), "response",
-                          GTK_SIGNAL_FUNC (gtk_widget_destroy),
-                          NULL);
+      g_signal_connect (window, "response",
+                        G_CALLBACK (gtk_widget_destroy),
+                        NULL);
 
       table = gtk_table_new (2, 2, FALSE);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
@@ -318,21 +324,21 @@ create_big_windows (void)
       darea = gtk_drawing_area_new ();
 
       hadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
-      gtk_signal_connect (GTK_OBJECT (hadj), "value_changed",
-			  GTK_SIGNAL_FUNC (pattern_hadj_changed), darea);
+      g_signal_connect (hadj, "value_changed",
+			G_CALLBACK (pattern_hadj_changed), darea);
       g_object_set_data (G_OBJECT (hadj), "old-value", &current_x);
       
       vadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
-      gtk_signal_connect (GTK_OBJECT (vadj), "value_changed",
-			  GTK_SIGNAL_FUNC (pattern_vadj_changed), darea);
+      g_signal_connect (vadj, "value_changed",
+			G_CALLBACK (pattern_vadj_changed), darea);
       g_object_set_data (G_OBJECT (vadj), "old-value", &current_y);
       
-      gtk_signal_connect (GTK_OBJECT (darea), "realize",
-                          GTK_SIGNAL_FUNC (pattern_realize),
-                          NULL);
-      gtk_signal_connect (GTK_OBJECT (darea), "expose_event",
-                          GTK_SIGNAL_FUNC (pattern_expose),
-                          NULL);
+      g_signal_connect (darea, "realize",
+                        G_CALLBACK (pattern_realize),
+                        NULL);
+      g_signal_connect (darea, "expose_event",
+                        G_CALLBACK (pattern_expose),
+                        NULL);
 
       eventbox = gtk_event_box_new ();
       gtk_table_attach (GTK_TABLE (table), eventbox,
@@ -377,7 +383,7 @@ button_window (GtkWidget *widget,
 }
 
 static void
-create_buttons (void)
+create_buttons (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -389,10 +395,12 @@ create_buttons (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -416,59 +424,59 @@ create_buttons (void)
       button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
       button[8] = gtk_button_new_with_label ("button9");
       
-      gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[1]);
+      g_signal_connect (button[0], "clicked",
+			G_CALLBACK (button_window),
+			button[1]);
 
       gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[2]);
+      g_signal_connect (button[1], "clicked",
+			G_CALLBACK (button_window),
+			button[2]);
 
       gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[3]);
+      g_signal_connect (button[2], "clicked",
+			G_CALLBACK (button_window),
+			button[3]);
       gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[4]);
+      g_signal_connect (button[3], "clicked",
+			G_CALLBACK (button_window),
+			button[4]);
       gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[5]);
+      g_signal_connect (button[4], "clicked",
+			G_CALLBACK (button_window),
+			button[5]);
       gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[6]);
+      g_signal_connect (button[5], "clicked",
+			G_CALLBACK (button_window),
+			button[6]);
       gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[7]);
+      g_signal_connect (button[6], "clicked",
+			G_CALLBACK (button_window),
+			button[7]);
       gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[8]);
+      g_signal_connect (button[7], "clicked",
+			G_CALLBACK (button_window),
+			button[8]);
       gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
-			  GTK_SIGNAL_FUNC(button_window),
-			  button[0]);
+      g_signal_connect (button[8], "clicked",
+			G_CALLBACK (button_window),
+			button[0]);
       gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
@@ -480,9 +488,9 @@ create_buttons (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button[9] = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button[9], "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
       gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
       GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
       gtk_widget_grab_default (button[9]);
@@ -499,7 +507,7 @@ create_buttons (void)
  */
 
 static void
-create_toggle_buttons (void)
+create_toggle_buttons (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -510,10 +518,12 @@ create_toggle_buttons (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -546,9 +556,9 @@ create_toggle_buttons (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -560,33 +570,96 @@ create_toggle_buttons (void)
     gtk_widget_destroy (window);
 }
 
+static GtkWidget *
+create_widget_grid (GType widget_type)
+{
+  GtkWidget *table;
+  GtkWidget *group_widget = NULL;
+  gint i, j;
+  
+  table = gtk_table_new (FALSE, 3, 3);
+  
+  for (i = 0; i < 5; i++)
+    {
+      for (j = 0; j < 5; j++)
+	{
+	  GtkWidget *widget;
+	  char *tmp;
+	  
+	  if (i == 0 && j == 0)
+	    {
+	      widget = NULL;
+	    }
+	  else if (i == 0)
+	    {
+	      tmp = g_strdup_printf ("%d", j);
+	      widget = gtk_label_new (tmp);
+	      g_free (tmp);
+	    }
+	  else if (j == 0)
+	    {
+	      tmp = g_strdup_printf ("%c", 'A' + i - 1);
+	      widget = gtk_label_new (tmp);
+	      g_free (tmp);
+	    }
+	  else
+	    {
+	      widget = g_object_new (widget_type, NULL);
+	      
+	      if (g_type_is_a (widget_type, GTK_TYPE_RADIO_BUTTON))
+		{
+		  if (!group_widget)
+		    group_widget = widget;
+		  else
+		    g_object_set (widget, "group", group_widget, NULL);
+		}
+	    }
+	  
+	  if (widget)
+	    gtk_table_attach (GTK_TABLE (table), widget,
+			      i, i + 1, j, j + 1,
+			      0,        0,
+			      0,        0);
+	}
+    }
+
+  return table;
+}
+
 /*
  * GtkCheckButton
  */
 
 static void
-create_check_buttons (void)
+create_check_buttons (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
   GtkWidget *box2;
   GtkWidget *button;
   GtkWidget *separator;
-
+  GtkWidget *table;
+  
   if (!window)
     {
-      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      window = gtk_dialog_new_with_buttons ("Check Buttons",
+                                            NULL, 0,
+                                            GTK_STOCK_CLOSE,
+                                            GTK_RESPONSE_NONE,
+                                            NULL);
 
-      gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
-      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+      gtk_window_set_screen (GTK_WINDOW (window), 
+			     gtk_widget_get_screen (widget));
 
-      box1 = gtk_vbox_new (FALSE, 0);
-      gtk_container_add (GTK_CONTAINER (window), box1);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+      g_signal_connect (window, "response",
+                        G_CALLBACK (gtk_widget_destroy),
+                        NULL);
 
+      box1 = GTK_DIALOG (window)->vbox;
+      
       box2 = gtk_vbox_new (FALSE, 10);
       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
@@ -603,21 +676,13 @@ create_check_buttons (void)
       button = gtk_check_button_new_with_label ("inconsistent");
       gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-      
+
       separator = gtk_hseparator_new ();
       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 
-      box2 = gtk_vbox_new (FALSE, 10);
-      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
-      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
-
-      button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 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);
+      table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
+      gtk_container_set_border_width (GTK_CONTAINER (table), 10);
+      gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
@@ -631,27 +696,34 @@ create_check_buttons (void)
  */
 
 static void
-create_radio_buttons (void)
+create_radio_buttons (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
   GtkWidget *box2;
   GtkWidget *button;
   GtkWidget *separator;
+  GtkWidget *table;
 
   if (!window)
     {
-      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      window = gtk_dialog_new_with_buttons ("Radio Buttons",
+                                            NULL, 0,
+                                            GTK_STOCK_CLOSE,
+                                            GTK_RESPONSE_NONE,
+                                            NULL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
-      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+      g_signal_connect (window, "response",
+                        G_CALLBACK (gtk_widget_destroy),
+                        NULL);
 
-      box1 = gtk_vbox_new (FALSE, 0);
-      gtk_container_add (GTK_CONTAINER (window), box1);
+      box1 = GTK_DIALOG (window)->vbox;
 
       box2 = gtk_vbox_new (FALSE, 10);
       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
@@ -704,17 +776,9 @@ create_radio_buttons (void)
       separator = gtk_hseparator_new ();
       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
 
-      box2 = gtk_vbox_new (FALSE, 10);
-      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
-      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
-
-      button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 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);
+      table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
+      gtk_container_set_border_width (GTK_CONTAINER (table), 10);
+      gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
@@ -731,8 +795,8 @@ static GtkWidget *
 create_bbox (gint  horizontal,
 	     char* title, 
 	     gint  spacing,
-	     gint  child_w, 
-	     gint  child_h, 
+	     gint  child_w,
+	     gint  child_h,
 	     gint  layout)
 {
   GtkWidget *frame;
@@ -766,7 +830,7 @@ create_bbox (gint  horizontal,
 }
 
 static void
-create_button_box (void)
+create_button_box (GtkWidget *widget)
 {
   static GtkWidget* window = NULL;
   GtkWidget *main_vbox;
@@ -774,15 +838,16 @@ create_button_box (void)
   GtkWidget *hbox;
   GtkWidget *frame_horz;
   GtkWidget *frame_vert;
-	
+
   if (!window)
   {
     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
     gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
     
-    gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			&window);
+    g_signal_connect (window, "destroy",
+		      G_CALLBACK (gtk_widget_destroyed),
+		      &window);
     
     gtk_container_set_border_width (GTK_CONTAINER (window), 10);
 
@@ -867,7 +932,7 @@ new_pixmap (char      *filename,
 					 background,
 					 filename);
   
-  wpixmap = gtk_pixmap_new (pixmap, mask);
+  wpixmap = gtk_image_new_from_pixmap (pixmap, mask);
 
   return wpixmap;
 }
@@ -944,7 +1009,7 @@ set_toolbar_disable (GtkWidget *widget,
 }
 
 static void
-create_toolbar (void)
+create_toolbar (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *toolbar;
@@ -953,12 +1018,14 @@ create_toolbar (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+      
       gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
-      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
       gtk_widget_realize (window);
@@ -968,42 +1035,42 @@ create_toolbar (void)
       gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
 				GTK_STOCK_NEW,
 				"Stock icon: New", "Toolbar/New",
-				(GtkSignalFunc) set_toolbar_small_stock, toolbar, -1);
+				G_CALLBACK (set_toolbar_small_stock), toolbar, -1);
       
       gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
 				GTK_STOCK_OPEN,
 				"Stock icon: Open", "Toolbar/Open",
-				(GtkSignalFunc) set_toolbar_large_stock, toolbar, -1);
+				G_CALLBACK (set_toolbar_large_stock), toolbar, -1);
       
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_horizontal, toolbar);
+			       G_CALLBACK (set_toolbar_horizontal), toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_vertical, toolbar);
+			       G_CALLBACK (set_toolbar_vertical), toolbar);
 
       gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_icons, toolbar);
+			       G_CALLBACK (set_toolbar_icons), toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Text", "Only show toolbar text", "Toolbar/TextOnly",
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_text, toolbar);
+			       G_CALLBACK (set_toolbar_text), toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Both", "Show toolbar icons and text", "Toolbar/Both",
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_both, toolbar);
+			       G_CALLBACK (set_toolbar_both), toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Both (horizontal)",
 			       "Show toolbar icons and text in a horizontal fashion",
 			       "Toolbar/BothHoriz",
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_both_horiz, toolbar);
+			       G_CALLBACK (set_toolbar_both_horiz), toolbar);
 			       
       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
@@ -1019,35 +1086,37 @@ create_toolbar (void)
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Enable", "Enable tooltips", NULL,
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_enable, toolbar);
+			       G_CALLBACK (set_toolbar_enable), toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Disable", "Disable tooltips", NULL,
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) set_toolbar_disable, toolbar);
+			       G_CALLBACK (set_toolbar_disable), toolbar);
 
       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Frobate", "Frobate tooltip", NULL,
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) NULL, toolbar);
+			       NULL, toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Baz", "Baz tooltip", NULL,
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) NULL, toolbar);
+			       NULL, toolbar);
 
       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
       
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Blah", "Blah tooltip", NULL,
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) NULL, toolbar);
+			       NULL, toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			       "Bar", "Bar tooltip", NULL,
 			       new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			       (GtkSignalFunc) NULL, toolbar);
+			       NULL, toolbar);
 
       gtk_container_add (GTK_CONTAINER (window), toolbar);
+
+      gtk_widget_set_size_request (toolbar, 200, -1);
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
@@ -1069,59 +1138,59 @@ make_toolbar (GtkWidget *window)
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Horizontal", "Horizontal toolbar layout", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) set_toolbar_horizontal, toolbar);
+			   G_CALLBACK (set_toolbar_horizontal), toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Vertical", "Vertical toolbar layout", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) set_toolbar_vertical, toolbar);
+			   G_CALLBACK (set_toolbar_vertical), toolbar);
 
   gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
 
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Icons", "Only show toolbar icons", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) set_toolbar_icons, toolbar);
+			   G_CALLBACK (set_toolbar_icons), toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Text", "Only show toolbar text", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) set_toolbar_text, toolbar);
+			   G_CALLBACK (set_toolbar_text), toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Both", "Show toolbar icons and text", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) set_toolbar_both, toolbar);
+			   G_CALLBACK (set_toolbar_both), toolbar);
 
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Woot", "Woot woot woot", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) NULL, toolbar);
+			   NULL, toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Blah", "Blah blah blah", "Toolbar/Big",
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) NULL, toolbar);
+			   NULL, toolbar);
 
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Enable", "Enable tooltips", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) set_toolbar_enable, toolbar);
+			   G_CALLBACK (set_toolbar_enable), toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Disable", "Disable tooltips", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) set_toolbar_disable, toolbar);
+			   G_CALLBACK (set_toolbar_disable), toolbar);
 
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
   
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Hoo", "Hoo tooltip", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) NULL, toolbar);
+			   NULL, toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
 			   "Woo", "Woo tooltip", NULL,
 			   new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-			   (GtkSignalFunc) NULL, toolbar);
+			   NULL, toolbar);
 
   return toolbar;
 }
@@ -1198,7 +1267,7 @@ statusbar_contexts (GtkStatusbar *statusbar)
 }
 
 static void
-create_statusbar (void)
+create_statusbar (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -1210,10 +1279,12 @@ create_statusbar (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "statusbar");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -1227,17 +1298,17 @@ create_statusbar (void)
 
       statusbar = gtk_statusbar_new ();
       gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (statusbar),
-			  "text_popped",
-			  GTK_SIGNAL_FUNC (statusbar_popped),
-			  NULL);
+      g_signal_connect (statusbar,
+			"text_popped",
+			G_CALLBACK (statusbar_popped),
+			NULL);
 
       button = gtk_widget_new (gtk_button_get_type (),
 			       "label", "push something",
 			       "visible", TRUE,
 			       "parent", box2,
 			       NULL);
-      g_object_connect (G_OBJECT (button),
+      g_object_connect (button,
 			"signal::clicked", statusbar_push, statusbar,
 			NULL);
 
@@ -1273,9 +1344,9 @@ create_statusbar (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -1297,7 +1368,7 @@ cb_tree_destroy_event(GtkWidget* w)
   sTreeButtons* tree_buttons;
 
   /* free buttons structure associate at this tree */
-  tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
+  tree_buttons = g_object_get_data (G_OBJECT (w), "user_data");
   g_free (tree_buttons);
 }
 
@@ -1311,7 +1382,7 @@ cb_add_new_item(GtkWidget* w, GtkTree* tree)
   GtkWidget* item_new;
   char buffer[255];
 
-  tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
+  tree_buttons = g_object_get_data (G_OBJECT (tree), "user_data");
 
   selected_list = GTK_TREE_SELECTION_OLD(tree);
 
@@ -1391,7 +1462,7 @@ cb_tree_changed(GtkTree* tree)
   GList* selected_list;
   guint nb_selected;
 
-  tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
+  tree_buttons = g_object_get_data (G_OBJECT (tree), "user_data");
 
   selected_list = GTK_TREE_SELECTION_OLD(tree);
   nb_selected = g_list_length(selected_list);
@@ -1453,7 +1524,7 @@ create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_
 }
 
 static void
-create_tree_sample(guint selection_mode, 
+create_tree_sample(GdkScreen *screen, guint selection_mode, 
 		   guint draw_line, guint view_line, guint no_root_item,
 		   guint nb_item_max, guint recursion_level_max) 
 {
@@ -1477,10 +1548,11 @@ create_tree_sample(guint selection_mode,
 
   /* create top level window */
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_screen (GTK_WINDOW (window), screen);
   gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
-  gtk_signal_connect(GTK_OBJECT(window), "destroy",
-		     (GtkSignalFunc) cb_tree_destroy_event, NULL);
-  gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
+  g_signal_connect (window, "destroy",
+		    G_CALLBACK (cb_tree_destroy_event), NULL);
+  g_object_set_data (G_OBJECT (window), "user_data", tree_buttons);
 
   box1 = gtk_vbox_new(FALSE, 0);
   gtk_container_add(GTK_CONTAINER(window), box1);
@@ -1497,15 +1569,15 @@ create_tree_sample(guint selection_mode,
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
 				  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
   gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
-  gtk_widget_set_usize (scrolled_win, 200, 200);
+  gtk_widget_set_size_request (scrolled_win, 200, 200);
   gtk_widget_show (scrolled_win);
   
   /* create root tree widget */
   root_tree = gtk_tree_new();
-  gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
-		     (GtkSignalFunc)cb_tree_changed,
-		     (gpointer)NULL);
-  gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
+  g_signal_connect (root_tree, "selection_changed",
+		    G_CALLBACK (cb_tree_changed),
+		    NULL);
+  g_object_set_data (G_OBJECT (root_tree), "user_data", tree_buttons);
   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
   gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
   gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
@@ -1533,27 +1605,27 @@ create_tree_sample(guint selection_mode,
 
   button = gtk_button_new_with_label("Add Item");
   gtk_widget_set_sensitive(button, FALSE);
-  gtk_signal_connect(GTK_OBJECT (button), "clicked",
-		     (GtkSignalFunc) cb_add_new_item, 
-		     (gpointer)root_tree);
+  g_signal_connect (button, "clicked",
+		    G_CALLBACK (cb_add_new_item),
+		    root_tree);
   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
   gtk_widget_show(button);
   tree_buttons->add_button = button;
 
   button = gtk_button_new_with_label("Remove Item(s)");
   gtk_widget_set_sensitive(button, FALSE);
-  gtk_signal_connect(GTK_OBJECT (button), "clicked",
-		     (GtkSignalFunc) cb_remove_item, 
-		     (gpointer)root_tree);
+  g_signal_connect (button, "clicked",
+		    G_CALLBACK (cb_remove_item),
+		    root_tree);
   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
   gtk_widget_show(button);
   tree_buttons->remove_button = button;
 
   button = gtk_button_new_with_label("Remove Subtree");
   gtk_widget_set_sensitive(button, FALSE);
-  gtk_signal_connect(GTK_OBJECT (button), "clicked",
-		     (GtkSignalFunc) cb_remove_subtree, 
-		     (gpointer)root_tree);
+  g_signal_connect (button, "clicked",
+		    G_CALLBACK (cb_remove_subtree),
+		    root_tree);
   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
   gtk_widget_show(button);
   tree_buttons->subtree_button = button;
@@ -1571,9 +1643,9 @@ create_tree_sample(guint selection_mode,
 
   button = gtk_button_new_with_label("Close");
   gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
-  gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
-			    (GtkSignalFunc) gtk_widget_destroy, 
-			    GTK_OBJECT(window));
+  g_signal_connect_swapped (button, "clicked",
+			    G_CALLBACK (gtk_widget_destroy),
+			    window);
   gtk_widget_show(button);
 
   gtk_widget_show(window);
@@ -1614,11 +1686,13 @@ cb_create_tree(GtkWidget* w)
       return;
     }
 
-  create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
+  create_tree_sample(gtk_widget_get_screen (w),
+		     selection_mode, draw_line, 
+		     view_line, no_root_item, nb_item, recursion_level);
 }
 
 void 
-create_tree_mode_window(void)
+create_tree_mode_window(GtkWidget *widget)
 {
   static GtkWidget* window;
   GtkWidget* box1;
@@ -1637,10 +1711,12 @@ create_tree_mode_window(void)
     {
       /* create toplevel window  */
       window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
       gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
       box1 = gtk_vbox_new(FALSE, 0);
       gtk_container_add(GTK_CONTAINER(window), box1);
 
@@ -1747,14 +1823,14 @@ create_tree_mode_window(void)
 
       button = gtk_button_new_with_label("Create Tree");
       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
-      gtk_signal_connect(GTK_OBJECT (button), "clicked",
-			 (GtkSignalFunc) cb_create_tree, NULL);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (cb_create_tree), NULL);
 
       button = gtk_button_new_with_label("Close");
       gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-                                 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-                                 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
     }
   if (!GTK_WIDGET_VISIBLE (window))
     gtk_widget_show_all (window);
@@ -1762,6 +1838,156 @@ create_tree_mode_window(void)
     gtk_widget_destroy (window);
 }
 
+/*
+ * Gridded geometry
+ */
+#define GRID_SIZE 20
+#define DEFAULT_GEOMETRY "10x10"
+
+static gboolean
+gridded_geometry_expose (GtkWidget      *widget,
+			 GdkEventExpose *event)
+{
+  int i, j;
+
+  gdk_draw_rectangle (widget->window, widget->style->base_gc[widget->state], TRUE,
+		      0, 0, widget->allocation.width, widget->allocation.height);
+  
+  for (i = 0 ; i * GRID_SIZE < widget->allocation.width; i++)
+    for (j = 0 ; j * GRID_SIZE < widget->allocation.height; j++)
+      {
+	if ((i + j) % 2 == 0)
+	  gdk_draw_rectangle (widget->window, widget->style->text_gc[widget->state], TRUE,
+			      i * GRID_SIZE, j * GRID_SIZE, GRID_SIZE, GRID_SIZE);
+      }
+
+  return FALSE;
+}
+
+static void
+gridded_geometry_subresponse (GtkDialog *dialog,
+			      gint       response_id,
+			      gchar     *geometry_string)
+{
+  if (response_id == GTK_RESPONSE_NONE)
+    {
+      gtk_widget_destroy (GTK_WIDGET (dialog));
+    }
+  else
+    {
+      if (!gtk_window_parse_geometry (GTK_WINDOW (dialog), geometry_string))
+	{
+	  g_print ("Can't parse geometry string %s\n", geometry_string);
+	  gtk_window_parse_geometry (GTK_WINDOW (dialog), DEFAULT_GEOMETRY);
+	}
+    }
+}
+
+static void
+gridded_geometry_response (GtkDialog *dialog,
+			   gint       response_id,
+			   GtkEntry  *entry)
+{
+  if (response_id == GTK_RESPONSE_NONE)
+    {
+      gtk_widget_destroy (GTK_WIDGET (dialog));
+    }
+  else
+    {
+      gchar *geometry_string = g_strdup (gtk_entry_get_text (entry));
+      gchar *title = g_strdup_printf ("Gridded window at: %s", geometry_string);
+      GtkWidget *window;
+      GtkWidget *drawing_area;
+      GtkWidget *box;
+      GdkGeometry geometry;
+      
+      window = gtk_dialog_new_with_buttons (title,
+                                            NULL, 0,
+                                            "Reset", 1,
+                                            GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
+                                            NULL);
+
+      gtk_window_set_screen (GTK_WINDOW (window), 
+			     gtk_widget_get_screen (GTK_WIDGET (dialog)));
+      g_free (title);
+      g_signal_connect (window, "response",
+			G_CALLBACK (gridded_geometry_subresponse), geometry_string);
+
+      box = gtk_vbox_new (FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), box, TRUE, TRUE, 0);
+      
+      gtk_container_set_border_width (GTK_CONTAINER (box), 7);
+      
+      drawing_area = gtk_drawing_area_new ();
+      g_signal_connect (drawing_area, "expose_event",
+			G_CALLBACK (gridded_geometry_expose), NULL);
+      gtk_box_pack_start (GTK_BOX (box), drawing_area, TRUE, TRUE, 0);
+
+      /* Gross hack to work around bug 68668... if we set the size request
+       * large enough, then  the current
+       *
+       *   request_of_window - request_of_geometry_widget
+       *
+       * method of getting the base size works more or less works.
+       */
+      gtk_widget_set_size_request (drawing_area, 2000, 2000);
+
+      geometry.base_width = 0;
+      geometry.base_height = 0;
+      geometry.min_width = 2 * GRID_SIZE;
+      geometry.min_height = 2 * GRID_SIZE;
+      geometry.width_inc = GRID_SIZE;
+      geometry.height_inc = GRID_SIZE;
+
+      gtk_window_set_geometry_hints (GTK_WINDOW (window), drawing_area,
+				     &geometry,
+				     GDK_HINT_BASE_SIZE | GDK_HINT_MIN_SIZE | GDK_HINT_RESIZE_INC);
+
+      if (!gtk_window_parse_geometry (GTK_WINDOW (window), geometry_string))
+	{
+	  g_print ("Can't parse geometry string %s\n", geometry_string);
+	  gtk_window_parse_geometry (GTK_WINDOW (window), DEFAULT_GEOMETRY);
+	}
+
+      gtk_widget_show_all (window);
+    }
+}
+
+static void 
+create_gridded_geometry (GtkWidget *widget)
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *entry;
+  GtkWidget *label;
+
+  if (!window)
+    {
+      window = gtk_dialog_new_with_buttons ("Gridded Geometry",
+                                            NULL, 0,
+					    "Create", 1,
+                                            GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
+                                            NULL);
+      
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      label = gtk_label_new ("Geometry string:");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, FALSE, FALSE, 0);
+
+      entry = gtk_entry_new ();
+      gtk_entry_set_text (GTK_ENTRY (entry), DEFAULT_GEOMETRY);
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), entry, FALSE, FALSE, 0);
+
+      g_signal_connect (window, "response",
+			G_CALLBACK (gridded_geometry_response), entry);
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      gtk_widget_show_all (window);
+    }
+  else
+    gtk_widget_destroy (window);
+}
+
 /*
  * GtkHandleBox
  */
@@ -1772,13 +1998,13 @@ handle_box_child_signal (GtkHandleBox *hb,
 			 const gchar  *action)
 {
   printf ("%s: child <%s> %sed\n",
-	  gtk_type_name (GTK_OBJECT_TYPE (hb)),
-	  gtk_type_name (GTK_OBJECT_TYPE (child)),
+	  g_type_name (G_OBJECT_TYPE (hb)),
+	  g_type_name (G_OBJECT_TYPE (child)),
 	  action);
 }
 
 static void
-create_handle_box (void)
+create_handle_box (GtkWidget *widget)
 {
   static GtkWidget* window = NULL;
   GtkWidget *handle_box;
@@ -1788,17 +2014,21 @@ create_handle_box (void)
   GtkWidget *toolbar;
   GtkWidget *label;
   GtkWidget *separator;
-	
+
   if (!window)
   {
     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_window_set_screen (GTK_WINDOW (window),
+			   gtk_widget_get_screen (widget));
+
     gtk_window_set_title (GTK_WINDOW (window),
 			  "Handle Box Test");
     gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
     
-    gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			&window);
+    g_signal_connect (window, "destroy",
+		      G_CALLBACK (gtk_widget_destroyed),
+		      &window);
     
     gtk_container_set_border_width (GTK_CONTAINER (window), 20);
 
@@ -1828,14 +2058,14 @@ create_handle_box (void)
 
     handle_box = gtk_handle_box_new ();
     gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
-    gtk_signal_connect (GTK_OBJECT (handle_box),
-			"child_attached",
-			GTK_SIGNAL_FUNC (handle_box_child_signal),
-			"attached");
-    gtk_signal_connect (GTK_OBJECT (handle_box),
-			"child_detached",
-			GTK_SIGNAL_FUNC (handle_box_child_signal),
-			"detached");
+    g_signal_connect (handle_box,
+		      "child_attached",
+		      G_CALLBACK (handle_box_child_signal),
+		      "attached");
+    g_signal_connect (handle_box,
+		      "child_detached",
+		      G_CALLBACK (handle_box_child_signal),
+		      "detached");
     gtk_widget_show (handle_box);
 
     toolbar = make_toolbar (window);
@@ -1845,26 +2075,26 @@ create_handle_box (void)
 
     handle_box = gtk_handle_box_new ();
     gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
-    gtk_signal_connect (GTK_OBJECT (handle_box),
-			"child_attached",
-			GTK_SIGNAL_FUNC (handle_box_child_signal),
-			"attached");
-    gtk_signal_connect (GTK_OBJECT (handle_box),
-			"child_detached",
-			GTK_SIGNAL_FUNC (handle_box_child_signal),
-			"detached");
+    g_signal_connect (handle_box,
+		      "child_attached",
+		      G_CALLBACK (handle_box_child_signal),
+		      "attached");
+    g_signal_connect (handle_box,
+		      "child_detached",
+		      G_CALLBACK (handle_box_child_signal),
+		      "detached");
     gtk_widget_show (handle_box);
 
     handle_box2 = gtk_handle_box_new ();
     gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
-    gtk_signal_connect (GTK_OBJECT (handle_box2),
-			"child_attached",
-			GTK_SIGNAL_FUNC (handle_box_child_signal),
-			"attached");
-    gtk_signal_connect (GTK_OBJECT (handle_box2),
-			"child_detached",
-			GTK_SIGNAL_FUNC (handle_box_child_signal),
-			"detached");
+    g_signal_connect (handle_box2,
+		      "child_attached",
+		      G_CALLBACK (handle_box_child_signal),
+		      "attached");
+    g_signal_connect (handle_box2,
+		      "child_detached",
+		      G_CALLBACK (handle_box_child_signal),
+		      "detached");
     gtk_widget_show (handle_box2);
 
     label = gtk_label_new ("Fooo!");
@@ -2035,7 +2265,7 @@ take_snapshot (GtkWidget *button,
   gtk_image_set_from_image (GTK_IMAGE (gid->snap),
                             shot, NULL);
 
-  g_object_unref (G_OBJECT (shot));
+  g_object_unref (shot);
   
   gdk_window_end_paint (gid->src->window);
   gdk_window_end_paint (gid->src->window);
@@ -2049,7 +2279,7 @@ take_snapshot (GtkWidget *button,
                       target.x, target.y,
                       target.width, target.height);
   
-  g_object_unref (G_OBJECT (gc));
+  g_object_unref (gc);
 }
 
 static gint
@@ -2100,13 +2330,13 @@ image_source_expose (GtkWidget *da,
       ++x;
     }
 
-  g_object_unref (G_OBJECT (gc));
+  g_object_unref (gc);
   
   return TRUE;
 }
 
 static void
-create_get_image (void)
+create_get_image (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
 
@@ -2117,28 +2347,31 @@ create_get_image (void)
       GtkWidget *sw;
       GtkWidget *src;
       GtkWidget *snap;
-      GtkWidget *vbox;
       GtkWidget *hbox;
+      GtkWidget *vbox;
       GtkWidget *button;
       struct GetImageData *gid;
 
       gid = g_new (struct GetImageData, 1);
       
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window),
-                          "destroy",
-                          GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-                          &window);
+      g_signal_connect (window,
+                        "destroy",
+                        G_CALLBACK (gtk_widget_destroyed),
+                        &window);
 
-      gtk_object_set_data_full (GTK_OBJECT (window),
-                                "testgtk-get-image-data",
-                                gid,
-                                g_free);
+      g_object_set_data_full (G_OBJECT (window),
+                              "testgtk-get-image-data",
+                              gid,
+                              g_free);
       
-      vbox = gtk_vbox_new (FALSE, 0);
+      hbox = gtk_hbox_new (FALSE, 0);
       
-      gtk_container_add (GTK_CONTAINER (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), hbox);
       
       sw = gtk_scrolled_window_new (NULL, NULL);
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
@@ -2147,26 +2380,26 @@ create_get_image (void)
 
       gid->sw = sw;
 
-      gtk_widget_set_usize (sw, 400, 400);
+      gtk_widget_set_size_request (sw, 400, 400);
       
       src = gtk_drawing_area_new ();
-      gtk_widget_set_usize (src, 10000, 10000);
+      gtk_widget_set_size_request (src, 10000, 10000);
 
-      gtk_signal_connect (GTK_OBJECT (src),
-                          "expose_event",
-                          GTK_SIGNAL_FUNC (image_source_expose),
-                          gid);
+      g_signal_connect (src,
+                        "expose_event",
+                        G_CALLBACK (image_source_expose),
+                        gid);
       
       gid->src = src;
       
       gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
                                              src);
       
-      gtk_box_pack_start (GTK_BOX (vbox),
+      gtk_box_pack_start (GTK_BOX (hbox),
                           sw, TRUE, TRUE, 0);                          
 
 
-      hbox = gtk_hbox_new (FALSE, 3);
+      vbox = gtk_vbox_new (FALSE, 3);
 
       snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL);
 
@@ -2176,22 +2409,22 @@ create_get_image (void)
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                       GTK_POLICY_AUTOMATIC,
                                       GTK_POLICY_AUTOMATIC);
-      gtk_widget_set_usize (sw, 300, 300);
+      gtk_widget_set_size_request (sw, 300, 300);
       
       gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), snap);
 
-      gtk_box_pack_end (GTK_BOX (hbox), sw, FALSE, FALSE, 5);
+      gtk_box_pack_end (GTK_BOX (vbox), sw, FALSE, FALSE, 5);
 
       button = gtk_button_new_with_label ("Get image from drawable");
 
-      gtk_signal_connect (GTK_OBJECT (button),
-                          "clicked",
-                          GTK_SIGNAL_FUNC (take_snapshot),
-                          gid);
+      g_signal_connect (button,
+                        "clicked",
+                        G_CALLBACK (take_snapshot),
+                        gid);
       
-      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
-      gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+      gtk_box_pack_end (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
       
       gtk_widget_show_all (window);
     }
@@ -2217,10 +2450,10 @@ create_sensitivity_control (GtkWidget *widget)
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
                                 GTK_WIDGET_IS_SENSITIVE (widget));
   
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "toggled",
-                      GTK_SIGNAL_FUNC (sensitivity_toggled),
-                      widget);
+  g_signal_connect (button,
+                    "toggled",
+                    G_CALLBACK (sensitivity_toggled),
+                    widget);
   
   gtk_widget_show_all (button);
 
@@ -2236,7 +2469,7 @@ set_selectable_recursive (GtkWidget *widget,
       GList *children;
       GList *tmp;
       
-      children = gtk_container_children (GTK_CONTAINER (widget));
+      children = gtk_container_get_children (GTK_CONTAINER (widget));
       tmp = children;
       while (tmp)
         {
@@ -2270,17 +2503,17 @@ create_selectable_control (GtkWidget *widget)
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
                                 FALSE);
   
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "toggled",
-                      GTK_SIGNAL_FUNC (selectable_toggled),
-                      widget);
+  g_signal_connect (button,
+                    "toggled",
+                    G_CALLBACK (selectable_toggled),
+                    widget);
   
   gtk_widget_show_all (button);
 
   return button;
 }
 
-void create_labels (void)
+void create_labels (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *hbox;
@@ -2288,13 +2521,17 @@ void create_labels (void)
   GtkWidget *frame;
   GtkWidget *label;
   GtkWidget *button;
-  
+
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Label");
 
@@ -2343,21 +2580,19 @@ void create_labels (void)
       frame = gtk_frame_new ("Internationalized Label");
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
-			    "French (Français) Bonjour, Salut\n"
-			    "Korean (한글)   안녕하세요, 안녕하십니까\n"
-			    "Russian (Русский) Здравствуйте!\n"
-			    "Chinese (Simplified) <span lang=\"zh-cn\">元气	开发</span>\n"
-			    "Chinese (Traditional) <span lang=\"zh-tw\">元氣	開發</span>\n"
-			    "Japanese <span lang=\"ja\">元気	開発</span>");
+			    "French (Fran\303\247ais) Bonjour, Salut\n"
+			    "Korean (\355\225\234\352\270\200)   \354\225\210\353\205\225\355\225\230\354\204\270\354\232\224, \354\225\210\353\205\225\355\225\230\354\213\255\353\213\210\352\271\214\n"
+			    "Russian (\320\240\321\203\321\201\321\201\320\272\320\270\320\271) \320\227\320\264\321\200\320\260\320\262\321\201\321\202\320\262\321\203\320\271\321\202\320\265!\n"
+			    "Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224	\345\274\200\345\217\221</span>\n"
+			    "Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243	\351\226\213\347\231\274</span>\n"
+			    "Japanese <span lang=\"ja\">\345\205\203\346\260\227	\351\226\213\347\231\272</span>");
       gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
       gtk_container_add (GTK_CONTAINER (frame), label);
       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
 
       frame = gtk_frame_new ("Bidirection Label");
-      label = gtk_label_new ("Arabic	السلام عليكم\n"
-			     "Hebrew	שלום");
-      gtk_widget_set_direction (label, GTK_TEXT_DIR_RTL);
-      gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
+      label = gtk_label_new ("\342\200\217Arabic	\330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205\n"
+			     "\342\200\217Hebrew	\327\251\327\234\327\225\327\235");
       gtk_container_add (GTK_CONTAINER (frame), label);
       gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
 
@@ -2391,7 +2626,7 @@ void create_labels (void)
 
       frame = gtk_frame_new ("Underlined label");
       label = gtk_label_new ("This label is underlined!\n"
-			     "This one is underlined (こんにちは) in quite a funky fashion");
+			     "This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
       gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
       gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __  ___ ____ _____");
       gtk_container_add (GTK_CONTAINER (frame), label);
@@ -2441,7 +2676,7 @@ reparent_label (GtkWidget *widget,
 {
   GtkWidget *label;
 
-  label = gtk_object_get_user_data (GTK_OBJECT (widget));
+  label = g_object_get_data (G_OBJECT (widget), "user_data");
 
   gtk_widget_reparent (label, new_parent);
 }
@@ -2452,14 +2687,14 @@ set_parent_signal (GtkWidget *child,
 		   gpointer   func_data)
 {
   g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
-	   gtk_type_name (GTK_OBJECT_TYPE (child)),
-	   child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
-	   old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
+	   g_type_name (G_OBJECT_TYPE (child)),
+	   child->parent ? g_type_name (G_OBJECT_TYPE (child->parent)) : "NULL",
+	   old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
 	   GPOINTER_TO_INT (func_data));
 }
 
 static void
-create_reparent (void)
+create_reparent (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -2469,14 +2704,18 @@ create_reparent (void)
   GtkWidget *button;
   GtkWidget *label;
   GtkWidget *separator;
+  GtkWidget *event_box;
 
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "reparent");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -2498,17 +2737,20 @@ create_reparent (void)
       gtk_container_add (GTK_CONTAINER (frame), box3);
 
       button = gtk_button_new_with_label ("switch");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(reparent_label),
-			  box3);
-      gtk_object_set_user_data (GTK_OBJECT (button), label);
+      g_object_set_data (G_OBJECT (button), "user_data", label);
       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
 
-      gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (label),
-			  "parent_set",
-			  GTK_SIGNAL_FUNC (set_parent_signal),
-			  GINT_TO_POINTER (42));
+      event_box = gtk_event_box_new ();
+      gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
+      gtk_container_add (GTK_CONTAINER (event_box), label);
+			 
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (reparent_label),
+			event_box);
+      
+      g_signal_connect (label, "parent_set",
+			G_CALLBACK (set_parent_signal),
+			GINT_TO_POINTER (42));
 
       frame = gtk_frame_new ("Frame 2");
       gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
@@ -2518,11 +2760,15 @@ create_reparent (void)
       gtk_container_add (GTK_CONTAINER (frame), box3);
 
       button = gtk_button_new_with_label ("switch");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(reparent_label),
-			  box3);
-      gtk_object_set_user_data (GTK_OBJECT (button), label);
+      g_object_set_data (G_OBJECT (button), "user_data", label);
       gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
+      
+      event_box = gtk_event_box_new ();
+      gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
+
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (reparent_label),
+			event_box);
 
       separator = gtk_hseparator_new ();
       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
@@ -2532,9 +2778,8 @@ create_reparent (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy), 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);
@@ -2546,6 +2791,157 @@ create_reparent (void)
     gtk_widget_destroy (window);
 }
 
+/*
+ * Resize Grips
+ */
+static gboolean
+grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
+{
+  if (event->type == GDK_BUTTON_PRESS) 
+    {
+      if (event->button == 1)
+	gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
+				      event->button, event->x_root, event->y_root,
+				      event->time);
+      else if (event->button == 2)
+	gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), 
+				    event->button, event->x_root, event->y_root,
+				    event->time);
+    }
+  return TRUE;
+}
+
+static gboolean
+grippy_expose (GtkWidget *area, GdkEventExpose *event, GdkWindowEdge edge)
+{
+  gtk_paint_resize_grip (area->style,
+			 area->window,
+			 GTK_WIDGET_STATE (area),
+			 &event->area,
+			 area,
+			 "statusbar",
+			 edge,
+			 0, 0,
+			 area->allocation.width,
+			 area->allocation.height);
+
+  return TRUE;
+}
+
+static void
+create_resize_grips (GtkWidget *widget)
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *area;
+  GtkWidget *hbox, *vbox;
+  if (!window)
+    {
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      gtk_window_set_title (GTK_WINDOW (window), "resize grips");
+      
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+
+      vbox = gtk_vbox_new (FALSE, 0);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
+      
+      hbox = gtk_hbox_new (FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+      /* North west */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
+      
+      /* North */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
+
+      /* North east */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
+
+      hbox = gtk_hbox_new (FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+      /* West */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
+
+      /* Middle */
+      area = gtk_drawing_area_new ();
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+
+      /* East */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
+
+
+      hbox = gtk_hbox_new (FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+      /* South west */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
+      /* South */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
+      
+      /* South east */
+      area = gtk_drawing_area_new ();
+      gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+      gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+      g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
+      g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+			GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
+    }
+
+  if (!GTK_WIDGET_VISIBLE (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+}
+
 /*
  * Saved Position
  */
@@ -2559,8 +2955,8 @@ uposition_configure (GtkWidget *window)
   GtkLabel *ly;
   gchar buffer[64];
 
-  lx = gtk_object_get_data (GTK_OBJECT (window), "x");
-  ly = gtk_object_get_data (GTK_OBJECT (window), "y");
+  lx = g_object_get_data (G_OBJECT (window), "x");
+  ly = g_object_get_data (G_OBJECT (window), "y");
 
   gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
   sprintf (buffer, "%d", upositionx);
@@ -2576,13 +2972,13 @@ uposition_stop_configure (GtkToggleButton *toggle,
 			  GtkObject       *window)
 {
   if (toggle->active)
-    gtk_signal_handler_block_by_func (window, GTK_SIGNAL_FUNC (uposition_configure), NULL);
+    g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
   else
-    gtk_signal_handler_unblock_by_func (window, GTK_SIGNAL_FUNC (uposition_configure), NULL);
+    g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
 }
 
 static void
-create_saved_position (void)
+create_saved_position (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
 
@@ -2599,16 +2995,20 @@ create_saved_position (void)
 
       window = g_object_connect (gtk_widget_new (GTK_TYPE_WINDOW,
 						 "type", GTK_WINDOW_TOPLEVEL,
-						 "x", upositionx,
-						 "y", upositiony,
 						 "title", "Saved Position",
 						 NULL),
 				 "signal::configure_event", uposition_configure, NULL,
 				 NULL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
+
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+      
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       main_vbox = gtk_vbox_new (FALSE, 5);
       gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
@@ -2640,7 +3040,7 @@ create_saved_position (void)
 
       x_label = gtk_label_new ("");
       gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
-      gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
+      g_object_set_data (G_OBJECT (window), "x", x_label);
 
       hbox = gtk_hbox_new (FALSE, 0);
       gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
@@ -2652,7 +3052,7 @@ create_saved_position (void)
 
       y_label = gtk_label_new ("");
       gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
-      gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
+      g_object_set_data (G_OBJECT (window), "y", y_label);
 
       any =
 	gtk_widget_new (gtk_hseparator_get_type (),
@@ -2665,9 +3065,9 @@ create_saved_position (void)
       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_widget_grab_default (button);
@@ -2683,7 +3083,7 @@ create_saved_position (void)
  */
 
 static void
-create_pixmap (void)
+create_pixmap (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -2698,9 +3098,12 @@ create_pixmap (void)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-                          GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-                          &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed),
+                        &window);
 
       gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -2747,9 +3150,9 @@ create_pixmap (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-                                 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-                                 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -2772,7 +3175,7 @@ tips_query_widget_entered (GtkTipsQuery   *tips_query,
     {
       gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
       /* don't let GtkTipsQuery reset its label */
-      gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
+      g_signal_stop_emission_by_name (tips_query, "widget_entered");
     }
 }
 
@@ -2787,12 +3190,12 @@ tips_query_widget_selected (GtkWidget      *tips_query,
   if (widget)
     g_print ("Help \"%s\" requested for <%s>\n",
 	     tip_private ? tip_private : "None",
-	     gtk_type_name (GTK_OBJECT_TYPE (widget)));
+	     g_type_name (G_OBJECT_TYPE (widget)));
   return TRUE;
 }
 
 static void
-create_tooltips (void)
+create_tooltips (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -2814,18 +3217,19 @@ create_tooltips (void)
 			"GtkWindow::title", "Tooltips",
 			"GtkWindow::allow_shrink", TRUE,
 			"GtkWindow::allow_grow", FALSE,
-			"GtkWindow::auto_shrink", TRUE,
-			"GtkWidget::width", 200,
 			NULL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-                          GTK_SIGNAL_FUNC (destroy_tooltips),
-                          &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (destroy_tooltips),
+                        &window);
 
       tooltips=gtk_tooltips_new();
       g_object_ref (tooltips);
       gtk_object_sink (GTK_OBJECT (tooltips));
-      gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
+      g_object_set_data (G_OBJECT (window), "tooltips", tooltips);
       
       box1 = gtk_vbox_new (FALSE, 0);
       gtk_container_add (GTK_CONTAINER (window), box1);
@@ -2837,7 +3241,10 @@ create_tooltips (void)
       button = gtk_toggle_button_new_with_label ("button1");
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 
-      gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
+      gtk_tooltips_set_tip (tooltips,
+			    button,
+			    "This is button 1",
+			    "ContextHelp/buttons/1");
 
       button = gtk_toggle_button_new_with_label ("button2");
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
@@ -2850,7 +3257,10 @@ create_tooltips (void)
       toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
       gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
 
-      gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
+      gtk_tooltips_set_tip (tooltips,
+			    toggle,
+			    "Toggle TipsQuery view.",
+			    "Hi msw! ;)");
 
       box3 =
 	gtk_widget_new (gtk_vbox_get_type (),
@@ -2868,7 +3278,7 @@ create_tooltips (void)
 			"visible", TRUE,
 			"parent", box3,
 			NULL);
-      g_object_connect (G_OBJECT (button),
+      g_object_connect (button,
 			"swapped_signal::clicked", gtk_tips_query_start_query, tips_query,
 			NULL);
       gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
@@ -2905,9 +3315,9 @@ create_tooltips (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-                                 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-                                 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -2940,10 +3350,10 @@ pack_image (GtkWidget *box,
 }
 
 static void
-create_image (void)
+create_image (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
-  
+
   if (window == NULL)
     {
       GtkWidget *vbox;
@@ -2951,14 +3361,18 @@ create_image (void)
       GdkBitmap *mask;
         
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
       /* this is bogus for testing drawing when allocation < request,
        * don't copy into real code
        */
-      gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
+      g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
       
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       vbox = gtk_vbox_new (FALSE, 5);
 
@@ -2989,7 +3403,7 @@ create_image (void)
  */
 
 static GtkWidget*
-create_menu (gint depth, gint length, gboolean tearoff)
+create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
 {
   GtkWidget *menu;
   GtkWidget *menuitem;
@@ -3002,6 +3416,8 @@ create_menu (gint depth, gint length, gboolean tearoff)
     return NULL;
 
   menu = gtk_menu_new ();
+  gtk_menu_set_screen (GTK_MENU (menu), screen);
+
   group = NULL;
 
   if (tearoff)
@@ -3024,10 +3440,12 @@ create_menu (gint depth, gint length, gboolean tearoff)
       sprintf (buf, "item %2d - %d", depth, j);
 
       menuitem = gtk_radio_menu_item_new_with_label (group, buf);
-      group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
+      group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
 
+#if 0
       if (depth % 2)
 	gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
+#endif
 
       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
       gtk_widget_show (menuitem);
@@ -3039,14 +3457,204 @@ create_menu (gint depth, gint length, gboolean tearoff)
                                               TRUE);
 
       if (i < 5)
-	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, 5,  TRUE));
+	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), 
+				   create_menu (screen, depth - 1, 5,  TRUE));
     }
 
   return menu;
 }
 
-static void
-create_menus (void)
+static GtkWidget*
+create_table_menu (GdkScreen *screen, gint cols, gint rows, gboolean tearoff)
+{
+  GtkWidget *menu;
+  GtkWidget *menuitem;
+  GtkWidget *submenu;
+  GtkWidget *image;
+  char buf[32];
+  int i, j;
+
+  menu = gtk_menu_new ();
+  gtk_menu_set_screen (GTK_MENU (menu), screen);
+
+  j = 0;
+  if (tearoff)
+    {
+      menuitem = gtk_tearoff_menu_item_new ();
+      gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
+      gtk_widget_show (menuitem);
+      j++;
+    }
+  
+  menuitem = gtk_menu_item_new_with_label ("items");
+  gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
+
+  submenu = gtk_menu_new ();
+  gtk_menu_set_screen (GTK_MENU (submenu), screen);
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+  gtk_widget_show (menuitem);
+  j++;
+
+  /* now fill the items submenu */
+  image = gtk_image_new_from_stock (GTK_STOCK_HELP,
+				    GTK_ICON_SIZE_MENU);
+  gtk_widget_show (image);
+  menuitem = gtk_image_menu_item_new_with_label ("Image");
+  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("x");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("x");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
+  gtk_widget_show (menuitem);
+  
+  image = gtk_image_new_from_stock (GTK_STOCK_HELP,
+				    GTK_ICON_SIZE_MENU);
+  gtk_widget_show (image);
+  menuitem = gtk_image_menu_item_new_with_label ("Image");
+  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("x");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("x");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
+  gtk_widget_show (menuitem);
+  
+  menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_check_menu_item_new_with_label ("Check");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("x");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("x");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
+  gtk_widget_show (menuitem);
+  
+  menuitem = gtk_check_menu_item_new_with_label ("Check");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
+  gtk_widget_show (menuitem);
+  gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
+
+  menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
+  gtk_widget_show (menuitem);
+  gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
+
+  menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
+  gtk_widget_show (menuitem);
+  gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
+
+  menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
+  gtk_widget_show (menuitem);
+  gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
+  
+  /* end of items submenu */
+
+  menuitem = gtk_menu_item_new_with_label ("spanning");
+  gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
+
+  submenu = gtk_menu_new ();
+  gtk_menu_set_screen (GTK_MENU (submenu), screen);
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+  gtk_widget_show (menuitem);
+  j++;
+
+  /* now fill the spanning submenu */
+  menuitem = gtk_menu_item_new_with_label ("a");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("b");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("c");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("d");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("e");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
+  gtk_widget_show (menuitem);
+  /* end of spanning submenu */
+  
+  menuitem = gtk_menu_item_new_with_label ("left");
+  gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
+  submenu = gtk_menu_new ();
+  gtk_menu_set_screen (GTK_MENU (submenu), screen);
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("Empty");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
+  submenu = gtk_menu_new ();
+  gtk_menu_set_screen (GTK_MENU (submenu), screen);
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("right");
+  gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
+  submenu = gtk_menu_new ();
+  gtk_menu_set_screen (GTK_MENU (submenu), screen);
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+  gtk_widget_show (menuitem);
+
+  menuitem = gtk_menu_item_new_with_label ("Empty");
+  gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
+  gtk_widget_show (menuitem);
+
+  j++;
+
+  for (; j < rows; j++)
+      for (i = 0; i < cols; i++)
+      {
+	sprintf (buf, "(%d %d)", i, j);
+	menuitem = gtk_menu_item_new_with_label (buf);
+	gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
+	gtk_widget_show (menuitem);
+      }
+  
+  menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
+  gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
+  gtk_widget_show (menuitem);
+  menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
+  gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
+  gtk_widget_show (menuitem);
+  menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
+  gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
+  gtk_widget_show (menuitem);
+  menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
+  gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
+  gtk_widget_show (menuitem);
+  
+  return menu;
+}
+
+static void
+create_menus (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -3062,15 +3670,18 @@ create_menus (void)
       GtkWidget *menuitem;
       GtkAccelGroup *accel_group;
       GtkWidget *image;
+      GdkScreen *screen = gtk_widget_get_screen (widget);
       
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+      gtk_window_set_screen (GTK_WINDOW (window), screen);
       
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
-      gtk_signal_connect (GTK_OBJECT (window), "delete-event",
-			  GTK_SIGNAL_FUNC (gtk_true),
-			  NULL);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+      g_signal_connect (window, "delete-event",
+			G_CALLBACK (gtk_true),
+			NULL);
       
       accel_group = gtk_accel_group_new ();
       gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
@@ -3087,16 +3698,23 @@ create_menus (void)
       gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
       gtk_widget_show (menubar);
       
-      menu = create_menu (2, 50, TRUE);
+      menu = create_menu (screen, 2, 50, TRUE);
       
       menuitem = gtk_menu_item_new_with_label ("test\nline2");
       gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
-      gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
+      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
+      gtk_widget_show (menuitem);
+
+      menu = create_table_menu (screen, 2, 50, TRUE);
+      
+      menuitem = gtk_menu_item_new_with_label ("table");
+      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
+      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
       gtk_widget_show (menuitem);
       
       menuitem = gtk_menu_item_new_with_label ("foo");
-      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, 5, TRUE));
-      gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
+      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
+      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
       gtk_widget_show (menuitem);
 
       image = gtk_image_new_from_stock (GTK_STOCK_HELP,
@@ -3104,9 +3722,20 @@ create_menus (void)
       gtk_widget_show (image);
       menuitem = gtk_image_menu_item_new_with_label ("Help");
       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
-      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, 5, TRUE));
+      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
       gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
-      gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
+      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
+      gtk_widget_show (menuitem);
+      
+      menubar = gtk_menu_bar_new ();
+      gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
+      gtk_widget_show (menubar);
+      
+      menu = create_menu (screen, 2, 10, TRUE);
+      
+      menuitem = gtk_menu_item_new_with_label ("Second menu bar");
+      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
+      gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
       gtk_widget_show (menuitem);
       
       box2 = gtk_vbox_new (FALSE, 10);
@@ -3114,7 +3743,7 @@ create_menus (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
       gtk_widget_show (box2);
       
-      menu = create_menu (1, 5, FALSE);
+      menu = create_menu (screen, 1, 5, FALSE);
       gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
 
       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
@@ -3171,9 +3800,9 @@ create_menus (void)
       gtk_widget_show (box2);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -3194,117 +3823,102 @@ gtk_ifactory_cb (gpointer             callback_data,
   g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
 }
 
-/* This file was automatically generated by the make-inline-pixbuf program.
- * It contains inline RGB image data.
- */
-static const guchar apple[] =
-{
-  /* File magic (1197763408) */
-  0x47, 0x64, 0x6b, 0x50,
-  /* Format of following stuff (0) */
-  0x00, 0x00, 0x00, 0x00,
-  /* Rowstride (64) */
-  0x00, 0x00, 0x00, 0x40,
-  /* Width (16) */
-  0x00, 0x00, 0x00, 0x10,
-  /* Height (16) */
-  0x00, 0x00, 0x00, 0x10,
-  /* Has an alpha channel (TRUE) */
-  0x01,
-  /* Colorspace (0 == RGB, no other options implemented) (0) */
-  0x00, 0x00, 0x00, 0x00,
-  /* Number of channels (4) */
-  0x00, 0x00, 0x00, 0x04,
-  /* Bits per sample (8) */
-  0x00, 0x00, 0x00, 0x08,
-  /* Image data */
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x16, 0x14, 0x0f, 0x04,
-  0x00, 0x00, 0x00, 0x01,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x61, 0x6d, 0x5b, 0x2b,  0x6e, 0x7c, 0x61, 0xd9,
-  0x71, 0x80, 0x63, 0xd7,  0x5f, 0x6b, 0x5b, 0x35,  0x00, 0x00, 0x00, 0x00,
-  0x3a, 0x35, 0x28, 0x8f,  0x00, 0x00, 0x00, 0x32,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x60, 0x6c, 0x5c, 0x07,  0x6d, 0x7b, 0x61, 0xd8,
-  0x75, 0x84, 0x65, 0xf6,  0x76, 0x86, 0x66, 0xf7,  0x6a, 0x77, 0x60, 0xec,
-  0x5e, 0x6a, 0x58, 0x47,  0x1c, 0x1a, 0x13, 0xa2,  0x4b, 0x47, 0x30, 0x07,
-  0x55, 0x4e, 0x33, 0x21,  0x48, 0x3e, 0x2a, 0x08,  0xd0, 0xb8, 0x84, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x69, 0x76, 0x5f, 0x74,
-  0x75, 0x84, 0x65, 0xf3,  0x67, 0x75, 0x5e, 0xc4,  0x69, 0x62, 0x55, 0x75,
-  0x94, 0x50, 0x50, 0x69,  0x75, 0x5c, 0x52, 0xb2,  0x69, 0x38, 0x34, 0xa2,
-  0xa7, 0x5b, 0x53, 0xea,  0xa3, 0x52, 0x4f, 0xff,  0x90, 0x47, 0x42, 0xfa,
-  0x76, 0x44, 0x36, 0xb9,  0x59, 0x38, 0x29, 0x3c,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x5f, 0x6b, 0x5a, 0x09,
-  0x69, 0x76, 0x5e, 0xb0,  0x5f, 0x6b, 0x59, 0x57,  0x9a, 0x4b, 0x4d, 0x5b,
-  0xb8, 0x5f, 0x63, 0xfa,  0xcc, 0x7d, 0x7e, 0xff,  0xc5, 0x69, 0x68, 0xff,
-  0xc7, 0x6b, 0x67, 0xff,  0xc5, 0x6f, 0x67, 0xff,  0xba, 0x5e, 0x5a, 0xff,
-  0xb1, 0x4d, 0x4d, 0xff,  0x92, 0x4b, 0x42, 0xff,  0x6a, 0x3e, 0x30, 0xfc,
-  0x5c, 0x3b, 0x27, 0x6d,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x5d, 0x69, 0x57, 0x09,  0x5d, 0x69, 0x57, 0x09,  0x92, 0x47, 0x46, 0x1e,
-  0xba, 0x65, 0x64, 0xf4,  0xe7, 0xbf, 0xc0, 0xff,  0xdf, 0xa5, 0xa3, 0xff,
-  0xd4, 0x84, 0x81, 0xff,  0xd1, 0x7c, 0x76, 0xff,  0xc9, 0x78, 0x6d, 0xff,
-  0xbb, 0x6a, 0x5d, 0xff,  0xb3, 0x5a, 0x52, 0xff,  0x9f, 0x4b, 0x47, 0xff,
-  0x78, 0x45, 0x35, 0xff,  0x5f, 0x3c, 0x28, 0xfa,  0x53, 0x5a, 0x38, 0x24,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0xa1, 0x54, 0x4d, 0x8c,  0xcf, 0x8e, 0x89, 0xff,  0xe3, 0xb1, 0xae, 0xff,
-  0xd8, 0x94, 0x8e, 0xff,  0xd3, 0x8a, 0x82, 0xff,  0xcf, 0x80, 0x76, 0xff,
-  0xc4, 0x75, 0x67, 0xff,  0xb7, 0x6c, 0x5c, 0xff,  0xab, 0x5e, 0x51, 0xff,
-  0x9c, 0x4c, 0x46, 0xff,  0x7e, 0x4a, 0x3a, 0xff,  0x5c, 0x3c, 0x26, 0xff,
-  0x58, 0x3d, 0x28, 0x55,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0xa2, 0x59, 0x4f, 0xc3,  0xcd, 0x8e, 0x88, 0xff,
-  0xd3, 0x93, 0x8c, 0xff,  0xd0, 0x8c, 0x83, 0xff,  0xcc, 0x84, 0x79, 0xff,
-  0xc7, 0x7c, 0x6e, 0xff,  0xbc, 0x73, 0x61, 0xff,  0xb1, 0x6b, 0x59, 0xff,
-  0xa3, 0x5f, 0x4f, 0xff,  0x93, 0x50, 0x44, 0xff,  0x78, 0x48, 0x35, 0xff,
-  0x59, 0x3b, 0x25, 0xff,  0x4f, 0x3d, 0x28, 0x4f,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x9b, 0x5b, 0x4d, 0xbc,
-  0xbd, 0x7e, 0x72, 0xff,  0xc6, 0x86, 0x7a, 0xff,  0xc5, 0x7f, 0x72, 0xff,
-  0xc2, 0x7b, 0x6c, 0xff,  0xbf, 0x77, 0x63, 0xff,  0xb7, 0x72, 0x5b, 0xff,
-  0xa9, 0x6b, 0x53, 0xff,  0x9a, 0x60, 0x4b, 0xff,  0x8b, 0x56, 0x41, 0xff,
-  0x6a, 0x44, 0x2e, 0xff,  0x53, 0x38, 0x21, 0xfd,  0x42, 0x4b, 0x2e, 0x1a,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x8e, 0x57, 0x48, 0x6e,  0xa6, 0x6b, 0x5a, 0xff,  0xb3, 0x74, 0x62, 0xff,
-  0xb8, 0x75, 0x61, 0xff,  0xba, 0x76, 0x61, 0xff,  0xb7, 0x74, 0x5c, 0xff,
-  0xae, 0x6e, 0x54, 0xff,  0x9f, 0x67, 0x4c, 0xff,  0x90, 0x5d, 0x43, 0xff,
-  0x79, 0x4d, 0x38, 0xff,  0x5c, 0x3d, 0x25, 0xff,  0x50, 0x39, 0x23, 0xb8,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x78, 0x52, 0x43, 0x07,  0x92, 0x5c, 0x47, 0xdc,
-  0x9e, 0x64, 0x4e, 0xff,  0xa8, 0x6b, 0x52, 0xff,  0xaa, 0x6d, 0x53, 0xff,
-  0xa7, 0x6d, 0x50, 0xff,  0x9c, 0x67, 0x4a, 0xff,  0x8e, 0x5d, 0x41, 0xff,
-  0x7d, 0x54, 0x3a, 0xff,  0x6a, 0x4b, 0x32, 0xff,  0x51, 0x39, 0x23, 0xff,
-  0x28, 0x20, 0x12, 0x77,  0x00, 0x00, 0x00, 0x12,  0x00, 0x00, 0x00, 0x01,
-  0x00, 0x00, 0x00, 0x03,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x6f, 0x4a, 0x37, 0x2a,  0x81, 0x54, 0x3d, 0xec,  0x8b, 0x5a, 0x41, 0xff,
-  0x8b, 0x5a, 0x3f, 0xff,  0x85, 0x56, 0x3c, 0xff,  0x7d, 0x52, 0x38, 0xff,
-  0x77, 0x51, 0x33, 0xff,  0x6f, 0x4e, 0x34, 0xff,  0x5f, 0x45, 0x2c, 0xff,
-  0x2e, 0x21, 0x14, 0xff,  0x00, 0x00, 0x00, 0xf8,  0x00, 0x00, 0x00, 0x92,
-  0x00, 0x00, 0x00, 0x0e,  0x00, 0x00, 0x00, 0x04,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x14,  0x11, 0x0b, 0x08, 0xb4,
-  0x50, 0x37, 0x25, 0xfe,  0x6d, 0x49, 0x2f, 0xff,  0x52, 0x37, 0x22, 0xff,
-  0x50, 0x37, 0x21, 0xff,  0x66, 0x45, 0x2b, 0xff,  0x60, 0x46, 0x2c, 0xff,
-  0x2d, 0x22, 0x16, 0xff,  0x00, 0x00, 0x00, 0xfe,  0x00, 0x00, 0x00, 0xd2,
-  0x00, 0x00, 0x00, 0x63,  0x00, 0x00, 0x00, 0x07,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x02,
-  0x00, 0x00, 0x00, 0x22,  0x00, 0x00, 0x00, 0x64,  0x09, 0x0a, 0x07, 0xa4,
-  0x00, 0x00, 0x00, 0xbd,  0x00, 0x00, 0x00, 0xbe,  0x00, 0x00, 0x00, 0xc4,
-  0x00, 0x00, 0x00, 0xb8,  0x00, 0x00, 0x00, 0x9d,  0x00, 0x00, 0x00, 0x6c,
-  0x00, 0x00, 0x00, 0x2c,  0x00, 0x00, 0x00, 0x07,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x01,
-  0x00, 0x00, 0x00, 0x05,  0x00, 0x00, 0x00, 0x0b,  0x00, 0x00, 0x00, 0x0d,
-  0x00, 0x00, 0x00, 0x0b,  0x00, 0x00, 0x00, 0x08,  0x00, 0x00, 0x00, 0x06,
-  0x00, 0x00, 0x00, 0x02,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00
-};
+/* GdkPixbuf RGBA C-Source image dump */
+
+static const guint8 apple[] = 
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (2304) */
+  "\0\0\11\30"
+  /* pixdata_type (0x1010002) */
+  "\1\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\26\24"
+  "\17\11\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`m"
+  "[pn{a\344hv_\345_k[`\0\0\0\0\0\0\0\0\0\0\0\0D>/\305\0\0\0_\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`l[Blza\373s\202d\354w\206g\372p~c"
+  "\374`l[y\0\0\0\0[S\77/\27\25\17\335\0\0\0\20\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
+  "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0eq"
+  "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
+  "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0ly`\40p~b\360lz`\353^kY\246["
+  "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
+  "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
+  "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
+  "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
+  "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
+  "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
+  "ff@\377QT5\377LR2d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]iW(\0\0\0\0\0\0\0"
+  "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
+  "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
+  "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
+  "\377SW6\377RX6\364Za<\34\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0b]@\20"
+  "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
+  "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
+  "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
+  "wvL\377X]:\377KR0\377NU5v\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\212"
+  "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
+  "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
+  "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
+  "ttJ\377[_<\377HO/\377GN0\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
+  "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
+  "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
+  "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
+  "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
+  "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
+  "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
+  "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
+  "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
+  "\377HP0\377@H+\373CJ-\25\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0xxO>"
+  "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
+  "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
+  "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\202\205W\312\216\220`\377\230"
+  "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
+  "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
+  "\377=D)\377HQ1:\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
+  "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
+  "R[;\377BJ-\3778@'\317\0\0\0>\0\0\0\36\0\0\0\7\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
+  "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
+  "\376\0\0\0\347\0\0\0\262\0\0\0Y\0\0\0\32\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
+  "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
+  "\0\0\374\0\0\0\320\0\0\0I\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
+  "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
+  "\0\0\0\347\0\0\0\217\0\0\0""4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\20\0\0\0P\0\0\0\252\7\10\5\346\7\7\5\375\0\0\0\377\0\0"
+  "\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\374\0"
+  "\0\0\336\0\0\0\254\0\0\0i\0\0\0""2\0\0\0\10\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\11\0\0\0\40\0\0\0D\0\0\0m\0\0\0"
+  "\226\0\0\0\234\0\0\0\234\0\0\0\244\0\0\0\246\0\0\0\232\0\0\0\202\0\0"
+  "\0i\0\0\0T\0\0\0,\0\0\0\15\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\6\0\0\0"
+  "\16\0\0\0\22\0\0\0\24\0\0\0\23\0\0\0\17\0\0\0\14\0\0\0\13\0\0\0\10\0"
+  "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
 
 
 static void
@@ -3341,6 +3955,9 @@ static GtkItemFactoryEntry menu_items[] =
   { "/_Preferences/Shape/_Rectangle",   NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
   { "/_Preferences/Shape/_Oval",        NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
   { "/_Preferences/Shape/_Image",       NULL, gtk_ifactory_cb, 0, "<ImageItem>", apple },
+  { "/_Preferences/Coffee",                  NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
+  { "/_Preferences/Toast",                   NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
+  { "/_Preferences/Marshmallow Froot Loops", NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
 
   /* For testing deletion of menus */
   { "/_Preferences/Should_NotAppear",          NULL, 0,               0, "<Branch>" },
@@ -3356,7 +3973,7 @@ static GtkItemFactoryEntry menu_items[] =
 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
 
 static void
-create_item_factory (void)
+create_item_factory (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   
@@ -3369,22 +3986,26 @@ create_item_factory (void)
       GtkWidget *button;
       GtkAccelGroup *accel_group;
       GtkItemFactory *item_factory;
+      GtkTooltips *tooltips;
       
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
       
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
-      gtk_signal_connect (GTK_OBJECT (window), "delete-event",
-			  GTK_SIGNAL_FUNC (gtk_true),
-			  NULL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+      
+      g_signal_connect (window, "destroy",
+			G_CALLBACK(gtk_widget_destroyed),
+			&window);
+      g_signal_connect (window, "delete-event",
+			G_CALLBACK (gtk_true),
+			NULL);
       
       accel_group = gtk_accel_group_new ();
       item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
-      gtk_object_set_data_full (GTK_OBJECT (window),
-				"<main>",
-				item_factory,
-				(GtkDestroyNotify) gtk_object_unref);
+      g_object_set_data_full (G_OBJECT (window),
+			      "<main>",
+			      item_factory,
+			      g_object_unref);
       gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
       gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -3396,6 +4017,38 @@ create_item_factory (void)
 										      "/Preferences/Shape/Oval")),
 				      TRUE);
 
+      /* preselect /Preferences/Coffee
+       */
+      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
+										      "/Preferences/Coffee")),
+				      TRUE);
+
+      /* preselect /Preferences/Marshmallow Froot Loops and set it insensitive
+       */
+      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
+										      "/Preferences/Marshmallow Froot Loops")),
+				      TRUE);
+      gtk_widget_set_sensitive (GTK_WIDGET (gtk_item_factory_get_item (item_factory,
+								       "/Preferences/Marshmallow Froot Loops")),
+				FALSE);
+       
+      /* Test how tooltips (ugh) work on menu items
+       */
+      tooltips = gtk_tooltips_new ();
+      g_object_ref (tooltips);
+      gtk_object_sink (GTK_OBJECT (tooltips));
+      g_object_set_data_full (G_OBJECT (window), "testgtk-tooltips",
+			      tooltips, (GDestroyNotify)g_object_unref);
+      
+      gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/New"),
+			    "Create a new file", NULL);
+      gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/Open"),
+			    "Open a file", NULL);
+      gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/Save"),
+			    "Safe file", NULL);
+      gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/Preferences/Color"),
+			    "Modify color", NULL);
+
       box1 = gtk_vbox_new (FALSE, 0);
       gtk_container_add (GTK_CONTAINER (window), box1);
       
@@ -3404,7 +4057,7 @@ create_item_factory (void)
 			  FALSE, FALSE, 0);
 
       label = gtk_label_new ("Type\n<alt>\nto start");
-      gtk_widget_set_usize (label, 200, 200);
+      gtk_widget_set_size_request (label, 200, 200);
       gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
 
@@ -3418,9 +4071,9 @@ create_item_factory (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -3433,6 +4086,86 @@ create_item_factory (void)
     gtk_widget_destroy (window);
 }
 
+static GtkWidget *
+accel_button_new (GtkAccelGroup *accel_group,
+		  const gchar   *text,
+		  const gchar   *accel)
+{
+  guint keyval;
+  GdkModifierType modifiers;
+  GtkWidget *button;
+  GtkWidget *label;
+
+  gtk_accelerator_parse (accel, &keyval, &modifiers);
+  g_assert (keyval);
+
+  button = gtk_button_new ();
+  gtk_widget_add_accelerator (button, "activate", accel_group,
+			      keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
+
+  label = gtk_accel_label_new (text);
+  gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
+  gtk_widget_show (label);
+  
+  gtk_container_add (GTK_CONTAINER (button), label);
+
+  return button;
+}
+
+static void
+create_key_lookup (GtkWidget *widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkAccelGroup *accel_group = gtk_accel_group_new ();
+      GtkWidget *button;
+      
+      window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
+					    GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+					    NULL);
+
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      /* We have to expand it so the accel labels will draw their labels
+       */
+      gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
+      
+      gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
+      
+      button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = accel_button_new (accel_group, "Button 8", "<Alt>d");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+      
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "response", G_CALLBACK (gtk_object_destroy), NULL);
+
+      gtk_widget_show_all (window);
+    }
+  else
+    gtk_widget_destroy (window);
+}
+
+
 /*
  create_modal_window
  */
@@ -3451,7 +4184,9 @@ cmw_color (GtkWidget *widget, GtkWidget *parent)
 {
     GtkWidget *csd;
 
-    csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
+    csd = gtk_color_selection_dialog_new ("This is a modal color selection dialog");
+
+    gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
 
     gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (csd)->colorsel),
                                          TRUE);
@@ -3462,15 +4197,13 @@ cmw_color (GtkWidget *widget, GtkWidget *parent)
     /* And mark it as a transient dialog */
     gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
     
-    gtk_signal_connect (GTK_OBJECT(csd), "destroy",
-		        GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
-
-    gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
-                               "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
-                               GTK_OBJECT (csd));
-    gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
-                               "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
-                               GTK_OBJECT (csd));
+    g_signal_connect (csd, "destroy",
+		      G_CALLBACK (cmw_destroy_cb), NULL);
+
+    g_signal_connect_swapped (GTK_COLOR_SELECTION_DIALOG (csd)->ok_button,
+			     "clicked", G_CALLBACK (gtk_widget_destroy), csd);
+    g_signal_connect_swapped (GTK_COLOR_SELECTION_DIALOG (csd)->cancel_button,
+			     "clicked", G_CALLBACK (gtk_widget_destroy), csd);
     
     /* wait until destroy calls gtk_main_quit */
     gtk_widget_show (csd);    
@@ -3484,21 +4217,21 @@ cmw_file (GtkWidget *widget, GtkWidget *parent)
 
     fs = gtk_file_selection_new("This is a modal file selection dialog");
 
+    gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
+
     /* Set as modal */
     gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
 
     /* And mark it as a transient dialog */
     gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
 
-    gtk_signal_connect (GTK_OBJECT(fs), "destroy",
-                        GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
+    g_signal_connect (fs, "destroy",
+                      G_CALLBACK (cmw_destroy_cb), NULL);
 
-    gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
-                               "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
-                               GTK_OBJECT (fs));
-    gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
-                               "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
-                               GTK_OBJECT (fs));
+    g_signal_connect_swapped (GTK_FILE_SELECTION (fs)->ok_button,
+			      "clicked", G_CALLBACK (gtk_widget_destroy), fs);
+    g_signal_connect_swapped (GTK_FILE_SELECTION (fs)->cancel_button,
+			      "clicked", G_CALLBACK (gtk_widget_destroy), fs);
     
     /* wait until destroy calls gtk_main_quit */
     gtk_widget_show (fs);
@@ -3508,7 +4241,7 @@ cmw_file (GtkWidget *widget, GtkWidget *parent)
 
 
 static void
-create_modal_window (void)
+create_modal_window (GtkWidget *widget)
 {
   GtkWidget *window = NULL;
   GtkWidget *box1,*box2;
@@ -3516,7 +4249,10 @@ create_modal_window (void)
   GtkWidget *btnColor,*btnFile,*btnClose;
 
   /* Create modal window (Here you can use any window descendent )*/
-  window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_screen (GTK_WINDOW (window),
+			 gtk_widget_get_screen (widget));
+
   gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
 
   /* Set window as modal */
@@ -3524,15 +4260,15 @@ create_modal_window (void)
 
   /* Create widgets */
   box1 = gtk_vbox_new (FALSE,5);
-   frame1 = gtk_frame_new ("Standard dialogs in modal form");
-    box2 = gtk_vbox_new (TRUE,5);
-     btnColor = gtk_button_new_with_label ("Color");
-     btnFile = gtk_button_new_with_label ("File Selection");
-     btnClose = gtk_button_new_with_label ("Close");
+  frame1 = gtk_frame_new ("Standard dialogs in modal form");
+  box2 = gtk_vbox_new (TRUE,5);
+  btnColor = gtk_button_new_with_label ("Color");
+  btnFile = gtk_button_new_with_label ("File Selection");
+  btnClose = gtk_button_new_with_label ("Close");
 
   /* Init widgets */
-  gtk_container_set_border_width (GTK_CONTAINER(box1),3);
-  gtk_container_set_border_width (GTK_CONTAINER(box2),3);
+  gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
+  gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
     
   /* Pack widgets */
   gtk_container_add (GTK_CONTAINER (window), box1);
@@ -3544,17 +4280,16 @@ create_modal_window (void)
   gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
    
   /* connect signals */
-  gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
-                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
-                             GTK_OBJECT (window));
+  g_signal_connect_swapped (btnClose, "clicked",
+			    G_CALLBACK (gtk_widget_destroy), window);
 
-  gtk_signal_connect (GTK_OBJECT (window), "destroy",
-                      GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
+  g_signal_connect (window, "destroy",
+                    G_CALLBACK (cmw_destroy_cb), NULL);
   
-  gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
-                      GTK_SIGNAL_FUNC (cmw_color),window);
-  gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
-                      GTK_SIGNAL_FUNC (cmw_file),window);
+  g_signal_connect (btnColor, "clicked",
+                    G_CALLBACK (cmw_color), window);
+  g_signal_connect (btnFile, "clicked",
+                    G_CALLBACK (cmw_file), window);
 
   /* Show widgets */
   gtk_widget_show_all (window);
@@ -3568,9 +4303,11 @@ create_modal_window (void)
  */
 
 static void
-make_message_dialog (GtkWidget **dialog,
+make_message_dialog (GdkScreen *screen,
+		     GtkWidget **dialog,
                      GtkMessageType  type,
-                     GtkButtonsType  buttons)
+                     GtkButtonsType  buttons,
+		     guint           default_response)
 {
   if (*dialog)
     {
@@ -3582,31 +4319,36 @@ make_message_dialog (GtkWidget **dialog,
   *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
                                     "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)");
 
-  gtk_signal_connect_object (GTK_OBJECT (*dialog),
-                             "response",
-                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
-                             GTK_OBJECT (*dialog));
-  
-  gtk_signal_connect (GTK_OBJECT (*dialog),
-                      "destroy",
-                      GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-                      dialog);
+  gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
+
+  g_signal_connect_swapped (*dialog,
+			    "response",
+			    G_CALLBACK (gtk_widget_destroy),
+			    *dialog);
   
+  g_signal_connect (*dialog,
+                    "destroy",
+                    G_CALLBACK (gtk_widget_destroyed),
+                    dialog);
+
+  gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
+
   gtk_widget_show (*dialog);
 }
 
 static void
-create_message_dialog (void)
+create_message_dialog (GtkWidget *widget)
 {
   static GtkWidget *info = NULL;
   static GtkWidget *warning = NULL;
   static GtkWidget *error = NULL;
   static GtkWidget *question = NULL;
+  GdkScreen *screen = gtk_widget_get_screen (widget);
 
-  make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);
-  make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE);
-  make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL);
-  make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO);
+  make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
+  make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
+  make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
+  make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
 }
 
 /*
@@ -3622,7 +4364,7 @@ scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *sc
 {
   gtk_widget_reparent (scrollwin, sw_parent);
   
-  gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
+  g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
   sw_float_parent = NULL;
   sw_parent = NULL;
   sw_destroyed_handler = 0;
@@ -3648,7 +4390,7 @@ scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
       gtk_widget_reparent (scrollwin, sw_parent);
       gtk_widget_destroy (sw_float_parent);
 
-      gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
+      g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
       sw_float_parent = NULL;
       sw_parent = NULL;
       sw_destroyed_handler = 0;
@@ -3657,21 +4399,24 @@ scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
     {
       sw_parent = scrollwin->parent;
       sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
+			     gtk_widget_get_screen (widget));
+      
       gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
       
       gtk_widget_reparent (scrollwin, sw_float_parent);
       gtk_widget_show (sw_float_parent);
 
       sw_destroyed_handler =
-	gtk_signal_connect (GTK_OBJECT (sw_parent), "destroy",
-			    GTK_SIGNAL_FUNC (scrolled_windows_destroy_cb), scrollwin);
-      gtk_signal_connect (GTK_OBJECT (sw_float_parent), "delete_event",
-			  GTK_SIGNAL_FUNC (scrolled_windows_delete_cb), scrollwin);
+	g_signal_connect (sw_parent, "destroy",
+			  G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
+      g_signal_connect (sw_float_parent, "delete_event",
+			G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
     }
 }
 
 static void
-create_scrolled_windows (void)
+create_scrolled_windows (GtkWidget *widget)
 {
   static GtkWidget *window;
   GtkWidget *scrolled_window;
@@ -3684,9 +4429,12 @@ create_scrolled_windows (void)
     {
       window = gtk_dialog_new ();
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "dialog");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -3723,9 +4471,9 @@ create_scrolled_windows (void)
 
 
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -3733,9 +4481,9 @@ create_scrolled_windows (void)
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("Reparent Out");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(scrolled_windows_remove),
-			  scrolled_window);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (scrolled_windows_remove),
+			scrolled_window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -3756,106 +4504,236 @@ create_scrolled_windows (void)
  */
 
 static void
-entry_toggle_frame (GtkWidget *checkbutton,
-                    GtkWidget *entry)
+entry_toggle_frame (GtkWidget *checkbutton,
+                    GtkWidget *entry)
+{
+   gtk_entry_set_has_frame (GTK_ENTRY(entry),
+                            GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static void
+entry_toggle_sensitive (GtkWidget *checkbutton,
+			GtkWidget *entry)
+{
+   gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static void
+entry_props_clicked (GtkWidget *button,
+		     GObject   *entry)
+{
+  GtkWidget *window = create_prop_editor (entry, 0);
+
+  gtk_window_set_title (GTK_WINDOW (window), "Entry Properties");
+}
+
+static void
+create_entry (GtkWidget *widget)
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *box1;
+  GtkWidget *box2;
+  GtkWidget *hbox;
+  GtkWidget *has_frame_check;
+  GtkWidget *sensitive_check;
+  GtkWidget *entry, *cb;
+  GtkWidget *button;
+  GtkWidget *separator;
+  GList *cbitems = NULL;
+
+  if (!window)
+    {
+      cbitems = g_list_append(cbitems, "item0");
+      cbitems = g_list_append(cbitems, "item1 item1");
+      cbitems = g_list_append(cbitems, "item2 item2 item2");
+      cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
+      cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
+      cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
+      cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
+      cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
+      cbitems = g_list_append(cbitems, "item8 item8 item8");
+      cbitems = g_list_append(cbitems, "item9 item9");
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+
+      gtk_window_set_title (GTK_WINDOW (window), "entry");
+      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+
+
+      box1 = gtk_vbox_new (FALSE, 0);
+      gtk_container_add (GTK_CONTAINER (window), box1);
+
+
+      box2 = gtk_vbox_new (FALSE, 10);
+      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
+      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
+
+      hbox = gtk_hbox_new (FALSE, 5);
+      gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
+      
+      entry = gtk_entry_new ();
+      gtk_entry_set_text (GTK_ENTRY (entry), "hello world \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205");
+      gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
+      gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
+
+      button = gtk_button_new_with_mnemonic ("_Props");
+      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (entry_props_clicked),
+			entry);
+
+      cb = gtk_combo_new ();
+      gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
+      gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world \n\n\n foo");
+      gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
+				  0, -1);
+      gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
+
+      sensitive_check = gtk_check_button_new_with_label("Sensitive");
+      gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
+      g_signal_connect (sensitive_check, "toggled",
+			G_CALLBACK (entry_toggle_sensitive), entry);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
+
+      has_frame_check = gtk_check_button_new_with_label("Has Frame");
+      gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
+      g_signal_connect (has_frame_check, "toggled",
+			G_CALLBACK (entry_toggle_frame), entry);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
+      
+      separator = gtk_hseparator_new ();
+      gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
+
+      box2 = gtk_vbox_new (FALSE, 10);
+      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
+      gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
+
+      button = gtk_button_new_with_label ("close");
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
+    }
+
+  if (!GTK_WIDGET_VISIBLE (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+}
+
+/* GtkEventBox */
+
+
+static void
+event_box_label_pressed (GtkWidget        *widget,
+			 GdkEventButton   *event,
+			 gpointer user_data)
+{
+  g_print ("clicked on event box\n");
+}
+
+static void
+event_box_button_clicked (GtkWidget *widget,
+			  GtkWidget *button,
+			  gpointer user_data)
 {
-   gtk_entry_set_has_frame (GTK_ENTRY(entry),
-                            GTK_TOGGLE_BUTTON(checkbutton)->active);
+  g_print ("pushed button\n");
 }
 
 static void
-entry_toggle_sensitive (GtkWidget *checkbutton,
-			GtkWidget *entry)
+event_box_toggle_visible_window (GtkWidget *checkbutton,
+				 GtkEventBox *event_box)
 {
-   gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+  gtk_event_box_set_visible_window (event_box,
+				    GTK_TOGGLE_BUTTON(checkbutton)->active);
 }
 
 static void
-entry_props_clicked (GtkWidget *button,
-		     GObject   *entry)
+event_box_toggle_above_child (GtkWidget *checkbutton,
+			      GtkEventBox *event_box)
 {
-  GtkWidget *window = create_prop_editor (entry, 0);
-
-  gtk_window_set_title (GTK_WINDOW (window), "Entry Properties");
+  gtk_event_box_set_above_child (event_box,
+				 GTK_TOGGLE_BUTTON(checkbutton)->active);
 }
 
 static void
-create_entry (void)
+create_event_box (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
   GtkWidget *box2;
   GtkWidget *hbox;
-  GtkWidget *has_frame_check;
-  GtkWidget *sensitive_check;
-  GtkWidget *entry, *cb;
+  GtkWidget *vbox;
   GtkWidget *button;
   GtkWidget *separator;
-  GList *cbitems = NULL;
+  GtkWidget *event_box;
+  GtkWidget *label;
+  GtkWidget *visible_window_check;
+  GtkWidget *above_child_check;
+  GdkColor color;
 
   if (!window)
     {
-      cbitems = g_list_append(cbitems, "item0");
-      cbitems = g_list_append(cbitems, "item1 item1");
-      cbitems = g_list_append(cbitems, "item2 item2 item2");
-      cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
-      cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
-      cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
-      cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
-      cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
-      cbitems = g_list_append(cbitems, "item8 item8 item8");
-      cbitems = g_list_append(cbitems, "item9 item9");
-
+      color.red = 0;
+      color.blue = 65535;
+      color.green = 0;
+      
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
-      gtk_window_set_title (GTK_WINDOW (window), "entry");
+      gtk_window_set_title (GTK_WINDOW (window), "event box");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 
-
       box1 = gtk_vbox_new (FALSE, 0);
       gtk_container_add (GTK_CONTAINER (window), box1);
+      gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
 
-
-      box2 = gtk_vbox_new (FALSE, 10);
-      gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
-      gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
-
-      hbox = gtk_hbox_new (FALSE, 5);
-      gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
+      hbox = gtk_hbox_new (FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
       
-      entry = gtk_entry_new ();
-      gtk_entry_set_text (GTK_ENTRY (entry), "hello world السلام عليكم");
-      gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
-      gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
-
-      button = gtk_button_new_with_mnemonic ("_Props");
-      gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (entry_props_clicked),
-			  entry);
+      event_box = gtk_event_box_new ();
+      gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
 
-      cb = gtk_combo_new ();
-      gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
-      gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world \n\n\n foo");
-      gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
-				  0, -1);
-      gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
+      vbox = gtk_vbox_new (FALSE, 0);
+      gtk_container_add (GTK_CONTAINER (event_box), vbox);
+      g_signal_connect (event_box, "button_press_event",
+			G_CALLBACK (event_box_label_pressed),
+			NULL);
+      
+      label = gtk_label_new ("Click on this label");
+      gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
 
-      sensitive_check = gtk_check_button_new_with_label("Sensitive");
-      gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
-			  GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
-      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
+      button = gtk_button_new_with_label ("button in eventbox");
+      gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (event_box_button_clicked),
+			NULL);
+      
 
-      has_frame_check = gtk_check_button_new_with_label("Has Frame");
-      gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT(has_frame_check), "toggled",
-			  GTK_SIGNAL_FUNC(entry_toggle_frame), entry);
-      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(has_frame_check), TRUE);
+      visible_window_check = gtk_check_button_new_with_label("Visible Window");
+      gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
+      g_signal_connect (visible_window_check, "toggled",
+			G_CALLBACK (event_box_toggle_visible_window), event_box);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
+      
+      above_child_check = gtk_check_button_new_with_label("Above Child");
+      gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
+      g_signal_connect (above_child_check, "toggled",
+			G_CALLBACK (event_box_toggle_above_child), event_box);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
       
       separator = gtk_hseparator_new ();
       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
@@ -3865,9 +4743,9 @@ create_entry (void)
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -3879,6 +4757,7 @@ create_entry (void)
     gtk_widget_destroy (window);
 }
 
+
 /*
  * GtkSizeGroup
  */
@@ -3889,22 +4768,23 @@ static void
 size_group_hsize_changed (GtkSpinButton *spin_button,
 			  GtkWidget     *button)
 {
-  gtk_widget_set_usize (GTK_BIN (button)->child,
-			gtk_spin_button_get_value_as_int (spin_button),
-			-2);
+  gtk_widget_set_size_request (GTK_BIN (button)->child,
+			       gtk_spin_button_get_value_as_int (spin_button),
+			       -1);
 }
 
 static void
 size_group_vsize_changed (GtkSpinButton *spin_button,
 			  GtkWidget     *button)
 {
-  gtk_widget_set_usize (GTK_BIN (button)->child,
-			-2,
-			gtk_spin_button_get_value_as_int (spin_button));
+  gtk_widget_set_size_request (GTK_BIN (button)->child,
+			       -1,
+			       gtk_spin_button_get_value_as_int (spin_button));
 }
 
 static GtkWidget *
-create_size_group_window (GtkSizeGroup *master_size_group)
+create_size_group_window (GdkScreen    *screen,
+			  GtkSizeGroup *master_size_group)
 {
   GtkWidget *window;
   GtkWidget *table;
@@ -3923,11 +4803,13 @@ create_size_group_window (GtkSizeGroup *master_size_group)
 					GTK_RESPONSE_NONE,
 					NULL);
 
+  gtk_window_set_screen (GTK_WINDOW (window), screen);
+
   gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
 
-  gtk_signal_connect (GTK_OBJECT (window), "response",
-		      GTK_SIGNAL_FUNC (gtk_widget_destroy),
-		      NULL);
+  g_signal_connect (window, "response",
+		    G_CALLBACK (gtk_widget_destroy),
+		    NULL);
 
   table = gtk_table_new (2, 2, FALSE);
   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), table, TRUE, TRUE, 0);
@@ -3935,7 +4817,7 @@ create_size_group_window (GtkSizeGroup *master_size_group)
   gtk_table_set_row_spacings (GTK_TABLE (table), 5);
   gtk_table_set_col_spacings (GTK_TABLE (table), 5);
   gtk_container_set_border_width (GTK_CONTAINER (table), 5);
-  gtk_widget_set_usize (table, 250, 250);
+  gtk_widget_set_size_request (table, 250, 250);
 
   hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
   hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
@@ -3951,7 +4833,9 @@ create_size_group_window (GtkSizeGroup *master_size_group)
   gtk_size_group_add_widget (master_size_group, main_button);
   gtk_size_group_add_widget (hgroup1, main_button);
   gtk_size_group_add_widget (vgroup1, main_button);
-  gtk_widget_set_usize (GTK_BIN (main_button)->child, SIZE_GROUP_INITIAL_SIZE, SIZE_GROUP_INITIAL_SIZE);
+  gtk_widget_set_size_request (GTK_BIN (main_button)->child,
+			       SIZE_GROUP_INITIAL_SIZE,
+			       SIZE_GROUP_INITIAL_SIZE);
 
   button = gtk_button_new ();
   gtk_table_attach (GTK_TABLE (table), button,
@@ -3977,10 +4861,10 @@ create_size_group_window (GtkSizeGroup *master_size_group)
   gtk_size_group_add_widget (hgroup2, button);
   gtk_size_group_add_widget (vgroup2, button);
 
-  g_object_unref (G_OBJECT (hgroup1));
-  g_object_unref (G_OBJECT (hgroup2));
-  g_object_unref (G_OBJECT (vgroup1));
-  g_object_unref (G_OBJECT (vgroup2));
+  g_object_unref (hgroup1);
+  g_object_unref (hgroup2);
+  g_object_unref (vgroup1);
+  g_object_unref (vgroup2);
   
   hbox = gtk_hbox_new (FALSE, 5);
   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox, FALSE, FALSE, 0);
@@ -3988,20 +4872,20 @@ create_size_group_window (GtkSizeGroup *master_size_group)
   spin_button = gtk_spin_button_new_with_range (1, 100, 1);
   gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
   gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
-  gtk_signal_connect (GTK_OBJECT (spin_button), "value_changed",
-		      GTK_SIGNAL_FUNC (size_group_hsize_changed), main_button);
+  g_signal_connect (spin_button, "value_changed",
+		    G_CALLBACK (size_group_hsize_changed), main_button);
 
   spin_button = gtk_spin_button_new_with_range (1, 100, 1);
   gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
   gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
-  gtk_signal_connect (GTK_OBJECT (spin_button), "value_changed",
-		      GTK_SIGNAL_FUNC (size_group_vsize_changed), main_button);
+  g_signal_connect (spin_button, "value_changed",
+		    G_CALLBACK (size_group_vsize_changed), main_button);
 
   return window;
 }
 
 static void
-create_size_groups (void)
+create_size_groups (GtkWidget *widget)
 {
   static GtkWidget *window1 = NULL;
   static GtkWidget *window2 = NULL;
@@ -4009,23 +4893,25 @@ create_size_groups (void)
 
   if (!master_size_group)
     master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
-  
+
   if (!window1)
     {
-      window1 = create_size_group_window (master_size_group);
+      window1 = create_size_group_window (gtk_widget_get_screen (widget),
+					  master_size_group);
 
-      gtk_signal_connect (GTK_OBJECT (window1), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window1);
+      g_signal_connect (window1, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window1);
     }
 
   if (!window2)
     {
-      window2 = create_size_group_window (master_size_group);
+      window2 = create_size_group_window (gtk_widget_get_screen (widget),
+					  master_size_group);
 
-      gtk_signal_connect (GTK_OBJECT (window2), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window2);
+      g_signal_connect (window2, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window2);
     }
 
   if (GTK_WIDGET_VISIBLE (window1) && GTK_WIDGET_VISIBLE (window2))
@@ -4075,12 +4961,11 @@ get_value (GtkWidget *widget, gpointer data)
   GtkSpinButton *spin;
 
   spin = GTK_SPIN_BUTTON (spinner1);
-  label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
+  label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
   if (GPOINTER_TO_INT (data) == 1)
     sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
   else
-    sprintf (buf, "%0.*f", spin->digits,
-	     gtk_spin_button_get_value_as_float (spin));
+    sprintf (buf, "%0.*f", spin->digits, gtk_spin_button_get_value (spin));
   gtk_label_set_text (label, buf);
 }
 
@@ -4095,7 +4980,7 @@ get_spin_value (GtkWidget *widget, gpointer data)
   label = GTK_LABEL (data);
 
   buffer = g_strdup_printf ("%0.*f", spin->digits,
-			    gtk_spin_button_get_value_as_float (spin));
+			    gtk_spin_button_get_value (spin));
   gtk_label_set_text (label, buffer);
 
   g_free (buffer);
@@ -4129,10 +5014,8 @@ spin_button_month_input_func (GtkSpinButton *spin_button,
 
   for (i = 1; i <= 12; i++)
     {
-      tmp1 = g_strdup (month[i-1]);
-      g_strup (tmp1);
-      tmp2 = g_strdup (gtk_entry_get_text (GTK_ENTRY (spin_button)));
-      g_strup (tmp2);
+      tmp1 = g_ascii_strup (month[i - 1], -1);
+      tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
       if (strstr (tmp1, tmp2) == tmp1)
 	found = TRUE;
       g_free (tmp1);
@@ -4200,7 +5083,7 @@ spin_button_hex_output_func (GtkSpinButton *spin_button)
 }
 
 static void
-create_spins (void)
+create_spins (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *frame;
@@ -4218,10 +5101,12 @@ create_spins (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
       
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
       
       gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
       
@@ -4251,12 +5136,12 @@ create_spins (void)
       adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
       spinner = gtk_spin_button_new (adj, 0, 0);
       gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
-      gtk_signal_connect (GTK_OBJECT (spinner),
-			  "output",
-			  GTK_SIGNAL_FUNC (spin_button_time_output_func),
-			  NULL);
+      g_signal_connect (spinner,
+			"output",
+			G_CALLBACK (spin_button_time_output_func),
+			NULL);
       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
-      gtk_widget_set_usize (spinner, 55, -1);
+      gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
 
       vbox2 = gtk_vbox_new (FALSE, 0);
@@ -4271,16 +5156,16 @@ create_spins (void)
       spinner = gtk_spin_button_new (adj, 0, 0);
       gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
 					 GTK_UPDATE_IF_VALID);
-      gtk_signal_connect (GTK_OBJECT (spinner),
-			  "input",
-			  GTK_SIGNAL_FUNC (spin_button_month_input_func),
-			  NULL);
-      gtk_signal_connect (GTK_OBJECT (spinner),
-			  "output",
-			  GTK_SIGNAL_FUNC (spin_button_month_output_func),
-			  NULL);
+      g_signal_connect (spinner,
+			"input",
+			G_CALLBACK (spin_button_month_input_func),
+			NULL);
+      g_signal_connect (spinner,
+			"output",
+			G_CALLBACK (spin_button_month_output_func),
+			NULL);
       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
-      gtk_widget_set_usize (spinner, 85, -1);
+      gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
       
       vbox2 = gtk_vbox_new (FALSE, 0);
@@ -4293,16 +5178,16 @@ create_spins (void)
       adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 255, 1, 16, 0);
       spinner = gtk_spin_button_new (adj, 0, 0);
       gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
-      gtk_signal_connect (GTK_OBJECT (spinner),
-			  "input",
-			  GTK_SIGNAL_FUNC (spin_button_hex_input_func),
-			  NULL);
-      gtk_signal_connect (GTK_OBJECT (spinner),
-			  "output",
-			  GTK_SIGNAL_FUNC (spin_button_hex_output_func),
-			  NULL);
+      g_signal_connect (spinner,
+			"input",
+			G_CALLBACK (spin_button_hex_input_func),
+			NULL);
+      g_signal_connect (spinner,
+			"output",
+			G_CALLBACK (spin_button_hex_output_func),
+			NULL);
       gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
-      gtk_widget_set_usize (spinner, 55, 0);
+      gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
       gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
 
       frame = gtk_frame_new ("Accelerated");
@@ -4337,25 +5222,25 @@ create_spins (void)
 
       adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 15, 1, 1, 0);
       spinner2 = gtk_spin_button_new (adj, 0.0, 0);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (change_digits),
-			  (gpointer) spinner2);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (change_digits),
+			spinner2);
       gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
 
       hbox = gtk_hbox_new (FALSE, 0);
       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
 
       button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (toggle_snap),
-			  spinner1);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (toggle_snap),
+			spinner1);
       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 
       button = gtk_check_button_new_with_label ("Numeric only input mode");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (toggle_numeric),
-			  spinner1);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (toggle_numeric),
+			spinner1);
       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 
@@ -4365,17 +5250,17 @@ create_spins (void)
       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
 
       button = gtk_button_new_with_label ("Value as Int");
-      gtk_object_set_user_data (GTK_OBJECT (button), val_label);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (get_value),
-			  GINT_TO_POINTER (1));
+      g_object_set_data (G_OBJECT (button), "user_data", val_label);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (get_value),
+			GINT_TO_POINTER (1));
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
 
       button = gtk_button_new_with_label ("Value as Float");
-      gtk_object_set_user_data (GTK_OBJECT (button), val_label);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (get_value),
-			  GINT_TO_POINTER (2));
+      g_object_set_data (G_OBJECT (button), "user_data", val_label);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (get_value),
+			GINT_TO_POINTER (2));
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
 
       gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
@@ -4392,8 +5277,8 @@ create_spins (void)
 
       spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
       gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
-      gtk_signal_connect (GTK_OBJECT (spinner), "value_changed",
-			  GTK_SIGNAL_FUNC (get_spin_value), val_label);
+      g_signal_connect (spinner, "value_changed",
+			G_CALLBACK (get_spin_value), val_label);
       gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
       gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
 
@@ -4401,9 +5286,9 @@ create_spins (void)
       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
   
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
     }
 
@@ -4473,13 +5358,17 @@ set_cursor (GtkWidget *spinner,
   guint c;
   GdkCursor *cursor;
   GtkWidget *label;
-  GtkEnumValue *vals;
+  GEnumClass *class;
+  GEnumValue *vals;
 
   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
   c &= 0xfe;
 
-  label = gtk_object_get_user_data (GTK_OBJECT (spinner));
-  vals = gtk_type_enum_get_values (GDK_TYPE_CURSOR_TYPE);
+  label = g_object_get_data (G_OBJECT (spinner), "user_data");
+  
+  class = gtk_type_class (GDK_TYPE_CURSOR_TYPE);
+  vals = class->values;
+
   while (vals && vals->value != c)
     vals++;
   if (vals)
@@ -4487,7 +5376,7 @@ set_cursor (GtkWidget *spinner,
   else
     gtk_label_set_text (GTK_LABEL (label), "<unknown>");
 
-  cursor = gdk_cursor_new (c);
+  cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
   gdk_window_set_cursor (widget->window, cursor);
   gdk_cursor_unref (cursor);
 }
@@ -4510,7 +5399,7 @@ cursor_event (GtkWidget          *widget,
 }
 
 static void
-create_cursors (void)
+create_cursors (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *frame;
@@ -4527,10 +5416,12 @@ create_cursors (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window), 
+			     gtk_widget_get_screen (widget));
       
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
       
       gtk_window_set_title (GTK_WINDOW (window), "Cursors");
       
@@ -4573,22 +5464,22 @@ create_cursors (void)
 			NULL);
 
       darea = gtk_drawing_area_new ();
-      gtk_widget_set_usize (darea, 80, 80);
+      gtk_widget_set_size_request (darea, 80, 80);
       gtk_container_add (GTK_CONTAINER (frame), darea);
-      gtk_signal_connect (GTK_OBJECT (darea),
-			  "expose_event",
-			  GTK_SIGNAL_FUNC (cursor_expose_event),
-			  NULL);
+      g_signal_connect (darea,
+			"expose_event",
+			G_CALLBACK (cursor_expose_event),
+			NULL);
       gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
-      gtk_signal_connect (GTK_OBJECT (darea),
-			  "button_press_event",
-			  GTK_SIGNAL_FUNC (cursor_event),
-			  spinner);
+      g_signal_connect (darea,
+			"button_press_event",
+			G_CALLBACK (cursor_event),
+			spinner);
       gtk_widget_show (darea);
 
-      gtk_signal_connect (GTK_OBJECT (spinner), "changed",
-			  GTK_SIGNAL_FUNC (set_cursor),
-			  darea);
+      g_signal_connect (spinner, "changed",
+			G_CALLBACK (set_cursor),
+			darea);
 
       label = gtk_widget_new (GTK_TYPE_LABEL,
 			      "visible", TRUE,
@@ -4598,7 +5489,7 @@ create_cursors (void)
       gtk_container_child_set (GTK_CONTAINER (vbox), label,
 			       "expand", FALSE,
 			       NULL);
-      gtk_object_set_user_data (GTK_OBJECT (spinner), label);
+      g_object_set_data (G_OBJECT (spinner), "user_data", label);
 
       any =
 	gtk_widget_new (gtk_hseparator_get_type (),
@@ -4611,9 +5502,9 @@ create_cursors (void)
       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
 
       gtk_widget_show_all (window);
@@ -4696,6 +5587,19 @@ list_clear (GtkWidget *widget,
   gtk_list_clear_items (GTK_LIST (list), 0, -1);
 }
 
+static gchar *selection_mode_items[] =
+{
+  "Single",
+  "Browse",
+  "Multiple"
+};
+
+static const GtkSelectionMode selection_modes[] = {
+  GTK_SELECTION_SINGLE,
+  GTK_SELECTION_BROWSE,
+  GTK_SELECTION_MULTIPLE
+};
+
 static GtkWidget *list_omenu;
 
 static void 
@@ -4711,21 +5615,14 @@ list_toggle_sel_mode (GtkWidget *widget, gpointer data)
 
   i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
 
-  gtk_list_set_selection_mode (list, (GtkSelectionMode) i);
+  gtk_list_set_selection_mode (list, selection_modes[i]);
 }
 
 static void
-create_list (void)
+create_list (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
 
-  static gchar *items[] =
-  {
-    "Single",
-    "Browse",
-    "Multiple"
-  };
-
   if (!window)
     {
       GtkWidget *cbox;
@@ -4740,9 +5637,12 @@ create_list (void)
 
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "list");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -4752,14 +5652,14 @@ create_list (void)
 
       scrolled_win = gtk_scrolled_window_new (NULL, NULL);
       gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
-      gtk_widget_set_usize (scrolled_win, -1, 300);
+      gtk_widget_set_size_request (scrolled_win, -1, 300);
       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
 				      GTK_POLICY_AUTOMATIC,
 				      GTK_POLICY_AUTOMATIC);
 
       list = gtk_list_new ();
-      gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
+      gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_SINGLE);
       gtk_scrolled_window_add_with_viewport
 	(GTK_SCROLLED_WINDOW (scrolled_win), list);
       gtk_container_set_focus_vadjustment
@@ -4771,7 +5671,7 @@ create_list (void)
 	 gtk_scrolled_window_get_hadjustment
 	 (GTK_SCROLLED_WINDOW (scrolled_win)));
 
-      if ((infile = fopen("gtkenums.h", "r")))
+      if ((infile = fopen("../gtk/gtkenums.h", "r")))
 	{
 	  char buffer[256];
 	  char *pos;
@@ -4795,21 +5695,21 @@ create_list (void)
 
       button = gtk_button_new_with_label ("Insert Row");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (list_add),
-			  list);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (list_add),
+			list);
 
       button = gtk_button_new_with_label ("Clear List");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (list_clear),
-			  list);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (list_clear),
+			list);
 
       button = gtk_button_new_with_label ("Remove Selection");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (list_remove),
-			  list);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (list_remove),
+			list);
 
       cbox = gtk_hbox_new (FALSE, 0);
       gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
@@ -4821,7 +5721,7 @@ create_list (void)
       label = gtk_label_new ("Selection Mode :");
       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
 
-      list_omenu = build_option_menu (items, 3, 3, 
+      list_omenu = build_option_menu (selection_mode_items, 3, 3, 
 				      list_toggle_sel_mode,
 				      list);
       gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
@@ -4835,9 +5735,9 @@ create_list (void)
       button = gtk_button_new_with_label ("close");
       gtk_container_set_border_width (GTK_CONTAINER (button), 10);
       gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
 
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_widget_grab_default (button);
@@ -5005,8 +5905,8 @@ add1000_clist (GtkWidget *widget, gpointer data)
 
   gtk_clist_thaw (GTK_CLIST (data));
 
-  gdk_pixmap_unref (pixmap);
-  gdk_bitmap_unref (mask);
+  g_object_unref (pixmap);
+  g_object_unref (mask);
 }
 
 static void
@@ -5143,7 +6043,7 @@ clist_warning_test (GtkWidget *button,
   add_remove = !add_remove;
 
   child = gtk_label_new ("Test");
-  gtk_widget_ref (child);
+  g_object_ref (child);
   gtk_object_sink (GTK_OBJECT (child));
 
   if (add_remove)
@@ -5178,7 +6078,7 @@ clist_toggle_sel_mode (GtkWidget *widget, gpointer data)
 
   i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
 
-  gtk_clist_set_selection_mode (clist, (GtkSelectionMode) i);
+  gtk_clist_set_selection_mode (clist, selection_modes[i]);
 }
 
 static void 
@@ -5200,7 +6100,7 @@ clist_click_column (GtkCList *clist, gint column, gpointer data)
 }
 
 static void
-create_clist (void)
+create_clist (GtkWidget *widget)
 {
   gint i;
   static GtkWidget *window = NULL;
@@ -5212,13 +6112,6 @@ create_clist (void)
     "Title 8",  "Title 9",  "Title 10", "Title 11"
   };
 
-  static gchar *items[] =
-  {
-    "Single",
-    "Browse",
-    "Multiple",
-  };
-
   char text[TESTGTK_CLIST_COLUMNS][50];
   char *texts[TESTGTK_CLIST_COLUMNS];
 
@@ -5241,9 +6134,11 @@ create_clist (void)
     {
       clist_rows = 0;
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window), 
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed), &window);
 
       gtk_window_set_title (GTK_WINDOW (window), "clist");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -5261,8 +6156,8 @@ create_clist (void)
        * button callbacks -- more is done with it later */
       clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
       gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
-      gtk_signal_connect (GTK_OBJECT (clist), "click_column",
-			  (GtkSignalFunc) clist_click_column, NULL);
+      g_signal_connect (clist, "click_column",
+			G_CALLBACK (clist_click_column), NULL);
 
       /* control buttons */
       hbox = gtk_hbox_new (FALSE, 5);
@@ -5271,18 +6166,18 @@ create_clist (void)
 
       button = gtk_button_new_with_label ("Insert Row");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-                          (GtkSignalFunc) insert_row_clist, (gpointer) clist);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (insert_row_clist), clist);
 
       button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-                          (GtkSignalFunc) add1000_clist, (gpointer) clist);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (add1000_clist), clist);
 
       button = gtk_button_new_with_label ("Add 10,000 Rows");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-                          (GtkSignalFunc) add10000_clist, (gpointer) clist);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (add10000_clist), clist);
 
       /* second layer of buttons */
       hbox = gtk_hbox_new (FALSE, 5);
@@ -5291,24 +6186,23 @@ create_clist (void)
 
       button = gtk_button_new_with_label ("Clear List");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-                          (GtkSignalFunc) clear_clist, (gpointer) clist);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (clear_clist), clist);
 
       button = gtk_button_new_with_label ("Remove Selection");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-                          (GtkSignalFunc) clist_remove_selection,
-			  (gpointer) clist);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (clist_remove_selection), clist);
 
       undo_button = gtk_button_new_with_label ("Undo Selection");
       gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
-                          (GtkSignalFunc) undo_selection, (gpointer) clist);
+      g_signal_connect (undo_button, "clicked",
+			G_CALLBACK (undo_selection), clist);
 
       button = gtk_button_new_with_label ("Warning Test");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-                          (GtkSignalFunc) clist_warning_test,(gpointer) clist);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (clist_warning_test), clist);
 
       /* third layer of buttons */
       hbox = gtk_hbox_new (FALSE, 5);
@@ -5317,20 +6211,20 @@ create_clist (void)
 
       check = gtk_check_button_new_with_label ("Show Title Buttons");
       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (check), "clicked",
-			  GTK_SIGNAL_FUNC (toggle_title_buttons), clist);
+      g_signal_connect (check, "clicked",
+			G_CALLBACK (toggle_title_buttons), clist);
       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
 
       check = gtk_check_button_new_with_label ("Reorderable");
       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (check), "clicked",
-			  GTK_SIGNAL_FUNC (toggle_reorderable), clist);
+      g_signal_connect (check, "clicked",
+			G_CALLBACK (toggle_reorderable), clist);
       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
 
       label = gtk_label_new ("Selection Mode :");
       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
 
-      clist_omenu = build_option_menu (items, 3, 3, 
+      clist_omenu = build_option_menu (selection_mode_items, 3, 3, 
 				       clist_toggle_sel_mode,
 				       clist);
       gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
@@ -5341,7 +6235,7 @@ create_clist (void)
 
       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
       gtk_clist_set_row_height (GTK_CLIST (clist), 18);
-      gtk_widget_set_usize (clist, -1, 300);
+      gtk_widget_set_size_request (clist, -1, 300);
 
       for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
 	gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
@@ -5406,9 +6300,9 @@ create_clist (void)
       button = gtk_button_new_with_label ("close");
       gtk_container_set_border_width (GTK_CONTAINER (button), 10);
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
 
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_widget_grab_default (button);
@@ -5427,12 +6321,15 @@ create_clist (void)
  * GtkCTree
  */
 
-GdkPixmap *pixmap1;
-GdkPixmap *pixmap2;
-GdkPixmap *pixmap3;
-GdkBitmap *mask1;
-GdkBitmap *mask2;
-GdkBitmap *mask3;
+typedef struct 
+{
+  GdkPixmap *pixmap1;
+  GdkPixmap *pixmap2;
+  GdkPixmap *pixmap3;
+  GdkBitmap *mask1;
+  GdkBitmap *mask2;
+  GdkBitmap *mask3;
+} CTreePixmaps;
 
 static gint books = 0;
 static gint pages = 0;
@@ -5450,6 +6347,34 @@ static GtkWidget *spin2;
 static GtkWidget *spin3;
 static gint line_style;
 
+
+static CTreePixmaps *
+get_ctree_pixmaps (GtkCTree *ctree)
+{
+  GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (ctree));
+  CTreePixmaps *pixmaps = g_object_get_data (G_OBJECT (screen), "ctree-pixmaps");
+
+  if (!pixmaps)
+    {
+      GdkColormap *colormap = gdk_screen_get_rgb_colormap (screen);
+      pixmaps = g_new (CTreePixmaps, 1);
+      
+      pixmaps->pixmap1 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+								&pixmaps->mask1, 
+								NULL, book_closed_xpm);
+      pixmaps->pixmap2 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+								&pixmaps->mask2, 
+								NULL, book_open_xpm);
+      pixmaps->pixmap3 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+								&pixmaps->mask3,
+								NULL, mini_page_xpm);
+      
+      g_object_set_data (G_OBJECT (screen), "ctree-pixmaps", pixmaps);
+    }
+
+  return pixmaps;
+}
+
 void after_press (GtkCTree *ctree, gpointer data)
 {
   char buf[80];
@@ -5624,23 +6549,26 @@ gnode2ctree (GtkCTree   *ctree,
   GdkBitmap *mask_closed;
   GdkPixmap *pixmap_opened;
   GdkBitmap *mask_opened;
+  CTreePixmaps *pixmaps;
 
   if (!cnode || !gnode || (!(es = gnode->data)))
     return FALSE;
 
+  pixmaps = get_ctree_pixmaps (ctree);
+
   if (es->is_leaf)
     {
-      pixmap_closed = pixmap3;
-      mask_closed = mask3;
+      pixmap_closed = pixmaps->pixmap3;
+      mask_closed = pixmaps->mask3;
       pixmap_opened = NULL;
       mask_opened = NULL;
     }
   else
     {
-      pixmap_closed = pixmap1;
-      mask_closed = mask1;
-      pixmap_opened = pixmap2;
-      mask_opened = mask2;
+      pixmap_closed = pixmaps->pixmap1;
+      mask_closed = pixmaps->mask1;
+      pixmap_opened = pixmaps->pixmap2;
+      mask_opened = pixmaps->mask2;
     }
 
   gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
@@ -5688,10 +6616,13 @@ void export_ctree (GtkWidget *widget, GtkCTree *ctree)
   if (!export_window)
     {
       export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+      gtk_window_set_screen (GTK_WINDOW (export_window),
+			     gtk_widget_get_screen (widget));
   
-      gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &export_window);
+      g_signal_connect (export_window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&export_window);
 
       gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
       gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
@@ -5702,9 +6633,9 @@ void export_ctree (GtkWidget *widget, GtkCTree *ctree)
       button = gtk_button_new_with_label ("Close");
       gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
 
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 (GtkSignalFunc) gtk_widget_destroy,
-				 GTK_OBJECT(export_window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				export_window);
 
       sep = gtk_hseparator_new ();
       gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
@@ -5723,7 +6654,7 @@ void export_ctree (GtkWidget *widget, GtkCTree *ctree)
 				    GTK_SELECTION_EXTENDED);
       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
       gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
-      gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
+      gtk_widget_set_size_request (GTK_WIDGET (export_ctree), 300, 200);
     }
 
   if (!GTK_WIDGET_VISIBLE (export_window))
@@ -5847,7 +6778,7 @@ ctree_toggle_sel_mode (GtkWidget *widget, gpointer data)
 
   i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
 
-  gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) i);
+  gtk_clist_set_selection_mode (GTK_CLIST (ctree), selection_modes[i]);
   after_press (ctree, NULL);
 }
     
@@ -5858,19 +6789,22 @@ void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
   gchar buf1[60];
   gchar buf2[60];
   GtkCTreeNode *sibling;
+  CTreePixmaps *pixmaps;
   gint i;
 
   text[0] = buf1;
   text[1] = buf2;
   sibling = NULL;
 
+  pixmaps = get_ctree_pixmaps (ctree);
+
   for (i = num_pages + num_books; i > num_books; i--)
     {
       pages++;
       sprintf (buf1, "Page %02d", (gint) rand() % 100);
       sprintf (buf2, "Item %d-%d", cur_depth, i);
       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
-				       pixmap3, mask3, NULL, NULL,
+				       pixmaps->pixmap3, pixmaps->mask3, NULL, NULL,
 				       TRUE, FALSE);
 
       if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
@@ -5889,7 +6823,7 @@ void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
       sprintf (buf1, "Book %02d", (gint) rand() % 100);
       sprintf (buf2, "Item %d-%d", cur_depth, i);
       sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
-				       pixmap1, mask1, pixmap2, mask2,
+				       pixmaps->pixmap1, pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2,
 				       FALSE, FALSE);
 
       style = gtk_style_new ();
@@ -5930,6 +6864,9 @@ void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
   GtkCTreeNode *parent;
   GtkStyle *style;
   guint b, d, p, n;
+  CTreePixmaps *pixmaps;
+
+  pixmaps = get_ctree_pixmaps (ctree);
 
   text[0] = label1;
   text[1] = label2;
@@ -5952,8 +6889,8 @@ void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
   books = 1;
   pages = 0;
 
-  parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
-				  mask1, pixmap2, mask2, FALSE, TRUE);
+  parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmaps->pixmap1,
+				  pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2, FALSE, TRUE);
 
   style = gtk_style_new ();
   style->base[GTK_STATE_NORMAL].red   = 0;
@@ -5990,7 +6927,7 @@ ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
   gtk_ctree_sort_recursive (ctree, NULL);
 }
 
-void create_ctree (void)
+void create_ctree (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkTooltips *tooltips;
@@ -6007,7 +6944,6 @@ void create_ctree (void)
   GtkWidget *check;
   GtkAdjustment *adj;
   GtkWidget *spinner;
-  GdkColor transparent = { 0 };
 
   char *title[] = { "Tree" , "Info" };
   char buf[80];
@@ -6034,30 +6970,25 @@ void create_ctree (void)
     "Right"
   };
   
-  static gchar *items4[] =
-  {
-    "Single",
-    "Browse",
-    "Multiple",
-  };
-
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window), 
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 
       tooltips = gtk_tooltips_new ();
-      gtk_object_ref (GTK_OBJECT (tooltips));
+      g_object_ref (tooltips);
       gtk_object_sink (GTK_OBJECT (tooltips));
 
-      gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
-				(GtkDestroyNotify) gtk_object_unref);
+      g_object_set_data_full (G_OBJECT (window), "tooltips", tooltips,
+			      g_object_unref);
 
       vbox = gtk_vbox_new (FALSE, 0);
       gtk_container_add (GTK_CONTAINER (window), vbox);
@@ -6090,9 +7021,9 @@ void create_ctree (void)
       button = gtk_button_new_with_label ("Close");
       gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
 
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 (GtkSignalFunc) gtk_widget_destroy,
-				 GTK_OBJECT(window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
 
       button = gtk_button_new_with_label ("Rebuild Tree");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
@@ -6113,27 +7044,27 @@ void create_ctree (void)
       gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
       line_style = GTK_CTREE_LINES_DOTTED;
 
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (rebuild_tree), ctree);
-      gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
-			  (GtkSignalFunc) ctree_click_column, NULL);
-
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
-				GTK_SIGNAL_FUNC (after_press), NULL);
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
-				GTK_SIGNAL_FUNC (after_press), NULL);
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
-				GTK_SIGNAL_FUNC (after_move), NULL);
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
-				GTK_SIGNAL_FUNC (after_press), NULL);
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
-				GTK_SIGNAL_FUNC (after_press), NULL);
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
-				GTK_SIGNAL_FUNC (after_press), NULL);
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
-				GTK_SIGNAL_FUNC (after_press), NULL);
-      gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
-				GTK_SIGNAL_FUNC (after_press), NULL);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (rebuild_tree), ctree);
+      g_signal_connect (ctree, "click_column",
+			G_CALLBACK (ctree_click_column), NULL);
+
+      g_signal_connect_after (ctree, "button_press_event",
+			      G_CALLBACK (after_press), NULL);
+      g_signal_connect_after (ctree, "button_release_event",
+			      G_CALLBACK (after_press), NULL);
+      g_signal_connect_after (ctree, "tree_move",
+			      G_CALLBACK (after_move), NULL);
+      g_signal_connect_after (ctree, "end_selection",
+			      G_CALLBACK (after_press), NULL);
+      g_signal_connect_after (ctree, "toggle_focus_row",
+			      G_CALLBACK (after_press), NULL);
+      g_signal_connect_after (ctree, "select_all",
+			      G_CALLBACK (after_press), NULL);
+      g_signal_connect_after (ctree, "unselect_all",
+			      G_CALLBACK (after_press), NULL);
+      g_signal_connect_after (ctree, "scroll_vertical",
+			      G_CALLBACK (after_press), NULL);
 
       bbox = gtk_hbox_new (FALSE, 5);
       gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
@@ -6159,23 +7090,23 @@ void create_ctree (void)
       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
       gtk_tooltips_set_tip (tooltips, spinner,
 			    "Row height of list items", NULL);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (change_row_height), ctree);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (change_row_height), ctree);
       gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
 
       adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
       spinner = gtk_spin_button_new (adj, 0, 0);
       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
       gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (change_indent), ctree);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (change_indent), ctree);
 
       adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
       spinner = gtk_spin_button_new (adj, 0, 0);
       gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
       gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (change_spacing), ctree);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (change_spacing), ctree);
 
       mbox = gtk_vbox_new (TRUE, 5);
       gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
@@ -6185,48 +7116,48 @@ void create_ctree (void)
 
       button = gtk_button_new_with_label ("Expand All");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (expand_all), ctree);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (expand_all), ctree);
 
       button = gtk_button_new_with_label ("Collapse All");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (collapse_all), ctree);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (collapse_all), ctree);
 
       button = gtk_button_new_with_label ("Change Style");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (change_style), ctree);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (change_style), ctree);
 
       button = gtk_button_new_with_label ("Export Tree");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (export_ctree), ctree);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (export_ctree), ctree);
 
       hbox = gtk_hbox_new (FALSE, 5);
       gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
 
       button = gtk_button_new_with_label ("Select All");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (select_all), ctree);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (select_all), ctree);
 
       button = gtk_button_new_with_label ("Unselect All");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (unselect_all), ctree);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (unselect_all), ctree);
 
       button = gtk_button_new_with_label ("Remove Selection");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (remove_selection), ctree);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (remove_selection), ctree);
 
       check = gtk_check_button_new_with_label ("Reorderable");
       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
       gtk_tooltips_set_tip (tooltips, check,
 			    "Tree items can be reordered by dragging.", NULL);
-      gtk_signal_connect (GTK_OBJECT (check), "clicked",
-			  GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
+      g_signal_connect (check, "clicked",
+			G_CALLBACK (toggle_reorderable), ctree);
       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
 
       hbox = gtk_hbox_new (TRUE, 5);
@@ -6251,25 +7182,15 @@ void create_ctree (void)
       gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
 			    NULL);
 
-      omenu4 = build_option_menu (items4, 3, 3, 
+      omenu4 = build_option_menu (selection_mode_items, 3, 3, 
 				  ctree_toggle_sel_mode, ctree);
       gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
       gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
 			    NULL);
 
       gtk_widget_realize (window);
-
-      if (!pixmap1)
-	pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1, 
-						&transparent, book_closed_xpm);
-      if (!pixmap2)
-	pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2, 
-						&transparent, book_open_xpm);
-      if (!pixmap3)
-	pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
-						&transparent, mini_page_xpm);
-
-      gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
+      
+      gtk_widget_set_size_request (GTK_WIDGET (ctree), -1, 300);
 
       frame = gtk_frame_new (NULL);
       gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
@@ -6400,61 +7321,41 @@ palette_toggled_cb (GtkWidget *w,
 }
 
 void
-create_color_selection (void)
+create_color_selection (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
 
   if (!window)
     {
-      GtkWidget *options_hbox;
-      GtkWidget *check_button;
+      GtkWidget *picker;
+      GtkWidget *hbox;
+      GtkWidget *label;
       
-      window = gtk_color_selection_dialog_new ("color selection dialog");
-      gtk_widget_show (GTK_COLOR_SELECTION_DIALOG (window)->help_button);
-
-      gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
-
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-                          GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-                          &window);
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window), 
+			     gtk_widget_get_screen (widget));
+			     
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+                        &window);
+
+      gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
+      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 
-      options_hbox = gtk_hbox_new (FALSE, 0);
-      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), options_hbox, FALSE, FALSE, 0);
-      gtk_container_set_border_width (GTK_CONTAINER (options_hbox), 10);
+      hbox = gtk_hbox_new (FALSE, 8);
+      gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
+      gtk_container_add (GTK_CONTAINER (window), hbox);
       
-      check_button = gtk_check_button_new_with_label ("Show Opacity");
-      gtk_box_pack_start (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
-      gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
-			  GTK_SIGNAL_FUNC (opacity_toggled_cb), window);
-
-      check_button = gtk_check_button_new_with_label ("Show Palette");
-      gtk_box_pack_end (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
-      gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
-			  GTK_SIGNAL_FUNC (palette_toggled_cb), window);
-
-      gtk_widget_show_all (options_hbox);
+      label = gtk_label_new ("Pick a color");
+      gtk_container_add (GTK_CONTAINER (hbox), label);
 
-      gtk_signal_connect (
-	GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
-	"color_changed",
-	GTK_SIGNAL_FUNC(color_selection_changed),
-	window);
-
-      gtk_signal_connect (
-	GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
-	"clicked",
-	GTK_SIGNAL_FUNC(color_selection_ok),
-	window);
-
-      gtk_signal_connect_object (
-        GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
-	"clicked",
-	GTK_SIGNAL_FUNC(gtk_widget_destroy),
-	GTK_OBJECT (window));
+      picker = gtk_color_button_new ();
+      gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
+      gtk_container_add (GTK_CONTAINER (hbox), picker);
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
-    gtk_widget_show (window);
+    gtk_widget_show_all (window);
   else
     gtk_widget_destroy (window);
 }
@@ -6464,22 +7365,47 @@ create_color_selection (void)
  */
 
 void
-file_selection_hide_fileops (GtkWidget *widget,
-			     GtkFileSelection *fs)
+show_fileops (GtkWidget        *widget,
+	      GtkFileSelection *fs)
 {
-  gtk_file_selection_hide_fileop_buttons (fs);
+  gboolean show_ops;
+
+  show_ops = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+
+  if (show_ops)
+    gtk_file_selection_show_fileop_buttons (fs);
+  else
+    gtk_file_selection_hide_fileop_buttons (fs);
+}
+
+void
+select_multiple (GtkWidget        *widget,
+		 GtkFileSelection *fs)
+{
+  gboolean select_multiple;
+
+  select_multiple = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+  gtk_file_selection_set_select_multiple (fs, select_multiple);
 }
 
 void
-file_selection_ok (GtkWidget        *w,
-		   GtkFileSelection *fs)
+file_selection_ok (GtkFileSelection *fs)
 {
-  g_print ("%s\n", gtk_file_selection_get_filename (fs));
+  int i;
+  gchar **selections;
+
+  selections = gtk_file_selection_get_selections (fs);
+
+  for (i = 0; selections[i] != NULL; i++)
+    g_print ("%s\n", selections[i]);
+
+  g_strfreev (selections);
+
   gtk_widget_destroy (GTK_WIDGET (fs));
 }
 
 void
-create_file_selection (void)
+create_file_selection (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
@@ -6487,34 +7413,38 @@ create_file_selection (void)
   if (!window)
     {
       window = gtk_file_selection_new ("file selection dialog");
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
       gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
 
       gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
-
-      gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
-			  "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
-			  window);
-      gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
-				 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
-      
-      button = gtk_button_new_with_label ("Hide Fileops");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  (GtkSignalFunc) file_selection_hide_fileops, 
-			  (gpointer) window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+
+      g_signal_connect_swapped (GTK_FILE_SELECTION (window)->ok_button,
+				"clicked",
+				G_CALLBACK (file_selection_ok),
+				window);
+      g_signal_connect_swapped (GTK_FILE_SELECTION (window)->cancel_button,
+			        "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
+      
+      button = gtk_check_button_new_with_label ("Show Fileops");
+      g_signal_connect (button, "toggled",
+			G_CALLBACK (show_fileops),
+			window);
       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area), 
 			  button, FALSE, FALSE, 0);
       gtk_widget_show (button);
 
-      button = gtk_button_new_with_label ("Show Fileops");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons, 
-				 (gpointer) window);
+      button = gtk_check_button_new_with_label ("Select Multiple");
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (select_multiple),
+			window);
       gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area), 
 			  button, FALSE, FALSE, 0);
       gtk_widget_show (button);
@@ -6535,8 +7465,41 @@ flipping_toggled_cb (GtkWidget *widget, gpointer data)
   gtk_widget_set_default_direction (new_direction);
 }
 
+static void
+set_direction_recurse (GtkWidget *widget,
+		       gpointer   data)
+{
+  GtkTextDirection *dir = data;
+  
+  gtk_widget_set_direction (widget, *dir);
+  if (GTK_IS_CONTAINER (widget))
+    gtk_container_foreach (GTK_CONTAINER (widget),
+			   set_direction_recurse,
+			   data);
+}
+
+static GtkWidget *
+create_forward_back (const char       *title,
+		     GtkTextDirection  text_dir)
+{
+  GtkWidget *frame = gtk_frame_new (title);
+  GtkWidget *bbox = gtk_hbutton_box_new ();
+  GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
+  GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
+
+  gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
+  
+  gtk_container_add (GTK_CONTAINER (frame), bbox);
+  gtk_container_add (GTK_CONTAINER (bbox), back_button);
+  gtk_container_add (GTK_CONTAINER (bbox), forward_button);
+
+  set_direction_recurse (frame, &text_dir);
+
+  return frame;
+}
+
 void
-create_flipping (void)
+create_flipping (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *check_button, *button;
@@ -6545,9 +7508,12 @@ create_flipping (void)
     {
       window = gtk_dialog_new ();
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
 
@@ -6555,17 +7521,29 @@ create_flipping (void)
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
 			  check_button, TRUE, TRUE, 0);
 
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
+			  create_forward_back ("Default", GTK_TEXT_DIR_NONE),
+			  TRUE, TRUE, 0);
+
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
+			  create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
+			  TRUE, TRUE, 0);
+
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
+			  create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
+			  TRUE, TRUE, 0);
+
       if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
 	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
 
-      gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
-			  GTK_SIGNAL_FUNC (flipping_toggled_cb), FALSE);
+      g_signal_connect (check_button, "toggled",
+			G_CALLBACK (flipping_toggled_cb), FALSE);
 
       gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
       
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy), window);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
     }
@@ -6625,10 +7603,10 @@ make_focus_table (GList **list)
 }
 
 static void
-create_focus (void)
+create_focus (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
-
+  
   if (!window)
     {
       GtkWidget *table;
@@ -6641,13 +7619,16 @@ create_focus (void)
                                             GTK_RESPONSE_NONE,
                                             NULL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
-      gtk_signal_connect (GTK_OBJECT (window), "response",
-                          GTK_SIGNAL_FUNC (gtk_widget_destroy),
-                          NULL);
+      g_signal_connect (window, "response",
+                        G_CALLBACK (gtk_widget_destroy),
+                        NULL);
       
       gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
 
@@ -6700,30 +7681,41 @@ font_selection_ok (GtkWidget              *w,
 }
 
 void
-create_font_selection (void)
+create_font_selection (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
 
   if (!window)
     {
-      window = gtk_font_selection_dialog_new ("Font Selection Dialog");
+      GtkWidget *picker;
+      GtkWidget *hbox;
+      GtkWidget *label;
+      
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+
+      gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
+      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      hbox = gtk_hbox_new (FALSE, 8);
+      gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
+      gtk_container_add (GTK_CONTAINER (window), hbox);
+      
+      label = gtk_label_new ("Pick a font");
+      gtk_container_add (GTK_CONTAINER (hbox), label);
 
-      gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
-			  "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
-			  GTK_FONT_SELECTION_DIALOG (window));
-      gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
-				 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      picker = gtk_font_button_new ();
+      gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
+      gtk_container_add (GTK_CONTAINER (hbox), picker);
     }
   
   if (!GTK_WIDGET_VISIBLE (window))
-    gtk_widget_show (window);
+    gtk_widget_show_all (window);
   else
     gtk_widget_destroy (window);
 }
@@ -6741,10 +7733,10 @@ label_toggle (GtkWidget  *widget,
   if (!(*label))
     {
       *label = gtk_label_new ("Dialog Test");
-      gtk_signal_connect (GTK_OBJECT (*label),
-			  "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  label);
+      g_signal_connect (*label,
+			"destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			label);
       gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox), 
 			  *label, TRUE, TRUE, 0);
@@ -6771,7 +7763,7 @@ print_response (GtkWidget *dialog,
 }
 
 static void
-create_dialog (void)
+create_dialog (GtkWidget *widget)
 {
   static GtkWidget *label;
   GtkWidget *button;
@@ -6784,15 +7776,17 @@ create_dialog (void)
        */
       
       dialog_window = gtk_dialog_new ();
+      gtk_window_set_screen (GTK_WINDOW (dialog_window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (dialog_window),
-                          "response",
-                          GTK_SIGNAL_FUNC (print_response),
-                          NULL);
+      g_signal_connect (dialog_window,
+                        "response",
+                        G_CALLBACK (print_response),
+                        NULL);
       
-      gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &dialog_window);
+      g_signal_connect (dialog_window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&dialog_window);
 
       gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
       gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
@@ -6805,9 +7799,9 @@ create_dialog (void)
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("Toggle");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (label_toggle),
-			  &label);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (label_toggle),
+			&label);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
 			  button, TRUE, TRUE, 0);
@@ -6831,6 +7825,169 @@ create_dialog (void)
     gtk_widget_destroy (dialog_window);
 }
 
+/* Display & Screen test 
+ */
+
+typedef struct 
+{ 
+  GtkEntry *entry;
+  GtkWidget *radio_dpy;
+  GtkWidget *toplevel; 
+  GtkWidget *dialog_window;
+  GList *valid_display_list;
+} ScreenDisplaySelection;
+
+static gint
+display_name_cmp (gconstpointer a,
+		  gconstpointer b)
+{
+  return g_ascii_strcasecmp (a,b);
+}
+
+static void
+screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
+{
+  char *display_name;
+  GdkDisplay *display = gtk_widget_get_display (widget);
+  GtkWidget *dialog;
+  GdkScreen *new_screen = NULL;
+  GdkScreen *current_screen = gtk_widget_get_screen (widget);
+  
+  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
+    {
+      display_name = g_strdup (gtk_entry_get_text (data->entry));
+      display = gdk_display_open (display_name);
+      
+      if (!display)
+	{
+	  dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
+					   GTK_DIALOG_DESTROY_WITH_PARENT,
+					   GTK_MESSAGE_ERROR,
+					   GTK_BUTTONS_OK,
+					   "The display :\n%s\ncannot be opened",
+					   display_name);
+	  gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
+	  gtk_widget_show (dialog);
+	  g_signal_connect (dialog, "response",
+			    G_CALLBACK (gtk_widget_destroy),
+			    NULL);
+	}
+      else
+	{
+	  if (!g_list_find_custom (data->valid_display_list, 
+				   display_name,
+				   display_name_cmp))
+	    data->valid_display_list = g_list_append (data->valid_display_list,
+						      display_name);
+	  
+	  new_screen = gdk_display_get_default_screen (display);
+	}
+    }
+  else
+    {
+      gint number_of_screens = gdk_display_get_n_screens (display);
+      gint screen_num = gdk_screen_get_number (current_screen);
+      if ((screen_num +1) < number_of_screens)
+	new_screen = gdk_display_get_screen (display, screen_num + 1);
+      else
+	new_screen = gdk_display_get_screen (display, 0);
+    }
+  
+  if (new_screen) 
+    {
+      gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
+      gtk_widget_destroy (data->dialog_window);
+    }
+}
+
+void
+screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
+{
+  gtk_widget_destroy (data);
+}
+
+void
+create_display_screen (GtkWidget *widget)
+{
+  GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
+  GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
+  GtkWidget *bbox;
+  ScreenDisplaySelection *scr_dpy_data;
+  GdkScreen *screen = gtk_widget_get_screen (widget);
+  static GList *valid_display_list = NULL;
+  
+  GdkDisplay *display = gdk_screen_get_display (screen);
+
+  window = gtk_widget_new (gtk_window_get_type (),
+			   "screen", screen,
+			   "user_data", NULL,
+			   "type", GTK_WINDOW_TOPLEVEL,
+			   "title",
+			   "Screen or Display selection",
+			   "border_width", 10, NULL);
+  g_signal_connect (window, "destroy", 
+		    G_CALLBACK (gtk_widget_destroy), NULL);
+
+  vbox = gtk_vbox_new (FALSE, 3);
+  gtk_container_add (GTK_CONTAINER (window), vbox);
+  
+  frame = gtk_frame_new ("Select screen or display");
+  gtk_container_add (GTK_CONTAINER (vbox), frame);
+  
+  table = gtk_table_new (2, 2, TRUE);
+  gtk_table_set_row_spacings (GTK_TABLE (table), 3);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 3);
+
+  gtk_container_add (GTK_CONTAINER (frame), table);
+
+  radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
+  if (gdk_display_get_n_screens(display) > 1)
+    radio_scr = gtk_radio_button_new_with_label 
+    (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
+  else
+    {    
+      radio_scr = gtk_radio_button_new_with_label 
+	(gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), 
+	 "only one screen on the current display");
+      gtk_widget_set_sensitive (radio_scr, FALSE);
+    }
+  combo_dpy = gtk_combo_new ();
+  if (!valid_display_list)
+    valid_display_list = g_list_append (valid_display_list, "diabolo:0.0");
+    
+  gtk_combo_set_popdown_strings (GTK_COMBO (combo_dpy), valid_display_list);
+    
+  gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo_dpy)->entry), 
+		      "<hostname>:<X Server Num>.<Screen Num>");
+
+  gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
+  gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
+  gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
+
+  bbox = gtk_hbutton_box_new ();
+  applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
+  cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
+  
+  gtk_container_add (GTK_CONTAINER (vbox), bbox);
+
+  gtk_container_add (GTK_CONTAINER (bbox), applyb);
+  gtk_container_add (GTK_CONTAINER (bbox), cancelb);
+
+  scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
+
+  scr_dpy_data->entry = GTK_ENTRY (GTK_COMBO (combo_dpy)->entry);
+  scr_dpy_data->radio_dpy = radio_dpy;
+  scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
+  scr_dpy_data->dialog_window = window;
+  scr_dpy_data->valid_display_list = valid_display_list;
+
+  g_signal_connect (cancelb, "clicked", 
+		    G_CALLBACK (screen_display_destroy_diag), window);
+  g_signal_connect (applyb, "clicked", 
+		    G_CALLBACK (screen_display_check), scr_dpy_data);
+  gtk_widget_show_all (window);
+}
+
 /* Event Watcher
  */
 static gboolean event_watcher_enter_id = 0;
@@ -6843,8 +8000,8 @@ event_watcher (GSignalInvocationHint *ihint,
 	       gpointer               data)
 {
   g_print ("Watch: \"%s\" emitted for %s\n",
-	   gtk_signal_name (ihint->signal_id),
-	   gtk_type_name (GTK_OBJECT_TYPE (g_value_get_object (param_values + 0))));
+	   g_signal_name (ihint->signal_id),
+	   G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
 
   return TRUE;
 }
@@ -6856,10 +8013,10 @@ event_watcher_down (void)
     {
       guint signal_id;
 
-      signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
+      signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
       g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
       event_watcher_enter_id = 0;
-      signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
+      signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
       g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
       event_watcher_leave_id = 0;
     }
@@ -6874,47 +8031,48 @@ event_watcher_toggle (void)
     {
       guint signal_id;
 
-      signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
+      signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
       event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
-      signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
+      signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
       event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
     }
 }
 
 static void
-create_event_watcher (void)
+create_event_watcher (GtkWidget *widget)
 {
   GtkWidget *button;
 
   if (!dialog_window)
     {
       dialog_window = gtk_dialog_new ();
-
-      gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &dialog_window);
-      gtk_signal_connect (GTK_OBJECT (dialog_window),
-			  "destroy",
-			  GTK_SIGNAL_FUNC (event_watcher_down),
-			  NULL);
+      gtk_window_set_screen (GTK_WINDOW (dialog_window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (dialog_window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&dialog_window);
+      g_signal_connect (dialog_window, "destroy",
+			G_CALLBACK (event_watcher_down),
+			NULL);
 
       gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
       gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
-      gtk_widget_set_usize (dialog_window, 200, 110);
+      gtk_widget_set_size_request (dialog_window, 200, 110);
 
       button = gtk_toggle_button_new_with_label ("Activate Watch");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (event_watcher_toggle),
-			  NULL);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (event_watcher_toggle),
+			NULL);
       gtk_container_set_border_width (GTK_CONTAINER (button), 10);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox), 
 			  button, TRUE, TRUE, 0);
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 (GtkObject*) dialog_window);
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				dialog_window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
 			  button, TRUE, TRUE, 0);
@@ -6941,7 +8099,7 @@ reformat_value (GtkScale *scale,
 }
 
 static void
-create_range_controls (void)
+create_range_controls (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -6957,9 +8115,12 @@ create_range_controls (void)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "range controls");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -6979,7 +8140,7 @@ create_range_controls (void)
       adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
 
       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
-      gtk_widget_set_usize (GTK_WIDGET (scale), 150, -1);
+      gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
       gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
       gtk_scale_set_digits (GTK_SCALE (scale), 1);
       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
@@ -6994,24 +8155,24 @@ create_range_controls (void)
 
       scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
-      gtk_signal_connect (GTK_OBJECT (scale),
-                          "format_value",
-                          GTK_SIGNAL_FUNC (reformat_value),
-                          NULL);
+      g_signal_connect (scale,
+                        "format_value",
+                        G_CALLBACK (reformat_value),
+                        NULL);
       gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
       gtk_widget_show (scale);
       
       hbox = gtk_hbox_new (FALSE, 0);
 
       scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
-      gtk_widget_set_usize (scale, -1, 200);
+      gtk_widget_set_size_request (scale, -1, 200);
       gtk_scale_set_digits (GTK_SCALE (scale), 2);
       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
       gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
       gtk_widget_show (scale);
 
       scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
-      gtk_widget_set_usize (scale, -1, 200);
+      gtk_widget_set_size_request (scale, -1, 200);
       gtk_scale_set_digits (GTK_SCALE (scale), 2);
       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
       gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
@@ -7020,10 +8181,10 @@ create_range_controls (void)
 
       scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
       gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
-      gtk_signal_connect (GTK_OBJECT (scale),
-                          "format_value",
-                          GTK_SIGNAL_FUNC (reformat_value),
-                          NULL);
+      g_signal_connect (scale,
+                        "format_value",
+                        G_CALLBACK (reformat_value),
+                        NULL);
       gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
       gtk_widget_show (scale);
 
@@ -7043,9 +8204,9 @@ create_range_controls (void)
 
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -7063,7 +8224,7 @@ create_range_controls (void)
  */
 
 void
-create_rulers (void)
+create_rulers (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *table;
@@ -7072,14 +8233,18 @@ create_rulers (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-      gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "rulers");
-      gtk_widget_set_usize (window, 300, 300);
+      gtk_widget_set_size_request (window, 300, 300);
       gtk_widget_set_events (window, 
 			     GDK_POINTER_MOTION_MASK 
 			     | GDK_POINTER_MOTION_HINT_MASK);
@@ -7093,10 +8258,10 @@ create_rulers (void)
       gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
       gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
 
-      gtk_signal_connect_object (GTK_OBJECT (window), 
-				 "motion_notify_event",
-				 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
-				 GTK_OBJECT (ruler));
+      g_signal_connect_swapped (window, 
+			        "motion_notify_event",
+				G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+			        ruler);
       
       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
 			GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
@@ -7106,10 +8271,10 @@ create_rulers (void)
       ruler = gtk_vruler_new ();
       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
 
-      gtk_signal_connect_object (GTK_OBJECT (window), 
-				 "motion_notify_event",
-				 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
-				 GTK_OBJECT (ruler));
+      g_signal_connect_swapped (window, 
+			        "motion_notify_event",
+			        G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+			        ruler);
       
       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
 			GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
@@ -7171,7 +8336,7 @@ text_insert_random (GtkWidget *w, GtkText *text)
 }
 
 void
-create_text (void)
+create_text (GtkWidget *widget)
 {
   int i, j;
 
@@ -7190,13 +8355,16 @@ create_text (void)
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
       gtk_widget_set_name (window, "text window");
-      gtk_widget_set_usize (window, 500, 500);
-      gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
+      g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
+      gtk_widget_set_size_request (window, 500, 500);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -7282,15 +8450,15 @@ create_text (void)
 
       check = gtk_check_button_new_with_label("Editable");
       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
-      gtk_signal_connect (GTK_OBJECT(check), "toggled",
-			  GTK_SIGNAL_FUNC(text_toggle_editable), text);
+      g_signal_connect (check, "toggled",
+			G_CALLBACK (text_toggle_editable), text);
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
       gtk_widget_show (check);
 
       check = gtk_check_button_new_with_label("Wrap Words");
       gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT(check), "toggled",
-			  GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
+      g_signal_connect (check, "toggled",
+			G_CALLBACK (text_toggle_word_wrap), text);
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
       gtk_widget_show (check);
 
@@ -7306,16 +8474,16 @@ create_text (void)
 
 
       button = gtk_button_new_with_label ("insert random");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(text_insert_random),
-			  GTK_TEXT (text));
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (text_insert_random),
+			text);
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				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);
@@ -7332,26 +8500,23 @@ create_text (void)
  * GtkNotebook
  */
 
-GdkPixmap *book_open;
-GdkPixmap *book_closed;
-GdkBitmap *book_open_mask;
-GdkBitmap *book_closed_mask;
+GdkPixbuf *book_open;
+GdkPixbuf *book_closed;
 GtkWidget *sample_notebook;
 
 static void
-set_page_pixmaps (GtkNotebook *notebook, gint page_num,
-		  GdkPixmap *pixmap, GdkPixmap *mask)
+set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
 {
   GtkWidget *page_widget;
   GtkWidget *pixwid;
 
   page_widget = gtk_notebook_get_nth_page (notebook, page_num);
 
-  pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "tab_pixmap");
-  gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+  pixwid = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
+  gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
   
-  pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "menu_pixmap");
-  gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+  pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
+  gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
 }
 
 static void
@@ -7363,10 +8528,10 @@ page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
   if (page_num == old_page_num)
     return;
 
-  set_page_pixmaps (notebook, page_num, book_open, book_open_mask);
+  set_page_image (notebook, page_num, book_open);
 
   if (old_page_num != -1)
-    set_page_pixmaps (notebook, old_page_num, book_closed, book_closed_mask);
+    set_page_image (notebook, old_page_num, book_closed);
 }
 
 static void
@@ -7439,30 +8604,30 @@ create_pages (GtkNotebook *notebook, gint start, gint end)
       button = gtk_check_button_new_with_label ("Fill Tab");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
-      gtk_signal_connect (GTK_OBJECT (button), "toggled",
-			  GTK_SIGNAL_FUNC (tab_fill), child);
+      g_signal_connect (button, "toggled",
+			G_CALLBACK (tab_fill), child);
 
       button = gtk_check_button_new_with_label ("Expand Tab");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
-      gtk_signal_connect (GTK_OBJECT (button), "toggled",
-      GTK_SIGNAL_FUNC (tab_expand), child);
+      g_signal_connect (button, "toggled",
+			G_CALLBACK (tab_expand), child);
 
       button = gtk_check_button_new_with_label ("Pack end");
       gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
-      gtk_signal_connect (GTK_OBJECT (button), "toggled",
-			  GTK_SIGNAL_FUNC (tab_pack), child);
+      g_signal_connect (button, "toggled",
+			G_CALLBACK (tab_pack), child);
 
       button = gtk_button_new_with_label ("Hide Page");
       gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_hide),
-				 GTK_OBJECT (child));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_hide),
+				child);
 
       gtk_widget_show_all (child);
 
       label_box = gtk_hbox_new (FALSE, 0);
-      pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
-      gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid);
+      pixwid = gtk_image_new_from_pixbuf (book_closed);
+      g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
 			   
       gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
@@ -7472,8 +8637,8 @@ create_pages (GtkNotebook *notebook, gint start, gint end)
       
 				       
       menu_box = gtk_hbox_new (FALSE, 0);
-      pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
-      gtk_object_set_data (GTK_OBJECT (child), "menu_pixmap", pixwid);
+      pixwid = gtk_image_new_from_pixbuf (book_closed);
+      g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
       
       gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
       gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
@@ -7570,11 +8735,11 @@ static void
 notebook_homogeneous (GtkToggleButton *button,
 		      GtkNotebook     *notebook)
 {
-  gtk_notebook_set_homogeneous_tabs (notebook, button->active);
+  g_object_set (notebook, "homogeneous", button->active, NULL);
 }
 
 static void
-create_notebook (void)
+create_notebook (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
@@ -7582,7 +8747,6 @@ create_notebook (void)
   GtkWidget *button;
   GtkWidget *separator;
   GtkWidget *omenu;
-  GdkColor *transparent = NULL;
   GtkWidget *label;
 
   static gchar *items[] =
@@ -7592,14 +8756,16 @@ create_notebook (void)
     "Borderless",
     "Scrollable"
   };
-
+  
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "notebook");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -7608,23 +8774,19 @@ create_notebook (void)
       gtk_container_add (GTK_CONTAINER (window), box1);
 
       sample_notebook = gtk_notebook_new ();
-      gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
-			  GTK_SIGNAL_FUNC (page_switch), NULL);
+      g_signal_connect (sample_notebook, "switch_page",
+			G_CALLBACK (page_switch), NULL);
       gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
       gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
       gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
 
       gtk_widget_realize (sample_notebook);
+
       if (!book_open)
-	book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
-						  &book_open_mask, 
-						  transparent, 
-						  book_open_xpm);
+	book_open = gdk_pixbuf_new_from_xpm_data ((const char **)book_open_xpm);
+						  
       if (!book_closed)
-	book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
-						    &book_closed_mask,
-						    transparent, 
-						    book_closed_xpm);
+	book_closed = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
 
       create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
 
@@ -7637,15 +8799,15 @@ create_notebook (void)
 
       button = gtk_check_button_new_with_label ("popup menu");
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
-      gtk_signal_connect (GTK_OBJECT(button), "clicked",
-			  GTK_SIGNAL_FUNC (notebook_popup),
-			  GTK_OBJECT (sample_notebook));
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (notebook_popup),
+			sample_notebook);
 
       button = gtk_check_button_new_with_label ("homogeneous tabs");
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
-      gtk_signal_connect (GTK_OBJECT(button), "clicked",
-			  GTK_SIGNAL_FUNC (notebook_homogeneous),
-			  GTK_OBJECT (sample_notebook));
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (notebook_homogeneous),
+			sample_notebook);
 
       box2 = gtk_hbox_new (FALSE, 5);
       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
@@ -7661,28 +8823,28 @@ create_notebook (void)
 
       button = gtk_button_new_with_label ("Show all Pages");
       gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (show_all_pages), sample_notebook);
 
       box2 = gtk_hbox_new (TRUE, 10);
       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
       gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
       button = gtk_button_new_with_label ("prev");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
-				 GTK_OBJECT (sample_notebook));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_notebook_prev_page),
+				sample_notebook);
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 
       button = gtk_button_new_with_label ("next");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
-				 GTK_OBJECT (sample_notebook));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_notebook_next_page),
+				sample_notebook);
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 
       button = gtk_button_new_with_label ("rotate");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (rotate_notebook), sample_notebook);
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
 
       separator = gtk_hseparator_new ();
@@ -7690,9 +8852,9 @@ create_notebook (void)
 
       button = gtk_button_new_with_label ("close");
       gtk_container_set_border_width (GTK_CONTAINER (button), 5);
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+			        G_CALLBACK (gtk_widget_destroy),
+				window);
       gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_widget_grab_default (button);
@@ -7711,39 +8873,23 @@ create_notebook (void)
 void
 toggle_resize (GtkWidget *widget, GtkWidget *child)
 {
-  GtkPaned *paned = GTK_PANED (child->parent);
-  gboolean is_child1 = (child == paned->child1);
-  gboolean resize, shrink;
-
-  resize = is_child1 ? paned->child1_resize : paned->child2_resize;
-  shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
-
-  gtk_widget_ref (child);
-  gtk_container_remove (GTK_CONTAINER (child->parent), child);
-  if (is_child1)
-    gtk_paned_pack1 (paned, child, !resize, shrink);
-  else
-    gtk_paned_pack2 (paned, child, !resize, shrink);
-  gtk_widget_unref (child);
+  GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
+  GValue value = { 0, };
+  g_value_init (&value, G_TYPE_BOOLEAN);
+  gtk_container_child_get_property (container, child, "resize", &value);
+  g_value_set_boolean (&value, !g_value_get_boolean (&value));
+  gtk_container_child_set_property (container, child, "resize", &value);
 }
 
 void
 toggle_shrink (GtkWidget *widget, GtkWidget *child)
 {
-  GtkPaned *paned = GTK_PANED (child->parent);
-  gboolean is_child1 = (child == paned->child1);
-  gboolean resize, shrink;
-
-  resize = is_child1 ? paned->child1_resize : paned->child2_resize;
-  shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
-
-  gtk_widget_ref (child);
-  gtk_container_remove (GTK_CONTAINER (child->parent), child);
-  if (is_child1)
-    gtk_paned_pack1 (paned, child, resize, !shrink);
-  else
-    gtk_paned_pack2 (paned, child, resize, !shrink);
-  gtk_widget_unref (child);
+  GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
+  GValue value = { 0, };
+  g_value_init (&value, G_TYPE_BOOLEAN);
+  gtk_container_child_get_property (container, child, "shrink", &value);
+  g_value_set_boolean (&value, !g_value_get_boolean (&value));
+  gtk_container_child_set_property (container, child, "shrink", &value);
 }
 
 static void
@@ -7751,7 +8897,7 @@ paned_props_clicked (GtkWidget *button,
 		     GObject   *paned)
 {
   GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
-
+  
   gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
 }
 
@@ -7780,18 +8926,18 @@ create_pane_options (GtkPaned    *paned,
   check_button = gtk_check_button_new_with_label ("Resize");
   gtk_table_attach_defaults (GTK_TABLE (table), check_button,
 			     0, 1, 1, 2);
-  gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
-		      GTK_SIGNAL_FUNC (toggle_resize),
-		      paned->child1);
+  g_signal_connect (check_button, "toggled",
+		    G_CALLBACK (toggle_resize),
+		    paned->child1);
   
   check_button = gtk_check_button_new_with_label ("Shrink");
   gtk_table_attach_defaults (GTK_TABLE (table), check_button,
 			     0, 1, 2, 3);
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
 			       TRUE);
-  gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
-		      GTK_SIGNAL_FUNC (toggle_shrink),
-		      paned->child1);
+  g_signal_connect (check_button, "toggled",
+		    G_CALLBACK (toggle_shrink),
+		    paned->child1);
   
   label = gtk_label_new (label2);
   gtk_table_attach_defaults (GTK_TABLE (table), label,
@@ -7802,31 +8948,31 @@ create_pane_options (GtkPaned    *paned,
 			     1, 2, 1, 2);
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
 			       TRUE);
-  gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
-		      GTK_SIGNAL_FUNC (toggle_resize),
-		      paned->child2);
+  g_signal_connect (check_button, "toggled",
+		    G_CALLBACK (toggle_resize),
+		    paned->child2);
   
   check_button = gtk_check_button_new_with_label ("Shrink");
   gtk_table_attach_defaults (GTK_TABLE (table), check_button,
 			     1, 2, 2, 3);
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
 			       TRUE);
-  gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
-		      GTK_SIGNAL_FUNC (toggle_shrink),
-		      paned->child2);
+  g_signal_connect (check_button, "toggled",
+		    G_CALLBACK (toggle_shrink),
+		    paned->child2);
 
   button = gtk_button_new_with_mnemonic ("_Properties");
   gtk_table_attach_defaults (GTK_TABLE (table), button,
 			     0, 2, 3, 4);
-  gtk_signal_connect (GTK_OBJECT (button), "clicked",
-		      GTK_SIGNAL_FUNC (paned_props_clicked),
-		      paned);
+  g_signal_connect (button, "clicked",
+		    G_CALLBACK (paned_props_clicked),
+		    paned);
 
   return frame;
 }
 
 void
-create_panes (void)
+create_panes (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *frame;
@@ -7839,9 +8985,12 @@ create_panes (void)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+      
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Panes");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -7858,7 +9007,7 @@ create_panes (void)
 
       frame = gtk_frame_new (NULL);
       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
-      gtk_widget_set_usize (frame, 60, 60);
+      gtk_widget_set_size_request (frame, 60, 60);
       gtk_paned_add1 (GTK_PANED (hpaned), frame);
       
       button = gtk_button_new_with_label ("Hi there");
@@ -7866,12 +9015,12 @@ create_panes (void)
 
       frame = gtk_frame_new (NULL);
       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
-      gtk_widget_set_usize (frame, 80, 60);
+      gtk_widget_set_size_request (frame, 80, 60);
       gtk_paned_add2 (GTK_PANED (hpaned), frame);
 
       frame = gtk_frame_new (NULL);
       gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
-      gtk_widget_set_usize (frame, 60, 80);
+      gtk_widget_set_size_request (frame, 60, 80);
       gtk_paned_add2 (GTK_PANED (vpaned), frame);
 
       /* Now create toggle buttons to control sizing */
@@ -7899,6 +9048,392 @@ create_panes (void)
     gtk_widget_destroy (window);
 }
 
+/*
+ * Paned keyboard navigation
+ */
+
+static GtkWidget*
+paned_keyboard_window1 (GtkWidget *widget)
+{
+  GtkWidget *window1;
+  GtkWidget *hpaned1;
+  GtkWidget *frame1;
+  GtkWidget *vbox1;
+  GtkWidget *button7;
+  GtkWidget *button8;
+  GtkWidget *button9;
+  GtkWidget *vpaned1;
+  GtkWidget *frame2;
+  GtkWidget *frame5;
+  GtkWidget *hbox1;
+  GtkWidget *button5;
+  GtkWidget *button6;
+  GtkWidget *frame3;
+  GtkWidget *frame4;
+  GtkWidget *table1;
+  GtkWidget *button1;
+  GtkWidget *button2;
+  GtkWidget *button3;
+  GtkWidget *button4;
+
+  window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
+  gtk_window_set_screen (GTK_WINDOW (window1), 
+			 gtk_widget_get_screen (widget));
+
+  hpaned1 = gtk_hpaned_new ();
+  gtk_container_add (GTK_CONTAINER (window1), hpaned1);
+
+  frame1 = gtk_frame_new (NULL);
+  gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
+
+  vbox1 = gtk_vbox_new (FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (frame1), vbox1);
+
+  button7 = gtk_button_new_with_label ("button7");
+  gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
+
+  button8 = gtk_button_new_with_label ("button8");
+  gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
+
+  button9 = gtk_button_new_with_label ("button9");
+  gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
+
+  vpaned1 = gtk_vpaned_new ();
+  gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
+
+  frame2 = gtk_frame_new (NULL);
+  gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
+
+  frame5 = gtk_frame_new (NULL);
+  gtk_container_add (GTK_CONTAINER (frame2), frame5);
+
+  hbox1 = gtk_hbox_new (FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (frame5), hbox1);
+
+  button5 = gtk_button_new_with_label ("button5");
+  gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
+
+  button6 = gtk_button_new_with_label ("button6");
+  gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
+
+  frame3 = gtk_frame_new (NULL);
+  gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
+
+  frame4 = gtk_frame_new ("Buttons");
+  gtk_container_add (GTK_CONTAINER (frame3), frame4);
+  gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
+
+  table1 = gtk_table_new (2, 2, FALSE);
+  gtk_container_add (GTK_CONTAINER (frame4), table1);
+  gtk_container_set_border_width (GTK_CONTAINER (table1), 11);
+
+  button1 = gtk_button_new_with_label ("button1");
+  gtk_table_attach (GTK_TABLE (table1), button1, 0, 1, 0, 1,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  button2 = gtk_button_new_with_label ("button2");
+  gtk_table_attach (GTK_TABLE (table1), button2, 1, 2, 0, 1,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  button3 = gtk_button_new_with_label ("button3");
+  gtk_table_attach (GTK_TABLE (table1), button3, 0, 1, 1, 2,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  button4 = gtk_button_new_with_label ("button4");
+  gtk_table_attach (GTK_TABLE (table1), button4, 1, 2, 1, 2,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  return window1;
+}
+
+static GtkWidget*
+paned_keyboard_window2 (GtkWidget *widget)
+{
+  GtkWidget *window2;
+  GtkWidget *hpaned2;
+  GtkWidget *frame6;
+  GtkWidget *button13;
+  GtkWidget *hbox2;
+  GtkWidget *vpaned2;
+  GtkWidget *frame7;
+  GtkWidget *button12;
+  GtkWidget *frame8;
+  GtkWidget *button11;
+  GtkWidget *button10;
+
+  window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
+
+  gtk_window_set_screen (GTK_WINDOW (window2), 
+			 gtk_widget_get_screen (widget));
+
+  hpaned2 = gtk_hpaned_new ();
+  gtk_container_add (GTK_CONTAINER (window2), hpaned2);
+
+  frame6 = gtk_frame_new (NULL);
+  gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
+
+  button13 = gtk_button_new_with_label ("button13");
+  gtk_container_add (GTK_CONTAINER (frame6), button13);
+
+  hbox2 = gtk_hbox_new (FALSE, 0);
+  gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
+
+  vpaned2 = gtk_vpaned_new ();
+  gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
+
+  frame7 = gtk_frame_new (NULL);
+  gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
+
+  button12 = gtk_button_new_with_label ("button12");
+  gtk_container_add (GTK_CONTAINER (frame7), button12);
+
+  frame8 = gtk_frame_new (NULL);
+  gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
+
+  button11 = gtk_button_new_with_label ("button11");
+  gtk_container_add (GTK_CONTAINER (frame8), button11);
+
+  button10 = gtk_button_new_with_label ("button10");
+  gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
+
+  return window2;
+}
+
+static GtkWidget*
+paned_keyboard_window3 (GtkWidget *widget)
+{
+  GtkWidget *window3;
+  GtkWidget *vbox2;
+  GtkWidget *label1;
+  GtkWidget *hpaned3;
+  GtkWidget *frame9;
+  GtkWidget *button14;
+  GtkWidget *hpaned4;
+  GtkWidget *frame10;
+  GtkWidget *button15;
+  GtkWidget *hpaned5;
+  GtkWidget *frame11;
+  GtkWidget *button16;
+  GtkWidget *frame12;
+  GtkWidget *button17;
+
+  window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  g_object_set_data (G_OBJECT (window3), "window3", window3);
+  gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
+
+  gtk_window_set_screen (GTK_WINDOW (window3), 
+			 gtk_widget_get_screen (widget));
+  
+
+  vbox2 = gtk_vbox_new (FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (window3), vbox2);
+
+  label1 = gtk_label_new ("Three panes nested inside each other");
+  gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
+
+  hpaned3 = gtk_hpaned_new ();
+  gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
+
+  frame9 = gtk_frame_new (NULL);
+  gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
+
+  button14 = gtk_button_new_with_label ("button14");
+  gtk_container_add (GTK_CONTAINER (frame9), button14);
+
+  hpaned4 = gtk_hpaned_new ();
+  gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
+
+  frame10 = gtk_frame_new (NULL);
+  gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
+
+  button15 = gtk_button_new_with_label ("button15");
+  gtk_container_add (GTK_CONTAINER (frame10), button15);
+
+  hpaned5 = gtk_hpaned_new ();
+  gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
+
+  frame11 = gtk_frame_new (NULL);
+  gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
+
+  button16 = gtk_button_new_with_label ("button16");
+  gtk_container_add (GTK_CONTAINER (frame11), button16);
+
+  frame12 = gtk_frame_new (NULL);
+  gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
+
+  button17 = gtk_button_new_with_label ("button17");
+  gtk_container_add (GTK_CONTAINER (frame12), button17);
+
+  return window3;
+}
+
+static GtkWidget*
+paned_keyboard_window4 (GtkWidget *widget)
+{
+  GtkWidget *window4;
+  GtkWidget *vbox3;
+  GtkWidget *label2;
+  GtkWidget *hpaned6;
+  GtkWidget *vpaned3;
+  GtkWidget *button19;
+  GtkWidget *button18;
+  GtkWidget *hbox3;
+  GtkWidget *vpaned4;
+  GtkWidget *button21;
+  GtkWidget *button20;
+  GtkWidget *vpaned5;
+  GtkWidget *button23;
+  GtkWidget *button22;
+  GtkWidget *vpaned6;
+  GtkWidget *button25;
+  GtkWidget *button24;
+
+  window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  g_object_set_data (G_OBJECT (window4), "window4", window4);
+  gtk_window_set_title (GTK_WINDOW (window4), "window4");
+
+  gtk_window_set_screen (GTK_WINDOW (window4), 
+			 gtk_widget_get_screen (widget));
+
+  vbox3 = gtk_vbox_new (FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (window4), vbox3);
+
+  label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n    - vpaned\n    - vpaned\n    - vpaned\n");
+  gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
+  gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
+
+  hpaned6 = gtk_hpaned_new ();
+  gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
+
+  vpaned3 = gtk_vpaned_new ();
+  gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
+
+  button19 = gtk_button_new_with_label ("button19");
+  gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
+
+  button18 = gtk_button_new_with_label ("button18");
+  gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
+
+  hbox3 = gtk_hbox_new (FALSE, 0);
+  gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
+
+  vpaned4 = gtk_vpaned_new ();
+  gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
+
+  button21 = gtk_button_new_with_label ("button21");
+  gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
+
+  button20 = gtk_button_new_with_label ("button20");
+  gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
+
+  vpaned5 = gtk_vpaned_new ();
+  gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
+
+  button23 = gtk_button_new_with_label ("button23");
+  gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
+
+  button22 = gtk_button_new_with_label ("button22");
+  gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
+
+  vpaned6 = gtk_vpaned_new ();
+  gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
+
+  button25 = gtk_button_new_with_label ("button25");
+  gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
+
+  button24 = gtk_button_new_with_label ("button24");
+  gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
+
+  return window4;
+}
+
+static void
+create_paned_keyboard_navigation (GtkWidget *widget)
+{
+  static GtkWidget *window1 = NULL;
+  static GtkWidget *window2 = NULL;
+  static GtkWidget *window3 = NULL;
+  static GtkWidget *window4 = NULL;
+
+  if (window1 && 
+     (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
+    {
+      gtk_widget_destroy (window1);
+      gtk_widget_destroy (window2);
+      gtk_widget_destroy (window3);
+      gtk_widget_destroy (window4);
+    }
+  
+  if (!window1)
+    {
+      window1 = paned_keyboard_window1 (widget);
+      g_signal_connect (window1, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window1);
+    }
+
+  if (!window2)
+    {
+      window2 = paned_keyboard_window2 (widget);
+      g_signal_connect (window2, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window2);
+    }
+
+  if (!window3)
+    {
+      window3 = paned_keyboard_window3 (widget);
+      g_signal_connect (window3, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window3);
+    }
+
+  if (!window4)
+    {
+      window4 = paned_keyboard_window4 (widget);
+      g_signal_connect (window4, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window4);
+    }
+
+  if (GTK_WIDGET_VISIBLE (window1))
+    gtk_widget_destroy (GTK_WIDGET (window1));
+  else
+    gtk_widget_show_all (GTK_WIDGET (window1));
+
+  if (GTK_WIDGET_VISIBLE (window2))
+    gtk_widget_destroy (GTK_WIDGET (window2));
+  else
+    gtk_widget_show_all (GTK_WIDGET (window2));
+
+  if (GTK_WIDGET_VISIBLE (window3))
+    gtk_widget_destroy (GTK_WIDGET (window3));
+  else
+    gtk_widget_show_all (GTK_WIDGET (window3));
+
+  if (GTK_WIDGET_VISIBLE (window4))
+    gtk_widget_destroy (GTK_WIDGET (window4));
+  else
+    gtk_widget_show_all (GTK_WIDGET (window4));
+}
+
+
 /*
  * Shaped Windows
  */
@@ -7914,7 +9449,7 @@ shape_pressed (GtkWidget *widget, GdkEventButton *event)
   if (event->type != GDK_BUTTON_PRESS)
     return;
 
-  p = gtk_object_get_user_data (GTK_OBJECT(widget));
+  p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
   p->x = (int) event->x;
   p->y = (int) event->y;
 
@@ -7930,7 +9465,8 @@ static void
 shape_released (GtkWidget *widget)
 {
   gtk_grab_remove (widget);
-  gdk_pointer_ungrab (0);
+  gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+			      GDK_CURRENT_TIME);
 }
 
 static void
@@ -7941,7 +9477,7 @@ shape_motion (GtkWidget      *widget,
   CursorOffset * p;
   GdkModifierType mask;
 
-  p = gtk_object_get_user_data (GTK_OBJECT (widget));
+  p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
 
   /*
    * Can't use event->x / event->y here 
@@ -7952,12 +9488,13 @@ shape_motion (GtkWidget      *widget,
 }
 
 GtkWidget *
-shape_create_icon (char     *xpm_file,
-		   gint      x,
-		   gint      y,
-		   gint      px,
-		   gint      py,
-		   gint      window_type)
+shape_create_icon (GdkScreen *screen,
+		   char      *xpm_file,
+		   gint       x,
+		   gint       y,
+		   gint       px,
+		   gint       py,
+		   gint       window_type)
 {
   GtkWidget *window;
   GtkWidget *pixmap;
@@ -7975,9 +9512,10 @@ shape_create_icon (char     *xpm_file,
    * GDK_WINDOW_TOPLEVEL works also, giving you a title border
    */
   window = gtk_window_new (window_type);
+  gtk_window_set_screen (GTK_WINDOW (window), screen);
   
   fixed = gtk_fixed_new ();
-  gtk_widget_set_usize (fixed, 100,100);
+  gtk_widget_set_size_request (fixed, 100, 100);
   gtk_container_add (GTK_CONTAINER (window), fixed);
   gtk_widget_show (fixed);
   
@@ -7992,24 +9530,24 @@ shape_create_icon (char     *xpm_file,
 					   &style->bg[GTK_STATE_NORMAL],
 					   xpm_file);
 
-  pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
+  pixmap = gtk_image_new_from_pixmap (gdk_pixmap, gdk_pixmap_mask);
   gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
   gtk_widget_show (pixmap);
   
   gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px, py);
   
-  gdk_drawable_unref (gdk_pixmap_mask);
-  gdk_drawable_unref (gdk_pixmap);
+  g_object_unref (gdk_pixmap_mask);
+  g_object_unref (gdk_pixmap);
 
-  gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
-		      GTK_SIGNAL_FUNC (shape_pressed),NULL);
-  gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
-		      GTK_SIGNAL_FUNC (shape_released),NULL);
-  gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
-		      GTK_SIGNAL_FUNC (shape_motion),NULL);
+  g_signal_connect (window, "button_press_event",
+		    G_CALLBACK (shape_pressed), NULL);
+  g_signal_connect (window, "button_release_event",
+		    G_CALLBACK (shape_released), NULL);
+  g_signal_connect (window, "motion_notify_event",
+		    G_CALLBACK (shape_motion), NULL);
 
   icon_pos = g_new (CursorOffset, 1);
-  gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
+  g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
 
   gtk_widget_set_uposition (window, x, y);
   gtk_widget_show (window);
@@ -8018,13 +9556,14 @@ shape_create_icon (char     *xpm_file,
 }
 
 void 
-create_shapes (void)
+create_shapes (GtkWidget *widget)
 {
   /* Variables used by the Drag/Drop and Shape Window demos */
   static GtkWidget *modeller = NULL;
   static GtkWidget *sheets = NULL;
   static GtkWidget *rings = NULL;
   static GtkWidget *with_region = NULL;
+  GdkScreen *screen = gtk_widget_get_screen (widget);
   
   if (!(file_exists ("Modeller.xpm") &&
 	file_exists ("FilesQueue.xpm") &&
@@ -8034,24 +9573,24 @@ create_shapes (void)
 
   if (!modeller)
     {
-      modeller = shape_create_icon ("Modeller.xpm",
+      modeller = shape_create_icon (screen, "Modeller.xpm",
 				    440, 140, 0,0, GTK_WINDOW_POPUP);
 
-      gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &modeller);
+      g_signal_connect (modeller, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&modeller);
     }
   else
     gtk_widget_destroy (modeller);
 
   if (!sheets)
     {
-      sheets = shape_create_icon ("FilesQueue.xpm",
+      sheets = shape_create_icon (screen, "FilesQueue.xpm",
 				  580, 170, 0,0, GTK_WINDOW_POPUP);
 
-      gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &sheets);
+      g_signal_connect (sheets, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&sheets);
 
     }
   else
@@ -8059,12 +9598,12 @@ create_shapes (void)
 
   if (!rings)
     {
-      rings = shape_create_icon ("3DRings.xpm",
+      rings = shape_create_icon (screen, "3DRings.xpm",
 				 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (rings), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &rings);
+      g_signal_connect (rings, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&rings);
     }
   else
     gtk_widget_destroy (rings);
@@ -8074,14 +9613,14 @@ create_shapes (void)
       GdkRegion *region;
       gint x, y;
       
-      with_region = shape_create_icon ("3DRings.xpm",
+      with_region = shape_create_icon (screen, "3DRings.xpm",
                                        460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
 
       gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
       
-      gtk_signal_connect (GTK_OBJECT (with_region), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &with_region);
+      g_signal_connect (with_region, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&with_region);
 
       /* reset shape from mask to a region */
       x = 0;
@@ -8119,7 +9658,7 @@ create_shapes (void)
  */
 
 void
-create_wmhints (void)
+create_wmhints (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *label;
@@ -8134,9 +9673,12 @@ create_wmhints (void)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+      
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -8160,7 +9702,7 @@ create_wmhints (void)
       gtk_widget_show (box1);
 
       label = gtk_label_new ("Try iconizing me!");
-      gtk_widget_set_usize (label, 150, 50);
+      gtk_widget_set_size_request (label, 150, 50);
       gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
       gtk_widget_show (label);
 
@@ -8178,9 +9720,9 @@ create_wmhints (void)
 
       button = gtk_button_new_with_label ("close");
 
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
 
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
@@ -8215,7 +9757,13 @@ window_state_callback (GtkWidget *widget,
                      (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
                      "sticky" : "not sticky", ", ",
                      (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
-                     "maximized" : "not maximized",
+                     "maximized" : "not maximized", ", ",
+                     (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
+                     "fullscreen" : "not fullscreen",
+                     (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
+                     "above" : "not above", ", ",
+                     (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
+                     "below" : "not below", ", ",
                      NULL);
   
   gtk_label_set_text (GTK_LABEL (label), msg);
@@ -8234,46 +9782,67 @@ tracking_label (GtkWidget *window)
 
   hbox = gtk_hbox_new (FALSE, 5);
 
-  gtk_signal_connect_object (GTK_OBJECT (hbox),
-                             "destroy",
-                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (hbox,
+			   "destroy",
+			   G_CALLBACK (gtk_widget_destroy),
+			   window,
+			   G_CONNECT_SWAPPED);
   
   label = gtk_label_new ("<no window state events received>");
   gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
   
-  gtk_signal_connect (GTK_OBJECT (window),
-                      "window_state_event",
-                      GTK_SIGNAL_FUNC (window_state_callback),
-                      label);
+  g_signal_connect (window,
+		    "window_state_event",
+		    G_CALLBACK (window_state_callback),
+		    label);
 
   button = gtk_button_new_with_label ("Deiconify");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_deiconify),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_deiconify),
+                           window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Iconify");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_iconify),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_iconify),
+                           window,
+			   G_CONNECT_SWAPPED);
+  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+  button = gtk_button_new_with_label ("Fullscreen");
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_fullscreen),
+                           window,
+			   G_CONNECT_SWAPPED);
+  gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+  button = gtk_button_new_with_label ("Unfullscreen");
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_unfullscreen),
+                           window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
   
   button = gtk_button_new_with_label ("Present");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_present),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_present),
+                           window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Show");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_widget_show),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_widget_show),
+                           window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
   
   gtk_widget_show_all (hbox);
@@ -8281,54 +9850,120 @@ tracking_label (GtkWidget *window)
   return hbox;
 }
 
+void
+keep_window_above (GtkToggleButton *togglebutton, gpointer data)
+{
+  GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
+
+  gtk_window_set_keep_above (GTK_WINDOW (data),
+                             gtk_toggle_button_get_active (togglebutton));
+
+  if (gtk_toggle_button_get_active (togglebutton))
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+}
+
+void
+keep_window_below (GtkToggleButton *togglebutton, gpointer data)
+{
+  GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
+
+  gtk_window_set_keep_below (GTK_WINDOW (data),
+                             gtk_toggle_button_get_active (togglebutton));
+
+  if (gtk_toggle_button_get_active (togglebutton))
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+}
+
+
 static GtkWidget*
 get_state_controls (GtkWidget *window)
 {
   GtkWidget *vbox;
   GtkWidget *button;
+  GtkWidget *button_above;
+  GtkWidget *button_below;
 
   vbox = gtk_vbox_new (FALSE, 0);
   
   button = gtk_button_new_with_label ("Stick");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_stick),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_stick),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Unstick");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_unstick),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_unstick),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   button = gtk_button_new_with_label ("Maximize");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_maximize),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_maximize),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Unmaximize");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_unmaximize),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_unmaximize),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Iconify");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_iconify),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_iconify),
+			   window,
+			   G_CONNECT_SWAPPED);
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+  button = gtk_button_new_with_label ("Fullscreen");
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_fullscreen),
+                           window,
+			   G_CONNECT_SWAPPED);
+  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+  button = gtk_button_new_with_label ("Unfullscreen");
+  g_signal_connect_object (button,
+			   "clicked",
+                           G_CALLBACK (gtk_window_unfullscreen),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
+  button_above = gtk_toggle_button_new_with_label ("Keep above");
+  g_signal_connect (button_above,
+		    "toggled",
+		    G_CALLBACK (keep_window_above),
+		    window);
+  gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
+
+  button_below = gtk_toggle_button_new_with_label ("Keep below");
+  g_signal_connect (button_below,
+		    "toggled",
+		    G_CALLBACK (keep_window_below),
+		    window);
+  gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
+
+  g_object_set_data (G_OBJECT (button_above), "radio", button_below);
+  g_object_set_data (G_OBJECT (button_below), "radio", button_above);
+
   button = gtk_button_new_with_label ("Hide (withdraw)");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_widget_hide),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_widget_hide),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   gtk_widget_show_all (vbox);
@@ -8337,7 +9972,7 @@ get_state_controls (GtkWidget *window)
 }
 
 void
-create_window_states (void)
+create_window_states (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *label;
@@ -8345,14 +9980,16 @@ create_window_states (void)
   GtkWidget *iconified;
   GtkWidget *normal;
   GtkWidget *controls;
-  
+
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Window states");
       
@@ -8360,18 +9997,28 @@ create_window_states (void)
       gtk_container_add (GTK_CONTAINER (window), box1);
 
       iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-      gtk_signal_connect_object (GTK_OBJECT (iconified), "destroy",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+
+      gtk_window_set_screen (GTK_WINDOW (iconified),
+			     gtk_widget_get_screen (widget));
+      
+      g_signal_connect_object (iconified, "destroy",
+			       G_CALLBACK (gtk_widget_destroy),
+			       window,
+			       G_CONNECT_SWAPPED);
       gtk_window_iconify (GTK_WINDOW (iconified));
       gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
       controls = get_state_controls (iconified);
       gtk_container_add (GTK_CONTAINER (iconified), controls);
       
       normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-      gtk_signal_connect_object (GTK_OBJECT (normal), "destroy",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+
+      gtk_window_set_screen (GTK_WINDOW (normal),
+			     gtk_widget_get_screen (widget));
+      
+      g_signal_connect_object (normal, "destroy",
+			       G_CALLBACK (gtk_widget_destroy),
+			       window,
+			       G_CONNECT_SWAPPED);
       
       gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
       controls = get_state_controls (normal);
@@ -8468,16 +10115,16 @@ set_default_size_callback (GtkWidget *widget,
 }
 
 static void
-unset_usize_callback (GtkWidget *widget,
-                      gpointer   data)
+unset_size_request_callback (GtkWidget *widget,
+			     gpointer   data)
 {
   gtk_widget_set_size_request (g_object_get_data (data, "target"),
                                -1, -1);
 }
 
 static void
-set_usize_callback (GtkWidget *widget,
-                    gpointer   data)
+set_size_request_callback (GtkWidget *widget,
+			   gpointer   data)
 {
   gint w, h;
   
@@ -8533,7 +10180,7 @@ static void
 allow_shrink_callback (GtkWidget *widget,
                        gpointer   data)
 {
-  g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+  g_object_set (g_object_get_data (data, "target"),
                 "allow_shrink",
                 GTK_TOGGLE_BUTTON (widget)->active,
                 NULL);
@@ -8543,22 +10190,12 @@ static void
 allow_grow_callback (GtkWidget *widget,
                      gpointer   data)
 {
-  g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+  g_object_set (g_object_get_data (data, "target"),
                 "allow_grow",
                 GTK_TOGGLE_BUTTON (widget)->active,
                 NULL);
 }
 
-static void
-auto_shrink_callback (GtkWidget *widget,
-                      gpointer   data)
-{
-  g_object_set (G_OBJECT (g_object_get_data (data, "target")),
-                "auto_shrink",
-                GTK_TOGGLE_BUTTON (widget)->active,
-                NULL);
-}
-
 static void
 gravity_selected (GtkWidget *widget,
                   gpointer   data)
@@ -8595,24 +10232,25 @@ get_screen_corner (GtkWindow *window,
                    gint      *y)
 {
   int w, h;
+  GdkScreen * screen = gtk_window_get_screen (window);
   
   gtk_window_get_size (GTK_WINDOW (window), &w, &h);
 
   switch (gtk_window_get_gravity (window))
     {
     case GDK_GRAVITY_SOUTH_EAST:
-      *x = gdk_screen_width () - w;
-      *y = gdk_screen_height () - h;
+      *x = gdk_screen_get_width (screen) - w;
+      *y = gdk_screen_get_height (screen) - h;
       break;
 
     case GDK_GRAVITY_NORTH_EAST:
-      *x = gdk_screen_width () - w;
+      *x = gdk_screen_get_width (screen) - w;
       *y = 0;
       break;
 
     case GDK_GRAVITY_SOUTH_WEST:
       *x = 0;
-      *y = gdk_screen_height () - h;
+      *y = gdk_screen_get_height (screen) - h;
       break;
 
     case GDK_GRAVITY_NORTH_WEST:
@@ -8621,28 +10259,28 @@ get_screen_corner (GtkWindow *window,
       break;
       
     case GDK_GRAVITY_SOUTH:
-      *x = (gdk_screen_width () - w) / 2;
-      *y = gdk_screen_height () - h;
+      *x = (gdk_screen_get_width (screen) - w) / 2;
+      *y = gdk_screen_get_height (screen) - h;
       break;
 
     case GDK_GRAVITY_NORTH:
-      *x = (gdk_screen_width () - w) / 2;
+      *x = (gdk_screen_get_width (screen) - w) / 2;
       *y = 0;
       break;
 
     case GDK_GRAVITY_WEST:
       *x = 0;
-      *y = (gdk_screen_height () - h) / 2;
+      *y = (gdk_screen_get_height (screen) - h) / 2;
       break;
 
     case GDK_GRAVITY_EAST:
-      *x = gdk_screen_width () - w;
-      *y = (gdk_screen_height () - h) / 2;
+      *x = gdk_screen_get_width (screen) - w;
+      *y = (gdk_screen_get_height (screen) - h) / 2;
       break;
 
     case GDK_GRAVITY_CENTER:
-      *x = (gdk_screen_width () - w) / 2;
-      *y = (gdk_screen_height () - h) / 2;
+      *x = (gdk_screen_get_width (screen) - w) / 2;
+      *y = (gdk_screen_get_height (screen) - h) / 2;
       break;
 
     case GDK_GRAVITY_STATIC:
@@ -8684,6 +10322,9 @@ make_gravity_window (GtkWidget   *destroy_with,
   
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
+  gtk_window_set_screen (GTK_WINDOW (window),
+			 gtk_widget_get_screen (destroy_with));
+
   vbox = gtk_vbox_new (FALSE, 0);
   gtk_widget_show (vbox);
   
@@ -8691,15 +10332,16 @@ make_gravity_window (GtkWidget   *destroy_with,
   gtk_window_set_title (GTK_WINDOW (window), title);
   gtk_window_set_gravity (GTK_WINDOW (window), gravity);
 
-  gtk_signal_connect_object (GTK_OBJECT (destroy_with),
-                             "destroy",
-                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (destroy_with,
+			   "destroy",
+			   G_CALLBACK (gtk_widget_destroy),
+			   window,
+			   G_CONNECT_SWAPPED);
 
   
   button = gtk_button_new_with_mnemonic ("_Move to current position");
 
-  g_signal_connect (G_OBJECT (button), "clicked",
+  g_signal_connect (button, "clicked",
                     G_CALLBACK (move_gravity_window_to_current_position),
                     window);
 
@@ -8708,7 +10350,7 @@ make_gravity_window (GtkWidget   *destroy_with,
 
   button = gtk_button_new_with_mnemonic ("Move to _starting position");
 
-  g_signal_connect (G_OBJECT (button), "clicked",
+  g_signal_connect (button, "clicked",
                     G_CALLBACK (move_gravity_window_to_starting_position),
                     window);
 
@@ -8803,16 +10445,20 @@ window_controls (GtkWidget *window)
   
   control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
+  gtk_window_set_screen (GTK_WINDOW (control_window),
+			 gtk_widget_get_screen (window));
+
   gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
   
   g_object_set_data (G_OBJECT (control_window),
                      "target",
                      window);
   
-  gtk_signal_connect_object (GTK_OBJECT (control_window),
-                             "destroy",
-                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (control_window,
+			   "destroy",
+			   G_CALLBACK (gtk_widget_destroy),
+                           window,
+			   G_CONNECT_SWAPPED);
 
   vbox = gtk_vbox_new (FALSE, 5);
   
@@ -8821,10 +10467,10 @@ window_controls (GtkWidget *window)
   label = gtk_label_new ("<no configure events>");
   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
   
-  gtk_signal_connect (GTK_OBJECT (window),
-                      "configure_event",
-                      GTK_SIGNAL_FUNC (configure_event_callback),
-                      label);
+  g_signal_connect (window,
+		    "configure_event",
+		    G_CALLBACK (configure_event_callback),
+		    label);
 
   adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
                                               5.0, 0.0);
@@ -8845,116 +10491,112 @@ window_controls (GtkWidget *window)
   entry = gtk_entry_new ();
   gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
 
-  gtk_signal_connect (GTK_OBJECT (entry), "changed",
-                      GTK_SIGNAL_FUNC (set_geometry_callback),
-                      control_window);
+  g_signal_connect (entry, "changed",
+		    G_CALLBACK (set_geometry_callback),
+		    control_window);
 
   button = gtk_button_new_with_label ("Show gravity test windows");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (do_gravity_test),
-                             control_window);
+  g_signal_connect_swapped (button,
+			    "clicked",
+			    G_CALLBACK (do_gravity_test),
+			    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Reshow with initial size");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_window_reshow_with_initial_size),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_window_reshow_with_initial_size),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   button = gtk_button_new_with_label ("Queue resize");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_widget_queue_resize),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   button = gtk_button_new_with_label ("Resize");
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "clicked",
-                      GTK_SIGNAL_FUNC (set_size_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "clicked",
+		    G_CALLBACK (set_size_callback),
+		    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Set default size");
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "clicked",
-                      GTK_SIGNAL_FUNC (set_default_size_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "clicked",
+		    G_CALLBACK (set_default_size_callback),
+		    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Unset default size");
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "clicked",
-                      GTK_SIGNAL_FUNC (unset_default_size_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "clicked",
+		    G_CALLBACK (unset_default_size_callback),
+                    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   button = gtk_button_new_with_label ("Set size request");
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "clicked",
-                      GTK_SIGNAL_FUNC (set_usize_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "clicked",
+		    G_CALLBACK (set_size_request_callback),
+		    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Unset size request");
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "clicked",
-                      GTK_SIGNAL_FUNC (unset_usize_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "clicked",
+		    G_CALLBACK (unset_size_request_callback),
+                    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   button = gtk_button_new_with_label ("Move");
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "clicked",
-                      GTK_SIGNAL_FUNC (set_location_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "clicked",
+		    G_CALLBACK (set_location_callback),
+		    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Move to current position");
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "clicked",
-                      GTK_SIGNAL_FUNC (move_to_position_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "clicked",
+		    G_CALLBACK (move_to_position_callback),
+		    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   button = gtk_check_button_new_with_label ("Allow shrink");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "toggled",
-                      GTK_SIGNAL_FUNC (allow_shrink_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "toggled",
+		    G_CALLBACK (allow_shrink_callback),
+		    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_check_button_new_with_label ("Allow grow");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "toggled",
-                      GTK_SIGNAL_FUNC (allow_grow_callback),
-                      GTK_OBJECT (control_window));
+  g_signal_connect (button,
+		    "toggled",
+		    G_CALLBACK (allow_grow_callback),
+                    control_window);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
-  button = gtk_check_button_new_with_label ("Auto shrink");
-  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
-  gtk_signal_connect (GTK_OBJECT (button),
-                      "toggled",
-                      GTK_SIGNAL_FUNC (auto_shrink_callback),
-                      GTK_OBJECT (control_window));
-  gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
-
   button = gtk_button_new_with_mnemonic ("_Show");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_widget_show),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_widget_show),
+			   window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_mnemonic ("_Hide");
-  gtk_signal_connect_object (GTK_OBJECT (button),
-                             "clicked",
-                             GTK_SIGNAL_FUNC (gtk_widget_hide),
-                             GTK_OBJECT (window));
+  g_signal_connect_object (button,
+			   "clicked",
+			   G_CALLBACK (gtk_widget_hide),
+                           window,
+			   G_CONNECT_SWAPPED);
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   menu = gtk_menu_new ();
@@ -8992,10 +10634,10 @@ window_controls (GtkWidget *window)
   gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
   
 
-  gtk_signal_connect (GTK_OBJECT (om),
-                      "changed",
-                      GTK_SIGNAL_FUNC (gravity_selected),
-                      control_window);
+  g_signal_connect (om,
+		    "changed",
+		    G_CALLBACK (gravity_selected),
+		    control_window);
 
   gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
 
@@ -9030,10 +10672,10 @@ window_controls (GtkWidget *window)
   gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
   
 
-  gtk_signal_connect (GTK_OBJECT (om),
-                      "changed",
-                      GTK_SIGNAL_FUNC (pos_selected),
-                      control_window);
+  g_signal_connect (om,
+		    "changed",
+		    G_CALLBACK (pos_selected),
+		    control_window);
 
   gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
   
@@ -9043,31 +10685,32 @@ window_controls (GtkWidget *window)
 }
 
 void
-create_window_sizing (void)
+create_window_sizing (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   static GtkWidget *target_window = NULL;
-  
+
   if (!target_window)
     {
       GtkWidget *label;
       
       target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-
+      gtk_window_set_screen (GTK_WINDOW (target_window),
+			     gtk_widget_get_screen (widget));
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
       gtk_container_add (GTK_CONTAINER (target_window), label);
       gtk_widget_show (label);
       
-      gtk_signal_connect (GTK_OBJECT (target_window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &target_window);
+      g_signal_connect (target_window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&target_window);
 
       window = window_controls (target_window);
       
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
       
       gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
     }
@@ -9220,10 +10863,8 @@ static void
 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
 {
   gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
-	 gtk_spin_button_get_value_as_float 
-				   (GTK_SPIN_BUTTON (pdata->x_align_spin)),
-	 gtk_spin_button_get_value_as_float
-				   (GTK_SPIN_BUTTON (pdata->y_align_spin)));
+	 gtk_spin_button_get_value (GTK_SPIN_BUTTON (pdata->x_align_spin)),
+	 gtk_spin_button_get_value (GTK_SPIN_BUTTON (pdata->y_align_spin)));
 }
 
 static void
@@ -9245,7 +10886,7 @@ entry_changed (GtkWidget *widget, ProgressData *pdata)
 }
 
 void
-create_progress_bar (void)
+create_progress_bar (GtkWidget *widget)
 {
   GtkWidget *button;
   GtkWidget *vbox;
@@ -9272,7 +10913,7 @@ create_progress_bar (void)
     "Continuous",
     "Discrete"
   };
-
+  
   if (!pdata)
     pdata = g_new0 (ProgressData, 1);
 
@@ -9280,11 +10921,14 @@ create_progress_bar (void)
     {
       pdata->window = gtk_dialog_new ();
 
-      gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
+      gtk_window_set_screen (GTK_WINDOW (pdata->window),
+			     gtk_widget_get_screen (widget));
+
+      gtk_window_set_resizable (GTK_WINDOW (pdata->window), FALSE);
 
-      gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
-			  GTK_SIGNAL_FUNC (destroy_progress),
-			  &pdata);
+      g_signal_connect (pdata->window, "destroy",
+			G_CALLBACK (destroy_progress),
+			&pdata);
 
       pdata->timer = 0;
 
@@ -9306,10 +10950,12 @@ create_progress_bar (void)
       gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
 
       adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (progress_value_changed), pdata);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (progress_value_changed), pdata);
 
-      pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
+      pdata->pbar = gtk_widget_new (GTK_TYPE_PROGRESS_BAR,
+				    "adjustment", adj,
+				    NULL);
       gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
 				      "%v from [%l,%u] (=%p%%)");
       gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
@@ -9350,9 +10996,9 @@ create_progress_bar (void)
       gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
       
       check = gtk_check_button_new_with_label ("Show text");
-      gtk_signal_connect (GTK_OBJECT (check), "clicked",
-			  GTK_SIGNAL_FUNC (toggle_show_text),
-			  pdata);
+      g_signal_connect (check, "clicked",
+			G_CALLBACK (toggle_show_text),
+			pdata);
       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
 			5, 5);
@@ -9366,12 +11012,12 @@ create_progress_bar (void)
       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
 
       pdata->entry = gtk_entry_new ();
-      gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
-			  GTK_SIGNAL_FUNC (entry_changed),
-			  pdata);
+      g_signal_connect (pdata->entry, "changed",
+			G_CALLBACK (entry_changed),
+			pdata);
       gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
       gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
-      gtk_widget_set_usize (pdata->entry, 100, -1);
+      gtk_widget_set_size_request (pdata->entry, 100, -1);
       gtk_widget_set_sensitive (pdata->entry, FALSE);
 
       label = gtk_label_new ("Text align :");
@@ -9390,8 +11036,8 @@ create_progress_bar (void)
       
       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
       pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (adjust_align), pdata);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (adjust_align), pdata);
       gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
       gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
 
@@ -9400,8 +11046,8 @@ create_progress_bar (void)
 
       adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
       pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (adjust_align), pdata);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (adjust_align), pdata);
       gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
       gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
 
@@ -9432,15 +11078,14 @@ create_progress_bar (void)
 			5, 5);
       adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
       pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (adjust_blocks), pdata);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (adjust_blocks), pdata);
       gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
       gtk_widget_set_sensitive (pdata->block_spin, FALSE);
 
       check = gtk_check_button_new_with_label ("Activity mode");
-      gtk_signal_connect (GTK_OBJECT (check), "clicked",
-			  GTK_SIGNAL_FUNC (toggle_activity_mode),
-			  pdata);
+      g_signal_connect (check, "clicked",
+			G_CALLBACK (toggle_activity_mode), pdata);
       gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
 			GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
 			5, 5);
@@ -9453,8 +11098,8 @@ create_progress_bar (void)
       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
       adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
       pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (adjust_step), pdata);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (adjust_step), pdata);
       gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
       gtk_widget_set_sensitive (pdata->step_spin, FALSE);
 
@@ -9466,16 +11111,16 @@ create_progress_bar (void)
       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
       adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
       pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (adjust_act_blocks), pdata);
       gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
 			  0);
       gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (pdata->window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				pdata->window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -9530,7 +11175,7 @@ find_widget (GtkWidget *widget, FindWidgetData *data)
       while (window != widget->parent->window)
 	{
 	  gint tx, ty, twidth, theight;
-	  gdk_window_get_size (window, &twidth, &theight);
+	  gdk_drawable_get_size (window, &twidth, &theight);
 
 	  if (new_allocation.x < 0)
 	    {
@@ -9595,14 +11240,14 @@ find_widget (GtkWidget *widget, FindWidgetData *data)
 }
 
 static GtkWidget *
-find_widget_at_pointer (void)
+find_widget_at_pointer (GdkDisplay *display)
 {
   GtkWidget *widget = NULL;
   GdkWindow *pointer_window;
   gint x, y;
   FindWidgetData data;
  
- pointer_window = gdk_window_at_pointer (NULL, NULL);
+ pointer_window = gdk_display_get_window_at_pointer (display, NULL, NULL);
  
  if (pointer_window)
    gdk_window_get_user_data (pointer_window, (gpointer*) &widget);
@@ -9644,13 +11289,13 @@ destroy_properties (GtkWidget             *widget,
 
   if (data->cursor)
     {
-      gdk_cursor_destroy (data->cursor);
+      gdk_cursor_unref (data->cursor);
       data->cursor = NULL;
     }
 
   if (data->handler)
     {
-      gtk_signal_disconnect (widget, data->handler);
+      g_signal_handler_disconnect (widget, data->handler);
       data->handler = 0;
     }
 
@@ -9670,11 +11315,16 @@ property_query_event (GtkWidget	       *widget,
   if (event->type == GDK_BUTTON_RELEASE)
     {
       gtk_grab_remove (widget);
-      gdk_pointer_ungrab (GDK_CURRENT_TIME);
+      gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+				  GDK_CURRENT_TIME);
       
-      res_widget = find_widget_at_pointer ();
+      res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
       if (res_widget)
-	create_prop_editor (G_OBJECT (res_widget), 0);
+	{
+	  g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
+			     gtk_widget_get_screen (widget));
+	  create_prop_editor (G_OBJECT (res_widget), 0);
+	}
 
       data->in_query = FALSE;
     }
@@ -9688,12 +11338,13 @@ query_properties (GtkButton *button,
 {
   gint failure;
 
-  gtk_signal_connect (GTK_OBJECT (button), "event",
-		      (GtkSignalFunc) property_query_event, data);
+  g_signal_connect (button, "event",
+		    G_CALLBACK (property_query_event), data);
 
 
   if (!data->cursor)
-    data->cursor = gdk_cursor_new (GDK_TARGET);
+    data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (button)),
+					       GDK_TARGET);
   
   failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
 			      TRUE,
@@ -9708,7 +11359,7 @@ query_properties (GtkButton *button,
 }
 
 static void
-create_properties (void)
+create_properties (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
@@ -9726,9 +11377,12 @@ create_properties (void)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      data->handler = gtk_signal_connect (GTK_OBJECT (window), "destroy",
-					  GTK_SIGNAL_FUNC(destroy_properties),
-					  data);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));      
+
+      data->handler = g_signal_connect (window, "destroy",
+					G_CALLBACK (destroy_properties),
+					data);
 
       gtk_window_set_title (GTK_WINDOW (window), "test properties");
       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
@@ -9741,9 +11395,9 @@ create_properties (void)
       
       button = gtk_button_new_with_label ("Query properties");
       gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(query_properties),
-			  data);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (query_properties),
+			data);
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
@@ -9782,7 +11436,8 @@ color_idle_func (GtkWidget *preview)
 
   count += 1;
 
-  gtk_widget_draw (preview, NULL);
+  gtk_widget_queue_draw (preview);
+  gdk_window_process_updates (preview->window, TRUE);
 
   return TRUE;
 }
@@ -9798,7 +11453,7 @@ color_preview_destroy (GtkWidget  *widget,
 }
 
 void
-create_color_preview (void)
+create_color_preview (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *preview;
@@ -9807,13 +11462,14 @@ create_color_preview (void)
 
   if (!window)
     {
-      gtk_widget_push_colormap (gdk_rgb_get_cmap ());
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-      gtk_widget_pop_colormap ();
+      
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(color_preview_destroy),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (color_preview_destroy),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
@@ -9883,7 +11539,7 @@ gray_preview_destroy (GtkWidget  *widget,
 }
 
 void
-create_gray_preview (void)
+create_gray_preview (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *preview;
@@ -9894,9 +11550,12 @@ create_gray_preview (void)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gray_preview_destroy),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gray_preview_destroy),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
@@ -9990,7 +11649,7 @@ selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
 }
 
 void
-create_selection_test (void)
+create_selection_test (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
@@ -10002,10 +11661,13 @@ create_selection_test (void)
   if (!window)
     {
       window = gtk_dialog_new ();
+      
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -10025,29 +11687,29 @@ create_selection_test (void)
 				      GTK_POLICY_AUTOMATIC, 
 				      GTK_POLICY_AUTOMATIC);
       gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
-      gtk_widget_set_usize (scrolled_win, 100, 200);
+      gtk_widget_set_size_request (scrolled_win, 100, 200);
 
       list = gtk_list_new ();
       gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
 
-      gtk_signal_connect (GTK_OBJECT(list), "selection_received",
-			  GTK_SIGNAL_FUNC (selection_test_received), NULL);
+      g_signal_connect (list, "selection_received",
+			G_CALLBACK (selection_test_received), NULL);
 
       /* .. And create some buttons */
       button = gtk_button_new_with_label ("Get Targets");
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
 			  button, TRUE, TRUE, 0);
 
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC (selection_test_get_targets), list);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (selection_test_get_targets), list);
 
       button = gtk_button_new_with_label ("Quit");
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
 			  button, TRUE, TRUE, 0);
 
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
@@ -10061,23 +11723,26 @@ create_selection_test (void)
  */
 
 void
-create_gamma_curve (void)
+create_gamma_curve (GtkWidget *widget)
 {
   static GtkWidget *window = NULL, *curve;
   static int count = 0;
   gfloat vec[256];
   gint max;
   gint i;
-
+  
   if (!window)
     {
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
       gtk_window_set_title (GTK_WINDOW (window), "test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK(gtk_widget_destroyed),
+			&window);
 
       curve = gtk_gamma_curve_new ();
       gtk_container_add (GTK_CONTAINER (window), curve);
@@ -10157,7 +11822,7 @@ scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
   adj->page_increment = 0.9 * widget->allocation.height;
   adj->page_size = widget->allocation.height;
 
-  gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
+  g_signal_emit_by_name (adj, "changed");
 }
 
 static void
@@ -10177,7 +11842,7 @@ scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
 
 
 void
-create_scroll_test (void)
+create_scroll_test (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *hbox;
@@ -10187,14 +11852,17 @@ create_scroll_test (void)
   GtkAdjustment *adj;
   GdkGeometry geometry;
   GdkWindowHints geometry_mask;
-  
+
   if (!window)
     {
       window = gtk_dialog_new ();
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -10205,7 +11873,7 @@ create_scroll_test (void)
       gtk_widget_show (hbox);
 
       drawing_area = gtk_drawing_area_new ();
-      gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
+      gtk_widget_set_size_request (drawing_area, 200, 200);
       gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
       gtk_widget_show (drawing_area);
 
@@ -10218,16 +11886,16 @@ create_scroll_test (void)
       gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
       gtk_widget_show (scrollbar);
 
-      gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
-			  GTK_SIGNAL_FUNC (scroll_test_expose), adj);
-      gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
-			  GTK_SIGNAL_FUNC (scroll_test_configure), adj);
-      gtk_signal_connect (GTK_OBJECT (drawing_area), "scroll_event",
-			  GTK_SIGNAL_FUNC (scroll_test_scroll), adj);
+      g_signal_connect (drawing_area, "expose_event",
+			G_CALLBACK (scroll_test_expose), adj);
+      g_signal_connect (drawing_area, "configure_event",
+			G_CALLBACK (scroll_test_configure), adj);
+      g_signal_connect (drawing_area, "scroll_event",
+			G_CALLBACK (scroll_test_scroll), adj);
       
-      gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
-			  GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
-			  drawing_area);
+      g_signal_connect (adj, "value_changed",
+			G_CALLBACK (scroll_test_adjustment_changed),
+			drawing_area);
       
       /* .. And create some buttons */
 
@@ -10235,9 +11903,9 @@ create_scroll_test (void)
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
 			  button, TRUE, TRUE, 0);
 
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
       gtk_widget_show (button);
 
       /* Set up gridded geometry */
@@ -10312,7 +11980,7 @@ destroy_timeout_test (GtkWidget  *widget,
 }
 
 void
-create_timeout_test (void)
+create_timeout_test (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
@@ -10322,9 +11990,12 @@ create_timeout_test (void)
     {
       window = gtk_dialog_new ();
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(destroy_timeout_test),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (destroy_timeout_test),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -10336,9 +12007,9 @@ create_timeout_test (void)
       gtk_widget_show (label);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -10346,18 +12017,18 @@ create_timeout_test (void)
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("start");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(start_timeout_test),
-			  label);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK(start_timeout_test),
+			label);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("stop");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(stop_timeout_test),
-			  NULL);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (stop_timeout_test),
+			NULL);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -10419,14 +12090,14 @@ destroy_idle_test (GtkWidget  *widget,
 }
 
 static void
-toggle_idle_container (GtkObject *button,
+toggle_idle_container (GObject *button,
 		       GtkContainer *container)
 {
-  gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button)));
+  gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
 }
 
 static void
-create_idle_test (void)
+create_idle_test (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
@@ -10441,9 +12112,12 @@ create_idle_test (void)
 
       window = gtk_dialog_new ();
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(destroy_idle_test),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (destroy_idle_test),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
@@ -10509,9 +12183,9 @@ create_idle_test (void)
 		    NULL);
 
       button = gtk_button_new_with_label ("close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -10519,18 +12193,18 @@ create_idle_test (void)
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("start");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(start_idle_test),
-			  label);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (start_idle_test),
+			label);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
       gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("stop");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(stop_idle_test),
-			  NULL);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (stop_idle_test),
+			NULL);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -10552,66 +12226,88 @@ reload_all_rc_files (void)
 {
   static GdkAtom atom_rcfiles = GDK_NONE;
 
-  GdkEventClient sev;
+  GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
   int i;
   
   if (!atom_rcfiles)
     atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
 
   for(i = 0; i < 5; i++)
-    sev.data.l[i] = 0;
-  sev.data_format = 32;
-  sev.message_type = atom_rcfiles;
-  gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
+    send_event->client.data.l[i] = 0;
+  send_event->client.data_format = 32;
+  send_event->client.message_type = atom_rcfiles;
+  gdk_event_send_clientmessage_toall (send_event);
+
+  gdk_event_free (send_event);
 }
 
 void
-create_rc_file (void)
+create_rc_file (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
+  GtkWidget *frame;
+  GtkWidget *vbox;
+  GtkWidget *label;
 
   if (!window)
     {
       window = gtk_dialog_new ();
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(destroy_idle_test),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
+
+      frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), frame, FALSE, FALSE, 0);
+
+      vbox = gtk_vbox_new (FALSE, 0);
+      gtk_container_add (GTK_CONTAINER (frame), vbox);
+      
+      label = gtk_label_new ("This label should be red");
+      gtk_widget_set_name (label, "testgtk-red-label");
+      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+      label = gtk_label_new ("This label should be green");
+      gtk_widget_set_name (label, "testgtk-green-label");
+      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+      label = gtk_label_new ("This label should be blue");
+      gtk_widget_set_name (label, "testgtk-blue-label");
+      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
       gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
       gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 
       button = gtk_button_new_with_label ("Reload");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(gtk_rc_reparse_all), NULL);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (gtk_rc_reparse_all), NULL);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
       gtk_widget_grab_default (button);
-      gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("Reload All");
-      gtk_signal_connect (GTK_OBJECT (button), "clicked",
-			  GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (reload_all_rc_files), NULL);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
-      gtk_widget_show (button);
 
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
-      gtk_widget_show (button);
-
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
-    gtk_widget_show (window);
+    gtk_widget_show_all (window);
   else
     gtk_widget_destroy (window);
 }
@@ -10628,7 +12324,7 @@ mainloop_destroyed (GtkWidget *w, GtkWidget **window)
 }
 
 void
-create_mainloop (void)
+create_mainloop (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *label;
@@ -10638,11 +12334,14 @@ create_mainloop (void)
     {
       window = gtk_dialog_new ();
 
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
       gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
 
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(mainloop_destroyed),
-			  &window);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (mainloop_destroyed),
+			&window);
 
       label = gtk_label_new ("In recursive main loop...");
       gtk_misc_set_padding (GTK_MISC(label), 20, 20);
@@ -10655,9 +12354,9 @@ create_mainloop (void)
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, 
 			  FALSE, TRUE, 0);
 
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC (gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
 
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_widget_grab_default (button);
@@ -10677,26 +12376,25 @@ create_mainloop (void)
     gtk_widget_destroy (window);
 }
 
-gint
+gboolean
 layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
 {
   GtkLayout *layout;
 
   gint i,j;
   gint imin, imax, jmin, jmax;
-  
+
   layout = GTK_LAYOUT (widget);
 
+  if (event->window != layout->bin_window)
+    return FALSE;
+  
   imin = (event->area.x) / 10;
   imax = (event->area.x + event->area.width + 9) / 10;
 
   jmin = (event->area.y) / 10;
   jmax = (event->area.y + event->area.height + 9) / 10;
 
-  gdk_window_clear_area (widget->window,
-			 event->area.x, event->area.y,
-			 event->area.width, event->area.height);
-
   for (i=imin; i<imax; i++)
     for (j=jmin; j<jmax; j++)
       if ((i+j) % 2)
@@ -10706,10 +12404,10 @@ layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
 			    10*i, 10*j, 
 			    1+i%10, 1+j%10);
   
-  return TRUE;
+  return FALSE;
 }
 
-void create_layout (void)
+void create_layout (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *layout;
@@ -10723,12 +12421,15 @@ void create_layout (void)
       gint i, j;
       
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Layout");
-      gtk_widget_set_usize (window, 200, 200);
+      gtk_widget_set_size_request (window, 200, 200);
 
       scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
       gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
@@ -10748,8 +12449,8 @@ void create_layout (void)
       GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0;
       
       gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
-      gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
-			  GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
+      g_signal_connect (layout, "expose_event",
+			G_CALLBACK (layout_expose_handler), NULL);
       
       gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000);
       
@@ -10786,7 +12487,7 @@ void create_layout (void)
 }
 
 void
-create_styles (void)
+create_styles (GtkWidget *widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *label;
@@ -10805,15 +12506,18 @@ create_styles (void)
   if (!window)
     {
       window = gtk_dialog_new ();
-      gtk_signal_connect (GTK_OBJECT (window), "destroy",
-			  GTK_SIGNAL_FUNC(gtk_widget_destroyed),
-			  &window);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (widget));
+     
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed),
+			&window);
 
       
       button = gtk_button_new_with_label ("Close");
-      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
-				 GTK_SIGNAL_FUNC(gtk_widget_destroy),
-				 GTK_OBJECT (window));
+      g_signal_connect_swapped (button, "clicked",
+				G_CALLBACK (gtk_widget_destroy),
+				window);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), 
 			  button, TRUE, TRUE, 0);
@@ -10891,7 +12595,7 @@ create_styles (void)
       gtk_widget_modify_style (button, rc_style);
       gtk_widget_modify_style (GTK_BIN (button)->child, rc_style);
 
-      g_object_unref (G_OBJECT (rc_style));
+      g_object_unref (rc_style);
       
       gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
     }
@@ -10915,11 +12619,16 @@ do_exit (GtkWidget *widget, GtkWidget *window)
 
 struct {
   char *label;
-  void (*func) ();
+  void (*func) (GtkWidget *widget);
   gboolean do_not_benchmark;
 } buttons[] =
 {
+#ifdef G_OS_WIN32
+  /* dog slow on NT, no working at all on 9x */
+  { "big windows", create_big_windows, TRUE },
+#else
   { "big windows", create_big_windows },
+#endif
   { "button box", create_button_box },
   { "buttons", create_buttons },
   { "check buttons", create_check_buttons },
@@ -10927,18 +12636,22 @@ struct {
   { "color selection", create_color_selection },
   { "ctree", create_ctree },
   { "cursors", create_cursors },
-  { "dialog", create_dialog },
+  { "dialog", create_dialog, TRUE },
+  { "display & screen", create_display_screen, TRUE },
   { "entry", create_entry },
+  { "event box", create_event_box },
   { "event watcher", create_event_watcher },
   { "file selection", create_file_selection },
   { "flipping", create_flipping },
   { "focus", create_focus },
   { "font selection", create_font_selection },
   { "gamma curve", create_gamma_curve, TRUE },
+  { "gridded geometry", create_gridded_geometry },
   { "handle box", create_handle_box },
   { "image from drawable", create_get_image },
   { "image", create_image },
   { "item factory", create_item_factory },
+  { "key lookup", create_key_lookup },
   { "labels", create_labels },
   { "layout", create_layout },
   { "list", create_list },
@@ -10947,6 +12660,7 @@ struct {
   { "modal window", create_modal_window, TRUE },
   { "notebook", create_notebook },
   { "panes", create_panes },
+  { "paned keyboard", create_paned_keyboard_navigation },
   { "pixmap", create_pixmap },
   { "preview color", create_color_preview, TRUE },
   { "preview gray", create_gray_preview, TRUE },
@@ -10956,6 +12670,7 @@ struct {
   { "range controls", create_range_controls },
   { "rc file", create_rc_file },
   { "reparent", create_reparent },
+  { "resize grips", create_resize_grips },
   { "rulers", create_rulers },
   { "saved position", create_saved_position },
   { "scrolled windows", create_scrolled_windows },
@@ -11007,12 +12722,12 @@ create_main_window (void)
 				 &geometry,
 				 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
 
-  gtk_signal_connect (GTK_OBJECT (window), "destroy",
-		      GTK_SIGNAL_FUNC(gtk_main_quit),
-		      NULL);
-  gtk_signal_connect (GTK_OBJECT (window), "delete-event",
-		      GTK_SIGNAL_FUNC (gtk_false),
-		      NULL);
+  g_signal_connect (window, "destroy",
+		    G_CALLBACK (gtk_main_quit),
+		    NULL);
+  g_signal_connect (window, "delete-event",
+		    G_CALLBACK (gtk_false),
+		    NULL);
 
   box1 = gtk_vbox_new (FALSE, 0);
   gtk_container_add (GTK_CONTAINER (window), box1);
@@ -11031,6 +12746,7 @@ create_main_window (void)
 
   label = gtk_label_new (buffer);
   gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+  gtk_widget_set_name (label, "testgtk-version-label");
 
   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
   gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
@@ -11050,10 +12766,10 @@ create_main_window (void)
     {
       button = gtk_button_new_with_label (buttons[i].label);
       if (buttons[i].func)
-        gtk_signal_connect (GTK_OBJECT (button), 
-			    "clicked", 
-			    GTK_SIGNAL_FUNC(buttons[i].func),
-			    NULL);
+        g_signal_connect (button, 
+			  "clicked", 
+			  G_CALLBACK(buttons[i].func),
+			  NULL);
       else
         gtk_widget_set_sensitive (button, FALSE);
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
@@ -11067,9 +12783,9 @@ create_main_window (void)
   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
 
   button = gtk_button_new_with_mnemonic ("_Close");
-  gtk_signal_connect (GTK_OBJECT (button), "clicked",
-		      GTK_SIGNAL_FUNC (do_exit),
-		      window);
+  g_signal_connect (button, "clicked",
+		    G_CALLBACK (do_exit),
+		    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);
@@ -11080,10 +12796,11 @@ create_main_window (void)
 static void
 test_init ()
 {
-  if (file_exists ("../gdk-pixbuf/.libs/libpixbufloader-pnm.so"))
+  if (g_file_test ("../gdk-pixbuf/libpixbufloader-pnm.la",
+		   G_FILE_TEST_EXISTS))
     {
-      putenv ("GDK_PIXBUF_MODULEDIR=../gdk-pixbuf/.libs");
-      putenv ("GTK_IM_MODULE_FILE=../modules/input/gtk.immodules");
+      g_setenv ("GDK_PIXBUF_MODULE_FILE", "../gdk-pixbuf/gdk-pixbuf.loaders", TRUE);
+      g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/gtk.immodules", TRUE);
     }
 }
 
@@ -11105,16 +12822,16 @@ pad (const char *str, int to)
 }
 
 static void
-bench_iteration (void (* fn) ())
+bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
 {
-  fn (); /* on */
-  while (g_main_iteration (FALSE));
-  fn (); /* off */
-  while (g_main_iteration (FALSE));
+  fn (widget); /* on */
+  while (g_main_context_iteration (NULL, FALSE));
+  fn (widget); /* off */
+  while (g_main_context_iteration (NULL, FALSE));
 }
 
 void
-do_real_bench (void (* fn) (), char *name, int num)
+do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
 {
   GTimeVal tv0, tv1;
   double dt_first;
@@ -11129,7 +12846,7 @@ do_real_bench (void (* fn) (), char *name, int num)
   }
 
   g_get_current_time (&tv0);
-  bench_iteration (fn); 
+  bench_iteration (widget, fn); 
   g_get_current_time (&tv1);
 
   dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
@@ -11137,7 +12854,7 @@ do_real_bench (void (* fn) (), char *name, int num)
 
   g_get_current_time (&tv0);
   for (n = 0; n < num - 1; n++)
-    bench_iteration (fn); 
+    bench_iteration (widget, fn); 
   g_get_current_time (&tv1);
   dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
 	+ (tv1.tv_usec - tv0.tv_usec) / 1000.0;
@@ -11153,15 +12870,17 @@ void
 do_bench (char* what, int num)
 {
   int i;
-  void (* fn) ();
+  GtkWidget *widget;
+  void (* fn) (GtkWidget *widget);
   fn = NULL;
+  widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
-  if (g_strcasecmp (what, "ALL") == 0)
+  if (g_ascii_strcasecmp (what, "ALL") == 0)
     {
       for (i = 0; i < nbuttons; i++)
 	{
 	  if (!buttons[i].do_not_benchmark)
-	    do_real_bench (buttons[i].func, buttons[i].label, num);
+	    do_real_bench (widget, buttons[i].func, buttons[i].label, num);
 	}
 
       return;
@@ -11180,7 +12899,7 @@ do_bench (char* what, int num)
       if (!fn)
 	g_print ("Can't bench: \"%s\" not found.\n", what);
       else
-	do_real_bench (fn, buttons[i].label, num);
+	do_real_bench (widget, fn, buttons[i].label, num);
     }
 }
 
@@ -11208,6 +12927,8 @@ main (int argc, char *argv[])
   if (file_exists ("testgtkrc"))
     gtk_rc_add_default_file ("testgtkrc");
 
+  g_set_application_name ("GTK+ Test Program");
+
   gtk_init (&argc, &argv);
 
   /*  benchmarking
@@ -11260,20 +12981,30 @@ main (int argc, char *argv[])
 				'9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
 				"debug_msg",
 				1,
-				GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
+				G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
+  
+  /* We use gtk_rc_parse_string() here so we can make sure it works across theme
+   * changes
+   */
 
+  gtk_rc_parse_string ("style \"testgtk-version-label\" { "
+		       "   fg[NORMAL] = \"#ff0000\"\n"
+		       "   font = \"Sans 18\"\n"
+		       "}\n"
+		       "widget \"*.testgtk-version-label\" style \"testgtk-version-label\"");
+  
   create_main_window ();
 
   gtk_main ();
 
   if (1)
     {
-      while (g_main_pending ())
-	g_main_iteration (FALSE);
+      while (g_main_context_pending (NULL))
+	g_main_context_iteration (NULL, FALSE);
 #if 0
       sleep (1);
-      while (g_main_pending ())
-	g_main_iteration (FALSE);
+      while (g_main_context_pending (NULL))
+	g_main_context_iteration (NULL, FALSE);
 #endif
     }
   return 0;