gdk3 1.2.0-x86-mingw32

data/vendor/local/share/gtk-3.0/demo/assistant.c

@@ -0,0 +1,201 @@
+/* Assistant
+ *
+ * Demonstrates a sample multi-step assistant. Assistants are used to divide
+ * an operation into several simpler sequential steps, and to guide the user
+ * through these steps.
+ */
+
+#include <gtk/gtk.h>
+#include "demo-common.h"
+
+static GtkWidget *assistant = NULL;
+static GtkWidget *progress_bar = NULL;
+
+static gboolean
+apply_changes_gradually (gpointer data)
+{
+  gdouble fraction;
+
+  /* Work, work, work... */
+  fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (progress_bar));
+  fraction += 0.05;
+
+  if (fraction < 1.0)
+    {
+      gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), fraction);
+      return G_SOURCE_CONTINUE;
+    }
+  else
+    {
+      /* Close automatically once changes are fully applied. */
+      gtk_widget_destroy (assistant);
+      assistant = NULL;
+      return G_SOURCE_REMOVE;
+    }
+}
+
+static void
+on_assistant_apply (GtkWidget *widget, gpointer data)
+{
+  /* Start a timer to simulate changes taking a few seconds to apply. */
+  g_timeout_add (100, apply_changes_gradually, NULL);
+}
+
+static void
+on_assistant_close_cancel (GtkWidget *widget, gpointer data)
+{
+  GtkWidget **assistant = (GtkWidget **) data;
+
+  gtk_widget_destroy (*assistant);
+  *assistant = NULL;
+}
+
+static void
+on_assistant_prepare (GtkWidget *widget, GtkWidget *page, gpointer data)
+{
+  gint current_page, n_pages;
+  gchar *title;
+
+  current_page = gtk_assistant_get_current_page (GTK_ASSISTANT (widget));
+  n_pages = gtk_assistant_get_n_pages (GTK_ASSISTANT (widget));
+
+  title = g_strdup_printf ("Sample assistant (%d of %d)", current_page + 1, n_pages);
+  gtk_window_set_title (GTK_WINDOW (widget), title);
+  g_free (title);
+
+  /* The fourth page (counting from zero) is the progress page.  The
+  * user clicked Apply to get here so we tell the assistant to commit,
+  * which means the changes up to this point are permanent and cannot
+  * be cancelled or revisited. */
+  if (current_page == 3)
+      gtk_assistant_commit (GTK_ASSISTANT (widget));
+}
+
+static void
+on_entry_changed (GtkWidget *widget, gpointer data)
+{
+  GtkAssistant *assistant = GTK_ASSISTANT (data);
+  GtkWidget *current_page;
+  gint page_number;
+  const gchar *text;
+
+  page_number = gtk_assistant_get_current_page (assistant);
+  current_page = gtk_assistant_get_nth_page (assistant, page_number);
+  text = gtk_entry_get_text (GTK_ENTRY (widget));
+
+  if (text && *text)
+    gtk_assistant_set_page_complete (assistant, current_page, TRUE);
+  else
+    gtk_assistant_set_page_complete (assistant, current_page, FALSE);
+}
+
+static void
+create_page1 (GtkWidget *assistant)
+{
+  GtkWidget *box, *label, *entry;
+
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+  gtk_container_set_border_width (GTK_CONTAINER (box), 12);
+
+  label = gtk_label_new ("You must fill out this entry to continue:");
+  gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
+
+  entry = gtk_entry_new ();
+  gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
+  gtk_box_pack_start (GTK_BOX (box), entry, TRUE, TRUE, 0);
+  g_signal_connect (G_OBJECT (entry), "changed",
+                    G_CALLBACK (on_entry_changed), assistant);
+
+  gtk_widget_show_all (box);
+  gtk_assistant_append_page (GTK_ASSISTANT (assistant), box);
+  gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), box, "Page 1");
+  gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), box, GTK_ASSISTANT_PAGE_INTRO);
+}
+
+static void
+create_page2 (GtkWidget *assistant)
+{
+  GtkWidget *box, *checkbutton;
+
+  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+  gtk_container_set_border_width (GTK_CONTAINER (box), 12);
+
+  checkbutton = gtk_check_button_new_with_label ("This is optional data, you may continue "
+                                                 "even if you do not check this");
+  gtk_box_pack_start (GTK_BOX (box), checkbutton, FALSE, FALSE, 0);
+
+  gtk_widget_show_all (box);
+  gtk_assistant_append_page (GTK_ASSISTANT (assistant), box);
+  gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), box, TRUE);
+  gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), box, "Page 2");
+}
+
+static void
+create_page3 (GtkWidget *assistant)
+{
+  GtkWidget *label;
+
+  label = gtk_label_new ("This is a confirmation page, press 'Apply' to apply changes");
+
+  gtk_widget_show (label);
+  gtk_assistant_append_page (GTK_ASSISTANT (assistant), label);
+  gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label, GTK_ASSISTANT_PAGE_CONFIRM);
+  gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label, TRUE);
+  gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label, "Confirmation");
+}
+
+static void
+create_page4 (GtkWidget *assistant)
+{
+  progress_bar = gtk_progress_bar_new ();
+  gtk_widget_set_halign (progress_bar, GTK_ALIGN_CENTER);
+  gtk_widget_set_valign (progress_bar, GTK_ALIGN_CENTER);
+
+  gtk_widget_show (progress_bar);
+  gtk_assistant_append_page (GTK_ASSISTANT (assistant), progress_bar);
+  gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), progress_bar, GTK_ASSISTANT_PAGE_PROGRESS);
+  gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), progress_bar, "Applying changes");
+
+  /* This prevents the assistant window from being
+   * closed while we're "busy" applying changes.
+   */
+  gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), progress_bar, FALSE);
+}
+
+GtkWidget*
+do_assistant (GtkWidget *do_widget)
+{
+  if (!assistant)
+    {
+      assistant = gtk_assistant_new ();
+
+         gtk_window_set_default_size (GTK_WINDOW (assistant), -1, 300);
+
+      gtk_window_set_screen (GTK_WINDOW (assistant),
+                             gtk_widget_get_screen (do_widget));
+
+      create_page1 (assistant);
+      create_page2 (assistant);
+      create_page3 (assistant);
+      create_page4 (assistant);
+
+      g_signal_connect (G_OBJECT (assistant), "cancel",
+                        G_CALLBACK (on_assistant_close_cancel), &assistant);
+      g_signal_connect (G_OBJECT (assistant), "close",
+                        G_CALLBACK (on_assistant_close_cancel), &assistant);
+      g_signal_connect (G_OBJECT (assistant), "apply",
+                        G_CALLBACK (on_assistant_apply), NULL);
+      g_signal_connect (G_OBJECT (assistant), "prepare",
+                        G_CALLBACK (on_assistant_prepare), NULL);
+    }
+
+  if (!gtk_widget_get_visible (assistant))
+    gtk_widget_show (assistant);
+  else
+    {
+      gtk_widget_destroy (assistant);
+      assistant = NULL;
+    }
+
+  return assistant;
+}

