Pileus Git - ~andy/gtk/blob - gtk/gtkfilechooserdefault.c

   1 /* GTK - The GIMP Toolkit
   2  * gtkfilechooserdefault.c: Default implementation of GtkFileChooser
   3  * Copyright (C) 2003, Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser 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  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "gdk/gdkkeysyms.h"
  22 #include "gtkalignment.h"
  23 #include "gtkbindings.h"
  24 #include "gtkbutton.h"
  25 #include "gtkcellrendererpixbuf.h"
  26 #include "gtkcellrendererseptext.h"
  27 #include "gtkcellrenderertext.h"
  28 #include "gtkcombobox.h"
  29 #include "gtkentry.h"
  30 #include "gtkexpander.h"
  31 #include "gtkfilechooserdefault.h"
  32 #include "gtkfilechooserentry.h"
  33 #include "gtkfilechooserutils.h"
  34 #include "gtkfilechooser.h"
  35 #include "gtkfilesystemmodel.h"
  36 #include "gtkframe.h"
  37 #include "gtkhbox.h"
  38 #include "gtkhpaned.h"
  39 #include "gtkicontheme.h"
  40 #include "gtkimage.h"
  41 #include "gtkintl.h"
  42 #include "gtklabel.h"
  43 #include "gtkmarshalers.h"
  44 #include "gtkmenuitem.h"
  45 #include "gtkmessagedialog.h"
  46 #include "gtkpathbar.h"
  47 #include "gtkprivate.h"
  48 #include "gtkscrolledwindow.h"
  49 #include "gtksizegroup.h"
  50 #include "gtkstock.h"
  51 #include "gtktable.h"
  52 #include "gtktreeview.h"
  53 #include "gtktreemodelsort.h"
  54 #include "gtktreeselection.h"
  55 #include "gtktreestore.h"
  56 #include "gtktypebuiltins.h"
  57 #include "gtkvbox.h"
  58
  59 #if defined (G_OS_UNIX)
  60 #include "gtkfilesystemunix.h"
  61 #elif defined (G_OS_WIN32)
  62 #include "gtkfilesystemwin32.h"
  63 #endif
  64
  65 #include <string.h>
  66 #include <time.h>
  67
  68 typedef struct _GtkFileChooserDefaultClass GtkFileChooserDefaultClass;
  69
  70 #define GTK_FILE_CHOOSER_DEFAULT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_DEFAULT, GtkFileChooserDefaultClass))
  71 #define GTK_IS_FILE_CHOOSER_DEFAULT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_DEFAULT))
  72 #define GTK_FILE_CHOOSER_DEFAULT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_DEFAULT, GtkFileChooserDefaultClass))
  73
  74 struct _GtkFileChooserDefaultClass
  75 {
  76   GtkVBoxClass parent_class;
  77 };
  78
  79 struct _GtkFileChooserDefault
  80 {
  81   GtkVBox parent_instance;
  82
  83   GtkFileChooserAction action;
  84
  85   GtkFileSystem *file_system;
  86
  87   /* Things common to Open and Save mode */
  88
  89   GtkWidget *hpaned;
  90
  91   GtkFileSystemModel *tree_model;
  92   GtkListStore *shortcuts_model;
  93   GtkFileSystemModel *list_model;
  94   GtkTreeModelSort *sort_model;
  95
  96   GtkFileFilter *current_filter;
  97   GSList *filters;
  98
  99   gboolean has_home;
 100   gboolean has_desktop;
 101
 102   int num_volumes;
 103   int num_shortcuts;
 104   int num_bookmarks;
 105
 106   guint volumes_changed_id;
 107   guint bookmarks_changed_id;
 108
 109   GtkFilePath *current_volume_path;
 110   GtkFilePath *current_folder;
 111   GtkFilePath *preview_path;
 112
 113   GtkWidget *new_folder_button;
 114
 115   GtkWidget *preview_frame;
 116
 117   GtkWidget *filter_combo;
 118   GtkWidget *tree_scrollwin;
 119   GtkWidget *tree;
 120   GtkWidget *shortcuts_scrollwin;
 121   GtkWidget *shortcuts_tree;
 122   GtkWidget *add_bookmark_button;
 123   GtkWidget *remove_bookmark_button;
 124   GtkWidget *list_scrollwin;
 125   GtkWidget *list;
 126   GtkWidget *preview_widget;
 127   GtkWidget *extra_widget;
 128   GtkWidget *path_bar;
 129
 130   GtkTreeViewColumn *list_name_column;
 131   GtkCellRenderer *list_name_renderer;
 132
 133   /* Things for Save mode */
 134
 135   GtkWidget *save_widgets;
 136
 137   GtkWidget *entry;
 138   GtkWidget *save_folder_combo;
 139
 140   /* Flags */
 141
 142   guint folder_mode : 1;
 143   guint local_only : 1;
 144   guint preview_widget_active : 1;
 145   guint select_multiple : 1;
 146   guint show_hidden : 1;
 147   guint list_sort_ascending : 1;
 148   guint changing_folder : 1;
 149 };
 150
 151 /* Signal IDs */
 152 enum {
 153   LOCATION_POPUP,
 154   UP_FOLDER,
 155   HOME_FOLDER,
 156   LAST_SIGNAL
 157 };
 158
 159 static guint signals[LAST_SIGNAL] = { 0 };
 160
 161 /* Column numbers for the shortcuts tree.  Keep these in sync with create_shortcuts_model() */
 162 enum {
 163   SHORTCUTS_COL_PIXBUF,
 164   SHORTCUTS_COL_NAME,
 165   SHORTCUTS_COL_PATH,
 166   SHORTCUTS_COL_REMOVABLE,
 167   SHORTCUTS_COL_PIXBUF_VISIBLE,
 168   SHORTCUTS_COL_NUM_COLUMNS
 169 };
 170
 171 /* Column numbers for the file list */
 172 enum {
 173   FILE_LIST_COL_NAME,
 174   FILE_LIST_COL_SIZE,
 175   FILE_LIST_COL_MTIME,
 176   FILE_LIST_COL_NUM_COLUMNS
 177 };
 178
 179 /* Identifiers for target types */
 180 enum {
 181   TEXT_URI_LIST
 182 };
 183
 184 /* Target types for DnD in the shortcuts list */
 185 static GtkTargetEntry shortcuts_targets[] = {
 186   { "text/uri-list", 0, TEXT_URI_LIST }
 187 };
 188
 189 static const int num_shortcuts_targets = sizeof (shortcuts_targets) / sizeof (shortcuts_targets[0]);
 190
 191 /* Interesting places in the shortcuts bar */
 192 typedef enum {
 193   SHORTCUTS_HOME,
 194   SHORTCUTS_DESKTOP,
 195   SHORTCUTS_VOLUMES,
 196   SHORTCUTS_SHORTCUTS,
 197   SHORTCUTS_SEPARATOR,
 198   SHORTCUTS_BOOKMARKS
 199 } ShortcutsIndex;
 200
 201 /* Standard icon size */
 202 /* FIXME: maybe this should correspond to the font size in the tree views... */
 203 #define ICON_SIZE 20
 204
 205 static void gtk_file_chooser_default_class_init   (GtkFileChooserDefaultClass *class);
 206 static void gtk_file_chooser_default_iface_init   (GtkFileChooserIface        *iface);
 207 static void gtk_file_chooser_default_init         (GtkFileChooserDefault      *impl);
 208
 209 static GObject* gtk_file_chooser_default_constructor  (GType                  type,
 210                                                        guint                  n_construct_properties,
 211                                                        GObjectConstructParam *construct_params);
 212 static void     gtk_file_chooser_default_finalize     (GObject               *object);
 213 static void     gtk_file_chooser_default_set_property (GObject               *object,
 214                                                        guint                  prop_id,
 215                                                        const GValue          *value,
 216                                                        GParamSpec            *pspec);
 217 static void     gtk_file_chooser_default_get_property (GObject               *object,
 218                                                        guint                  prop_id,
 219                                                        GValue                *value,
 220                                                        GParamSpec            *pspec);
 221 static void     gtk_file_chooser_default_show_all     (GtkWidget             *widget);
 222
 223 static void           gtk_file_chooser_default_set_current_folder          (GtkFileChooser    *chooser,
 224                                                                             const GtkFilePath *path);
 225 static GtkFilePath *  gtk_file_chooser_default_get_current_folder          (GtkFileChooser    *chooser);
 226 static void           gtk_file_chooser_default_set_current_name            (GtkFileChooser    *chooser,
 227                                                                             const gchar       *name);
 228 static void           gtk_file_chooser_default_select_path                 (GtkFileChooser    *chooser,
 229                                                                             const GtkFilePath *path);
 230 static void           gtk_file_chooser_default_unselect_path               (GtkFileChooser    *chooser,
 231                                                                             const GtkFilePath *path);
 232 static void           gtk_file_chooser_default_select_all                  (GtkFileChooser    *chooser);
 233 static void           gtk_file_chooser_default_unselect_all                (GtkFileChooser    *chooser);
 234 static GSList *       gtk_file_chooser_default_get_paths                   (GtkFileChooser    *chooser);
 235 static GtkFilePath *  gtk_file_chooser_default_get_preview_path            (GtkFileChooser    *chooser);
 236 static GtkFileSystem *gtk_file_chooser_default_get_file_system             (GtkFileChooser    *chooser);
 237 static void           gtk_file_chooser_default_add_filter                  (GtkFileChooser    *chooser,
 238                                                                             GtkFileFilter     *filter);
 239 static void           gtk_file_chooser_default_remove_filter               (GtkFileChooser    *chooser,
 240                                                                             GtkFileFilter     *filter);
 241 static GSList *       gtk_file_chooser_default_list_filters                (GtkFileChooser    *chooser);
 242 static gboolean       gtk_file_chooser_default_add_shortcut_folder    (GtkFileChooser    *chooser,
 243                                                                        const GtkFilePath *path,
 244                                                                        GError           **error);
 245 static gboolean       gtk_file_chooser_default_remove_shortcut_folder (GtkFileChooser    *chooser,
 246                                                                        const GtkFilePath *path,
 247                                                                        GError           **error);
 248 static GSList *       gtk_file_chooser_default_list_shortcut_folders  (GtkFileChooser    *chooser);
 249
 250 static void location_popup_handler (GtkFileChooserDefault *impl);
 251 static void up_folder_handler      (GtkFileChooserDefault *impl);
 252 static void home_folder_handler    (GtkFileChooserDefault *impl);
 253
 254 static void set_current_filter   (GtkFileChooserDefault *impl,
 255                                   GtkFileFilter         *filter);
 256 static void check_preview_change (GtkFileChooserDefault *impl);
 257
 258 static void filter_combo_changed       (GtkComboBox           *combo_box,
 259                                         GtkFileChooserDefault *impl);
 260 static void tree_selection_changed     (GtkTreeSelection      *tree_selection,
 261                                         GtkFileChooserDefault *impl);
 262
 263 static void     shortcuts_row_activated_cb (GtkTreeView           *tree_view,
 264                                             GtkTreePath           *path,
 265                                             GtkTreeViewColumn     *column,
 266                                             GtkFileChooserDefault *impl);
 267 static gboolean shortcuts_select_func   (GtkTreeSelection      *selection,
 268                                          GtkTreeModel          *model,
 269                                          GtkTreePath           *path,
 270                                          gboolean               path_currently_selected,
 271                                          gpointer               data);
 272
 273 static void list_selection_changed     (GtkTreeSelection      *tree_selection,
 274                                         GtkFileChooserDefault *impl);
 275 static void list_row_activated         (GtkTreeView           *tree_view,
 276                                         GtkTreePath           *path,
 277                                         GtkTreeViewColumn     *column,
 278                                         GtkFileChooserDefault *impl);
 279
 280 static void path_bar_clicked           (GtkPathBar            *path_bar,
 281                                         GtkFilePath           *file_path,
 282                                         GtkFileChooserDefault *impl);
 283
 284 static void add_bookmark_button_clicked_cb    (GtkButton             *button,
 285                                                GtkFileChooserDefault *impl);
 286 static void remove_bookmark_button_clicked_cb (GtkButton             *button,
 287                                                GtkFileChooserDefault *impl);
 288
 289 static void tree_name_data_func (GtkTreeViewColumn *tree_column,
 290                                  GtkCellRenderer   *cell,
 291                                  GtkTreeModel      *tree_model,
 292                                  GtkTreeIter       *iter,
 293                                  gpointer           data);
 294 static void list_icon_data_func (GtkTreeViewColumn *tree_column,
 295                                  GtkCellRenderer   *cell,
 296                                  GtkTreeModel      *tree_model,
 297                                  GtkTreeIter       *iter,
 298                                  gpointer           data);
 299 static void list_name_data_func (GtkTreeViewColumn *tree_column,
 300                                  GtkCellRenderer   *cell,
 301                                  GtkTreeModel      *tree_model,
 302                                  GtkTreeIter       *iter,
 303                                  gpointer           data);
 304 #if 0
 305 static void list_size_data_func (GtkTreeViewColumn *tree_column,
 306                                  GtkCellRenderer   *cell,
 307                                  GtkTreeModel      *tree_model,
 308                                  GtkTreeIter       *iter,
 309                                  gpointer           data);
 310 #endif
 311 static void list_mtime_data_func (GtkTreeViewColumn *tree_column,
 312                                   GtkCellRenderer   *cell,
 313                                   GtkTreeModel      *tree_model,
 314                                   GtkTreeIter       *iter,
 315                                   gpointer           data);
 316
 317 static GObjectClass *parent_class;
 318
 319 GType
 320 _gtk_file_chooser_default_get_type (void)
 321 {
 322   static GType file_chooser_default_type = 0;
 323
 324   if (!file_chooser_default_type)
 325     {
 326       static const GTypeInfo file_chooser_default_info =
 327       {
 328         sizeof (GtkFileChooserDefaultClass),
 329         NULL,           /* base_init */
 330         NULL,           /* base_finalize */
 331         (GClassInitFunc) gtk_file_chooser_default_class_init,
 332         NULL,           /* class_finalize */
 333         NULL,           /* class_data */
 334         sizeof (GtkFileChooserDefault),
 335         0,              /* n_preallocs */
 336         (GInstanceInitFunc) gtk_file_chooser_default_init,
 337       };
 338
 339       static const GInterfaceInfo file_chooser_info =
 340       {
 341         (GInterfaceInitFunc) gtk_file_chooser_default_iface_init, /* interface_init */
 342         NULL,                                                          /* interface_finalize */
 343         NULL                                                           /* interface_data */
 344       };
 345
 346       file_chooser_default_type = g_type_register_static (GTK_TYPE_VBOX, "GtkFileChooserDefault",
 347                                                          &file_chooser_default_info, 0);
 348       g_type_add_interface_static (file_chooser_default_type,
 349                                    GTK_TYPE_FILE_CHOOSER,
 350                                    &file_chooser_info);
 351     }
 352
 353   return file_chooser_default_type;
 354 }
 355
 356 static void
 357 gtk_file_chooser_default_class_init (GtkFileChooserDefaultClass *class)
 358 {
 359   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 360   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 361   GtkBindingSet *binding_set;
 362
 363   parent_class = g_type_class_peek_parent (class);
 364
 365   gobject_class->finalize = gtk_file_chooser_default_finalize;
 366   gobject_class->constructor = gtk_file_chooser_default_constructor;
 367   gobject_class->set_property = gtk_file_chooser_default_set_property;
 368   gobject_class->get_property = gtk_file_chooser_default_get_property;
 369
 370   widget_class->show_all = gtk_file_chooser_default_show_all;
 371
 372   signals[LOCATION_POPUP] =
 373     _gtk_binding_signal_new ("location-popup",
 374                              G_OBJECT_CLASS_TYPE (class),
 375                              G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 376                              G_CALLBACK (location_popup_handler),
 377                              NULL, NULL,
 378                              _gtk_marshal_VOID__VOID,
 379                              G_TYPE_NONE, 0);
 380   signals[UP_FOLDER] =
 381     _gtk_binding_signal_new ("up-folder",
 382                              G_OBJECT_CLASS_TYPE (class),
 383                              G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 384                              G_CALLBACK (up_folder_handler),
 385                              NULL, NULL,
 386                              _gtk_marshal_VOID__VOID,
 387                              G_TYPE_NONE, 0);
 388   signals[HOME_FOLDER] =
 389     _gtk_binding_signal_new ("home-folder",
 390                              G_OBJECT_CLASS_TYPE (class),
 391                              G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 392                              G_CALLBACK (home_folder_handler),
 393                              NULL, NULL,
 394                              _gtk_marshal_VOID__VOID,
 395                              G_TYPE_NONE, 0);
 396
 397   binding_set = gtk_binding_set_by_class (class);
 398
 399   gtk_binding_entry_add_signal (binding_set,
 400                                 GDK_l, GDK_CONTROL_MASK,
 401                                 "location-popup",
 402                                 0);
 403
 404   gtk_binding_entry_add_signal (binding_set,
 405                                 GDK_Up, GDK_MOD1_MASK,
 406                                 "up-folder",
 407                                 0);
 408   gtk_binding_entry_add_signal (binding_set,
 409                                 GDK_KP_Up, GDK_MOD1_MASK,
 410                                 "up-folder",
 411                                 0);
 412
 413   gtk_binding_entry_add_signal (binding_set,
 414                                 GDK_Home, GDK_MOD1_MASK,
 415                                 "home-folder",
 416                                 0);
 417   gtk_binding_entry_add_signal (binding_set,
 418                                 GDK_KP_Home, GDK_MOD1_MASK,
 419                                 "home-folder",
 420                                 0);
 421
 422   _gtk_file_chooser_install_properties (gobject_class);
 423 }
 424
 425 static void
 426 gtk_file_chooser_default_iface_init (GtkFileChooserIface *iface)
 427 {
 428   iface->select_path = gtk_file_chooser_default_select_path;
 429   iface->unselect_path = gtk_file_chooser_default_unselect_path;
 430   iface->select_all = gtk_file_chooser_default_select_all;
 431   iface->unselect_all = gtk_file_chooser_default_unselect_all;
 432   iface->get_paths = gtk_file_chooser_default_get_paths;
 433   iface->get_preview_path = gtk_file_chooser_default_get_preview_path;
 434   iface->get_file_system = gtk_file_chooser_default_get_file_system;
 435   iface->set_current_folder = gtk_file_chooser_default_set_current_folder;
 436   iface->get_current_folder = gtk_file_chooser_default_get_current_folder;
 437   iface->set_current_name = gtk_file_chooser_default_set_current_name;
 438   iface->add_filter = gtk_file_chooser_default_add_filter;
 439   iface->remove_filter = gtk_file_chooser_default_remove_filter;
 440   iface->list_filters = gtk_file_chooser_default_list_filters;
 441   iface->add_shortcut_folder = gtk_file_chooser_default_add_shortcut_folder;
 442   iface->remove_shortcut_folder = gtk_file_chooser_default_remove_shortcut_folder;
 443   iface->list_shortcut_folders = gtk_file_chooser_default_list_shortcut_folders;
 444 }
 445
 446 static void
 447 gtk_file_chooser_default_init (GtkFileChooserDefault *impl)
 448 {
 449   impl->folder_mode = FALSE;
 450   impl->local_only = TRUE;
 451   impl->preview_widget_active = TRUE;
 452   impl->select_multiple = FALSE;
 453   impl->show_hidden = FALSE;
 454
 455   gtk_box_set_spacing (GTK_BOX (impl), 12);
 456 }
 457
 458 static void
 459 gtk_file_chooser_default_finalize (GObject *object)
 460 {
 461   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (object);
 462   GSList *l;
 463
 464   g_signal_handler_disconnect (impl->file_system, impl->volumes_changed_id);
 465   impl->volumes_changed_id = 0;
 466   g_signal_handler_disconnect (impl->file_system, impl->bookmarks_changed_id);
 467   impl->bookmarks_changed_id = 0;
 468   g_object_unref (impl->file_system);
 469
 470   for (l = impl->filters; l; l = l->next)
 471     {
 472       GtkFileFilter *filter;
 473
 474       filter = GTK_FILE_FILTER (l->data);
 475       g_object_unref (filter);
 476     }
 477   g_slist_free (impl->filters);
 478
 479   if (impl->current_filter)
 480     g_object_unref (impl->current_filter);
 481
 482   if (impl->current_volume_path)
 483     gtk_file_path_free (impl->current_volume_path);
 484
 485   if (impl->current_folder)
 486     gtk_file_path_free (impl->current_folder);
 487
 488   if (impl->preview_path)
 489     gtk_file_path_free (impl->preview_path);
 490
 491   G_OBJECT_CLASS (parent_class)->finalize (object);
 492 }
 493
 494 /* Shows an error dialog set as transient for the specified window */
 495 static void
 496 error_message_with_parent (GtkWindow  *parent,
 497                            const char *msg)
 498 {
 499   GtkWidget *dialog;
 500
 501   dialog = gtk_message_dialog_new (parent,
 502                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 503                                    GTK_MESSAGE_ERROR,
 504                                    GTK_BUTTONS_CLOSE,
 505                                    "%s",
 506                                    msg);
 507   gtk_dialog_run (GTK_DIALOG (dialog));
 508   gtk_widget_destroy (dialog);
 509 }
 510
 511 /* Shows an error dialog for the file chooser */
 512 static void
 513 error_message (GtkFileChooserDefault *impl,
 514                const char            *msg)
 515 {
 516   GtkWidget *toplevel;
 517
 518   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
 519   if (!GTK_WIDGET_TOPLEVEL (toplevel))
 520     toplevel = NULL;
 521
 522   error_message_with_parent (toplevel ? GTK_WINDOW (toplevel) : NULL,
 523                              msg);
 524 }
 525
 526 /* Shows a simple error dialog relative to a path.  Frees the GError as well. */
 527 static void
 528 error_dialog (GtkFileChooserDefault *impl,
 529               const char            *msg,
 530               const GtkFilePath     *path,
 531               GError                *error)
 532 {
 533   char *text;
 534
 535   text = g_strdup_printf (msg,
 536                           gtk_file_path_get_string (path),
 537                           error->message);
 538   error_message (impl, text);
 539   g_free (text);
 540   g_error_free (error);
 541 }
 542
 543 /* Displays an error message about not being able to get information for a file.
 544  * Frees the GError as well.
 545  */
 546 static void
 547 error_getting_info_dialog (GtkFileChooserDefault *impl,
 548                            const GtkFilePath     *path,
 549                            GError                *error)
 550 {
 551   error_dialog (impl,
 552                 _("Could not retrieve information about %s:\n%s"),
 553                 path, error);
 554 }
 555
 556 /* Shows an error dialog about not being able to add a bookmark */
 557 static void
 558 error_could_not_add_bookmark_dialog (GtkFileChooserDefault *impl,
 559                                      const GtkFilePath     *path,
 560                                      GError                *error)
 561 {
 562   error_dialog (impl,
 563                 _("Could not add a bookmark for %s:\n%s"),
 564                 path, error);
 565 }
 566
 567 /* Shows an error dialog about not being able to compose a filename */
 568 static void
 569 error_building_filename_dialog (GtkFileChooserDefault *impl,
 570                                 const GtkFilePath     *base_path,
 571                                 const char            *file_part,
 572                                 GError                *error)
 573 {
 574   char *msg;
 575
 576   msg = g_strdup_printf (_("Could not build file name from '%s' and '%s':\n%s"),
 577                          gtk_file_path_get_string (base_path),
 578                          file_part,
 579                          error->message);
 580   error_message (impl, msg);
 581   g_free (msg);
 582   g_error_free (error);
 583 }
 584
 585 static void
 586 update_preview_widget_visibility (GtkFileChooserDefault *impl)
 587 {
 588   if (impl->preview_widget_active && impl->preview_widget)
 589     gtk_widget_show (impl->preview_frame);
 590   else
 591     gtk_widget_hide (impl->preview_frame);
 592 }
 593
 594 static void
 595 set_preview_widget (GtkFileChooserDefault *impl,
 596                     GtkWidget             *preview_widget)
 597 {
 598   if (preview_widget == impl->preview_widget)
 599     return;
 600
 601   if (impl->preview_widget)
 602     gtk_container_remove (GTK_CONTAINER (impl->preview_frame),
 603                           impl->preview_widget);
 604
 605   impl->preview_widget = preview_widget;
 606   if (impl->preview_widget)
 607     {
 608       gtk_widget_show_all (impl->preview_widget);
 609       gtk_container_add (GTK_CONTAINER (impl->preview_frame),
 610                          impl->preview_widget);
 611     }
 612
 613   update_preview_widget_visibility (impl);
 614 }
 615
 616 /* Clears the selection in the shortcuts tree */
 617 static void
 618 shortcuts_unselect_all (GtkFileChooserDefault *impl)
 619 {
 620   GtkTreeSelection *selection;
 621
 622   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->shortcuts_tree));
 623   gtk_tree_selection_unselect_all (selection);
 624 }
 625
 626 /* Convenience function to get the display name and icon info for a path */
 627 static GtkFileInfo *
 628 get_file_info (GtkFileSystem *file_system, const GtkFilePath *path, GError **error)
 629 {
 630   GtkFilePath *parent_path;
 631   GtkFileFolder *parent_folder;
 632   GtkFileInfo *info;
 633
 634   if (!gtk_file_system_get_parent (file_system, path, &parent_path, error))
 635     return NULL;
 636
 637   parent_folder = gtk_file_system_get_folder (file_system, parent_path,
 638                                               GTK_FILE_INFO_DISPLAY_NAME
 639 #if 0
 640                                               | GTK_FILE_INFO_ICON
 641 #endif
 642                                               | GTK_FILE_INFO_IS_FOLDER,
 643                                               error);
 644   gtk_file_path_free (parent_path);
 645
 646   if (!parent_folder)
 647     return NULL;
 648
 649   info = gtk_file_folder_get_info (parent_folder, path, error);
 650   g_object_unref (parent_folder);
 651
 652   return info;
 653 }
 654
 655 /* Inserts a path in the shortcuts tree, making a copy of it; alternatively,
 656  * inserts a volume.  A position of -1 indicates the end of the tree.
 657  */
 658 static gboolean
 659 shortcuts_insert_path (GtkFileChooserDefault *impl,
 660                        int                    pos,
 661                        gboolean               is_volume,
 662                        GtkFileSystemVolume   *volume,
 663                        const GtkFilePath     *path,
 664                        const char            *label,
 665                        gboolean               removable,
 666                        GError               **error)
 667 {
 668   char *label_copy;
 669   GdkPixbuf *pixbuf;
 670   gpointer data;
 671   GtkTreeIter iter;
 672
 673   if (is_volume)
 674     {
 675       data = volume;
 676       label_copy = gtk_file_system_volume_get_display_name (impl->file_system, volume);
 677       pixbuf = gtk_file_system_volume_render_icon (impl->file_system,
 678                                                    volume,
 679                                                    GTK_WIDGET (impl),
 680                                                    ICON_SIZE,
 681                                                    NULL);
 682     }
 683   else
 684     {
 685       GtkFileInfo *info;
 686
 687       info = get_file_info (impl->file_system, path, error);
 688       if (!info)
 689         return FALSE;
 690
 691       data = gtk_file_path_copy (path);
 692
 693       if (label)
 694         label_copy = g_strdup (label);
 695       else
 696         label_copy = g_strdup (gtk_file_info_get_display_name (info));
 697
 698       pixbuf = gtk_file_system_render_icon (impl->file_system, path, GTK_WIDGET (impl), ICON_SIZE, NULL);
 699
 700       gtk_file_info_free (info);
 701     }
 702
 703   if (pos == -1)
 704     gtk_list_store_append (impl->shortcuts_model, &iter);
 705   else
 706     gtk_list_store_insert (impl->shortcuts_model, &iter, pos);
 707
 708   gtk_list_store_set (impl->shortcuts_model, &iter,
 709                       SHORTCUTS_COL_PIXBUF, pixbuf,
 710                       SHORTCUTS_COL_PIXBUF_VISIBLE, TRUE,
 711                       SHORTCUTS_COL_NAME, label_copy,
 712                       SHORTCUTS_COL_PATH, data,
 713                       SHORTCUTS_COL_REMOVABLE, removable,
 714                       -1);
 715
 716   g_free (label_copy);
 717
 718   if (pixbuf)
 719     g_object_unref (pixbuf);
 720
 721   return TRUE;
 722 }
 723
 724 /* Appends an item for the user's home directory to the shortcuts model */
 725 static void
 726 shortcuts_append_home (GtkFileChooserDefault *impl)
 727 {
 728   const char *home;
 729   GtkFilePath *home_path;
 730   GError *error;
 731
 732   home = g_get_home_dir ();
 733   home_path = gtk_file_system_filename_to_path (impl->file_system, home);
 734
 735   error = NULL;
 736   impl->has_home = shortcuts_insert_path (impl, -1, FALSE, NULL, home_path, _("Home"), FALSE, &error);
 737   if (!impl->has_home)
 738     error_getting_info_dialog (impl, home_path, error);
 739
 740   gtk_file_path_free (home_path);
 741 }
 742
 743 /* Appends the ~/Desktop directory to the shortcuts model */
 744 static void
 745 shortcuts_append_desktop (GtkFileChooserDefault *impl)
 746 {
 747   char *name;
 748   GtkFilePath *path;
 749
 750   name = g_build_filename (g_get_home_dir (), "Desktop", NULL);
 751   path = gtk_file_system_filename_to_path (impl->file_system, name);
 752   g_free (name);
 753
 754   impl->has_desktop = shortcuts_insert_path (impl, -1, FALSE, NULL, path, NULL, FALSE, NULL);
 755   /* We do not actually pop up an error dialog if there is no desktop directory
 756    * because some people may really not want to have one.
 757    */
 758
 759   gtk_file_path_free (path);
 760 }
 761
 762 /* Appends a list of GtkFilePath to the shortcuts model; returns how many were inserted */
 763 static int
 764 shortcuts_append_paths (GtkFileChooserDefault *impl,
 765                         GSList                *paths)
 766 {
 767   int num_inserted;
 768
 769   num_inserted = 0;
 770
 771   for (; paths; paths = paths->next)
 772     {
 773       GtkFilePath *path;
 774       GError *error;
 775
 776       path = paths->data;
 777       error = NULL;
 778
 779       /* NULL GError, but we don't really want to show error boxes here */
 780
 781       if (shortcuts_insert_path (impl, -1, FALSE, NULL, path, NULL, TRUE, NULL))
 782         num_inserted++;
 783     }
 784
 785   return num_inserted;
 786 }
 787
 788 /* Returns the index for the corresponding item in the shortcuts bar */
 789 static int
 790 shortcuts_get_index (GtkFileChooserDefault *impl,
 791                      ShortcutsIndex         where)
 792 {
 793   int n;
 794
 795   n = 0;
 796
 797   if (where == SHORTCUTS_HOME)
 798     goto out;
 799
 800   n += impl->has_home ? 1 : 0;
 801
 802   if (where == SHORTCUTS_DESKTOP)
 803     goto out;
 804
 805   n += impl->has_desktop ? 1 : 0;
 806
 807   if (where == SHORTCUTS_VOLUMES)
 808     goto out;
 809
 810   n += impl->num_volumes;
 811
 812   if (where == SHORTCUTS_SHORTCUTS)
 813     goto out;
 814
 815   n += impl->num_shortcuts;
 816
 817   if (where == SHORTCUTS_SEPARATOR)
 818     goto out;
 819
 820   n += 1;
 821
 822   if (where == SHORTCUTS_BOOKMARKS)
 823     goto out;
 824
 825   g_assert_not_reached ();
 826
 827  out:
 828
 829   return n;
 830 }
 831
 832 typedef void (* RemoveFunc) (GtkFileChooserDefault *impl, gpointer data);
 833
 834 /* Removes the specified number of rows from the shortcuts list */
 835 static void
 836 shortcuts_remove_rows (GtkFileChooserDefault *impl,
 837                        int start_row,
 838                        int n_rows,
 839                        RemoveFunc remove_fn)
 840 {
 841   GtkTreePath *path;
 842
 843   path = gtk_tree_path_new_from_indices (start_row, -1);
 844
 845   for (; n_rows; n_rows--)
 846     {
 847       GtkTreeIter iter;
 848       gpointer data;
 849
 850       if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->shortcuts_model), &iter, path))
 851         g_assert_not_reached ();
 852
 853       if (remove_fn)
 854         {
 855           gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter, SHORTCUTS_COL_PATH, &data, -1);
 856           (* remove_fn) (impl, data);
 857         }
 858
 859       gtk_list_store_remove (impl->shortcuts_model, &iter);
 860     }
 861
 862   gtk_tree_path_free (path);
 863 }
 864
 865 /* Used from shortcuts_remove_rows() */
 866 static void
 867 volume_remove_cb (GtkFileChooserDefault *impl, gpointer data)
 868 {
 869   GtkFileSystemVolume *volume;
 870
 871   volume = data;
 872   gtk_file_system_volume_free (impl->file_system, volume);
 873 }
 874
 875 /* Adds all the file system volumes to the shortcuts model */
 876 static void
 877 shortcuts_add_volumes (GtkFileChooserDefault *impl)
 878 {
 879   int start_row;
 880   GSList *list, *l;
 881   int n;
 882
 883   start_row = shortcuts_get_index (impl, SHORTCUTS_VOLUMES);
 884   shortcuts_remove_rows (impl, start_row, impl->num_volumes, volume_remove_cb);
 885   impl->num_volumes = 0;
 886
 887   list = gtk_file_system_list_volumes (impl->file_system);
 888
 889   n = 0;
 890
 891   for (l = list; l; l = l->next)
 892     {
 893       GtkFileSystemVolume *volume;
 894
 895       volume = l->data;
 896
 897       shortcuts_insert_path (impl, start_row + n, TRUE, volume, NULL, NULL, FALSE, NULL);
 898       n++;
 899     }
 900
 901   impl->num_volumes = n;
 902
 903   g_slist_free (list);
 904 }
 905
 906 /* Used from shortcuts_remove_rows() */
 907 static void
 908 remove_bookmark_cb (GtkFileChooserDefault *impl, gpointer data)
 909 {
 910   GtkFilePath *path;
 911
 912   path = data;
 913   gtk_file_path_free (path);
 914 }
 915
 916 /* Updates the list of bookmarks */
 917 static void
 918 shortcuts_add_bookmarks (GtkFileChooserDefault *impl)
 919 {
 920   GSList *bookmarks;
 921
 922   shortcuts_remove_rows (impl,
 923                          shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS),
 924                          impl->num_bookmarks,
 925                          remove_bookmark_cb);
 926
 927   bookmarks = gtk_file_system_list_bookmarks (impl->file_system);
 928   impl->num_bookmarks = shortcuts_append_paths (impl, bookmarks);
 929   gtk_file_paths_free (bookmarks);
 930 }
 931
 932 /* Appends the bookmarks separator node and the bookmarks from the file system. */
 933 static void
 934 shortcuts_append_bookmarks (GtkFileChooserDefault *impl)
 935 {
 936   GtkTreeIter iter;
 937
 938   gtk_list_store_append (impl->shortcuts_model, &iter);
 939   gtk_list_store_set (impl->shortcuts_model, &iter,
 940                       SHORTCUTS_COL_PIXBUF, NULL,
 941                       SHORTCUTS_COL_PIXBUF_VISIBLE, FALSE,
 942                       SHORTCUTS_COL_NAME, NULL,
 943                       SHORTCUTS_COL_PATH, NULL,
 944                       -1);
 945   shortcuts_add_bookmarks (impl);
 946 }
 947
 948 /* Creates the GtkTreeStore used as the shortcuts model */
 949 static void
 950 create_shortcuts_model (GtkFileChooserDefault *impl)
 951 {
 952   if (impl->shortcuts_model)
 953     g_object_unref (impl->shortcuts_model);
 954
 955   /* Keep this order in sync with the SHORCUTS_COL_* enum values */
 956   impl->shortcuts_model = gtk_list_store_new (SHORTCUTS_COL_NUM_COLUMNS,
 957                                               GDK_TYPE_PIXBUF,  /* pixbuf */
 958                                               G_TYPE_STRING,    /* name */
 959                                               G_TYPE_POINTER,   /* path or volume */
 960                                               G_TYPE_BOOLEAN,   /* removable */
 961                                               G_TYPE_BOOLEAN);  /* pixbuf cell visibility */
 962
 963   if (impl->file_system)
 964     {
 965       shortcuts_append_home (impl);
 966       shortcuts_append_desktop (impl);
 967       shortcuts_add_volumes (impl);
 968       shortcuts_append_bookmarks (impl);
 969     }
 970
 971   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->shortcuts_tree), GTK_TREE_MODEL (impl->shortcuts_model));
 972 }
 973
 974 /* Callback used when the "New Folder" toolbar button is clicked */
 975 static void
 976 new_folder_button_clicked (GtkButton             *button,
 977                            GtkFileChooserDefault *impl)
 978 {
 979   GtkTreeIter iter;
 980   GtkTreePath *path;
 981
 982   /* FIXME: this doesn't work for folder mode, just for file mode */
 983
 984   _gtk_file_system_model_add_editable (impl->list_model, &iter);
 985   g_object_set (impl->list_name_renderer, "editable", TRUE, NULL);
 986
 987   path = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->list_model), &iter);
 988   gtk_tree_view_set_cursor (GTK_TREE_VIEW (impl->list),
 989                             path,
 990                             impl->list_name_column,
 991                             TRUE);
 992 }
 993
 994 /* Callback used from the text cell renderer when the new folder is named */
 995 static void
 996 renderer_edited_cb (GtkCellRendererText   *cell_renderer_text,
 997                     const gchar           *path,
 998                     const gchar           *new_text,
 999                     GtkFileChooserDefault *impl)
