Pileus Git - ~andy/gtk/blob - tests/testfilechooser.c

   1 /* testfilechooser.c
   2  * Copyright (C) 2003  Red Hat, Inc.
   3  * Author: Owen Taylor
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #include "config.h"
  19
  20 #include <string.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <stdlib.h>
  24 #include <time.h>
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28 #include <gtk/gtk.h>
  29
  30 #ifdef G_OS_WIN32
  31 #  include <io.h>
  32 #  define localtime_r(t,b) *(b) = *localtime (t)
  33 #  ifndef S_ISREG
  34 #    define S_ISREG(m) ((m) & _S_IFREG)
  35 #  endif
  36 #endif
  37
  38 #include "prop-editor.h"
  39
  40 static GtkWidget *preview_label;
  41 static GtkWidget *preview_image;
  42 static GtkFileChooserAction action;
  43
  44 static void
  45 print_current_folder (GtkFileChooser *chooser)
  46 {
  47   gchar *uri;
  48
  49   uri = gtk_file_chooser_get_current_folder_uri (chooser);
  50   g_print ("Current folder changed :\n  %s\n", uri ? uri : "(null)");
  51   g_free (uri);
  52 }
  53
  54 static void
  55 print_selected (GtkFileChooser *chooser)
  56 {
  57   GSList *uris = gtk_file_chooser_get_uris (chooser);
  58   GSList *tmp_list;
  59
  60   g_print ("Selection changed :\n");
  61   for (tmp_list = uris; tmp_list; tmp_list = tmp_list->next)
  62     {
  63       gchar *uri = tmp_list->data;
  64       g_print ("  %s\n", uri);
  65       g_free (uri);
  66     }
  67   g_print ("\n");
  68   g_slist_free (uris);
  69 }
  70
  71 static void
  72 response_cb (GtkDialog *dialog,
  73              gint       response_id)
  74 {
  75   if (response_id == GTK_RESPONSE_OK)
  76     {
  77       GSList *list;
  78
  79       list = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
  80
  81       if (list)
  82         {
  83           GSList *l;
  84
  85           g_print ("Selected files:\n");
  86
  87           for (l = list; l; l = l->next)
  88             {
  89               g_print ("%s\n", (char *) l->data);
  90               g_free (l->data);
  91             }
  92
  93           g_slist_free (list);
  94         }
  95       else
  96         g_print ("No selected files\n");
  97     }
  98   else
  99     g_print ("Dialog was closed\n");
 100
 101   gtk_main_quit ();
 102 }
 103
 104 static gboolean
 105 no_backup_files_filter (const GtkFileFilterInfo *filter_info,
 106                         gpointer                 data)
 107 {
 108   gsize len = filter_info->display_name ? strlen (filter_info->display_name) : 0;
 109   if (len > 0 && filter_info->display_name[len - 1] == '~')
 110     return 0;
 111   else
 112     return 1;
 113 }
 114
 115 static void
 116 filter_changed (GtkFileChooserDialog *dialog,
 117                 gpointer              data)
 118 {
 119   g_print ("file filter changed\n");
 120 }
 121
 122 static char *
 123 format_time (time_t t)
 124 {
 125   gchar buf[128];
 126   struct tm tm_buf;
 127   time_t now = time (NULL);
 128   const char *format;
 129
 130   if (abs (now - t) < 24*60*60)
 131     format = "%X";
 132   else
 133     format = "%x";
 134
 135   localtime_r (&t, &tm_buf);
 136   if (strftime (buf, sizeof (buf), format, &tm_buf) == 0)
 137     return g_strdup ("<unknown>");
 138   else
 139     return g_strdup (buf);
 140 }
 141
 142 static char *
 143 format_size (gint64 size)
 144 {
 145   if (size < (gint64)1024)
 146     return g_strdup_printf ("%d bytes", (gint)size);
 147   else if (size < (gint64)1024*1024)
 148     return g_strdup_printf ("%.1f K", size / (1024.));
 149   else if (size < (gint64)1024*1024*1024)
 150     return g_strdup_printf ("%.1f M", size / (1024.*1024.));
 151   else
 152     return g_strdup_printf ("%.1f G", size / (1024.*1024.*1024.));
 153 }
 154
 155 #include <stdio.h>
 156 #include <errno.h>
 157 #define _(s) (s)
 158
 159 static void
 160 size_prepared_cb (GdkPixbufLoader *loader,
 161                   int              width,
 162                   int              height,
 163                   int             *data)
 164 {
 165         int des_width = data[0];
 166         int des_height = data[1];
 167
 168         if (des_height >= height && des_width >= width) {
 169                 /* Nothing */
 170         } else if ((double)height * des_width > (double)width * des_height) {
 171                 width = 0.5 + (double)width * des_height / (double)height;
 172                 height = des_height;
 173         } else {
 174                 height = 0.5 + (double)height * des_width / (double)width;
 175                 width = des_width;
 176         }
 177
 178         gdk_pixbuf_loader_set_size (loader, width, height);
 179 }
 180
 181 GdkPixbuf *
 182 my_new_from_file_at_size (const char *filename,
 183                           int         width,
 184                           int         height,
 185                           GError    **error)
 186 {
 187         GdkPixbufLoader *loader;
 188         GdkPixbuf       *pixbuf;
 189         int              info[2];
 190         struct stat st;
 191
 192         guchar buffer [4096];
 193         int length;
 194         FILE *f;
 195
 196         g_return_val_if_fail (filename != NULL, NULL);
 197         g_return_val_if_fail (width > 0 && height > 0, NULL);
 198
 199         if (stat (filename, &st) != 0) {
 200                 int errsv = errno;
 201
 202                 g_set_error (error,
 203                              G_FILE_ERROR,
 204                              g_file_error_from_errno (errsv),
 205                              _("Could not get information for file '%s': %s"),
 206                              filename, g_strerror (errsv));
 207                 return NULL;
 208         }
 209
 210         if (!S_ISREG (st.st_mode))
 211                 return NULL;
 212
 213         f = fopen (filename, "rb");
 214         if (!f) {
 215                 int errsv = errno;
 216
 217                 g_set_error (error,
 218                              G_FILE_ERROR,
 219                              g_file_error_from_errno (errsv),
 220                              _("Failed to open file '%s': %s"),
 221                              filename, g_strerror (errsv));
 222                 return NULL;
 223         }
 224
 225         loader = gdk_pixbuf_loader_new ();
 226 #ifdef DONT_PRESERVE_ASPECT
 227         gdk_pixbuf_loader_set_size (loader, width, height);
 228 #else
 229         info[0] = width;
 230         info[1] = height;
 231         g_signal_connect (loader, "size-prepared", G_CALLBACK (size_prepared_cb), info);
 232 #endif
 233
 234         while (!feof (f)) {
 235                 length = fread (buffer, 1, sizeof (buffer), f);
 236                 if (length > 0)
 237                         if (!gdk_pixbuf_loader_write (loader, buffer, length, error)) {
 238                                 gdk_pixbuf_loader_close (loader, NULL);
 239                                 fclose (f);
 240                                 g_object_unref (loader);
 241                                 return NULL;
 242                         }
 243         }
 244
 245         fclose (f);
 246
 247         g_assert (*error == NULL);
 248         if (!gdk_pixbuf_loader_close (loader, error)) {
 249                 g_object_unref (loader);
 250                 return NULL;
 251         }
 252
 253         pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
 254
 255         if (!pixbuf) {
 256                 g_object_unref (loader);
 257
 258                 /* did the loader set an error? */
 259                 if (*error != NULL)
 260                         return NULL;
 261
 262                 g_set_error (error,
 263                              GDK_PIXBUF_ERROR,
 264                              GDK_PIXBUF_ERROR_FAILED,
 265                              _("Failed to load image '%s': reason not known, probably a corrupt image file"),
 266                              filename);
 267                 return NULL;
 268         }
 269
 270         g_object_ref (pixbuf);
 271
 272         g_object_unref (loader);
 273
 274         return pixbuf;
 275 }
 276
 277 static void
 278 update_preview_cb (GtkFileChooser *chooser)
 279 {
 280   gchar *filename = gtk_file_chooser_get_preview_filename (chooser);
 281   gboolean have_preview = FALSE;
 282
 283   if (filename)
 284     {
 285       GdkPixbuf *pixbuf;
 286       GError *error = NULL;
 287
 288       pixbuf = my_new_from_file_at_size (filename, 128, 128, &error);
 289       if (pixbuf)
 290         {
 291           gtk_image_set_from_pixbuf (GTK_IMAGE (preview_image), pixbuf);
 292           g_object_unref (pixbuf);
 293           gtk_widget_show (preview_image);
 294           gtk_widget_hide (preview_label);
 295           have_preview = TRUE;
 296         }
 297       else
 298         {
 299           struct stat buf;
 300           if (stat (filename, &buf) == 0)
 301             {
 302               gchar *preview_text;
 303               gchar *size_str;
 304               gchar *modified_time;
 305
 306               size_str = format_size (buf.st_size);
 307               modified_time = format_time (buf.st_mtime);
 308
 309               preview_text = g_strdup_printf ("<i>Modified:</i>\t%s\n"
 310                                               "<i>Size:</i>\t%s\n",
 311                                               modified_time,
 312                                               size_str);
 313               gtk_label_set_markup (GTK_LABEL (preview_label), preview_text);
 314               g_free (modified_time);
 315               g_free (size_str);
 316               g_free (preview_text);
 317
 318               gtk_widget_hide (preview_image);
 319               gtk_widget_show (preview_label);
 320               have_preview = TRUE;
 321             }
 322         }
 323
 324       g_free (filename);
 325
 326       if (error)
 327         g_error_free (error);
 328     }
 329
 330   gtk_file_chooser_set_preview_widget_active (chooser, have_preview);
 331 }
 332
 333 static void
 334 set_current_folder (GtkFileChooser *chooser,
 335                     const char     *name)
 336 {
 337   if (!gtk_file_chooser_set_current_folder (chooser, name))
 338     {
 339       GtkWidget *dialog;
 340
 341       dialog = gtk_message_dialog_new (GTK_WINDOW (chooser),
 342                                        GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 343                                        GTK_MESSAGE_ERROR,
 344                                        GTK_BUTTONS_CLOSE,
 345                                        "Could not set the folder to %s",
 346                                        name);
 347       gtk_dialog_run (GTK_DIALOG (dialog));
 348       gtk_widget_destroy (dialog);
 349     }
 350 }
 351
 352 static void
 353 set_folder_nonexistent_cb (GtkButton      *button,
 354                            GtkFileChooser *chooser)
 355 {
 356   set_current_folder (chooser, "/nonexistent");
 357 }
 358
 359 static void
 360 set_folder_existing_nonexistent_cb (GtkButton      *button,
 361                                     GtkFileChooser *chooser)
 362 {
 363   set_current_folder (chooser, "/usr/nonexistent");
 364 }
 365
 366 static void
 367 set_filename (GtkFileChooser *chooser,
 368               const char     *name)
 369 {
 370   if (!gtk_file_chooser_set_filename (chooser, name))
 371     {
 372       GtkWidget *dialog;
 373
 374       dialog = gtk_message_dialog_new (GTK_WINDOW (chooser),
 375                                        GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 376                                        GTK_MESSAGE_ERROR,
 377                                        GTK_BUTTONS_CLOSE,
 378                                        "Could not select %s",
 379                                        name);
 380       gtk_dialog_run (GTK_DIALOG (dialog));
 381       gtk_widget_destroy (dialog);
 382     }
 383 }
 384
 385 static void
 386 set_filename_nonexistent_cb (GtkButton      *button,
 387                              GtkFileChooser *chooser)
 388 {
 389   set_filename (chooser, "/nonexistent");
 390 }
 391
 392 static void
 393 set_filename_existing_nonexistent_cb (GtkButton      *button,
 394                                       GtkFileChooser *chooser)
 395 {
 396   set_filename (chooser, "/usr/nonexistent");
 397 }
 398
 399 static void
 400 unmap_and_remap_cb (GtkButton *button,
 401                     GtkFileChooser *chooser)
 402 {
 403   gtk_widget_hide (GTK_WIDGET (chooser));
 404   gtk_widget_show (GTK_WIDGET (chooser));
 405 }
 406
 407 static void
 408 kill_dependent (GtkWindow *win, GtkWidget *dep)
 409 {
 410   gtk_widget_destroy (dep);
 411   g_object_unref (dep);
 412 }
 413
 414 static void
 415 notify_multiple_cb (GtkWidget  *dialog,
 416                     GParamSpec *pspec,
 417                     GtkWidget  *button)
 418 {
 419   gboolean multiple;
 420
 421   multiple = gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (dialog));
 422
 423   gtk_widget_set_sensitive (button, multiple);
 424 }
 425
 426 static GtkFileChooserConfirmation
 427 confirm_overwrite_cb (GtkFileChooser *chooser,
 428                       gpointer        data)
 429 {
 430   GtkWidget *dialog;
 431   GtkWidget *button;
 432   int response;
 433   GtkFileChooserConfirmation conf;
 434
 435   dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (chooser))),
 436                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 437                                    GTK_MESSAGE_QUESTION,
 438                                    GTK_BUTTONS_NONE,
 439                                    "What do you want to do?");
 440
 441   button = gtk_button_new_with_label ("Use the stock confirmation dialog");
 442   gtk_widget_show (button);
 443   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, 1);
 444
 445   button = gtk_button_new_with_label ("Type a new file name");
 446   gtk_widget_show (button);
 447   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, 2);
 448
 449   button = gtk_button_new_with_label ("Accept the file name");
 450   gtk_widget_show (button);
 451   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, 3);
 452
 453   response = gtk_dialog_run (GTK_DIALOG (dialog));
 454
 455   switch (response)
 456     {
 457     case 1:
 458       conf = GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM;
 459       break;
 460
 461     case 3:
 462       conf = GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME;
 463       break;
 464
 465     default:
 466       conf = GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN;
 467       break;
 468     }
 469
 470   gtk_widget_destroy (dialog);
 471
 472   return conf;
 473 }
 474
 475 int
 476 main (int argc, char **argv)
 477 {
 478   GtkWidget *control_window;
 479   GtkWidget *vbbox;
 480   GtkWidget *button;
 481   GtkWidget *dialog;
 482   GtkWidget *extra;
 483   GtkFileFilter *filter;
 484   GtkWidget *preview_vbox;
 485   gboolean force_rtl = FALSE;
 486   gboolean multiple = FALSE;
 487   char *action_arg = NULL;
 488   char *initial_filename = NULL;
 489   char *initial_folder = NULL;
 490   GError *error = NULL;
 491   GOptionEntry options[] = {
 492     { "action", 'a', 0, G_OPTION_ARG_STRING, &action_arg, "Filechooser action", "ACTION" },
 493     { "multiple", 'm', 0, G_OPTION_ARG_NONE, &multiple, "Select-multiple", NULL },
 494     { "right-to-left", 'r', 0, G_OPTION_ARG_NONE, &force_rtl, "Force right-to-left layout.", NULL },
 495     { "initial-filename", 'f', 0, G_OPTION_ARG_FILENAME, &initial_filename, "Initial filename to select", "FILENAME" },
 496     { "initial-folder", 'F', 0, G_OPTION_ARG_FILENAME, &initial_folder, "Initial folder to show", "FILENAME" },
 497     { NULL }
 498   };
 499
 500   if (!gtk_init_with_args (&argc, &argv, "", options, NULL, &error))
 501     {
 502       g_print ("Failed to parse args: %s\n", error->message);
 503       g_error_free (error);
 504       return 1;
 505     }
 506
 507   if (initial_filename && initial_folder)
 508     {
 509       g_print ("Only one of --initial-filename and --initial-folder may be specified");
 510       return 1;
 511     }
 512
 513   if (force_rtl)
 514     gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
 515
 516   action = GTK_FILE_CHOOSER_ACTION_OPEN;
 517
 518   if (action_arg != NULL)
 519     {
 520       if (! strcmp ("open", action_arg))
 521         action = GTK_FILE_CHOOSER_ACTION_OPEN;
 522       else if (! strcmp ("save", action_arg))
 523         action = GTK_FILE_CHOOSER_ACTION_SAVE;
 524       else if (! strcmp ("select_folder", action_arg))
 525         action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
 526       else if (! strcmp ("create_folder", action_arg))
 527         action = GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER;
 528
 529       g_free (action_arg);
 530     }
 531
 532   dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
 533                          "action", action,
 534                          "select-multiple", multiple,
 535                          NULL);
 536
 537   switch (action)
 538     {
 539     case GTK_FILE_CHOOSER_ACTION_OPEN:
 540     case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
 541       gtk_window_set_title (GTK_WINDOW (dialog), "Select a file");
 542       gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 543                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 544                               GTK_STOCK_OPEN, GTK_RESPONSE_OK,
 545                               NULL);
 546       break;
 547     case GTK_FILE_CHOOSER_ACTION_SAVE:
 548     case GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER:
 549       gtk_window_set_title (GTK_WINDOW (dialog), "Save a file");
 550       gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 551                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 552                               GTK_STOCK_SAVE, GTK_RESPONSE_OK,
 553                               NULL);
 554       break;
 555     }
 556   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 557
 558   g_signal_connect (dialog, "selection-changed",
 559                     G_CALLBACK (print_selected), NULL);
 560   g_signal_connect (dialog, "current-folder-changed",
 561                     G_CALLBACK (print_current_folder), NULL);
 562   g_signal_connect (dialog, "response",
 563                     G_CALLBACK (response_cb), NULL);
 564   g_signal_connect (dialog, "confirm-overwrite",
 565                     G_CALLBACK (confirm_overwrite_cb), NULL);
 566
 567   /* Filters */
 568   filter = gtk_file_filter_new ();
 569   gtk_file_filter_set_name (filter, "All Files");
 570   gtk_file_filter_add_pattern (filter, "*");
 571   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 572
 573   filter = gtk_file_filter_new ();
 574   gtk_file_filter_set_name (filter, "No backup files");
 575   gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_DISPLAY_NAME,
 576                               no_backup_files_filter, NULL, NULL);
 577   gtk_file_filter_add_mime_type (filter, "image/png");
 578   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 579
 580   filter = gtk_file_filter_new ();
 581   gtk_file_filter_set_name (filter, "Starts with D");
 582   gtk_file_filter_add_pattern (filter, "D*");
 583   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 584
 585   g_signal_connect (dialog, "notify::filter",
 586                     G_CALLBACK (filter_changed), NULL);
 587
 588   /* Make this filter the default */
 589   gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);
 590
 591   filter = gtk_file_filter_new ();
 592   gtk_file_filter_set_name (filter, "PNG and JPEG");
 593   gtk_file_filter_add_mime_type (filter, "image/jpeg");
 594   gtk_file_filter_add_mime_type (filter, "image/png");
 595   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 596
 597   filter = gtk_file_filter_new ();
 598   gtk_file_filter_set_name (filter, "Images");
 599   gtk_file_filter_add_pixbuf_formats (filter);
 600   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 601
 602   /* Preview widget */
 603   /* THIS IS A TERRIBLE PREVIEW WIDGET, AND SHOULD NOT BE COPIED AT ALL.
 604    */
 605   preview_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 606   /*gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), preview_vbox);*/
 607
 608   preview_label = gtk_label_new (NULL);
 609   gtk_box_pack_start (GTK_BOX (preview_vbox), preview_label, TRUE, TRUE, 0);
 610   g_object_set (preview_label, "margin", 6, NULL);
 611
 612   preview_image = gtk_image_new ();
 613   gtk_box_pack_start (GTK_BOX (preview_vbox), preview_image, TRUE, TRUE, 0);
 614   g_object_set (preview_image, "margin", 6, NULL);
 615
 616   update_preview_cb (GTK_FILE_CHOOSER (dialog));
 617   g_signal_connect (dialog, "update-preview",
 618                     G_CALLBACK (update_preview_cb), NULL);
 619
 620   /* Extra widget */
 621
 622   extra = gtk_check_button_new_with_mnemonic ("Lar_t whoever asks about this button");
 623   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (extra), TRUE);
 624   gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), extra);
 625
 626   /* Shortcuts */
 627
 628   gtk_file_chooser_add_shortcut_folder_uri (GTK_FILE_CHOOSER (dialog),
 629                                             "file:///usr/share/pixmaps",
 630                                             NULL);
 631
 632   /* Initial filename or folder */
 633
 634   if (initial_filename)
 635     set_filename (GTK_FILE_CHOOSER (dialog), initial_filename);
 636
 637   if (initial_folder)
 638     set_current_folder (GTK_FILE_CHOOSER (dialog), initial_folder);
 639
 640   /* show_all() to reveal bugs in composite widget handling */
 641   gtk_widget_show_all (dialog);
 642
 643   /* Extra controls for manipulating the test environment
 644    */
 645   create_prop_editor (G_OBJECT (dialog), GTK_TYPE_FILE_CHOOSER);
 646
 647   control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 648
 649   vbbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
 650   gtk_container_add (GTK_CONTAINER (control_window), vbbox);
 651
 652   button = gtk_button_new_with_mnemonic ("_Select all");
 653   gtk_widget_set_sensitive (button, multiple);
 654   gtk_container_add (GTK_CONTAINER (vbbox), button);
 655   g_signal_connect_swapped (button, "clicked",
 656                             G_CALLBACK (gtk_file_chooser_select_all), dialog);
 657   g_signal_connect (dialog, "notify::select-multiple",
 658                     G_CALLBACK (notify_multiple_cb), button);
 659
 660   button = gtk_button_new_with_mnemonic ("_Unselect all");
 661   gtk_container_add (GTK_CONTAINER (vbbox), button);
 662   g_signal_connect_swapped (button, "clicked",
 663                             G_CALLBACK (gtk_file_chooser_unselect_all), dialog);
 664
 665   button = gtk_button_new_with_label ("set_current_folder (\"/nonexistent\")");
 666   gtk_container_add (GTK_CONTAINER (vbbox), button);
 667   g_signal_connect (button, "clicked",
 668                     G_CALLBACK (set_folder_nonexistent_cb), dialog);
 669
 670   button = gtk_button_new_with_label ("set_current_folder (\"/usr/nonexistent\")");
 671   gtk_container_add (GTK_CONTAINER (vbbox), button);
 672   g_signal_connect (button, "clicked",
 673                     G_CALLBACK (set_folder_existing_nonexistent_cb), dialog);
 674
 675   button = gtk_button_new_with_label ("set_filename (\"/nonexistent\")");
 676   gtk_container_add (GTK_CONTAINER (vbbox), button);
 677   g_signal_connect (button, "clicked",
 678                     G_CALLBACK (set_filename_nonexistent_cb), dialog);
 679
 680   button = gtk_button_new_with_label ("set_filename (\"/usr/nonexistent\")");
 681   gtk_container_add (GTK_CONTAINER (vbbox), button);
 682   g_signal_connect (button, "clicked",
 683                     G_CALLBACK (set_filename_existing_nonexistent_cb), dialog);
 684
 685   button = gtk_button_new_with_label ("Unmap and remap");
 686   gtk_container_add (GTK_CONTAINER (vbbox), button);
 687   g_signal_connect (button, "clicked",
 688                     G_CALLBACK (unmap_and_remap_cb), dialog);
 689
 690   gtk_widget_show_all (control_window);
 691
 692   g_object_ref (control_window);
 693   g_signal_connect (dialog, "destroy",
 694                     G_CALLBACK (kill_dependent), control_window);
 695
 696   /* We need to hold a ref until we have destroyed the widgets, just in case
 697    * someone else destroys them.  We explicitly destroy windows to catch leaks.
 698    */
 699   g_object_ref (dialog);
 700   gtk_main ();
 701   gtk_widget_destroy (dialog);
 702   g_object_unref (dialog);
 703
 704   return 0;
 705 }