data/vendor/local/share/gtk-3.0/demo/builder.c

@@ -0,0 +1,74 @@
+/* Builder :: demo.ui
+ *
+ * Demonstrates an interface loaded from a XML description.
+ */
+
+#include <gtk/gtk.h>
+#include "demo-common.h"
+
+static GtkBuilder *builder;
+
+G_MODULE_EXPORT void
+quit_activate (GtkAction *action)
+{
+  GtkWidget *window;
+
+  window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
+  gtk_widget_destroy (window);
+}
+
+G_MODULE_EXPORT void
+about_activate (GtkAction *action)
+{
+  GtkWidget *about_dlg;
+
+  about_dlg = GTK_WIDGET (gtk_builder_get_object (builder, "aboutdialog1"));
+  gtk_dialog_run (GTK_DIALOG (about_dlg));
+  gtk_widget_hide (about_dlg);
+}
+
+G_MODULE_EXPORT void
+help_activate (GtkAction *action)
+{
+  g_print ("Help not available\n");
+}
+
+GtkWidget *
+do_builder (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+  GError *err = NULL;
+  gchar *filename;
+
+  if (!window)
+    {
+      builder = gtk_builder_new ();
+      filename = demo_find_file ("demo.ui", NULL);
+      gtk_builder_add_from_file (builder, filename, &err);
+      g_free (filename);
+      if (err)
+        {
+          g_error ("ERROR: %s\n", err->message);
+          return NULL;
+        }
+      gtk_builder_connect_signals (builder, NULL);
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
+      gtk_window_set_screen (GTK_WINDOW (window),
+                             gtk_widget_get_screen (do_widget));
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+    }
+
+  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-3.0/demo/button_box.c

@@ -0,0 +1,127 @@
+/* Button Boxes
+ *
+ * The Button Box widgets are used to arrange buttons with padding.
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *
+create_bbox (gint  horizontal,
+             char *title,
+             gint  spacing,
+             gint  layout)
+{
+  GtkWidget *frame;
+  GtkWidget *bbox;
+  GtkWidget *button;
+
+  frame = gtk_frame_new (title);
+
+  if (horizontal)
+    bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
+  else
+    bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
+
+  gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
+  gtk_container_add (GTK_CONTAINER (frame), bbox);
+
+  gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
+  gtk_box_set_spacing (GTK_BOX (bbox), spacing);
+
+  button = gtk_button_new_from_stock (GTK_STOCK_OK);
+  gtk_container_add (GTK_CONTAINER (bbox), button);
+
+  button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
+  gtk_container_add (GTK_CONTAINER (bbox), button);
+
+  button = gtk_button_new_from_stock (GTK_STOCK_HELP);
+  gtk_container_add (GTK_CONTAINER (bbox), button);
+
+  return frame;
+}
+
+GtkWidget *
+do_button_box (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+  GtkWidget *main_vbox;
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+  GtkWidget *frame_horz;
+  GtkWidget *frame_vert;
+
+  if (!window)
+  {
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_screen (GTK_WINDOW (window),
+                           gtk_widget_get_screen (do_widget));
+    gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
+
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed),
+                      &window);
+
+    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+    main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+    gtk_container_add (GTK_CONTAINER (window), main_vbox);
+
+    frame_horz = gtk_frame_new ("Horizontal Button Boxes");
+    gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
+
+    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
+    gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
+
+    gtk_box_pack_start (GTK_BOX (vbox),
+                        create_bbox (TRUE, "Spread", 40, GTK_BUTTONBOX_SPREAD),
+                        TRUE, TRUE, 0);
+
+    gtk_box_pack_start (GTK_BOX (vbox),
+                        create_bbox (TRUE, "Edge", 40, GTK_BUTTONBOX_EDGE),
+                        TRUE, TRUE, 5);
+
+    gtk_box_pack_start (GTK_BOX (vbox),
+                        create_bbox (TRUE, "Start", 40, GTK_BUTTONBOX_START),
+                        TRUE, TRUE, 5);
+
+    gtk_box_pack_start (GTK_BOX (vbox),
+                        create_bbox (TRUE, "End", 40, GTK_BUTTONBOX_END),
+                        TRUE, TRUE, 5);
+
+    frame_vert = gtk_frame_new ("Vertical Button Boxes");
+    gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
+
+    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
+    gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
+
+    gtk_box_pack_start (GTK_BOX (hbox),
+                        create_bbox (FALSE, "Spread", 30, GTK_BUTTONBOX_SPREAD),
+                        TRUE, TRUE, 0);
+
+    gtk_box_pack_start (GTK_BOX (hbox),
+                        create_bbox (FALSE, "Edge", 30, GTK_BUTTONBOX_EDGE),
+                        TRUE, TRUE, 5);
+
+    gtk_box_pack_start (GTK_BOX (hbox),
+                        create_bbox (FALSE, "Start", 30, GTK_BUTTONBOX_START),
+                        TRUE, TRUE, 5);
+
+    gtk_box_pack_start (GTK_BOX (hbox),
+                        create_bbox (FALSE, "End", 30, GTK_BUTTONBOX_END),
+                        TRUE, TRUE, 5);
+  }
+
+  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-3.0/demo/changedisplay.c

@@ -0,0 +1,654 @@
+/* Change Display
+ *
+ * Demonstrates migrating a window between different displays and
+ * screens. A display is a mouse and keyboard with some number of
+ * associated monitors. A screen is a set of monitors grouped
+ * into a single physical work area. The neat thing about having
+ * multiple displays is that they can be on a completely separate
+ * computers, as long as there is a network connection to the
+ * computer where the application is running.
+ *
+ * Only some of the windowing systems where GTK+ runs have the
+ * concept of multiple displays and screens. (The X Window System
+ * is the main example.) Other windowing systems can only
+ * handle one keyboard and mouse, and combine all monitors into
+ * a single screen.
+ *
+ * This is a moderately complex example, and demonstrates:
+ *
+ *  - Tracking the currently open displays and screens
+ *
+ *  - Changing the screen for a window
+ *
+ *  - Letting the user choose a window by clicking on it
+ *
+ *  - Using GtkListStore and GtkTreeView
+ *
+ *  - Using GtkDialog
+ */
+#include <string.h>
+
+#undef GDK_DISABLE_DEPRECATED
+
+#include <gtk/gtk.h>
+#include "demo-common.h"
+
+/* The ChangeDisplayInfo structure corresponds to a toplevel window and
+ * holds pointers to widgets inside the toplevel window along with other
+ * information about the contents of the window.
+ * This is a common organizational structure in real applications.
+ */
+typedef struct _ChangeDisplayInfo ChangeDisplayInfo;
+
+struct _ChangeDisplayInfo
+{
+  GtkWidget *window;
+  GtkSizeGroup *size_group;
+
+  GtkTreeModel *display_model;
+  GtkTreeModel *screen_model;
+  GtkTreeSelection *screen_selection;
+
+  GdkDisplay *current_display;
+  GdkScreen *current_screen;
+};
+
+/* These enumerations provide symbolic names for the columns
+ * in the two GtkListStore models.
+ */
+enum
+{
+  DISPLAY_COLUMN_NAME,
+  DISPLAY_COLUMN_DISPLAY,
+  DISPLAY_NUM_COLUMNS
+};
+
+enum
+{
+  SCREEN_COLUMN_NUMBER,
+  SCREEN_COLUMN_SCREEN,
+  SCREEN_NUM_COLUMNS
+};
+
+/* Finds the toplevel window under the mouse pointer, if any.
+ */
+static GtkWidget *
+find_toplevel_at_pointer (GdkDisplay *display)
+{
+  GdkWindow *pointer_window;
+  GtkWidget *widget = NULL;
+
+  pointer_window = gdk_device_get_window_at_position (gtk_get_current_event_device (),
+                                                      NULL, NULL);
+
+  /* The user data field of a GdkWindow is used to store a pointer
+   * to the widget that created it.
+   */
+  if (pointer_window)
+    {
+      gpointer widget_ptr;
+      gdk_window_get_user_data (pointer_window, &widget_ptr);
+      widget = widget_ptr;
+    }
+
+  return widget ? gtk_widget_get_toplevel (widget) : NULL;
+}
+
+static gboolean
+button_release_event_cb (GtkWidget       *widget,
+                         GdkEventButton  *event,
+                         gboolean        *clicked)
+{
+  *clicked = TRUE;
+  return TRUE;
+}
+
+/* Asks the user to click on a window, then waits for them click
+ * the mouse. When the mouse is released, returns the toplevel
+ * window under the pointer, or NULL, if there is none.
+ */
+static GtkWidget *
+query_for_toplevel (GdkScreen  *screen,
+                    const char *prompt)
+{
+  GdkDisplay *display = gdk_screen_get_display (screen);
+  GtkWidget *popup, *label, *frame;
+  GdkCursor *cursor;
+  GtkWidget *toplevel = NULL;
+
+  popup = gtk_window_new (GTK_WINDOW_POPUP);
+  gtk_window_set_screen (GTK_WINDOW (popup), screen);
+  gtk_window_set_modal (GTK_WINDOW (popup), TRUE);
+  gtk_window_set_position (GTK_WINDOW (popup), GTK_WIN_POS_CENTER);
+
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
+  gtk_container_add (GTK_CONTAINER (popup), frame);
+
+  label = gtk_label_new (prompt);
+  g_object_set (label, "margin", 10, NULL);
+  gtk_container_add (GTK_CONTAINER (frame), label);
+
+  gtk_widget_show_all (popup);
+  cursor = gdk_cursor_new_for_display (display, GDK_CROSSHAIR);
+
+  if (gdk_device_grab (gtk_get_current_event_device (),
+                       gtk_widget_get_window (popup),
+                       GDK_OWNERSHIP_NONE,
+                       FALSE,
+                       GDK_BUTTON_RELEASE_MASK,
+                       cursor,
+                       GDK_CURRENT_TIME) == GDK_GRAB_SUCCESS)
+    {
+      gboolean clicked = FALSE;
+
+      g_signal_connect (popup, "button-release-event",
+                        G_CALLBACK (button_release_event_cb), &clicked);
+
+      /* Process events until clicked is set by button_release_event_cb.
+       * We pass in may_block=TRUE since we want to wait if there
+       * are no events currently.
+       */
+      while (!clicked)
+        g_main_context_iteration (NULL, TRUE);
+
+      toplevel = find_toplevel_at_pointer (gdk_screen_get_display (screen));
+      if (toplevel == popup)
+        toplevel = NULL;
+    }
+
+  g_object_unref (cursor);
+  gtk_widget_destroy (popup);
+  gdk_flush ();                 /* Really release the grab */
+
+  return toplevel;
+}
+
+/* Prompts the user for a toplevel window to move, and then moves
+ * that window to the currently selected display
+ */
+static void
+query_change_display (ChangeDisplayInfo *info)
+{
+  GdkScreen *screen = gtk_widget_get_screen (info->window);
+  GtkWidget *toplevel;
+
+  toplevel = query_for_toplevel (screen,
+                                 "Please select the toplevel\n"
+                                 "to move to the new screen");
+
+  if (toplevel)
+    gtk_window_set_screen (GTK_WINDOW (toplevel), info->current_screen);
+  else
+    gdk_display_beep (gdk_screen_get_display (screen));
+}
+
+/* Fills in the screen list based on the current display
+ */
+static void
+fill_screens (ChangeDisplayInfo *info)
+{
+  gtk_list_store_clear (GTK_LIST_STORE (info->screen_model));
+
+  if (info->current_display)
+    {
+      gint n_screens = gdk_display_get_n_screens (info->current_display);
+      gint i;
+
+      for (i = 0; i < n_screens; i++)
+        {
+          GdkScreen *screen = gdk_display_get_screen (info->current_display, i);
+          GtkTreeIter iter;
+
+          gtk_list_store_append (GTK_LIST_STORE (info->screen_model), &iter);
+          gtk_list_store_set (GTK_LIST_STORE (info->screen_model), &iter,
+                              SCREEN_COLUMN_NUMBER, i,
+                              SCREEN_COLUMN_SCREEN, screen,
+                              -1);
+
+          if (i == 0)
+            gtk_tree_selection_select_iter (info->screen_selection, &iter);
+        }
+    }
+}
+
+/* Called when the user clicks on a button in our dialog or
+ * closes the dialog through the window manager. Unless the
+ * "Change" button was clicked, we destroy the dialog.
+ */
+static void
+response_cb (GtkDialog         *dialog,
+             gint               response_id,
+             ChangeDisplayInfo *info)
+{
+  if (response_id == GTK_RESPONSE_OK)
+    query_change_display (info);
+  else
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
+/* Called when the user clicks on "Open..." in the display
+ * frame. Prompts for a new display, and then opens a connection
+ * to that display.
+ */
+static void
+open_display_cb (GtkWidget         *button,
+                 ChangeDisplayInfo *info)
+{
+  GtkWidget *content_area;
+  GtkWidget *dialog;
+  GtkWidget *display_entry;
+  GtkWidget *dialog_label;
+  gchar *new_screen_name = NULL;
+  GdkDisplay *result = NULL;
+
+  dialog = gtk_dialog_new_with_buttons ("Open Display",
+                                        GTK_WINDOW (info->window),
+                                        GTK_DIALOG_MODAL,
+                                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                        GTK_STOCK_OK, GTK_RESPONSE_OK,
+                                        NULL);
+
+  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+  display_entry = gtk_entry_new ();
+  gtk_entry_set_activates_default (GTK_ENTRY (display_entry), TRUE);
+  dialog_label =
+    gtk_label_new ("Please enter the name of\nthe new display\n");
+
+  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
+
+  gtk_container_add (GTK_CONTAINER (content_area), dialog_label);
+  gtk_container_add (GTK_CONTAINER (content_area), display_entry);
+
+  gtk_widget_grab_focus (display_entry);
+  gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (dialog)));
+
+  while (!result)
+    {
+      gint response_id = gtk_dialog_run (GTK_DIALOG (dialog));
+      if (response_id != GTK_RESPONSE_OK)
+        break;
+
+      new_screen_name = gtk_editable_get_chars (GTK_EDITABLE (display_entry),
+                                                0, -1);
+
+      if (strcmp (new_screen_name, "") != 0)
+        {
+          result = gdk_display_open (new_screen_name);
+          if (!result)
+            {
+              gchar *error_msg =
+                g_strdup_printf  ("Can't open display :\n\t%s\nplease try another one\n",
+                                  new_screen_name);
+              gtk_label_set_text (GTK_LABEL (dialog_label), error_msg);
+              g_free (error_msg);
+            }
+
+          g_free (new_screen_name);
+        }
+    }
+
+  gtk_widget_destroy (dialog);
+}
+
+/* Called when the user clicks on the "Close" button in the
+ * "Display" frame. Closes the selected display.
+ */
+static void
+close_display_cb (GtkWidget         *button,
+                  ChangeDisplayInfo *info)
+{
+  if (info->current_display)
+    gdk_display_close (info->current_display);
+}
+
+/* Called when the selected row in the display list changes.
+ * Updates info->current_display, then refills the list of
+ * screens.
+ */
+static void
+display_changed_cb (GtkTreeSelection  *selection,
+                    ChangeDisplayInfo *info)
+{
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+
+  if (info->current_display)
+    g_object_unref (info->current_display);
+  if (gtk_tree_selection_get_selected (selection, &model, &iter))
+    gtk_tree_model_get (model, &iter,
+                        DISPLAY_COLUMN_DISPLAY, &info->current_display,
+                        -1);
+  else
+    info->current_display = NULL;
+
+  fill_screens (info);
+}
+
+/* Called when the selected row in the sceen list changes.
+ * Updates info->current_screen.
+ */
+static void
+screen_changed_cb (GtkTreeSelection  *selection,
+                   ChangeDisplayInfo *info)
+{
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+
+  if (info->current_screen)
+    g_object_unref (info->current_screen);
+  if (gtk_tree_selection_get_selected (selection, &model, &iter))
+    gtk_tree_model_get (model, &iter,
+                        SCREEN_COLUMN_SCREEN, &info->current_screen,
+                        -1);
+  else
+    info->current_screen = NULL;
+}
+
+/* This function is used both for creating the "Display" and
+ * "Screen" frames, since they have a similar structure. The
+ * caller hooks up the right context for the value returned
+ * in tree_view, and packs any relevant buttons into button_vbox.
+ */
+static void
+create_frame (ChangeDisplayInfo *info,
+              const char        *title,
+              GtkWidget        **frame,
+              GtkWidget        **tree_view,
+              GtkWidget        **button_vbox)
+{
+  GtkTreeSelection *selection;
+  GtkWidget *scrollwin;
+  GtkWidget *hbox;
+
+  *frame = gtk_frame_new (title);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
+  gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
+  gtk_container_add (GTK_CONTAINER (*frame), hbox);
+
+  scrollwin = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
+                                  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin),
+                                       GTK_SHADOW_IN);
+  gtk_box_pack_start (GTK_BOX (hbox), scrollwin, TRUE, TRUE, 0);
+
+  *tree_view = gtk_tree_view_new ();
+  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (*tree_view), FALSE);
+  gtk_container_add (GTK_CONTAINER (scrollwin), *tree_view);
+
+  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (*tree_view));
+  gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
+
+  *button_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+  gtk_box_pack_start (GTK_BOX (hbox), *button_vbox, FALSE, FALSE, 0);
+
+  if (!info->size_group)
+    info->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+  gtk_size_group_add_widget (GTK_SIZE_GROUP (info->size_group), *button_vbox);
+}
+
+/* If we have a stack of buttons, it often looks better if their contents
+ * are left-aligned, rather than centered. This function creates a button
+ * and left-aligns it contents.
+ */
+GtkWidget *
+left_align_button_new (const char *label)
+{
+  GtkWidget *button = gtk_button_new_with_mnemonic (label);
+  GtkWidget *child = gtk_bin_get_child (GTK_BIN (button));
+
+  gtk_widget_set_halign (child, GTK_ALIGN_START);
+  gtk_widget_set_valign (child, GTK_ALIGN_CENTER);
+
+  return button;
+}
+
+/* Creates the "Display" frame in the main window.
+ */
+GtkWidget *
+create_display_frame (ChangeDisplayInfo *info)
+{
+  GtkWidget *frame;
+  GtkWidget *tree_view;
+  GtkWidget *button_vbox;
+  GtkTreeViewColumn *column;
+  GtkTreeSelection *selection;
+  GtkWidget *button;
+
+  create_frame (info, "Display", &frame, &tree_view, &button_vbox);
+
+  button = left_align_button_new ("_Open...");
+  g_signal_connect (button, "clicked",  G_CALLBACK (open_display_cb), info);
+  gtk_box_pack_start (GTK_BOX (button_vbox), button, FALSE, FALSE, 0);
+
+  button = left_align_button_new ("_Close");
+  g_signal_connect (button, "clicked",  G_CALLBACK (close_display_cb), info);
+  gtk_box_pack_start (GTK_BOX (button_vbox), button, FALSE, FALSE, 0);
+
+  info->display_model = (GtkTreeModel *)gtk_list_store_new (DISPLAY_NUM_COLUMNS,
+                                                            G_TYPE_STRING,
+                                                            GDK_TYPE_DISPLAY);
+
+  gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), info->display_model);
+
+  column = gtk_tree_view_column_new_with_attributes ("Name",
+                                                     gtk_cell_renderer_text_new (),
+                                                     "text", DISPLAY_COLUMN_NAME,
+                                                     NULL);
+  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
+
+  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
+  g_signal_connect (selection, "changed",
+                    G_CALLBACK (display_changed_cb), info);
+
+  return frame;
+}
+
+/* Creates the "Screen" frame in the main window.
+ */
+GtkWidget *
+create_screen_frame (ChangeDisplayInfo *info)
+{
+  GtkWidget *frame;
+  GtkWidget *tree_view;
+  GtkWidget *button_vbox;
+  GtkTreeViewColumn *column;
+
+  create_frame (info, "Screen", &frame, &tree_view, &button_vbox);
+
+  info->screen_model = (GtkTreeModel *)gtk_list_store_new (SCREEN_NUM_COLUMNS,
+                                                           G_TYPE_INT,
+                                                           GDK_TYPE_SCREEN);
+
+  gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), info->screen_model);
+
+  column = gtk_tree_view_column_new_with_attributes ("Number",
+                                                     gtk_cell_renderer_text_new (),
+                                                     "text", SCREEN_COLUMN_NUMBER,
+                                                     NULL);
+  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
+
+  info->screen_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
+  g_signal_connect (info->screen_selection, "changed",
+                    G_CALLBACK (screen_changed_cb), info);
+
+  return frame;
+}
+
+/* Called when one of the currently open displays is closed.
+ * Remove it from our list of displays.
+ */
+static void
+display_closed_cb (GdkDisplay        *display,
+                   gboolean           is_error,
+                   ChangeDisplayInfo *info)
+{
+  GtkTreeIter iter;
+  gboolean valid;
+
+  for (valid = gtk_tree_model_get_iter_first (info->display_model, &iter);
+       valid;
+       valid = gtk_tree_model_iter_next (info->display_model, &iter))
+    {
+      GdkDisplay *tmp_display;
+
+      gtk_tree_model_get (info->display_model, &iter,
+                          DISPLAY_COLUMN_DISPLAY, &tmp_display,
+                          -1);
+      if (tmp_display == display)
+        {
+          gtk_list_store_remove (GTK_LIST_STORE (info->display_model), &iter);
+          break;
+        }
+    }
+}
+
+/* Adds a new display to our list of displays, and connects
+ * to the "closed" signal so that we can remove it from the
+ * list of displays again.
+ */
+static void
+add_display (ChangeDisplayInfo *info,
+             GdkDisplay        *display)
+{
+  const gchar *name = gdk_display_get_name (display);
+  GtkTreeIter iter;
+
+  gtk_list_store_append (GTK_LIST_STORE (info->display_model), &iter);
+  gtk_list_store_set (GTK_LIST_STORE (info->display_model), &iter,
+                      DISPLAY_COLUMN_NAME, name,
+                      DISPLAY_COLUMN_DISPLAY, display,
+                      -1);
+
+  g_signal_connect (display, "closed",
+                    G_CALLBACK (display_closed_cb), info);
+}
+
+/* Called when a new display is opened
+ */
+static void
+display_opened_cb (GdkDisplayManager *manager,
+                   GdkDisplay        *display,
+                   ChangeDisplayInfo *info)
+{
+  add_display (info, display);
+}
+
+/* Adds all currently open displays to our list of displays,
+ * and set up a signal connection so that we'll be notified
+ * when displays are opened in the future as well.
+ */
+static void
+initialize_displays (ChangeDisplayInfo *info)
+{
+  GdkDisplayManager *manager = gdk_display_manager_get ();
+  GSList *displays = gdk_display_manager_list_displays (manager);
+  GSList *tmp_list;
+
+  for (tmp_list = displays; tmp_list; tmp_list = tmp_list->next)
+    add_display (info, tmp_list->data);
+
+  g_slist_free (tmp_list);
+
+  g_signal_connect (manager, "display-opened",
+                    G_CALLBACK (display_opened_cb), info);
+}
+
+/* Cleans up when the toplevel is destroyed; we remove the
+ * connections we use to track currently open displays, then
+ * free the ChangeDisplayInfo structure.
+ */
+static void
+destroy_info (ChangeDisplayInfo *info)
+{
+  GdkDisplayManager *manager = gdk_display_manager_get ();
+  GSList *displays = gdk_display_manager_list_displays (manager);
+  GSList *tmp_list;
+
+  g_signal_handlers_disconnect_by_func (manager,
+                                        display_opened_cb,
+                                        info);
+
+  for (tmp_list = displays; tmp_list; tmp_list = tmp_list->next)
+    g_signal_handlers_disconnect_by_func (tmp_list->data,
+                                          display_closed_cb,
+                                          info);
+
+  g_slist_free (tmp_list);
+
+  g_object_unref (info->size_group);
+  g_object_unref (info->display_model);
+  g_object_unref (info->screen_model);
+
+  if (info->current_display)
+    g_object_unref (info->current_display);
+  if (info->current_screen)
+    g_object_unref (info->current_screen);
+
+  g_free (info);
+}
+
+static void
+destroy_cb (GObject            *object,
+            ChangeDisplayInfo **info)
+{
+  destroy_info (*info);
+  *info = NULL;
+}
+
+/* Main entry point. If the dialog for this demo doesn't yet exist, creates
+ * it. Otherwise, destroys it.
+ */
+GtkWidget *
+do_changedisplay (GtkWidget *do_widget)
+{
+  static ChangeDisplayInfo *info = NULL;
+
+  if (!info)
+    {
+      GtkWidget *content_area;
+      GtkWidget *vbox;
+      GtkWidget *frame;
+
+      info = g_new0 (ChangeDisplayInfo, 1);
+
+      info->window = gtk_dialog_new_with_buttons ("Change Screen or display",
+                                            GTK_WINDOW (do_widget),
+                                            0,
+                                            GTK_STOCK_CLOSE,  GTK_RESPONSE_CLOSE,
+                                            "Change",         GTK_RESPONSE_OK,
+                                            NULL);
+
+      gtk_window_set_default_size (GTK_WINDOW (info->window), 300, 400);
+
+      g_signal_connect (info->window, "response",
+                        G_CALLBACK (response_cb), info);
+      g_signal_connect (info->window, "destroy",
+                        G_CALLBACK (destroy_cb), &info);
+
+      content_area = gtk_dialog_get_content_area (GTK_DIALOG (info->window));
+
+      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+      gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
+      gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
+
+      frame = create_display_frame (info);
+      gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
+
+      frame = create_screen_frame (info);
+      gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
+
+      initialize_displays (info);
+
+      gtk_widget_show_all (info->window);
+      return info->window;
+    }
+  else
+    {
+      gtk_widget_destroy (info->window);
+      return NULL;
+    }
+}