1000 {
1001   GError *error;
1002   GtkFilePath *file_path;
1003
1004   _gtk_file_system_model_remove_editable (impl->list_model);
1005   g_object_set (impl->list_name_renderer, "editable", FALSE, NULL);
1006
1007   error = NULL;
1008   file_path = gtk_file_system_make_path (impl->file_system, impl->current_folder, new_text, &error);
1009   if (!file_path)
1010     {
1011       error_building_filename_dialog (impl, impl->current_folder, new_text, error);
1012       return;
1013     }
1014
1015   error = NULL;
1016   if (!gtk_file_system_create_folder (impl->file_system, file_path, &error))
1017     error_dialog (impl,
1018                   _("Could not create folder %s:\n%s"),
1019                   file_path, error);
1020
1021   gtk_file_path_free (file_path);
1022
1023   /* FIXME: scroll to the new folder and select it */
1024 }
1025
1026 /* Callback used from the text cell renderer when the new folder edition gets
1027  * canceled.
1028  */
1029 static void
1030 renderer_editing_canceled_cb (GtkCellRendererText   *cell_renderer_text,
1031                               GtkFileChooserDefault *impl)
1032 {
1033   _gtk_file_system_model_remove_editable (impl->list_model);
1034   g_object_set (impl->list_name_renderer, "editable", FALSE, NULL);
1035 }
1036
1037 /* Creates the widgets for the filter combo box */
1038 static GtkWidget *
1039 filter_create (GtkFileChooserDefault *impl)
1040 {
1041   impl->filter_combo = gtk_combo_box_new_text ();
1042   g_signal_connect (impl->filter_combo, "changed",
1043                     G_CALLBACK (filter_combo_changed), impl);
1044
1045   return impl->filter_combo;
1046 }
1047
1048 static GtkWidget *
1049 button_new (GtkFileChooserDefault *impl,
1050             const char *text,
1051             const char *stock_id,
1052             gboolean    sensitive,
1053             gboolean    show,
1054             GCallback   callback)
1055 {
1056   GtkWidget *button;
1057   GtkWidget *hbox;
1058   GtkWidget *widget;
1059   GtkWidget *align;
1060
1061   button = gtk_button_new ();
1062   hbox = gtk_hbox_new (FALSE, 2);
1063   align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
1064
1065   gtk_container_add (GTK_CONTAINER (button), align);
1066   gtk_container_add (GTK_CONTAINER (align), hbox);
1067   widget = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
1068
1069   gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1070
1071   widget = gtk_label_new_with_mnemonic (text);
1072   gtk_label_set_mnemonic_widget (GTK_LABEL (widget), GTK_WIDGET (button));
1073   gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1074
1075   gtk_widget_set_sensitive (button, sensitive);
1076   g_signal_connect (button, "clicked", callback, impl);
1077
1078   gtk_widget_show_all (align);
1079
1080   if (show)
1081     gtk_widget_show (button);
1082
1083   return button;
1084 }
1085
1086 /* Creates the widgets for the folder tree */
1087 static GtkWidget *
1088 create_folder_tree (GtkFileChooserDefault *impl)
1089 {
1090   GtkTreeSelection *selection;
1091
1092   /* Scrolled window */
1093
1094   impl->tree_scrollwin = gtk_scrolled_window_new (NULL, NULL);
1095   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (impl->tree_scrollwin),
1096                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1097   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (impl->tree_scrollwin),
1098                                        GTK_SHADOW_IN);
1099   if (impl->folder_mode)
1100     gtk_widget_show (impl->tree_scrollwin);
1101
1102   /* Tree */
1103
1104   impl->tree = gtk_tree_view_new ();
1105   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (impl->tree), FALSE);
1106
1107   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->tree));
1108   g_signal_connect (selection, "changed",
1109                     G_CALLBACK (tree_selection_changed), impl);
1110
1111   gtk_container_add (GTK_CONTAINER (impl->tree_scrollwin), impl->tree);
1112   gtk_widget_show (impl->tree);
1113
1114   /* Column */
1115
1116   gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (impl->tree), 0,
1117                                               _("File name"),
1118                                               gtk_cell_renderer_text_new (),
1119                                               tree_name_data_func, impl, NULL);
1120   gtk_tree_view_set_search_column (GTK_TREE_VIEW (impl->tree),
1121                                    GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME);
1122
1123   return impl->tree_scrollwin;
1124 }
1125
1126 /* Tries to add a bookmark from a path name */
1127 static void
1128 shortcuts_add_bookmark_from_path (GtkFileChooserDefault *impl,
1129                                   const GtkFilePath     *path)
1130 {
1131   GtkFileInfo *info;
1132   GError *error;
1133
1134   error = NULL;
1135   info = get_file_info (impl->file_system, path, &error);
1136
1137   if (!info)
1138     error_getting_info_dialog (impl, path, error);
1139   else if (!gtk_file_info_get_is_folder (info))
1140     {
1141       char *msg;
1142
1143       msg = g_strdup_printf (_("Could not add bookmark for %s because it is not a folder."),
1144                              gtk_file_path_get_string (path));
1145       error_message (impl, msg);
1146       g_free (msg);
1147     }
1148   else
1149     {
1150       error = NULL;
1151       if (!gtk_file_system_add_bookmark (impl->file_system, path, &error))
1152         error_could_not_add_bookmark_dialog (impl, path, error);
1153     }
1154 }
1155
1156 /* Callback used when the "Add bookmark" button is clicked */
1157 static void
1158 add_bookmark_button_clicked_cb (GtkButton *button,
1159                                 GtkFileChooserDefault *impl)
1160 {
1161   shortcuts_add_bookmark_from_path (impl, impl->current_folder);
1162 }
1163
1164 /* Callback used when the "Remove bookmark" button is clicked */
1165 static void
1166 remove_bookmark_button_clicked_cb (GtkButton *button,
1167                                    GtkFileChooserDefault *impl)
1168 {
1169   GtkTreeSelection *selection;
1170   GtkTreeIter iter;
1171   GtkFilePath *path;
1172   gboolean removable;
1173   GError *error;
1174
1175   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->shortcuts_tree));
1176
1177   if (gtk_tree_selection_get_selected (selection, NULL, &iter))
1178     {
1179       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
1180                           SHORTCUTS_COL_PATH, &path,
1181                           SHORTCUTS_COL_REMOVABLE, &removable, -1);
1182       if (!removable)
1183         {
1184           g_assert_not_reached ();
1185           return;
1186         }
1187
1188       error = NULL;
1189       if (!gtk_file_system_remove_bookmark (impl->file_system, path, &error))
1190         error_dialog (impl,
1191                       _("Could not remove bookmark for %s:\n%s"),
1192                       path,
1193                       error);
1194     }
1195 }
1196
1197 /* Sensitize the "add bookmark" button if the current folder is not in the
1198  * bookmarks list, or de-sensitize it otherwise.
1199  */
1200 static void
1201 bookmarks_check_add_sensitivity (GtkFileChooserDefault *impl)
1202 {
1203   GtkTreeIter iter;
1204   gboolean exists;
1205   int volumes_idx;
1206   int separator_idx;
1207
1208   exists = FALSE;
1209
1210   if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
1211     {
1212       int i;
1213
1214       separator_idx = shortcuts_get_index (impl, SHORTCUTS_SEPARATOR);
1215       volumes_idx = shortcuts_get_index (impl, SHORTCUTS_VOLUMES);
1216
1217       i = 0;
1218
1219       do
1220         {
1221           gpointer data;
1222
1223           if (i == separator_idx)
1224             continue;
1225
1226           gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter, SHORTCUTS_COL_PATH, &data, -1);
1227
1228           if (i >= volumes_idx && i < volumes_idx + impl->num_volumes)
1229             {
1230               GtkFileSystemVolume *volume;
1231               GtkFilePath *base_path;
1232
1233               volume = data;
1234               base_path = gtk_file_system_volume_get_base_path (impl->file_system, volume);
1235
1236               exists = strcmp (gtk_file_path_get_string (impl->current_folder),
1237                                gtk_file_path_get_string (base_path)) == 0;
1238               g_free (base_path);
1239
1240               if (exists)
1241                 break;
1242             }
1243           else
1244             {
1245               GtkFilePath *path;
1246
1247               path = data;
1248
1249               if (path && gtk_file_path_compare (path, impl->current_folder) == 0)
1250                 {
1251                   exists = TRUE;
1252                   break;
1253                 }
1254             }
1255         }
1256       while (gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter));
1257     }
1258
1259   gtk_widget_set_sensitive (impl->add_bookmark_button, !exists);
1260 }
1261
1262 /* Sets the sensitivity of the "remove bookmark" button depending on whether a
1263  * bookmark row is selected in the shortcuts tree.
1264  */
1265 static void
1266 bookmarks_check_remove_sensitivity (GtkFileChooserDefault *impl)
1267 {
1268   GtkTreeSelection *selection;
1269   GtkTreeIter iter;
1270   gboolean removable = FALSE;
1271
1272   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->shortcuts_tree));
1273
1274   if (gtk_tree_selection_get_selected (selection, NULL, &iter))
1275     gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
1276                         SHORTCUTS_COL_REMOVABLE, &removable,
1277                         -1);
1278
1279   gtk_widget_set_sensitive (impl->remove_bookmark_button, removable);
1280 }
1281
1282 /* Converts raw selection data from text/uri-list to a list of strings */
1283 static GSList *
1284 split_uris (const char *data)
1285 {
1286   GSList *uris;
1287   const char *p, *start;
1288
1289   uris = NULL;
1290
1291   start = data;
1292
1293   for (p = start; *p != 0; p++)
1294     if (*p == '\r' && *(p + 1) == '\n')
1295       {
1296         char *name;
1297
1298         name = g_strndup (start, p - start);
1299         uris = g_slist_prepend (uris, name);
1300
1301         start = p + 2;
1302         p = start;
1303       }
1304
1305   uris = g_slist_reverse (uris);
1306   return uris;
1307 }
1308
1309 /* Callback used when we get the drag data for the bookmarks list.  We add the
1310  * received URIs as bookmarks if they are folders.
1311  */
1312 static void
1313 shortcuts_drag_data_received_cb (GtkWidget          *widget,
1314                                  GdkDragContext     *context,
1315                                  gint                x,
1316                                  gint                y,
1317                                  GtkSelectionData   *selection_data,
1318                                  guint               info,
1319                                  guint               time_,
1320                                  gpointer            data)
1321 {
1322   GtkFileChooserDefault *impl;
1323   GSList *uris, *l;
1324
1325   impl = GTK_FILE_CHOOSER_DEFAULT (data);
1326
1327   uris = split_uris (selection_data->data);
1328
1329   for (l = uris; l; l = l->next)
1330     {
1331       char *uri;
1332       GtkFilePath *path;
1333
1334       uri = l->data;
1335       path = gtk_file_system_uri_to_path (impl->file_system, uri);
1336
1337       if (path)
1338         {
1339           shortcuts_add_bookmark_from_path (impl, path);
1340           gtk_file_path_free (path);
1341         }
1342       else
1343         {
1344           char *msg;
1345
1346           msg = g_strdup_printf (_("Could not add a bookmark for %s because it is an invalid path name."),
1347                                  uri);
1348           error_message (impl, msg);
1349           g_free (msg);
1350         }
1351
1352       g_free (uri);
1353     }
1354
1355   g_slist_free (uris);
1356 }
1357
1358 /* Callback used when the selection in the shortcuts tree changes */
1359 static void
1360 shortcuts_selection_changed_cb (GtkTreeSelection      *selection,
1361                                 GtkFileChooserDefault *impl)
1362 {
1363   bookmarks_check_remove_sensitivity (impl);
1364 }
1365
1366 /* Creates the widgets for the shortcuts and bookmarks tree */
1367 static GtkWidget *
1368 shortcuts_tree_create (GtkFileChooserDefault *impl)
1369 {
1370   GtkTreeSelection *selection;
1371   GtkTreeViewColumn *column;
1372   GtkCellRenderer *renderer;
1373
1374   /* Scrolled window */
1375
1376   impl->shortcuts_scrollwin = gtk_scrolled_window_new (NULL, NULL);
1377   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (impl->shortcuts_scrollwin),
1378                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1379   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (impl->shortcuts_scrollwin),
1380                                        GTK_SHADOW_IN);
1381   gtk_widget_show (impl->shortcuts_scrollwin);
1382
1383   /* Tree */
1384
1385   impl->shortcuts_tree = gtk_tree_view_new ();
1386   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (impl->shortcuts_tree), FALSE);
1387
1388   gtk_drag_dest_set (impl->shortcuts_tree,
1389                      GTK_DEST_DEFAULT_ALL,
1390                      shortcuts_targets,
1391                      num_shortcuts_targets,
1392                      GDK_ACTION_COPY);
1393
1394   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->shortcuts_tree));
1395   gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
1396   gtk_tree_selection_set_select_function (selection,
1397                                           shortcuts_select_func,
1398                                           impl, NULL);
1399
1400   g_signal_connect (selection, "changed",
1401                     G_CALLBACK (shortcuts_selection_changed_cb), impl);
1402
1403   g_signal_connect (impl->shortcuts_tree, "row-activated",
1404                     G_CALLBACK (shortcuts_row_activated_cb), impl);
1405
1406   g_signal_connect (impl->shortcuts_tree, "drag-data-received",
1407                     G_CALLBACK (shortcuts_drag_data_received_cb), impl);
1408
1409   gtk_container_add (GTK_CONTAINER (impl->shortcuts_scrollwin), impl->shortcuts_tree);
1410   gtk_widget_show (impl->shortcuts_tree);
1411
1412   /* Model */
1413
1414   create_shortcuts_model (impl);
1415
1416   /* Column */
1417
1418   column = gtk_tree_view_column_new ();
1419   gtk_tree_view_column_set_title (column, _("Folder"));
1420
1421   renderer = gtk_cell_renderer_pixbuf_new ();
1422   gtk_tree_view_column_pack_start (column, renderer, FALSE);
1423   gtk_tree_view_column_set_attributes (column, renderer,
1424                                        "pixbuf", SHORTCUTS_COL_PIXBUF,
1425                                        "visible", SHORTCUTS_COL_PIXBUF_VISIBLE,
1426                                        NULL);
1427
1428   renderer = _gtk_cell_renderer_sep_text_new ();
1429   gtk_tree_view_column_pack_start (column, renderer, TRUE);
1430   gtk_tree_view_column_set_attributes (column, renderer,
1431                                        "text", SHORTCUTS_COL_NAME,
1432                                        NULL);
1433
1434   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->shortcuts_tree), column);
1435
1436   return impl->shortcuts_scrollwin;
1437 }
1438
1439 /* Creates the widgets for the shortcuts/bookmarks pane */
1440 static GtkWidget *
1441 shortcuts_pane_create (GtkFileChooserDefault *impl,
1442                        GtkSizeGroup          *size_group)
1443 {
1444   GtkWidget *vbox;
1445   GtkWidget *hbox;
1446   GtkWidget *widget;
1447
1448   vbox = gtk_vbox_new (FALSE, 6);
1449   gtk_widget_show (vbox);
1450
1451   /* Shortcuts tree */
1452
1453   widget = shortcuts_tree_create (impl);
1454   gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
1455
1456   /* Box for buttons */
1457
1458   hbox = gtk_hbox_new (TRUE, 6);
1459   gtk_size_group_add_widget (size_group, hbox);
1460   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1461   gtk_widget_show (hbox);
1462
1463   /* Add bookmark button */
1464
1465   impl->add_bookmark_button = button_new (impl,
1466                                           _("_Add"),
1467                                           GTK_STOCK_ADD,
1468                                           FALSE,
1469                                           TRUE,
1470                                           G_CALLBACK (add_bookmark_button_clicked_cb));
1471   gtk_box_pack_start (GTK_BOX (hbox), impl->add_bookmark_button, TRUE, TRUE, 0);
1472
1473   /* Remove bookmark button */
1474
1475   impl->remove_bookmark_button = button_new (impl,
1476                                              _("_Remove"),
1477                                              GTK_STOCK_REMOVE,
1478                                              FALSE,
1479                                              TRUE,
1480                                              G_CALLBACK (remove_bookmark_button_clicked_cb));
1481   gtk_box_pack_start (GTK_BOX (hbox), impl->remove_bookmark_button, TRUE, TRUE, 0);
1482
1483   return vbox;
1484 }
1485
1486 /* Creates the widgets for the file list */
1487 static GtkWidget *
1488 create_file_list (GtkFileChooserDefault *impl)
1489 {
1490   GtkTreeSelection *selection;
1491   GtkTreeViewColumn *column;
1492   GtkCellRenderer *renderer;
1493
1494   /* Scrolled window */
1495
1496   impl->list_scrollwin = gtk_scrolled_window_new (NULL, NULL);
1497   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (impl->list_scrollwin),
1498                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1499   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (impl->list_scrollwin),
1500                                        GTK_SHADOW_IN);
1501   if (!impl->folder_mode)
1502     gtk_widget_show (impl->list_scrollwin);
1503
1504   /* Tree/list view */
1505
1506   impl->list = gtk_tree_view_new ();
1507   gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (impl->list), TRUE);
1508   gtk_container_add (GTK_CONTAINER (impl->list_scrollwin), impl->list);
1509   g_signal_connect (impl->list, "row_activated",
1510                     G_CALLBACK (list_row_activated), impl);
1511   gtk_widget_show (impl->list);
1512
1513   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
1514   g_signal_connect (selection, "changed",
1515                     G_CALLBACK (list_selection_changed), impl);
1516
1517   /* Filename column */
1518
1519   impl->list_name_column = gtk_tree_view_column_new ();
1520   gtk_tree_view_column_set_expand (impl->list_name_column, TRUE);
1521   gtk_tree_view_column_set_title (impl->list_name_column, _("File name"));
1522   gtk_tree_view_column_set_sort_column_id (impl->list_name_column, FILE_LIST_COL_NAME);
1523
1524   renderer = gtk_cell_renderer_pixbuf_new ();
1525   gtk_tree_view_column_pack_start (impl->list_name_column, renderer, FALSE);
1526   gtk_tree_view_column_set_cell_data_func (impl->list_name_column, renderer,
1527                                            list_icon_data_func, impl, NULL);
1528
1529   impl->list_name_renderer = gtk_cell_renderer_text_new ();
1530   g_signal_connect (impl->list_name_renderer, "edited",
1531                     G_CALLBACK (renderer_edited_cb), impl);
1532   g_signal_connect (impl->list_name_renderer, "editing-canceled",
1533                     G_CALLBACK (renderer_editing_canceled_cb), impl);
1534   gtk_tree_view_column_pack_start (impl->list_name_column, impl->list_name_renderer, TRUE);
1535   gtk_tree_view_column_set_cell_data_func (impl->list_name_column, impl->list_name_renderer,
1536                                            list_name_data_func, impl, NULL);
1537
1538   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->list), impl->list_name_column);
1539 #if 0
1540   /* Size column */
1541
1542   column = gtk_tree_view_column_new ();
1543   gtk_tree_view_column_set_title (column, _("Size"));
1544
1545   renderer = gtk_cell_renderer_text_new ();
1546   gtk_tree_view_column_pack_start (column, renderer, TRUE);
1547   gtk_tree_view_column_set_cell_data_func (column, renderer,
1548                                            list_size_data_func, impl, NULL);
1549   gtk_tree_view_column_set_sort_column_id (column, FILE_LIST_COL_SIZE);
1550   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->list), column);
1551 #endif
1552   /* Modification time column */
1553
1554   column = gtk_tree_view_column_new ();
1555   gtk_tree_view_column_set_title (column, _("Modified"));
1556
1557   renderer = gtk_cell_renderer_text_new ();
1558   gtk_tree_view_column_pack_start (column, renderer, TRUE);
1559   gtk_tree_view_column_set_cell_data_func (column, renderer,
1560                                            list_mtime_data_func, impl, NULL);
1561   gtk_tree_view_column_set_sort_column_id (column, FILE_LIST_COL_MTIME);
1562   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->list), column);
1563
1564   return impl->list_scrollwin;
1565 }
1566
1567 static GtkWidget *
1568 create_filename_entry_and_filter_combo (GtkFileChooserDefault *impl)
1569 {
1570   GtkWidget *hbox;
1571   GtkWidget *widget;
1572
1573   hbox = gtk_hbox_new (FALSE, 12);
1574   gtk_widget_show (hbox);
1575
1576   /* Filter combo */
1577
1578   widget = filter_create (impl);
1579   gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1580
1581   return hbox;
1582 }
1583
1584 /* Creates the widgets for the files/folders pane */
1585 static GtkWidget *
1586 file_pane_create (GtkFileChooserDefault *impl,
1587                   GtkSizeGroup          *size_group)
1588 {
1589   GtkWidget *vbox;
1590   GtkWidget *hbox;
1591   GtkWidget *widget;
1592
1593   vbox = gtk_vbox_new (FALSE, 6);
1594   gtk_widget_show (vbox);
1595
1596   /* The path bar and 'Create Folder' button */
1597   hbox = gtk_hbox_new (FALSE, 12);
1598   gtk_widget_show (hbox);
1599   impl->path_bar = g_object_new (GTK_TYPE_PATH_BAR, NULL);
1600   g_signal_connect (impl->path_bar, "path_clicked", G_CALLBACK (path_bar_clicked), impl);
1601   gtk_widget_show_all (impl->path_bar);
1602   gtk_box_pack_start (GTK_BOX (hbox), impl->path_bar, TRUE, TRUE, 0);
1603
1604   /* Create Folder */
1605   impl->new_folder_button = gtk_button_new_with_mnemonic (_("Create _Folder"));
1606   g_signal_connect (impl->new_folder_button, "clicked",
1607                     G_CALLBACK (new_folder_button_clicked), impl);
1608   gtk_box_pack_end (GTK_BOX (hbox), impl->new_folder_button, FALSE, FALSE, 0);
1609
1610   if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
1611       impl->folder_mode)
1612     gtk_widget_show (impl->new_folder_button);
1613   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1614
1615   /* Box for lists and preview */
1616
1617   hbox = gtk_hbox_new (FALSE, 12);
1618   gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
1619   gtk_widget_show (hbox);
1620
1621   /* Folder tree */
1622
1623   widget = create_folder_tree (impl);
1624   gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1625
1626   /* File list */
1627
1628   widget = create_file_list (impl);
1629   gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1630
1631   /* Preview */
1632
1633   impl->preview_frame = gtk_frame_new (_("Preview"));
1634   gtk_box_pack_start (GTK_BOX (hbox), impl->preview_frame, FALSE, FALSE, 0);
1635   /* Don't show preview frame initially */
1636
1637   /* Filename entry and filter combo */
1638   hbox = gtk_hbox_new (FALSE, 0);
1639   gtk_size_group_add_widget (size_group, hbox);
1640   widget = create_filename_entry_and_filter_combo (impl);
1641   gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1642   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1643   gtk_widget_show (hbox);
1644
1645   return vbox;
1646 }
1647 /* Callback used when the "Browse for more folders" expander is toggled */
1648 static void
1649 expander_activate_cb (GtkExpander           *expander,
1650                       GtkFileChooserDefault *impl)
1651 {
1652   gboolean active;
1653
1654   active = gtk_expander_get_expanded (expander);
1655
1656   if (active)
1657     gtk_widget_show (impl->hpaned);
1658   else
1659     gtk_widget_hide (impl->hpaned);
1660 }
1661
1662 /* Creates the widgets specific to Save mode */
1663 static GtkWidget *
1664 save_widgets_create (GtkFileChooserDefault *impl)
1665 {
1666   GtkWidget *table;
1667   GtkWidget *widget;
1668   GtkWidget *alignment;
1669
1670   table = gtk_table_new (3, 2, FALSE);
1671   gtk_table_set_row_spacings (GTK_TABLE (table), 12);
1672   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1673
1674   /* Name entry */
1675
1676   widget = gtk_label_new_with_mnemonic (_("_Name:"));
1677   gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
1678   gtk_table_attach (GTK_TABLE (table), widget,
1679                     0, 1, 0, 1,
1680                     GTK_FILL, GTK_FILL,
1681                     0, 0);
1682   gtk_widget_show (widget);
1683
1684   impl->entry = _gtk_file_chooser_entry_new ();
1685   gtk_entry_set_activates_default (GTK_ENTRY (impl->entry), TRUE);
1686   _gtk_file_chooser_entry_set_file_system (GTK_FILE_CHOOSER_ENTRY (impl->entry), impl->file_system);
1687   _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->entry), impl->current_folder);
1688
1689   gtk_table_attach (GTK_TABLE (table), impl->entry,
1690                     1, 2, 0, 1,
1691                     GTK_EXPAND | GTK_FILL, 0,
1692                     0, 0);
1693   gtk_widget_show (impl->entry);
1694   gtk_label_set_mnemonic_widget (GTK_LABEL (widget), impl->entry);
1695
1696   /* Folder combo */
1697
1698   widget = gtk_label_new_with_mnemonic (_("Save in _Folder:"));
1699   gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
1700   gtk_table_attach (GTK_TABLE (table), widget,
1701                     0, 1, 1, 2,
1702                     GTK_FILL, GTK_FILL,
1703                     0, 0);
1704   gtk_widget_show (widget);
1705
1706   /* FIXME: create the combo */
1707
1708   /* Expander */
1709
1710   alignment = gtk_alignment_new (0.0, 0.5, 1.0, 1.0);
1711   gtk_table_attach (GTK_TABLE (table), alignment,
1712                     0, 2, 2, 3,
1713                     GTK_FILL, GTK_FILL,
1714                     0, 0);
1715   gtk_widget_show (alignment);
1716
1717   widget = gtk_expander_new_with_mnemonic (_("_Browse for other folders"));
1718   gtk_container_add (GTK_CONTAINER (alignment), widget);
1719   gtk_widget_show (widget);
1720   g_signal_connect (widget, "activate",
1721                     G_CALLBACK (expander_activate_cb),
1722                     impl);
1723
1724   return table;
1725 }
1726
1727 /* Creates the main hpaned with the widgets shared by Open and Save mode */
1728 static GtkWidget *
1729 main_paned_create (GtkFileChooserDefault *impl)
1730 {
1731   GtkWidget *hpaned;
1732   GtkWidget *widget;
1733   GtkSizeGroup *size_group;
1734
1735   /* size group is used by the [+][-] buttons, as well as the filter. */
1736   size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
1737
1738   /* Paned widget */
1739
1740   hpaned = gtk_hpaned_new ();
1741   gtk_paned_set_position (GTK_PANED (hpaned), 200); /* FIXME: this sucks */
1742
1743   /* Shortcuts pane */
1744
1745   widget = shortcuts_pane_create (impl, size_group);
1746   gtk_paned_pack1 (GTK_PANED (hpaned), widget, FALSE, FALSE);
1747
1748   /* File/folder pane */
1749
1750   widget = file_pane_create (impl, size_group);
1751   gtk_paned_pack2 (GTK_PANED (hpaned), widget, TRUE, FALSE);
1752
1753   return hpaned;
1754 }
1755
1756 static GObject*
1757 gtk_file_chooser_default_constructor (GType                  type,
1758                                       guint                  n_construct_properties,
1759                                       GObjectConstructParam *construct_params)
1760 {
1761   GtkFileChooserDefault *impl;
1762   GObject *object;
1763   GtkWidget *show_widget;
1764
1765   object = parent_class->constructor (type,
1766                                       n_construct_properties,
1767                                       construct_params);
1768   impl = GTK_FILE_CHOOSER_DEFAULT (object);
1769
1770   g_assert (impl->file_system);
1771
1772   gtk_widget_push_composite_child ();
1773
1774   /* Widgets for Save mode */
1775
1776   impl->save_widgets = save_widgets_create (impl);
1777   gtk_box_pack_start (GTK_BOX (impl), impl->save_widgets, FALSE, FALSE, 0);
1778
1779   /* Widgets for Open and Save mode */
1780
1781   impl->hpaned = main_paned_create (impl);
1782   gtk_box_pack_start (GTK_BOX (impl), impl->hpaned, TRUE, TRUE, 0);
1783
1784   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
1785     show_widget = impl->hpaned;
1786   else
1787     show_widget = impl->save_widgets;
1788
1789   gtk_widget_show (show_widget);
1790
1791   gtk_widget_pop_composite_child ();
1792
1793   return object;
1794 }
1795
1796 /* Sets the extra_widget by packing it in the appropriate place */
1797 static void
1798 set_extra_widget (GtkFileChooserDefault *impl,
1799                   GtkWidget             *extra_widget)
1800 {
1801   if (extra_widget == impl->extra_widget)
1802     return;
1803
1804   if (impl->extra_widget)
1805     gtk_container_remove (GTK_CONTAINER (impl), impl->extra_widget);
1806
1807   impl->extra_widget = extra_widget;
1808   if (impl->extra_widget)
1809     {
1810       gtk_widget_show_all (impl->extra_widget);
1811       gtk_box_pack_end (GTK_BOX (impl), impl->extra_widget, FALSE, FALSE, 0);
1812     }
1813 }
1814
1815 static void
1816 volumes_changed_cb (GtkFileSystem         *file_system,
1817                     GtkFileChooserDefault *impl)
1818 {
1819   shortcuts_add_volumes (impl);
1820 }
1821
1822 /* Callback used when the set of bookmarks changes in the file system */
1823 static void
1824 bookmarks_changed_cb (GtkFileSystem         *file_system,
1825                       GtkFileChooserDefault *impl)
1826 {
1827   shortcuts_add_bookmarks (impl);
1828
1829   bookmarks_check_add_sensitivity (impl);
1830   bookmarks_check_remove_sensitivity (impl);
1831 }
1832
1833 /* Sets the file chooser to multiple selection mode */
1834 static void
1835 set_select_multiple (GtkFileChooserDefault *impl,
1836                      gboolean               select_multiple,
1837                      gboolean               property_notify)
1838 {
1839   GtkTreeSelection *selection;
1840   GtkSelectionMode mode;
1841
1842   if (select_multiple == impl->select_multiple)
1843     return;
1844
1845   impl->select_multiple = select_multiple;
1846
1847   mode = select_multiple ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_BROWSE;
1848
1849   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->tree));
1850   gtk_tree_selection_set_mode (selection, mode);
1851
1852   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
1853   gtk_tree_selection_set_mode (selection, mode);
1854
1855   g_object_notify (G_OBJECT (impl), "select-multiple");
1856
1857   /* FIXME #132255: See note in check_preview_change() */
1858   check_preview_change (impl);
1859 }
1860
1861 static void
1862 set_file_system_backend (GtkFileChooserDefault *impl,
1863                          const char *backend)
1864 {
1865   if (impl->file_system)
1866     {
1867       g_signal_handler_disconnect (impl->file_system, impl->volumes_changed_id);
1868       impl->volumes_changed_id = 0;
1869       g_signal_handler_disconnect (impl->file_system, impl->bookmarks_changed_id);
1870       impl->bookmarks_changed_id = 0;
1871       g_object_unref (impl->file_system);
1872     }
1873
1874   impl->file_system = NULL;
1875   if (backend)
1876     impl->file_system = _gtk_file_system_create (backend);
1877
1878   if (!impl->file_system)
1879     {
1880 #if defined (G_OS_UNIX)
1881       impl->file_system = gtk_file_system_unix_new ();
1882 #elif defined (G_OS_WIN32)
1883       impl->file_system = gtk_file_system_win32_new ();
1884 #else
1885 #error "No default filesystem implementation on the platform"
1886 #endif
1887     }
1888
1889   if (impl->file_system)
1890     {
1891       impl->volumes_changed_id = g_signal_connect (impl->file_system, "volumes-changed",
1892                                                    G_CALLBACK (volumes_changed_cb),
1893                                                    impl);
1894       impl->bookmarks_changed_id = g_signal_connect (impl->file_system, "bookmarks-changed",
1895                                                      G_CALLBACK (bookmarks_changed_cb),
1896                                                      impl);
1897     }
1898 }
1899
1900 static void
1901 gtk_file_chooser_default_set_property (GObject      *object,
1902                                        guint         prop_id,
1903                                        const GValue *value,
1904                                        GParamSpec   *pspec)
1905
1906 {
1907   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (object);
1908
1909   switch (prop_id)
1910     {
1911     case GTK_FILE_CHOOSER_PROP_ACTION:
1912       impl->action = g_value_get_enum (value);
1913       if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
1914         {
1915           gtk_widget_hide (impl->hpaned);
1916           gtk_widget_show (impl->save_widgets);
1917           gtk_widget_show (impl->new_folder_button);
1918
1919           if (impl->select_multiple)
1920             {
1921               g_warning ("Save mode cannot be set in conjunction with multiple selection mode.  "
1922                          "Re-setting to single selection mode.");
1923               set_select_multiple (impl, FALSE, TRUE);
1924             }
1925         }
1926       else
1927         {
1928           gtk_widget_hide (impl->save_widgets);
1929           gtk_widget_show (impl->hpaned);
1930
1931           if (impl->folder_mode)
1932             gtk_widget_show (impl->new_folder_button);
1933           else
1934             gtk_widget_hide (impl->new_folder_button);
1935         }
1936
1937       break;
1938     case GTK_FILE_CHOOSER_PROP_FILE_SYSTEM_BACKEND:
1939       set_file_system_backend (impl, g_value_get_string (value));
1940       break;
1941     case GTK_FILE_CHOOSER_PROP_FILTER:
1942       set_current_filter (impl, g_value_get_object (value));
1943       break;
1944     case GTK_FILE_CHOOSER_PROP_FOLDER_MODE:
1945       {
1946         gboolean folder_mode = g_value_get_boolean (value);
1947         if (folder_mode != impl->folder_mode)
1948           {
1949             impl->folder_mode = folder_mode;
1950             if (impl->folder_mode)
1951               {
1952                 gtk_widget_hide (impl->list_scrollwin);
1953                 gtk_widget_show (impl->tree_scrollwin);
1954                 gtk_widget_show (impl->new_folder_button);
1955               }
1956             else
1957               {
1958                 gtk_widget_hide (impl->tree_scrollwin);
1959                 gtk_widget_show (impl->list_scrollwin);
1960                 gtk_widget_hide (impl->new_folder_button);
1961               }
1962           }
1963       }
1964       break;
1965     case GTK_FILE_CHOOSER_PROP_LOCAL_ONLY:
1966       impl->local_only = g_value_get_boolean (value);
1967       break;
1968     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET:
1969       set_preview_widget (impl, g_value_get_object (value));
1970       break;
1971     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE:
1972       impl->preview_widget_active = g_value_get_boolean (value);
1973       update_preview_widget_visibility (impl);
1974       break;
1975     case GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET:
1976       set_extra_widget (impl, g_value_get_object (value));
1977       break;
1978     case GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE:
1979       {
1980         gboolean select_multiple = g_value_get_boolean (value);
1981         if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE && select_multiple)
1982           {
1983             g_warning ("Multiple selection mode is not allowed in Save mode");
1984             return;
1985           }
1986
1987         set_select_multiple (impl, select_multiple, FALSE);
1988       }
1989       break;
1990     case GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN:
1991       {
1992         gboolean show_hidden = g_value_get_boolean (value);
1993         if (show_hidden != impl->show_hidden)
1994           {
1995             impl->show_hidden = show_hidden;
1996             _gtk_file_system_model_set_show_hidden (impl->tree_model, show_hidden);
1997             _gtk_file_system_model_set_show_hidden (impl->list_model, show_hidden);
1998           }
1999       }
2000       break;
2001     default:
2002       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2003       break;
2004     }
2005 }
2006
2007 static void
2008 gtk_file_chooser_default_get_property (GObject    *object,
2009                                        guint       prop_id,
2010                                        GValue     *value,
2011                                        GParamSpec *pspec)
2012 {
2013   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (object);
2014
2015   switch (prop_id)
2016     {
2017     case GTK_FILE_CHOOSER_PROP_ACTION:
2018       g_value_set_enum (value, impl->action);
2019       break;
2020     case GTK_FILE_CHOOSER_PROP_FILTER:
2021       g_value_set_object (value, impl->current_filter);
2022       break;
2023     case GTK_FILE_CHOOSER_PROP_FOLDER_MODE:
2024       g_value_set_boolean (value, impl->folder_mode);
2025       break;
2026     case GTK_FILE_CHOOSER_PROP_LOCAL_ONLY:
2027       g_value_set_boolean (value, impl->local_only);
2028       break;
2029     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET:
2030       g_value_set_object (value, impl->preview_widget);
2031       break;
2032     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE:
2033       g_value_set_boolean (value, impl->preview_widget_active);
2034       break;
2035     case GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET:
2036       g_value_set_object (value, impl->extra_widget);
2037       break;
2038     case GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE:
2039       g_value_set_boolean (value, impl->select_multiple);
2040       break;
2041     case GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN:
2042       g_value_set_boolean (value, impl->show_hidden);
2043       break;
2044     default:
2045       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2046       break;
2047     }
2048 }
2049
2050 /* We override show-all since we have internal widgets that
2051  * shouldn't be shown when you call show_all(), like the filter
2052  * combo box.
2053  */
2054 static void
2055 gtk_file_chooser_default_show_all (GtkWidget *widget)
2056 {
2057   gtk_widget_show (widget);
2058 }
2059
2060 static void
2061 expand_and_select_func (GtkFileSystemModel *model,
2062                         GtkTreePath        *path,
2063                         GtkTreeIter        *iter,
2064                         gpointer            user_data)
2065 {
2066   GtkFileChooserDefault *impl = user_data;
2067   GtkTreeView *tree_view;
2068
2069   if (model == impl->tree_model)
2070     tree_view = GTK_TREE_VIEW (impl->tree);
2071   else
2072     tree_view = GTK_TREE_VIEW (impl->list);
2073
2074   gtk_tree_view_expand_to_path (tree_view, path);
2075   gtk_tree_view_expand_row (tree_view, path, FALSE);
2076   gtk_tree_view_set_cursor (tree_view, path, NULL, FALSE);
2077   gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (impl->tree), path, NULL, TRUE, 0.3, 0.5);
2078 }
2079
2080 static gboolean
2081 list_model_filter_func (GtkFileSystemModel *model,
2082                         GtkFilePath        *path,
2083                         const GtkFileInfo  *file_info,
2084                         gpointer            user_data)
2085 {
2086   GtkFileChooserDefault *impl = user_data;
2087   GtkFileFilterInfo filter_info;
2088   GtkFileFilterFlags needed;
2089   gboolean result;
2090
2091   if (!impl->current_filter)
2092     return TRUE;
2093
2094   if (gtk_file_info_get_is_folder (file_info))
2095     return TRUE;
2096
2097   filter_info.contains = GTK_FILE_FILTER_DISPLAY_NAME | GTK_FILE_FILTER_MIME_TYPE;
2098
2099   needed = gtk_file_filter_get_needed (impl->current_filter);
2100
2101   filter_info.display_name = gtk_file_info_get_display_name (file_info);
2102   filter_info.mime_type = gtk_file_info_get_mime_type (file_info);
2103
2104   if (needed & GTK_FILE_FILTER_FILENAME)
2105     {
2106       filter_info.filename = gtk_file_system_path_to_filename (impl->file_system, path);
2107       if (filter_info.filename)
2108         filter_info.contains |= GTK_FILE_FILTER_FILENAME;
2109     }
2110   else
2111     filter_info.filename = NULL;
2112
2113   if (needed & GTK_FILE_FILTER_URI)
2114     {
2115       filter_info.uri = gtk_file_system_path_to_uri (impl->file_system, path);
2116       if (filter_info.filename)
2117         filter_info.contains |= GTK_FILE_FILTER_URI;
2118     }
2119   else
2120     filter_info.uri = NULL;
2121
2122   result = gtk_file_filter_filter (impl->current_filter, &filter_info);
2123
2124   if (filter_info.filename)
2125     g_free ((gchar *)filter_info.filename);
2126   if (filter_info.uri)
2127     g_free ((gchar *)filter_info.uri);
2128
2129   return result;
2130 }
2131
2132 static void
2133 install_list_model_filter (GtkFileChooserDefault *impl)
2134 {
2135   if (impl->current_filter)
2136     _gtk_file_system_model_set_filter (impl->list_model,
2137                                        list_model_filter_func,
2138                                        impl);
2139 }
2140
2141 #define COMPARE_DIRECTORIES                                                                                    \
2142   GtkFileChooserDefault *impl = user_data;                                                                     \
2143   const GtkFileInfo *info_a = _gtk_file_system_model_get_info (impl->list_model, a);                           \
2144   const GtkFileInfo *info_b = _gtk_file_system_model_get_info (impl->list_model, b);                           \
2145   gboolean dir_a, dir_b;                                                                                       \
2146                                                                                                                \
2147   if (info_a)                                                                                                  \
2148     dir_a = gtk_file_info_get_is_folder (info_a);                                                              \
2149   else                                                                                                         \
2150     return impl->list_sort_ascending ? -1 : 1;                                                                 \
2151                                                                                                                \
2152   if (info_b)                                                                                                  \
2153     dir_b = gtk_file_info_get_is_folder (info_b);                                                              \
2154   else                                                                                                         \
2155     return impl->list_sort_ascending ? 1 : -1;                                                                 \
2156                                                                                                                \
2157   if (dir_a != dir_b)                                                                                          \
2158     return impl->list_sort_ascending ? (dir_a ? -1 : 1) : (dir_a ? 1 : -1) /* Directories *always* go first */
2159
2160 /* Sort callback for the filename column */
2161 static gint
2162 name_sort_func (GtkTreeModel *model,
2163                 GtkTreeIter  *a,
2164                 GtkTreeIter  *b,
2165                 gpointer      user_data)
2166 {
2167   COMPARE_DIRECTORIES;
2168   else
2169     return strcmp (gtk_file_info_get_display_key (info_a), gtk_file_info_get_display_key (info_b));
2170 }
2171
2172 /* Sort callback for the size column */
2173 static gint
2174 size_sort_func (GtkTreeModel *model,
2175                 GtkTreeIter  *a,
2176                 GtkTreeIter  *b,
2177                 gpointer      user_data)
2178 {
2179   COMPARE_DIRECTORIES;
2180   else
2181     {
2182       gint64 size_a = gtk_file_info_get_size (info_a);
2183       gint64 size_b = gtk_file_info_get_size (info_b);
2184
2185       return size_a > size_b ? -1 : (size_a == size_b ? 0 : 1);
2186     }
2187 }
2188
2189 /* Sort callback for the mtime column */
2190 static gint
2191 mtime_sort_func (GtkTreeModel *model,
2192                  GtkTreeIter  *a,
2193                  GtkTreeIter  *b,
2194                  gpointer      user_data)
2195 {
2196   COMPARE_DIRECTORIES;
2197   else
2198     {
2199       GtkFileTime ta = gtk_file_info_get_modification_time (info_a);
2200       GtkFileTime tb = gtk_file_info_get_modification_time (info_b);
2201
2202       return ta > tb ? -1 : (ta == tb ? 0 : 1);
2203     }
2204 }
2205
2206 /* Callback used when the sort column changes.  We cache the sort order for use
2207  * in name_sort_func().
2208  */
2209 static void
2210 list_sort_column_changed_cb (GtkTreeSortable       *sortable,
2211                              GtkFileChooserDefault *impl)
2212 {
2213   GtkSortType sort_type;
2214
2215   if (gtk_tree_sortable_get_sort_column_id (sortable, NULL, &sort_type))
2216     impl->list_sort_ascending = (sort_type == GTK_SORT_ASCENDING);
2217 }
2218
2219 /* Gets rid of the old list model and creates a new one for the current folder */
2220 static void
2221 set_list_model (GtkFileChooserDefault *impl)
2222 {
2223   if (impl->list_model)
2224     {
2225       g_object_unref (impl->list_model);
2226       g_object_unref (impl->sort_model);
2227     }
2228
2229   impl->list_model = _gtk_file_system_model_new (impl->file_system,
2230                                                  impl->current_folder, 0,
2231                                                  GTK_FILE_INFO_ALL);
2232   _gtk_file_system_model_set_show_hidden (impl->list_model, impl->show_hidden);
2233   install_list_model_filter (impl);
2234
2235   impl->sort_model = (GtkTreeModelSort *)gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (impl->list_model));
2236   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_NAME, name_sort_func, impl, NULL);
2237   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_SIZE, size_sort_func, impl, NULL);
2238   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_MTIME, mtime_sort_func, impl, NULL);
2239   gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (impl->sort_model), NULL, NULL, NULL);
2240   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_NAME, GTK_SORT_ASCENDING);
2241   impl->list_sort_ascending = TRUE;
2242
2243   g_signal_connect (impl->sort_model, "sort_column_changed",
2244                     G_CALLBACK (list_sort_column_changed_cb), impl);
2245
2246   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->list),
2247                            GTK_TREE_MODEL (impl->sort_model));
2248   gtk_tree_view_columns_autosize (GTK_TREE_VIEW (impl->list));
2249   gtk_tree_view_set_search_column (GTK_TREE_VIEW (impl->list),
2250                                    GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME);
2251 }
2252
2253 /* Gets rid of the old folder tree model and creates a new one for the volume
2254  * corresponding to the specified path.
2255  */
2256 static void
2257 set_tree_model (GtkFileChooserDefault *impl, const GtkFilePath *path)
2258 {
2259   GtkFileSystemVolume *volume;
2260   GtkFilePath *base_path, *parent_path;
2261
2262   base_path = NULL;
2263
2264   volume = gtk_file_system_get_volume_for_path (impl->file_system, path);
2265
2266   if (volume)
2267     base_path = gtk_file_system_volume_get_base_path (impl->file_system, volume);
2268
2269   if (base_path == NULL)
2270     {
2271       base_path = gtk_file_path_copy (path);
2272       while (gtk_file_system_get_parent (impl->file_system,
2273                                          base_path,
2274                                          &parent_path,
2275                                          NULL) &&
2276              parent_path != NULL)
2277         {
2278           gtk_file_path_free (base_path);
2279           base_path = parent_path;
2280         }
2281     }
2282
2283   if (impl->current_volume_path && gtk_file_path_compare (base_path, impl->current_volume_path) == 0)
2284     goto out;
2285
2286   if (impl->tree_model)
2287     g_object_unref (impl->tree_model);
2288
2289   impl->current_volume_path = gtk_file_path_copy (base_path);
2290
2291   impl->tree_model = _gtk_file_system_model_new (impl->file_system, impl->current_volume_path, -1,
2292                                                  GTK_FILE_INFO_DISPLAY_NAME);
2293   _gtk_file_system_model_set_show_files (impl->tree_model, FALSE);
2294   _gtk_file_system_model_set_show_hidden (impl->tree_model, impl->show_hidden);
2295
2296   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->tree),
2297                            GTK_TREE_MODEL (impl->tree_model));
2298
2299  out:
2300
2301   gtk_file_path_free (base_path);
2302   if (volume)
2303     gtk_file_system_volume_free (impl->file_system, volume);
2304 }
2305
2306 static void
2307 update_chooser_entry (GtkFileChooserDefault *impl)
2308 {
2309   GtkTreeSelection *selection;
2310   const GtkFileInfo *info;
2311   GtkTreeIter iter;
2312   GtkTreeIter child_iter;
2313
2314   if (impl->action != GTK_FILE_CHOOSER_ACTION_SAVE)
2315     return;
2316
2317   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
2318
2319   if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
2320     return;
2321
2322   gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
2323                                                   &child_iter,
2324                                                   &iter);
2325
2326   info = _gtk_file_system_model_get_info (impl->list_model, &child_iter);
2327
2328   if (!gtk_file_info_get_is_folder (info))
2329     _gtk_file_chooser_entry_set_file_part (GTK_FILE_CHOOSER_ENTRY (impl->entry),
2330                                            gtk_file_info_get_display_name (info));
2331 }
2332
2333 static void
2334 gtk_file_chooser_default_set_current_folder (GtkFileChooser    *chooser,
2335                                              const GtkFilePath *path)
2336 {
2337   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2338
2339   if (impl->current_folder)
2340     gtk_file_path_free (impl->current_folder);
2341
2342   impl->current_folder = gtk_file_path_copy (path);
2343
2344   /* Change the current folder label */
2345   gtk_path_bar_set_path (GTK_PATH_BAR (impl->path_bar), path, impl->file_system, NULL);
2346
2347   /* Update the folder tree */
2348
2349   if (!impl->changing_folder)
2350     {
2351       impl->changing_folder = TRUE;
2352       set_tree_model (impl, impl->current_folder);
2353       _gtk_file_system_model_path_do (impl->tree_model, path,
2354                                       expand_and_select_func, impl);
2355       impl->changing_folder = FALSE;
2356     }
2357
2358   /* Notify the save entry */
2359
2360   _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->entry), impl->current_folder);
2361
2362   /* Create a new list model */
2363   set_list_model (impl);
2364
2365   /* Refresh controls */
2366
2367   shortcuts_unselect_all (impl);
2368
2369   g_signal_emit_by_name (impl, "current-folder-changed", 0);
2370
2371   update_chooser_entry (impl);
2372   check_preview_change (impl);
2373   bookmarks_check_add_sensitivity (impl);
2374
2375   g_signal_emit_by_name (impl, "selection-changed", 0);
2376 }
2377
2378 static GtkFilePath *
2379 gtk_file_chooser_default_get_current_folder (GtkFileChooser *chooser)
2380 {
2381   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2382
2383   return gtk_file_path_copy (impl->current_folder);
2384 }
2385
2386 static void
2387 gtk_file_chooser_default_set_current_name (GtkFileChooser *chooser,
2388                                            const gchar    *name)
2389 {
2390   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2391
2392   g_return_if_fail (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE);
2393
2394   _gtk_file_chooser_entry_set_file_part (GTK_FILE_CHOOSER_ENTRY (impl->entry), name);
2395 }
2396
2397 static void
2398 select_func (GtkFileSystemModel *model,
2399              GtkTreePath        *path,
2400              GtkTreeIter        *iter,
2401              gpointer            user_data)
2402 {
2403   GtkFileChooserDefault *impl = user_data;
2404   GtkTreeView *tree_view = GTK_TREE_VIEW (impl->list);
2405   GtkTreePath *sorted_path;
2406
2407   sorted_path = gtk_tree_model_sort_convert_child_path_to_path (impl->sort_model, path);
2408   gtk_tree_view_set_cursor (tree_view, sorted_path, NULL, FALSE);
2409   gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (impl->tree), sorted_path, NULL, TRUE, 0.3, 0.0);
2410   gtk_tree_path_free (sorted_path);
2411 }
2412
2413 static void
2414 gtk_file_chooser_default_select_path (GtkFileChooser    *chooser,
2415                                       const GtkFilePath *path)
2416 {
2417   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2418   GtkFilePath *parent_path;
2419   GError *error;
2420
2421   error = NULL;
2422   if (!gtk_file_system_get_parent (impl->file_system, path, &parent_path, &error))
2423     {
2424       error_getting_info_dialog (impl, path, error);
2425       return;
2426     }
2427
2428   if (!parent_path)
2429     {
2430       _gtk_file_chooser_set_current_folder_path (chooser, path);
2431     }
2432   else
2433     {
2434       _gtk_file_chooser_set_current_folder_path (chooser, parent_path);
2435       gtk_file_path_free (parent_path);
2436       _gtk_file_system_model_path_do (impl->list_model, path,
2437                                       select_func, impl);
2438     }
2439 }
2440
2441 static void
2442 unselect_func (GtkFileSystemModel *model,
2443                GtkTreePath        *path,
2444                GtkTreeIter        *iter,
2445                gpointer            user_data)
2446 {
2447   GtkFileChooserDefault *impl = user_data;
2448   GtkTreeView *tree_view = GTK_TREE_VIEW (impl->list);
2449   GtkTreePath *sorted_path;
2450
2451   sorted_path = gtk_tree_model_sort_convert_child_path_to_path (impl->sort_model,
2452                                                                 path);
2453   gtk_tree_selection_unselect_path (gtk_tree_view_get_selection (tree_view),
2454                                     sorted_path);
2455   gtk_tree_path_free (sorted_path);
2456 }
2457
2458 static void
2459 gtk_file_chooser_default_unselect_path (GtkFileChooser    *chooser,
2460                                         const GtkFilePath *path)
2461 {
2462   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2463
2464   _gtk_file_system_model_path_do (impl->list_model, path,
2465                                  unselect_func, impl);
2466 }
2467
2468 static void
2469 gtk_file_chooser_default_select_all (GtkFileChooser *chooser)
2470 {
2471   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2472   if (impl->select_multiple)
2473     {
2474       GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
2475       gtk_tree_selection_select_all (selection);
2476     }
2477 }
2478
2479 static void
2480 gtk_file_chooser_default_unselect_all (GtkFileChooser *chooser)
2481 {
2482   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2483   GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
2484
2485   gtk_tree_selection_unselect_all (selection);
2486 }
2487
2488 struct get_paths_closure {
2489   GtkFileChooserDefault *impl;
2490   GSList *result;
2491   GtkFilePath *path_from_entry;
2492 };
2493
2494 static void
2495 get_paths_foreach (GtkTreeModel *model,
2496                    GtkTreePath  *path,
2497                    GtkTreeIter  *iter,
2498                    gpointer      data)
2499 {
2500   struct get_paths_closure *info;
2501   const GtkFilePath *file_path;
2502   GtkFileSystemModel *fs_model;
2503   GtkTreeIter sel_iter;
2504
2505   info = data;
2506
2507   if (info->impl->folder_mode)
2508     {
2509       fs_model = info->impl->tree_model;
2510       sel_iter = *iter;
2511     }
2512   else
2513     {
2514       fs_model = info->impl->list_model;
2515       gtk_tree_model_sort_convert_iter_to_child_iter (info->impl->sort_model, &sel_iter, iter);
2516     }
2517
2518   file_path = _gtk_file_system_model_get_path (fs_model, &sel_iter);
2519
2520   if (!info->path_from_entry
2521       || gtk_file_path_compare (info->path_from_entry, file_path) != 0)
2522     info->result = g_slist_prepend (info->result, gtk_file_path_copy (file_path));
2523 }
2524
2525 static GSList *
2526 gtk_file_chooser_default_get_paths (GtkFileChooser *chooser)
2527 {
2528   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2529   struct get_paths_closure info;
2530
2531   info.impl = impl;
2532   info.result = NULL;
2533   info.path_from_entry = NULL;
2534
2535   if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
2536     {
2537       GtkFileChooserEntry *chooser_entry;
2538       const GtkFilePath *folder_path;
2539       const gchar *file_part;
2540
2541       chooser_entry = GTK_FILE_CHOOSER_ENTRY (impl->entry);
2542       folder_path = _gtk_file_chooser_entry_get_current_folder (chooser_entry);
2543       file_part = _gtk_file_chooser_entry_get_file_part (chooser_entry);
2544
2545       if (file_part != NULL && file_part[0] != '\0')
2546         {
2547           GtkFilePath *selected;
2548           GError *error = NULL;
2549
2550           selected = gtk_file_system_make_path (impl->file_system, folder_path, file_part, &error);
2551
2552           if (!selected)
2553             {
2554               error_building_filename_dialog (impl, folder_path, file_part, error);
2555               return NULL;
2556             }
2557
2558           info.path_from_entry = selected;
2559         }
2560     }
2561
2562   if (!info.path_from_entry || impl->select_multiple)
2563     {
2564       GtkTreeSelection *selection;
2565
2566       selection = NULL;
2567
2568       if (impl->folder_mode)
2569         {
2570           if (impl->tree_model)
2571             selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->tree));
2572         }
2573       else
2574         {
2575           if (impl->sort_model)
2576             selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
2577         }
2578
2579       if (selection)
2580         gtk_tree_selection_selected_foreach (selection, get_paths_foreach, &info);
2581     }
2582
2583   if (info.path_from_entry)
2584     info.result = g_slist_prepend (info.result, info.path_from_entry);
2585
2586   return g_slist_reverse (info.result);
2587 }
2588
2589 static GtkFilePath *
2590 gtk_file_chooser_default_get_preview_path (GtkFileChooser *chooser)
2591 {
2592   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2593
2594   if (impl->preview_path)
2595     return gtk_file_path_copy (impl->preview_path);
2596   else
2597     return NULL;
2598 }
2599
2600 static GtkFileSystem *
2601 gtk_file_chooser_default_get_file_system (GtkFileChooser *chooser)
2602 {
2603   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2604
2605   return impl->file_system;
2606 }
2607
2608 /* Shows or hides the filter widgets */
2609 static void
2610 toolbar_show_filters (GtkFileChooserDefault *impl,
2611                       gboolean               show)
2612 {
2613   if (show)
2614     gtk_widget_show (impl->filter_combo);
2615   else
2616     gtk_widget_hide (impl->filter_combo);
2617 }
2618
2619 static void
2620 gtk_file_chooser_default_add_filter (GtkFileChooser *chooser,
2621                                      GtkFileFilter  *filter)
2622 {
2623   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2624   const gchar *name;
2625
2626   if (g_slist_find (impl->filters, filter))
2627     {
2628       g_warning ("gtk_file_chooser_add_filter() called on filter already in list\n");
2629       return;
2630     }
2631
2632   g_object_ref (filter);
2633   gtk_object_sink (GTK_OBJECT (filter));
2634   impl->filters = g_slist_append (impl->filters, filter);
2635
2636   name = gtk_file_filter_get_name (filter);
2637   if (!name)
2638     name = "Untitled filter";   /* Place-holder, doesn't need to be marked for translation */
2639
2640   gtk_combo_box_append_text (GTK_COMBO_BOX (impl->filter_combo), name);
2641
2642   if (!g_slist_find (impl->filters, impl->current_filter))
2643     set_current_filter (impl, filter);
2644
2645   toolbar_show_filters (impl, TRUE);
2646 }
2647
2648 static void
2649 gtk_file_chooser_default_remove_filter (GtkFileChooser *chooser,
2650                                         GtkFileFilter  *filter)
2651 {
2652   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2653   GtkTreeModel *model;
2654   GtkTreeIter iter;
2655   gint filter_index;
2656
2657   filter_index = g_slist_index (impl->filters, filter);
2658
2659   if (filter_index < 0)
2660     {
2661       g_warning ("gtk_file_chooser_remove_filter() called on filter not in list\n");
2662       return;
2663     }
2664
2665   impl->filters = g_slist_remove (impl->filters, filter);
2666
2667   if (filter == impl->current_filter)
2668     {
2669       if (impl->filters)
2670         set_current_filter (impl, impl->filters->data);
2671       else
2672         set_current_filter (impl, NULL);
2673     }
2674
2675   /* Remove row from the combo box */
2676   model = gtk_combo_box_get_model (GTK_COMBO_BOX (impl->filter_combo));
2677   gtk_tree_model_iter_nth_child  (model, &iter, NULL, filter_index);
2678   gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
2679
2680   g_object_unref (filter);
2681
2682   if (!impl->filters)
2683     toolbar_show_filters (impl, FALSE);
2684 }
2685
2686 static GSList *
2687 gtk_file_chooser_default_list_filters (GtkFileChooser *chooser)
2688 {
2689   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2690
2691   return g_slist_copy (impl->filters);
2692 }
2693
2694 /* Returns the position in the shortcuts tree where the nth specified shortcut would appear */
2695 static int
2696 shortcuts_get_pos_for_shortcut_folder (GtkFileChooserDefault *impl,
2697                                        int                    pos)
2698 {
2699   return pos + shortcuts_get_index (impl, SHORTCUTS_SHORTCUTS);
2700 }
2701
2702 static gboolean
2703 gtk_file_chooser_default_add_shortcut_folder (GtkFileChooser    *chooser,
2704                                               const GtkFilePath *path,
2705                                               GError           **error)
2706 {
2707   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2708   gboolean result;
2709   int pos;
2710
2711   pos = shortcuts_get_pos_for_shortcut_folder (impl, impl->num_shortcuts);
2712
2713   result = shortcuts_insert_path (impl, pos, FALSE, NULL, path, NULL, FALSE, error);
2714
2715   if (result)
2716     impl->num_shortcuts++;
2717
2718   return result;
2719 }
2720
2721 static gboolean
2722 gtk_file_chooser_default_remove_shortcut_folder (GtkFileChooser    *chooser,
2723                                                  const GtkFilePath *path,
2724                                                  GError           **error)
2725 {
2726   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2727   int pos;
2728   GtkTreeIter iter;
2729   int i;
2730
2731   if (impl->num_shortcuts == 0)
2732     goto out;
2733
2734   pos = shortcuts_get_pos_for_shortcut_folder (impl, 0);
2735   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
2736     g_assert_not_reached ();
2737
2738   for (i = 0; i < impl->num_shortcuts; i++)
2739     {
2740       GtkFilePath *shortcut;
2741
2742       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter, SHORTCUTS_COL_PATH, &shortcut, -1);
2743       g_assert (shortcut != NULL);
2744
2745       if (gtk_file_path_compare (shortcut, path) == 0)
2746         {
2747           /* The other columns are freed by the GtkTreeStore */
2748           gtk_file_path_free (shortcut);
2749           gtk_list_store_remove (impl->shortcuts_model, &iter);
2750           impl->num_shortcuts--;
2751           return TRUE;
2752         }
2753
2754       if (!gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
2755         g_assert_not_reached ();
2756     }
2757
2758  out:
2759
2760   g_set_error (error,
2761                GTK_FILE_CHOOSER_ERROR,
2762                GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
2763                _("shortcut %s does not exist"),
2764                gtk_file_path_get_string (path));
2765
2766   return FALSE;
2767 }
2768
2769 static GSList *
2770 gtk_file_chooser_default_list_shortcut_folders (GtkFileChooser *chooser)
2771 {
2772   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
2773   int pos;
2774   GtkTreeIter iter;
2775   int i;
2776   GSList *list;
2777
2778   pos = shortcuts_get_pos_for_shortcut_folder (impl, 0);
2779   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
2780     g_assert_not_reached ();
2781
2782   list = NULL;
2783
2784   for (i = 0; i < impl->num_shortcuts; i++)
2785     {
2786       GtkFilePath *shortcut;
2787
2788       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter, SHORTCUTS_COL_PATH, &shortcut, -1);
2789       g_assert (shortcut != NULL);
2790
2791       list = g_slist_prepend (list, gtk_file_path_copy (shortcut));
2792
2793       if (!gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
2794         g_assert_not_reached ();
2795     }
2796
2797   return g_slist_reverse (list);
2798 }
2799
2800 static void
2801 set_current_filter (GtkFileChooserDefault *impl,
2802                     GtkFileFilter         *filter)
2803 {
2804   if (impl->current_filter != filter)
2805     {
2806       int filter_index;
2807
2808       /* If we have filters, new filter must be one of them
2809        */
2810       filter_index = g_slist_index (impl->filters, filter);
2811       if (impl->filters && filter_index < 0)
2812         return;
2813
2814       if (impl->current_filter)
2815         g_object_unref (impl->current_filter);
2816       impl->current_filter = filter;
2817       if (impl->current_filter)
2818         {
2819           g_object_ref (impl->current_filter);
2820           gtk_object_sink (GTK_OBJECT (filter));
2821         }
2822
2823       if (impl->filters)
2824         gtk_combo_box_set_active (GTK_COMBO_BOX (impl->filter_combo),
2825                                   filter_index);
2826
2827       install_list_model_filter (impl);
2828
2829       g_object_notify (G_OBJECT (impl), "filter");
2830     }
2831 }
2832
2833 static void
2834 open_and_close (GtkTreeView *tree_view,
2835                 GtkTreePath *target_path)
2836 {
2837   GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
2838   GtkTreeIter iter;
2839   GtkTreePath *path;
2840
2841   path = gtk_tree_path_new ();
2842   gtk_tree_path_append_index (path, 0);
2843
2844   gtk_tree_model_get_iter (model, &iter, path);
2845
2846   while (TRUE)
2847     {
2848       if (gtk_tree_path_is_ancestor (path, target_path) ||
2849           gtk_tree_path_compare (path, target_path) == 0)
2850         {
2851           GtkTreeIter child_iter;
2852           gtk_tree_view_expand_row (tree_view, path, FALSE);
2853           if (gtk_tree_model_iter_children (model, &child_iter, &iter))
2854             {
2855               iter = child_iter;
2856               gtk_tree_path_down (path);
2857               goto next;
2858             }
2859         }
2860       else
2861         gtk_tree_view_collapse_row (tree_view, path);
2862
2863       while (TRUE)
2864         {
2865           GtkTreeIter parent_iter;
2866           GtkTreeIter next_iter;
2867
2868           next_iter = iter;
2869           if (gtk_tree_model_iter_next (model, &next_iter))
2870             {
2871               iter = next_iter;
2872               gtk_tree_path_next (path);
2873               goto next;
2874             }
2875
2876           if (!gtk_tree_model_iter_parent (model, &parent_iter, &iter))
2877             goto out;
2878
2879           iter = parent_iter;
2880           gtk_tree_path_up (path);
2881         }
2882     next:
2883       ;
2884     }
2885
2886  out:
2887   gtk_tree_path_free (path);
2888 }
2889
2890 static void
2891 filter_combo_changed (GtkComboBox           *combo_box,
2892                       GtkFileChooserDefault *impl)
2893 {
2894   gint new_index = gtk_combo_box_get_active (combo_box);
2895   GtkFileFilter *new_filter = g_slist_nth_data (impl->filters, new_index);
2896
2897   set_current_filter (impl, new_filter);
2898 }
2899
2900 static void
2901 check_preview_change (GtkFileChooserDefault *impl)
2902 {
2903   const GtkFilePath *new_path = NULL;
2904
2905   /* FIXME #132255: Fixing preview for multiple selection involves getting the
2906    * full selection and diffing to find out what the most recently selected file
2907    * is; there is logic in GtkFileSelection that probably can be
2908    * copied.
2909    */
2910   if (impl->sort_model && !impl->select_multiple)
2911     {
2912       GtkTreeSelection *selection;
2913       GtkTreeIter iter;
2914
2915       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
2916       if (gtk_tree_selection_get_selected (selection, NULL, &iter))
2917         {
2918           GtkTreeIter child_iter;
2919
2920           gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
2921                                                           &child_iter, &iter);
2922
2923           new_path = _gtk_file_system_model_get_path (impl->list_model, &child_iter);
2924         }
2925     }
2926
2927   if (new_path != impl->preview_path &&
2928       !(new_path && impl->preview_path &&
2929         gtk_file_path_compare (new_path, impl->preview_path) == 0))
2930     {
2931       if (impl->preview_path)
2932         gtk_file_path_free (impl->preview_path);
2933
2934       if (new_path)
2935         impl->preview_path = gtk_file_path_copy (new_path);
2936       else
2937         impl->preview_path = NULL;
2938
2939       g_signal_emit_by_name (impl, "update-preview");
2940     }
2941 }
2942
2943 static void
2944 tree_selection_changed (GtkTreeSelection      *selection,
2945                         GtkFileChooserDefault *impl)
2946 {
2947   GtkTreeIter iter;
2948   const GtkFilePath *file_path;
2949   GtkTreePath *path;
2950
2951   /* FIXME #132255: Fixing this for multiple selection involves getting the full
2952    * selection and diffing to find out what the most recently selected file is;
2953    * there is logic in GtkFileSelection that probably can be copied;
2954    * check_preview_change() is similar.
2955    */
2956   if (impl->select_multiple
2957       || !gtk_tree_selection_get_selected (selection, NULL, &iter))
2958     return;
2959
2960   file_path = _gtk_file_system_model_get_path (impl->tree_model, &iter);
2961   if (impl->current_folder && gtk_file_path_compare (file_path, impl->current_folder) == 0)
2962     return;
2963
2964   /* Close the tree up to only the parents of the newly selected
2965    * node and it's immediate children are visible.
2966    */
2967   path = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->tree_model), &iter);
2968   open_and_close (GTK_TREE_VIEW (impl->tree), path);
2969   gtk_tree_path_free (path);
2970
2971   if (!impl->changing_folder)
2972     _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), file_path);
2973 }
2974
2975 /* Activates a volume by mounting it if necessary and then switching to its
2976  * base path.
2977  */
2978 static void
2979 shortcuts_activate_volume (GtkFileChooserDefault *impl,
2980                            GtkFileSystemVolume   *volume)
2981 {
2982   GtkFilePath *path;
2983
2984   if (!gtk_file_system_volume_get_is_mounted (impl->file_system, volume))
2985     {
2986       GError *error;
2987
2988       error = NULL;
2989       if (!gtk_file_system_volume_mount (impl->file_system, volume, &error))
2990         {
2991           char *msg;
2992
2993           msg = g_strdup_printf ("Could not mount %s:\n%s",
2994                                  gtk_file_system_volume_get_display_name (impl->file_system, volume),
2995                                  error->message);
2996           error_message (impl, msg);
2997           g_free (msg);
2998           g_error_free (error);
2999
3000           return;
3001         }
3002     }
3003
3004   path = gtk_file_system_volume_get_base_path (impl->file_system, volume);
3005   _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), path);
3006   gtk_file_path_free (path);
3007 }
3008
3009 /* Callback used when a row in the shortcuts list is activated */
3010 static void
3011 shortcuts_row_activated_cb (GtkTreeView           *tree_view,
3012                             GtkTreePath           *path,
3013                             GtkTreeViewColumn     *column,
3014                             GtkFileChooserDefault *impl)
3015 {
3016   GtkTreeIter iter;
3017   int selected, start_row;
3018   gpointer data;
3019
3020   if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->shortcuts_model), &iter, path))
3021     return;
3022
3023   selected = *gtk_tree_path_get_indices (path);
3024
3025   if (selected == shortcuts_get_index (impl, SHORTCUTS_SEPARATOR))
3026     return;
3027
3028   gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter, SHORTCUTS_COL_PATH, &data, -1);
3029
3030   start_row = shortcuts_get_index (impl, SHORTCUTS_VOLUMES);
3031   if (selected >= start_row && selected < start_row + impl->num_volumes)
3032     {
3033       GtkFileSystemVolume *volume;
3034
3035       volume = data;
3036       shortcuts_activate_volume (impl, volume);
3037     }
3038   else
3039     {
3040       GtkFilePath *file_path;
3041
3042       file_path = data;
3043       _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), file_path);
3044     }
3045 }
3046
3047 static gboolean
3048 shortcuts_select_func  (GtkTreeSelection  *selection,
3049                         GtkTreeModel      *model,
3050                         GtkTreePath       *path,
3051                         gboolean           path_currently_selected,
3052                         gpointer           data)
3053 {
3054   GtkFileChooserDefault *impl = data;
3055
3056   return (*gtk_tree_path_get_indices (path) != shortcuts_get_index (impl, SHORTCUTS_SEPARATOR));
3057 }
3058
3059 static void
3060 list_selection_changed (GtkTreeSelection      *selection,
3061                         GtkFileChooserDefault *impl)
3062 {
3063   /* See if we are in the new folder editable row for Save mode */
3064   if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
3065     {
3066       GtkTreeSelection *selection;
3067       GtkTreeIter iter, child_iter;
3068       const GtkFileInfo *info;
3069
3070       g_assert (!impl->select_multiple);
3071       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->list));
3072       if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
3073         return;
3074
3075       gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
3076                                                       &child_iter,
3077                                                       &iter);
3078
3079       info = _gtk_file_system_model_get_info (impl->list_model, &child_iter);
3080       if (!info)
3081         return; /* We are on the editable row for New Folder */
3082     }
3083
3084   update_chooser_entry (impl);
3085   check_preview_change (impl);
3086
3087   g_signal_emit_by_name (impl, "selection-changed", 0);
3088 }
3089
3090 /* Callback used when a row in the file list is activated */
3091 static void
3092 list_row_activated (GtkTreeView           *tree_view,
3093                     GtkTreePath           *path,
3094                     GtkTreeViewColumn     *column,
3095                     GtkFileChooserDefault *impl)
3096 {
3097   GtkTreeIter iter, child_iter;
3098   const GtkFileInfo *info;
3099
3100   if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->sort_model), &iter, path))
3101     return;
3102
3103   gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model, &child_iter, &iter);
3104
3105   info = _gtk_file_system_model_get_info (impl->list_model, &child_iter);
3106
3107   if (gtk_file_info_get_is_folder (info))
3108     {
3109       const GtkFilePath *file_path;
3110
3111       file_path = _gtk_file_system_model_get_path (impl->list_model, &child_iter);
3112       _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), file_path);
3113
3114       return;
3115     }
3116
3117   g_signal_emit_by_name (impl, "file-activated");
3118 }
3119
3120 static void
3121 path_bar_clicked (GtkPathBar            *path_bar,
3122                   GtkFilePath           *file_path,
3123                   GtkFileChooserDefault *impl)
3124 {
3125   _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), file_path);
3126 }
3127
3128 static const GtkFileInfo *
3129 get_list_file_info (GtkFileChooserDefault *impl,
3130                     GtkTreeIter           *iter)
3131 {
3132   GtkTreeIter child_iter;
3133
3134   gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
3135                                                   &child_iter,
3136                                                   iter);
3137
3138   return _gtk_file_system_model_get_info (impl->list_model, &child_iter);
3139 }
3140
3141 static void
3142 tree_name_data_func (GtkTreeViewColumn *tree_column,
3143                      GtkCellRenderer   *cell,
3144                      GtkTreeModel      *tree_model,
3145                      GtkTreeIter       *iter,
3146                      gpointer           data)
3147 {
3148   GtkFileChooserDefault *impl = data;
3149   const GtkFileInfo *info = _gtk_file_system_model_get_info (impl->tree_model, iter);
3150
3151   if (info)
3152     {
3153       g_object_set (cell,
3154                     "text", gtk_file_info_get_display_name (info),
3155                     NULL);
3156     }
3157 }
3158
3159 static void
3160 list_icon_data_func (GtkTreeViewColumn *tree_column,
3161                      GtkCellRenderer   *cell,
3162                      GtkTreeModel      *tree_model,
3163                      GtkTreeIter       *iter,
3164                      gpointer           data)
3165 {
3166   GtkFileChooserDefault *impl = data;
3167   GtkTreeIter child_iter;
3168   const GtkFilePath *path;
3169   GdkPixbuf *pixbuf;
3170
3171   gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
3172                                                   &child_iter,
3173                                                   iter);
3174   path = _gtk_file_system_model_get_path (impl->list_model, &child_iter);
3175   if (!path)
3176     return;
3177
3178   /* FIXME: NULL GError */
3179   pixbuf = gtk_file_system_render_icon (impl->file_system, path, GTK_WIDGET (impl), ICON_SIZE, NULL);
3180   g_object_set (cell,
3181                 "pixbuf", pixbuf,
3182                 NULL);
3183
3184   if (pixbuf)
3185     g_object_unref (pixbuf);
3186 }
3187
3188 /* Sets a cellrenderer's text, making it bold if the GtkFileInfo is a folder */
3189 static void
3190 set_cell_text_bold_if_folder (const GtkFileInfo *info, GtkCellRenderer *cell, const char *text)
3191 {
3192   g_object_set (cell,
3193                 "text", text,
3194                 "weight", gtk_file_info_get_is_folder (info) ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL,
3195                 NULL);
3196 }
3197
3198 static void
3199 list_name_data_func (GtkTreeViewColumn *tree_column,
3200                      GtkCellRenderer   *cell,
3201                      GtkTreeModel      *tree_model,
3202                      GtkTreeIter       *iter,
3203                      gpointer           data)
3204 {
3205   GtkFileChooserDefault *impl = data;
3206   const GtkFileInfo *info = get_list_file_info (impl, iter);
3207
3208   if (!info)
3209     {
3210       g_object_set (cell,
3211                     "text", _("Type name of new folder"),
3212                     NULL);
3213       return;
3214     }
3215
3216   set_cell_text_bold_if_folder (info, cell, gtk_file_info_get_display_name (info));
3217 }
3218
3219 #if 0
3220 static void
3221 list_size_data_func (GtkTreeViewColumn *tree_column,
3222                      GtkCellRenderer   *cell,
3223                      GtkTreeModel      *tree_model,
3224                      GtkTreeIter       *iter,
3225                      gpointer           data)
3226 {
3227   GtkFileChooserDefault *impl = data;
3228   const GtkFileInfo *info = get_list_file_info (impl, iter);
3229   gint64 size;
3230   gchar *str;
3231
3232   if (!info || gtk_file_info_get_is_folder (info))
3233     return;
3234
3235   size = gtk_file_info_get_size (info);
3236
3237   if (size < (gint64)1024)
3238     str = g_strdup_printf (ngettext ("%d byte", "%d bytes", (gint)size), (gint)size);
3239   else if (size < (gint64)1024*1024)
3240     str = g_strdup_printf (_("%.1f K"), size / (1024.));
3241   else if (size < (gint64)1024*1024*1024)
3242     str = g_strdup_printf (_("%.1f M"), size / (1024.*1024.));
3243   else
3244     str = g_strdup_printf (_("%.1f G"), size / (1024.*1024.*1024.));
3245
3246   g_object_set (cell,
3247                 "text", str,
3248                 NULL);
3249
3250   g_free (str);
3251 }
3252 #endif
3253
3254 /* Tree column data callback for the file list; fetches the mtime of a file */
3255 static void
3256 list_mtime_data_func (GtkTreeViewColumn *tree_column,
3257                       GtkCellRenderer   *cell,
3258                       GtkTreeModel      *tree_model,
3259                       GtkTreeIter       *iter,
3260                       gpointer           data)
3261 {
3262   GtkFileChooserDefault *impl;
3263   const GtkFileInfo *info;
3264   GtkFileTime time_mtime, time_now;
3265   GDate mtime, now;
3266   int days_diff;
3267   char buf[256];
3268
3269   impl = data;
3270
3271   info = get_list_file_info (impl, iter);
3272   if (!info)
3273     {
3274       g_object_set (cell,
3275                     "text", "",
3276                     NULL);
3277       return;
3278     }
3279
3280   time_mtime = gtk_file_info_get_modification_time (info);
3281   g_date_set_time (&mtime, (GTime) time_mtime);
3282
3283   time_now = (GTime ) time (NULL);
3284   g_date_set_time (&now, (GTime) time_now);
3285
3286   days_diff = g_date_get_julian (&now) - g_date_get_julian (&mtime);
3287
3288   if (days_diff == 0)
3289     strcpy (buf, _("Today"));
3290   else if (days_diff == 1)
3291     strcpy (buf, _("Yesterday"));
3292   else
3293     {
3294       char *format;
3295
3296       if (days_diff > 1 && days_diff < 7)
3297         format = "%A"; /* Days from last week */
3298       else
3299         format = _("%d/%b/%Y"); /* Any other date */
3300
3301       if (g_date_strftime (buf, sizeof (buf), format, &mtime) == 0)
3302         strcpy (buf, _("Unknown"));
3303     }
3304
3305   set_cell_text_bold_if_folder (info, cell, buf);
3306 }
3307
3308 GtkWidget *
3309 _gtk_file_chooser_default_new (const char *file_system)
3310 {
3311   return  g_object_new (GTK_TYPE_FILE_CHOOSER_DEFAULT,
3312                         "file-system-backend", file_system,
3313                         NULL);
3314 }
3315
3316 static GtkWidget *
3317 location_entry_create (GtkFileChooserDefault *impl)
3318 {
3319   GtkWidget *entry;
3320
3321   entry = _gtk_file_chooser_entry_new ();
3322   gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
3323   _gtk_file_chooser_entry_set_file_system (GTK_FILE_CHOOSER_ENTRY (entry), impl->file_system);
3324   _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (entry), impl->current_folder);
3325
3326   return GTK_WIDGET (entry);
3327 }
3328
3329 static void
3330 update_from_entry (GtkFileChooserDefault *impl,
3331                    GtkWindow             *parent,
3332                    GtkFileChooserEntry   *chooser_entry)
3333 {
3334   const GtkFilePath *folder_path;
3335   const char *file_part;
3336
3337   folder_path = _gtk_file_chooser_entry_get_current_folder (chooser_entry);
3338   file_part = _gtk_file_chooser_entry_get_file_part (chooser_entry);
3339
3340   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN && !folder_path)
3341     {
3342       error_message_with_parent (parent,
3343                                  _("Cannot change to the folder you specified as it is an invalid path."));
3344       return;
3345     }
3346
3347   if (file_part[0] == '\0')
3348     {
3349       _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), folder_path);
3350       return;
3351     }
3352   else
3353     {
3354       GtkFileFolder *folder = NULL;
3355       GtkFilePath *subfolder_path = NULL;
3356       GtkFileInfo *info = NULL;
3357       GError *error;
3358
3359       /* If the file part is non-empty, we need to figure out if it refers to a
3360        * folder within folder. We could optimize the case here where the folder
3361        * is already loaded for one of our tree models.
3362        */
3363
3364       error = NULL;
3365       folder = gtk_file_system_get_folder (impl->file_system, folder_path, GTK_FILE_INFO_IS_FOLDER, &error);
3366
3367       if (!folder)
3368         {
3369           error_getting_info_dialog (impl, folder_path, error);
3370           return;
3371         }
3372
3373       error = NULL;
3374       subfolder_path = gtk_file_system_make_path (impl->file_system, folder_path, file_part, &error);
3375
3376       if (!subfolder_path)
3377         {
3378           char *msg;
3379
3380           msg = g_strdup_printf (_("Could not build file name from '%s' and '%s':\n%s"),
3381                                  gtk_file_path_get_string (folder_path),
3382                                  file_part,
3383                                  error->message);
3384           error_message (impl, msg);
3385           g_free (msg);
3386           g_object_unref (folder);
3387           return;
3388         }
3389
3390       error = NULL;
3391       info = gtk_file_folder_get_info (folder, subfolder_path, &error);
3392
3393       if (!info)
3394         {
3395 #if 0
3396           if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
3397             {
3398               g_object_unref (folder);
3399               gtk_file_path_free (subfolder_path);
3400               return;
3401             }
3402 #endif
3403           error_getting_info_dialog (impl, subfolder_path, error);
3404           g_object_unref (folder);
3405           gtk_file_path_free (subfolder_path);
3406           return;
3407         }
3408
3409       if (gtk_file_info_get_is_folder (info))
3410         _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), subfolder_path);
3411       else
3412         _gtk_file_chooser_select_path (GTK_FILE_CHOOSER (impl), subfolder_path);
3413
3414       g_object_unref (folder);
3415       gtk_file_path_free (subfolder_path);
3416       gtk_file_info_free (info);
3417     }
3418 }
3419
3420 static void
3421 location_popup_handler (GtkFileChooserDefault *impl)
3422 {
3423   GtkWidget *dialog;
3424   GtkWidget *toplevel;
3425   GtkWidget *hbox;
3426   GtkWidget *label;
3427   GtkWidget *entry;
3428
3429   /* Create dialog */
3430
3431   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
3432   if (!GTK_WIDGET_TOPLEVEL (toplevel))
3433     toplevel = NULL;
3434
3435   dialog = gtk_dialog_new_with_buttons (_("Open Location"),
3436                                         GTK_WINDOW (toplevel),
3437                                         GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
3438                                         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
3439                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3440                                         NULL);
3441   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
3442
3443   hbox = gtk_hbox_new (FALSE, 12);
3444   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0);
3445
3446   label = gtk_label_new_with_mnemonic (_("_Location:"));
3447   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
3448
3449   entry = location_entry_create (impl);
3450   gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
3451   gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
3452
3453   /* Run */
3454
3455   gtk_widget_show_all (dialog);
3456   if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
3457     update_from_entry (impl, GTK_WINDOW (dialog), GTK_FILE_CHOOSER_ENTRY (entry));
3458
3459   gtk_widget_destroy (dialog);
3460 }
3461
3462 /* Handler for the "up-folder" keybinding signal */
3463 static void
3464 up_folder_handler (GtkFileChooserDefault *impl)
3465 {
3466   GtkFilePath *parent_path;
3467   GError *error;
3468
3469   error = NULL;
3470   if (gtk_file_system_get_parent (impl->file_system, impl->current_folder, &parent_path, &error))
3471     {
3472       if (parent_path) /* If we were on a root, parent_path will be NULL */
3473         {
3474           _gtk_file_chooser_set_current_folder_path (GTK_FILE_CHOOSER (impl), parent_path);
3475           gtk_file_path_free (parent_path);
3476         }
3477     }
3478   else
3479     error_dialog (impl,
3480                   _("Could not go to the parent folder of %s:\n%s"),
3481                   impl->current_folder,
3482                   error);
3483 }
3484
3485 /* Handler for the "home-folder" keybinding signal */
3486 static void
3487 home_folder_handler (GtkFileChooserDefault *impl)
3488 {
3489   const char *home;
3490
3491   /* Should we pull this information from impl->has_home and the shortcuts data
3492    * instead?  Sounds like a bit of overkill...
3493    */
3494
3495   home = g_get_home_dir ();
3496   gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (impl), home);
3497 }