gtk3 1.2.0-x86-mingw32

data/vendor/local/share/gtk-2.0/demo/sizegroup.c

@@ -0,0 +1,167 @@
+/* Size Groups
+ *
+ * GtkSizeGroup provides a mechanism for grouping a number of
+ * widgets together so they all request the same amount of space.
+ * This is typically useful when you want a column of widgets to 
+ * have the same size, but you can't use a GtkTable widget.
+ * 
+ * Note that size groups only affect the amount of space requested,
+ * not the size that the widgets finally receive. If you want the
+ * widgets in a GtkSizeGroup to actually be the same size, you need
+ * to pack them in such a way that they get the size they request
+ * and not more. For example, if you are packing your widgets
+ * into a table, you would not include the GTK_FILL flag.
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+
+/* Convenience function to create a combo box holding a number of strings
+ */
+GtkWidget *
+create_combo_box (const char **strings)
+{
+  GtkWidget *combo_box;
+  const char **str;
+
+  combo_box = gtk_combo_box_text_new ();
+  
+  for (str = strings; *str; str++)
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), *str);
+
+  gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
+
+  return combo_box;
+}
+
+static void
+add_row (GtkTable     *table,
+	 int           row,
+	 GtkSizeGroup *size_group,
+	 const char   *label_text,
+	 const char  **options)
+{
+  GtkWidget *combo_box;
+  GtkWidget *label;
+
+  label = gtk_label_new_with_mnemonic (label_text);
+  gtk_misc_set_alignment (GTK_MISC (label), 0, 1);
+  gtk_table_attach (GTK_TABLE (table), label,
+		    0, 1,                  row, row + 1,
+		    GTK_EXPAND | GTK_FILL, 0,
+		    0,                     0);
+  
+  combo_box = create_combo_box (options);
+  gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo_box);
+  gtk_size_group_add_widget (size_group, combo_box);
+  gtk_table_attach (GTK_TABLE (table), combo_box,
+		    1, 2,                  row, row + 1,
+		    0,                     0,
+		    0,                     0);
+}
+
+static void
+toggle_grouping (GtkToggleButton *check_button,
+		 GtkSizeGroup    *size_group)
+{
+  GtkSizeGroupMode new_mode;
+
+  /* GTK_SIZE_GROUP_NONE is not generally useful, but is useful
+   * here to show the effect of GTK_SIZE_GROUP_HORIZONTAL by
+   * contrast.
+   */
+  if (gtk_toggle_button_get_active (check_button))
+    new_mode = GTK_SIZE_GROUP_HORIZONTAL;
+  else
+    new_mode = GTK_SIZE_GROUP_NONE;
+  
+  gtk_size_group_set_mode (size_group, new_mode);
+}
+
+GtkWidget *
+do_sizegroup (GtkWidget *do_widget)
+{
+  GtkWidget *table;
+  GtkWidget *frame;
+  GtkWidget *vbox;
+  GtkWidget *check_button;
+  GtkSizeGroup *size_group;
+
+  static const char *color_options[] = {
+    "Red", "Green", "Blue", NULL
+  };
+  
+  static const char *dash_options[] = {
+    "Solid", "Dashed", "Dotted", NULL
+  };
+  
+  static const char *end_options[] = {
+    "Square", "Round", "Arrow", NULL
+  };
+  
+  if (!window)
+    {
+      window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
+					    GTK_WINDOW (do_widget),
+					    0,
+					    GTK_STOCK_CLOSE,
+					    GTK_RESPONSE_NONE,
+					    NULL);
+      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+      
+      g_signal_connect (window, "response",
+			G_CALLBACK (gtk_widget_destroy), NULL);
+      g_signal_connect (window, "destroy",
+			G_CALLBACK (gtk_widget_destroyed), &window);
+
+      vbox = gtk_vbox_new (FALSE, 5);
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0);
+      gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+      size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+      
+      /* Create one frame holding color options
+       */
+      frame = gtk_frame_new ("Color Options");
+      gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
+
+      table = gtk_table_new (2, 2, FALSE);
+      gtk_container_set_border_width (GTK_CONTAINER (table), 5);
+      gtk_table_set_row_spacings (GTK_TABLE (table), 5);
+      gtk_table_set_col_spacings (GTK_TABLE (table), 10);
+      gtk_container_add (GTK_CONTAINER (frame), table);
+
+      add_row (GTK_TABLE (table), 0, size_group, "_Foreground", color_options);
+      add_row (GTK_TABLE (table), 1, size_group, "_Background", color_options);
+
+      /* And another frame holding line style options
+       */
+      frame = gtk_frame_new ("Line Options");
+      gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+
+      table = gtk_table_new (2, 2, FALSE);
+      gtk_container_set_border_width (GTK_CONTAINER (table), 5);
+      gtk_table_set_row_spacings (GTK_TABLE (table), 5);
+      gtk_table_set_col_spacings (GTK_TABLE (table), 10);
+      gtk_container_add (GTK_CONTAINER (frame), table);
+
+      add_row (GTK_TABLE (table), 0, size_group, "_Dashing", dash_options);
+      add_row (GTK_TABLE (table), 1, size_group, "_Line ends", end_options);
+
+      /* And a check button to turn grouping on and off */
+      check_button = gtk_check_button_new_with_mnemonic ("_Enable grouping");
+      gtk_box_pack_start (GTK_BOX (vbox), check_button, FALSE, FALSE, 0);
+      
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
+      g_signal_connect (check_button, "toggled",
+			G_CALLBACK (toggle_grouping), size_group);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

