]> Pileus Git - ~andy/gtk/blobdiff - tests/testgtk.c
Remove reallocate-redraws property. This is something that only a widget
[~andy/gtk] / tests / testgtk.c
index b8aa151133ac8c726d743c4d031c587be3dbc31e..a6502591826f1ea4ba26386d8fdd6d5b3e68c084 100644 (file)
@@ -39,7 +39,7 @@
 #endif
 
 #define GTK_ENABLE_BROKEN
-#include "gtk.h"
+#include "gtk/gtk.h"
 #include "gdk/gdk.h"
 #include "gdk/gdkkeysyms.h"
 
@@ -47,6 +47,8 @@
 #define sleep(n) _sleep(n)
 #endif
 
+#include "prop-editor.h"
+
 #include "circles.xbm"
 #include "test.xpm"
 
@@ -111,18 +113,23 @@ build_option_menu (OptionMenuItem items[],
   GtkWidget *omenu;
   GtkWidget *menu;
   GtkWidget *menu_item;
+  GSList *group;
   gint i;
 
   omenu = gtk_option_menu_new ();
       
   menu = gtk_menu_new ();
+  group = NULL;
   
   for (i = 0; i < num_items; i++)
     {
-      menu_item = gtk_menu_item_new_with_label (items[i].name);
+      menu_item = gtk_radio_menu_item_new_with_label (group, items[i].name);
       gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
                          (GtkSignalFunc) items[i].func, data);
+      group = gtk_radio_menu_item_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);
       gtk_widget_show (menu_item);
     }
 
@@ -683,20 +690,6 @@ set_toolbar_both_horiz (GtkWidget *widget,
   gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
 }
 
-static void
-set_toolbar_small_space (GtkWidget *widget,
-                        gpointer   data)
-{
-  gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
-}
-
-static void
-set_toolbar_big_space (GtkWidget *widget,
-                      gpointer   data)
-{
-  gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
-}
-
 static void
 set_toolbar_enable (GtkWidget *widget,
                    gpointer   data)
@@ -711,34 +704,6 @@ set_toolbar_disable (GtkWidget *widget,
   gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
 }
 
-static void
-set_toolbar_borders (GtkWidget *widget,
-                    gpointer   data)
-{
-  gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
-}
-
-static void
-set_toolbar_borderless (GtkWidget *widget,
-                       gpointer   data)
-{
-  gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
-}
-
-static void
-set_toolbar_space_style_empty (GtkWidget *widget,
-                              gpointer   data)
-{
-  gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY);
-}
-
-static void
-set_toolbar_space_style_line (GtkWidget *widget,
-                             gpointer   data)
-{
-  gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE);
-}
-
 static void
 create_toolbar (void)
 {
@@ -760,7 +725,6 @@ create_toolbar (void)
       gtk_widget_realize (window);
 
       toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
-      gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
 
       gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
                                GTK_STOCK_NEW,
@@ -810,14 +774,6 @@ create_toolbar (void)
 
       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
-      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                              "Small", "Use small spaces", "Toolbar/Small",
-                              new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                              (GtkSignalFunc) set_toolbar_small_space, toolbar);
-      gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                              "Big", "Use big spaces", "Toolbar/Big",
-                              new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                              (GtkSignalFunc) set_toolbar_big_space, toolbar);
 
       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
@@ -833,24 +789,24 @@ create_toolbar (void)
       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                              "Borders", "Show Borders", NULL,
+                              "Frobate", "Frobate tooltip", NULL,
                               new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                              (GtkSignalFunc) set_toolbar_borders, toolbar);
+                              (GtkSignalFunc) NULL, toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                              "Borderless", "Hide Borders", NULL,
+                              "Baz", "Baz tooltip", NULL,
                               new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                              (GtkSignalFunc) set_toolbar_borderless, toolbar);
+                              (GtkSignalFunc) NULL, toolbar);
 
       gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
       
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                              "Empty", "Empty spaces", NULL,
+                              "Blah", "Blah tooltip", NULL,
                               new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                              (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
+                              (GtkSignalFunc) NULL, toolbar);
       gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                              "Lines", "Lines in spaces", NULL,
+                              "Bar", "Bar tooltip", NULL,
                               new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                              (GtkSignalFunc) set_toolbar_space_style_line, toolbar);
