gtk3 1.2.0-x86-mingw32

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

@@ -0,0 +1,212 @@
+/* Printing
+ *
+ * GtkPrintOperation offers a simple API to support printing
+ * in a cross-platform way.
+ *
+ */
+
+#include <math.h>
+#include <gtk/gtk.h>
+#include "demo-common.h"
+
+/* In points */
+#define HEADER_HEIGHT (10*72/25.4)
+#define HEADER_GAP (3*72/25.4)
+
+typedef struct
+{
+  gchar *filename;
+  gdouble font_size;
+
+  gint lines_per_page;
+  gchar **lines;
+  gint num_lines;
+  gint num_pages;
+} PrintData;
+
+static void
+begin_print (GtkPrintOperation *operation,
+	     GtkPrintContext   *context,
+	     gpointer           user_data)
+{
+  PrintData *data = (PrintData *)user_data;
+  char *contents;
+  int i;
+  double height;
+
+  height = gtk_print_context_get_height (context) - HEADER_HEIGHT - HEADER_GAP;
+
+  data->lines_per_page = floor (height / data->font_size);
+
+  g_file_get_contents (data->filename, &contents, NULL, NULL);
+
+  data->lines = g_strsplit (contents, "\n", 0);
+  g_free (contents);
+
+  i = 0;
+  while (data->lines[i] != NULL)
+    i++;
+
+  data->num_lines = i;
+  data->num_pages = (data->num_lines - 1) / data->lines_per_page + 1;
+
+  gtk_print_operation_set_n_pages (operation, data->num_pages);
+}
+
+static void
+draw_page (GtkPrintOperation *operation,
+	   GtkPrintContext   *context,
+	   gint               page_nr,
+	   gpointer           user_data)
+{
+  PrintData *data = (PrintData *)user_data;
+  cairo_t *cr;
+  PangoLayout *layout;
+  gint text_width, text_height;
+  gdouble width;
+  gint line, i;
+  PangoFontDescription *desc;
+  gchar *page_str;
+
+  cr = gtk_print_context_get_cairo_context (context);
+  width = gtk_print_context_get_width (context);
+
+  cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT);
+
+  cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
+  cairo_fill_preserve (cr);
+
+  cairo_set_source_rgb (cr, 0, 0, 0);
+  cairo_set_line_width (cr, 1);
+  cairo_stroke (cr);
+
+  layout = gtk_print_context_create_pango_layout (context);
+
+  desc = pango_font_description_from_string ("sans 14");
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  pango_layout_set_text (layout, data->filename, -1);
+  pango_layout_get_pixel_size (layout, &text_width, &text_height);
+
+  if (text_width > width)
+    {
+      pango_layout_set_width (layout, width);
+      pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_START);
+      pango_layout_get_pixel_size (layout, &text_width, &text_height);
+    }
+
+  cairo_move_to (cr, (width - text_width) / 2,  (HEADER_HEIGHT - text_height) / 2);
+  pango_cairo_show_layout (cr, layout);
+
+  page_str = g_strdup_printf ("%d/%d", page_nr + 1, data->num_pages);
+  pango_layout_set_text (layout, page_str, -1);
+  g_free (page_str);
+
+  pango_layout_set_width (layout, -1);
+  pango_layout_get_pixel_size (layout, &text_width, &text_height);
+  cairo_move_to (cr, width - text_width - 4, (HEADER_HEIGHT - text_height) / 2);
+  pango_cairo_show_layout (cr, layout);
+
+  g_object_unref (layout);
+
+  layout = gtk_print_context_create_pango_layout (context);
+
+  desc = pango_font_description_from_string ("monospace");
+  pango_font_description_set_size (desc, data->font_size * PANGO_SCALE);
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  cairo_move_to (cr, 0, HEADER_HEIGHT + HEADER_GAP);
+  line = page_nr * data->lines_per_page;
+  for (i = 0; i < data->lines_per_page && line < data->num_lines; i++)
+    {
+      pango_layout_set_text (layout, data->lines[line], -1);
+      pango_cairo_show_layout (cr, layout);
+      cairo_rel_move_to (cr, 0, data->font_size);
+      line++;
+    }
+
+  g_object_unref (layout);
+}
+
+static void
+end_print (GtkPrintOperation *operation,
+	   GtkPrintContext   *context,
+	   gpointer           user_data)
+{
+  PrintData *data = (PrintData *)user_data;
+
+  g_free (data->filename);
+  g_strfreev (data->lines);
+  g_free (data);
+}
+
+
+GtkWidget *
+do_printing (GtkWidget *do_widget)
+{
+  GtkPrintOperation *operation;
+  GtkPrintSettings *settings;
+  PrintData *data;
+  gchar *uri, *ext;
+  const gchar *dir;
+  GError *error = NULL;
+
+  operation = gtk_print_operation_new ();
+  data = g_new0 (PrintData, 1);
+  data->filename = demo_find_file ("printing.c", NULL);
+  data->font_size = 12.0;
+
+  g_signal_connect (G_OBJECT (operation), "begin-print",
+		    G_CALLBACK (begin_print), data);
+  g_signal_connect (G_OBJECT (operation), "draw-page",
+		    G_CALLBACK (draw_page), data);
+  g_signal_connect (G_OBJECT (operation), "end-print",
+		    G_CALLBACK (end_print), data);
+
+  gtk_print_operation_set_use_full_page (operation, FALSE);
+  gtk_print_operation_set_unit (operation, GTK_UNIT_POINTS);
+  gtk_print_operation_set_embed_page_setup (operation, TRUE);
+
+  settings = gtk_print_settings_new ();
+  dir = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
+  if (dir == NULL)
+    dir = g_get_home_dir ();
+  if (g_strcmp0 (gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT), "ps") == 0)
+    ext = ".ps";
+  else if (g_strcmp0 (gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT), "svg") == 0)
+    ext = ".svg";
+  else
+    ext = ".pdf";
+
+  uri = g_strconcat ("file://", dir, "/", "gtk-demo", ext, NULL);
+  gtk_print_settings_set (settings, GTK_PRINT_SETTINGS_OUTPUT_URI, uri);
+  gtk_print_operation_set_print_settings (operation, settings);
+
+  gtk_print_operation_run (operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW (do_widget), &error);
+
+  g_object_unref (operation);
+  g_object_unref (settings);
+  g_free (uri);
+
+  if (error)
+    {
+      GtkWidget *dialog;
+
+      dialog = gtk_message_dialog_new (GTK_WINDOW (do_widget),
+				       GTK_DIALOG_DESTROY_WITH_PARENT,
+				       GTK_MESSAGE_ERROR,
+				       GTK_BUTTONS_CLOSE,
+				       "%s", error->message);
+      g_error_free (error);
+
+      g_signal_connect (dialog, "response",
+			G_CALLBACK (gtk_widget_destroy), NULL);
+
+      gtk_widget_show (dialog);
+    }
+
+
+  return NULL;
+}

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