data/vendor/local/share/gtk-2.0/demo/spinner.c

@@ -0,0 +1,94 @@
+/* Spinner
+ *
+ * GtkSpinner allows to show that background activity is on-going.
+ *
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+static GtkWidget *spinner_sensitive = NULL;
+static GtkWidget *spinner_unsensitive = NULL;
+
+static void
+on_play_clicked (GtkButton *button, gpointer user_data)
+{
+  gtk_spinner_start (GTK_SPINNER (spinner_sensitive));
+  gtk_spinner_start (GTK_SPINNER (spinner_unsensitive));
+}
+
+static void
+on_stop_clicked (GtkButton *button, gpointer user_data)
+{
+  gtk_spinner_stop (GTK_SPINNER (spinner_sensitive));
+  gtk_spinner_stop (GTK_SPINNER (spinner_unsensitive));
+}
+
+GtkWidget *
+do_spinner (GtkWidget *do_widget)
+{
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+  GtkWidget *button;
+  GtkWidget *spinner;
+
+  if (!window)
+  {
+    window = gtk_dialog_new_with_buttons ("GtkSpinner",
+                                          GTK_WINDOW (do_widget),
+                                          0,
+                                          GTK_STOCK_CLOSE,
+                                          GTK_RESPONSE_NONE,
+                                          NULL);
+    gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+    g_signal_connect (window, "response",
+                      G_CALLBACK (gtk_widget_destroy), NULL);
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed), &window);
+
+    vbox = gtk_vbox_new (FALSE, 5);
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+    /* Sensitive */
+    hbox = gtk_hbox_new (FALSE, 5);
+    spinner = gtk_spinner_new ();
+    gtk_container_add (GTK_CONTAINER (hbox), spinner);
+    gtk_container_add (GTK_CONTAINER (hbox), gtk_entry_new ());
+    gtk_container_add (GTK_CONTAINER (vbox), hbox);
+    spinner_sensitive = spinner;
+
+    /* Disabled */
+    hbox = gtk_hbox_new (FALSE, 5);
+    spinner = gtk_spinner_new ();
+    gtk_container_add (GTK_CONTAINER (hbox), spinner);
+    gtk_container_add (GTK_CONTAINER (hbox), gtk_entry_new ());
+    gtk_container_add (GTK_CONTAINER (vbox), hbox);
+    spinner_unsensitive = spinner;
+    gtk_widget_set_sensitive (hbox, FALSE);
+
+    button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
+    g_signal_connect (G_OBJECT (button), "clicked",
+                      G_CALLBACK (on_play_clicked), spinner);
+    gtk_container_add (GTK_CONTAINER (vbox), button);
+
+    button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP);
+    g_signal_connect (G_OBJECT (button), "clicked",
+                      G_CALLBACK (on_stop_clicked), spinner);
+    gtk_container_add (GTK_CONTAINER (vbox), button);
+
+    /* Start by default to test for:
+     * https://bugzilla.gnome.org/show_bug.cgi?id=598496 */
+    on_play_clicked (NULL, NULL);
+  }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}
+
+