+                              (GtkSignalFunc) NULL, toolbar);
 
       gtk_container_add (GTK_CONTAINER (window), toolbar);
     }
@@ -870,7 +826,6 @@ make_toolbar (GtkWidget *window)
     gtk_widget_realize (window);
 
   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
-  gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
 
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
                           "Horizontal", "Horizontal toolbar layout", NULL,
@@ -899,13 +854,13 @@ make_toolbar (GtkWidget *window)
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                          "Small", "Use small spaces", NULL,
+                          "Woot", "Woot woot woot", NULL,
                           new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                          (GtkSignalFunc) set_toolbar_small_space, toolbar);
+                          (GtkSignalFunc) NULL, toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                          "Big", "Use big spaces", "Toolbar/Big",
+                          "Blah", "Blah blah blah", "Toolbar/Big",
                           new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                          (GtkSignalFunc) set_toolbar_big_space, toolbar);
+                          (GtkSignalFunc) NULL, toolbar);
 
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
@@ -921,13 +876,13 @@ make_toolbar (GtkWidget *window)
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
   
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                          "Borders", "Show Borders", NULL,
+                          "Hoo", "Hoo tooltip", NULL,
                           new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                          (GtkSignalFunc) set_toolbar_borders, toolbar);
+                          (GtkSignalFunc) NULL, toolbar);
   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
-                          "Borderless", "Hide Borders", NULL,
+                          "Woo", "Woo tooltip", NULL,
                           new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
-                          (GtkSignalFunc) set_toolbar_borderless, toolbar);
+                          (GtkSignalFunc) NULL, toolbar);
 
   return toolbar;
 }
@@ -1648,7 +1603,7 @@ create_handle_box (void)
     gtk_widget_show (handle_box);
 
     toolbar = make_toolbar (window);
-    gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
+    
     gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
     gtk_widget_show (toolbar);
 
@@ -2753,6 +2708,10 @@ create_image (void)
       GdkBitmap *mask;
         
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      /* 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);
       
       gtk_signal_connect (GTK_OBJECT (window), "destroy",
                          GTK_SIGNAL_FUNC(gtk_widget_destroyed),
@@ -2812,7 +2771,8 @@ create_menu (gint depth, gint length, gboolean tearoff)
   image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
                                     GTK_ICON_SIZE_MENU);
   gtk_widget_show (image);
-  menuitem = gtk_image_menu_item_new (image, "Image item");
+  menuitem = gtk_image_menu_item_new_with_label ("Image item");
+  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
   gtk_widget_show (menuitem);
   
@@ -2899,7 +2859,8 @@ create_menus (void)
       image = gtk_image_new_from_stock (GTK_STOCK_HELP,
                                         GTK_ICON_SIZE_MENU);
       gtk_widget_show (image);
-      menuitem = gtk_image_menu_item_new (image, "Help");
+      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_right_justify (GTK_MENU_ITEM (menuitem));
       gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
@@ -3250,6 +3211,9 @@ cmw_color (GtkWidget *widget, GtkWidget *parent)
 
     csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
 
+    gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (csd)->colorsel),
+                                         TRUE);
+    
     /* Set as modal */
     gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
 
@@ -3557,14 +3521,6 @@ entry_toggle_frame (GtkWidget *checkbutton,
                             GTK_TOGGLE_BUTTON(checkbutton)->active);
 }
 
-static void
-entry_toggle_editable (GtkWidget *checkbutton,
-                      GtkWidget *entry)
-{
-   gtk_entry_set_editable(GTK_ENTRY(entry),
-                         GTK_TOGGLE_BUTTON(checkbutton)->active);
-}
-
 static void
 entry_toggle_sensitive (GtkWidget *checkbutton,
                        GtkWidget *entry)
@@ -3573,30 +3529,12 @@ entry_toggle_sensitive (GtkWidget *checkbutton,
 }
 
 static void