@@ -0,0 +1,237 @@
+/* Rotated Text
+ *
+ * This demo shows how to use PangoCairo to draw rotated and transformed
+ * text.  The right pane shows a rotated GtkLabel widget.
+ *
+ * In both cases, a custom PangoCairo shape renderer is installed to draw
+ * a red heard using cairo drawing operations instead of the Unicode heart
+ * character.
+ */
+
+#include <gtk/gtk.h>
+#include <string.h>
+
+static GtkWidget *window = NULL;
+
+#define HEART "♥"
+const char text[] = "I ♥ GTK+";
+
+static void
+fancy_shape_renderer (cairo_t        *cr,
+		      PangoAttrShape *attr,
+		      gboolean        do_path,
+		      gpointer        data)
+{
+  double x, y;
+  cairo_get_current_point (cr, &x, &y);
+  cairo_translate (cr, x, y);
+
+  cairo_scale (cr,
+	       (double) attr->ink_rect.width  / PANGO_SCALE,
+	       (double) attr->ink_rect.height / PANGO_SCALE);
+
+  switch (GPOINTER_TO_UINT (attr->data))
+    {
+    case 0x2665: /* U+2665 BLACK HEART SUIT */
+      {
+        cairo_move_to (cr, .5, .0);
+        cairo_line_to (cr, .9, -.4);
+	cairo_curve_to (cr, 1.1, -.8, .5, -.9, .5, -.5);
+	cairo_curve_to (cr, .5, -.9, -.1, -.8, .1, -.4);
+	cairo_close_path (cr);
+      }
+      break;
+    }
+
+  if (!do_path) {
+    cairo_set_source_rgb (cr, 1., 0., 0.);
+    cairo_fill (cr);
+  }
+}
+
+PangoAttrList *
+create_fancy_attr_list_for_layout (PangoLayout *layout)
+{
+  PangoAttrList *attrs;
+  PangoFontMetrics *metrics;
+  int ascent;
+  PangoRectangle ink_rect, logical_rect;
+  const char *p;
+
+  /* Get font metrics and prepare fancy shape size */
+  metrics = pango_context_get_metrics (pango_layout_get_context (layout),
+				       pango_layout_get_font_description (layout),
+				       NULL);
+  ascent = pango_font_metrics_get_ascent (metrics);
+  logical_rect.x = 0;
+  logical_rect.width = ascent;
+  logical_rect.y = -ascent;
+  logical_rect.height = ascent;
+  ink_rect = logical_rect;
+  pango_font_metrics_unref (metrics);
+
+  /* Set fancy shape attributes for all hearts */
+  attrs = pango_attr_list_new ();
+  for (p = text; (p = strstr (p, HEART)); p += strlen (HEART))
+    {
+      PangoAttribute *attr;
+      
+      attr = pango_attr_shape_new_with_data (&ink_rect,
+					     &logical_rect,
+					     GUINT_TO_POINTER (g_utf8_get_char (p)),
+					     NULL, NULL);
+
+      attr->start_index = p - text;
+      attr->end_index = attr->start_index + strlen (HEART);
+
+      pango_attr_list_insert (attrs, attr);
+    }
+
+  return attrs;
+}
+
+static gboolean
+rotated_text_expose_event (GtkWidget      *widget,
+			   GdkEventExpose *event,
+			   gpointer	   data)
+{
+#define RADIUS 150
+#define N_WORDS 5
+#define FONT "Serif 18"
+
+  PangoContext *context;
+  PangoLayout *layout;
+  PangoFontDescription *desc;
+
+  cairo_t *cr;
+  cairo_pattern_t *pattern;
+
+  PangoAttrList *attrs;
+
+  int width = widget->allocation.width;
+  int height = widget->allocation.height;
+  double device_radius;
+  int i;
+
+  /* Create a cairo context and set up a transformation matrix so that the user
+   * space coordinates for the centered square where we draw are [-RADIUS, RADIUS],
+   * [-RADIUS, RADIUS].
+   * We first center, then change the scale. */
+  cr = gdk_cairo_create (widget->window);
+  device_radius = MIN (width, height) / 2.;
+  cairo_translate (cr,
+		   device_radius + (width - 2 * device_radius) / 2,
+		   device_radius + (height - 2 * device_radius) / 2);
+  cairo_scale (cr, device_radius / RADIUS, device_radius / RADIUS);
+
+  /* Create and a subtle gradient source and use it. */
+  pattern = cairo_pattern_create_linear (-RADIUS, -RADIUS, RADIUS, RADIUS);
+  cairo_pattern_add_color_stop_rgb (pattern, 0., .5, .0, .0);
+  cairo_pattern_add_color_stop_rgb (pattern, 1., .0, .0, .5);
+  cairo_set_source (cr, pattern);
+
+  /* Create a PangoContext and set up our shape renderer */
+  context = gtk_widget_create_pango_context (widget);
+  pango_cairo_context_set_shape_renderer (context,
+					  fancy_shape_renderer,
+					  NULL, NULL);
+
+  /* Create a PangoLayout, set the text, font, and attributes */
+  layout = pango_layout_new (context);
+  pango_layout_set_text (layout, text, -1);
+  desc = pango_font_description_from_string (FONT);
+  pango_layout_set_font_description (layout, desc);
+
+  attrs = create_fancy_attr_list_for_layout (layout);
+  pango_layout_set_attributes (layout, attrs);
+  pango_attr_list_unref (attrs);
+
+  /* Draw the layout N_WORDS times in a circle */
+  for (i = 0; i < N_WORDS; i++)
+    {
+      int width, height;
+
+      /* Inform Pango to re-layout the text with the new transformation matrix */
+      pango_cairo_update_layout (cr, layout);
+    
+      pango_layout_get_pixel_size (layout, &width, &height);
+      cairo_move_to (cr, - width / 2, - RADIUS * .9);
+      pango_cairo_show_layout (cr, layout);
+
+      /* Rotate for the next turn */
+      cairo_rotate (cr, G_PI*2 / N_WORDS);
+    }
+
+  /* free the objects we created */
+  pango_font_description_free (desc);
+  g_object_unref (layout);
+  g_object_unref (context);
+  cairo_pattern_destroy (pattern);
+  cairo_destroy (cr);
+  
+  return FALSE;
+}
+
+GtkWidget *
+do_rotated_text (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkWidget *box;
+      GtkWidget *drawing_area;
+      GtkWidget *label;
+      PangoLayout *layout;
+      PangoAttrList *attrs;
+
+      const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
+      
+      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), "Rotated Text");
+      gtk_window_set_default_size (GTK_WINDOW (window), 4 * RADIUS, 2 * RADIUS);
+      g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
+
+      box = gtk_hbox_new (TRUE, 0);
+      gtk_container_add (GTK_CONTAINER (window), box);
+
+      /* Add a drawing area */
+
+      drawing_area = gtk_drawing_area_new ();
+      gtk_container_add (GTK_CONTAINER (box), drawing_area);
+
+      /* This overrides the background color from the theme */
+      gtk_widget_modify_bg (drawing_area, GTK_STATE_NORMAL, &white);
+
+      g_signal_connect (drawing_area, "expose-event",
+			G_CALLBACK (rotated_text_expose_event), NULL);
+
+      /* And a label */
+
+      label = gtk_label_new (text);
+      gtk_container_add (GTK_CONTAINER (box), label);
+
+      gtk_label_set_angle (GTK_LABEL (label), 45);
+
+      /* Set up fancy stuff on the label */
+      layout = gtk_label_get_layout (GTK_LABEL (label));
+      pango_cairo_context_set_shape_renderer (pango_layout_get_context (layout),
+					      fancy_shape_renderer,
+					      NULL, NULL);
+      attrs = create_fancy_attr_list_for_layout (layout);
+      gtk_label_set_attributes (GTK_LABEL (label), attrs);
+      pango_attr_list_unref (attrs);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    {
+      gtk_widget_show_all (window);
+    }
+  else
+    {
+      gtk_widget_destroy (window);
+      window = NULL;
+    }
+
+  return window;
+}

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