data/vendor/local/share/gtk-2.0/demo/stock_browser.c

@@ -0,0 +1,546 @@
+/* Stock Item and Icon Browser
+ *
+ * This source code for this demo doesn't demonstrate anything
+ * particularly useful in applications. The purpose of the "demo" is
+ * just to provide a handy place to browse the available stock icons
+ * and stock items.
+ */
+
+#include <string.h>
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+
+typedef struct _StockItemInfo StockItemInfo;
+struct _StockItemInfo
+{
+  gchar *id;
+  GtkStockItem item;
+  GdkPixbuf *small_icon;
+  gchar *macro;
+  gchar *accel_str;
+};
+
+/* Make StockItemInfo a boxed type so we can automatically
+ * manage memory
+ */
+#define STOCK_ITEM_INFO_TYPE stock_item_info_get_type ()
+
+static void
+stock_item_info_free (StockItemInfo *info)
+{
+  g_free (info->id);
+  g_free (info->macro);
+  g_free (info->accel_str);
+  if (info->small_icon)
+    g_object_unref (info->small_icon);
+  
+  g_free (info);
+}
+
+static StockItemInfo*
+stock_item_info_copy (StockItemInfo *src)
+{
+  StockItemInfo *info;
+
+  info = g_new (StockItemInfo, 1);
+  info->id = g_strdup (src->id);
+  info->macro = g_strdup (src->macro);
+  info->accel_str = g_strdup (src->accel_str);
+  
+  info->item = src->item;
+
+  info->small_icon = src->small_icon;
+  if (info->small_icon)
+    g_object_ref (info->small_icon);
+
+  return info;
+}
+
+static GType
+stock_item_info_get_type (void)
+{
+  static GType our_type = 0;
+  
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("StockItemInfo",
+                                             (GBoxedCopyFunc) stock_item_info_copy,
+                                             (GBoxedFreeFunc) stock_item_info_free);
+
+  return our_type;
+}
+
+typedef struct _StockItemDisplay StockItemDisplay;
+struct _StockItemDisplay
+{
+  GtkWidget *type_label;
+  GtkWidget *macro_label;
+  GtkWidget *id_label;
+  GtkWidget *label_accel_label;
+  GtkWidget *icon_image;
+};
+
+static gchar*
+id_to_macro (const gchar *id)
+{
+  GString *macro = NULL;
+  const gchar *cp;
+
+  /* gtk-foo-bar -> GTK_STOCK_FOO_BAR */
+
+  macro = g_string_new (NULL);
+  
+  cp = id;
+  
+  if (strncmp (cp, "gtk-", 4) == 0)
+    {
+      g_string_append (macro, "GTK_STOCK_");
+      cp += 4;
+    }
+
+  while (*cp)
+    {
+      if (*cp == '-')
+	g_string_append_c (macro, '_');
+      else if (g_ascii_islower (*cp))
+	g_string_append_c (macro, g_ascii_toupper (*cp));
+      else
+	g_string_append_c (macro, *cp);
+
+      cp++;
+    }
+
+  return g_string_free (macro, FALSE);
+}
+
+static GtkTreeModel*
+create_model (void)
+{
+  GtkListStore *store;
+  GSList *ids;
+  GSList *tmp_list;
+  
+  store = gtk_list_store_new (2, STOCK_ITEM_INFO_TYPE, G_TYPE_STRING);
+
+  ids = gtk_stock_list_ids ();
+  ids = g_slist_sort (ids, (GCompareFunc) strcmp);
+  tmp_list = ids;
+  while (tmp_list != NULL)
+    {
+      StockItemInfo info;
+      GtkStockItem item;
+      GtkTreeIter iter;
+      GtkIconSet *icon_set;
+      
+      info.id = tmp_list->data;
+      
+      if (gtk_stock_lookup (info.id, &item))
+        {
+          info.item = item;
+        }
+      else
+        {
+          info.item.label = NULL;
+          info.item.stock_id = NULL;
+          info.item.modifier = 0;
+          info.item.keyval = 0;
+          info.item.translation_domain = NULL;
+        }
+
+      /* only show icons for stock IDs that have default icons */
+      icon_set = gtk_icon_factory_lookup_default (info.id);
+      if (icon_set)
+        {
+          GtkIconSize *sizes = NULL;
+          gint n_sizes = 0;
+          gint i;
+          GtkIconSize size;
+
+          /* See what sizes this stock icon really exists at */
+          gtk_icon_set_get_sizes (icon_set, &sizes, &n_sizes);
+
+          /* Use menu size if it exists, otherwise first size found */
+          size = sizes[0];
+          i = 0;
+          while (i < n_sizes)
+            {
+              if (sizes[i] == GTK_ICON_SIZE_MENU)
+                {
+                  size = GTK_ICON_SIZE_MENU;
+                  break;
+                }
+              ++i;
+            }
+          g_free (sizes);
+          
+          info.small_icon = gtk_widget_render_icon (window, info.id,
+                                                    size,
+                                                    NULL);
+          
+          if (size != GTK_ICON_SIZE_MENU)
+            {
+              /* Make the result the proper size for our thumbnail */
+              gint w, h;
+              GdkPixbuf *scaled;
+              
+              gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
+              
+              scaled = gdk_pixbuf_scale_simple (info.small_icon,
+                                                w, h,
+                                                GDK_INTERP_BILINEAR);
+
+              g_object_unref (info.small_icon);
+              info.small_icon = scaled;
+            }
+        }
+      else
+        info.small_icon = NULL;
+
+      if (info.item.keyval != 0)
+        {
+          info.accel_str = gtk_accelerator_name (info.item.keyval,
+                                                 info.item.modifier);
+        }
+      else
+        {
+          info.accel_str = g_strdup ("");
+        }
+
+      info.macro = id_to_macro (info.id);
+      
+      gtk_list_store_append (store, &iter);
+      gtk_list_store_set (store, &iter, 0, &info, 1, info.id, -1);
+
+      g_free (info.macro);
+      g_free (info.accel_str);
+      if (info.small_icon)
+        g_object_unref (info.small_icon);
+      
+      tmp_list = g_slist_next (tmp_list);
+    }
+  
+  g_slist_foreach (ids, (GFunc)g_free, NULL);
+  g_slist_free (ids);
+
+  return GTK_TREE_MODEL (store);
+}
+
+/* Finds the largest size at which the given image stock id is
+ * available. This would not be useful for a normal application
+ */
+static GtkIconSize
+get_largest_size (const char *id)
+{
+  GtkIconSet *set = gtk_icon_factory_lookup_default (id);
+  GtkIconSize *sizes;
+  gint n_sizes, i;
+  GtkIconSize best_size = GTK_ICON_SIZE_INVALID;
+  gint best_pixels = 0;
+
+  gtk_icon_set_get_sizes (set, &sizes, &n_sizes);
+
+  for (i = 0; i < n_sizes; i++)
+    {
+      gint width, height;
+      
+      gtk_icon_size_lookup (sizes[i], &width, &height);
+
+      if (width * height > best_pixels)
+	{
+	  best_size = sizes[i];
+	  best_pixels = width * height;
+	}
+    }
+  
+  g_free (sizes);
+
+  return best_size;
+}
+
+static void
+selection_changed (GtkTreeSelection *selection)
+{
+  GtkTreeView *treeview;
+  StockItemDisplay *display;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+  
+  treeview = gtk_tree_selection_get_tree_view (selection);
+  display = g_object_get_data (G_OBJECT (treeview), "stock-display");
+
+  if (gtk_tree_selection_get_selected (selection, &model, &iter))
+    {
+      StockItemInfo *info;
+      gchar *str;
+      
+      gtk_tree_model_get (model, &iter,
+                          0, &info,
+                          -1);
+
+      if (info->small_icon && info->item.label)
+        gtk_label_set_text (GTK_LABEL (display->type_label), "Icon and Item");
+      else if (info->small_icon)
+        gtk_label_set_text (GTK_LABEL (display->type_label), "Icon Only");
+      else if (info->item.label)
+        gtk_label_set_text (GTK_LABEL (display->type_label), "Item Only");
+      else
+        gtk_label_set_text (GTK_LABEL (display->type_label), "???????");
+
+      gtk_label_set_text (GTK_LABEL (display->macro_label), info->macro);
+      gtk_label_set_text (GTK_LABEL (display->id_label), info->id);
+
+      if (info->item.label)
+        {
+          str = g_strdup_printf ("%s %s", info->item.label, info->accel_str);
+          gtk_label_set_text_with_mnemonic (GTK_LABEL (display->label_accel_label), str);
+          g_free (str);
+        }
+      else
+        {
+          gtk_label_set_text (GTK_LABEL (display->label_accel_label), "");
+        }
+
+      if (info->small_icon)
+        gtk_image_set_from_stock (GTK_IMAGE (display->icon_image), info->id,
+                                  get_largest_size (info->id));
+      else
+        gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL);
+
+      stock_item_info_free (info);
+    }
+  else
+    {
+      gtk_label_set_text (GTK_LABEL (display->type_label), "No selected item");
+      gtk_label_set_text (GTK_LABEL (display->macro_label), "");
+      gtk_label_set_text (GTK_LABEL (display->id_label), "");
+      gtk_label_set_text (GTK_LABEL (display->label_accel_label), "");
+      gtk_image_set_from_pixbuf (GTK_IMAGE (display->icon_image), NULL);
+    }
+}
+
+static void
+macro_set_func_text (GtkTreeViewColumn *tree_column,
+		     GtkCellRenderer   *cell,
+		     GtkTreeModel      *model,
+		     GtkTreeIter       *iter,
+		     gpointer           data)
+{
+  StockItemInfo *info;
+  
+  gtk_tree_model_get (model, iter,
+                      0, &info,
+                      -1);
+  
+  g_object_set (GTK_CELL_RENDERER (cell),
+                "text", info->macro,
+                NULL);
+  
+  stock_item_info_free (info);
+}
+
+static void
+id_set_func (GtkTreeViewColumn *tree_column,
+             GtkCellRenderer   *cell,
+             GtkTreeModel      *model,
+             GtkTreeIter       *iter,
+             gpointer           data)
+{
+  StockItemInfo *info;
+  
+  gtk_tree_model_get (model, iter,
+                      0, &info,
+                      -1);
+  
+  g_object_set (GTK_CELL_RENDERER (cell),
+                "text", info->id,
+                NULL);
+  
+  stock_item_info_free (info);
+}
+
+static void
+accel_set_func (GtkTreeViewColumn *tree_column,
+                GtkCellRenderer   *cell,
+                GtkTreeModel      *model,
+                GtkTreeIter       *iter,
+                gpointer           data)
+{
+  StockItemInfo *info;
+  
+  gtk_tree_model_get (model, iter,
+                      0, &info,
+                      -1);
+  
+  g_object_set (GTK_CELL_RENDERER (cell),
+                "text", info->accel_str,
+                NULL);
+  
+  stock_item_info_free (info);
+}
+
+static void
+label_set_func (GtkTreeViewColumn *tree_column,
+                GtkCellRenderer   *cell,
+                GtkTreeModel      *model,
+                GtkTreeIter       *iter,
+                gpointer           data)
+{
+  StockItemInfo *info;
+  
+  gtk_tree_model_get (model, iter,
+                      0, &info,
+                      -1);
+  
+  g_object_set (GTK_CELL_RENDERER (cell),
+                "text", info->item.label,
+                NULL);
+  
+  stock_item_info_free (info);
+}
+
+GtkWidget *
+do_stock_browser (GtkWidget *do_widget)
+{  
+  if (!window)
+    {
+      GtkWidget *frame;
+      GtkWidget *vbox;
+      GtkWidget *hbox;
+      GtkWidget *sw;
+      GtkWidget *treeview;
+      GtkWidget *align;
+      GtkTreeModel *model;
+      GtkCellRenderer *cell_renderer;
+      StockItemDisplay *display;
+      GtkTreeSelection *selection;
+      GtkTreeViewColumn *column;
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+			     gtk_widget_get_screen (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Stock Icons and Items");
+      gtk_window_set_default_size (GTK_WINDOW (window), -1, 500);
+
+      g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
+      gtk_container_set_border_width (GTK_CONTAINER (window), 8);
+
+      hbox = gtk_hbox_new (FALSE, 8);
+      gtk_container_add (GTK_CONTAINER (window), hbox);
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                      GTK_POLICY_NEVER,
+                                      GTK_POLICY_AUTOMATIC);
+      gtk_box_pack_start (GTK_BOX (hbox), sw, FALSE, FALSE, 0);
+
+      model = create_model ();
+      
+      treeview = gtk_tree_view_new_with_model (model);
+
+      g_object_unref (model);
+
+      gtk_container_add (GTK_CONTAINER (sw), treeview);
+      
+      column = gtk_tree_view_column_new ();
+      gtk_tree_view_column_set_title (column, "Macro");
+
+      cell_renderer = gtk_cell_renderer_pixbuf_new ();
+      gtk_tree_view_column_pack_start (column,
+				       cell_renderer,
+				       FALSE);
+      gtk_tree_view_column_set_attributes (column, cell_renderer,
+					   "stock_id", 1, NULL);
+      cell_renderer = gtk_cell_renderer_text_new ();
+      gtk_tree_view_column_pack_start (column,
+				       cell_renderer,
+				       TRUE);
+      gtk_tree_view_column_set_cell_data_func (column, cell_renderer,
+					       macro_set_func_text, NULL, NULL);
+
+      gtk_tree_view_append_column (GTK_TREE_VIEW (treeview),
+				   column);
+
+      cell_renderer = gtk_cell_renderer_text_new ();
+      gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
+                                                  -1,
+                                                  "Label",
+                                                  cell_renderer,
+                                                  label_set_func,
+                                                  NULL,
+                                                  NULL);
+
+      cell_renderer = gtk_cell_renderer_text_new ();
+      gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
+                                                  -1,
+                                                  "Accel",
+                                                  cell_renderer,
+                                                  accel_set_func,
+                                                  NULL,
+                                                  NULL);
+
+      cell_renderer = gtk_cell_renderer_text_new ();
+      gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (treeview),
+                                                  -1,
+                                                  "ID",
+                                                  cell_renderer,
+                                                  id_set_func,
+                                                  NULL,
+                                                  NULL);
+      
+      align = gtk_alignment_new (0.5, 0.0, 0.0, 0.0);
+      gtk_box_pack_end (GTK_BOX (hbox), align, FALSE, FALSE, 0);
+      
+      frame = gtk_frame_new ("Selected Item");
+      gtk_container_add (GTK_CONTAINER (align), frame);
+
+      vbox = gtk_vbox_new (FALSE, 8);
+      gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
+      gtk_container_add (GTK_CONTAINER (frame), vbox);
+
+      display = g_new (StockItemDisplay, 1);
+      g_object_set_data_full (G_OBJECT (treeview),
+                              "stock-display",
+                              display,
+                              g_free); /* free display with treeview */
+      
+      display->type_label = gtk_label_new (NULL);
+      display->macro_label = gtk_label_new (NULL);
+      display->id_label = gtk_label_new (NULL);
+      display->label_accel_label = gtk_label_new (NULL);
+      display->icon_image = gtk_image_new_from_pixbuf (NULL); /* empty image */
+
+      gtk_box_pack_start (GTK_BOX (vbox), display->type_label,
+                          FALSE, FALSE, 0);
+
+      gtk_box_pack_start (GTK_BOX (vbox), display->icon_image,
+                          FALSE, FALSE, 0);
+      
+      gtk_box_pack_start (GTK_BOX (vbox), display->label_accel_label,
+                          FALSE, FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (vbox), display->macro_label,
+                          FALSE, FALSE, 0);
+      gtk_box_pack_start (GTK_BOX (vbox), display->id_label,
+                          FALSE, FALSE, 0);
+
+      selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
+      gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
+      
+      g_signal_connect (selection,
+			"changed",
+			G_CALLBACK (selection_changed),
+			NULL);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    {
+      gtk_widget_show_all (window);
+    }
+  else
+    {	 
+      gtk_widget_destroy (window);
+      window = NULL;
+    }
+
+  return window;
+}