-entry_toggle_visibility (GtkWidget *checkbutton,
-                       GtkWidget *entry)
-{
-   gtk_entry_set_visibility (GTK_ENTRY (entry),
-                             GTK_TOGGLE_BUTTON (checkbutton)->active);
-}
-
-static void
-entry_toggle_invisible_char (GtkWidget *checkbutton,
-                             GtkWidget *entry)
+entry_props_clicked (GtkWidget *button,
+                    GObject   *entry)
 {
-  if (GTK_TOGGLE_BUTTON (checkbutton)->active)
-    gtk_entry_set_invisible_char (GTK_ENTRY (entry), 0);
-  else
-    gtk_entry_set_invisible_char (GTK_ENTRY (entry), '*');
-}
+  GtkWidget *window = create_prop_editor (entry, 0);
 
-
-static void
-entry_toggle_activate_default (GtkWidget *checkbutton,
-                               GtkWidget *entry)
-{
-   gtk_entry_set_activates_default (GTK_ENTRY (entry),
-                                    GTK_TOGGLE_BUTTON (checkbutton)->active);
+  gtk_window_set_title (GTK_WINDOW (window), "Entry Properties");
 }
 
 static void
@@ -3605,10 +3543,9 @@ create_entry (void)
   static GtkWidget *window = NULL;
   GtkWidget *box1;
   GtkWidget *box2;
-  GtkWidget *editable_check;
+  GtkWidget *hbox;
+  GtkWidget *has_frame_check;
   GtkWidget *sensitive_check;
-  GtkWidget *invisible_char_check;
-  GtkWidget *activate_check;
   GtkWidget *entry, *cb;
   GtkWidget *button;
   GtkWidget *separator;
@@ -3639,78 +3576,51 @@ create_entry (void)
 
       box1 = gtk_vbox_new (FALSE, 0);
       gtk_container_add (GTK_CONTAINER (window), box1);
-      gtk_widget_show (box1);
 
 
       box2 = gtk_vbox_new (FALSE, 10);
       gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
       gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
-      gtk_widget_show (box2);
 
+      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 السلام عليكم");
       gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
-      gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
-      gtk_widget_show (entry);
+      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);
 
       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");
+      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);
-      gtk_widget_show (cb);
-
-      editable_check = gtk_check_button_new_with_label("Editable");
-      gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
-                         GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
-      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
-      gtk_widget_show (editable_check);
-
-      editable_check = gtk_check_button_new_with_label("Visible");
-      gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
-                         GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
-      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
-      gtk_widget_show (editable_check);
 
       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);
-      gtk_widget_show (sensitive_check);
-
-      activate_check = gtk_check_button_new_with_label ("Activates default");
-      gtk_box_pack_start (GTK_BOX (box2), activate_check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT (activate_check), "toggled",
-                         GTK_SIGNAL_FUNC (entry_toggle_activate_default), entry);
-      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (activate_check), FALSE);
-      gtk_widget_show (activate_check);
-      
-      invisible_char_check = gtk_check_button_new_with_label("invisible_char = 0");
-      gtk_box_pack_start (GTK_BOX (box2), invisible_char_check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT(invisible_char_check), "toggled",
-                         GTK_SIGNAL_FUNC(entry_toggle_invisible_char), entry);
-      gtk_widget_show (invisible_char_check);
-
-      editable_check = gtk_check_button_new_with_label("Has Frame");
-      gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
-      gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
+
+      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(editable_check), TRUE);
-      gtk_widget_show (editable_check);
+      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);
-      gtk_widget_show (separator);
 
       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);
-      gtk_widget_show (box2);
-
 
       button = gtk_button_new_with_label ("close");
       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
@@ -3719,15 +3629,177 @@ create_entry (void)
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
       gtk_widget_grab_default (button);
-      gtk_widget_show (button);
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
-    gtk_widget_show (window);
+    gtk_widget_show_all (window);
   else
     gtk_widget_destroy (window);
 }
 
