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

   1 #include <config.h>
   2
   3 #include <string.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <stdlib.h>
   7 #include <time.h>
   8 #ifdef HAVE_UNISTD_H
   9 #include <unistd.h>
  10 #endif
  11 #include <gtk/gtk.h>
  12
  13 #ifdef G_OS_WIN32
  14 #  include <io.h>
  15 #  define localtime_r(t,b) *(b) = *localtime (t)
  16 #  ifndef S_ISREG
  17 #    define S_ISREG(m) ((m) & _S_IFREG)
  18 #  endif
  19 #endif
  20
  21 #include "prop-editor.h"
  22
  23 static GtkWidget *preview_label;
  24 static GtkWidget *preview_image;
  25 static GtkFileChooserAction action;
  26
  27 static void
  28 print_current_folder (GtkFileChooser *chooser)
  29 {
  30   gchar *uri;
  31
  32   uri = gtk_file_chooser_get_current_folder_uri (chooser);
  33   g_print ("Current folder changed :\n  %s\n", uri ? uri : "(null)");
  34   g_free (uri);
  35 }
  36
  37 static void
  38 print_selected (GtkFileChooser *chooser)
  39 {
  40   GSList *uris = gtk_file_chooser_get_uris (chooser);
  41   GSList *tmp_list;
  42
  43   g_print ("Selection changed :\n");
  44   for (tmp_list = uris; tmp_list; tmp_list = tmp_list->next)
  45     {
  46       gchar *uri = tmp_list->data;
  47       g_print ("  %s\n", uri);
  48       g_free (uri);
  49     }
  50   g_print ("\n");
  51   g_slist_free (uris);
  52 }
  53
  54 static void
  55 response_cb (GtkDialog *dialog,
  56              gint       response_id)
  57 {
  58   if (response_id == GTK_RESPONSE_OK)
  59     {
  60       GSList *list;
  61
  62       list = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
  63
  64       if (list)
  65         {
  66           GSList *l;
  67
  68           g_print ("Selected files:\n");
  69
  70           for (l = list; l; l = l->next)
  71             {
  72               g_print ("%s\n", (char *) l->data);
  73               g_free (l->data);
  74             }
  75
  76           g_slist_free (list);
  77         }
  78       else
  79         g_print ("No selected files\n");
  80     }
  81   else
  82     g_print ("Dialog was closed\n");
  83
  84   gtk_main_quit ();
  85 }
  86
  87 static gboolean
  88 no_backup_files_filter (const GtkFileFilterInfo *filter_info,
  89                         gpointer                 data)
  90 {
  91   gsize len = filter_info->display_name ? strlen (filter_info->display_name) : 0;
  92   if (len > 0 && filter_info->display_name[len - 1] == '~')
  93     return 0;
  94   else
  95     return 1;
  96 }
  97
  98 static void
  99 filter_changed (GtkFileChooserDialog *dialog,
 100                 gpointer              data)
 101 {
 102   g_print ("file filter changed\n");
 103 }
 104
 105 static char *
 106 format_time (time_t t)
 107 {
 108   gchar buf[128];
 109   struct tm tm_buf;
 110   time_t now = time (NULL);
 111   const char *format;
 112
 113   if (abs (now - t) < 24*60*60)
 114     format = "%X";
 115   else
 116     format = "%x";
 117
 118   localtime_r (&t, &tm_buf);
 119   if (strftime (buf, sizeof (buf), format, &tm_buf) == 0)
 120     return g_strdup ("<unknown>");
 121   else
 122     return g_strdup (buf);
 123 }
 124
 125 static char *
 126 format_size (gint64 size)
 127 {
 128   if (size < (gint64)1024)
 129     return g_strdup_printf ("%d bytes", (gint)size);
 130   else if (size < (gint64)1024*1024)
 131     return g_strdup_printf ("%.1f K", size / (1024.));
 132   else if (size < (gint64)1024*1024*1024)
 133     return g_strdup_printf ("%.1f M", size / (1024.*1024.));
 134   else
 135     return g_strdup_printf ("%.1f G", size / (1024.*1024.*1024.));
 136 }
 137
 138 #include <stdio.h>
 139 #include <errno.h>
 140 #define _(s) (s)
 141
 142 static void
 143 size_prepared_cb (GdkPixbufLoader *loader,
 144                   int              width,
 145                   int              height,
 146                   int             *data)
 147 {
 148         int des_width = data[0];
 149         int des_height = data[1];
 150
 151         if (des_height >= height && des_width >= width) {
 152                 /* Nothing */
 153         } else if ((double)height * des_width > (double)width * des_height) {
 154                 width = 0.5 + (double)width * des_height / (double)height;
 155                 height = des_height;
 156         } else {
 157                 height = 0.5 + (double)height * des_width / (double)width;
 158                 width = des_width;
 159         }
 160
 161         gdk_pixbuf_loader_set_size (loader, width, height);
 162 }
 163
 164 GdkPixbuf *
 165 my_new_from_file_at_size (const char *filename,
 166                           int         width,
 167                           int         height,
 168                           GError    **error)
 169 {
 170         GdkPixbufLoader *loader;
 171         GdkPixbuf       *pixbuf;
 172         int              info[2];
 173         struct stat st;
 174
 175         guchar buffer [4096];
 176         int length;
 177         FILE *f;
 178
 179         g_return_val_if_fail (filename != NULL, NULL);
 180         g_return_val_if_fail (width > 0 && height > 0, NULL);
 181
 182         if (stat (filename, &st) != 0) {
 183                 g_set_error (error,
 184                              G_FILE_ERROR,
 185                              g_file_error_from_errno (errno),
 186                              _("Could not get information for file '%s': %s"),
 187                              filename, g_strerror (errno));
 188                 return NULL;
 189         }
 190
 191         if (!S_ISREG (st.st_mode))
 192                 return NULL;
 193
 194         f = fopen (filename, "rb");
 195         if (!f) {
 196                 g_set_error (error,
 197                              G_FILE_ERROR,
 198                              g_file_error_from_errno (errno),
 199                              _("Failed to open file '%s': %s"),
 200                              filename, g_strerror (errno));
 201                 return NULL;
 202         }
 203
 204         loader = gdk_pixbuf_loader_new ();
 205 #ifdef DONT_PRESERVE_ASPECT
 206         gdk_pixbuf_loader_set_size (loader, width, height);
 207 #else
 208         info[0] = width;
 209         info[1] = height;
 210         g_signal_connect (loader, "size-prepared", G_CALLBACK (size_prepared_cb), info);
 211 #endif
 212
 213         while (!feof (f)) {
 214                 length = fread (buffer, 1, sizeof (buffer), f);
 215                 if (length > 0)
 216                         if (!gdk_pixbuf_loader_write (loader, buffer, length, error)) {
 217                                 gdk_pixbuf_loader_close (loader, NULL);
 218                                 fclose (f);
 219                                 g_object_unref (G_OBJECT (loader));
 220                                 return NULL;
 221                         }
 222         }
 223
 224         fclose (f);
 225
 226         g_assert (*error == NULL);
 227         if (!gdk_pixbuf_loader_close (loader, error)) {
 228                 g_object_unref (G_OBJECT (loader));
 229                 return NULL;
 230         }
 231
 232         pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
 233
 234         if (!pixbuf) {
 235                 g_object_unref (G_OBJECT (loader));
 236
 237                 /* did the loader set an error? */
 238                 if (*error != NULL)
 239                         return NULL;
 240
 241                 g_set_error (error,
 242                              GDK_PIXBUF_ERROR,
 243                              GDK_PIXBUF_ERROR_FAILED,
 244                              _("Failed to load image '%s': reason not known, probably a corrupt image file"),
 245                              filename);
 246                 return NULL;
 247         }
 248
 249         g_object_ref (pixbuf);
 250
 251         g_object_unref (G_OBJECT (loader));
 252
 253         return pixbuf;
 254 }
 255
 256 static void
 257 update_preview_cb (GtkFileChooser *chooser)
 258 {
 259   gchar *filename = gtk_file_chooser_get_preview_filename (chooser);
 260   gboolean have_preview = FALSE;
 261
 262   if (filename)
 263     {
 264       GdkPixbuf *pixbuf;
 265       GError *error = NULL;
 266
 267       pixbuf = my_new_from_file_at_size (filename, 128, 128, &error);
 268       if (pixbuf)
 269         {
 270           gtk_image_set_from_pixbuf (GTK_IMAGE (preview_image), pixbuf);
 271           g_object_unref (pixbuf);
 272           gtk_widget_show (preview_image);
 273           gtk_widget_hide (preview_label);
 274           have_preview = TRUE;
 275         }
 276       else
 277         {
 278           struct stat buf;
 279           if (stat (filename, &buf) == 0)
 280             {
 281               gchar *preview_text;
 282               gchar *size_str;
 283               gchar *modified_time;
 284
 285               size_str = format_size (buf.st_size);
 286               modified_time = format_time (buf.st_mtime);
 287
 288               preview_text = g_strdup_printf ("<i>Modified:</i>\t%s\n"
 289                                               "<i>Size:</i>\t%s\n",
 290                                               modified_time,
 291                                               size_str);
 292               gtk_label_set_markup (GTK_LABEL (preview_label), preview_text);
 293               g_free (modified_time);
 294               g_free (size_str);
 295               g_free (preview_text);
 296
 297               gtk_widget_hide (preview_image);
 298               gtk_widget_show (preview_label);
 299               have_preview = TRUE;
 300             }
 301         }
 302
 303       g_free (filename);
 304
 305       if (error)
 306         g_error_free (error);
 307     }
 308
 309   gtk_file_chooser_set_preview_widget_active (chooser, have_preview);
 310 }
 311
 312 static void
 313 set_current_folder (GtkFileChooser *chooser,
 314                     const char     *name)
 315 {
 316   if (!gtk_file_chooser_set_current_folder (chooser, name))
 317     {
 318       GtkWidget *dialog;
 319
 320       dialog = gtk_message_dialog_new (GTK_WINDOW (chooser),
 321                                        GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 322                                        GTK_MESSAGE_ERROR,
 323                                        GTK_BUTTONS_CLOSE,
 324                                        "Could not set the folder to %s",
 325                                        name);
 326       gtk_dialog_run (GTK_DIALOG (dialog));
 327       gtk_widget_destroy (dialog);
 328     }
 329 }
 330
 331 static void
 332 set_folder_nonexistent_cb (GtkButton      *button,
 333                            GtkFileChooser *chooser)
 334 {
 335   set_current_folder (chooser, "/nonexistent");
 336 }
 337
 338 static void
 339 set_folder_existing_nonexistent_cb (GtkButton      *button,
 340                                     GtkFileChooser *chooser)
 341 {
 342   set_current_folder (chooser, "/usr/nonexistent");
 343 }
 344
 345 static void
 346 set_filename (GtkFileChooser *chooser,
 347               const char     *name)
 348 {
 349   if (!gtk_file_chooser_set_filename (chooser, name))
 350     {
 351       GtkWidget *dialog;
 352
 353       dialog = gtk_message_dialog_new (GTK_WINDOW (chooser),
 354                                        GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 355                                        GTK_MESSAGE_ERROR,
 356                                        GTK_BUTTONS_CLOSE,
 357                                        "Could not select %s",
 358                                        name);
 359       gtk_dialog_run (GTK_DIALOG (dialog));
 360       gtk_widget_destroy (dialog);
 361     }
 362 }
 363
 364 static void
 365 set_filename_nonexistent_cb (GtkButton      *button,
 366                              GtkFileChooser *chooser)
 367 {
 368   set_filename (chooser, "/nonexistent");
 369 }
 370
 371 static void
 372 set_filename_existing_nonexistent_cb (GtkButton      *button,
 373                                       GtkFileChooser *chooser)
 374 {
 375   set_filename (chooser, "/usr/nonexistent");
 376 }
 377
 378 static void
 379 kill_dependent (GtkWindow *win, GtkObject *dep)
 380 {
 381   gtk_object_destroy (dep);
 382   g_object_unref (dep);
 383 }
 384
 385 static void
 386 notify_multiple_cb (GtkWidget  *dialog,
 387                     GParamSpec *pspec,
 388                     GtkWidget  *button)
 389 {
 390   gboolean multiple;
 391
 392   multiple = gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (dialog));
 393
 394   gtk_widget_set_sensitive (button, multiple);
 395 }
 396
 397 int
 398 main (int argc, char **argv)
 399 {
 400   GtkWidget *control_window;
 401   GtkWidget *vbbox;
 402   GtkWidget *button;
 403   GtkWidget *dialog;
 404   GtkWidget *prop_editor;
 405   GtkWidget *extra;
 406   GtkFileFilter *filter;
 407   GtkWidget *preview_vbox;
 408   int i;
 409   gboolean multiple = FALSE;
 410
 411   gtk_init (&argc, &argv);
 412
 413   /* to test rtl layout, set RTL=1 in the environment */
 414   if (g_getenv ("RTL"))
 415     gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
 416
 417   action = GTK_FILE_CHOOSER_ACTION_OPEN;
 418
 419   /* lame-o arg parsing */
 420   for (i = 1; i < argc; i++)
 421     {
 422       if (! strcmp ("--action=open", argv[i]))
 423         action = GTK_FILE_CHOOSER_ACTION_OPEN;
 424       else if (! strcmp ("--action=save", argv[i]))
 425         action = GTK_FILE_CHOOSER_ACTION_SAVE;
 426       else if (! strcmp ("--action=select_folder", argv[i]))
 427         action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
 428       else if (! strcmp ("--action=create_folder", argv[i]))
 429         action = GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER;
 430       else if (! strcmp ("--multiple", argv[i]))
 431         multiple = TRUE;
 432     }
 433
 434   dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
 435                          "action", action,
 436                          "file-system-backend", "gtk+",
 437                          "select-multiple", multiple,
 438                          NULL);
 439   switch (action)
 440     {
 441     case GTK_FILE_CHOOSER_ACTION_OPEN:
 442     case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
 443       gtk_window_set_title (GTK_WINDOW (dialog), "Select a file");
 444       gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 445                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 446                               GTK_STOCK_OPEN, GTK_RESPONSE_OK,
 447                               NULL);
 448       break;
 449     case GTK_FILE_CHOOSER_ACTION_SAVE:
 450     case GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER:
 451       gtk_window_set_title (GTK_WINDOW (dialog), "Save a file");
 452       gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 453                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 454                               GTK_STOCK_SAVE, GTK_RESPONSE_OK,
 455                               NULL);
 456       break;
 457     }
 458   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 459
 460   g_signal_connect (dialog, "selection-changed",
 461                     G_CALLBACK (print_selected), NULL);
 462   g_signal_connect (dialog, "current-folder-changed",
 463                     G_CALLBACK (print_current_folder), NULL);
 464   g_signal_connect (dialog, "response",
 465                     G_CALLBACK (response_cb), NULL);
 466
 467   /* Filters */
 468   filter = gtk_file_filter_new ();
 469   gtk_file_filter_set_name (filter, "All Files");
 470   gtk_file_filter_add_pattern (filter, "*");
 471   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 472
 473   filter = gtk_file_filter_new ();
 474   gtk_file_filter_set_name (filter, "No backup files");
 475   gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_DISPLAY_NAME,
 476                               no_backup_files_filter, NULL, NULL);
 477   gtk_file_filter_add_mime_type (filter, "image/png");
 478   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 479
 480   g_signal_connect (dialog, "notify::filter",
 481                     G_CALLBACK (filter_changed), NULL);
 482
 483   /* Make this filter the default */
 484   gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);
 485
 486   filter = gtk_file_filter_new ();
 487   gtk_file_filter_set_name (filter, "PNG and JPEG");
 488   gtk_file_filter_add_mime_type (filter, "image/jpeg");
 489   gtk_file_filter_add_mime_type (filter, "image/png");
 490   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 491
 492   filter = gtk_file_filter_new ();
 493   gtk_file_filter_set_name (filter, "Images");
 494   gtk_file_filter_add_pixbuf_formats (filter);
 495   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 496
 497   /* Preview widget */
 498   /* THIS IS A TERRIBLE PREVIEW WIDGET, AND SHOULD NOT BE COPIED AT ALL.
 499    */
 500   preview_vbox = gtk_vbox_new (0, FALSE);
 501   /*gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), preview_vbox);*/
 502
 503   preview_label = gtk_label_new (NULL);
 504   gtk_box_pack_start (GTK_BOX (preview_vbox), preview_label, TRUE, TRUE, 0);
 505   gtk_misc_set_padding (GTK_MISC (preview_label), 6, 6);
 506
 507   preview_image = gtk_image_new ();
 508   gtk_box_pack_start (GTK_BOX (preview_vbox), preview_image, TRUE, TRUE, 0);
 509   gtk_misc_set_padding (GTK_MISC (preview_image), 6, 6);
 510
 511   update_preview_cb (GTK_FILE_CHOOSER (dialog));
 512   g_signal_connect (dialog, "update-preview",
 513                     G_CALLBACK (update_preview_cb), NULL);
 514
 515   /* Extra widget */
 516
 517   extra = gtk_check_button_new_with_mnemonic ("Lar_t whoever asks about this button");
 518   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (extra), TRUE);
 519   gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), extra);
 520
 521   /* Shortcuts */
 522
 523   gtk_file_chooser_add_shortcut_folder_uri (GTK_FILE_CHOOSER (dialog),
 524                                             "file:///usr/share/pixmaps",
 525                                             NULL);
 526
 527   /* show_all() to reveal bugs in composite widget handling */
 528   gtk_widget_show_all (dialog);
 529
 530   /* Extra controls for manipulating the test environment
 531    */
 532   prop_editor = create_prop_editor (G_OBJECT (dialog), GTK_TYPE_FILE_CHOOSER);
 533
 534   control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 535
 536   vbbox = gtk_vbutton_box_new ();
 537   gtk_container_add (GTK_CONTAINER (control_window), vbbox);
 538
 539   button = gtk_button_new_with_mnemonic ("_Select all");
 540   gtk_widget_set_sensitive (button, multiple);
 541   gtk_container_add (GTK_CONTAINER (vbbox), button);
 542   g_signal_connect_swapped (button, "clicked",
 543                             G_CALLBACK (gtk_file_chooser_select_all), dialog);
 544   g_signal_connect (dialog, "notify::select-multiple",
 545                     G_CALLBACK (notify_multiple_cb), button);
 546
 547   button = gtk_button_new_with_mnemonic ("_Unselect all");
 548   gtk_container_add (GTK_CONTAINER (vbbox), button);
 549   g_signal_connect_swapped (button, "clicked",
 550                             G_CALLBACK (gtk_file_chooser_unselect_all), dialog);
 551
 552   button = gtk_button_new_with_label ("set_current_folder (\"/nonexistent\")");
 553   gtk_container_add (GTK_CONTAINER (vbbox), button);
 554   g_signal_connect (button, "clicked",
 555                     G_CALLBACK (set_folder_nonexistent_cb), dialog);
 556
 557   button = gtk_button_new_with_label ("set_current_folder (\"/usr/nonexistent\")");
 558   gtk_container_add (GTK_CONTAINER (vbbox), button);
 559   g_signal_connect (button, "clicked",
 560                     G_CALLBACK (set_folder_existing_nonexistent_cb), dialog);
 561
 562   button = gtk_button_new_with_label ("set_filename (\"/nonexistent\")");
 563   gtk_container_add (GTK_CONTAINER (vbbox), button);
 564   g_signal_connect (button, "clicked",
 565                     G_CALLBACK (set_filename_nonexistent_cb), dialog);
 566
 567   button = gtk_button_new_with_label ("set_filename (\"/usr/nonexistent\")");
 568   gtk_container_add (GTK_CONTAINER (vbbox), button);
 569   g_signal_connect (button, "clicked",
 570                     G_CALLBACK (set_filename_existing_nonexistent_cb), dialog);
 571
 572   gtk_widget_show_all (control_window);
 573
 574   g_object_ref (control_window);
 575   g_signal_connect (G_OBJECT (dialog), "destroy",
 576                     G_CALLBACK (kill_dependent), control_window);
 577
 578   /* We need to hold a ref until we have destroyed the widgets, just in case
 579    * someone else destroys them.  We explicitly destroy windows to catch leaks.
 580    */
 581   g_object_ref (dialog);
 582   gtk_main ();
 583   gtk_widget_destroy (dialog);
 584   g_object_unref (dialog);
 585
 586   return 0;
 587 }