@@ -0,0 +1,335 @@
+/* Entry/Search Entry
+ *
+ * GtkEntry allows to display icons and progress information.
+ * This demo shows how to use these features in a search entry.
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+static GtkWidget *menu = NULL;
+static GtkWidget *notebook = NULL;
+
+static guint search_progress_id = 0;
+static guint finish_search_id = 0;
+
+static void
+show_find_button (void)
+{
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 0);
+}
+
+static void
+show_cancel_button (void)
+{
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 1);
+}
+
+static gboolean
+search_progress (gpointer data)
+{
+  gtk_entry_progress_pulse (GTK_ENTRY (data));
+
+  return TRUE;
+}
+
+static void
+search_progress_done (GtkEntry *entry)
+{
+  gtk_entry_set_progress_fraction (entry, 0.0);
+}
+
+static gboolean
+finish_search (GtkButton *button)
+{
+  show_find_button ();
+  g_source_remove (search_progress_id);
+  search_progress_id = 0;
+
+  return FALSE;
+}
+
+static gboolean
+start_search_feedback (gpointer data)
+{
+  search_progress_id = g_timeout_add_full (G_PRIORITY_DEFAULT, 100,
+                                           (GSourceFunc)search_progress, data,
+                                           (GDestroyNotify)search_progress_done);
+  return FALSE;
+}
+
+static void
+start_search (GtkButton *button,
+              GtkEntry  *entry)
+{
+  show_cancel_button ();
+  search_progress_id = g_timeout_add_seconds (1, (GSourceFunc)start_search_feedback, entry);
+  finish_search_id = g_timeout_add_seconds (15, (GSourceFunc)finish_search, button);
+}
+
+
+static void
+stop_search (GtkButton *button,
+             gpointer   data)
+{
+  g_source_remove (finish_search_id);
+  finish_search (button);
+}
+
+static void
+clear_entry (GtkEntry *entry)
+{
+  gtk_entry_set_text (entry, "");
+}
+
+static void
+search_by_name (GtkWidget *item,
+                GtkEntry  *entry)
+{
+  gtk_entry_set_icon_from_stock (entry,
+                                 GTK_ENTRY_ICON_PRIMARY,
+                                 GTK_STOCK_FIND);
+  gtk_entry_set_icon_tooltip_text (entry,
+                                   GTK_ENTRY_ICON_PRIMARY,
+                                   "Search by name\n"
+                                   "Click here to change the search type");
+}
+
+static void
+search_by_description (GtkWidget *item,
+                       GtkEntry  *entry)
+{
+  gtk_entry_set_icon_from_stock (entry,
+                                 GTK_ENTRY_ICON_PRIMARY,
+                                 GTK_STOCK_EDIT);
+  gtk_entry_set_icon_tooltip_text (entry,
+                                   GTK_ENTRY_ICON_PRIMARY,
+                                   "Search by description\n"
+                                   "Click here to change the search type");
+}
+
+static void
+search_by_file (GtkWidget *item,
+                GtkEntry  *entry)
+{
+  gtk_entry_set_icon_from_stock (entry,
+                                 GTK_ENTRY_ICON_PRIMARY,
+                                 GTK_STOCK_OPEN);
+  gtk_entry_set_icon_tooltip_text (entry,
+                                   GTK_ENTRY_ICON_PRIMARY,
+                                   "Search by file name\n"
+                                   "Click here to change the search type");
+}
+
+GtkWidget *
+create_search_menu (GtkWidget *entry)
+{
+  GtkWidget *menu;
+  GtkWidget *item;
+  GtkWidget *image;
+
+  menu = gtk_menu_new ();
+
+  item = gtk_image_menu_item_new_with_mnemonic ("Search by _name");
+  image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
+  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
+  gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
+  g_signal_connect (item, "activate",
+                    G_CALLBACK (search_by_name), entry);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+
+  item = gtk_image_menu_item_new_with_mnemonic ("Search by _description");
+  image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
+  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
+  gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
+  g_signal_connect (item, "activate",
+                    G_CALLBACK (search_by_description), entry);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+
+  item = gtk_image_menu_item_new_with_mnemonic ("Search by _file name");
+  image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
+  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
+  gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), TRUE);
+  g_signal_connect (item, "activate",
+                    G_CALLBACK (search_by_file), entry);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+
+  gtk_widget_show_all (menu);
+
+  return menu;
+}
+
+static void
+icon_press_cb (GtkEntry       *entry,
+               gint            position,
+               GdkEventButton *event,
+               gpointer        data)
+{
+  if (position == GTK_ENTRY_ICON_PRIMARY)
+    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
+                    event->button, event->time);
+  else
+    clear_entry (entry);
+}
+
+static void
+text_changed_cb (GtkEntry   *entry,
+                 GParamSpec *pspec,
+                 GtkWidget  *button)
+{
+  gboolean has_text;
+
+  has_text = gtk_entry_get_text_length (entry) > 0;
+  gtk_entry_set_icon_sensitive (entry,
+                                GTK_ENTRY_ICON_SECONDARY,
+                                has_text);
+  gtk_widget_set_sensitive (button, has_text);
+}
+
+static void
+activate_cb (GtkEntry  *entry,
+             GtkButton *button)
+{
+  if (search_progress_id != 0)
+    return;
+
+  start_search (button, entry);
+
+}
+
+static void
+search_entry_destroyed (GtkWidget  *widget)
+{
+  if (finish_search_id != 0)
+    g_source_remove (finish_search_id);
+
+  if (search_progress_id != 0)
+    g_source_remove (search_progress_id);
+
+  window = NULL;
+}
+
+static void
+entry_populate_popup (GtkEntry *entry,
+                      GtkMenu  *menu,
+                      gpointer user_data)
+{
+  GtkWidget *item;
+  GtkWidget *search_menu;
+  gboolean has_text;
+
+  has_text = gtk_entry_get_text_length (entry) > 0;
+
+  item = gtk_separator_menu_item_new ();
+  gtk_widget_show (item);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+
+  item = gtk_menu_item_new_with_mnemonic ("C_lear");
+  gtk_widget_show (item);
+  g_signal_connect_swapped (item, "activate",
+                            G_CALLBACK (clear_entry), entry);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+  gtk_widget_set_sensitive (item, has_text);
+
+  search_menu = create_search_menu (GTK_WIDGET (entry));
+  item = gtk_menu_item_new_with_label ("Search by");
+  gtk_widget_show (item);
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), search_menu);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+}
+
+GtkWidget *
+do_search_entry (GtkWidget *do_widget)
+{
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+  GtkWidget *label;
+  GtkWidget *entry;
+  GtkWidget *find_button;
+  GtkWidget *cancel_button;
+
+  if (!window)
+    {
+      window = gtk_dialog_new_with_buttons ("Search Entry",
+                                            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 (search_entry_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);
+
+      label = gtk_label_new (NULL);
+      gtk_label_set_markup (GTK_LABEL (label), "Search entry demo");
+      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+      hbox = gtk_hbox_new (FALSE, 10);
+      gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+      gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
+
+      /* Create our entry */
+      entry = gtk_entry_new ();
+      gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
+
+      /* Create the find and cancel buttons */
+      notebook = gtk_notebook_new ();
+      gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
+      gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
+      gtk_box_pack_start (GTK_BOX (hbox), notebook, FALSE, FALSE, 0);
+
+      find_button = gtk_button_new_with_label ("Find");
+      g_signal_connect (find_button, "clicked",
+                        G_CALLBACK (start_search), entry);
+      gtk_notebook_append_page (GTK_NOTEBOOK (notebook), find_button, NULL);
+      gtk_widget_show (find_button);
+
+      cancel_button = gtk_button_new_with_label ("Cancel");
+      g_signal_connect (cancel_button, "clicked",
+                        G_CALLBACK (stop_search), NULL);
+      gtk_notebook_append_page (GTK_NOTEBOOK (notebook), cancel_button, NULL);
+      gtk_widget_show (cancel_button);
+
+      /* Set up the search icon */
+      search_by_name (NULL, GTK_ENTRY (entry));
+
+      /* Set up the clear icon */
+      gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
+                                     GTK_ENTRY_ICON_SECONDARY,
+                                     GTK_STOCK_CLEAR);
+      text_changed_cb (GTK_ENTRY (entry), NULL, find_button);
+
+      g_signal_connect (entry, "icon-press",
+                        G_CALLBACK (icon_press_cb), NULL);
+      g_signal_connect (entry, "notify::text",
+                        G_CALLBACK (text_changed_cb), find_button);
+      g_signal_connect (entry, "activate",
+                        G_CALLBACK (activate_cb), NULL);
+
+      /* Create the menu */
+      menu = create_search_menu (entry);
+      gtk_menu_attach_to_widget (GTK_MENU (menu), entry, NULL);
+
+      /* add accessible alternatives for icon functionality */
+      g_signal_connect (entry, "populate-popup",
+                        G_CALLBACK (entry_populate_popup), NULL);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show_all (window);
+  else
+    {
+      gtk_widget_destroy (menu);
+      gtk_widget_destroy (window);
+      window = NULL;
+    }
+
+  return window;
+}