+/*
+ * GtkSizeGroup
+ */
+
+#define SIZE_GROUP_INITIAL_SIZE 50
+
+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);
+}
+
+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));
+}
+
+static GtkWidget *
+create_size_group_window (GtkSizeGroup *master_size_group)
+{
+  GtkWidget *window;
+  GtkWidget *table;
+  GtkWidget *main_button;
+  GtkWidget *button;
+  GtkWidget *spin_button;
+  GtkWidget *hbox;
+  GtkSizeGroup *hgroup1;
+  GtkSizeGroup *hgroup2;
+  GtkSizeGroup *vgroup1;
+  GtkSizeGroup *vgroup2;
+
+  window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
+                                       NULL, 0,
+                                       GTK_STOCK_BUTTON_CLOSE,
+                                       GTK_RESPONSE_NONE,
+                                       NULL);
+
+  gtk_window_set_resizeable (GTK_WINDOW (window), FALSE);
+
+  gtk_signal_connect (GTK_OBJECT (window), "response",
+                     GTK_SIGNAL_FUNC (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);
+
+  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);
+
+  hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+  hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+  vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+  vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+
+  main_button = gtk_button_new_with_label ("X");
+  
+  gtk_table_attach (GTK_TABLE (table), main_button,
+                   0, 1,       0, 1,
+                   GTK_EXPAND, GTK_EXPAND,
+                   0,          0);
+  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);
+
+  button = gtk_button_new ();
+  gtk_table_attach (GTK_TABLE (table), button,
+                   1, 2,       0, 1,
+                   GTK_EXPAND, GTK_EXPAND,
+                   0,          0);
+  gtk_size_group_add_widget (vgroup1, button);
+  gtk_size_group_add_widget (vgroup2, button);
+
+  button = gtk_button_new ();
+  gtk_table_attach (GTK_TABLE (table), button,
+                   0, 1,       1, 2,
+                   GTK_EXPAND, GTK_EXPAND,
+                   0,          0);
+  gtk_size_group_add_widget (hgroup1, button);
+  gtk_size_group_add_widget (hgroup2, button);
+
+  button = gtk_button_new ();
+  gtk_table_attach (GTK_TABLE (table), button,
+                   1, 2,       1, 2,
+                   GTK_EXPAND, GTK_EXPAND,
+                   0,          0);
+  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));
+  
+  hbox = gtk_hbox_new (FALSE, 5);
+  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox, FALSE, FALSE, 0);
+  
+  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);
+
+  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);
+
+  return window;
+}
+
+static void
+create_size_groups (void)
+{
+  static GtkWidget *window1 = NULL;
+  static GtkWidget *window2 = NULL;
+  static GtkSizeGroup *master_size_group;
+
+  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);
+
+      gtk_signal_connect (GTK_OBJECT (window1), "destroy",
+                         GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+                         &window1);
+    }
+
+  if (!window2)
+    {
+      window2 = create_size_group_window (master_size_group);
+
+      gtk_signal_connect (GTK_OBJECT (window2), "destroy",
+                         GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+                         &window2);
+    }
+
+  if (GTK_WIDGET_VISIBLE (window1) && GTK_WIDGET_VISIBLE (window2))
+    {
+      gtk_widget_destroy (window1);
+      gtk_widget_destroy (window2);
+    }
+  else
+    {
+      if (!GTK_WIDGET_VISIBLE (window1))
+       gtk_widget_show_all (window1);
+      if (!GTK_WIDGET_VISIBLE (window2))
+       gtk_widget_show_all (window2);
+    }
+}
+
 /*
  * GtkSpinButton
  */
@@ -3770,6 +3842,23 @@ get_value (GtkWidget *widget, gpointer data)
   gtk_label_set_text (label, buf);
 }
 
+static void
+get_spin_value (GtkWidget *widget, gpointer data)
+{
+  gchar *buffer;
+  GtkLabel *label;
+  GtkSpinButton *spin;
+
+  spin = GTK_SPIN_BUTTON (widget);
+  label = GTK_LABEL (data);
+
+  buffer = g_strdup_printf ("%0.*f", spin->digits,
+                           gtk_spin_button_get_value_as_float (spin));
+  gtk_label_set_text (label, buffer);
+
+  g_free (buffer);
+}
+
 static gint
 spin_button_time_output_func (GtkSpinButton *spin_button)
 {
@@ -3839,7 +3928,7 @@ static gint
 spin_button_hex_input_func (GtkSpinButton *spin_button,
                            gdouble       *new_val)
 {
-  gchar *buf;
+  const gchar *buf;
   gchar *err;
   gdouble res;
 
@@ -4050,6 +4139,22 @@ create_spins (void)
       gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
       gtk_label_set_text (GTK_LABEL (val_label), "0");
 
+      frame = gtk_frame_new ("Using Convenience Constructor");
+      gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
+  
+      hbox = gtk_hbox_new (FALSE, 0);
+      gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+      gtk_container_add (GTK_CONTAINER (frame), hbox);
+      
+      val_label = gtk_label_new ("0.0");
+
+      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);
+      gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
+      gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
+
       hbox = gtk_hbox_new (FALSE, 0);
       gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
   
@@ -4132,7 +4237,7 @@ set_cursor (GtkWidget *spinner,
   c &= 0xfe;
 
   label = gtk_object_get_user_data (GTK_OBJECT (spinner));
-  vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
+  vals = gtk_type_enum_get_values (GDK_TYPE_CURSOR_TYPE);
   while (vals && vals->value != c)
     vals++;
   if (vals)
@@ -6024,8 +6129,8 @@ opacity_toggled_cb (GtkWidget *w,
   GtkColorSelection *colorsel;
 
   colorsel = GTK_COLOR_SELECTION (cs->colorsel);
-  gtk_color_selection_set_use_opacity (colorsel,
-                                      gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
+  gtk_color_selection_set_has_opacity_control (colorsel,
+                                              gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
 }
 
 static void
@@ -6035,7 +6140,7 @@ palette_toggled_cb (GtkWidget *w,
   GtkColorSelection *colorsel;
 
   colorsel = GTK_COLOR_SELECTION (cs->colorsel);
-  gtk_color_selection_set_use_palette (colorsel,
+  gtk_color_selection_set_has_palette (colorsel,
                                       gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
 }
 
@@ -6571,6 +6676,13 @@ create_event_watcher (void)
  * GtkRange
  */
 
+static gchar*
+reformat_value (GtkScale *scale,
+                gdouble   value)
+{
+  return g_strdup_printf ("-->%g<--", value);
+}
+
 static void
 create_range_controls (void)
 {
@@ -6623,6 +6735,15 @@ create_range_controls (void)
       gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
       gtk_widget_show (scrollbar);
 
+      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);
+      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));
@@ -6639,10 +6760,20 @@ create_range_controls (void)
       gtk_range_set_inverted (GTK_RANGE (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_scale_set_draw_value (GTK_SCALE (scale), TRUE);
+      gtk_signal_connect (GTK_OBJECT (scale),
+                          "format_value",
+                          GTK_SIGNAL_FUNC (reformat_value),
+                          NULL);
+      gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
+      gtk_widget_show (scale);
+
       
       gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
       gtk_widget_show (hbox);
-
+      
       separator = gtk_hseparator_new ();
       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
       gtk_widget_show (separator);
@@ -7351,8 +7482,17 @@ toggle_shrink (GtkWidget *widget, GtkWidget *child)
   gtk_widget_unref (child);
 }
 
+static void
+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");
+}
+
 GtkWidget *
-create_pane_options (GtkPaned *paned,
+create_pane_options (GtkPaned    *paned,
                     const gchar *frame_label,
                     const gchar *label1,
                     const gchar *label2)
@@ -7360,12 +7500,13 @@ create_pane_options (GtkPaned *paned,
   GtkWidget *frame;
   GtkWidget *table;
   GtkWidget *label;
+  GtkWidget *button;
   GtkWidget *check_button;
   
   frame = gtk_frame_new (frame_label);
   gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
   
-  table = gtk_table_new (3, 2, 4);
+  table = gtk_table_new (4, 2, 4);
   gtk_container_add (GTK_CONTAINER (frame), table);
   
   label = gtk_label_new (label1);
@@ -7410,6 +7551,13 @@ create_pane_options (GtkPaned *paned,
                      GTK_SIGNAL_FUNC (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);
+
   return frame;
 }
 
@@ -8218,8 +8366,14 @@ configure_event_callback (GtkWidget *widget,
   GtkWidget *label = data;
   gchar *msg;
   gint x, y;
-
+  
+#if 0
+  /* FIXME */
   gtk_window_get_location (GTK_WINDOW (widget), &x, &y);
+#else  
+  x = 0;
+  y = 0;
+#endif
   
   msg = g_strdup_printf ("event: %d,%d  %d x %d\n"
                          "location: %d, %d",
@@ -8256,8 +8410,7 @@ set_size_callback (GtkWidget *widget,
   
   get_ints (data, &w, &h);
 
-  gtk_window_set_size (g_object_get_data (data, "target"),
-                       w, h);
+  gtk_window_set_default_size (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
 }
      
 static void
@@ -8292,8 +8445,27 @@ set_location_callback (GtkWidget *widget,
   
   get_ints (data, &x, &y);
 
-  gtk_window_set_location (g_object_get_data (data, "target"),
-                           x, y);
+  gtk_widget_set_uposition (g_object_get_data (data, "target"), x, y);
+}
+
+static void
+set_geometry_callback (GtkWidget *entry,
+                       gpointer   data)
+{
+  gchar *text;
+  GtkWindow *target;
+
+  target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
+  
+  text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
+
+#if 0
+  /* FIXME */
+  if (!gtk_window_parse_geometry (target, text))
+    g_print ("Bad geometry string '%s'\n", text);
+#endif
+  
+  g_free (text);
 }
 
 static void
@@ -8330,7 +8502,7 @@ static void
 gravity_selected (GtkWidget *widget,
                   gpointer data)
 {
-  gtk_window_set_gravity (G_OBJECT (g_object_get_data (data, "target")),
+  gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
                           gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GDK_GRAVITY_NORTH_WEST);
 }
 
@@ -8343,6 +8515,7 @@ window_controls (GtkWidget *window)
   GtkWidget *button;
   GtkWidget *spin;
   GtkAdjustment *adj;
+  GtkWidget *entry;
   GtkWidget *om;
   GtkWidget *menu;
   gint i;
@@ -8388,36 +8561,43 @@ window_controls (GtkWidget *window)
 
   g_object_set_data (G_OBJECT (control_window), "spin2", spin);
 
+  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);
+  
   button = gtk_button_new_with_label ("Queue resize");
-  gtk_signal_connect_object (GTK_WIDGET (button),
+  gtk_signal_connect_object (GTK_OBJECT (button),
                              "clicked",
                              GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
                              GTK_OBJECT (control_window));
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   
   button = gtk_button_new_with_label ("Set size");
-  gtk_signal_connect (GTK_WIDGET (button),
+  gtk_signal_connect (GTK_OBJECT (button),
                       "clicked",
                       GTK_SIGNAL_FUNC (set_size_callback),
                       GTK_OBJECT (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_WIDGET (button),
+  gtk_signal_connect (GTK_OBJECT (button),
                       "clicked",
                       GTK_SIGNAL_FUNC (set_default_size_callback),
                       GTK_OBJECT (control_window));
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Set usize");
-  gtk_signal_connect (GTK_WIDGET (button),
+  gtk_signal_connect (GTK_OBJECT (button),
                       "clicked",
                       GTK_SIGNAL_FUNC (set_usize_callback),
                       GTK_OBJECT (control_window));
   gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   button = gtk_button_new_with_label ("Set location");
-  gtk_signal_connect (GTK_WIDGET (button),
+  gtk_signal_connect (GTK_OBJECT (button),
                       "clicked",
                       GTK_SIGNAL_FUNC (set_location_callback),
                       GTK_OBJECT (control_window));
@@ -8425,7 +8605,7 @@ window_controls (GtkWidget *window)
 
   button = gtk_check_button_new_with_label ("Allow shrink");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
-  gtk_signal_connect (GTK_WIDGET (button),
+  gtk_signal_connect (GTK_OBJECT (button),
                       "toggled",
                       GTK_SIGNAL_FUNC (allow_shrink_callback),
                       GTK_OBJECT (control_window));
@@ -8433,7 +8613,7 @@ window_controls (GtkWidget *window)
 
   button = gtk_check_button_new_with_label ("Allow grow");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
-  gtk_signal_connect (GTK_WIDGET (button),
+  gtk_signal_connect (GTK_OBJECT (button),
                       "toggled",
                       GTK_SIGNAL_FUNC (allow_grow_callback),
                       GTK_OBJECT (control_window));
@@ -8441,19 +8621,33 @@ window_controls (GtkWidget *window)
   
   button = gtk_check_button_new_with_label ("Auto shrink");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
-  gtk_signal_connect (GTK_WIDGET (button),
+  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));
+  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));
+  gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+  
   menu = gtk_menu_new ();
   
   i = 0;
   while (i < 10)
     {
       GtkWidget *mi;
-      static gchar *names[10] = {
+      static gchar *names[] = {
         "GDK_GRAVITY_NORTH_WEST",
         "GDK_GRAVITY_NORTH",
         "GDK_GRAVITY_NORTH_EAST",
@@ -8925,6 +9119,255 @@ create_progress_bar (void)
     gtk_widget_destroy (pdata->window);
 }
 
+/*
+ * Properties
+ */
+
+typedef struct {
+  int x;
+  int y;
+  gboolean found;
+  gboolean first;
+  GtkWidget *res_widget;
+} FindWidgetData;
+
+static void
+find_widget (GtkWidget *widget, FindWidgetData *data)
+{
+  GtkAllocation new_allocation;
+  gint x_offset = 0;
+  gint y_offset = 0;
+
+  new_allocation = widget->allocation;
+
+  if (data->found || !GTK_WIDGET_MAPPED (widget))
+    return;
+
+  /* Note that in the following code, we only count the
+   * position as being inside a WINDOW widget if it is inside
+   * widget->window; points that are outside of widget->window
+   * but within the allocation are not counted. This is consistent
+   * with the way we highlight drag targets.
+   */
+  if (!GTK_WIDGET_NO_WINDOW (widget))
+    {
+      new_allocation.x = 0;
+      new_allocation.y = 0;
+    }
+  
+  if (widget->parent && !data->first)
+    {
+      GdkWindow *window = widget->window;
+      while (window != widget->parent->window)
+       {
+         gint tx, ty, twidth, theight;
+         gdk_window_get_size (window, &twidth, &theight);
+
+         if (new_allocation.x < 0)
+           {
+             new_allocation.width += new_allocation.x;
+             new_allocation.x = 0;
+           }
+         if (new_allocation.y < 0)
+           {
+             new_allocation.height += new_allocation.y;
+             new_allocation.y = 0;
+           }
+         if (new_allocation.x + new_allocation.width > twidth)
+           new_allocation.width = twidth - new_allocation.x;
+         if (new_allocation.y + new_allocation.height > theight)
+           new_allocation.height = theight - new_allocation.y;
+
+         gdk_window_get_position (window, &tx, &ty);
+         new_allocation.x += tx;
+         x_offset += tx;
+         new_allocation.y += ty;
+         y_offset += ty;
+         
+         window = gdk_window_get_parent (window);
+       }
+    }
+
+  if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
+      (data->x < new_allocation.x + new_allocation.width) && 
+      (data->y < new_allocation.y + new_allocation.height))
+    {
+      /* First, check if the drag is in a valid drop site in
+       * one of our children 
+       */
+      if (GTK_IS_CONTAINER (widget))
+       {
+         FindWidgetData new_data = *data;
+         
+         new_data.x -= x_offset;
+         new_data.y -= y_offset;
+         new_data.found = FALSE;
+         new_data.first = FALSE;
+         
+         gtk_container_forall (GTK_CONTAINER (widget),
+                               (GtkCallback)find_widget,
+                               &new_data);
+         
+         data->found = new_data.found;
+         if (data->found)
+           data->res_widget = new_data.res_widget;
+       }
+
+      /* If not, and this widget is registered as a drop site, check to
+       * emit "drag_motion" to check if we are actually in
+       * a drop site.
+       */
+      if (!data->found)
+       {
+         data->found = TRUE;
+         data->res_widget = widget;
+       }
+    }
+}
+
+static GtkWidget *
+find_widget_at_pointer (void)
+{
+  GtkWidget *widget = NULL;
+  GdkWindow *pointer_window;
+  gint x, y;
+  FindWidgetData data;
+ pointer_window = gdk_window_at_pointer (NULL, NULL);
+ if (pointer_window)
+   gdk_window_get_user_data (pointer_window, (gpointer*) &widget);
+
+ if (widget)
+   {
+     gdk_window_get_pointer (widget->window,
+                            &x, &y, NULL);
+     
+     data.x = x;
+     data.y = y;
+     data.found = FALSE;
+     data.first = TRUE;
+
+     find_widget (widget, &data);
+     if (data.found)
+       return data.res_widget;
+     return widget;
+   }
+ return NULL;
+}
+
+struct PropertiesData {
+  GtkWidget **window;
+  GdkCursor *cursor;
+  gboolean in_query;
+  gint handler;
+};
+
+static void
+destroy_properties (GtkWidget  *widget,
+                   struct PropertiesData *data)
+{
+  *data->window = NULL;
+
+  if (data->cursor)
+    gdk_cursor_destroy (data->cursor);
+    
+  gtk_signal_disconnect (widget, data->handler);
+
+  g_free (data);
+}
+
+static gint
+property_query_event (GtkWidget               *widget,
+                     GdkEvent         *event,
+                     struct PropertiesData *data)
+{
+  GtkWidget *res_widget = NULL;
+
+  if (!data->in_query)
+    return FALSE;
+  
+  if (event->type == GDK_BUTTON_RELEASE)
+    {
+      gtk_grab_remove (widget);
+      gdk_pointer_ungrab (GDK_CURRENT_TIME);
+      
+      res_widget = find_widget_at_pointer ();
+      if (res_widget)
+       create_prop_editor (G_OBJECT (res_widget), 0);
+
+      data->in_query = FALSE;
+    }
+  return FALSE;
+}
+
+
+static void
+query_properties (GtkButton *button,
+                 struct PropertiesData *data)
+{
+  gint failure;
+
+  gtk_signal_connect (GTK_OBJECT (button), "event",
+                     (GtkSignalFunc) property_query_event, data);
+
+
+  if (!data->cursor)
+    data->cursor = gdk_cursor_new (GDK_TARGET);
+  
+  failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
+                             TRUE,
+                             GDK_BUTTON_RELEASE_MASK,
+                             NULL,
+                             data->cursor,
+                             GDK_CURRENT_TIME);
+
+  gtk_grab_add (GTK_WIDGET (button));
+
+  data->in_query = TRUE;
+}
+
+static void
+create_properties (void)
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *button;
+  struct PropertiesData *data;
+
+  data = g_new (struct PropertiesData, 1);
+  data->window = &window;
+  data->in_query = FALSE;
+  data->cursor = NULL;
+  data->handler = 0;
+
+  if (!window)
+    {
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+      data->handler = gtk_signal_connect_object (GTK_OBJECT (window), "destroy",
+                                                GTK_SIGNAL_FUNC(destroy_properties),
+                                                data);
+
+      gtk_window_set_title (GTK_WINDOW (window), "test properties");
+      gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+      button = gtk_button_new_with_label ("Query properties");
+      gtk_signal_connect (GTK_OBJECT (button), "clicked",
+                         GTK_SIGNAL_FUNC(query_properties),
+                         data);
+
+      
+      gtk_container_add (GTK_CONTAINER (window), button);
+    }
+
+  if (!GTK_WIDGET_VISIBLE (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+  
+}
+
+
 /*
  * Color Preview
  */
@@ -9342,7 +9785,6 @@ scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
 
   if (!GTK_WIDGET_DRAWABLE (widget))
     return;
-
   gdk_window_scroll (widget->window, 0, dy);
   gdk_window_process_updates (widget->window, FALSE);
 }
@@ -10145,6 +10587,7 @@ create_main_window (void)
       { "preview color", create_color_preview },
       { "preview gray", create_gray_preview },
       { "progress bar", create_progress_bar },
+      { "properties", create_properties },
       { "radio buttons", create_radio_buttons },
       { "range controls", create_range_controls },
       { "rc file", create_rc_file },
@@ -10153,6 +10596,7 @@ create_main_window (void)
       { "saved position", create_saved_position },
       { "scrolled windows", create_scrolled_windows },
       { "shapes", create_shapes },
+      { "size groups", create_size_groups },
       { "spinbutton", create_spins },
       { "statusbar", create_statusbar },
       { "styles", create_styles },
@@ -10254,7 +10698,7 @@ create_main_window (void)
   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");
+  button = gtk_button_new_with_mnemonic ("_Close");
   gtk_signal_connect (GTK_OBJECT (button), "clicked",
                      GTK_SIGNAL_FUNC (do_exit),
                      window);
@@ -10271,7 +10715,7 @@ test_init ()
   if (file_exists ("../gdk-pixbuf/.libs/libpixbufloader-pnm.so"))
     {
       putenv ("GDK_PIXBUF_MODULEDIR=../gdk-pixbuf/.libs");
-      putenv ("GTK_IM_MODULE_FILE=./gtk.immodules");
+      putenv ("GTK_IM_MODULE_FILE=../modules/input/gtk.immodules");
     }
 }