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

   1 /* -*- Mode: C; c-file-style: "gnu"; tab-width: 8 -*- */
   2 /* GTK - The GIMP Toolkit
   3  * gtkfilechooserdefault.c: Default implementation of GtkFileChooser
   4  * Copyright (C) 2003, Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gtkfilechooserdefault.h"
  23
  24 #include "gtkbindings.h"
  25 #include "gtkcelllayout.h"
  26 #include "gtkcellrendererpixbuf.h"
  27 #include "gtkcellrenderertext.h"
  28 #include "gtkcheckmenuitem.h"
  29 #include "gtkclipboard.h"
  30 #include "gtkcomboboxtext.h"
  31 #include "gtkentry.h"
  32 #include "gtkexpander.h"
  33 #include "gtkfilechooserprivate.h"
  34 #include "gtkfilechooserdialog.h"
  35 #include "gtkfilechooserembed.h"
  36 #include "gtkfilechooserentry.h"
  37 #include "gtkfilechooserutils.h"
  38 #include "gtkfilechooser.h"
  39 #include "gtkfilesystem.h"
  40 #include "gtkfilesystemmodel.h"
  41 #include "gtkframe.h"
  42 #include "gtkgrid.h"
  43 #include "gtkiconfactory.h"
  44 #include "gtkicontheme.h"
  45 #include "gtkimage.h"
  46 #include "gtkimagemenuitem.h"
  47 #include "gtkinfobar.h"
  48 #include "gtklabel.h"
  49 #include "gtkmarshalers.h"
  50 #include "gtkmessagedialog.h"
  51 #include "gtkmountoperation.h"
  52 #include "gtkpaned.h"
  53 #include "gtkpathbar.h"
  54 #include "gtkprivate.h"
  55 #include "gtkradiobutton.h"
  56 #include "gtkrecentfilter.h"
  57 #include "gtkrecentmanager.h"
  58 #include "gtkscrolledwindow.h"
  59 #include "gtkseparatormenuitem.h"
  60 #include "gtksettings.h"
  61 #include "gtksizegroup.h"
  62 #include "gtksizerequest.h"
  63 #include "gtkstock.h"
  64 #include "gtktoolbar.h"
  65 #include "gtktoolbutton.h"
  66 #include "gtktooltip.h"
  67 #include "gtktreednd.h"
  68 #include "gtktreeprivate.h"
  69 #include "gtktreeselection.h"
  70 #include "gtkbox.h"
  71 #include "gtkorientable.h"
  72 #include "gtkintl.h"
  73
  74 #include <errno.h>
  75 #include <string.h>
  76 #include <time.h>
  77 #include <sys/stat.h>
  78 #include <sys/types.h>
  79 #include <locale.h>
  80
  81 #ifdef HAVE_UNISTD_H
  82 #include <unistd.h>
  83 #endif
  84 #ifdef G_OS_WIN32
  85 #include <io.h>
  86 #endif
  87
  88 /* Values for GtkSelection-related "info" fields */
  89 #define SELECTION_TEXT 0
  90 #define SELECTION_URI  1
  91
  92 /* Profiling stuff */
  93 #undef PROFILE_FILE_CHOOSER
  94 #ifdef PROFILE_FILE_CHOOSER
  95
  96
  97 #ifndef F_OK
  98 #define F_OK 0
  99 #endif
 100
 101 #define PROFILE_INDENT 4
 102
 103 static int profile_indent;
 104
 105 static void
 106 profile_add_indent (int indent)
 107 {
 108   profile_indent += indent;
 109   if (profile_indent < 0)
 110     g_error ("You screwed up your indentation");
 111 }
 112
 113 void
 114 _gtk_file_chooser_profile_log (const char *func, int indent, const char *msg1, const char *msg2)
 115 {
 116   char *str;
 117
 118   if (indent < 0)
 119     profile_add_indent (indent);
 120
 121   if (profile_indent == 0)
 122     str = g_strdup_printf ("MARK: %s %s %s", func ? func : "", msg1 ? msg1 : "", msg2 ? msg2 : "");
 123   else
 124     str = g_strdup_printf ("MARK: %*c %s %s %s", profile_indent - 1, ' ', func ? func : "", msg1 ? msg1 : "", msg2 ? msg2 : "");
 125
 126   access (str, F_OK);
 127   g_free (str);
 128
 129   if (indent > 0)
 130     profile_add_indent (indent);
 131 }
 132
 133 #define profile_start(x, y) _gtk_file_chooser_profile_log (G_STRFUNC, PROFILE_INDENT, x, y)
 134 #define profile_end(x, y) _gtk_file_chooser_profile_log (G_STRFUNC, -PROFILE_INDENT, x, y)
 135 #define profile_msg(x, y) _gtk_file_chooser_profile_log (NULL, 0, x, y)
 136 #else
 137 #define profile_start(x, y)
 138 #define profile_end(x, y)
 139 #define profile_msg(x, y)
 140 #endif
 141
 142
 143
 144 typedef struct _GtkFileChooserDefaultClass GtkFileChooserDefaultClass;
 145
 146 #define GTK_FILE_CHOOSER_DEFAULT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_DEFAULT, GtkFileChooserDefaultClass))
 147 #define GTK_IS_FILE_CHOOSER_DEFAULT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_DEFAULT))
 148 #define GTK_FILE_CHOOSER_DEFAULT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_DEFAULT, GtkFileChooserDefaultClass))
 149
 150 #define MAX_LOADING_TIME 500
 151
 152 #define DEFAULT_NEW_FOLDER_NAME _("Type name of new folder")
 153
 154 struct _GtkFileChooserDefaultClass
 155 {
 156   GtkBoxClass parent_class;
 157 };
 158
 159 /* Signal IDs */
 160 enum {
 161   LOCATION_POPUP,
 162   LOCATION_POPUP_ON_PASTE,
 163   UP_FOLDER,
 164   DOWN_FOLDER,
 165   HOME_FOLDER,
 166   DESKTOP_FOLDER,
 167   QUICK_BOOKMARK,
 168   LOCATION_TOGGLE_POPUP,
 169   SHOW_HIDDEN,
 170   SEARCH_SHORTCUT,
 171   RECENT_SHORTCUT,
 172
 173   LAST_SIGNAL
 174 };
 175
 176 static guint signals[LAST_SIGNAL] = { 0 };
 177
 178 /* Column numbers for the shortcuts tree.  Keep these in sync with shortcuts_model_create() */
 179 enum {
 180   SHORTCUTS_COL_PIXBUF,
 181   SHORTCUTS_COL_NAME,
 182   SHORTCUTS_COL_DATA,
 183   SHORTCUTS_COL_TYPE,
 184   SHORTCUTS_COL_REMOVABLE,
 185   SHORTCUTS_COL_PIXBUF_VISIBLE,
 186   SHORTCUTS_COL_CANCELLABLE,
 187   SHORTCUTS_COL_NUM_COLUMNS
 188 };
 189
 190 typedef enum {
 191   SHORTCUT_TYPE_FILE,
 192   SHORTCUT_TYPE_VOLUME,
 193   SHORTCUT_TYPE_SEPARATOR,
 194   SHORTCUT_TYPE_SEARCH,
 195   SHORTCUT_TYPE_RECENT
 196 } ShortcutType;
 197
 198 #define MODEL_ATTRIBUTES "standard::name,standard::type,standard::display-name," \
 199                          "standard::is-hidden,standard::is-backup,standard::size," \
 200                          "standard::content-type,time::modified"
 201 enum {
 202   /* the first 3 must be these due to settings caching sort column */
 203   MODEL_COL_NAME,
 204   MODEL_COL_SIZE,
 205   MODEL_COL_MTIME,
 206   MODEL_COL_FILE,
 207   MODEL_COL_NAME_COLLATED,
 208   MODEL_COL_IS_FOLDER,
 209   MODEL_COL_IS_SENSITIVE,
 210   MODEL_COL_PIXBUF,
 211   MODEL_COL_SIZE_TEXT,
 212   MODEL_COL_MTIME_TEXT,
 213   MODEL_COL_ELLIPSIZE,
 214   MODEL_COL_NUM_COLUMNS
 215 };
 216
 217 /* This list of types is passed to _gtk_file_system_model_new*() */
 218 #define MODEL_COLUMN_TYPES                                      \
 219         MODEL_COL_NUM_COLUMNS,                                  \
 220         G_TYPE_STRING,            /* MODEL_COL_NAME */          \
 221         G_TYPE_INT64,             /* MODEL_COL_SIZE */          \
 222         G_TYPE_LONG,              /* MODEL_COL_MTIME */         \
 223         G_TYPE_FILE,              /* MODEL_COL_FILE */          \
 224         G_TYPE_STRING,            /* MODEL_COL_NAME_COLLATED */ \
 225         G_TYPE_BOOLEAN,           /* MODEL_COL_IS_FOLDER */     \
 226         G_TYPE_BOOLEAN,           /* MODEL_COL_IS_SENSITIVE */  \
 227         GDK_TYPE_PIXBUF,          /* MODEL_COL_PIXBUF */        \
 228         G_TYPE_STRING,            /* MODEL_COL_SIZE_TEXT */     \
 229         G_TYPE_STRING,            /* MODEL_COL_MTIME_TEXT */    \
 230         PANGO_TYPE_ELLIPSIZE_MODE /* MODEL_COL_ELLIPSIZE */
 231
 232 /* Identifiers for target types */
 233 enum {
 234   GTK_TREE_MODEL_ROW,
 235 };
 236
 237 /* Interesting places in the shortcuts bar */
 238 typedef enum {
 239   SHORTCUTS_SEARCH,
 240   SHORTCUTS_RECENT,
 241   SHORTCUTS_RECENT_SEPARATOR,
 242   SHORTCUTS_HOME,
 243   SHORTCUTS_DESKTOP,
 244   SHORTCUTS_VOLUMES,
 245   SHORTCUTS_SHORTCUTS,
 246   SHORTCUTS_BOOKMARKS_SEPARATOR,
 247   SHORTCUTS_BOOKMARKS,
 248   SHORTCUTS_CURRENT_FOLDER_SEPARATOR,
 249   SHORTCUTS_CURRENT_FOLDER
 250 } ShortcutsIndex;
 251
 252 /* Icon size for if we can't get it from the theme */
 253 #define FALLBACK_ICON_SIZE 16
 254
 255 #define PREVIEW_HBOX_SPACING 12
 256 #define NUM_LINES 45
 257 #define NUM_CHARS 60
 258
 259 static void gtk_file_chooser_default_iface_init       (GtkFileChooserIface        *iface);
 260 static void gtk_file_chooser_embed_default_iface_init (GtkFileChooserEmbedIface   *iface);
 261
 262 static GObject* gtk_file_chooser_default_constructor  (GType                  type,
 263                                                        guint                  n_construct_properties,
 264                                                        GObjectConstructParam *construct_params);
 265 static void     gtk_file_chooser_default_finalize     (GObject               *object);
 266 static void     gtk_file_chooser_default_set_property (GObject               *object,
 267                                                        guint                  prop_id,
 268                                                        const GValue          *value,
 269                                                        GParamSpec            *pspec);
 270 static void     gtk_file_chooser_default_get_property (GObject               *object,
 271                                                        guint                  prop_id,
 272                                                        GValue                *value,
 273                                                        GParamSpec            *pspec);
 274 static void     gtk_file_chooser_default_dispose      (GObject               *object);
 275 static void     gtk_file_chooser_default_show_all       (GtkWidget             *widget);
 276 static void     gtk_file_chooser_default_realize        (GtkWidget             *widget);
 277 static void     gtk_file_chooser_default_map            (GtkWidget             *widget);
 278 static void     gtk_file_chooser_default_unmap          (GtkWidget             *widget);
 279 static void     gtk_file_chooser_default_hierarchy_changed (GtkWidget          *widget,
 280                                                             GtkWidget          *previous_toplevel);
 281 static void     gtk_file_chooser_default_style_updated  (GtkWidget             *widget);
 282 static void     gtk_file_chooser_default_screen_changed (GtkWidget             *widget,
 283                                                          GdkScreen             *previous_screen);
 284
 285 static gboolean       gtk_file_chooser_default_set_current_folder          (GtkFileChooser    *chooser,
 286                                                                             GFile             *folder,
 287                                                                             GError           **error);
 288 static gboolean       gtk_file_chooser_default_update_current_folder       (GtkFileChooser    *chooser,
 289                                                                             GFile             *folder,
 290                                                                             gboolean           keep_trail,
 291                                                                             gboolean           clear_entry,
 292                                                                             GError           **error);
 293 static GFile *        gtk_file_chooser_default_get_current_folder          (GtkFileChooser    *chooser);
 294 static void           gtk_file_chooser_default_set_current_name            (GtkFileChooser    *chooser,
 295                                                                             const gchar       *name);
 296 static gboolean       gtk_file_chooser_default_select_file                 (GtkFileChooser    *chooser,
 297                                                                             GFile             *file,
 298                                                                             GError           **error);
 299 static void           gtk_file_chooser_default_unselect_file               (GtkFileChooser    *chooser,
 300                                                                             GFile             *file);
 301 static void           gtk_file_chooser_default_select_all                  (GtkFileChooser    *chooser);
 302 static void           gtk_file_chooser_default_unselect_all                (GtkFileChooser    *chooser);
 303 static GSList *       gtk_file_chooser_default_get_files                   (GtkFileChooser    *chooser);
 304 static GFile *        gtk_file_chooser_default_get_preview_file            (GtkFileChooser    *chooser);
 305 static GtkFileSystem *gtk_file_chooser_default_get_file_system             (GtkFileChooser    *chooser);
 306 static void           gtk_file_chooser_default_add_filter                  (GtkFileChooser    *chooser,
 307                                                                             GtkFileFilter     *filter);
 308 static void           gtk_file_chooser_default_remove_filter               (GtkFileChooser    *chooser,
 309                                                                             GtkFileFilter     *filter);
 310 static GSList *       gtk_file_chooser_default_list_filters                (GtkFileChooser    *chooser);
 311 static gboolean       gtk_file_chooser_default_add_shortcut_folder    (GtkFileChooser    *chooser,
 312                                                                        GFile             *file,
 313                                                                        GError           **error);
 314 static gboolean       gtk_file_chooser_default_remove_shortcut_folder (GtkFileChooser    *chooser,
 315                                                                        GFile             *file,
 316                                                                        GError           **error);
 317 static GSList *       gtk_file_chooser_default_list_shortcut_folders  (GtkFileChooser    *chooser);
 318
 319 static void           gtk_file_chooser_default_get_default_size       (GtkFileChooserEmbed *chooser_embed,
 320                                                                        gint                *default_width,
 321                                                                        gint                *default_height);
 322 static gboolean       gtk_file_chooser_default_should_respond         (GtkFileChooserEmbed *chooser_embed);
 323 static void           gtk_file_chooser_default_initial_focus          (GtkFileChooserEmbed *chooser_embed);
 324
 325 static void add_selection_to_recent_list (GtkFileChooserDefault *impl);
 326
 327 static void location_popup_handler  (GtkFileChooserDefault *impl,
 328                                      const gchar           *path);
 329 static void location_popup_on_paste_handler (GtkFileChooserDefault *impl);
 330 static void location_toggle_popup_handler   (GtkFileChooserDefault *impl);
 331 static void up_folder_handler       (GtkFileChooserDefault *impl);
 332 static void down_folder_handler     (GtkFileChooserDefault *impl);
 333 static void home_folder_handler     (GtkFileChooserDefault *impl);
 334 static void desktop_folder_handler  (GtkFileChooserDefault *impl);
 335 static void quick_bookmark_handler  (GtkFileChooserDefault *impl,
 336                                      gint                   bookmark_index);
 337 static void show_hidden_handler     (GtkFileChooserDefault *impl);
 338 static void search_shortcut_handler (GtkFileChooserDefault *impl);
 339 static void recent_shortcut_handler (GtkFileChooserDefault *impl);
 340 static void update_appearance       (GtkFileChooserDefault *impl);
 341
 342 static void set_current_filter   (GtkFileChooserDefault *impl,
 343                                   GtkFileFilter         *filter);
 344 static void check_preview_change (GtkFileChooserDefault *impl);
 345
 346 static void filter_combo_changed       (GtkComboBox           *combo_box,
 347                                         GtkFileChooserDefault *impl);
 348
 349 static gboolean shortcuts_key_press_event_cb (GtkWidget             *widget,
 350                                               GdkEventKey           *event,
 351                                               GtkFileChooserDefault *impl);
 352
 353 static gboolean shortcuts_select_func   (GtkTreeSelection      *selection,
 354                                          GtkTreeModel          *model,
 355                                          GtkTreePath           *path,
 356                                          gboolean               path_currently_selected,
 357                                          gpointer               data);
 358 static gboolean shortcuts_get_selected  (GtkFileChooserDefault *impl,
 359                                          GtkTreeIter           *iter);
 360 static void shortcuts_activate_iter (GtkFileChooserDefault *impl,
 361                                      GtkTreeIter           *iter);
 362 static int shortcuts_get_index (GtkFileChooserDefault *impl,
 363                                 ShortcutsIndex         where);
 364 static int shortcut_find_position (GtkFileChooserDefault *impl,
 365                                    GFile                 *file);
 366
 367 static void bookmarks_check_add_sensitivity (GtkFileChooserDefault *impl);
 368
 369 static gboolean list_select_func   (GtkTreeSelection      *selection,
 370                                     GtkTreeModel          *model,
 371                                     GtkTreePath           *path,
 372                                     gboolean               path_currently_selected,
 373                                     gpointer               data);
 374
 375 static void list_selection_changed     (GtkTreeSelection      *tree_selection,
 376                                         GtkFileChooserDefault *impl);
 377 static void list_row_activated         (GtkTreeView           *tree_view,
 378                                         GtkTreePath           *path,
 379                                         GtkTreeViewColumn     *column,
 380                                         GtkFileChooserDefault *impl);
 381
 382 static void path_bar_clicked (GtkPathBar            *path_bar,
 383                               GFile                 *file,
 384                               GFile                 *child,
 385                               gboolean               child_is_hidden,
 386                               GtkFileChooserDefault *impl);
 387
 388 static void add_bookmark_button_clicked_cb    (GtkButton             *button,
 389                                                GtkFileChooserDefault *impl);
 390 static void remove_bookmark_button_clicked_cb (GtkButton             *button,
 391                                                GtkFileChooserDefault *impl);
 392
 393 static void update_cell_renderer_attributes (GtkFileChooserDefault *impl);
 394
 395 static void load_remove_timer (GtkFileChooserDefault *impl, LoadState new_load_state);
 396 static void browse_files_center_selected_row (GtkFileChooserDefault *impl);
 397
 398 static void location_button_toggled_cb (GtkToggleButton *toggle,
 399                                         GtkFileChooserDefault *impl);
 400 static void location_switch_to_path_bar (GtkFileChooserDefault *impl);
 401
 402 static void stop_loading_and_clear_list_model (GtkFileChooserDefault *impl,
 403                                                gboolean remove_from_treeview);
 404
 405 static void     search_setup_widgets         (GtkFileChooserDefault *impl);
 406 static void     search_stop_searching        (GtkFileChooserDefault *impl,
 407                                               gboolean               remove_query);
 408 static void     search_clear_model           (GtkFileChooserDefault *impl,
 409                                               gboolean               remove_from_treeview);
 410 static gboolean search_should_respond        (GtkFileChooserDefault *impl);
 411 static GSList  *search_get_selected_files    (GtkFileChooserDefault *impl);
 412 static void     search_entry_activate_cb     (GtkEntry              *entry,
 413                                               gpointer               data);
 414 static void     settings_load                (GtkFileChooserDefault *impl);
 415
 416 static void     recent_start_loading         (GtkFileChooserDefault *impl);
 417 static void     recent_stop_loading          (GtkFileChooserDefault *impl);
 418 static void     recent_clear_model           (GtkFileChooserDefault *impl,
 419                                               gboolean               remove_from_treeview);
 420 static gboolean recent_should_respond        (GtkFileChooserDefault *impl);
 421 static GSList * recent_get_selected_files    (GtkFileChooserDefault *impl);
 422 static void     set_file_system_backend      (GtkFileChooserDefault *impl);
 423 static void     unset_file_system_backend    (GtkFileChooserDefault *impl);
 424
 425
 426
 427 \f
 428
 429 /* Drag and drop interface declarations */
 430
 431 typedef struct {
 432   GtkTreeModelFilter parent;
 433
 434   GtkFileChooserDefault *impl;
 435 } ShortcutsPaneModelFilter;
 436
 437 typedef struct {
 438   GtkTreeModelFilterClass parent_class;
 439 } ShortcutsPaneModelFilterClass;
 440
 441 #define SHORTCUTS_PANE_MODEL_FILTER_TYPE (_shortcuts_pane_model_filter_get_type ())
 442 #define SHORTCUTS_PANE_MODEL_FILTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SHORTCUTS_PANE_MODEL_FILTER_TYPE, ShortcutsPaneModelFilter))
 443
 444 static void shortcuts_pane_model_filter_drag_source_iface_init (GtkTreeDragSourceIface *iface);
 445
 446 GType _shortcuts_pane_model_filter_get_type (void);
 447
 448 G_DEFINE_TYPE_WITH_CODE (ShortcutsPaneModelFilter,
 449                          _shortcuts_pane_model_filter,
 450                          GTK_TYPE_TREE_MODEL_FILTER,
 451                          G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
 452                                                 shortcuts_pane_model_filter_drag_source_iface_init))
 453
 454 static GtkTreeModel *shortcuts_pane_model_filter_new (GtkFileChooserDefault *impl,
 455                                                       GtkTreeModel          *child_model,
 456                                                       GtkTreePath           *root);
 457
 458 \f
 459
 460 G_DEFINE_TYPE_WITH_CODE (GtkFileChooserDefault, _gtk_file_chooser_default, GTK_TYPE_BOX,
 461                          G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER,
 462                                                 gtk_file_chooser_default_iface_init)
 463                          G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER_EMBED,
 464                                                 gtk_file_chooser_embed_default_iface_init));
 465
 466
 467 static void
 468 add_normal_and_shifted_binding (GtkBindingSet  *binding_set,
 469                                 guint           keyval,
 470                                 GdkModifierType modifiers,
 471                                 const gchar    *signal_name)
 472 {
 473   gtk_binding_entry_add_signal (binding_set,
 474                                 keyval, modifiers,
 475                                 signal_name, 0);
 476
 477   gtk_binding_entry_add_signal (binding_set,
 478                                 keyval, modifiers | GDK_SHIFT_MASK,
 479                                 signal_name, 0);
 480 }
 481
 482 static void
 483 _gtk_file_chooser_default_class_init (GtkFileChooserDefaultClass *class)
 484 {
 485   static const guint quick_bookmark_keyvals[10] = {
 486     GDK_KEY_1, GDK_KEY_2, GDK_KEY_3, GDK_KEY_4, GDK_KEY_5, GDK_KEY_6, GDK_KEY_7, GDK_KEY_8, GDK_KEY_9, GDK_KEY_0
 487   };
 488   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 489   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 490   GtkBindingSet *binding_set;
 491   int i;
 492
 493   gobject_class->finalize = gtk_file_chooser_default_finalize;
 494   gobject_class->constructor = gtk_file_chooser_default_constructor;
 495   gobject_class->set_property = gtk_file_chooser_default_set_property;
 496   gobject_class->get_property = gtk_file_chooser_default_get_property;
 497   gobject_class->dispose = gtk_file_chooser_default_dispose;
 498
 499   widget_class->show_all = gtk_file_chooser_default_show_all;
 500   widget_class->realize = gtk_file_chooser_default_realize;
 501   widget_class->map = gtk_file_chooser_default_map;
 502   widget_class->unmap = gtk_file_chooser_default_unmap;
 503   widget_class->hierarchy_changed = gtk_file_chooser_default_hierarchy_changed;
 504   widget_class->style_updated = gtk_file_chooser_default_style_updated;
 505   widget_class->screen_changed = gtk_file_chooser_default_screen_changed;
 506
 507   signals[LOCATION_POPUP] =
 508     g_signal_new_class_handler (I_("location-popup"),
 509                                 G_OBJECT_CLASS_TYPE (class),
 510                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 511                                 G_CALLBACK (location_popup_handler),
 512                                 NULL, NULL,
 513                                 _gtk_marshal_VOID__STRING,
 514                                 G_TYPE_NONE, 1, G_TYPE_STRING);
 515
 516   signals[LOCATION_POPUP_ON_PASTE] =
 517     g_signal_new_class_handler (I_("location-popup-on-paste"),
 518                                 G_OBJECT_CLASS_TYPE (class),
 519                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 520                                 G_CALLBACK (location_popup_on_paste_handler),
 521                                 NULL, NULL,
 522                                 _gtk_marshal_VOID__VOID,
 523                                 G_TYPE_NONE, 0);
 524
 525   signals[LOCATION_TOGGLE_POPUP] =
 526     g_signal_new_class_handler (I_("location-toggle-popup"),
 527                                 G_OBJECT_CLASS_TYPE (class),
 528                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 529                                 G_CALLBACK (location_toggle_popup_handler),
 530                                 NULL, NULL,
 531                                 _gtk_marshal_VOID__VOID,
 532                                 G_TYPE_NONE, 0);
 533
 534   signals[UP_FOLDER] =
 535     g_signal_new_class_handler (I_("up-folder"),
 536                                 G_OBJECT_CLASS_TYPE (class),
 537                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 538                                 G_CALLBACK (up_folder_handler),
 539                                 NULL, NULL,
 540                                 _gtk_marshal_VOID__VOID,
 541                                 G_TYPE_NONE, 0);
 542
 543   signals[DOWN_FOLDER] =
 544     g_signal_new_class_handler (I_("down-folder"),
 545                                 G_OBJECT_CLASS_TYPE (class),
 546                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 547                                 G_CALLBACK (down_folder_handler),
 548                                 NULL, NULL,
 549                                 _gtk_marshal_VOID__VOID,
 550                                 G_TYPE_NONE, 0);
 551
 552   signals[HOME_FOLDER] =
 553     g_signal_new_class_handler (I_("home-folder"),
 554                                 G_OBJECT_CLASS_TYPE (class),
 555                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 556                                 G_CALLBACK (home_folder_handler),
 557                                 NULL, NULL,
 558                                 _gtk_marshal_VOID__VOID,
 559                                 G_TYPE_NONE, 0);
 560
 561   signals[DESKTOP_FOLDER] =
 562     g_signal_new_class_handler (I_("desktop-folder"),
 563                                 G_OBJECT_CLASS_TYPE (class),
 564                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 565                                 G_CALLBACK (desktop_folder_handler),
 566                                 NULL, NULL,
 567                                 _gtk_marshal_VOID__VOID,
 568                                 G_TYPE_NONE, 0);
 569
 570   signals[QUICK_BOOKMARK] =
 571     g_signal_new_class_handler (I_("quick-bookmark"),
 572                                 G_OBJECT_CLASS_TYPE (class),
 573                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 574                                 G_CALLBACK (quick_bookmark_handler),
 575                                 NULL, NULL,
 576                                 _gtk_marshal_VOID__INT,
 577                                 G_TYPE_NONE, 1, G_TYPE_INT);
 578
 579   signals[SHOW_HIDDEN] =
 580     g_signal_new_class_handler (I_("show-hidden"),
 581                                 G_OBJECT_CLASS_TYPE (class),
 582                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 583                                 G_CALLBACK (show_hidden_handler),
 584                                 NULL, NULL,
 585                                 _gtk_marshal_VOID__VOID,
 586                                 G_TYPE_NONE, 0);
 587
 588   signals[SEARCH_SHORTCUT] =
 589     g_signal_new_class_handler (I_("search-shortcut"),
 590                                 G_OBJECT_CLASS_TYPE (class),
 591                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 592                                 G_CALLBACK (search_shortcut_handler),
 593                                 NULL, NULL,
 594                                 _gtk_marshal_VOID__VOID,
 595                                 G_TYPE_NONE, 0);
 596
 597   signals[RECENT_SHORTCUT] =
 598     g_signal_new_class_handler (I_("recent-shortcut"),
 599                                 G_OBJECT_CLASS_TYPE (class),
 600                                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 601                                 G_CALLBACK (recent_shortcut_handler),
 602                                 NULL, NULL,
 603                                 _gtk_marshal_VOID__VOID,
 604                                 G_TYPE_NONE, 0);
 605
 606   binding_set = gtk_binding_set_by_class (class);
 607
 608   gtk_binding_entry_add_signal (binding_set,
 609                                 GDK_KEY_l, GDK_CONTROL_MASK,
 610                                 "location-toggle-popup",
 611                                 0);
 612
 613   gtk_binding_entry_add_signal (binding_set,
 614                                 GDK_KEY_slash, 0,
 615                                 "location-popup",
 616                                 1, G_TYPE_STRING, "/");
 617   gtk_binding_entry_add_signal (binding_set,
 618                                 GDK_KEY_KP_Divide, 0,
 619                                 "location-popup",
 620                                 1, G_TYPE_STRING, "/");
 621
 622 #ifdef G_OS_UNIX
 623   gtk_binding_entry_add_signal (binding_set,
 624                                 GDK_KEY_asciitilde, 0,
 625                                 "location-popup",
 626                                 1, G_TYPE_STRING, "~");
 627 #endif
 628
 629   gtk_binding_entry_add_signal (binding_set,
 630                                 GDK_KEY_v, GDK_CONTROL_MASK,
 631                                 "location-popup-on-paste",
 632                                 0);
 633
 634   add_normal_and_shifted_binding (binding_set,
 635                                   GDK_KEY_Up, GDK_MOD1_MASK,
 636                                   "up-folder");
 637
 638   add_normal_and_shifted_binding (binding_set,
 639                                   GDK_KEY_KP_Up, GDK_MOD1_MASK,
 640                                   "up-folder");
 641
 642   add_normal_and_shifted_binding (binding_set,
 643                                   GDK_KEY_Down, GDK_MOD1_MASK,
 644                                   "down-folder");
 645   add_normal_and_shifted_binding (binding_set,
 646                                   GDK_KEY_KP_Down, GDK_MOD1_MASK,
 647                                   "down-folder");
 648
 649   gtk_binding_entry_add_signal (binding_set,
 650                                 GDK_KEY_Home, GDK_MOD1_MASK,
 651                                 "home-folder",
 652                                 0);
 653   gtk_binding_entry_add_signal (binding_set,
 654                                 GDK_KEY_KP_Home, GDK_MOD1_MASK,
 655                                 "home-folder",
 656                                 0);
 657   gtk_binding_entry_add_signal (binding_set,
 658                                 GDK_KEY_d, GDK_MOD1_MASK,
 659                                 "desktop-folder",
 660                                 0);
 661   gtk_binding_entry_add_signal (binding_set,
 662                                 GDK_KEY_h, GDK_CONTROL_MASK,
 663                                 "show-hidden",
 664                                 0);
 665   gtk_binding_entry_add_signal (binding_set,
 666                                 GDK_KEY_s, GDK_MOD1_MASK,
 667                                 "search-shortcut",
 668                                 0);
 669   gtk_binding_entry_add_signal (binding_set,
 670                                 GDK_KEY_r, GDK_MOD1_MASK,
 671                                 "recent-shortcut",
 672                                 0);
 673
 674   for (i = 0; i < 10; i++)
 675     gtk_binding_entry_add_signal (binding_set,
 676                                   quick_bookmark_keyvals[i], GDK_MOD1_MASK,
 677                                   "quick-bookmark",
 678                                   1, G_TYPE_INT, i);
 679
 680   _gtk_file_chooser_install_properties (gobject_class);
 681 }
 682
 683 static void
 684 gtk_file_chooser_default_iface_init (GtkFileChooserIface *iface)
 685 {
 686   iface->select_file = gtk_file_chooser_default_select_file;
 687   iface->unselect_file = gtk_file_chooser_default_unselect_file;
 688   iface->select_all = gtk_file_chooser_default_select_all;
 689   iface->unselect_all = gtk_file_chooser_default_unselect_all;
 690   iface->get_files = gtk_file_chooser_default_get_files;
 691   iface->get_preview_file = gtk_file_chooser_default_get_preview_file;
 692   iface->get_file_system = gtk_file_chooser_default_get_file_system;
 693   iface->set_current_folder = gtk_file_chooser_default_set_current_folder;
 694   iface->get_current_folder = gtk_file_chooser_default_get_current_folder;
 695   iface->set_current_name = gtk_file_chooser_default_set_current_name;
 696   iface->add_filter = gtk_file_chooser_default_add_filter;
 697   iface->remove_filter = gtk_file_chooser_default_remove_filter;
 698   iface->list_filters = gtk_file_chooser_default_list_filters;
 699   iface->add_shortcut_folder = gtk_file_chooser_default_add_shortcut_folder;
 700   iface->remove_shortcut_folder = gtk_file_chooser_default_remove_shortcut_folder;
 701   iface->list_shortcut_folders = gtk_file_chooser_default_list_shortcut_folders;
 702 }
 703
 704 static void
 705 gtk_file_chooser_embed_default_iface_init (GtkFileChooserEmbedIface *iface)
 706 {
 707   iface->get_default_size = gtk_file_chooser_default_get_default_size;
 708   iface->should_respond = gtk_file_chooser_default_should_respond;
 709   iface->initial_focus = gtk_file_chooser_default_initial_focus;
 710 }
 711
 712 static void
 713 _gtk_file_chooser_default_init (GtkFileChooserDefault *impl)
 714 {
 715   profile_start ("start", NULL);
 716 #ifdef PROFILE_FILE_CHOOSER
 717   access ("MARK: *** CREATE FILE CHOOSER", F_OK);
 718 #endif
 719   impl->local_only = TRUE;
 720   impl->preview_widget_active = TRUE;
 721   impl->use_preview_label = TRUE;
 722   impl->select_multiple = FALSE;
 723   impl->show_hidden = FALSE;
 724   impl->show_size_column = TRUE;
 725   impl->icon_size = FALLBACK_ICON_SIZE;
 726   impl->load_state = LOAD_EMPTY;
 727   impl->reload_state = RELOAD_EMPTY;
 728   impl->pending_select_files = NULL;
 729   impl->location_mode = LOCATION_MODE_PATH_BAR;
 730   impl->operation_mode = OPERATION_MODE_BROWSE;
 731   impl->sort_column = MODEL_COL_NAME;
 732   impl->sort_order = GTK_SORT_ASCENDING;
 733   impl->recent_manager = gtk_recent_manager_get_default ();
 734   impl->create_folders = TRUE;
 735
 736   gtk_orientable_set_orientation (GTK_ORIENTABLE (impl),
 737                                   GTK_ORIENTATION_VERTICAL);
 738   gtk_box_set_spacing (GTK_BOX (impl), 12);
 739
 740   set_file_system_backend (impl);
 741
 742   profile_end ("end", NULL);
 743 }
 744
 745 /* Frees the data columns for the specified iter in the shortcuts model*/
 746 static void
 747 shortcuts_free_row_data (GtkFileChooserDefault *impl,
 748                          GtkTreeIter           *iter)
 749 {
 750   gpointer col_data;
 751   ShortcutType shortcut_type;
 752   GCancellable *cancellable;
 753
 754   gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), iter,
 755                       SHORTCUTS_COL_DATA, &col_data,
 756                       SHORTCUTS_COL_TYPE, &shortcut_type,
 757                       SHORTCUTS_COL_CANCELLABLE, &cancellable,
 758                       -1);
 759
 760   if (cancellable)
 761     {
 762       g_cancellable_cancel (cancellable);
 763       g_object_unref (cancellable);
 764     }
 765
 766   if (!(shortcut_type == SHORTCUT_TYPE_FILE ||
 767         shortcut_type == SHORTCUT_TYPE_VOLUME) ||
 768       !col_data)
 769     return;
 770
 771   if (shortcut_type == SHORTCUT_TYPE_VOLUME)
 772     {
 773       GtkFileSystemVolume *volume;
 774
 775       volume = col_data;
 776       _gtk_file_system_volume_unref (volume);
 777     }
 778   if (shortcut_type == SHORTCUT_TYPE_FILE)
 779     {
 780       GFile *file;
 781
 782       file = col_data;
 783       g_object_unref (file);
 784     }
 785 }
 786
 787 /* Frees all the data columns in the shortcuts model */
 788 static void
 789 shortcuts_free (GtkFileChooserDefault *impl)
 790 {
 791   GtkTreeIter iter;
 792
 793   if (!impl->shortcuts_model)
 794     return;
 795
 796   if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
 797     do
 798       {
 799         shortcuts_free_row_data (impl, &iter);
 800       }
 801     while (gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter));
 802
 803   g_object_unref (impl->shortcuts_model);
 804   impl->shortcuts_model = NULL;
 805 }
 806
 807 static void
 808 pending_select_files_free (GtkFileChooserDefault *impl)
 809 {
 810   g_slist_free_full (impl->pending_select_files, g_object_unref);
 811   impl->pending_select_files = NULL;
 812 }
 813
 814 static void
 815 pending_select_files_add (GtkFileChooserDefault *impl,
 816                           GFile                 *file)
 817 {
 818   impl->pending_select_files =
 819     g_slist_prepend (impl->pending_select_files, g_object_ref (file));
 820 }
 821
 822 static void
 823 gtk_file_chooser_default_finalize (GObject *object)
 824 {
 825   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (object);
 826   GSList *l;
 827
 828   unset_file_system_backend (impl);
 829
 830   if (impl->shortcuts_pane_filter_model)
 831     g_object_unref (impl->shortcuts_pane_filter_model);
 832
 833   shortcuts_free (impl);
 834
 835   g_free (impl->browse_files_last_selected_name);
 836
 837   for (l = impl->filters; l; l = l->next)
 838     {
 839       GtkFileFilter *filter;
 840
 841       filter = GTK_FILE_FILTER (l->data);
 842       g_object_unref (filter);
 843     }
 844   g_slist_free (impl->filters);
 845
 846   if (impl->current_filter)
 847     g_object_unref (impl->current_filter);
 848
 849   if (impl->current_volume_file)
 850     g_object_unref (impl->current_volume_file);
 851
 852   if (impl->current_folder)
 853     g_object_unref (impl->current_folder);
 854
 855   if (impl->preview_file)
 856     g_object_unref (impl->preview_file);
 857
 858   if (impl->browse_path_bar_size_group)
 859     g_object_unref (impl->browse_path_bar_size_group);
 860
 861   /* Free all the Models we have */
 862   stop_loading_and_clear_list_model (impl, FALSE);
 863   search_clear_model (impl, FALSE);
 864   recent_clear_model (impl, FALSE);
 865
 866   /* stopping the load above should have cleared this */
 867   g_assert (impl->load_timeout_id == 0);
 868
 869   g_free (impl->preview_display_name);
 870
 871   g_free (impl->edited_new_text);
 872
 873   G_OBJECT_CLASS (_gtk_file_chooser_default_parent_class)->finalize (object);
 874 }
 875
 876 /* Shows an error dialog set as transient for the specified window */
 877 static void
 878 error_message_with_parent (GtkWindow  *parent,
 879                            const char *msg,
 880                            const char *detail)
 881 {
 882   GtkWidget *dialog;
 883
 884   dialog = gtk_message_dialog_new (parent,
 885                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 886                                    GTK_MESSAGE_ERROR,
 887                                    GTK_BUTTONS_OK,
 888                                    "%s",
 889                                    msg);
 890   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 891                                             "%s", detail);
 892
 893   if (parent && gtk_window_has_group (parent))
 894     gtk_window_group_add_window (gtk_window_get_group (parent),
 895                                  GTK_WINDOW (dialog));
 896
 897   gtk_dialog_run (GTK_DIALOG (dialog));
 898   gtk_widget_destroy (dialog);
 899 }
 900
 901 /* Returns a toplevel GtkWindow, or NULL if none */
 902 static GtkWindow *
 903 get_toplevel (GtkWidget *widget)
 904 {
 905   GtkWidget *toplevel;
 906
 907   toplevel = gtk_widget_get_toplevel (widget);
 908   if (!gtk_widget_is_toplevel (toplevel))
 909     return NULL;
 910   else
 911     return GTK_WINDOW (toplevel);
 912 }
 913
 914 /* Shows an error dialog for the file chooser */
 915 static void
 916 error_message (GtkFileChooserDefault *impl,
 917                const char            *msg,
 918                const char            *detail)
 919 {
 920   error_message_with_parent (get_toplevel (GTK_WIDGET (impl)), msg, detail);
 921 }
 922
 923 /* Shows a simple error dialog relative to a path.  Frees the GError as well. */
 924 static void
 925 error_dialog (GtkFileChooserDefault *impl,
 926               const char            *msg,
 927               GFile                 *file,
 928               GError                *error)
 929 {
 930   if (error)
 931     {
 932       char *uri = NULL;
 933       char *text;
 934
 935       if (file)
 936         uri = g_file_get_uri (file);
 937       text = g_strdup_printf (msg, uri);
 938       error_message (impl, text, error->message);
 939       g_free (text);
 940       g_free (uri);
 941       g_error_free (error);
 942     }
 943 }
 944
 945 /* Displays an error message about not being able to get information for a file.
 946  * Frees the GError as well.
 947  */
 948 static void
 949 error_getting_info_dialog (GtkFileChooserDefault *impl,
 950                            GFile                 *file,
 951                            GError                *error)
 952 {
 953   error_dialog (impl,
 954                 _("Could not retrieve information about the file"),
 955                 file, error);
 956 }
 957
 958 /* Shows an error dialog about not being able to add a bookmark */
 959 static void
 960 error_adding_bookmark_dialog (GtkFileChooserDefault *impl,
 961                               GFile                 *file,
 962                               GError                *error)
 963 {
 964   error_dialog (impl,
 965                 _("Could not add a bookmark"),
 966                 file, error);
 967 }
 968
 969 /* Shows an error dialog about not being able to remove a bookmark */
 970 static void
 971 error_removing_bookmark_dialog (GtkFileChooserDefault *impl,
 972                                 GFile                 *file,
 973                                 GError                *error)
 974 {
 975   error_dialog (impl,
 976                 _("Could not remove bookmark"),
 977                 file, error);
 978 }
 979
 980 /* Shows an error dialog about not being able to create a folder */
 981 static void
 982 error_creating_folder_dialog (GtkFileChooserDefault *impl,
 983                               GFile                 *file,
 984                               GError                *error)
 985 {
 986   error_dialog (impl,
 987                 _("The folder could not be created"),
 988                 file, error);
 989 }
 990
 991 /* Shows an error about not being able to create a folder because a file with
 992  * the same name is already there.
 993  */
 994 static void
 995 error_creating_folder_over_existing_file_dialog (GtkFileChooserDefault *impl,
 996                                                  GFile                 *file,
 997                                                  GError                *error)
 998 {
 999   error_dialog (impl,
1000                 _("The folder could not be created, as a file with the same "
1001                   "name already exists.  Try using a different name for the "
1002                   "folder, or rename the file first."),
1003                 file, error);
1004 }
1005
1006 static void
1007 error_with_file_under_nonfolder (GtkFileChooserDefault *impl,
1008                                  GFile *parent_file)
1009 {
1010   GError *error;
1011
1012   error = NULL;
1013   g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_DIRECTORY,
1014                        _("You need to choose a valid filename."));
1015
1016   error_dialog (impl,
1017                 _("Cannot create a file under %s as it is not a folder"),
1018                 parent_file, error);
1019 }
1020
1021 /* Shows an error about not being able to select a folder because a file with
1022  * the same name is already there.
1023  */
1024 static void
1025 error_selecting_folder_over_existing_file_dialog (GtkFileChooserDefault *impl,
1026                                                   GFile                 *file)
1027 {
1028   error_dialog (impl,
1029                 _("You may only select folders.  The item that you selected is not a folder; "
1030                   "try using a different item."),
1031                 file, NULL);
1032 }
1033
1034 /* Shows an error dialog about not being able to create a filename */
1035 static void
1036 error_building_filename_dialog (GtkFileChooserDefault *impl,
1037                                 GError                *error)
1038 {
1039   error_dialog (impl, _("Invalid file name"),
1040                 NULL, error);
1041 }
1042
1043 /* Shows an error dialog when we cannot switch to a folder */
1044 static void
1045 error_changing_folder_dialog (GtkFileChooserDefault *impl,
1046                               GFile                 *file,
1047                               GError                *error)
1048 {
1049   error_dialog (impl, _("The folder contents could not be displayed"),
1050                 file, error);
1051 }
1052
1053 /* Changes folders, displaying an error dialog if this fails */
1054 static gboolean
1055 change_folder_and_display_error (GtkFileChooserDefault *impl,
1056                                  GFile                 *file,
1057                                  gboolean               clear_entry)
1058 {
1059   GError *error;
1060   gboolean result;
1061
1062   g_return_val_if_fail (G_IS_FILE (file), FALSE);
1063
1064   /* We copy the path because of this case:
1065    *
1066    * list_row_activated()
1067    *   fetches path from model; path belongs to the model (*)
1068    *   calls change_folder_and_display_error()
1069    *     calls gtk_file_chooser_set_current_folder_file()
1070    *       changing folders fails, sets model to NULL, thus freeing the path in (*)
1071    */
1072
1073   error = NULL;
1074   result = gtk_file_chooser_default_update_current_folder (GTK_FILE_CHOOSER (impl), file, TRUE, clear_entry, &error);
1075
1076   if (!result)
1077     error_changing_folder_dialog (impl, file, error);
1078
1079   return result;
1080 }
1081
1082 static void
1083 emit_default_size_changed (GtkFileChooserDefault *impl)
1084 {
1085   profile_msg ("    emit default-size-changed start", NULL);
1086   g_signal_emit_by_name (impl, "default-size-changed");
1087   profile_msg ("    emit default-size-changed end", NULL);
1088 }
1089
1090 static void
1091 update_preview_widget_visibility (GtkFileChooserDefault *impl)
1092 {
1093   if (impl->use_preview_label)
1094     {
1095       if (!impl->preview_label)
1096         {
1097           impl->preview_label = gtk_label_new (impl->preview_display_name);
1098           gtk_box_pack_start (GTK_BOX (impl->preview_box), impl->preview_label, FALSE, FALSE, 0);
1099           gtk_box_reorder_child (GTK_BOX (impl->preview_box), impl->preview_label, 0);
1100           gtk_label_set_ellipsize (GTK_LABEL (impl->preview_label), PANGO_ELLIPSIZE_MIDDLE);
1101           gtk_widget_show (impl->preview_label);
1102         }
1103     }
1104   else
1105     {
1106       if (impl->preview_label)
1107         {
1108           gtk_widget_destroy (impl->preview_label);
1109           impl->preview_label = NULL;
1110         }
1111     }
1112
1113   if (impl->preview_widget_active && impl->preview_widget)
1114     gtk_widget_show (impl->preview_box);
1115   else
1116     gtk_widget_hide (impl->preview_box);
1117
1118   if (!gtk_widget_get_mapped (GTK_WIDGET (impl)))
1119     emit_default_size_changed (impl);
1120 }
1121
1122 static void
1123 set_preview_widget (GtkFileChooserDefault *impl,
1124                     GtkWidget             *preview_widget)
1125 {
1126   if (preview_widget == impl->preview_widget)
1127     return;
1128
1129   if (impl->preview_widget)
1130     gtk_container_remove (GTK_CONTAINER (impl->preview_box),
1131                           impl->preview_widget);
1132
1133   impl->preview_widget = preview_widget;
1134   if (impl->preview_widget)
1135     {
1136       gtk_widget_show (impl->preview_widget);
1137       gtk_box_pack_start (GTK_BOX (impl->preview_box), impl->preview_widget, TRUE, TRUE, 0);
1138       gtk_box_reorder_child (GTK_BOX (impl->preview_box),
1139                              impl->preview_widget,
1140                              (impl->use_preview_label && impl->preview_label) ? 1 : 0);
1141     }
1142
1143   update_preview_widget_visibility (impl);
1144 }
1145
1146 /* Renders a "Search" icon at an appropriate size for a tree view */
1147 static GdkPixbuf *
1148 render_search_icon (GtkFileChooserDefault *impl)
1149 {
1150   return gtk_widget_render_icon_pixbuf (GTK_WIDGET (impl), GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
1151 }
1152
1153 static GdkPixbuf *
1154 render_recent_icon (GtkFileChooserDefault *impl)
1155 {
1156   GtkIconTheme *theme;
1157   GdkPixbuf *retval;
1158
1159   if (gtk_widget_has_screen (GTK_WIDGET (impl)))
1160     theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (impl)));
1161   else
1162     theme = gtk_icon_theme_get_default ();
1163
1164   retval = gtk_icon_theme_load_icon (theme, "document-open-recent",
1165                                      impl->icon_size, 0,
1166                                      NULL);
1167
1168   /* fallback */
1169   if (!retval)
1170     retval = gtk_widget_render_icon_pixbuf (GTK_WIDGET (impl), GTK_STOCK_FILE, GTK_ICON_SIZE_MENU);
1171
1172   return retval;
1173 }
1174
1175
1176 /* Re-reads all the icons for the shortcuts, used when the theme changes */
1177 struct ReloadIconsData
1178 {
1179   GtkFileChooserDefault *impl;
1180   GtkTreeRowReference *row_ref;
1181 };
1182
1183 static void
1184 shortcuts_reload_icons_get_info_cb (GCancellable *cancellable,
1185                                     GFileInfo    *info,
1186                                     const GError *error,
1187                                     gpointer      user_data)
1188 {
1189   GdkPixbuf *pixbuf;
1190   GtkTreeIter iter;
1191   GtkTreePath *path;
1192   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
1193   struct ReloadIconsData *data = user_data;
1194
1195   if (!g_slist_find (data->impl->reload_icon_cancellables, cancellable))
1196     goto out;
1197
1198   data->impl->reload_icon_cancellables = g_slist_remove (data->impl->reload_icon_cancellables, cancellable);
1199
1200   if (cancelled || error)
1201     goto out;
1202
1203   pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (data->impl), data->impl->icon_size);
1204
1205   path = gtk_tree_row_reference_get_path (data->row_ref);
1206   if (path)
1207     {
1208       gtk_tree_model_get_iter (GTK_TREE_MODEL (data->impl->shortcuts_model), &iter, path);
1209       gtk_list_store_set (data->impl->shortcuts_model, &iter,
1210                           SHORTCUTS_COL_PIXBUF, pixbuf,
1211                           -1);
1212       gtk_tree_path_free (path);
1213     }
1214
1215   if (pixbuf)
1216     g_object_unref (pixbuf);
1217
1218 out:
1219   gtk_tree_row_reference_free (data->row_ref);
1220   g_object_unref (data->impl);
1221   g_free (data);
1222
1223   g_object_unref (cancellable);
1224 }
1225
1226 static void
1227 shortcuts_reload_icons (GtkFileChooserDefault *impl)
1228 {
1229   GSList *l;
1230   GtkTreeIter iter;
1231
1232   profile_start ("start", NULL);
1233
1234   if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
1235     goto out;
1236
1237   for (l = impl->reload_icon_cancellables; l; l = l->next)
1238     {
1239       GCancellable *cancellable = G_CANCELLABLE (l->data);
1240       g_cancellable_cancel (cancellable);
1241     }
1242   g_slist_free (impl->reload_icon_cancellables);
1243   impl->reload_icon_cancellables = NULL;
1244
1245   do
1246     {
1247       gpointer data;
1248       ShortcutType shortcut_type;
1249       gboolean pixbuf_visible;
1250       GdkPixbuf *pixbuf;
1251
1252       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
1253                           SHORTCUTS_COL_DATA, &data,
1254                           SHORTCUTS_COL_TYPE, &shortcut_type,
1255                           SHORTCUTS_COL_PIXBUF_VISIBLE, &pixbuf_visible,
1256                           -1);
1257
1258       pixbuf = NULL;
1259       if (pixbuf_visible)
1260         {
1261           if (shortcut_type == SHORTCUT_TYPE_VOLUME)
1262             {
1263               GtkFileSystemVolume *volume;
1264
1265               volume = data;
1266               pixbuf = _gtk_file_system_volume_render_icon (volume, GTK_WIDGET (impl),
1267                                                             impl->icon_size, NULL);
1268             }
1269           else if (shortcut_type == SHORTCUT_TYPE_FILE)
1270             {
1271               if (g_file_is_native (G_FILE (data)))
1272                 {
1273                   GFile *file;
1274                   struct ReloadIconsData *info;
1275                   GtkTreePath *tree_path;
1276                   GCancellable *cancellable;
1277
1278                   file = data;
1279
1280                   info = g_new0 (struct ReloadIconsData, 1);
1281                   info->impl = g_object_ref (impl);
1282                   tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->shortcuts_model), &iter);
1283                   info->row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (impl->shortcuts_model), tree_path);
1284                   gtk_tree_path_free (tree_path);
1285
1286                   cancellable = _gtk_file_system_get_info (impl->file_system, file,
1287                                                            "standard::icon",
1288                                                            shortcuts_reload_icons_get_info_cb,
1289                                                            info);
1290                   impl->reload_icon_cancellables = g_slist_append (impl->reload_icon_cancellables, cancellable);
1291                 }
1292               else
1293                 {
1294                   GtkIconTheme *icon_theme;
1295
1296                   /* Don't call get_info for remote paths to avoid latency and
1297                    * auth dialogs.
1298                    * If we switch to a better bookmarks file format (XBEL), we
1299                    * should use mime info to get a better icon.
1300                    */
1301                   icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (impl)));
1302                   pixbuf = gtk_icon_theme_load_icon (icon_theme, "folder-remote",
1303                                                      impl->icon_size, 0, NULL);
1304                 }
1305             }
1306           else if (shortcut_type == SHORTCUT_TYPE_SEARCH)
1307             {
1308               pixbuf = render_search_icon (impl);
1309             }
1310           else if (shortcut_type == SHORTCUT_TYPE_RECENT)
1311             {
1312               pixbuf = render_recent_icon (impl);
1313             }
1314
1315           gtk_list_store_set (impl->shortcuts_model, &iter,
1316                               SHORTCUTS_COL_PIXBUF, pixbuf,
1317                               -1);
1318
1319           if (pixbuf)
1320             g_object_unref (pixbuf);
1321
1322         }
1323     }
1324   while (gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model),&iter));
1325
1326  out:
1327
1328   profile_end ("end", NULL);
1329 }
1330
1331 static void
1332 shortcuts_find_folder (GtkFileChooserDefault *impl,
1333                        GFile                 *folder)
1334 {
1335   GtkTreeSelection *selection;
1336   int pos;
1337   GtkTreePath *path;
1338
1339   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view));
1340
1341   g_assert (folder != NULL);
1342   pos = shortcut_find_position (impl, folder);
1343   if (pos == -1)
1344     {
1345       gtk_tree_selection_unselect_all (selection);
1346       return;
1347     }
1348
1349   path = gtk_tree_path_new_from_indices (pos, -1);
1350   gtk_tree_selection_select_path (selection, path);
1351   gtk_tree_path_free (path);
1352 }
1353
1354 /* If a shortcut corresponds to the current folder, selects it */
1355 static void
1356 shortcuts_find_current_folder (GtkFileChooserDefault *impl)
1357 {
1358   shortcuts_find_folder (impl, impl->current_folder);
1359 }
1360
1361 /* Removes the specified number of rows from the shortcuts list */
1362 static void
1363 shortcuts_remove_rows (GtkFileChooserDefault *impl,
1364                        int                    start_row,
1365                        int                    n_rows)
1366 {
1367   GtkTreePath *path;
1368
1369   path = gtk_tree_path_new_from_indices (start_row, -1);
1370
1371   for (; n_rows; n_rows--)
1372     {
1373       GtkTreeIter iter;
1374
1375       if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->shortcuts_model), &iter, path))
1376         g_assert_not_reached ();
1377
1378       shortcuts_free_row_data (impl, &iter);
1379       gtk_list_store_remove (impl->shortcuts_model, &iter);
1380     }
1381
1382   gtk_tree_path_free (path);
1383 }
1384
1385 static void
1386 shortcuts_update_count (GtkFileChooserDefault *impl,
1387                         ShortcutsIndex         type,
1388                         gint                   value)
1389 {
1390   switch (type)
1391     {
1392       case SHORTCUTS_HOME:
1393         if (value < 0)
1394           impl->has_home = FALSE;
1395         else
1396           impl->has_home = TRUE;
1397         break;
1398
1399       case SHORTCUTS_DESKTOP:
1400         if (value < 0)
1401           impl->has_desktop = FALSE;
1402         else
1403           impl->has_desktop = TRUE;
1404         break;
1405
1406       case SHORTCUTS_VOLUMES:
1407         impl->num_volumes += value;
1408         break;
1409
1410       case SHORTCUTS_SHORTCUTS:
1411         impl->num_shortcuts += value;
1412         break;
1413
1414       case SHORTCUTS_BOOKMARKS:
1415         impl->num_bookmarks += value;
1416         break;
1417
1418       case SHORTCUTS_CURRENT_FOLDER:
1419         if (value < 0)
1420           impl->shortcuts_current_folder_active = FALSE;
1421         else
1422           impl->shortcuts_current_folder_active = TRUE;
1423         break;
1424
1425       default:
1426         /* nothing */
1427         break;
1428     }
1429 }
1430
1431 struct ShortcutsInsertRequest
1432 {
1433   GtkFileChooserDefault *impl;
1434   GFile *file;
1435   int pos;
1436   char *label_copy;
1437   GtkTreeRowReference *row_ref;
1438   ShortcutsIndex type;
1439   gboolean name_only;
1440   gboolean removable;
1441 };
1442
1443 static void
1444 get_file_info_finished (GCancellable *cancellable,
1445                         GFileInfo    *info,
1446                         const GError *error,
1447                         gpointer      data)
1448 {
1449   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
1450   GdkPixbuf *pixbuf;
1451   GtkTreePath *path;
1452   GtkTreeIter iter;
1453   GCancellable *model_cancellable = NULL;
1454   struct ShortcutsInsertRequest *request = data;
1455
1456   path = gtk_tree_row_reference_get_path (request->row_ref);
1457   if (!path)
1458     /* Handle doesn't exist anymore in the model */
1459     goto out;
1460
1461   gtk_tree_model_get_iter (GTK_TREE_MODEL (request->impl->shortcuts_model),
1462                            &iter, path);
1463   gtk_tree_path_free (path);
1464
1465   /* validate cancellable, else goto out */
1466   gtk_tree_model_get (GTK_TREE_MODEL (request->impl->shortcuts_model), &iter,
1467                       SHORTCUTS_COL_CANCELLABLE, &model_cancellable,
1468                       -1);
1469   if (cancellable != model_cancellable)
1470     goto out;
1471
1472   /* set the cancellable to NULL in the model (we unref later on) */
1473   gtk_list_store_set (request->impl->shortcuts_model, &iter,
1474                       SHORTCUTS_COL_CANCELLABLE, NULL,
1475                       -1);
1476
1477   if (cancelled)
1478     goto out;
1479
1480   if (!info)
1481     {
1482       gtk_list_store_remove (request->impl->shortcuts_model, &iter);
1483       shortcuts_update_count (request->impl, request->type, -1);
1484
1485       if (request->type == SHORTCUTS_HOME)
1486         {
1487           GFile *home;
1488
1489           home = g_file_new_for_path (g_get_home_dir ());
1490           error_getting_info_dialog (request->impl, home, g_error_copy (error));
1491           g_object_unref (home);
1492         }
1493       else if (request->type == SHORTCUTS_CURRENT_FOLDER)
1494         {
1495           /* Remove the current folder separator */
1496           gint separator_pos = shortcuts_get_index (request->impl, SHORTCUTS_CURRENT_FOLDER_SEPARATOR);
1497           shortcuts_remove_rows (request->impl, separator_pos, 1);
1498         }
1499
1500       goto out;
1501     }
1502
1503   if (!request->label_copy)
1504     request->label_copy = g_strdup (g_file_info_get_display_name (info));
1505   pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (request->impl),
1506                                        request->impl->icon_size);
1507
1508   gtk_list_store_set (request->impl->shortcuts_model, &iter,
1509                       SHORTCUTS_COL_PIXBUF, pixbuf,
1510                       SHORTCUTS_COL_PIXBUF_VISIBLE, TRUE,
1511                       SHORTCUTS_COL_NAME, request->label_copy,
1512                       SHORTCUTS_COL_TYPE, SHORTCUT_TYPE_FILE,
1513                       SHORTCUTS_COL_REMOVABLE, request->removable,
1514                       -1);
1515
1516   if (request->impl->shortcuts_pane_filter_model)
1517     gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (request->impl->shortcuts_pane_filter_model));
1518
1519   if (pixbuf)
1520     g_object_unref (pixbuf);
1521
1522 out:
1523   g_object_unref (request->impl);
1524   g_object_unref (request->file);
1525   gtk_tree_row_reference_free (request->row_ref);
1526   g_free (request->label_copy);
1527   g_free (request);
1528
1529   if (model_cancellable)
1530     g_object_unref (model_cancellable);
1531 }
1532
1533 /* FIXME: GtkFileSystem needs a function to split a remote path
1534  * into hostname and path components, or maybe just have a
1535  * gtk_file_system_path_get_display_name().
1536  *
1537  * This function is also used in gtkfilechooserbutton.c
1538  */
1539 gchar *
1540 _gtk_file_chooser_label_for_file (GFile *file)
1541 {
1542   const gchar *path, *start, *end, *p;
1543   gchar *uri, *host, *label;
1544
1545   uri = g_file_get_uri (file);
1546
1547   start = strstr (uri, "://");
1548   if (start)
1549     {
1550       start += 3;
1551       path = strchr (start, '/');
1552       if (path)
1553         end = path;
1554       else
1555         {
1556           end = uri + strlen (uri);
1557           path = "/";
1558         }
1559
1560       /* strip username */
1561       p = strchr (start, '@');
1562       if (p && p < end)
1563         start = p + 1;
1564
1565       p = strchr (start, ':');
1566       if (p && p < end)
1567         end = p;
1568
1569       host = g_strndup (start, end - start);
1570
1571       /* Translators: the first string is a path and the second string
1572        * is a hostname. Nautilus and the panel contain the same string
1573        * to translate.
1574        */
1575       label = g_strdup_printf (_("%1$s on %2$s"), path, host);
1576
1577       g_free (host);
1578     }
1579   else
1580     {
1581       label = g_strdup (uri);
1582     }
1583
1584   g_free (uri);
1585
1586   return label;
1587 }
1588
1589 /* Inserts a path in the shortcuts tree, making a copy of it; alternatively,
1590  * inserts a volume.  A position of -1 indicates the end of the tree.
1591  */
1592 static void
1593 shortcuts_insert_file (GtkFileChooserDefault *impl,
1594                        int                    pos,
1595                        ShortcutType           shortcut_type,
1596                        GtkFileSystemVolume   *volume,
1597                        GFile                 *file,
1598                        const char            *label,
1599                        gboolean               removable,
1600                        ShortcutsIndex         type)
1601 {
1602   char *label_copy;
1603   GdkPixbuf *pixbuf = NULL;
1604   gpointer data = NULL;
1605   GtkTreeIter iter;
1606   GtkIconTheme *icon_theme;
1607
1608   profile_start ("start shortcut", NULL);
1609
1610   if (shortcut_type == SHORTCUT_TYPE_VOLUME)
1611     {
1612       data = volume;
1613       label_copy = _gtk_file_system_volume_get_display_name (volume);
1614       pixbuf = _gtk_file_system_volume_render_icon (volume, GTK_WIDGET (impl),
1615                                                     impl->icon_size, NULL);
1616     }
1617   else if (shortcut_type == SHORTCUT_TYPE_FILE)
1618     {
1619       if (g_file_is_native (file))
1620         {
1621           struct ShortcutsInsertRequest *request;
1622           GCancellable *cancellable;
1623           GtkTreePath *p;
1624
1625           request = g_new0 (struct ShortcutsInsertRequest, 1);
1626           request->impl = g_object_ref (impl);
1627           request->file = g_object_ref (file);
1628           request->name_only = TRUE;
1629           request->removable = removable;
1630           request->pos = pos;
1631           request->type = type;
1632           if (label)
1633             request->label_copy = g_strdup (label);
1634
1635           if (pos == -1)
1636             gtk_list_store_append (impl->shortcuts_model, &iter);
1637           else
1638             gtk_list_store_insert (impl->shortcuts_model, &iter, pos);
1639
1640           p = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->shortcuts_model), &iter);
1641           request->row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (impl->shortcuts_model), p);
1642           gtk_tree_path_free (p);
1643
1644           cancellable = _gtk_file_system_get_info (request->impl->file_system, request->file,
1645                                                    "standard::is-hidden,standard::is-backup,standard::display-name,standard::icon",
1646                                                    get_file_info_finished, request);
1647
1648           gtk_list_store_set (impl->shortcuts_model, &iter,
1649                               SHORTCUTS_COL_DATA, g_object_ref (file),
1650                               SHORTCUTS_COL_TYPE, SHORTCUT_TYPE_FILE,
1651                               SHORTCUTS_COL_CANCELLABLE, cancellable,
1652                               -1);
1653
1654           shortcuts_update_count (impl, type, 1);
1655
1656           return;
1657         }
1658       else
1659         {
1660           /* Don't call get_info for remote paths to avoid latency and
1661            * auth dialogs.
1662            */
1663           data = g_object_ref (file);
1664           if (label)
1665             label_copy = g_strdup (label);
1666           else
1667             label_copy = _gtk_file_chooser_label_for_file (file);
1668
1669           /* If we switch to a better bookmarks file format (XBEL), we
1670            * should use mime info to get a better icon.
1671            */
1672           icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (impl)));
1673           pixbuf = gtk_icon_theme_load_icon (icon_theme, "folder-remote",
1674                                              impl->icon_size, 0, NULL);
1675         }
1676     }
1677    else
1678     {
1679       g_assert_not_reached ();
1680
1681       return;
1682     }
1683
1684   if (pos == -1)
1685     gtk_list_store_append (impl->shortcuts_model, &iter);
1686   else
1687     gtk_list_store_insert (impl->shortcuts_model, &iter, pos);
1688
1689   shortcuts_update_count (impl, type, 1);
1690
1691   gtk_list_store_set (impl->shortcuts_model, &iter,
1692                       SHORTCUTS_COL_PIXBUF, pixbuf,
1693                       SHORTCUTS_COL_PIXBUF_VISIBLE, TRUE,
1694                       SHORTCUTS_COL_NAME, label_copy,
1695                       SHORTCUTS_COL_DATA, data,
1696                       SHORTCUTS_COL_TYPE, shortcut_type,
1697                       SHORTCUTS_COL_REMOVABLE, removable,
1698                       SHORTCUTS_COL_CANCELLABLE, NULL,
1699                       -1);
1700
1701   if (impl->shortcuts_pane_filter_model)
1702     gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (impl->shortcuts_pane_filter_model));
1703
1704   g_free (label_copy);
1705
1706   if (pixbuf)
1707     g_object_unref (pixbuf);
1708
1709   profile_end ("end", NULL);
1710 }
1711
1712 static void
1713 shortcuts_append_search (GtkFileChooserDefault *impl)
1714 {
1715   GdkPixbuf *pixbuf;
1716   GtkTreeIter iter;
1717
1718   pixbuf = render_search_icon (impl);
1719
1720   gtk_list_store_append (impl->shortcuts_model, &iter);
1721   gtk_list_store_set (impl->shortcuts_model, &iter,
1722                       SHORTCUTS_COL_PIXBUF, pixbuf,
1723                       SHORTCUTS_COL_PIXBUF_VISIBLE, TRUE,
1724                       SHORTCUTS_COL_NAME, _("Search"),
1725                       SHORTCUTS_COL_DATA, NULL,
1726                       SHORTCUTS_COL_TYPE, SHORTCUT_TYPE_SEARCH,
1727                       SHORTCUTS_COL_REMOVABLE, FALSE,
1728                       -1);
1729
1730   if (pixbuf)
1731     g_object_unref (pixbuf);
1732
1733   impl->has_search = TRUE;
1734 }
1735
1736 static gboolean
1737 shortcuts_get_recent_enabled (GtkWidget *widget)
1738 {
1739   GtkSettings *settings;
1740   gboolean enabled;
1741
1742   if (gtk_widget_has_screen (widget))
1743     settings = gtk_settings_get_for_screen (gtk_widget_get_screen (widget));
1744   else
1745     settings = gtk_settings_get_default ();
1746
1747   g_object_get (settings, "gtk-recent-files-enabled", &enabled, NULL);
1748   return enabled;
1749 }
1750
1751 static void
1752 shortcuts_append_recent (GtkFileChooserDefault *impl)
1753 {
1754   GdkPixbuf *pixbuf;
1755   GtkTreeIter iter;
1756   gboolean enabled;
1757
1758   enabled = shortcuts_get_recent_enabled (GTK_WIDGET (impl));
1759   if (!enabled)
1760     return;
1761
1762   pixbuf = render_recent_icon (impl);
1763
1764   gtk_list_store_append (impl->shortcuts_model, &iter);
1765   gtk_list_store_set (impl->shortcuts_model, &iter,
1766                       SHORTCUTS_COL_PIXBUF, pixbuf,
1767                       SHORTCUTS_COL_PIXBUF_VISIBLE, TRUE,
1768                       SHORTCUTS_COL_NAME, _("Recently Used"),
1769                       SHORTCUTS_COL_DATA, NULL,
1770                       SHORTCUTS_COL_TYPE, SHORTCUT_TYPE_RECENT,
1771                       SHORTCUTS_COL_REMOVABLE, FALSE,
1772                       -1);
1773
1774   if (pixbuf)
1775     g_object_unref (pixbuf);
1776
1777   impl->has_recent = TRUE;
1778 }
1779
1780 /* Appends an item for the user's home directory to the shortcuts model */
1781 static void
1782 shortcuts_append_home (GtkFileChooserDefault *impl)
1783 {
1784   const char *home_path;
1785   GFile *home;
1786
1787   profile_start ("start", NULL);
1788
1789   home_path = g_get_home_dir ();
1790   if (home_path == NULL)
1791     {
1792       profile_end ("end - no home directory!?", NULL);
1793       return;
1794     }
1795
1796   home = g_file_new_for_path (home_path);
1797   shortcuts_insert_file (impl, -1, SHORTCUT_TYPE_FILE, NULL, home, NULL, FALSE, SHORTCUTS_HOME);
1798   impl->has_home = TRUE;
1799
1800   g_object_unref (home);
1801
1802   profile_end ("end", NULL);
1803 }
1804
1805 /* Appends the ~/Desktop directory to the shortcuts model */
1806 static void
1807 shortcuts_append_desktop (GtkFileChooserDefault *impl)
1808 {
1809   const char *name;
1810   GFile *file;
1811
1812   profile_start ("start", NULL);
1813
1814   name = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
1815   /* "To disable a directory, point it to the homedir."
1816    * See http://freedesktop.org/wiki/Software/xdg-user-dirs
1817    **/
1818   if (!g_strcmp0 (name, g_get_home_dir ()))
1819     {
1820       profile_end ("end", NULL);
1821       return;
1822     }
1823
1824   file = g_file_new_for_path (name);
1825   shortcuts_insert_file (impl, -1, SHORTCUT_TYPE_FILE, NULL, file, _("Desktop"), FALSE, SHORTCUTS_DESKTOP);
1826   impl->has_desktop = TRUE;
1827
1828   /* We do not actually pop up an error dialog if there is no desktop directory
1829    * because some people may really not want to have one.
1830    */
1831
1832   g_object_unref (file);
1833
1834   profile_end ("end", NULL);
1835 }
1836
1837 /* Appends a list of GFile to the shortcuts model; returns how many were inserted */
1838 static int
1839 shortcuts_append_bookmarks (GtkFileChooserDefault *impl,
1840                             GSList                *bookmarks)
1841 {
1842   int start_row;
1843   int num_inserted;
1844   gchar *label;
1845
1846   profile_start ("start", NULL);
1847
1848   start_row = shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS_SEPARATOR) + 1;
1849   num_inserted = 0;
1850
1851   for (; bookmarks; bookmarks = bookmarks->next)
1852     {
1853       GFile *file;
1854
1855       file = bookmarks->data;
1856
1857       if (impl->local_only && !_gtk_file_has_native_path (file))
1858         continue;
1859
1860       if (shortcut_find_position (impl, file) != -1)
1861         continue;
1862
1863       label = _gtk_file_system_get_bookmark_label (impl->file_system, file);
1864
1865       shortcuts_insert_file (impl, start_row + num_inserted, SHORTCUT_TYPE_FILE, NULL, file, label, TRUE, SHORTCUTS_BOOKMARKS);
1866       g_free (label);
1867
1868       num_inserted++;
1869     }
1870
1871   profile_end ("end", NULL);
1872
1873   return num_inserted;
1874 }
1875
1876 /* Returns the index for the corresponding item in the shortcuts bar */
1877 static int
1878 shortcuts_get_index (GtkFileChooserDefault *impl,
1879                      ShortcutsIndex         where)
1880 {
1881   int n;
1882
1883   n = 0;
1884
1885   if (where == SHORTCUTS_SEARCH)
1886     goto out;
1887
1888   n += impl->has_search ? 1 : 0;
1889
1890   if (where == SHORTCUTS_RECENT)
1891     goto out;
1892
1893   n += impl->has_recent ? 1 : 0;
1894
1895   if (where == SHORTCUTS_RECENT_SEPARATOR)
1896     goto out;
1897
1898   n += 1; /* we always have the separator after the recently-used item */
1899
1900   if (where == SHORTCUTS_HOME)
1901     goto out;
1902
1903   n += impl->has_home ? 1 : 0;
1904
1905   if (where == SHORTCUTS_DESKTOP)
1906     goto out;
1907
1908   n += impl->has_desktop ? 1 : 0;
1909
1910   if (where == SHORTCUTS_VOLUMES)
1911     goto out;
1912
1913   n += impl->num_volumes;
1914
1915   if (where == SHORTCUTS_SHORTCUTS)
1916     goto out;
1917
1918   n += impl->num_shortcuts;
1919
1920   if (where == SHORTCUTS_BOOKMARKS_SEPARATOR)
1921     goto out;
1922
1923   /* If there are no bookmarks there won't be a separator */
1924   n += (impl->num_bookmarks > 0) ? 1 : 0;
1925
1926   if (where == SHORTCUTS_BOOKMARKS)
1927     goto out;
1928
1929   n += impl->num_bookmarks;
1930
1931   if (where == SHORTCUTS_CURRENT_FOLDER_SEPARATOR)
1932     goto out;
1933
1934   n += 1;
1935
1936   if (where == SHORTCUTS_CURRENT_FOLDER)
1937     goto out;
1938
1939   g_assert_not_reached ();
1940
1941  out:
1942
1943   return n;
1944 }
1945
1946 /* Adds all the file system volumes to the shortcuts model */
1947 static void
1948 shortcuts_add_volumes (GtkFileChooserDefault *impl)
1949 {
1950   int start_row;
1951   GSList *list, *l;
1952   int n;
1953   gboolean old_changing_folders;
1954
1955   profile_start ("start", NULL);
1956
1957   old_changing_folders = impl->changing_folder;
1958   impl->changing_folder = TRUE;
1959
1960   start_row = shortcuts_get_index (impl, SHORTCUTS_VOLUMES);
1961   shortcuts_remove_rows (impl, start_row, impl->num_volumes);
1962   impl->num_volumes = 0;
1963
1964   list = _gtk_file_system_list_volumes (impl->file_system);
1965
1966   n = 0;
1967
1968   for (l = list; l; l = l->next)
1969     {
1970       GtkFileSystemVolume *volume;
1971
1972       volume = l->data;
1973
1974       if (impl->local_only)
1975         {
1976           if (_gtk_file_system_volume_is_mounted (volume))
1977             {
1978               GFile *base_file;
1979               gboolean base_has_native_path = FALSE;
1980
1981               base_file = _gtk_file_system_volume_get_root (volume);
1982               if (base_file != NULL)
1983                 {
1984                   base_has_native_path = _gtk_file_has_native_path (base_file);
1985                   g_object_unref (base_file);
1986                 }
1987
1988               if (!base_has_native_path)
1989                 continue;
1990             }
1991         }
1992
1993       shortcuts_insert_file (impl,
1994                              start_row + n,
1995                              SHORTCUT_TYPE_VOLUME,
1996                              _gtk_file_system_volume_ref (volume),
1997                              NULL,
1998                              NULL,
1999                              FALSE,
2000                              SHORTCUTS_VOLUMES);
2001       n++;
2002     }
2003
2004   impl->num_volumes = n;
2005   g_slist_free (list);
2006
2007   if (impl->shortcuts_pane_filter_model)
2008     gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (impl->shortcuts_pane_filter_model));
2009
2010   impl->changing_folder = old_changing_folders;
2011
2012   profile_end ("end", NULL);
2013 }
2014
2015 /* Inserts a separator node in the shortcuts list */
2016 static void
2017 shortcuts_insert_separator (GtkFileChooserDefault *impl,
2018                             ShortcutsIndex         where)
2019 {
2020   GtkTreeIter iter;
2021
2022   g_assert (where == SHORTCUTS_RECENT_SEPARATOR ||
2023             where == SHORTCUTS_BOOKMARKS_SEPARATOR ||
2024             where == SHORTCUTS_CURRENT_FOLDER_SEPARATOR);
2025
2026   gtk_list_store_insert (impl->shortcuts_model, &iter,
2027                          shortcuts_get_index (impl, where));
2028   gtk_list_store_set (impl->shortcuts_model, &iter,
2029                       SHORTCUTS_COL_PIXBUF, NULL,
2030                       SHORTCUTS_COL_PIXBUF_VISIBLE, FALSE,
2031                       SHORTCUTS_COL_NAME, NULL,
2032                       SHORTCUTS_COL_DATA, NULL,
2033                       SHORTCUTS_COL_TYPE, SHORTCUT_TYPE_SEPARATOR,
2034                       -1);
2035 }
2036
2037 /* Updates the list of bookmarks */
2038 static void
2039 shortcuts_add_bookmarks (GtkFileChooserDefault *impl)
2040 {
2041   GSList *bookmarks;
2042   gboolean old_changing_folders;
2043   GtkTreeIter iter;
2044   GFile *list_selected = NULL;
2045   ShortcutType shortcut_type;
2046   gpointer col_data;
2047
2048   profile_start ("start", NULL);
2049
2050   old_changing_folders = impl->changing_folder;
2051   impl->changing_folder = TRUE;
2052
2053   if (shortcuts_get_selected (impl, &iter))
2054     {
2055       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model),
2056                           &iter,
2057                           SHORTCUTS_COL_DATA, &col_data,
2058                           SHORTCUTS_COL_TYPE, &shortcut_type,
2059                           -1);
2060
2061       if (col_data && shortcut_type == SHORTCUT_TYPE_FILE)
2062         list_selected = g_object_ref (col_data);
2063     }
2064
2065   if (impl->num_bookmarks > 0)
2066     shortcuts_remove_rows (impl,
2067                            shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS_SEPARATOR),
2068                            impl->num_bookmarks + 1);
2069
2070   impl->num_bookmarks = 0;
2071   shortcuts_insert_separator (impl, SHORTCUTS_BOOKMARKS_SEPARATOR);
2072
2073   bookmarks = _gtk_file_system_list_bookmarks (impl->file_system);
2074   shortcuts_append_bookmarks (impl, bookmarks);
2075   g_slist_foreach (bookmarks, (GFunc) g_object_unref, NULL);
2076   g_slist_free (bookmarks);
2077
2078   if (impl->num_bookmarks == 0)
2079     shortcuts_remove_rows (impl, shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS_SEPARATOR), 1);
2080
2081   if (impl->shortcuts_pane_filter_model)
2082     gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (impl->shortcuts_pane_filter_model));
2083
2084   if (list_selected)
2085     {
2086       shortcuts_find_folder (impl, list_selected);
2087       g_object_unref (list_selected);
2088     }
2089
2090   impl->changing_folder = old_changing_folders;
2091
2092   profile_end ("end", NULL);
2093 }
2094
2095 /* Appends a separator and a row to the shortcuts list for the current folder */
2096 static void
2097 shortcuts_add_current_folder (GtkFileChooserDefault *impl)
2098 {
2099   int pos;
2100
2101   g_assert (!impl->shortcuts_current_folder_active);
2102
2103   g_assert (impl->current_folder != NULL);
2104
2105   pos = shortcut_find_position (impl, impl->current_folder);
2106   if (pos == -1)
2107     {
2108       GtkFileSystemVolume *volume;
2109       GFile *base_file;
2110
2111       /* Separator */
2112       shortcuts_insert_separator (impl, SHORTCUTS_CURRENT_FOLDER_SEPARATOR);
2113
2114       /* Item */
2115       pos = shortcuts_get_index (impl, SHORTCUTS_CURRENT_FOLDER);
2116
2117       volume = _gtk_file_system_get_volume_for_file (impl->file_system, impl->current_folder);
2118       if (volume)
2119         base_file = _gtk_file_system_volume_get_root (volume);
2120       else
2121         base_file = NULL;
2122
2123       if (base_file && g_file_equal (base_file, impl->current_folder))
2124         shortcuts_insert_file (impl, pos, SHORTCUT_TYPE_VOLUME, volume, NULL, NULL, FALSE, SHORTCUTS_CURRENT_FOLDER);
2125       else
2126         shortcuts_insert_file (impl, pos, SHORTCUT_TYPE_FILE, NULL, impl->current_folder, NULL, FALSE, SHORTCUTS_CURRENT_FOLDER);
2127
2128       if (base_file)
2129         g_object_unref (base_file);
2130     }
2131 }
2132
2133 /* Updates the current folder row in the shortcuts model */
2134 static void
2135 shortcuts_update_current_folder (GtkFileChooserDefault *impl)
2136 {
2137   int pos;
2138
2139   pos = shortcuts_get_index (impl, SHORTCUTS_CURRENT_FOLDER_SEPARATOR);
2140
2141   if (impl->shortcuts_current_folder_active)
2142     {
2143       shortcuts_remove_rows (impl, pos, 2);
2144       impl->shortcuts_current_folder_active = FALSE;
2145     }
2146
2147   shortcuts_add_current_folder (impl);
2148 }
2149
2150 /* Filter function used for the shortcuts filter model */
2151 static gboolean
2152 shortcuts_pane_filter_cb (GtkTreeModel *model,
2153                           GtkTreeIter  *iter,
2154                           gpointer      data)
2155 {
2156   GtkFileChooserDefault *impl;
2157   GtkTreePath *path;
2158   int pos;
2159
2160   impl = GTK_FILE_CHOOSER_DEFAULT (data);
2161
2162   path = gtk_tree_model_get_path (model, iter);
2163   if (!path)
2164     return FALSE;
2165
2166   pos = *gtk_tree_path_get_indices (path);
2167   gtk_tree_path_free (path);
2168
2169   return (pos < shortcuts_get_index (impl, SHORTCUTS_CURRENT_FOLDER_SEPARATOR));
2170 }
2171
2172 /* Creates the list model for shortcuts */
2173 static void
2174 shortcuts_model_create (GtkFileChooserDefault *impl)
2175 {
2176   /* Keep this order in sync with the SHORCUTS_COL_* enum values */
2177   impl->shortcuts_model = gtk_list_store_new (SHORTCUTS_COL_NUM_COLUMNS,
2178                                               GDK_TYPE_PIXBUF,  /* pixbuf */
2179                                               G_TYPE_STRING,    /* name */
2180                                               G_TYPE_POINTER,   /* path or volume */
2181                                               G_TYPE_INT,       /* ShortcutType */
2182                                               G_TYPE_BOOLEAN,   /* removable */
2183                                               G_TYPE_BOOLEAN,   /* pixbuf cell visibility */
2184                                               G_TYPE_POINTER);  /* GCancellable */
2185
2186   shortcuts_append_search (impl);
2187
2188   if (impl->recent_manager)
2189     {
2190       shortcuts_append_recent (impl);
2191       shortcuts_insert_separator (impl, SHORTCUTS_RECENT_SEPARATOR);
2192     }
2193
2194   if (impl->file_system)
2195     {
2196       shortcuts_append_home (impl);
2197       shortcuts_append_desktop (impl);
2198       shortcuts_add_volumes (impl);
2199     }
2200
2201   impl->shortcuts_pane_filter_model = shortcuts_pane_model_filter_new (impl,
2202                                                                        GTK_TREE_MODEL (impl->shortcuts_model),
2203                                                                        NULL);
2204
2205   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (impl->shortcuts_pane_filter_model),
2206                                           shortcuts_pane_filter_cb,
2207                                           impl,
2208                                           NULL);
2209 }
2210
2211 /* Callback used when the "New Folder" button is clicked */
2212 static void
2213 new_folder_button_clicked (GtkButton             *button,
2214                            GtkFileChooserDefault *impl)
2215 {
2216   GtkTreeIter iter;
2217   GtkTreePath *path;
2218
2219   if (!impl->browse_files_model)
2220     return; /* FIXME: this sucks.  Disable the New Folder button or something. */
2221
2222   /* Prevent button from being clicked twice */
2223   gtk_widget_set_sensitive (impl->browse_new_folder_button, FALSE);
2224
2225   _gtk_file_system_model_add_editable (impl->browse_files_model, &iter);
2226
2227   path = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->browse_files_model), &iter);
2228   gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (impl->browse_files_tree_view),
2229                                 path, impl->list_name_column,
2230                                 FALSE, 0.0, 0.0);
2231
2232   g_object_set (impl->list_name_renderer, "editable", TRUE, NULL);
2233   gtk_tree_view_set_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view),
2234                             path,
2235                             impl->list_name_column,
2236                             TRUE);
2237
2238   gtk_tree_path_free (path);
2239 }
2240
2241 static GSource *
2242 add_idle_while_impl_is_alive (GtkFileChooserDefault *impl, GCallback callback)
2243 {
2244   GSource *source;
2245
2246   source = g_idle_source_new ();
2247   g_source_set_closure (source,
2248                         g_cclosure_new_object (callback, G_OBJECT (impl)));
2249   g_source_attach (source, NULL);
2250
2251   return source;
2252 }
2253
2254 /* Idle handler for creating a new folder after editing its name cell, or for
2255  * canceling the editing.
2256  */
2257 static gboolean
2258 edited_idle_cb (GtkFileChooserDefault *impl)
2259 {
2260   gdk_threads_enter ();
2261
2262   g_source_destroy (impl->edited_idle);
2263   impl->edited_idle = NULL;
2264
2265   _gtk_file_system_model_remove_editable (impl->browse_files_model);
2266   g_object_set (impl->list_name_renderer, "editable", FALSE, NULL);
2267
2268   gtk_widget_set_sensitive (impl->browse_new_folder_button, TRUE);
2269
2270   if (impl->edited_new_text /* not cancelled? */
2271       && (strlen (impl->edited_new_text) != 0)
2272       && (strcmp (impl->edited_new_text, DEFAULT_NEW_FOLDER_NAME) != 0)) /* Don't create folder if name is empty or has not been edited */
2273     {
2274       GError *error = NULL;
2275       GFile *file;
2276
2277       file = g_file_get_child_for_display_name (impl->current_folder,
2278                                                 impl->edited_new_text,
2279                                                 &error);
2280       if (file)
2281         {
2282           GError *error = NULL;
2283
2284           if (g_file_make_directory (file, NULL, &error))
2285             change_folder_and_display_error (impl, file, FALSE);
2286           else
2287             error_creating_folder_dialog (impl, file, error);
2288
2289           g_object_unref (file);
2290         }
2291       else
2292         error_creating_folder_dialog (impl, file, error);
2293
2294       g_free (impl->edited_new_text);
2295       impl->edited_new_text = NULL;
2296     }
2297
2298   gdk_threads_leave ();
2299
2300   return FALSE;
2301 }
2302
2303 static void
2304 queue_edited_idle (GtkFileChooserDefault *impl,
2305                    const gchar           *new_text)
2306 {
2307   /* We create the folder in an idle handler so that we don't modify the tree
2308    * just now.
2309    */
2310
2311   if (!impl->edited_idle)
2312     impl->edited_idle = add_idle_while_impl_is_alive (impl, G_CALLBACK (edited_idle_cb));
2313
2314   g_free (impl->edited_new_text);
2315   impl->edited_new_text = g_strdup (new_text);
2316 }
2317
2318 /* Callback used from the text cell renderer when the new folder is named */
2319 static void
2320 renderer_edited_cb (GtkCellRendererText   *cell_renderer_text,
2321                     const gchar           *path,
2322                     const gchar           *new_text,
2323                     GtkFileChooserDefault *impl)
2324 {
2325   /* work around bug #154921 */
2326   g_object_set (cell_renderer_text,
2327                 "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
2328   queue_edited_idle (impl, new_text);
2329 }
2330
2331 /* Callback used from the text cell renderer when the new folder edition gets
2332  * canceled.
2333  */
2334 static void
2335 renderer_editing_canceled_cb (GtkCellRendererText   *cell_renderer_text,
2336                               GtkFileChooserDefault *impl)
2337 {
2338   /* work around bug #154921 */
2339   g_object_set (cell_renderer_text,
2340                 "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
2341   queue_edited_idle (impl, NULL);
2342 }
2343
2344 /* Creates the widgets for the filter combo box */
2345 static GtkWidget *
2346 filter_create (GtkFileChooserDefault *impl)
2347 {
2348   GtkCellRenderer *cell;
2349   GList           *cells;
2350
2351   impl->filter_combo = gtk_combo_box_text_new ();
2352   gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (impl->filter_combo), FALSE);
2353
2354   /* Get the combo's text renderer and set ellipsize parameters */
2355   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (impl->filter_combo));
2356   g_assert (cells);
2357   cell = cells->data;
2358
2359   g_object_set (G_OBJECT (cell),
2360                 "ellipsize", PANGO_ELLIPSIZE_END,
2361                 NULL);
2362
2363   g_list_free (cells);
2364
2365   g_signal_connect (impl->filter_combo, "changed",
2366                     G_CALLBACK (filter_combo_changed), impl);
2367
2368   gtk_widget_set_tooltip_text (impl->filter_combo,
2369                                _("Select which types of files are shown"));
2370
2371   return impl->filter_combo;
2372 }
2373
2374 static GtkWidget *
2375 toolbutton_new (GtkFileChooserDefault *impl,
2376                 GIcon                 *icon,
2377                 gboolean               sensitive,
2378                 gboolean               show,
2379                 GCallback              callback)
2380 {
2381   GtkToolItem *item;
2382   GtkWidget *image;
2383
2384   item = gtk_tool_button_new (NULL, NULL);
2385   image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_SMALL_TOOLBAR);
2386   gtk_widget_show (image);
2387   gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), image);
2388
2389   gtk_widget_set_sensitive (GTK_WIDGET (item), sensitive);
2390   g_signal_connect (item, "clicked", callback, impl);
2391
2392   if (show)
2393     gtk_widget_show (GTK_WIDGET (item));
2394
2395   return GTK_WIDGET (item);
2396 }
2397
2398 /* Looks for a path among the shortcuts; returns its index or -1 if it doesn't exist */
2399 static int
2400 shortcut_find_position (GtkFileChooserDefault *impl,
2401                         GFile                 *file)
2402 {
2403   GtkTreeIter iter;
2404   int i;
2405   int current_folder_separator_idx;
2406
2407   if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
2408     return -1;
2409
2410   current_folder_separator_idx = shortcuts_get_index (impl, SHORTCUTS_CURRENT_FOLDER_SEPARATOR);
2411
2412 #if 0
2413   /* FIXME: is this still needed? */
2414   if (current_folder_separator_idx >= impl->shortcuts_model->length)
2415     return -1;
2416 #endif
2417
2418   for (i = 0; i < current_folder_separator_idx; i++)
2419     {
2420       gpointer col_data;
2421       ShortcutType shortcut_type;
2422
2423       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
2424                           SHORTCUTS_COL_DATA, &col_data,
2425                           SHORTCUTS_COL_TYPE, &shortcut_type,
2426                           -1);
2427
2428       if (col_data)
2429         {
2430           if (shortcut_type == SHORTCUT_TYPE_VOLUME)
2431             {
2432               GtkFileSystemVolume *volume;
2433               GFile *base_file;
2434               gboolean exists;
2435
2436               volume = col_data;
2437               base_file = _gtk_file_system_volume_get_root (volume);
2438
2439               exists = base_file && g_file_equal (file, base_file);
2440
2441               if (base_file)
2442                 g_object_unref (base_file);
2443
2444               if (exists)
2445                 return i;
2446             }
2447           else if (shortcut_type == SHORTCUT_TYPE_FILE)
2448             {
2449               GFile *model_file;
2450
2451               model_file = col_data;
2452
2453               if (model_file && g_file_equal (model_file, file))
2454                 return i;
2455             }
2456         }
2457
2458       if (i < current_folder_separator_idx - 1)
2459         {
2460           if (!gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
2461             g_assert_not_reached ();
2462         }
2463     }
2464
2465   return -1;
2466 }
2467
2468 /* Tries to add a bookmark from a path name */
2469 static gboolean
2470 shortcuts_add_bookmark_from_file (GtkFileChooserDefault *impl,
2471                                   GFile                 *file,
2472                                   int                    pos)
2473 {
2474   GError *error;
2475
2476   g_return_val_if_fail (G_IS_FILE (file), FALSE);
2477
2478   if (shortcut_find_position (impl, file) != -1)
2479     return FALSE;
2480
2481   error = NULL;
2482   if (!_gtk_file_system_insert_bookmark (impl->file_system, file, pos, &error))
2483     {
2484       error_adding_bookmark_dialog (impl, file, error);
2485       return FALSE;
2486     }
2487
2488   return TRUE;
2489 }
2490
2491 static void
2492 add_bookmark_foreach_cb (GtkTreeModel *model,
2493                          GtkTreePath  *path,
2494                          GtkTreeIter  *iter,
2495                          gpointer      data)
2496 {
2497   GtkFileChooserDefault *impl;
2498   GFile *file;
2499
2500   impl = (GtkFileChooserDefault *) data;
2501
2502   gtk_tree_model_get (model, iter,
2503                       MODEL_COL_FILE, &file,
2504                       -1);
2505
2506   shortcuts_add_bookmark_from_file (impl, file, -1);
2507
2508   g_object_unref (file);
2509 }
2510
2511 /* Adds a bookmark from the currently selected item in the file list */
2512 static void
2513 bookmarks_add_selected_folder (GtkFileChooserDefault *impl)
2514 {
2515   GtkTreeSelection *selection;
2516
2517   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
2518
2519   if (gtk_tree_selection_count_selected_rows (selection) == 0)
2520     shortcuts_add_bookmark_from_file (impl, impl->current_folder, -1);
2521   else
2522     gtk_tree_selection_selected_foreach (selection,
2523                                          add_bookmark_foreach_cb,
2524                                          impl);
2525 }
2526
2527 /* Callback used when the "Add bookmark" button is clicked */
2528 static void
2529 add_bookmark_button_clicked_cb (GtkButton *button,
2530                                 GtkFileChooserDefault *impl)
2531 {
2532   bookmarks_add_selected_folder (impl);
2533 }
2534
2535 /* Returns TRUE plus an iter in the shortcuts_model if a row is selected;
2536  * returns FALSE if no shortcut is selected.
2537  */
2538 static gboolean
2539 shortcuts_get_selected (GtkFileChooserDefault *impl,
2540                         GtkTreeIter           *iter)
2541 {
2542   GtkTreeSelection *selection;
2543   GtkTreeIter parent_iter;
2544
2545   if (!impl->browse_shortcuts_tree_view)
2546     return FALSE;
2547
2548   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view));
2549
2550   if (!gtk_tree_selection_get_selected (selection, NULL, &parent_iter))
2551     return FALSE;
2552
2553   gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (impl->shortcuts_pane_filter_model),
2554                                                     iter,
2555                                                     &parent_iter);
2556   return TRUE;
2557 }
2558
2559 /* Removes the selected bookmarks */
2560 static void
2561 remove_selected_bookmarks (GtkFileChooserDefault *impl)
2562 {
2563   GtkTreeIter iter;
2564   gpointer col_data;
2565   GFile *file;
2566   gboolean removable;
2567   GError *error;
2568
2569   if (!shortcuts_get_selected (impl, &iter))
2570     return;
2571
2572   gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
2573                       SHORTCUTS_COL_DATA, &col_data,
2574                       SHORTCUTS_COL_REMOVABLE, &removable,
2575                       -1);
2576
2577   if (!removable)
2578     return;
2579
2580   g_assert (col_data != NULL);
2581
2582   file = col_data;
2583
2584   error = NULL;
2585   if (!_gtk_file_system_remove_bookmark (impl->file_system, file, &error))
2586     error_removing_bookmark_dialog (impl, file, error);
2587 }
2588
2589 /* Callback used when the "Remove bookmark" button is clicked */
2590 static void
2591 remove_bookmark_button_clicked_cb (GtkButton *button,
2592                                    GtkFileChooserDefault *impl)
2593 {
2594   remove_selected_bookmarks (impl);
2595 }
2596
2597 struct selection_check_closure {
2598   GtkFileChooserDefault *impl;
2599   int num_selected;
2600   gboolean all_files;
2601   gboolean all_folders;
2602 };
2603
2604 /* Used from gtk_tree_selection_selected_foreach() */
2605 static void
2606 selection_check_foreach_cb (GtkTreeModel *model,
2607                             GtkTreePath  *path,
2608                             GtkTreeIter  *iter,
2609                             gpointer      data)
2610 {
2611   struct selection_check_closure *closure;
2612   gboolean is_folder;
2613   GFile *file;
2614
2615   gtk_tree_model_get (model, iter,
2616                       MODEL_COL_FILE, &file,
2617                       MODEL_COL_IS_FOLDER, &is_folder,
2618                       -1);
2619
2620   if (file == NULL)
2621     return;
2622
2623   g_object_unref (file);
2624
2625   closure = data;
2626   closure->num_selected++;
2627
2628   closure->all_folders = closure->all_folders && is_folder;
2629   closure->all_files = closure->all_files && !is_folder;
2630 }
2631
2632 /* Checks whether the selected items in the file list are all files or all folders */
2633 static void
2634 selection_check (GtkFileChooserDefault *impl,
2635                  gint                  *num_selected,
2636                  gboolean              *all_files,
2637                  gboolean              *all_folders)
2638 {
2639   struct selection_check_closure closure;
2640   GtkTreeSelection *selection;
2641
2642   closure.impl = impl;
2643   closure.num_selected = 0;
2644   closure.all_files = TRUE;
2645   closure.all_folders = TRUE;
2646
2647   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
2648   gtk_tree_selection_selected_foreach (selection,
2649                                        selection_check_foreach_cb,
2650                                        &closure);
2651
2652   g_assert (closure.num_selected == 0 || !(closure.all_files && closure.all_folders));
2653
2654   if (num_selected)
2655     *num_selected = closure.num_selected;
2656
2657   if (all_files)
2658     *all_files = closure.all_files;
2659
2660   if (all_folders)
2661     *all_folders = closure.all_folders;
2662 }
2663
2664 struct get_selected_file_closure {
2665   GtkFileChooserDefault *impl;
2666   GFile *file;
2667 };
2668
2669 static void
2670 get_selected_file_foreach_cb (GtkTreeModel *model,
2671                               GtkTreePath  *path,
2672                               GtkTreeIter  *iter,
2673                               gpointer      data)
2674 {
2675   struct get_selected_file_closure *closure = data;
2676
2677   if (closure->file)
2678     {
2679       /* Just in case this function gets run more than once with a multiple selection; we only care about one file */
2680       g_object_unref (closure->file);
2681       closure->file = NULL;
2682     }
2683
2684   gtk_tree_model_get (model, iter,
2685                       MODEL_COL_FILE, &closure->file, /* this will give us a reffed file */
2686                       -1);
2687 }
2688
2689 /* Returns a selected path from the file list */
2690 static GFile *
2691 get_selected_file (GtkFileChooserDefault *impl)
2692 {
2693   struct get_selected_file_closure closure;
2694   GtkTreeSelection *selection;
2695
2696   closure.impl = impl;
2697   closure.file = NULL;
2698
2699   selection =  gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
2700   gtk_tree_selection_selected_foreach (selection,
2701                                        get_selected_file_foreach_cb,
2702                                        &closure);
2703
2704   return closure.file;
2705 }
2706
2707 typedef struct {
2708   GtkFileChooserDefault *impl;
2709   gchar *tip;
2710 } UpdateTooltipData;
2711
2712 static void
2713 update_tooltip (GtkTreeModel      *model,
2714                 GtkTreePath       *path,
2715                 GtkTreeIter       *iter,
2716                 gpointer           data)
2717 {
2718   UpdateTooltipData *udata = data;
2719
2720   if (udata->tip == NULL)
2721     {
2722       gchar *display_name;
2723
2724       gtk_tree_model_get (model, iter,
2725                           MODEL_COL_NAME, &display_name,
2726                           -1);
2727
2728       udata->tip = g_strdup_printf (_("Add the folder '%s' to the bookmarks"),
2729                                     display_name);
2730       g_free (display_name);
2731     }
2732 }
2733
2734
2735 /* Sensitize the "add bookmark" button if all the selected items are folders, or
2736  * if there are no selected items *and* the current folder is not in the
2737  * bookmarks list.  De-sensitize the button otherwise.
2738  */
2739 static void
2740 bookmarks_check_add_sensitivity (GtkFileChooserDefault *impl)
2741 {
2742   gint num_selected;
2743   gboolean all_folders;
2744   gboolean active;
2745   gchar *tip;
2746
2747   selection_check (impl, &num_selected, NULL, &all_folders);
2748
2749   if (num_selected == 0)
2750     active = (impl->current_folder != NULL) && (shortcut_find_position (impl, impl->current_folder) == -1);
2751   else if (num_selected == 1)
2752     {
2753       GFile *file;
2754
2755       file = get_selected_file (impl);
2756       active = file && all_folders && (shortcut_find_position (impl, file) == -1);
2757       if (file)
2758         g_object_unref (file);
2759     }
2760   else
2761     active = all_folders;
2762
2763   gtk_widget_set_sensitive (impl->browse_shortcuts_add_button, active);
2764
2765   if (impl->browse_files_popup_menu_add_shortcut_item)
2766     gtk_widget_set_sensitive (impl->browse_files_popup_menu_add_shortcut_item,
2767                               (num_selected == 0) ? FALSE : active);
2768
2769   if (active)
2770     {
2771       if (num_selected == 0)
2772         tip = g_strdup_printf (_("Add the current folder to the bookmarks"));
2773       else if (num_selected > 1)
2774         tip = g_strdup_printf (_("Add the selected folders to the bookmarks"));
2775       else
2776         {
2777           GtkTreeSelection *selection;
2778           UpdateTooltipData data;
2779
2780           selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
2781           data.impl = impl;
2782           data.tip = NULL;
2783           gtk_tree_selection_selected_foreach (selection, update_tooltip, &data);
2784           tip = data.tip;
2785         }
2786
2787       gtk_widget_set_tooltip_text (impl->browse_shortcuts_add_button, tip);
2788       g_free (tip);
2789     }
2790 }
2791
2792 /* Sets the sensitivity of the "remove bookmark" button depending on whether a
2793  * bookmark row is selected in the shortcuts tree.
2794  */
2795 static void
2796 bookmarks_check_remove_sensitivity (GtkFileChooserDefault *impl)
2797 {
2798   GtkTreeIter iter;
2799   gboolean removable = FALSE;
2800   gchar *name = NULL;
2801   gchar *tip;
2802
2803   if (shortcuts_get_selected (impl, &iter))
2804     {
2805       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
2806                           SHORTCUTS_COL_REMOVABLE, &removable,
2807                           SHORTCUTS_COL_NAME, &name,
2808                           -1);
2809       gtk_widget_set_sensitive (impl->browse_shortcuts_remove_button, removable);
2810
2811       if (removable)
2812         tip = g_strdup_printf (_("Remove the bookmark '%s'"), name);
2813       else
2814         tip = g_strdup_printf (_("Bookmark '%s' cannot be removed"), name);
2815
2816       gtk_widget_set_tooltip_text (impl->browse_shortcuts_remove_button, tip);
2817       g_free (tip);
2818     }
2819   else
2820     gtk_widget_set_tooltip_text (impl->browse_shortcuts_remove_button,
2821                                  _("Remove the selected bookmark"));
2822   g_free (name);
2823 }
2824
2825 static void
2826 shortcuts_check_popup_sensitivity (GtkFileChooserDefault *impl)
2827 {
2828   GtkTreeIter iter;
2829   gboolean removable = FALSE;
2830
2831   if (impl->browse_shortcuts_popup_menu == NULL)
2832     return;
2833
2834   if (shortcuts_get_selected (impl, &iter))
2835     gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
2836                         SHORTCUTS_COL_REMOVABLE, &removable,
2837                         -1);
2838
2839   gtk_widget_set_sensitive (impl->browse_shortcuts_popup_menu_remove_item, removable);
2840   gtk_widget_set_sensitive (impl->browse_shortcuts_popup_menu_rename_item, removable);
2841 }
2842
2843 /* GtkWidget::drag-begin handler for the shortcuts list. */
2844 static void
2845 shortcuts_drag_begin_cb (GtkWidget             *widget,
2846                          GdkDragContext        *context,
2847                          GtkFileChooserDefault *impl)
2848 {
2849 #if 0
2850   impl->shortcuts_drag_context = g_object_ref (context);
2851 #endif
2852 }
2853
2854 #if 0
2855 /* Removes the idle handler for outside drags */
2856 static void
2857 shortcuts_cancel_drag_outside_idle (GtkFileChooserDefault *impl)
2858 {
2859   if (!impl->shortcuts_drag_outside_idle)
2860     return;
2861
2862   g_source_destroy (impl->shortcuts_drag_outside_idle);
2863   impl->shortcuts_drag_outside_idle = NULL;
2864 }
2865 #endif
2866
2867 /* GtkWidget::drag-end handler for the shortcuts list. */
2868 static void
2869 shortcuts_drag_end_cb (GtkWidget             *widget,
2870                        GdkDragContext        *context,
2871                        GtkFileChooserDefault *impl)
2872 {
2873 #if 0
2874   g_object_unref (impl->shortcuts_drag_context);
2875
2876   shortcuts_cancel_drag_outside_idle (impl);
2877
2878   if (!impl->shortcuts_drag_outside)
2879     return;
2880
2881   gtk_button_clicked (GTK_BUTTON (impl->browse_shortcuts_remove_button));
2882
2883   impl->shortcuts_drag_outside = FALSE;
2884 #endif
2885 }
2886
2887 /* GtkWidget::drag-data-delete handler for the shortcuts list. */
2888 static void
2889 shortcuts_drag_data_delete_cb (GtkWidget             *widget,
2890                                GdkDragContext        *context,
2891                                GtkFileChooserDefault *impl)
2892 {
2893   g_signal_stop_emission_by_name (widget, "drag-data-delete");
2894 }
2895
2896 /* GtkWidget::drag-leave handler for the shortcuts list.  We unhighlight the
2897  * drop position.
2898  */
2899 static void
2900 shortcuts_drag_leave_cb (GtkWidget             *widget,
2901                          GdkDragContext        *context,
2902                          guint                  time_,
2903                          GtkFileChooserDefault *impl)
2904 {
2905 #if 0
2906   if (gtk_drag_get_source_widget (context) == widget && !impl->shortcuts_drag_outside_idle)
2907     {
2908       impl->shortcuts_drag_outside_idle = add_idle_while_impl_is_alive (impl, G_CALLBACK (shortcuts_drag_outside_idle_cb));
2909     }
2910 #endif
2911
2912   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view),
2913                                    NULL,
2914                                    GTK_TREE_VIEW_DROP_BEFORE);
2915
2916   g_signal_stop_emission_by_name (widget, "drag-leave");
2917 }
2918
2919 /* Computes the appropriate row and position for dropping */
2920 static void
2921 shortcuts_compute_drop_position (GtkFileChooserDefault   *impl,
2922                                  int                      x,
2923                                  int                      y,
2924                                  GtkTreePath            **path,
2925                                  GtkTreeViewDropPosition *pos)
2926 {
2927   GtkTreeView *tree_view;
2928   GtkTreeViewColumn *column;
2929   int cell_y;
2930   GdkRectangle cell;
2931   int row;
2932   int bookmarks_index;
2933   int header_height = 0;
2934
2935   tree_view = GTK_TREE_VIEW (impl->browse_shortcuts_tree_view);
2936
2937   if (gtk_tree_view_get_headers_visible (tree_view))
2938     header_height = _gtk_tree_view_get_header_height (tree_view);
2939
2940   bookmarks_index = shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS);
2941
2942   if (!gtk_tree_view_get_path_at_pos (tree_view,
2943                                       x,
2944                                       y - header_height,
2945                                       path,
2946                                       &column,
2947                                       NULL,
2948                                       &cell_y))
2949     {
2950       row = bookmarks_index + impl->num_bookmarks - 1;
2951       *path = gtk_tree_path_new_from_indices (row, -1);
2952       *pos = GTK_TREE_VIEW_DROP_AFTER;
2953       return;
2954     }
2955
2956   row = *gtk_tree_path_get_indices (*path);
2957   gtk_tree_view_get_background_area (tree_view, *path, column, &cell);
2958   gtk_tree_path_free (*path);
2959
2960   if (row < bookmarks_index)
2961     {
2962       row = bookmarks_index;
2963       *pos = GTK_TREE_VIEW_DROP_BEFORE;
2964     }
2965   else if (row > bookmarks_index + impl->num_bookmarks - 1)
2966     {
2967       row = bookmarks_index + impl->num_bookmarks - 1;
2968       *pos = GTK_TREE_VIEW_DROP_AFTER;
2969     }
2970   else
2971     {
2972       if (cell_y < cell.height / 2)
2973         *pos = GTK_TREE_VIEW_DROP_BEFORE;
2974       else
2975         *pos = GTK_TREE_VIEW_DROP_AFTER;
2976     }
2977
2978   *path = gtk_tree_path_new_from_indices (row, -1);
2979 }
2980
2981 /* GtkWidget::drag-motion handler for the shortcuts list.  We basically
2982  * implement the destination side of DnD by hand, due to limitations in
2983  * GtkTreeView's DnD API.
2984  */
2985 static gboolean
2986 shortcuts_drag_motion_cb (GtkWidget             *widget,
2987                           GdkDragContext        *context,
2988                           gint                   x,
2989                           gint                   y,
2990                           guint                  time_,
2991                           GtkFileChooserDefault *impl)
2992 {
2993   GtkTreePath *path;
2994   GtkTreeViewDropPosition pos;
2995   GdkDragAction action;
2996
2997 #if 0
2998   if (gtk_drag_get_source_widget (context) == widget)
2999     {
3000       shortcuts_cancel_drag_outside_idle (impl);
3001
3002       if (impl->shortcuts_drag_outside)
3003         {
3004           shortcuts_drag_set_delete_cursor (impl, FALSE);
3005           impl->shortcuts_drag_outside = FALSE;
3006         }
3007     }
3008 #endif
3009
3010   if (gdk_drag_context_get_suggested_action (context) == GDK_ACTION_COPY ||
3011       (gdk_drag_context_get_actions (context) & GDK_ACTION_COPY) != 0)
3012     action = GDK_ACTION_COPY;
3013   else if (gdk_drag_context_get_suggested_action (context) == GDK_ACTION_MOVE ||
3014            (gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
3015     action = GDK_ACTION_MOVE;
3016   else
3017     {
3018       action = 0;
3019       goto out;
3020     }
3021
3022   shortcuts_compute_drop_position (impl, x, y, &path, &pos);
3023   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view), path, pos);
3024   gtk_tree_path_free (path);
3025
3026  out:
3027
3028   g_signal_stop_emission_by_name (widget, "drag-motion");
3029
3030   if (action != 0)
3031     {
3032       gdk_drag_status (context, action, time_);
3033       return TRUE;
3034     }
3035   else
3036     return FALSE;
3037 }
3038
3039 /* GtkWidget::drag-drop handler for the shortcuts list. */
3040 static gboolean
3041 shortcuts_drag_drop_cb (GtkWidget             *widget,
3042                         GdkDragContext        *context,
3043                         gint                   x,
3044                         gint                   y,
3045                         guint                  time_,
3046                         GtkFileChooserDefault *impl)
3047 {
3048 #if 0
3049   shortcuts_cancel_drag_outside_idle (impl);
3050 #endif
3051
3052   g_signal_stop_emission_by_name (widget, "drag-drop");
3053   return TRUE;
3054 }
3055
3056 /* Parses a "text/uri-list" string and inserts its URIs as bookmarks */
3057 static void
3058 shortcuts_drop_uris (GtkFileChooserDefault *impl,
3059                      GtkSelectionData      *selection_data,
3060                      int                    position)
3061 {
3062   gchar **uris;
3063   gint i;
3064
3065   uris = gtk_selection_data_get_uris (selection_data);
3066   if (!uris)
3067     return;
3068
3069   for (i = 0; uris[i]; i++)
3070     {
3071       char *uri;
3072       GFile *file;
3073
3074       uri = uris[i];
3075       file = g_file_new_for_uri (uri);
3076
3077       if (shortcuts_add_bookmark_from_file (impl, file, position))
3078         position++;
3079
3080       g_object_unref (file);
3081     }
3082
3083   g_strfreev (uris);
3084 }
3085
3086 /* Reorders the selected bookmark to the specified position */
3087 static void
3088 shortcuts_reorder (GtkFileChooserDefault *impl,
3089                    int                    new_position)
3090 {
3091   GtkTreeIter iter;
3092   gpointer col_data;
3093   ShortcutType shortcut_type;
3094   GtkTreePath *path;
3095   int old_position;
3096   int bookmarks_index;
3097   GFile *file;
3098   GError *error;
3099   gchar *name = NULL;
3100
3101   /* Get the selected path */
3102
3103   if (!shortcuts_get_selected (impl, &iter))
3104     g_assert_not_reached ();
3105
3106   path = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->shortcuts_model), &iter);
3107   old_position = *gtk_tree_path_get_indices (path);
3108   gtk_tree_path_free (path);
3109
3110   bookmarks_index = shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS);
3111   old_position -= bookmarks_index;
3112   g_assert (old_position >= 0 && old_position < impl->num_bookmarks);
3113
3114   gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
3115                       SHORTCUTS_COL_NAME, &name,
3116                       SHORTCUTS_COL_DATA, &col_data,
3117                       SHORTCUTS_COL_TYPE, &shortcut_type,
3118                       -1);
3119   g_assert (col_data != NULL);
3120   g_assert (shortcut_type == SHORTCUT_TYPE_FILE);
3121
3122   file = col_data;
3123   g_object_ref (file); /* removal below will free file, so we need a new ref */
3124
3125   /* Remove the path from the old position and insert it in the new one */
3126
3127   if (new_position > old_position)
3128     new_position--;
3129
3130   if (old_position == new_position)
3131     goto out;
3132
3133   error = NULL;
3134   if (_gtk_file_system_remove_bookmark (impl->file_system, file, &error))
3135     {
3136       shortcuts_add_bookmark_from_file (impl, file, new_position);
3137       _gtk_file_system_set_bookmark_label (impl->file_system, file, name);
3138     }
3139   else
3140     error_adding_bookmark_dialog (impl, file, error);
3141
3142  out:
3143
3144   g_object_unref (file);
3145   g_free (name);
3146 }
3147
3148 /* Callback used when we get the drag data for the bookmarks list.  We add the
3149  * received URIs as bookmarks if they are folders.
3150  */
3151 static void
3152 shortcuts_drag_data_received_cb (GtkWidget          *widget,
3153                                  GdkDragContext     *context,
3154                                  gint                x,
3155                                  gint                y,
3156                                  GtkSelectionData   *selection_data,
3157                                  guint               info,
3158                                  guint               time_,
3159                                  gpointer            data)
3160 {
3161   GtkFileChooserDefault *impl;
3162   GtkTreePath *tree_path;
3163   GtkTreeViewDropPosition tree_pos;
3164   GdkAtom target;
3165   int position;
3166   int bookmarks_index;
3167
3168   impl = GTK_FILE_CHOOSER_DEFAULT (data);
3169
3170   /* Compute position */
3171
3172   bookmarks_index = shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS);
3173
3174   shortcuts_compute_drop_position (impl, x, y, &tree_path, &tree_pos);
3175   position = *gtk_tree_path_get_indices (tree_path);
3176   gtk_tree_path_free (tree_path);
3177
3178   if (tree_pos == GTK_TREE_VIEW_DROP_AFTER)
3179     position++;
3180
3181   g_assert (position >= bookmarks_index);
3182   position -= bookmarks_index;
3183
3184   target = gtk_selection_data_get_target (selection_data);
3185
3186   if (gtk_targets_include_uri (&target, 1))
3187     shortcuts_drop_uris (impl, selection_data, position);
3188   else if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
3189     shortcuts_reorder (impl, position);
3190
3191   g_signal_stop_emission_by_name (widget, "drag-data-received");
3192 }
3193
3194 /* Callback used to display a tooltip in the shortcuts tree */
3195 static gboolean
3196 shortcuts_query_tooltip_cb (GtkWidget             *widget,
3197                             gint                   x,
3198                             gint                   y,
3199                             gboolean               keyboard_mode,
3200                             GtkTooltip            *tooltip,
3201                             GtkFileChooserDefault *impl)
3202 {
3203   GtkTreeModel *model;
3204   GtkTreeIter iter;
3205
3206   if (gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
3207                                          &x, &y,
3208                                          keyboard_mode,
3209                                          &model,
3210                                          NULL,
3211                                          &iter))
3212     {
3213       gpointer col_data;
3214       ShortcutType shortcut_type;
3215
3216       gtk_tree_model_get (model, &iter,
3217                           SHORTCUTS_COL_DATA, &col_data,
3218                           SHORTCUTS_COL_TYPE, &shortcut_type,
3219                           -1);
3220
3221       if (shortcut_type == SHORTCUT_TYPE_SEPARATOR)
3222         return FALSE;
3223       else if (shortcut_type == SHORTCUT_TYPE_VOLUME)
3224         return FALSE;
3225       else if (shortcut_type == SHORTCUT_TYPE_FILE)
3226         {
3227           GFile *file;
3228           char *parse_name;
3229
3230           file = G_FILE (col_data);
3231           parse_name = g_file_get_parse_name (file);
3232
3233           gtk_tooltip_set_text (tooltip, parse_name);
3234
3235           g_free (parse_name);
3236
3237           return TRUE;
3238         }
3239       else if (shortcut_type == SHORTCUT_TYPE_SEARCH)
3240         {
3241           return FALSE;
3242         }
3243       else if (shortcut_type == SHORTCUT_TYPE_RECENT)
3244         {
3245           return FALSE;
3246         }
3247     }
3248
3249   return FALSE;
3250 }
3251
3252
3253 /* Callback used when the selection in the shortcuts tree changes */
3254 static void
3255 shortcuts_selection_changed_cb (GtkTreeSelection      *selection,
3256                                 GtkFileChooserDefault *impl)
3257 {
3258   GtkTreeIter iter;
3259   GtkTreeIter child_iter;
3260
3261   bookmarks_check_remove_sensitivity (impl);
3262   shortcuts_check_popup_sensitivity (impl);
3263
3264   if (impl->changing_folder)
3265     return;
3266
3267   if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3268     {
3269       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (impl->shortcuts_pane_filter_model),
3270                                                         &child_iter,
3271                                                         &iter);
3272       shortcuts_activate_iter (impl, &child_iter);
3273     }
3274 }
3275
3276 static gboolean
3277 shortcuts_row_separator_func (GtkTreeModel *model,
3278                               GtkTreeIter  *iter,
3279                               gpointer      data)
3280 {
3281   ShortcutType shortcut_type;
3282
3283   gtk_tree_model_get (model, iter, SHORTCUTS_COL_TYPE, &shortcut_type, -1);
3284
3285   return shortcut_type == SHORTCUT_TYPE_SEPARATOR;
3286 }
3287
3288 static gboolean
3289 shortcuts_key_press_event_after_cb (GtkWidget             *tree_view,
3290                                     GdkEventKey           *event,
3291                                     GtkFileChooserDefault *impl)
3292 {
3293   GtkWidget *entry;
3294
3295   /* don't screw up focus switching with Tab */
3296   if (event->keyval == GDK_KEY_Tab
3297       || event->keyval == GDK_KEY_KP_Tab
3298       || event->keyval == GDK_KEY_ISO_Left_Tab
3299       || event->length < 1)
3300     return FALSE;
3301
3302   if (impl->location_entry)
3303     entry = impl->location_entry;
3304   else if (impl->search_entry)
3305     entry = impl->search_entry;
3306   else
3307     entry = NULL;
3308
3309   if (entry)
3310     {
3311       gtk_widget_grab_focus (entry);
3312       return gtk_widget_event (entry, (GdkEvent *) event);
3313     }
3314   else
3315     return FALSE;
3316 }
3317
3318 /* Callback used when the file list's popup menu is detached */
3319 static void
3320 shortcuts_popup_menu_detach_cb (GtkWidget *attach_widget,
3321                                 GtkMenu   *menu)
3322 {
3323   GtkFileChooserDefault *impl;
3324
3325   impl = g_object_get_data (G_OBJECT (attach_widget), "GtkFileChooserDefault");
3326   g_assert (GTK_IS_FILE_CHOOSER_DEFAULT (impl));
3327
3328   impl->browse_shortcuts_popup_menu = NULL;
3329   impl->browse_shortcuts_popup_menu_remove_item = NULL;
3330   impl->browse_shortcuts_popup_menu_rename_item = NULL;
3331 }
3332
3333 static void
3334 remove_shortcut_cb (GtkMenuItem           *item,
3335                     GtkFileChooserDefault *impl)
3336 {
3337   remove_selected_bookmarks (impl);
3338 }
3339
3340 /* Rename the selected bookmark */
3341 static void
3342 rename_selected_bookmark (GtkFileChooserDefault *impl)
3343 {
3344   GtkTreeIter iter;
3345   GtkTreePath *path;
3346   GtkTreeViewColumn *column;
3347   GtkCellRenderer *cell;
3348   GList *renderers;
3349
3350   if (shortcuts_get_selected (impl, &iter))
3351     {
3352       path = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->shortcuts_model), &iter);
3353       column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view), 0);
3354       renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
3355       cell = g_list_nth_data (renderers, 1);
3356       g_list_free (renderers);
3357       g_object_set (cell, "editable", TRUE, NULL);
3358       gtk_tree_view_set_cursor_on_cell (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view),
3359                                         path, column, cell, TRUE);
3360       gtk_tree_path_free (path);
3361     }
3362 }
3363
3364 static void
3365 rename_shortcut_cb (GtkMenuItem           *item,
3366                     GtkFileChooserDefault *impl)
3367 {
3368   rename_selected_bookmark (impl);
3369 }
3370
3371 /* Constructs the popup menu for the file list if needed */
3372 static void
3373 shortcuts_build_popup_menu (GtkFileChooserDefault *impl)
3374 {
3375   GtkWidget *item;
3376
3377   if (impl->browse_shortcuts_popup_menu)
3378     return;
3379
3380   impl->browse_shortcuts_popup_menu = gtk_menu_new ();
3381   gtk_menu_attach_to_widget (GTK_MENU (impl->browse_shortcuts_popup_menu),
3382                              impl->browse_shortcuts_tree_view,
3383                              shortcuts_popup_menu_detach_cb);
3384
3385   item = gtk_image_menu_item_new_with_label (_("Remove"));
3386   impl->browse_shortcuts_popup_menu_remove_item = item;
3387   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
3388                                  gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
3389   g_signal_connect (item, "activate",
3390                     G_CALLBACK (remove_shortcut_cb), impl);
3391   gtk_widget_show (item);
3392   gtk_menu_shell_append (GTK_MENU_SHELL (impl->browse_shortcuts_popup_menu), item);
3393
3394   item = gtk_menu_item_new_with_label (_("Rename…"));
3395   impl->browse_shortcuts_popup_menu_rename_item = item;
3396   g_signal_connect (item, "activate",
3397                     G_CALLBACK (rename_shortcut_cb), impl);
3398   gtk_widget_show (item);
3399   gtk_menu_shell_append (GTK_MENU_SHELL (impl->browse_shortcuts_popup_menu), item);
3400 }
3401
3402 static void
3403 shortcuts_update_popup_menu (GtkFileChooserDefault *impl)
3404 {
3405   shortcuts_build_popup_menu (impl);
3406   shortcuts_check_popup_sensitivity (impl);
3407 }
3408
3409 static void
3410 popup_position_func (GtkMenu   *menu,
3411                      gint      *x,
3412                      gint      *y,
3413                      gboolean  *push_in,
3414                      gpointer   user_data);
3415
3416 static void
3417 shortcuts_popup_menu (GtkFileChooserDefault *impl,
3418                       GdkEventButton        *event)
3419 {
3420   shortcuts_update_popup_menu (impl);
3421   if (event)
3422     gtk_menu_popup (GTK_MENU (impl->browse_shortcuts_popup_menu),
3423                     NULL, NULL, NULL, NULL,
3424                     event->button, event->time);
3425   else
3426     {
3427       gtk_menu_popup (GTK_MENU (impl->browse_shortcuts_popup_menu),
3428                       NULL, NULL,
3429                       popup_position_func, impl->browse_shortcuts_tree_view,
3430                       0, GDK_CURRENT_TIME);
3431       gtk_menu_shell_select_first (GTK_MENU_SHELL (impl->browse_shortcuts_popup_menu),
3432                                    FALSE);
3433     }
3434 }
3435
3436 /* Callback used for the GtkWidget::popup-menu signal of the shortcuts list */
3437 static gboolean
3438 shortcuts_popup_menu_cb (GtkWidget *widget,
3439                          GtkFileChooserDefault *impl)
3440 {
3441   shortcuts_popup_menu (impl, NULL);
3442   return TRUE;
3443 }
3444
3445 /* Callback used when a button is pressed on the shortcuts list.
3446  * We trap button 3 to bring up a popup menu.
3447  */
3448 static gboolean
3449 shortcuts_button_press_event_cb (GtkWidget             *widget,
3450                                  GdkEventButton        *event,
3451                                  GtkFileChooserDefault *impl)
3452 {
3453   static gboolean in_press = FALSE;
3454   gboolean handled;
3455
3456   if (in_press)
3457     return FALSE;
3458
3459   if (!gdk_event_triggers_context_menu ((GdkEvent *) event))
3460     return FALSE;
3461
3462   in_press = TRUE;
3463   handled = gtk_widget_event (impl->browse_shortcuts_tree_view, (GdkEvent *) event);
3464   in_press = FALSE;
3465
3466   if (!handled)
3467     return FALSE;
3468
3469   shortcuts_popup_menu (impl, event);
3470   return TRUE;
3471 }
3472
3473 static void
3474 shortcuts_edited (GtkCellRenderer       *cell,
3475                   gchar                 *path_string,
3476                   gchar                 *new_text,
3477                   GtkFileChooserDefault *impl)
3478 {
3479   GtkTreePath *path;
3480   GtkTreeIter iter;
3481   GFile *shortcut;
3482
3483   g_object_set (cell, "editable", FALSE, NULL);
3484
3485   path = gtk_tree_path_new_from_string (path_string);
3486   if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->shortcuts_model), &iter, path))
3487     g_assert_not_reached ();
3488
3489   gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
3490                       SHORTCUTS_COL_DATA, &shortcut,
3491                       -1);
3492   gtk_tree_path_free (path);
3493
3494   _gtk_file_system_set_bookmark_label (impl->file_system, shortcut, new_text);
3495 }
3496
3497 static void
3498 shortcuts_editing_canceled (GtkCellRenderer       *cell,
3499                             GtkFileChooserDefault *impl)
3500 {
3501   g_object_set (cell, "editable", FALSE, NULL);
3502 }
3503
3504 /* Creates the widgets for the shortcuts and bookmarks tree */
3505 static GtkWidget *
3506 shortcuts_list_create (GtkFileChooserDefault *impl)
3507 {
3508   GtkWidget *swin;
3509   GtkTreeSelection *selection;
3510   GtkTreeViewColumn *column;
3511   GtkCellRenderer *renderer;
3512
3513   /* Target types for dragging a row to/from the shortcuts list */
3514   const GtkTargetEntry tree_model_row_targets[] = {
3515     { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, GTK_TREE_MODEL_ROW }
3516   };
3517
3518   /* Scrolled window */
3519
3520   swin = gtk_scrolled_window_new (NULL, NULL);
3521   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
3522                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
3523   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin),
3524                                        GTK_SHADOW_IN);
3525   gtk_widget_show (swin);
3526
3527   /* Tree */
3528   impl->browse_shortcuts_tree_view = gtk_tree_view_new ();
3529   gtk_style_context_add_class (gtk_widget_get_style_context (impl->browse_shortcuts_tree_view),
3530                                GTK_STYLE_CLASS_SIDEBAR);
3531   gtk_tree_view_set_enable_search (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view), FALSE);
3532 #ifdef PROFILE_FILE_CHOOSER
3533   g_object_set_data (G_OBJECT (impl->browse_shortcuts_tree_view), "fmq-name", "shortcuts");
3534 #endif
3535
3536   /* Connect "after" to key-press-event on the shortcuts pane.  We want this action to be possible:
3537    *
3538    *   1. user brings up a SAVE dialog
3539    *   2. user clicks on a shortcut in the shortcuts pane
3540    *   3. user starts typing a filename
3541    *
3542    * Normally, the user's typing would be ignored, as the shortcuts treeview doesn't
3543    * support interactive search.  However, we'd rather focus the location entry
3544    * so that the user can type *there*.
3545    *
3546    * To preserve keyboard navigation in the shortcuts pane, we don't focus the
3547    * filename entry if one clicks on a shortcut; rather, we focus the entry only
3548    * if the user starts typing while the focus is in the shortcuts pane.
3549    */
3550   g_signal_connect_after (impl->browse_shortcuts_tree_view, "key-press-event",
3551                           G_CALLBACK (shortcuts_key_press_event_after_cb), impl);
3552
3553   g_signal_connect (impl->browse_shortcuts_tree_view, "popup-menu",
3554                     G_CALLBACK (shortcuts_popup_menu_cb), impl);
3555   g_signal_connect (impl->browse_shortcuts_tree_view, "button-press-event",
3556                     G_CALLBACK (shortcuts_button_press_event_cb), impl);
3557   /* Accessible object name for the file chooser's shortcuts pane */
3558   atk_object_set_name (gtk_widget_get_accessible (impl->browse_shortcuts_tree_view), _("Places"));
3559
3560   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view), impl->shortcuts_pane_filter_model);
3561
3562   gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view),
3563                                           GDK_BUTTON1_MASK,
3564                                           tree_model_row_targets,
3565                                           G_N_ELEMENTS (tree_model_row_targets),
3566                                           GDK_ACTION_MOVE);
3567
3568   gtk_drag_dest_set (impl->browse_shortcuts_tree_view,
3569                      GTK_DEST_DEFAULT_ALL,
3570                      tree_model_row_targets,
3571                      G_N_ELEMENTS (tree_model_row_targets),
3572                      GDK_ACTION_COPY | GDK_ACTION_MOVE);
3573   gtk_drag_dest_add_uri_targets (impl->browse_shortcuts_tree_view);
3574
3575   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view));
3576   gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
3577   gtk_tree_selection_set_select_function (selection,
3578                                           shortcuts_select_func,
3579                                           impl, NULL);
3580
3581   g_signal_connect (selection, "changed",
3582                     G_CALLBACK (shortcuts_selection_changed_cb), impl);
3583
3584   g_signal_connect (impl->browse_shortcuts_tree_view, "key-press-event",
3585                     G_CALLBACK (shortcuts_key_press_event_cb), impl);
3586
3587   g_signal_connect (impl->browse_shortcuts_tree_view, "drag-begin",
3588                     G_CALLBACK (shortcuts_drag_begin_cb), impl);
3589   g_signal_connect (impl->browse_shortcuts_tree_view, "drag-end",
3590                     G_CALLBACK (shortcuts_drag_end_cb), impl);
3591   g_signal_connect (impl->browse_shortcuts_tree_view, "drag-data-delete",
3592                     G_CALLBACK (shortcuts_drag_data_delete_cb), impl);
3593
3594   g_signal_connect (impl->browse_shortcuts_tree_view, "drag-leave",
3595                     G_CALLBACK (shortcuts_drag_leave_cb), impl);
3596   g_signal_connect (impl->browse_shortcuts_tree_view, "drag-motion",
3597                     G_CALLBACK (shortcuts_drag_motion_cb), impl);
3598   g_signal_connect (impl->browse_shortcuts_tree_view, "drag-drop",
3599                     G_CALLBACK (shortcuts_drag_drop_cb), impl);
3600   g_signal_connect (impl->browse_shortcuts_tree_view, "drag-data-received",
3601                     G_CALLBACK (shortcuts_drag_data_received_cb), impl);
3602
3603   /* Support tooltips */
3604   gtk_widget_set_has_tooltip (impl->browse_shortcuts_tree_view, TRUE);
3605   g_signal_connect (impl->browse_shortcuts_tree_view, "query-tooltip",
3606                     G_CALLBACK (shortcuts_query_tooltip_cb), impl);
3607
3608   gtk_container_add (GTK_CONTAINER (swin), impl->browse_shortcuts_tree_view);
3609   gtk_widget_show (impl->browse_shortcuts_tree_view);
3610
3611   /* Column */
3612
3613   column = gtk_tree_view_column_new ();
3614   /* Column header for the file chooser's shortcuts pane */
3615   gtk_tree_view_column_set_title (column, _("_Places"));
3616
3617   renderer = gtk_cell_renderer_pixbuf_new ();
3618   gtk_tree_view_column_pack_start (column, renderer, FALSE);
3619   gtk_tree_view_column_set_attributes (column, renderer,
3620                                        "pixbuf", SHORTCUTS_COL_PIXBUF,
3621                                        "visible", SHORTCUTS_COL_PIXBUF_VISIBLE,
3622                                        NULL);
3623
3624   renderer = gtk_cell_renderer_text_new ();
3625   g_object_set (renderer,
3626                 "width-chars", 12,
3627                 "ellipsize", PANGO_ELLIPSIZE_END,
3628                 NULL);
3629   g_signal_connect (renderer, "edited",
3630                     G_CALLBACK (shortcuts_edited), impl);
3631   g_signal_connect (renderer, "editing-canceled",
3632                     G_CALLBACK (shortcuts_editing_canceled), impl);
3633   gtk_tree_view_column_pack_start (column, renderer, TRUE);
3634   gtk_tree_view_column_set_attributes (column, renderer,
3635                                        "text", SHORTCUTS_COL_NAME,
3636                                        NULL);
3637
3638   gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view),
3639                                         shortcuts_row_separator_func,
3640                                         NULL, NULL);
3641
3642   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view), column);
3643
3644   return swin;
3645 }
3646
3647 /* Creates the widgets for the shortcuts/bookmarks pane */
3648 static GtkWidget *
3649 shortcuts_pane_create (GtkFileChooserDefault *impl,
3650                        GtkSizeGroup          *size_group)
3651 {
3652   GtkWidget *vbox;
3653   GtkWidget *toolbar;
3654   GtkWidget *widget;
3655   GtkStyleContext *context;
3656   GIcon *icon;
3657
3658   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3659   gtk_widget_show (vbox);
3660
3661   /* Shortcuts tree */
3662
3663   widget = shortcuts_list_create (impl);
3664
3665   gtk_size_group_add_widget (size_group, widget);
3666   context = gtk_widget_get_style_context (widget);
3667   gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
3668
3669   gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
3670
3671   /* Box for buttons */
3672
3673   toolbar = gtk_toolbar_new ();
3674   gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
3675   gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU);
3676
3677   context = gtk_widget_get_style_context (toolbar);
3678   gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
3679   gtk_style_context_add_class (context, GTK_STYLE_CLASS_INLINE_TOOLBAR);
3680
3681   gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
3682   gtk_widget_show (toolbar);
3683
3684   /* Add bookmark button */
3685   icon = g_themed_icon_new_with_default_fallbacks ("list-add-symbolic");
3686   impl->browse_shortcuts_add_button = toolbutton_new (impl,
3687                                                       icon,
3688                                                       FALSE,
3689                                                       TRUE,
3690                                                       G_CALLBACK (add_bookmark_button_clicked_cb));
3691   g_object_unref (icon);
3692
3693   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (impl->browse_shortcuts_add_button), 0);
3694   gtk_widget_set_tooltip_text (impl->browse_shortcuts_add_button,
3695                                _("Add the selected folder to the Bookmarks"));
3696
3697   /* Remove bookmark button */
3698   icon = g_themed_icon_new_with_default_fallbacks ("list-remove-symbolic");
3699   impl->browse_shortcuts_remove_button = toolbutton_new (impl,
3700                                                          icon,
3701                                                          FALSE,
3702                                                          TRUE,
3703                                                          G_CALLBACK (remove_bookmark_button_clicked_cb));
3704   g_object_unref (icon);
3705   gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (impl->browse_shortcuts_remove_button), 1);
3706   gtk_widget_set_tooltip_text (impl->browse_shortcuts_remove_button,
3707                                _("Remove the selected bookmark"));
3708
3709   return vbox;
3710 }
3711
3712 static gboolean
3713 key_is_left_or_right (GdkEventKey *event)
3714 {
3715   guint modifiers;
3716
3717   modifiers = gtk_accelerator_get_default_mod_mask ();
3718
3719   return ((event->keyval == GDK_KEY_Right
3720            || event->keyval == GDK_KEY_KP_Right
3721            || event->keyval == GDK_KEY_Left
3722            || event->keyval == GDK_KEY_KP_Left)
3723           && (event->state & modifiers) == 0);
3724 }
3725
3726 /* Handles key press events on the file list, so that we can trap Enter to
3727  * activate the default button on our own.  Also, checks to see if '/' has been
3728  * pressed.
3729  */
3730 static gboolean
3731 browse_files_key_press_event_cb (GtkWidget   *widget,
3732                                  GdkEventKey *event,
3733                                  gpointer     data)
3734 {
3735   GtkFileChooserDefault *impl;
3736   GdkModifierType no_text_input_mask;
3737
3738   impl = (GtkFileChooserDefault *) data;
3739
3740   no_text_input_mask =
3741     gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_NO_TEXT_INPUT);
3742
3743   if ((event->keyval == GDK_KEY_slash
3744        || event->keyval == GDK_KEY_KP_Divide
3745 #ifdef G_OS_UNIX
3746        || event->keyval == GDK_KEY_asciitilde
3747 #endif
3748        ) && !(event->state & no_text_input_mask))
3749     {
3750       location_popup_handler (impl, event->string);
3751       return TRUE;
3752     }
3753
3754   if (key_is_left_or_right (event))
3755     {
3756       gtk_widget_grab_focus (impl->browse_shortcuts_tree_view);
3757       return TRUE;
3758     }
3759
3760   if ((event->keyval == GDK_KEY_Return
3761        || event->keyval == GDK_KEY_ISO_Enter
3762        || event->keyval == GDK_KEY_KP_Enter
3763        || event->keyval == GDK_KEY_space
3764        || event->keyval == GDK_KEY_KP_Space)
3765       && !(event->state & gtk_accelerator_get_default_mod_mask ())
3766       && !(impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
3767            impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER))
3768     {
3769       GtkWindow *window;
3770
3771       window = get_toplevel (widget);
3772       if (window)
3773         {
3774           GtkWidget *default_widget, *focus_widget;
3775
3776           default_widget = gtk_window_get_default_widget (window);
3777           focus_widget = gtk_window_get_focus (window);
3778
3779           if (widget != default_widget &&
3780               !(widget == focus_widget && (!default_widget || !gtk_widget_get_sensitive (default_widget))))
3781             {
3782               gtk_window_activate_default (window);
3783
3784               return TRUE;
3785             }
3786         }
3787     }
3788
3789   return FALSE;
3790 }
3791
3792 /* Callback used when the file list's popup menu is detached */
3793 static void
3794 popup_menu_detach_cb (GtkWidget *attach_widget,
3795                       GtkMenu   *menu)
3796 {
3797   GtkFileChooserDefault *impl;
3798
3799   impl = g_object_get_data (G_OBJECT (attach_widget), "GtkFileChooserDefault");
3800   g_assert (GTK_IS_FILE_CHOOSER_DEFAULT (impl));
3801
3802   impl->browse_files_popup_menu = NULL;
3803   impl->browse_files_popup_menu_add_shortcut_item = NULL;
3804   impl->browse_files_popup_menu_hidden_files_item = NULL;
3805   impl->browse_files_popup_menu_copy_file_location_item = NULL;
3806 }
3807
3808 /* Callback used when the "Add to Bookmarks" menu item is activated */
3809 static void
3810 add_to_shortcuts_cb (GtkMenuItem           *item,
3811                      GtkFileChooserDefault *impl)
3812 {
3813   bookmarks_add_selected_folder (impl);
3814 }
3815
3816 /* callback used to set data to clipboard */
3817 static void
3818 copy_file_get_cb  (GtkClipboard     *clipboard,
3819                    GtkSelectionData *selection_data,
3820                    guint             info,
3821                    gpointer          data)
3822 {
3823   GSList *selected_files = data;
3824
3825   if (selected_files)
3826     {
3827       gint num_files = g_slist_length (selected_files);
3828       gchar **uris;
3829       gint i;
3830       GSList *l;
3831
3832       uris = g_new (gchar *, num_files + 1);
3833       uris[num_files] = NULL; /* null terminator */
3834
3835       i = 0;
3836
3837       for (l = selected_files; l; l = l->next)
3838         {
3839           GFile *file = (GFile *) l->data;
3840
3841           if (info == SELECTION_URI)
3842             uris[i] = g_file_get_uri (file);
3843           else /* if (info == SELECTION_TEXT) - let this be the fallback */
3844             uris[i] = g_file_get_parse_name (file);
3845
3846           i++;
3847         }
3848
3849       if (info == SELECTION_URI)
3850         gtk_selection_data_set_uris (selection_data, uris);
3851       else /* if (info == SELECTION_TEXT) - let this be the fallback */
3852         {
3853           char *str = g_strjoinv (" ", uris);
3854           gtk_selection_data_set_text (selection_data, str, -1);
3855           g_free (str);
3856         }
3857
3858       g_strfreev (uris);
3859     }
3860 }
3861
3862 /* callback used to clear the clipboard data */
3863 static void
3864 copy_file_clear_cb (GtkClipboard *clipboard,
3865                     gpointer      data)
3866 {
3867   GSList *selected_files = data;
3868
3869   g_slist_foreach (selected_files, (GFunc) g_object_unref, NULL);
3870   g_slist_free (selected_files);
3871 }
3872
3873 /* Callback used when the "Copy file’s location" menu item is activated */
3874 static void
3875 copy_file_location_cb (GtkMenuItem           *item,
3876                        GtkFileChooserDefault *impl)
3877 {
3878   GSList *selected_files = NULL;
3879
3880   selected_files = search_get_selected_files (impl);
3881
3882   if (selected_files)
3883     {
3884       GtkClipboard *clipboard;
3885       GtkTargetList *target_list;
3886       GtkTargetEntry *targets;
3887       int n_targets;
3888
3889       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (impl), GDK_SELECTION_CLIPBOARD);
3890
3891       target_list = gtk_target_list_new (NULL, 0);
3892       gtk_target_list_add_text_targets (target_list, SELECTION_TEXT);
3893       gtk_target_list_add_uri_targets (target_list, SELECTION_URI);
3894
3895       targets = gtk_target_table_new_from_list (target_list, &n_targets);
3896       gtk_target_list_unref (target_list);
3897
3898       gtk_clipboard_set_with_data (clipboard, targets, n_targets,
3899                                    copy_file_get_cb,
3900                                    copy_file_clear_cb,
3901                                    selected_files);
3902
3903       gtk_target_table_free (targets, n_targets);
3904     }
3905 }
3906
3907 /* Callback used when the "Visit this file" menu item is activated */
3908 static void
3909 visit_file_cb (GtkMenuItem *item,
3910                GtkFileChooserDefault *impl)
3911 {
3912   GSList *files;
3913
3914   files = search_get_selected_files (impl);
3915
3916   /* Sigh, just use the first one */
3917   if (files)
3918     {
3919       GFile *file = files->data;
3920
3921       gtk_file_chooser_default_select_file (GTK_FILE_CHOOSER (impl), file, NULL); /* NULL-GError */
3922     }
3923
3924   g_slist_foreach (files, (GFunc) g_object_unref, NULL);
3925   g_slist_free (files);
3926 }
3927
3928 /* callback used when the "Show Hidden Files" menu item is toggled */
3929 static void
3930 show_hidden_toggled_cb (GtkCheckMenuItem      *item,
3931                         GtkFileChooserDefault *impl)
3932 {
3933   g_object_set (impl,
3934                 "show-hidden", gtk_check_menu_item_get_active (item),
3935                 NULL);
3936 }
3937
3938 /* Callback used when the "Show Size Column" menu item is toggled */
3939 static void
3940 show_size_column_toggled_cb (GtkCheckMenuItem *item,
3941                              GtkFileChooserDefault *impl)
3942 {
3943   impl->show_size_column = gtk_check_menu_item_get_active (item);
3944
3945   gtk_tree_view_column_set_visible (impl->list_size_column,
3946                                     impl->show_size_column);
3947 }
3948
3949 /* Shows an error dialog about not being able to select a dragged file */
3950 static void
3951 error_selecting_dragged_file_dialog (GtkFileChooserDefault *impl,
3952                                      GFile                 *file,
3953                                      GError                *error)
3954 {
3955   error_dialog (impl,
3956                 _("Could not select file"),
3957                 file, error);
3958 }
3959
3960 static void
3961 file_list_drag_data_select_uris (GtkFileChooserDefault  *impl,
3962                                  gchar                 **uris)
3963 {
3964   int i;
3965   char *uri;
3966   GtkFileChooser *chooser = GTK_FILE_CHOOSER (impl);
3967
3968   for (i = 1; uris[i]; i++)
3969     {
3970       GFile *file;
3971       GError *error = NULL;
3972
3973       uri = uris[i];
3974       file = g_file_new_for_uri (uri);
3975
3976       gtk_file_chooser_default_select_file (chooser, file, &error);
3977       if (error)
3978         error_selecting_dragged_file_dialog (impl, file, error);
3979
3980       g_object_unref (file);
3981     }
3982 }
3983
3984 struct FileListDragData
3985 {
3986   GtkFileChooserDefault *impl;
3987   gchar **uris;
3988   GFile *file;
3989 };
3990
3991 static void
3992 file_list_drag_data_received_get_info_cb (GCancellable *cancellable,
3993                                           GFileInfo    *info,
3994                                           const GError *error,
3995                                           gpointer      user_data)
3996 {
3997   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
3998   struct FileListDragData *data = user_data;
3999   GtkFileChooser *chooser = GTK_FILE_CHOOSER (data->impl);
4000
4001   if (cancellable != data->impl->file_list_drag_data_received_cancellable)
4002     goto out;
4003
4004   data->impl->file_list_drag_data_received_cancellable = NULL;
4005
4006   if (cancelled || error)
4007     goto out;
4008
4009   if ((data->impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
4010        data->impl->action == GTK_FILE_CHOOSER_ACTION_SAVE) &&
4011       data->uris[1] == 0 && !error && _gtk_file_info_consider_as_directory (info))
4012     change_folder_and_display_error (data->impl, data->file, FALSE);
4013   else
4014     {
4015       GError *error = NULL;
4016
4017       gtk_file_chooser_default_unselect_all (chooser);
4018       gtk_file_chooser_default_select_file (chooser, data->file, &error);
4019       if (error)
4020         error_selecting_dragged_file_dialog (data->impl, data->file, error);
4021       else
4022         browse_files_center_selected_row (data->impl);
4023     }
4024
4025   if (data->impl->select_multiple)
4026     file_list_drag_data_select_uris (data->impl, data->uris);
4027
4028 out:
4029   g_object_unref (data->impl);
4030   g_strfreev (data->uris);
4031   g_object_unref (data->file);
4032   g_free (data);
4033
4034   g_object_unref (cancellable);
4035 }
4036
4037 static void
4038 file_list_drag_data_received_cb (GtkWidget        *widget,
4039                                  GdkDragContext   *context,
4040                                  gint              x,
4041                                  gint              y,
4042                                  GtkSelectionData *selection_data,
4043                                  guint             info,
4044                                  guint             time_,
4045                                  gpointer          data)
4046 {
4047   GtkFileChooserDefault *impl;
4048   gchar **uris;
4049   char *uri;
4050   GFile *file;
4051
4052   impl = GTK_FILE_CHOOSER_DEFAULT (data);
4053
4054   /* Allow only drags from other widgets; see bug #533891. */
4055   if (gtk_drag_get_source_widget (context) == widget)
4056     {
4057       g_signal_stop_emission_by_name (widget, "drag-data-received");
4058       return;
4059     }
4060
4061   /* Parse the text/uri-list string, navigate to the first one */
4062   uris = gtk_selection_data_get_uris (selection_data);
4063   if (uris && uris[0])
4064     {
4065       struct FileListDragData *data;
4066
4067       uri = uris[0];
4068       file = g_file_new_for_uri (uri);
4069
4070       data = g_new0 (struct FileListDragData, 1);
4071       data->impl = g_object_ref (impl);
4072       data->uris = uris;
4073       data->file = file;
4074
4075       if (impl->file_list_drag_data_received_cancellable)
4076         g_cancellable_cancel (impl->file_list_drag_data_received_cancellable);
4077
4078       impl->file_list_drag_data_received_cancellable =
4079         _gtk_file_system_get_info (impl->file_system, file,
4080                                    "standard::type",
4081                                    file_list_drag_data_received_get_info_cb,
4082                                    data);
4083     }
4084
4085   g_signal_stop_emission_by_name (widget, "drag-data-received");
4086 }
4087
4088 /* Don't do anything with the drag_drop signal */
4089 static gboolean
4090 file_list_drag_drop_cb (GtkWidget             *widget,
4091                         GdkDragContext        *context,
4092                         gint                   x,
4093                         gint                   y,
4094                         guint                  time_,
4095                         GtkFileChooserDefault *impl)
4096 {
4097   g_signal_stop_emission_by_name (widget, "drag-drop");
4098   return TRUE;
4099 }
4100
4101 /* Disable the normal tree drag motion handler, it makes it look like you're
4102    dropping the dragged item onto a tree item */
4103 static gboolean
4104 file_list_drag_motion_cb (GtkWidget             *widget,
4105                           GdkDragContext        *context,
4106                           gint                   x,
4107                           gint                   y,
4108                           guint                  time_,
4109                           GtkFileChooserDefault *impl)
4110 {
4111   g_signal_stop_emission_by_name (widget, "drag-motion");
4112   return TRUE;
4113 }
4114
4115 /* Sensitizes the "Copy file’s location" context menu item if there is actually
4116  * a selection active.
4117  */
4118 static void
4119 check_copy_file_location_sensitivity (GtkFileChooserDefault *impl)
4120 {
4121   GtkTreeSelection *selection;
4122   gboolean active;
4123
4124   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
4125   if (gtk_tree_selection_count_selected_rows (selection) == 0)
4126     active = FALSE;
4127   else
4128     active = TRUE;
4129
4130   if (impl->browse_files_popup_menu_copy_file_location_item)
4131     gtk_widget_set_sensitive (impl->browse_files_popup_menu_copy_file_location_item, active);
4132 }
4133
4134 static GtkWidget *
4135 file_list_add_image_menu_item (GtkFileChooserDefault *impl,
4136                                const char *stock_name,
4137                                const char *mnemonic_label,
4138                                GCallback callback)
4139 {
4140   GtkWidget *item;
4141
4142   item = gtk_image_menu_item_new_with_mnemonic (mnemonic_label);
4143   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
4144                                  gtk_image_new_from_stock (stock_name, GTK_ICON_SIZE_MENU));
4145   g_signal_connect (item, "activate", callback, impl);
4146   gtk_widget_show (item);
4147   gtk_menu_shell_append (GTK_MENU_SHELL (impl->browse_files_popup_menu), item);
4148
4149   return item;
4150 }
4151
4152 static GtkWidget *
4153 file_list_add_check_menu_item (GtkFileChooserDefault *impl,
4154                                const char *mnemonic_label,
4155                                GCallback callback)
4156 {
4157   GtkWidget *item;
4158
4159   item = gtk_check_menu_item_new_with_mnemonic (mnemonic_label);
4160   g_signal_connect (item, "toggled", callback, impl);
4161   gtk_widget_show (item);
4162   gtk_menu_shell_append (GTK_MENU_SHELL (impl->browse_files_popup_menu), item);
4163
4164   return item;
4165 }
4166
4167 /* Constructs the popup menu for the file list if needed */
4168 static void
4169 file_list_build_popup_menu (GtkFileChooserDefault *impl)
4170 {
4171   GtkWidget *item;
4172
4173   if (impl->browse_files_popup_menu)
4174     return;
4175
4176   impl->browse_files_popup_menu = gtk_menu_new ();
4177   gtk_menu_attach_to_widget (GTK_MENU (impl->browse_files_popup_menu),
4178                              impl->browse_files_tree_view,
4179                              popup_menu_detach_cb);
4180
4181   impl->browse_files_popup_menu_visit_file_item         = file_list_add_image_menu_item (impl, GTK_STOCK_DIRECTORY, _("_Visit this file"),
4182                                                                                          G_CALLBACK (visit_file_cb));
4183
4184   impl->browse_files_popup_menu_copy_file_location_item = file_list_add_image_menu_item (impl, GTK_STOCK_COPY, _("_Copy file’s location"),
4185                                                                                          G_CALLBACK (copy_file_location_cb));
4186
4187   impl->browse_files_popup_menu_add_shortcut_item       = file_list_add_image_menu_item (impl, GTK_STOCK_ADD, _("_Add to Bookmarks"),
4188                                                                                          G_CALLBACK (add_to_shortcuts_cb));
4189
4190   item = gtk_separator_menu_item_new ();
4191   gtk_widget_show (item);
4192   gtk_menu_shell_append (GTK_MENU_SHELL (impl->browse_files_popup_menu), item);
4193
4194   impl->browse_files_popup_menu_hidden_files_item       = file_list_add_check_menu_item (impl, _("Show _Hidden Files"),
4195                                                                                          G_CALLBACK (show_hidden_toggled_cb));
4196
4197   impl->browse_files_popup_menu_size_column_item        = file_list_add_check_menu_item (impl, _("Show _Size Column"),
4198                                                                                          G_CALLBACK (show_size_column_toggled_cb));
4199
4200   bookmarks_check_add_sensitivity (impl);
4201   check_copy_file_location_sensitivity (impl);
4202 }
4203
4204 /* Updates the popup menu for the file list, creating it if necessary */
4205 static void
4206 file_list_update_popup_menu (GtkFileChooserDefault *impl)
4207 {
4208   file_list_build_popup_menu (impl);
4209
4210   /* The sensitivity of the Add to Bookmarks item is set in
4211    * bookmarks_check_add_sensitivity()
4212    */
4213
4214   /* 'Visit this file' */
4215   gtk_widget_set_visible (impl->browse_files_popup_menu_visit_file_item, (impl->operation_mode != OPERATION_MODE_BROWSE));
4216
4217   /* 'Show Hidden Files' */
4218   g_signal_handlers_block_by_func (impl->browse_files_popup_menu_hidden_files_item,
4219                                    G_CALLBACK (show_hidden_toggled_cb), impl);
4220   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (impl->browse_files_popup_menu_hidden_files_item),
4221                                   impl->show_hidden);
4222   g_signal_handlers_unblock_by_func (impl->browse_files_popup_menu_hidden_files_item,
4223                                      G_CALLBACK (show_hidden_toggled_cb), impl);
4224
4225   /* 'Show Size Column' */
4226   g_signal_handlers_block_by_func (impl->browse_files_popup_menu_size_column_item,
4227                                    G_CALLBACK (show_size_column_toggled_cb), impl);
4228   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (impl->browse_files_popup_menu_size_column_item),
4229                                   impl->show_size_column);
4230   g_signal_handlers_unblock_by_func (impl->browse_files_popup_menu_size_column_item,
4231                                      G_CALLBACK (show_size_column_toggled_cb), impl);
4232 }
4233
4234 static void
4235 popup_position_func (GtkMenu   *menu,
4236                      gint      *x,
4237                      gint      *y,
4238                      gboolean  *push_in,
4239                      gpointer   user_data)
4240 {
4241   GtkAllocation allocation;
4242   GtkWidget *widget = GTK_WIDGET (user_data);
4243   GdkScreen *screen = gtk_widget_get_screen (widget);
4244   GtkRequisition req;
4245   gint monitor_num;
4246   GdkRectangle monitor;
4247
4248   g_return_if_fail (gtk_widget_get_realized (widget));
4249
4250   gdk_window_get_origin (gtk_widget_get_window (widget), x, y);
4251
4252   gtk_widget_get_preferred_size (GTK_WIDGET (menu),
4253                                  &req, NULL);
4254
4255   gtk_widget_get_allocation (widget, &allocation);
4256   *x += (allocation.width - req.width) / 2;
4257   *y += (allocation.height - req.height) / 2;
4258
4259   monitor_num = gdk_screen_get_monitor_at_point (screen, *x, *y);
4260   gtk_menu_set_monitor (menu, monitor_num);
4261   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
4262
4263   *x = CLAMP (*x, monitor.x, monitor.x + MAX (0, monitor.width - req.width));
4264   *y = CLAMP (*y, monitor.y, monitor.y + MAX (0, monitor.height - req.height));
4265
4266   *push_in = FALSE;
4267 }
4268
4269 static void
4270 file_list_popup_menu (GtkFileChooserDefault *impl,
4271                       GdkEventButton        *event)
4272 {
4273   file_list_update_popup_menu (impl);
4274   if (event)
4275     gtk_menu_popup (GTK_MENU (impl->browse_files_popup_menu),
4276                     NULL, NULL, NULL, NULL,
4277                     event->button, event->time);
4278   else
4279     {
4280       gtk_menu_popup (GTK_MENU (impl->browse_files_popup_menu),
4281                       NULL, NULL,
4282                       popup_position_func, impl->browse_files_tree_view,
4283                       0, GDK_CURRENT_TIME);
4284       gtk_menu_shell_select_first (GTK_MENU_SHELL (impl->browse_files_popup_menu),
4285                                    FALSE);
4286     }
4287
4288 }
4289
4290 /* Callback used for the GtkWidget::popup-menu signal of the file list */
4291 static gboolean
4292 list_popup_menu_cb (GtkWidget *widget,
4293                     GtkFileChooserDefault *impl)
4294 {
4295   file_list_popup_menu (impl, NULL);
4296   return TRUE;
4297 }
4298
4299 /* Callback used when a button is pressed on the file list.  We trap button 3 to
4300  * bring up a popup menu.
4301  */
4302 static gboolean
4303 list_button_press_event_cb (GtkWidget             *widget,
4304                             GdkEventButton        *event,
4305                             GtkFileChooserDefault *impl)
4306 {
4307   static gboolean in_press = FALSE;
4308
4309   if (in_press)
4310     return FALSE;
4311
4312   if (!gdk_event_triggers_context_menu ((GdkEvent *) event))
4313     return FALSE;
4314
4315   in_press = TRUE;
4316   gtk_widget_event (impl->browse_files_tree_view, (GdkEvent *) event);
4317   in_press = FALSE;
4318
4319   file_list_popup_menu (impl, event);
4320   return TRUE;
4321 }
4322
4323 typedef struct {
4324   OperationMode operation_mode;
4325   gint general_column;
4326   gint model_column;
4327 } ColumnMap;
4328
4329 /* Sets the sort column IDs for the file list; needs to be done whenever we
4330  * change the model on the treeview.
4331  */
4332 static void
4333 file_list_set_sort_column_ids (GtkFileChooserDefault *impl)
4334 {
4335   gtk_tree_view_column_set_sort_column_id (impl->list_name_column, MODEL_COL_NAME);
4336   gtk_tree_view_column_set_sort_column_id (impl->list_mtime_column, MODEL_COL_MTIME);
4337   gtk_tree_view_column_set_sort_column_id (impl->list_size_column, MODEL_COL_SIZE);
4338 }
4339
4340 static gboolean
4341 file_list_query_tooltip_cb (GtkWidget  *widget,
4342                             gint        x,
4343                             gint        y,
4344                             gboolean    keyboard_tip,
4345                             GtkTooltip *tooltip,
4346                             gpointer    user_data)
4347 {
4348   GtkFileChooserDefault *impl = user_data;
4349   GtkTreeModel *model;
4350   GtkTreePath *path;
4351   GtkTreeIter iter;
4352   GFile *file;
4353   gchar *filename;
4354
4355   if (impl->operation_mode == OPERATION_MODE_BROWSE)
4356     return FALSE;
4357
4358
4359   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (impl->browse_files_tree_view),
4360                                           &x, &y,
4361                                           keyboard_tip,
4362                                           &model, &path, &iter))
4363     return FALSE;
4364
4365   gtk_tree_model_get (model, &iter,
4366                       MODEL_COL_FILE, &file,
4367                       -1);
4368
4369   if (file == NULL)
4370     {
4371       gtk_tree_path_free (path);
4372       return FALSE;
4373     }
4374
4375   filename = g_file_get_path (file);
4376   gtk_tooltip_set_text (tooltip, filename);
4377   gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (impl->browse_files_tree_view),
4378                                  tooltip,
4379                                  path);
4380
4381   g_free (filename);
4382   g_object_unref (file);
4383   gtk_tree_path_free (path);
4384
4385   return TRUE;
4386 }
4387
4388 static void
4389 set_icon_cell_renderer_fixed_size (GtkFileChooserDefault *impl, GtkCellRenderer *renderer)
4390 {
4391   gint xpad, ypad;
4392
4393   gtk_cell_renderer_get_padding (renderer, &xpad, &ypad);
4394   gtk_cell_renderer_set_fixed_size (renderer,
4395                                     xpad * 2 + impl->icon_size,
4396                                     ypad * 2 + impl->icon_size);
4397 }
4398
4399 /* Creates the widgets for the file list */
4400 static GtkWidget *
4401 create_file_list (GtkFileChooserDefault *impl)
4402 {
4403   GtkWidget *swin;
4404   GtkTreeSelection *selection;
4405   GtkTreeViewColumn *column;
4406   GtkCellRenderer *renderer;
4407
4408   /* Scrolled window */
4409   swin = gtk_scrolled_window_new (NULL, NULL);
4410   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
4411                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
4412   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin),
4413                                        GTK_SHADOW_IN);
4414
4415   /* Tree/list view */
4416
4417   impl->browse_files_tree_view = gtk_tree_view_new ();
4418 #ifdef PROFILE_FILE_CHOOSER
4419   g_object_set_data (G_OBJECT (impl->browse_files_tree_view), "fmq-name", "file_list");
4420 #endif
4421   g_object_set_data (G_OBJECT (impl->browse_files_tree_view), I_("GtkFileChooserDefault"), impl);
4422   atk_object_set_name (gtk_widget_get_accessible (impl->browse_files_tree_view), _("Files"));
4423
4424   gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (impl->browse_files_tree_view), TRUE);
4425   gtk_container_add (GTK_CONTAINER (swin), impl->browse_files_tree_view);
4426
4427   gtk_drag_dest_set (impl->browse_files_tree_view,
4428                      GTK_DEST_DEFAULT_ALL,
4429                      NULL, 0,
4430                      GDK_ACTION_COPY | GDK_ACTION_MOVE);
4431   gtk_drag_dest_add_uri_targets (impl->browse_files_tree_view);
4432
4433   g_signal_connect (impl->browse_files_tree_view, "row-activated",
4434                     G_CALLBACK (list_row_activated), impl);
4435   g_signal_connect (impl->browse_files_tree_view, "key-press-event",
4436                     G_CALLBACK (browse_files_key_press_event_cb), impl);
4437   g_signal_connect (impl->browse_files_tree_view, "popup-menu",
4438                     G_CALLBACK (list_popup_menu_cb), impl);
4439   g_signal_connect (impl->browse_files_tree_view, "button-press-event",
4440                     G_CALLBACK (list_button_press_event_cb), impl);
4441
4442   g_signal_connect (impl->browse_files_tree_view, "drag-data-received",
4443                     G_CALLBACK (file_list_drag_data_received_cb), impl);
4444   g_signal_connect (impl->browse_files_tree_view, "drag-drop",
4445                     G_CALLBACK (file_list_drag_drop_cb), impl);
4446   g_signal_connect (impl->browse_files_tree_view, "drag-motion",
4447                     G_CALLBACK (file_list_drag_motion_cb), impl);
4448
4449   g_object_set (impl->browse_files_tree_view, "has-tooltip", TRUE, NULL);
4450   g_signal_connect (impl->browse_files_tree_view, "query-tooltip",
4451                     G_CALLBACK (file_list_query_tooltip_cb), impl);
4452
4453   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
4454   gtk_tree_selection_set_select_function (selection,
4455                                           list_select_func,
4456                                           impl, NULL);
4457   gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (impl->browse_files_tree_view),
4458                                           GDK_BUTTON1_MASK,
4459                                           NULL, 0,
4460                                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
4461   gtk_drag_source_add_uri_targets (impl->browse_files_tree_view);
4462
4463   g_signal_connect (selection, "changed",
4464                     G_CALLBACK (list_selection_changed), impl);
4465
4466   /* Keep the column order in sync with update_cell_renderer_attributes() */
4467
4468   /* Filename column */
4469
4470   impl->list_name_column = gtk_tree_view_column_new ();
4471   gtk_tree_view_column_set_expand (impl->list_name_column, TRUE);
4472   gtk_tree_view_column_set_resizable (impl->list_name_column, TRUE);
4473   gtk_tree_view_column_set_title (impl->list_name_column, _("Name"));
4474
4475   renderer = gtk_cell_renderer_pixbuf_new ();
4476   /* We set a fixed size so that we get an empty slot even if no icons are loaded yet */
4477   set_icon_cell_renderer_fixed_size (impl, renderer);
4478   gtk_tree_view_column_pack_start (impl->list_name_column, renderer, FALSE);
4479
4480   impl->list_name_renderer = gtk_cell_renderer_text_new ();
4481   g_object_set (impl->list_name_renderer,
4482                 "ellipsize", PANGO_ELLIPSIZE_END,
4483                 NULL);
4484   g_signal_connect (impl->list_name_renderer, "edited",
4485                     G_CALLBACK (renderer_edited_cb), impl);
4486   g_signal_connect (impl->list_name_renderer, "editing-canceled",
4487                     G_CALLBACK (renderer_editing_canceled_cb), impl);
4488   gtk_tree_view_column_pack_start (impl->list_name_column, impl->list_name_renderer, TRUE);
4489
4490   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->browse_files_tree_view), impl->list_name_column);
4491
4492   /* Size column */
4493
4494   column = gtk_tree_view_column_new ();
4495   gtk_tree_view_column_set_resizable (column, TRUE);
4496   gtk_tree_view_column_set_title (column, _("Size"));
4497
4498   renderer = gtk_cell_renderer_text_new ();
4499   g_object_set (renderer,
4500                 "alignment", PANGO_ALIGN_RIGHT,
4501                 NULL);
4502   gtk_tree_view_column_pack_start (column, renderer, TRUE); /* bug: it doesn't expand */
4503   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->browse_files_tree_view), column);
4504   impl->list_size_column = column;
4505
4506   /* Modification time column */
4507
4508   column = gtk_tree_view_column_new ();
4509   gtk_tree_view_column_set_resizable (column, TRUE);
4510   gtk_tree_view_column_set_title (column, _("Modified"));
4511
4512   renderer = gtk_cell_renderer_text_new ();
4513   gtk_tree_view_column_pack_start (column, renderer, TRUE);
4514   gtk_tree_view_append_column (GTK_TREE_VIEW (impl->browse_files_tree_view), column);
4515   impl->list_mtime_column = column;
4516
4517   file_list_set_sort_column_ids (impl);
4518   update_cell_renderer_attributes (impl);
4519
4520   gtk_widget_show_all (swin);
4521
4522   return swin;
4523 }
4524
4525 /* Creates the widgets for the files/folders pane */
4526 static GtkWidget *
4527 file_pane_create (GtkFileChooserDefault *impl,
4528                   GtkSizeGroup          *size_group)
4529 {
4530   GtkWidget *vbox;
4531   GtkWidget *hbox;
4532   GtkWidget *widget;
4533
4534   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
4535   gtk_widget_show (vbox);
4536
4537   /* Box for lists and preview */
4538
4539   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, PREVIEW_HBOX_SPACING);
4540   gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
4541   gtk_widget_show (hbox);
4542
4543   /* File list */
4544
4545   widget = create_file_list (impl);
4546   gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
4547   gtk_size_group_add_widget (size_group, widget);
4548
4549   /* Preview */
4550
4551   impl->preview_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
4552   gtk_box_pack_start (GTK_BOX (hbox), impl->preview_box, FALSE, FALSE, 0);
4553   /* Don't show preview box initially */
4554
4555   /* Filter combo */
4556
4557   impl->filter_combo_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
4558
4559   widget = filter_create (impl);
4560
4561   gtk_widget_show (widget);
4562   gtk_box_pack_end (GTK_BOX (impl->filter_combo_hbox), widget, FALSE, FALSE, 0);
4563
4564   gtk_box_pack_end (GTK_BOX (vbox), impl->filter_combo_hbox, FALSE, FALSE, 0);
4565
4566   return vbox;
4567 }
4568
4569 static void
4570 location_entry_create (GtkFileChooserDefault *impl)
4571 {
4572   if (!impl->location_entry)
4573     impl->location_entry = _gtk_file_chooser_entry_new (TRUE);
4574
4575   _gtk_file_chooser_entry_set_local_only (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), impl->local_only);
4576   _gtk_file_chooser_entry_set_action (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), impl->action);
4577   gtk_entry_set_width_chars (GTK_ENTRY (impl->location_entry), 45);
4578   gtk_entry_set_activates_default (GTK_ENTRY (impl->location_entry), TRUE);
4579 }
4580
4581 /* Creates the widgets specific to Save mode */
4582 static void
4583 save_widgets_create (GtkFileChooserDefault *impl)
4584 {
4585   GtkWidget *vbox;
4586   GtkWidget *widget;
4587
4588   if (impl->save_widgets != NULL)
4589     return;
4590
4591   location_switch_to_path_bar (impl);
4592
4593   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
4594
4595   impl->save_widgets_table = gtk_grid_new ();
4596   gtk_box_pack_start (GTK_BOX (vbox), impl->save_widgets_table, FALSE, FALSE, 0);
4597   gtk_widget_show (impl->save_widgets_table);
4598   gtk_grid_set_row_spacing (GTK_GRID (impl->save_widgets_table), 12);
4599   gtk_grid_set_column_spacing (GTK_GRID (impl->save_widgets_table), 12);
4600
4601   /* Label */
4602
4603   widget = gtk_label_new_with_mnemonic (_("_Name:"));
4604   gtk_widget_set_halign (widget, GTK_ALIGN_START);
4605   gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
4606   gtk_grid_attach (GTK_GRID (impl->save_widgets_table), widget, 0, 0, 1, 1);
4607   gtk_widget_show (widget);
4608
4609   /* Location entry */
4610
4611   location_entry_create (impl);
4612   gtk_widget_set_hexpand (impl->location_entry, TRUE);
4613   gtk_grid_attach (GTK_GRID (impl->save_widgets_table), impl->location_entry, 1, 0, 1, 1);
4614   gtk_widget_show (impl->location_entry);
4615   gtk_label_set_mnemonic_widget (GTK_LABEL (widget), impl->location_entry);
4616
4617   /* Folder combo */
4618   impl->save_folder_label = gtk_label_new (NULL);
4619   gtk_widget_set_halign (impl->save_folder_label, GTK_ALIGN_START);
4620   gtk_widget_set_valign (impl->save_folder_label, GTK_ALIGN_CENTER);
4621   gtk_grid_attach (GTK_GRID (impl->save_widgets_table), impl->save_folder_label, 0, 1, 1, 1);
4622   gtk_widget_show (impl->save_folder_label);
4623
4624   impl->save_widgets = vbox;
4625   gtk_box_pack_start (GTK_BOX (impl), impl->save_widgets, FALSE, FALSE, 0);
4626   gtk_box_reorder_child (GTK_BOX (impl), impl->save_widgets, 0);
4627   gtk_widget_show (impl->save_widgets);
4628 }
4629
4630 /* Destroys the widgets specific to Save mode */
4631 static void
4632 save_widgets_destroy (GtkFileChooserDefault *impl)
4633 {
4634   if (impl->save_widgets == NULL)
4635     return;
4636
4637   gtk_widget_destroy (impl->save_widgets);
4638   impl->save_widgets = NULL;
4639   impl->save_widgets_table = NULL;
4640   impl->location_entry = NULL;
4641   impl->save_folder_label = NULL;
4642 }
4643
4644 /* Turns on the path bar widget.  Can be called even if we are already in that
4645  * mode.
4646  */
4647 static void
4648 location_switch_to_path_bar (GtkFileChooserDefault *impl)
4649 {
4650   if (impl->location_entry)
4651     {
4652       gtk_widget_destroy (impl->location_entry);
4653       impl->location_entry = NULL;
4654     }
4655
4656   gtk_widget_hide (impl->location_entry_box);
4657 }
4658
4659 /* Turns on the location entry.  Can be called even if we are already in that
4660  * mode.
4661  */
4662 static void
4663 location_switch_to_filename_entry (GtkFileChooserDefault *impl)
4664 {
4665   /* when in search or recent files mode, we are not showing the
4666    * location_entry_box container, so there's no point in switching
4667    * to it.
4668    */
4669   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
4670       impl->operation_mode == OPERATION_MODE_RECENT)
4671     return;
4672
4673   /* Box */
4674
4675   gtk_widget_show (impl->location_entry_box);
4676
4677   /* Entry */
4678
4679   if (!impl->location_entry)
4680     {
4681       location_entry_create (impl);
4682       gtk_box_pack_start (GTK_BOX (impl->location_entry_box), impl->location_entry, TRUE, TRUE, 0);
4683       gtk_label_set_mnemonic_widget (GTK_LABEL (impl->location_label), impl->location_entry);
4684     }
4685
4686   /* Configure the entry */
4687
4688   _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), impl->current_folder);
4689
4690   /* Done */
4691
4692   gtk_widget_show (impl->location_entry);
4693   gtk_widget_grab_focus (impl->location_entry);
4694 }
4695
4696 /* Sets a new location mode.  set_buttons determines whether the toggle button
4697  * for the mode will also be changed.
4698  */
4699 static void
4700 location_mode_set (GtkFileChooserDefault *impl,
4701                    LocationMode new_mode,
4702                    gboolean set_button)
4703 {
4704   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
4705       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
4706     {
4707       GtkWindow *toplevel;
4708       GtkWidget *current_focus;
4709       gboolean button_active;
4710       gboolean switch_to_file_list;
4711
4712       switch (new_mode)
4713         {
4714         case LOCATION_MODE_PATH_BAR:
4715           button_active = FALSE;
4716
4717           /* The location_entry will disappear when we switch to path bar mode.  So,
4718            * we'll focus the file list in that case, to avoid having a window with
4719            * no focused widget.
4720            */
4721           toplevel = get_toplevel (GTK_WIDGET (impl));
4722           switch_to_file_list = FALSE;
4723           if (toplevel)
4724             {
4725               current_focus = gtk_window_get_focus (toplevel);
4726               if (!current_focus || current_focus == impl->location_entry)
4727                 switch_to_file_list = TRUE;
4728             }
4729
4730           location_switch_to_path_bar (impl);
4731
4732           if (switch_to_file_list)
4733             gtk_widget_grab_focus (impl->browse_files_tree_view);
4734
4735           break;
4736
4737         case LOCATION_MODE_FILENAME_ENTRY:
4738           button_active = TRUE;
4739           location_switch_to_filename_entry (impl);
4740           break;
4741
4742         default:
4743           g_assert_not_reached ();
4744           return;
4745         }
4746
4747       if (set_button)
4748         {
4749           g_signal_handlers_block_by_func (impl->location_button,
4750                                            G_CALLBACK (location_button_toggled_cb), impl);
4751
4752           gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (impl->location_button), button_active);
4753
4754           g_signal_handlers_unblock_by_func (impl->location_button,
4755                                              G_CALLBACK (location_button_toggled_cb), impl);
4756         }
4757     }
4758
4759   impl->location_mode = new_mode;
4760 }
4761
4762 static void
4763 location_toggle_popup_handler (GtkFileChooserDefault *impl)
4764 {
4765   /* when in search or recent files mode, we are not showing the
4766    * location_entry_box container, so there's no point in switching
4767    * to it.
4768    */
4769   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
4770       impl->operation_mode == OPERATION_MODE_RECENT)
4771     return;
4772
4773   /* If the file entry is not visible, show it.
4774    * If it is visible, turn it off only if it is focused.  Otherwise, switch to the entry.
4775    */
4776   if (impl->location_mode == LOCATION_MODE_PATH_BAR)
4777     {
4778       location_mode_set (impl, LOCATION_MODE_FILENAME_ENTRY, TRUE);
4779     }
4780   else if (impl->location_mode == LOCATION_MODE_FILENAME_ENTRY)
4781     {
4782       if (gtk_widget_has_focus (impl->location_entry))
4783         {
4784           location_mode_set (impl, LOCATION_MODE_PATH_BAR, TRUE);
4785         }
4786       else
4787         {
4788           gtk_widget_grab_focus (impl->location_entry);
4789         }
4790     }
4791 }
4792
4793 /* Callback used when one of the location mode buttons is toggled */
4794 static void
4795 location_button_toggled_cb (GtkToggleButton *toggle,
4796                             GtkFileChooserDefault *impl)
4797 {
4798   gboolean is_active;
4799   LocationMode new_mode;
4800
4801   is_active = gtk_toggle_button_get_active (toggle);
4802
4803   if (is_active)
4804     {
4805       g_assert (impl->location_mode == LOCATION_MODE_PATH_BAR);
4806       new_mode = LOCATION_MODE_FILENAME_ENTRY;
4807     }
4808   else
4809     {
4810       g_assert (impl->location_mode == LOCATION_MODE_FILENAME_ENTRY);
4811       new_mode = LOCATION_MODE_PATH_BAR;
4812     }
4813
4814   location_mode_set (impl, new_mode, FALSE);
4815 }
4816
4817 /* Creates a toggle button for the location entry. */
4818 static void
4819 location_button_create (GtkFileChooserDefault *impl)
4820 {
4821   GtkWidget *image;
4822   const char *str;
4823
4824   image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON);
4825   gtk_widget_show (image);
4826
4827   impl->location_button = g_object_new (GTK_TYPE_TOGGLE_BUTTON,
4828                                         "image", image,
4829                                         NULL);
4830
4831   g_signal_connect (impl->location_button, "toggled",
4832                     G_CALLBACK (location_button_toggled_cb), impl);
4833
4834   str = _("Type a file name");
4835
4836   gtk_widget_set_tooltip_text (impl->location_button, str);
4837   atk_object_set_name (gtk_widget_get_accessible (impl->location_button), str);
4838 }
4839
4840 typedef enum {
4841   PATH_BAR_FOLDER_PATH,
4842   PATH_BAR_SELECT_A_FOLDER,
4843   PATH_BAR_ERROR_NO_FILENAME,
4844   PATH_BAR_ERROR_NO_FOLDER,
4845   PATH_BAR_RECENTLY_USED,
4846   PATH_BAR_SEARCH
4847 } PathBarMode;
4848
4849 /* Creates the info bar for informational messages or warnings, with its icon and label */
4850 static void
4851 info_bar_create (GtkFileChooserDefault *impl)
4852 {
4853   GtkWidget *content_area;
4854
4855   impl->browse_select_a_folder_info_bar = gtk_info_bar_new ();
4856   impl->browse_select_a_folder_icon = gtk_image_new_from_stock (GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU);
4857   impl->browse_select_a_folder_label = gtk_label_new (NULL);
4858
4859   content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (impl->browse_select_a_folder_info_bar));
4860
4861   gtk_box_pack_start (GTK_BOX (content_area), impl->browse_select_a_folder_icon, FALSE, FALSE, 0);
4862   gtk_box_pack_start (GTK_BOX (content_area), impl->browse_select_a_folder_label, FALSE, FALSE, 0);
4863
4864   gtk_widget_show (impl->browse_select_a_folder_icon);
4865   gtk_widget_show (impl->browse_select_a_folder_label);
4866 }
4867
4868 /* Sets the info bar to show the appropriate informational or warning message */
4869 static void
4870 info_bar_set (GtkFileChooserDefault *impl, PathBarMode mode)
4871 {
4872   char *str;
4873   gboolean free_str;
4874   GtkMessageType message_type;
4875
4876   free_str = FALSE;
4877
4878   switch (mode)
4879     {
4880     case PATH_BAR_SELECT_A_FOLDER:
4881       str = g_strconcat ("<i>", _("Please select a folder below"), "</i>", NULL);
4882       free_str = TRUE;
4883       message_type = GTK_MESSAGE_OTHER;
4884       break;
4885
4886     case PATH_BAR_ERROR_NO_FILENAME:
4887       str = _("Please type a file name");
4888       message_type = GTK_MESSAGE_WARNING;
4889       break;
4890
4891     case PATH_BAR_ERROR_NO_FOLDER:
4892       str = _("Please select a folder below");
4893       message_type = GTK_MESSAGE_WARNING;
4894       break;
4895
4896     default:
4897       g_assert_not_reached ();
4898       return;
4899     }
4900
4901   gtk_info_bar_set_message_type (GTK_INFO_BAR (impl->browse_select_a_folder_info_bar), message_type);
4902   gtk_image_set_from_stock (GTK_IMAGE (impl->browse_select_a_folder_icon),
4903                             (message_type == GTK_MESSAGE_WARNING) ? GTK_STOCK_DIALOG_WARNING : GTK_STOCK_DIRECTORY,
4904                             GTK_ICON_SIZE_MENU);
4905   gtk_label_set_markup (GTK_LABEL (impl->browse_select_a_folder_label), str);
4906
4907   if (free_str)
4908     g_free (str);
4909 }
4910
4911 /* Creates the icon and label used to show that the file chooser is in Search or Recently-used mode */
4912 static void
4913 special_mode_widgets_create (GtkFileChooserDefault *impl)
4914 {
4915   impl->browse_special_mode_icon = gtk_image_new ();
4916   gtk_size_group_add_widget (impl->browse_path_bar_size_group, impl->browse_special_mode_icon);
4917   gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->browse_special_mode_icon, FALSE, FALSE, 0);
4918
4919   impl->browse_special_mode_label = gtk_label_new (NULL);
4920   gtk_size_group_add_widget (impl->browse_path_bar_size_group, impl->browse_special_mode_label);
4921   gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->browse_special_mode_label, FALSE, FALSE, 0);
4922 }
4923
4924 /* Creates the path bar's container and eveyrthing that goes in it: location button, pathbar, info bar, and Create Folder button */
4925 static void
4926 path_bar_widgets_create (GtkFileChooserDefault *impl)
4927 {
4928   /* Location widgets - note browse_path_bar_hbox is packed in the right place until switch_path_bar() */
4929   impl->browse_path_bar_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
4930   gtk_widget_show (impl->browse_path_bar_hbox);
4931
4932   /* Size group that allows the path bar to be the same size between modes */
4933   impl->browse_path_bar_size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4934   gtk_size_group_set_ignore_hidden (impl->browse_path_bar_size_group, FALSE);
4935
4936   /* Location button */
4937   location_button_create (impl);
4938   gtk_size_group_add_widget (impl->browse_path_bar_size_group, impl->location_button);
4939   gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->location_button, FALSE, FALSE, 0);
4940
4941   /* Path bar */
4942   impl->browse_path_bar = g_object_new (GTK_TYPE_PATH_BAR, NULL);
4943   _gtk_path_bar_set_file_system (GTK_PATH_BAR (impl->browse_path_bar), impl->file_system);
4944   g_signal_connect (impl->browse_path_bar, "path-clicked", G_CALLBACK (path_bar_clicked), impl);
4945
4946   gtk_size_group_add_widget (impl->browse_path_bar_size_group, impl->browse_path_bar);
4947   gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->browse_path_bar, TRUE, TRUE, 0);
4948
4949   /* Info bar */
4950   info_bar_create (impl);
4951   gtk_size_group_add_widget (impl->browse_path_bar_size_group, impl->browse_select_a_folder_info_bar);
4952   gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->browse_select_a_folder_info_bar, TRUE, TRUE, 0);
4953
4954   /* Widgets for special modes (recently-used in Open mode, Search mode) */
4955   special_mode_widgets_create (impl);
4956
4957   /* Create Folder */
4958   impl->browse_new_folder_button = gtk_button_new_with_mnemonic (_("Create Fo_lder"));
4959   g_signal_connect (impl->browse_new_folder_button, "clicked",
4960                     G_CALLBACK (new_folder_button_clicked), impl);
4961   gtk_size_group_add_widget (impl->browse_path_bar_size_group, impl->browse_new_folder_button);
4962   gtk_box_pack_end (GTK_BOX (impl->browse_path_bar_hbox), impl->browse_new_folder_button, FALSE, FALSE, 0);
4963 }
4964
4965 /* Sets the path bar's mode to show a label, the actual folder path, or a
4966  * warning message.  You may call this function with PATH_BAR_ERROR_* directly
4967  * if the pathbar is already showing the widgets you expect; otherwise, call
4968  * path_bar_update() instead to set the appropriate widgets automatically.
4969  */
4970 static void
4971 path_bar_set_mode (GtkFileChooserDefault *impl, PathBarMode mode)
4972 {
4973   gboolean path_bar_visible             = FALSE;
4974   gboolean special_mode_widgets_visible = FALSE;
4975   gboolean info_bar_visible             = FALSE;
4976   gboolean create_folder_visible        = FALSE;
4977
4978   char *tmp;
4979
4980   switch (mode)
4981     {
4982     case PATH_BAR_FOLDER_PATH:
4983       path_bar_visible = TRUE;
4984       break;
4985
4986     case PATH_BAR_SELECT_A_FOLDER:
4987     case PATH_BAR_ERROR_NO_FILENAME:
4988     case PATH_BAR_ERROR_NO_FOLDER:
4989       info_bar_set (impl, mode);
4990       info_bar_visible = TRUE;
4991       break;
4992
4993     case PATH_BAR_RECENTLY_USED:
4994       gtk_image_set_from_icon_name (GTK_IMAGE (impl->browse_special_mode_icon), "document-open-recent", GTK_ICON_SIZE_BUTTON);
4995
4996       tmp = g_strdup_printf ("<b>%s</b>", _("Recently Used"));
4997       gtk_label_set_markup (GTK_LABEL (impl->browse_special_mode_label), tmp);
4998       g_free (tmp);
4999
5000       special_mode_widgets_visible = TRUE;
5001       break;
5002
5003     case PATH_BAR_SEARCH:
5004       gtk_image_set_from_stock (GTK_IMAGE (impl->browse_special_mode_icon), GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON);
5005
5006       tmp = g_strdup_printf ("<b>%s</b>", _("Search:"));
5007       gtk_label_set_markup (GTK_LABEL (impl->browse_special_mode_label), tmp);
5008       g_free (tmp);
5009
5010       special_mode_widgets_visible = TRUE;
5011       break;
5012
5013     default:
5014       g_assert_not_reached ();
5015     }
5016
5017   gtk_widget_set_visible (impl->browse_path_bar,                        path_bar_visible);
5018   gtk_widget_set_visible (impl->browse_special_mode_icon,               special_mode_widgets_visible);
5019   gtk_widget_set_visible (impl->browse_special_mode_label,              special_mode_widgets_visible);
5020   gtk_widget_set_visible (impl->browse_select_a_folder_info_bar,        info_bar_visible);
5021
5022   if (path_bar_visible)
5023     {
5024       if (impl->create_folders
5025           && impl->action != GTK_FILE_CHOOSER_ACTION_OPEN
5026           && impl->operation_mode != OPERATION_MODE_RECENT)
5027         create_folder_visible = TRUE;
5028     }
5029
5030   gtk_widget_set_visible (impl->browse_new_folder_button,               create_folder_visible);
5031 }
5032
5033 /* Creates the main hpaned with the widgets shared by Open and Save mode */
5034 static void
5035 browse_widgets_create (GtkFileChooserDefault *impl)
5036 {
5037   GtkWidget *hpaned;
5038   GtkWidget *widget;
5039   GtkSizeGroup *size_group;
5040
5041   impl->browse_widgets_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
5042   gtk_box_pack_start (GTK_BOX (impl), impl->browse_widgets_box, TRUE, TRUE, 0);
5043   gtk_widget_show (impl->browse_widgets_box);
5044
5045   impl->browse_header_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
5046   gtk_box_pack_start (GTK_BOX (impl->browse_widgets_box), impl->browse_header_box, FALSE, FALSE, 0);
5047   gtk_widget_show (impl->browse_header_box);
5048
5049   /* Path bar, info bar, and their respective machinery - the browse_path_bar_hbox will get packed elsewhere */
5050   path_bar_widgets_create (impl);
5051
5052   /* Box for the location label and entry */
5053
5054   impl->location_entry_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
5055   gtk_box_pack_start (GTK_BOX (impl->browse_header_box), impl->location_entry_box, FALSE, FALSE, 0);
5056
5057   impl->location_label = gtk_label_new_with_mnemonic (_("_Location:"));
5058   gtk_widget_show (impl->location_label);
5059   gtk_box_pack_start (GTK_BOX (impl->location_entry_box), impl->location_label, FALSE, FALSE, 0);
5060
5061   /* size group is used by the scrolled windows of the panes */
5062   size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
5063
5064   /* Paned widget */
5065
5066   hpaned = impl->browse_widgets_hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
5067   gtk_widget_show (hpaned);
5068   gtk_box_pack_start (GTK_BOX (impl->browse_widgets_box), hpaned, TRUE, TRUE, 0);
5069
5070   widget = shortcuts_pane_create (impl, size_group);
5071   gtk_paned_pack1 (GTK_PANED (hpaned), widget, FALSE, FALSE);
5072   widget = file_pane_create (impl, size_group);
5073   gtk_paned_pack2 (GTK_PANED (hpaned), widget, TRUE, FALSE);
5074   g_object_unref (size_group);
5075 }
5076
5077 static GObject*
5078 gtk_file_chooser_default_constructor (GType                  type,
5079                                       guint                  n_construct_properties,
5080                                       GObjectConstructParam *construct_params)
5081 {
5082   GtkFileChooserDefault *impl;
5083   GObject *object;
5084
5085   profile_start ("start", NULL);
5086
5087   object = G_OBJECT_CLASS (_gtk_file_chooser_default_parent_class)->constructor (type,
5088                                                                                 n_construct_properties,
5089                                                                                 construct_params);
5090   impl = GTK_FILE_CHOOSER_DEFAULT (object);
5091
5092   g_assert (impl->file_system);
5093
5094   gtk_widget_push_composite_child ();
5095
5096   /* Shortcuts model */
5097   shortcuts_model_create (impl);
5098
5099   /* The browse widgets */
5100   browse_widgets_create (impl);
5101
5102   /* Alignment to hold extra widget */
5103   impl->extra_align = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5104   gtk_widget_set_halign (impl->extra_align, GTK_ALIGN_START);
5105   gtk_widget_set_valign (impl->extra_align, GTK_ALIGN_CENTER);
5106   gtk_box_pack_start (GTK_BOX (impl), impl->extra_align, FALSE, FALSE, 0);
5107
5108   gtk_widget_pop_composite_child ();
5109   update_appearance (impl);
5110
5111   profile_end ("end", NULL);
5112
5113   return object;
5114 }
5115
5116 /* Sets the extra_widget by packing it in the appropriate place */
5117 static void
5118 set_extra_widget (GtkFileChooserDefault *impl,
5119                   GtkWidget             *extra_widget)
5120 {
5121   if (extra_widget)
5122     {
5123       g_object_ref (extra_widget);
5124       /* FIXME: is this right ? */
5125       gtk_widget_show (extra_widget);
5126     }
5127
5128   if (impl->extra_widget)
5129     {
5130       gtk_container_remove (GTK_CONTAINER (impl->extra_align), impl->extra_widget);
5131       g_object_unref (impl->extra_widget);
5132     }
5133
5134   impl->extra_widget = extra_widget;
5135   if (impl->extra_widget)
5136     {
5137       gtk_container_add (GTK_CONTAINER (impl->extra_align), impl->extra_widget);
5138       gtk_widget_show (impl->extra_align);
5139     }
5140   else
5141     gtk_widget_hide (impl->extra_align);
5142 }
5143
5144 static void
5145 set_local_only (GtkFileChooserDefault *impl,
5146                 gboolean               local_only)
5147 {
5148   if (local_only != impl->local_only)
5149     {
5150       impl->local_only = local_only;
5151
5152       if (impl->location_entry)
5153         _gtk_file_chooser_entry_set_local_only (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), local_only);
5154
5155       if (impl->shortcuts_model && impl->file_system)
5156         {
5157           shortcuts_add_volumes (impl);
5158           shortcuts_add_bookmarks (impl);
5159         }
5160
5161       if (local_only && impl->current_folder &&
5162            !_gtk_file_has_native_path (impl->current_folder))
5163         {
5164           /* If we are pointing to a non-local folder, make an effort to change
5165            * back to a local folder, but it's really up to the app to not cause
5166            * such a situation, so we ignore errors.
5167            */
5168           const gchar *home = g_get_home_dir ();
5169           GFile *home_file;
5170
5171           if (home == NULL)
5172             return;
5173
5174           home_file = g_file_new_for_path (home);
5175
5176           gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (impl), home_file, NULL);
5177
5178           g_object_unref (home_file);
5179         }
5180     }
5181 }
5182
5183 static void
5184 volumes_bookmarks_changed_cb (GtkFileSystem         *file_system,
5185                               GtkFileChooserDefault *impl)
5186 {
5187   shortcuts_add_volumes (impl);
5188   shortcuts_add_bookmarks (impl);
5189
5190   bookmarks_check_add_sensitivity (impl);
5191   bookmarks_check_remove_sensitivity (impl);
5192   shortcuts_check_popup_sensitivity (impl);
5193 }
5194
5195 /* Sets the file chooser to multiple selection mode */
5196 static void
5197 set_select_multiple (GtkFileChooserDefault *impl,
5198                      gboolean               select_multiple,
5199                      gboolean               property_notify)
5200 {
5201   GtkTreeSelection *selection;
5202   GtkSelectionMode mode;
5203
5204   if (select_multiple == impl->select_multiple)
5205     return;
5206
5207   mode = select_multiple ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_SINGLE;
5208
5209   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
5210   gtk_tree_selection_set_mode (selection, mode);
5211
5212   gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (impl->browse_files_tree_view), select_multiple);
5213
5214   impl->select_multiple = select_multiple;
5215   g_object_notify (G_OBJECT (impl), "select-multiple");
5216
5217   check_preview_change (impl);
5218 }
5219
5220 static void
5221 set_file_system_backend (GtkFileChooserDefault *impl)
5222 {
5223   profile_start ("start for backend", "default");
5224
5225   impl->file_system = _gtk_file_system_new ();
5226
5227   g_signal_connect (impl->file_system, "volumes-changed",
5228                     G_CALLBACK (volumes_bookmarks_changed_cb), impl);
5229   g_signal_connect (impl->file_system, "bookmarks-changed",
5230                     G_CALLBACK (volumes_bookmarks_changed_cb), impl);
5231
5232   profile_end ("end", NULL);
5233 }
5234
5235 static void
5236 unset_file_system_backend (GtkFileChooserDefault *impl)
5237 {
5238   g_signal_handlers_disconnect_by_func (impl->file_system,
5239                                         G_CALLBACK (volumes_bookmarks_changed_cb), impl);
5240
5241   g_object_unref (impl->file_system);
5242
5243   impl->file_system = NULL;
5244 }
5245
5246 /* Saves the widgets around the pathbar so they can be reparented later
5247  * in the correct place.  This function must be called paired with
5248  * restore_path_bar().
5249  */
5250 static void
5251 save_path_bar (GtkFileChooserDefault *impl)
5252 {
5253   GtkWidget *parent;
5254
5255   g_object_ref (impl->browse_path_bar_hbox);
5256
5257   parent = gtk_widget_get_parent (impl->browse_path_bar_hbox);
5258   if (parent)
5259     gtk_container_remove (GTK_CONTAINER (parent), impl->browse_path_bar_hbox);
5260 }
5261
5262 /* Reparents the path bar and the "Create folder" button to the right place:
5263  * Above the file list in Open mode, or to the right of the "Save in folder:"
5264  * label in Save mode.  The save_path_bar() function must be called before this
5265  * one.
5266  */
5267 static void
5268 restore_path_bar (GtkFileChooserDefault *impl)
5269 {
5270   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
5271       || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
5272     {
5273       gtk_box_pack_start (GTK_BOX (impl->browse_header_box), impl->browse_path_bar_hbox, FALSE, FALSE, 0);
5274       gtk_box_reorder_child (GTK_BOX (impl->browse_header_box), impl->browse_path_bar_hbox, 0);
5275     }
5276   else if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
5277            || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
5278     {
5279       gtk_widget_set_hexpand (impl->browse_path_bar_hbox, TRUE);
5280       gtk_grid_attach (GTK_GRID (impl->save_widgets_table), impl->browse_path_bar_hbox, 1, 1, 1, 1);
5281       gtk_label_set_mnemonic_widget (GTK_LABEL (impl->save_folder_label), impl->browse_path_bar);
5282     }
5283   else
5284     g_assert_not_reached ();
5285
5286   g_object_unref (impl->browse_path_bar_hbox);
5287 }
5288
5289 /* Takes the folder stored in a row in the recent_model, and puts it in the pathbar */
5290 static void
5291 put_recent_folder_in_pathbar (GtkFileChooserDefault *impl, GtkTreeIter *iter)
5292 {
5293   GFile *file;
5294
5295   gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), iter,
5296                       MODEL_COL_FILE, &file,
5297                       -1);
5298   _gtk_path_bar_set_file (GTK_PATH_BAR (impl->browse_path_bar), file, FALSE);
5299   g_object_unref (file);
5300 }
5301
5302 /* Sets the pathbar in the appropriate mode according to the current operation mode and action.  This is the central function for
5303  * dealing with the pathbar's widgets; as long as impl->action and impl->operation_mode are set correctly, then calling this
5304  * function will update all the pathbar's widgets.
5305  */
5306 static void
5307 path_bar_update (GtkFileChooserDefault *impl)
5308 {
5309   PathBarMode mode;
5310
5311   switch (impl->operation_mode)
5312     {
5313     case OPERATION_MODE_BROWSE:
5314       mode = PATH_BAR_FOLDER_PATH;
5315       break;
5316
5317     case OPERATION_MODE_RECENT:
5318       if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
5319         {
5320           GtkTreeSelection *selection;
5321           gboolean have_selected;
5322           GtkTreeIter iter;
5323
5324           selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
5325
5326           /* Save mode means single-selection mode, so the following is valid */
5327           have_selected = gtk_tree_selection_get_selected (selection, NULL, &iter);
5328
5329           if (have_selected)
5330             {
5331               mode = PATH_BAR_FOLDER_PATH;
5332               put_recent_folder_in_pathbar (impl, &iter);
5333             }
5334           else
5335             mode = PATH_BAR_SELECT_A_FOLDER;
5336         }
5337       else
5338         mode = PATH_BAR_RECENTLY_USED;
5339
5340       break;
5341
5342     case OPERATION_MODE_SEARCH:
5343       mode = PATH_BAR_SEARCH;
5344       break;
5345
5346     default:
5347       g_assert_not_reached ();
5348       return;
5349     }
5350
5351   path_bar_set_mode (impl, mode);
5352 }
5353
5354 static void
5355 operation_mode_discard_search_widgets (GtkFileChooserDefault *impl)
5356 {
5357   if (impl->search_hbox)
5358     {
5359       gtk_widget_destroy (impl->search_hbox);
5360
5361       impl->search_hbox = NULL;
5362       impl->search_entry = NULL;
5363     }
5364 }
5365
5366 /* Stops running operations like populating the browse model, searches, and the recent-files model */
5367 static void
5368 operation_mode_stop (GtkFileChooserDefault *impl, OperationMode mode)
5369 {
5370   switch (mode)
5371     {
5372     case OPERATION_MODE_BROWSE:
5373       stop_loading_and_clear_list_model (impl, TRUE);
5374       break;
5375
5376     case OPERATION_MODE_SEARCH:
5377       search_stop_searching (impl, FALSE);
5378       search_clear_model (impl, TRUE);
5379
5380       operation_mode_discard_search_widgets (impl);
5381       break;
5382
5383     case OPERATION_MODE_RECENT:
5384       recent_stop_loading (impl);
5385       recent_clear_model (impl, TRUE);
5386       break;
5387
5388     default:
5389       g_assert_not_reached ();
5390     }
5391 }
5392
5393 static void
5394 operation_mode_set_browse (GtkFileChooserDefault *impl)
5395 {
5396   path_bar_update (impl);
5397
5398   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
5399       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
5400     {
5401       gtk_widget_show (impl->location_button);
5402       location_mode_set (impl, impl->location_mode, TRUE);
5403
5404       if (impl->location_mode == LOCATION_MODE_FILENAME_ENTRY)
5405         gtk_widget_show (impl->location_entry_box);
5406     }
5407 }
5408
5409 static void
5410 operation_mode_set_search (GtkFileChooserDefault *impl)
5411 {
5412   g_assert (impl->search_hbox == NULL);
5413   g_assert (impl->search_entry == NULL);
5414   g_assert (impl->search_model == NULL);
5415
5416   search_setup_widgets (impl);
5417 }
5418
5419 static void
5420 operation_mode_set_recent (GtkFileChooserDefault *impl)
5421 {
5422   path_bar_update (impl);
5423
5424   /* Hide the location widgets temporarily */
5425   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
5426       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
5427     {
5428       gtk_widget_hide (impl->location_button);
5429       gtk_widget_hide (impl->location_entry_box);
5430     }
5431
5432   recent_start_loading (impl);
5433 }
5434
5435 /* Sometimes we need to frob the selection in the shortcuts list manually */
5436 static void
5437 shortcuts_select_item_without_activating (GtkFileChooserDefault *impl, int pos)
5438 {
5439   GtkTreeSelection *selection;
5440   GtkTreePath *path;
5441
5442   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view));
5443
5444   g_signal_handlers_block_by_func (selection, G_CALLBACK (shortcuts_selection_changed_cb), impl);
5445
5446   path = gtk_tree_path_new_from_indices (pos, -1);
5447   gtk_tree_selection_select_path (selection, path);
5448   gtk_tree_path_free (path);
5449
5450   g_signal_handlers_unblock_by_func (selection, G_CALLBACK (shortcuts_selection_changed_cb), impl);
5451 }
5452
5453 static void
5454 operation_mode_set (GtkFileChooserDefault *impl, OperationMode mode)
5455 {
5456   ShortcutsIndex shortcut_to_select;
5457
5458   operation_mode_stop (impl, impl->operation_mode);
5459
5460   impl->operation_mode = mode;
5461
5462   switch (impl->operation_mode)
5463     {
5464     case OPERATION_MODE_BROWSE:
5465       operation_mode_set_browse (impl);
5466       shortcut_to_select = SHORTCUTS_CURRENT_FOLDER;
5467       break;
5468
5469     case OPERATION_MODE_SEARCH:
5470       operation_mode_set_search (impl);
5471       shortcut_to_select = SHORTCUTS_SEARCH;
5472       break;
5473
5474     case OPERATION_MODE_RECENT:
5475       operation_mode_set_recent (impl);
5476       shortcut_to_select = SHORTCUTS_RECENT;
5477       break;
5478
5479     default:
5480       g_assert_not_reached ();
5481       return;
5482     }
5483
5484   if (shortcut_to_select != SHORTCUTS_CURRENT_FOLDER)
5485     shortcuts_select_item_without_activating (impl, shortcuts_get_index (impl, shortcut_to_select));
5486 }
5487
5488 /* This function is basically a do_all function.
5489  *
5490  * It sets the visibility on all the widgets based on the current state, and
5491  * moves the custom_widget if needed.
5492  */
5493 static void
5494 update_appearance (GtkFileChooserDefault *impl)
5495 {
5496   save_path_bar (impl);
5497
5498   if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
5499       impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
5500     {
5501       const char *text;
5502
5503       gtk_widget_hide (impl->location_button);
5504       save_widgets_create (impl);
5505
5506       if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
5507         text = _("Save in _folder:");
5508       else
5509         text = _("Create in _folder:");
5510
5511       gtk_label_set_text_with_mnemonic (GTK_LABEL (impl->save_folder_label), text);
5512
5513       if (impl->select_multiple)
5514         {
5515           g_warning ("Save mode cannot be set in conjunction with multiple selection mode.  "
5516                      "Re-setting to single selection mode.");
5517           set_select_multiple (impl, FALSE, TRUE);
5518         }
5519     }
5520   else if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
5521            impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
5522     {
5523       gtk_widget_show (impl->location_button);
5524       save_widgets_destroy (impl);
5525       location_mode_set (impl, impl->location_mode, TRUE);
5526     }
5527
5528   if (impl->location_entry)
5529     _gtk_file_chooser_entry_set_action (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), impl->action);
5530
5531   restore_path_bar (impl);
5532   path_bar_update (impl);
5533
5534   /* This *is* needed; we need to redraw the file list because the "sensitivity"
5535    * of files may change depending whether we are in a file or folder-only mode.
5536    */
5537   gtk_widget_queue_draw (impl->browse_files_tree_view);
5538
5539   emit_default_size_changed (impl);
5540 }
5541
5542 static void
5543 gtk_file_chooser_default_set_property (GObject      *object,
5544                                        guint         prop_id,
5545                                        const GValue *value,
5546                                        GParamSpec   *pspec)
5547
5548 {
5549   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (object);
5550
5551   switch (prop_id)
5552     {
5553     case GTK_FILE_CHOOSER_PROP_ACTION:
5554       {
5555         GtkFileChooserAction action = g_value_get_enum (value);
5556
5557         if (action != impl->action)
5558           {
5559             gtk_file_chooser_default_unselect_all (GTK_FILE_CHOOSER (impl));
5560
5561             if ((action == GTK_FILE_CHOOSER_ACTION_SAVE ||
5562                  action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
5563                 && impl->select_multiple)
5564               {
5565                 g_warning ("Tried to change the file chooser action to SAVE or CREATE_FOLDER, but "
5566                            "this is not allowed in multiple selection mode.  Resetting the file chooser "
5567                            "to single selection mode.");
5568                 set_select_multiple (impl, FALSE, TRUE);
5569               }
5570             impl->action = action;
5571             update_cell_renderer_attributes (impl);
5572             update_appearance (impl);
5573             settings_load (impl);
5574           }
5575       }
5576       break;
5577
5578     case GTK_FILE_CHOOSER_PROP_FILTER:
5579       set_current_filter (impl, g_value_get_object (value));
5580       break;
5581
5582     case GTK_FILE_CHOOSER_PROP_LOCAL_ONLY:
5583       set_local_only (impl, g_value_get_boolean (value));
5584       break;
5585
5586     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET:
5587       set_preview_widget (impl, g_value_get_object (value));
5588       break;
5589
5590     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE:
5591       impl->preview_widget_active = g_value_get_boolean (value);
5592       update_preview_widget_visibility (impl);
5593       break;
5594
5595     case GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL:
5596       impl->use_preview_label = g_value_get_boolean (value);
5597       update_preview_widget_visibility (impl);
5598       break;
5599
5600     case GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET:
5601       set_extra_widget (impl, g_value_get_object (value));
5602       break;
5603
5604     case GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE:
5605       {
5606         gboolean select_multiple = g_value_get_boolean (value);
5607         if ((impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
5608              impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
5609             && select_multiple)
5610           {
5611             g_warning ("Tried to set the file chooser to multiple selection mode, but this is "
5612                        "not allowed in SAVE or CREATE_FOLDER modes.  Ignoring the change and "
5613                        "leaving the file chooser in single selection mode.");
5614             return;
5615           }
5616
5617         set_select_multiple (impl, select_multiple, FALSE);
5618       }
5619       break;
5620
5621     case GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN:
5622       {
5623         gboolean show_hidden = g_value_get_boolean (value);
5624         if (show_hidden != impl->show_hidden)
5625           {
5626             impl->show_hidden = show_hidden;
5627
5628             if (impl->browse_files_model)
5629               _gtk_file_system_model_set_show_hidden (impl->browse_files_model, show_hidden);
5630           }
5631       }
5632       break;
5633
5634     case GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION:
5635       {
5636         gboolean do_overwrite_confirmation = g_value_get_boolean (value);
5637         impl->do_overwrite_confirmation = do_overwrite_confirmation;
5638       }
5639       break;
5640
5641     case GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS:
5642       {
5643         gboolean create_folders = g_value_get_boolean (value);
5644         impl->create_folders = create_folders;
5645         update_appearance (impl);
5646       }
5647       break;
5648
5649     default:
5650       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
5651       break;
5652     }
5653 }
5654
5655 static void
5656 gtk_file_chooser_default_get_property (GObject    *object,
5657                                        guint       prop_id,
5658                                        GValue     *value,
5659                                        GParamSpec *pspec)
5660 {
5661   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (object);
5662
5663   switch (prop_id)
5664     {
5665     case GTK_FILE_CHOOSER_PROP_ACTION:
5666       g_value_set_enum (value, impl->action);
5667       break;
5668
5669     case GTK_FILE_CHOOSER_PROP_FILTER:
5670       g_value_set_object (value, impl->current_filter);
5671       break;
5672
5673     case GTK_FILE_CHOOSER_PROP_LOCAL_ONLY:
5674       g_value_set_boolean (value, impl->local_only);
5675       break;
5676
5677     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET:
5678       g_value_set_object (value, impl->preview_widget);
5679       break;
5680
5681     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE:
5682       g_value_set_boolean (value, impl->preview_widget_active);
5683       break;
5684
5685     case GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL:
5686       g_value_set_boolean (value, impl->use_preview_label);
5687       break;
5688
5689     case GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET:
5690       g_value_set_object (value, impl->extra_widget);
5691       break;
5692
5693     case GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE:
5694       g_value_set_boolean (value, impl->select_multiple);
5695       break;
5696
5697     case GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN:
5698       g_value_set_boolean (value, impl->show_hidden);
5699       break;
5700
5701     case GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION:
5702       g_value_set_boolean (value, impl->do_overwrite_confirmation);
5703       break;
5704
5705     case GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS:
5706       g_value_set_boolean (value, impl->create_folders);
5707       break;
5708
5709     default:
5710       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
5711       break;
5712     }
5713 }
5714
5715 /* This cancels everything that may be going on in the background. */
5716 static void
5717 cancel_all_operations (GtkFileChooserDefault *impl)
5718 {
5719   GSList *l;
5720
5721   pending_select_files_free (impl);
5722
5723   if (impl->reload_icon_cancellables)
5724     {
5725       for (l = impl->reload_icon_cancellables; l; l = l->next)
5726         {
5727           GCancellable *cancellable = G_CANCELLABLE (l->data);
5728           g_cancellable_cancel (cancellable);
5729         }
5730       g_slist_free (impl->reload_icon_cancellables);
5731       impl->reload_icon_cancellables = NULL;
5732     }
5733
5734   if (impl->loading_shortcuts)
5735     {
5736       for (l = impl->loading_shortcuts; l; l = l->next)
5737         {
5738           GCancellable *cancellable = G_CANCELLABLE (l->data);
5739           g_cancellable_cancel (cancellable);
5740         }
5741       g_slist_free (impl->loading_shortcuts);
5742       impl->loading_shortcuts = NULL;
5743     }
5744
5745   if (impl->file_list_drag_data_received_cancellable)
5746     {
5747       g_cancellable_cancel (impl->file_list_drag_data_received_cancellable);
5748       impl->file_list_drag_data_received_cancellable = NULL;
5749     }
5750
5751   if (impl->update_current_folder_cancellable)
5752     {
5753       g_cancellable_cancel (impl->update_current_folder_cancellable);
5754       impl->update_current_folder_cancellable = NULL;
5755     }
5756
5757   if (impl->should_respond_get_info_cancellable)
5758     {
5759       g_cancellable_cancel (impl->should_respond_get_info_cancellable);
5760       impl->should_respond_get_info_cancellable = NULL;
5761     }
5762
5763   if (impl->file_exists_get_info_cancellable)
5764     {
5765       g_cancellable_cancel (impl->file_exists_get_info_cancellable);
5766       impl->file_exists_get_info_cancellable = NULL;
5767     }
5768
5769   if (impl->update_from_entry_cancellable)
5770     {
5771       g_cancellable_cancel (impl->update_from_entry_cancellable);
5772       impl->update_from_entry_cancellable = NULL;
5773     }
5774
5775   if (impl->shortcuts_activate_iter_cancellable)
5776     {
5777       g_cancellable_cancel (impl->shortcuts_activate_iter_cancellable);
5778       impl->shortcuts_activate_iter_cancellable = NULL;
5779     }
5780
5781   search_stop_searching (impl, TRUE);
5782   recent_stop_loading (impl);
5783 }
5784
5785 /* Removes the settings signal handler.  It's safe to call multiple times */
5786 static void
5787 remove_settings_signal (GtkFileChooserDefault *impl,
5788                         GdkScreen             *screen)
5789 {
5790   if (impl->settings_signal_id)
5791     {
5792       GtkSettings *settings;
5793
5794       settings = gtk_settings_get_for_screen (screen);
5795       g_signal_handler_disconnect (settings,
5796                                    impl->settings_signal_id);
5797       impl->settings_signal_id = 0;
5798     }
5799 }
5800
5801 static void
5802 gtk_file_chooser_default_dispose (GObject *object)
5803 {
5804   GtkFileChooserDefault *impl = (GtkFileChooserDefault *) object;
5805
5806   cancel_all_operations (impl);
5807
5808   if (impl->extra_widget)
5809     {
5810       g_object_unref (impl->extra_widget);
5811       impl->extra_widget = NULL;
5812     }
5813
5814   remove_settings_signal (impl, gtk_widget_get_screen (GTK_WIDGET (impl)));
5815
5816   G_OBJECT_CLASS (_gtk_file_chooser_default_parent_class)->dispose (object);
5817 }
5818
5819 /* We override show-all since we have internal widgets that
5820  * shouldn't be shown when you call show_all(), like the filter
5821  * combo box.
5822  */
5823 static void
5824 gtk_file_chooser_default_show_all (GtkWidget *widget)
5825 {
5826   GtkFileChooserDefault *impl = (GtkFileChooserDefault *) widget;
5827
5828   gtk_widget_show (widget);
5829
5830   if (impl->extra_widget)
5831     gtk_widget_show_all (impl->extra_widget);
5832 }
5833
5834 /* Handler for GtkWindow::set-focus; this is where we save the last-focused
5835  * widget on our toplevel.  See gtk_file_chooser_default_hierarchy_changed()
5836  */
5837 static void
5838 toplevel_set_focus_cb (GtkWindow             *window,
5839                        GtkWidget             *focus,
5840                        GtkFileChooserDefault *impl)
5841 {
5842   impl->toplevel_last_focus_widget = gtk_window_get_focus (window);
5843 }
5844
5845 /* We monitor the focus widget on our toplevel to be able to know which widget
5846  * was last focused at the time our "should_respond" method gets called.
5847  */
5848 static void
5849 gtk_file_chooser_default_hierarchy_changed (GtkWidget *widget,
5850                                             GtkWidget *previous_toplevel)
5851 {
5852   GtkFileChooserDefault *impl;
5853   GtkWidget *toplevel;
5854
5855   impl = GTK_FILE_CHOOSER_DEFAULT (widget);
5856   toplevel = gtk_widget_get_toplevel (widget);
5857
5858   if (previous_toplevel &&
5859       impl->toplevel_set_focus_id != 0)
5860     {
5861       g_signal_handler_disconnect (previous_toplevel,
5862                                    impl->toplevel_set_focus_id);
5863       impl->toplevel_set_focus_id = 0;
5864       impl->toplevel_last_focus_widget = NULL;
5865     }
5866
5867   if (gtk_widget_is_toplevel (toplevel))
5868     {
5869       g_assert (impl->toplevel_set_focus_id == 0);
5870       impl->toplevel_set_focus_id = g_signal_connect (toplevel, "set-focus",
5871                                                       G_CALLBACK (toplevel_set_focus_cb), impl);
5872       impl->toplevel_last_focus_widget = gtk_window_get_focus (GTK_WINDOW (toplevel));
5873     }
5874 }
5875
5876 /* Changes the icons wherever it is needed */
5877 static void
5878 change_icon_theme (GtkFileChooserDefault *impl)
5879 {
5880   GtkSettings *settings;
5881   gint width, height;
5882   GtkCellRenderer *renderer;
5883   GList *cells;
5884
5885   profile_start ("start", NULL);
5886
5887   settings = gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (impl)));
5888
5889   if (gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU, &width, &height))
5890     impl->icon_size = MAX (width, height);
5891   else
5892     impl->icon_size = FALLBACK_ICON_SIZE;
5893
5894   shortcuts_reload_icons (impl);
5895   /* the first cell in the first column is the icon column, and we have a fixed size there */
5896   cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (
5897         gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 0)));
5898   renderer = GTK_CELL_RENDERER (cells->data);
5899   set_icon_cell_renderer_fixed_size (impl, renderer);
5900   g_list_free (cells);
5901   if (impl->browse_files_model)
5902     _gtk_file_system_model_clear_cache (impl->browse_files_model, MODEL_COL_PIXBUF);
5903   gtk_widget_queue_resize (impl->browse_files_tree_view);
5904
5905   profile_end ("end", NULL);
5906 }
5907
5908 /* Callback used when a GtkSettings value changes */
5909 static void
5910 settings_notify_cb (GObject               *object,
5911                     GParamSpec            *pspec,
5912                     GtkFileChooserDefault *impl)
5913 {
5914   const char *name;
5915
5916   profile_start ("start", NULL);
5917
5918   name = g_param_spec_get_name (pspec);
5919
5920   if (strcmp (name, "gtk-icon-theme-name") == 0 ||
5921       strcmp (name, "gtk-icon-sizes") == 0)
5922     change_icon_theme (impl);
5923
5924   profile_end ("end", NULL);
5925 }
5926
5927 /* Installs a signal handler for GtkSettings so that we can monitor changes in
5928  * the icon theme.
5929  */
5930 static void
5931 check_icon_theme (GtkFileChooserDefault *impl)
5932 {
5933   GtkSettings *settings;
5934
5935   profile_start ("start", NULL);
5936
5937   if (impl->settings_signal_id)
5938     {
5939       profile_end ("end", NULL);
5940       return;
5941     }
5942
5943   if (gtk_widget_has_screen (GTK_WIDGET (impl)))
5944     {
5945       settings = gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (impl)));
5946       impl->settings_signal_id = g_signal_connect (settings, "notify",
5947                                                    G_CALLBACK (settings_notify_cb), impl);
5948
5949       change_icon_theme (impl);
5950     }
5951
5952   profile_end ("end", NULL);
5953 }
5954
5955 static void
5956 gtk_file_chooser_default_style_updated (GtkWidget *widget)
5957 {
5958   GtkFileChooserDefault *impl;
5959
5960   profile_start ("start", NULL);
5961
5962   impl = GTK_FILE_CHOOSER_DEFAULT (widget);
5963
5964   profile_msg ("    parent class style_udpated start", NULL);
5965   GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->style_updated (widget);
5966   profile_msg ("    parent class style_updated end", NULL);
5967
5968   if (gtk_widget_has_screen (GTK_WIDGET (impl)))
5969     change_icon_theme (impl);
5970
5971   emit_default_size_changed (impl);
5972
5973   profile_end ("end", NULL);
5974 }
5975
5976 static void
5977 gtk_file_chooser_default_screen_changed (GtkWidget *widget,
5978                                          GdkScreen *previous_screen)
5979 {
5980   GtkFileChooserDefault *impl;
5981
5982   profile_start ("start", NULL);
5983
5984   impl = GTK_FILE_CHOOSER_DEFAULT (widget);
5985
5986   if (GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->screen_changed)
5987     GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->screen_changed (widget, previous_screen);
5988
5989   remove_settings_signal (impl, previous_screen);
5990   check_icon_theme (impl);
5991
5992   emit_default_size_changed (impl);
5993
5994   profile_end ("end", NULL);
5995 }
5996
5997 static void
5998 set_sort_column (GtkFileChooserDefault *impl)
5999 {
6000   GtkTreeSortable *sortable;
6001
6002   sortable = GTK_TREE_SORTABLE (gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view)));
6003
6004   /* can happen when we're still populating the model */
6005   if (sortable == NULL)
6006     return;
6007
6008   gtk_tree_sortable_set_sort_column_id (sortable,
6009                                         impl->sort_column,
6010                                         impl->sort_order);
6011 }
6012
6013 static void
6014 settings_load (GtkFileChooserDefault *impl)
6015 {
6016   LocationMode location_mode;
6017   gboolean show_hidden;
6018   gboolean show_size_column;
6019   gint sort_column;
6020   GtkSortType sort_order;
6021   gint sidebar_width;
6022   GSettings *settings;
6023
6024   settings = _gtk_file_chooser_get_settings_for_widget (GTK_WIDGET (impl));
6025
6026   location_mode = g_settings_get_enum (settings, SETTINGS_KEY_LOCATION_MODE);
6027   show_hidden = g_settings_get_boolean (settings, SETTINGS_KEY_SHOW_HIDDEN);
6028   show_size_column = g_settings_get_boolean (settings, SETTINGS_KEY_SHOW_SIZE_COLUMN);
6029   sort_column = g_settings_get_enum (settings, SETTINGS_KEY_SORT_COLUMN);
6030   sort_order = g_settings_get_enum (settings, SETTINGS_KEY_SORT_ORDER);
6031   sidebar_width = g_settings_get_int (settings, SETTINGS_KEY_SIDEBAR_WIDTH);
6032
6033   location_mode_set (impl, location_mode, TRUE);
6034
6035   gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (impl), show_hidden);
6036
6037   impl->show_size_column = show_size_column;
6038   gtk_tree_view_column_set_visible (impl->list_size_column, show_size_column);
6039
6040   impl->sort_column = sort_column;
6041   impl->sort_order = sort_order;
6042   /* We don't call set_sort_column() here as the models may not have been
6043    * created yet.  The individual functions that create and set the models will
6044    * call set_sort_column() themselves.
6045    */
6046
6047   gtk_paned_set_position (GTK_PANED (impl->browse_widgets_hpaned), sidebar_width);
6048 }
6049
6050 static void
6051 settings_save (GtkFileChooserDefault *impl)
6052 {
6053   GSettings *settings;
6054
6055   settings = _gtk_file_chooser_get_settings_for_widget (GTK_WIDGET (impl));
6056
6057   /* All the other state */
6058
6059   g_settings_set_enum (settings, SETTINGS_KEY_LOCATION_MODE, impl->location_mode);
6060   g_settings_set_boolean (settings, SETTINGS_KEY_SHOW_HIDDEN,
6061                           gtk_file_chooser_get_show_hidden (GTK_FILE_CHOOSER (impl)));
6062   g_settings_set_boolean (settings, SETTINGS_KEY_SHOW_SIZE_COLUMN, impl->show_size_column);
6063   g_settings_set_enum (settings, SETTINGS_KEY_SORT_COLUMN, impl->sort_column);
6064   g_settings_set_enum (settings, SETTINGS_KEY_SORT_ORDER, impl->sort_order);
6065   g_settings_set_int (settings, SETTINGS_KEY_SIDEBAR_WIDTH,
6066                      gtk_paned_get_position (GTK_PANED (impl->browse_widgets_hpaned)));
6067
6068   /* Now apply the settings */
6069   g_settings_apply (settings);
6070 }
6071
6072 /* GtkWidget::realize method */
6073 static void
6074 gtk_file_chooser_default_realize (GtkWidget *widget)
6075 {
6076   GtkFileChooserDefault *impl;
6077
6078   impl = GTK_FILE_CHOOSER_DEFAULT (widget);
6079
6080   GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->realize (widget);
6081
6082   emit_default_size_changed (impl);
6083 }
6084
6085 /* GtkWidget::map method */
6086 static void
6087 gtk_file_chooser_default_map (GtkWidget *widget)
6088 {
6089   GtkFileChooserDefault *impl;
6090
6091   profile_start ("start", NULL);
6092
6093   impl = GTK_FILE_CHOOSER_DEFAULT (widget);
6094
6095   GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->map (widget);
6096
6097   if (impl->operation_mode == OPERATION_MODE_BROWSE)
6098     {
6099       switch (impl->reload_state)
6100         {
6101         case RELOAD_EMPTY:
6102           recent_shortcut_handler (impl);
6103           break;
6104
6105         case RELOAD_HAS_FOLDER:
6106           /* Nothing; we are already loading or loaded, so we
6107            * don't need to reload
6108            */
6109           break;
6110
6111         default:
6112           g_assert_not_reached ();
6113       }
6114     }
6115
6116   volumes_bookmarks_changed_cb (impl->file_system, impl);
6117
6118   settings_load (impl);
6119
6120   profile_end ("end", NULL);
6121 }
6122
6123 /* GtkWidget::unmap method */
6124 static void
6125 gtk_file_chooser_default_unmap (GtkWidget *widget)
6126 {
6127   GtkFileChooserDefault *impl;
6128
6129   impl = GTK_FILE_CHOOSER_DEFAULT (widget);
6130
6131   settings_save (impl);
6132
6133   cancel_all_operations (impl);
6134   impl->reload_state = RELOAD_EMPTY;
6135
6136   GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->unmap (widget);
6137 }
6138
6139 #define COMPARE_DIRECTORIES                                                                                    \
6140   GtkFileChooserDefault *impl = user_data;                                                                     \
6141   GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model);                                                \
6142   gboolean dir_a, dir_b;                                                                                       \
6143                                                                                                                \
6144   dir_a = g_value_get_boolean (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_IS_FOLDER));           \
6145   dir_b = g_value_get_boolean (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_IS_FOLDER));           \
6146                                                                                                                \
6147   if (dir_a != dir_b)                                                                                          \
6148     return impl->list_sort_ascending ? (dir_a ? -1 : 1) : (dir_a ? 1 : -1) /* Directories *always* go first */
6149
6150 /* Sort callback for the filename column */
6151 static gint
6152 name_sort_func (GtkTreeModel *model,
6153                 GtkTreeIter  *a,
6154                 GtkTreeIter  *b,
6155                 gpointer      user_data)
6156 {
6157   COMPARE_DIRECTORIES;
6158   else
6159     {
6160       const char *key_a, *key_b;
6161       gint result;
6162
6163       key_a = g_value_get_string (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_NAME_COLLATED));
6164       key_b = g_value_get_string (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_NAME_COLLATED));
6165
6166       if (key_a && key_b)
6167         result = strcmp (key_a, key_b);
6168       else if (key_a)
6169         result = 1;
6170       else if (key_b)
6171         result = -1;
6172       else
6173         result = 0;
6174
6175       return result;
6176     }
6177 }
6178
6179 /* Sort callback for the size column */
6180 static gint
6181 size_sort_func (GtkTreeModel *model,
6182                 GtkTreeIter  *a,
6183                 GtkTreeIter  *b,
6184                 gpointer      user_data)
6185 {
6186   COMPARE_DIRECTORIES;
6187   else
6188     {
6189       gint64 size_a, size_b;
6190
6191       size_a = g_value_get_int64 (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_SIZE));
6192       size_b = g_value_get_int64 (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_SIZE));
6193
6194       return size_a < size_b ? -1 : (size_a == size_b ? 0 : 1);
6195     }
6196 }
6197
6198 /* Sort callback for the mtime column */
6199 static gint
6200 mtime_sort_func (GtkTreeModel *model,
6201                  GtkTreeIter  *a,
6202                  GtkTreeIter  *b,
6203                  gpointer      user_data)
6204 {
6205   COMPARE_DIRECTORIES;
6206   else
6207     {
6208       glong ta, tb;
6209
6210       ta = g_value_get_long (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_MTIME));
6211       tb = g_value_get_long (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_MTIME));
6212
6213       return ta < tb ? -1 : (ta == tb ? 0 : 1);
6214     }
6215 }
6216
6217 /* Callback used when the sort column changes.  We cache the sort order for use
6218  * in name_sort_func().
6219  */
6220 static void
6221 list_sort_column_changed_cb (GtkTreeSortable       *sortable,
6222                              GtkFileChooserDefault *impl)
6223 {
6224   gint sort_column_id;
6225   GtkSortType sort_type;
6226
6227   if (gtk_tree_sortable_get_sort_column_id (sortable, &sort_column_id, &sort_type))
6228     {
6229       impl->list_sort_ascending = (sort_type == GTK_SORT_ASCENDING);
6230       impl->sort_column = sort_column_id;
6231       impl->sort_order = sort_type;
6232     }
6233 }
6234
6235 static void
6236 set_busy_cursor (GtkFileChooserDefault *impl,
6237                  gboolean               busy)
6238 {
6239   GtkWidget *widget;
6240   GtkWindow *toplevel;
6241   GdkDisplay *display;
6242   GdkCursor *cursor;
6243
6244   toplevel = get_toplevel (GTK_WIDGET (impl));
6245   widget = GTK_WIDGET (toplevel);
6246   if (!toplevel || !gtk_widget_get_realized (widget))
6247     return;
6248
6249   display = gtk_widget_get_display (widget);
6250
6251   if (busy)
6252     cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
6253   else
6254     cursor = NULL;
6255
6256   gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
6257   gdk_display_flush (display);
6258
6259   if (cursor)
6260     g_object_unref (cursor);
6261 }
6262
6263 /* Creates a sort model to wrap the file system model and sets it on the tree view */
6264 static void
6265 load_set_model (GtkFileChooserDefault *impl)
6266 {
6267   profile_start ("start", NULL);
6268
6269   g_assert (impl->browse_files_model != NULL);
6270
6271   profile_msg ("    gtk_tree_view_set_model start", NULL);
6272   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
6273                            GTK_TREE_MODEL (impl->browse_files_model));
6274   gtk_tree_view_columns_autosize (GTK_TREE_VIEW (impl->browse_files_tree_view));
6275   gtk_tree_view_set_search_column (GTK_TREE_VIEW (impl->browse_files_tree_view),
6276                                    MODEL_COL_NAME);
6277   file_list_set_sort_column_ids (impl);
6278   set_sort_column (impl);
6279   profile_msg ("    gtk_tree_view_set_model end", NULL);
6280   impl->list_sort_ascending = TRUE;
6281
6282   profile_end ("end", NULL);
6283 }
6284
6285 /* Timeout callback used when the loading timer expires */
6286 static gboolean
6287 load_timeout_cb (gpointer data)
6288 {
6289   GtkFileChooserDefault *impl;
6290
6291   profile_start ("start", NULL);
6292
6293   impl = GTK_FILE_CHOOSER_DEFAULT (data);
6294   g_assert (impl->load_state == LOAD_PRELOAD);
6295   g_assert (impl->load_timeout_id != 0);
6296   g_assert (impl->browse_files_model != NULL);
6297
6298   impl->load_timeout_id = 0;
6299   impl->load_state = LOAD_LOADING;
6300
6301   load_set_model (impl);
6302
6303   profile_end ("end", NULL);
6304
6305   return FALSE;
6306 }
6307
6308 /* Sets up a new load timer for the model and switches to the LOAD_PRELOAD state */
6309 static void
6310 load_setup_timer (GtkFileChooserDefault *impl)
6311 {
6312   g_assert (impl->load_timeout_id == 0);
6313   g_assert (impl->load_state != LOAD_PRELOAD);
6314
6315   impl->load_timeout_id = gdk_threads_add_timeout (MAX_LOADING_TIME, load_timeout_cb, impl);
6316   impl->load_state = LOAD_PRELOAD;
6317 }
6318
6319 /* Removes the load timeout; changes the impl->load_state to the specified value. */
6320 static void
6321 load_remove_timer (GtkFileChooserDefault *impl, LoadState new_load_state)
6322 {
6323   if (impl->load_timeout_id != 0)
6324     {
6325       g_assert (impl->load_state == LOAD_PRELOAD);
6326
6327       g_source_remove (impl->load_timeout_id);
6328       impl->load_timeout_id = 0;
6329     }
6330   else
6331     g_assert (impl->load_state == LOAD_EMPTY ||
6332               impl->load_state == LOAD_LOADING ||
6333               impl->load_state == LOAD_FINISHED);
6334
6335   g_assert (new_load_state == LOAD_EMPTY ||
6336             new_load_state == LOAD_LOADING ||
6337             new_load_state == LOAD_FINISHED);
6338   impl->load_state = new_load_state;
6339 }
6340
6341 /* Selects the first row in the file list */
6342 static void
6343 browse_files_select_first_row (GtkFileChooserDefault *impl)
6344 {
6345   GtkTreePath *path;
6346   GtkTreeIter dummy_iter;
6347   GtkTreeModel *tree_model;
6348
6349   tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
6350
6351   if (!tree_model)
6352     return;
6353
6354   path = gtk_tree_path_new_from_indices (0, -1);
6355
6356   /* If the list is empty, do nothing. */
6357   if (gtk_tree_model_get_iter (tree_model, &dummy_iter, path))
6358       gtk_tree_view_set_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view), path, NULL, FALSE);
6359
6360   gtk_tree_path_free (path);
6361 }
6362
6363 struct center_selected_row_closure {
6364   GtkFileChooserDefault *impl;
6365   gboolean already_centered;
6366 };
6367
6368 /* Callback used from gtk_tree_selection_selected_foreach(); centers the
6369  * selected row in the tree view.
6370  */
6371 static void
6372 center_selected_row_foreach_cb (GtkTreeModel      *model,
6373                                 GtkTreePath       *path,
6374                                 GtkTreeIter       *iter,
6375                                 gpointer           data)
6376 {
6377   struct center_selected_row_closure *closure;
6378
6379   closure = data;
6380   if (closure->already_centered)
6381     return;
6382
6383   gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (closure->impl->browse_files_tree_view), path, NULL, TRUE, 0.5, 0.0);
6384   closure->already_centered = TRUE;
6385 }
6386
6387 /* Centers the selected row in the tree view */
6388 static void
6389 browse_files_center_selected_row (GtkFileChooserDefault *impl)
6390 {
6391   struct center_selected_row_closure closure;
6392   GtkTreeSelection *selection;
6393
6394   closure.impl = impl;
6395   closure.already_centered = FALSE;
6396
6397   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
6398   gtk_tree_selection_selected_foreach (selection, center_selected_row_foreach_cb, &closure);
6399 }
6400
6401 static gboolean
6402 show_and_select_files (GtkFileChooserDefault *impl,
6403                        GSList                *files)
6404 {
6405   GtkTreeSelection *selection;
6406   GtkFileSystemModel *fsmodel;
6407   gboolean enabled_hidden, removed_filters;
6408   gboolean selected_a_file;
6409   GSList *walk;
6410
6411   g_assert (impl->load_state == LOAD_FINISHED);
6412   g_assert (impl->browse_files_model != NULL);
6413
6414   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
6415   fsmodel = GTK_FILE_SYSTEM_MODEL (gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view)));
6416
6417   g_assert (fsmodel == impl->browse_files_model);
6418
6419   enabled_hidden = impl->show_hidden;
6420   removed_filters = (impl->current_filter == NULL);
6421
6422   selected_a_file = FALSE;
6423
6424   for (walk = files; walk; walk = walk->next)
6425     {
6426       GFile *file = walk->data;
6427       GtkTreeIter iter;
6428
6429       /* Is it a hidden file? */
6430
6431       if (!_gtk_file_system_model_get_iter_for_file (fsmodel, &iter, file))
6432         continue;
6433
6434       if (!_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
6435         {
6436           GFileInfo *info = _gtk_file_system_model_get_info (fsmodel, &iter);
6437
6438           if (!enabled_hidden &&
6439               (g_file_info_get_is_hidden (info) ||
6440                g_file_info_get_is_backup (info)))
6441             {
6442               g_object_set (impl, "show-hidden", TRUE, NULL);
6443               enabled_hidden = TRUE;
6444             }
6445         }
6446
6447       /* Is it a filtered file? */
6448
6449       if (!_gtk_file_system_model_get_iter_for_file (fsmodel, &iter, file))
6450         continue; /* re-get the iter as it may change when the model refilters */
6451
6452       if (!_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
6453         {
6454           /* Maybe we should have a way to ask the fsmodel if it had filtered a file */
6455           if (!removed_filters)
6456             {
6457               set_current_filter (impl, NULL);
6458               removed_filters = TRUE;
6459             }
6460         }
6461
6462       /* Okay, can we select the file now? */
6463
6464       if (!_gtk_file_system_model_get_iter_for_file (fsmodel, &iter, file))
6465         continue;
6466
6467       if (_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
6468         {
6469           GtkTreePath *path;
6470
6471           gtk_tree_selection_select_iter (selection, &iter);
6472
6473           path = gtk_tree_model_get_path (GTK_TREE_MODEL (fsmodel), &iter);
6474           gtk_tree_view_set_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view),
6475                                     path, NULL, FALSE);
6476           gtk_tree_path_free (path);
6477
6478           selected_a_file = TRUE;
6479         }
6480     }
6481
6482   browse_files_center_selected_row (impl);
6483
6484   return selected_a_file;
6485 }
6486
6487 /* Processes the pending operation when a folder is finished loading */
6488 static void
6489 pending_select_files_process (GtkFileChooserDefault *impl)
6490 {
6491   g_assert (impl->load_state == LOAD_FINISHED);
6492   g_assert (impl->browse_files_model != NULL);
6493
6494   if (impl->pending_select_files)
6495     {
6496       show_and_select_files (impl, impl->pending_select_files);
6497       pending_select_files_free (impl);
6498       browse_files_center_selected_row (impl);
6499     }
6500   else
6501     {
6502       /* We only select the first row if the chooser is actually mapped ---
6503        * selecting the first row is to help the user when he is interacting with
6504        * the chooser, but sometimes a chooser works not on behalf of the user,
6505        * but rather on behalf of something else like GtkFileChooserButton.  In
6506        * that case, the chooser's selection should be what the caller expects,
6507        * as the user can't see that something else got selected.  See bug #165264.
6508        */
6509       if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN &&
6510           gtk_widget_get_mapped (GTK_WIDGET (impl)))
6511         browse_files_select_first_row (impl);
6512     }
6513
6514   g_assert (impl->pending_select_files == NULL);
6515 }
6516
6517 static void
6518 show_error_on_reading_current_folder (GtkFileChooserDefault *impl, GError *error)
6519 {
6520   GFileInfo *info;
6521   char *msg;
6522
6523   info = g_file_query_info (impl->current_folder,
6524                             G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
6525                             G_FILE_QUERY_INFO_NONE,
6526                             NULL,
6527                             NULL);
6528   if (info)
6529     {
6530       msg = g_strdup_printf (_("Could not read the contents of %s"), g_file_info_get_display_name (info));
6531       g_object_unref (info);
6532     }
6533   else
6534     msg = g_strdup (_("Could not read the contents of the folder"));
6535
6536   error_message (impl, msg, error->message);
6537   g_free (msg);
6538 }
6539
6540 /* Callback used when the file system model finishes loading */
6541 static void
6542 browse_files_model_finished_loading_cb (GtkFileSystemModel    *model,
6543                                         GError                *error,
6544                                         GtkFileChooserDefault *impl)
6545 {
6546   profile_start ("start", NULL);
6547
6548   if (error)
6549     show_error_on_reading_current_folder (impl, error);
6550
6551   if (impl->load_state == LOAD_PRELOAD)
6552     {
6553       load_remove_timer (impl, LOAD_FINISHED);
6554       load_set_model (impl);
6555     }
6556   else if (impl->load_state == LOAD_LOADING)
6557     {
6558       /* Nothing */
6559     }
6560   else
6561     {
6562       /* We can't g_assert_not_reached(), as something other than us may have
6563        *  initiated a folder reload.  See #165556.
6564        */
6565       profile_end ("end", NULL);
6566       return;
6567     }
6568
6569   g_assert (impl->load_timeout_id == 0);
6570
6571   impl->load_state = LOAD_FINISHED;
6572
6573   pending_select_files_process (impl);
6574   set_busy_cursor (impl, FALSE);
6575 #ifdef PROFILE_FILE_CHOOSER
6576   access ("MARK: *** FINISHED LOADING", F_OK);
6577 #endif
6578
6579   profile_end ("end", NULL);
6580 }
6581
6582 static void
6583 stop_loading_and_clear_list_model (GtkFileChooserDefault *impl,
6584                                    gboolean remove_from_treeview)
6585 {
6586   load_remove_timer (impl, LOAD_EMPTY);
6587
6588   if (impl->browse_files_model)
6589     {
6590       g_object_unref (impl->browse_files_model);
6591       impl->browse_files_model = NULL;
6592     }
6593
6594   if (remove_from_treeview)
6595     gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
6596 }
6597
6598 static char *
6599 my_g_format_time_for_display (glong secs)
6600 {
6601   GDate mtime, now;
6602   gint days_diff;
6603   struct tm tm_mtime;
6604   time_t time_mtime, time_now;
6605   const gchar *format;
6606   gchar *locale_format = NULL;
6607   gchar buf[256];
6608   char *date_str = NULL;
6609 #ifdef G_OS_WIN32
6610   const char *locale, *dot = NULL;
6611   gint64 codepage = -1;
6612   char charset[20];
6613 #endif
6614
6615   time_mtime = secs;
6616
6617 #ifdef HAVE_LOCALTIME_R
6618   localtime_r ((time_t *) &time_mtime, &tm_mtime);
6619 #else
6620   {
6621     struct tm *ptm = localtime ((time_t *) &time_mtime);
6622
6623     if (!ptm)
6624       {
6625         g_warning ("ptm != NULL failed");
6626
6627         return g_strdup (_("Unknown"));
6628       }
6629     else
6630       memcpy ((void *) &tm_mtime, (void *) ptm, sizeof (struct tm));
6631   }
6632 #endif /* HAVE_LOCALTIME_R */
6633
6634   g_date_set_time_t (&mtime, time_mtime);
6635   time_now = time (NULL);
6636   g_date_set_time_t (&now, time_now);
6637
6638   days_diff = g_date_get_julian (&now) - g_date_get_julian (&mtime);
6639
6640   /* Translators: %H means "hours" and %M means "minutes" */
6641   if (days_diff == 0)
6642     format = _("%H:%M");
6643   else if (days_diff == 1)
6644     format = _("Yesterday at %H:%M");
6645   else
6646     {
6647       if (days_diff > 1 && days_diff < 7)
6648         format = "%A"; /* Days from last week */
6649       else
6650         format = "%x"; /* Any other date */
6651     }
6652
6653 #ifdef G_OS_WIN32
6654   /* g_locale_from_utf8() returns a string in the system
6655    * code-page, which is not always the same as that used by the C
6656    * library. For instance when running a GTK+ program with
6657    * LANG=ko on an English version of Windows, the system
6658    * code-page is 1252, but the code-page used by the C library is
6659    * 949. (It's GTK+ itself that sets the C library locale when it
6660    * notices the LANG environment variable. See gtkmain.c The
6661    * Microsoft C library doesn't look at any locale environment
6662    * variables.) We need to pass strftime() a string in the C
6663    * library's code-page. See bug #509885.
6664    */
6665   locale = setlocale (LC_ALL, NULL);
6666   if (locale != NULL)
6667     dot = strchr (locale, '.');
6668   if (dot != NULL)
6669     {
6670       codepage = g_ascii_strtoll (dot+1, NULL, 10);
6671
6672       /* All codepages should fit in 16 bits AFAIK */
6673       if (codepage > 0 && codepage < 65536)
6674         {
6675           sprintf (charset, "CP%u", (guint) codepage);
6676           locale_format = g_convert (format, -1, charset, "UTF-8", NULL, NULL, NULL);
6677         }
6678     }
6679 #else
6680   locale_format = g_locale_from_utf8 (format, -1, NULL, NULL, NULL);
6681 #endif
6682   if (locale_format != NULL &&
6683       strftime (buf, sizeof (buf), locale_format, &tm_mtime) != 0)
6684     {
6685 #ifdef G_OS_WIN32
6686       /* As above but in opposite direction... */
6687       if (codepage > 0 && codepage < 65536)
6688         date_str = g_convert (buf, -1, "UTF-8", charset, NULL, NULL, NULL);
6689 #else
6690       date_str = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
6691 #endif
6692     }
6693
6694   if (date_str == NULL)
6695     date_str = g_strdup (_("Unknown"));
6696
6697   g_free (locale_format);
6698   return date_str;
6699 }
6700
6701 static void
6702 copy_attribute (GFileInfo *to, GFileInfo *from, const char *attribute)
6703 {
6704   GFileAttributeType type;
6705   gpointer value;
6706
6707   if (g_file_info_get_attribute_data (from, attribute, &type, &value, NULL))
6708     g_file_info_set_attribute (to, attribute, type, value);
6709 }
6710
6711 static void
6712 file_system_model_got_thumbnail (GObject *object, GAsyncResult *res, gpointer data)
6713 {
6714   GtkFileSystemModel *model = data; /* might be unreffed if operation was cancelled */
6715   GFile *file = G_FILE (object);
6716   GFileInfo *queried, *info;
6717   GtkTreeIter iter;
6718
6719   queried = g_file_query_info_finish (file, res, NULL);
6720   if (queried == NULL)
6721     return;
6722
6723   gdk_threads_enter ();
6724
6725   /* now we know model is valid */
6726
6727   /* file was deleted */
6728   if (!_gtk_file_system_model_get_iter_for_file (model, &iter, file))
6729     {
6730       gdk_threads_leave ();
6731       return;
6732     }
6733
6734   info = g_file_info_dup (_gtk_file_system_model_get_info (model, &iter));
6735
6736   copy_attribute (info, queried, G_FILE_ATTRIBUTE_THUMBNAIL_PATH);
6737   copy_attribute (info, queried, G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
6738   copy_attribute (info, queried, G_FILE_ATTRIBUTE_STANDARD_ICON);
6739
6740   _gtk_file_system_model_update_file (model, file, info);
6741
6742   g_object_unref (info);
6743
6744   gdk_threads_leave ();
6745 }
6746
6747 static gboolean
6748 file_system_model_set (GtkFileSystemModel *model,
6749                        GFile              *file,
6750                        GFileInfo          *info,
6751                        int                 column,
6752                        GValue             *value,
6753                        gpointer            data)
6754 {
6755   GtkFileChooserDefault *impl = data;
6756
6757   switch (column)
6758     {
6759     case MODEL_COL_FILE:
6760       g_value_set_object (value, file);
6761       break;
6762     case MODEL_COL_NAME:
6763       if (info == NULL)
6764         g_value_set_string (value, DEFAULT_NEW_FOLDER_NAME);
6765       else
6766         g_value_set_string (value, g_file_info_get_display_name (info));
6767       break;
6768     case MODEL_COL_NAME_COLLATED:
6769       if (info == NULL)
6770         g_value_take_string (value, g_utf8_collate_key_for_filename (DEFAULT_NEW_FOLDER_NAME, -1));
6771       else
6772         g_value_take_string (value, g_utf8_collate_key_for_filename (g_file_info_get_display_name (info), -1));
6773       break;
6774     case MODEL_COL_IS_FOLDER:
6775       g_value_set_boolean (value, info == NULL || _gtk_file_info_consider_as_directory (info));
6776       break;
6777     case MODEL_COL_IS_SENSITIVE:
6778       if (info)
6779         {
6780           gboolean sensitive = TRUE;
6781
6782           if (!(impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
6783                 || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER))
6784             {
6785               sensitive = TRUE; /* for file modes... */
6786             }
6787           else if (!_gtk_file_info_consider_as_directory (info))
6788             {
6789               sensitive = FALSE; /* for folder modes, files are not sensitive... */
6790             }
6791           else
6792             {
6793               /* ... and for folder modes, folders are sensitive only if the filter says so */
6794               GtkTreeIter iter;
6795               if (!_gtk_file_system_model_get_iter_for_file (model, &iter, file))
6796                 g_assert_not_reached ();
6797               sensitive = !_gtk_file_system_model_iter_is_filtered_out (model, &iter);
6798             }
6799
6800           g_value_set_boolean (value, sensitive);
6801         }
6802       else
6803         g_value_set_boolean (value, TRUE);
6804       break;
6805     case MODEL_COL_PIXBUF:
6806       if (info)
6807         {
6808           if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_ICON))
6809             {
6810               g_value_take_object (value, _gtk_file_info_render_icon (info, GTK_WIDGET (impl), impl->icon_size));
6811             }
6812           else
6813             {
6814               GtkTreeModel *tree_model;
6815               GtkTreePath *path, *start, *end;
6816               GtkTreeIter iter;
6817
6818               if (impl->browse_files_tree_view == NULL ||
6819                   g_file_info_has_attribute (info, "filechooser::queried"))
6820                 return FALSE;
6821
6822               tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
6823               if (tree_model != GTK_TREE_MODEL (model))
6824                 return FALSE;
6825
6826               if (!_gtk_file_system_model_get_iter_for_file (model,
6827                                                              &iter,
6828                                                              file))
6829                 g_assert_not_reached ();
6830               if (!gtk_tree_view_get_visible_range (GTK_TREE_VIEW (impl->browse_files_tree_view), &start, &end))
6831                 return FALSE;
6832               path = gtk_tree_model_get_path (tree_model, &iter);
6833               if (gtk_tree_path_compare (start, path) != 1 &&
6834                   gtk_tree_path_compare (path, end) != 1)
6835                 {
6836                   g_file_info_set_attribute_boolean (info, "filechooser::queried", TRUE);
6837                   g_file_query_info_async (file,
6838                                            G_FILE_ATTRIBUTE_THUMBNAIL_PATH ","
6839                                            G_FILE_ATTRIBUTE_THUMBNAILING_FAILED ","
6840                                            G_FILE_ATTRIBUTE_STANDARD_ICON,
6841                                            G_FILE_QUERY_INFO_NONE,
6842                                            G_PRIORITY_DEFAULT,
6843                                            _gtk_file_system_model_get_cancellable (model),
6844                                            file_system_model_got_thumbnail,
6845                                            model);
6846                 }
6847               gtk_tree_path_free (path);
6848               gtk_tree_path_free (start);
6849               gtk_tree_path_free (end);
6850               return FALSE;
6851             }
6852         }
6853       else
6854         g_value_set_object (value, NULL);
6855       break;
6856     case MODEL_COL_SIZE:
6857       g_value_set_int64 (value, info ? g_file_info_get_size (info) : 0);
6858       break;
6859     case MODEL_COL_SIZE_TEXT:
6860       if (info == NULL || _gtk_file_info_consider_as_directory (info))
6861         g_value_set_string (value, NULL);
6862       else
6863         g_value_take_string (value, g_format_size (g_file_info_get_size (info)));
6864       break;
6865     case MODEL_COL_MTIME:
6866     case MODEL_COL_MTIME_TEXT:
6867       {
6868         GTimeVal tv;
6869         if (info == NULL)
6870           break;
6871         g_file_info_get_modification_time (info, &tv);
6872         if (column == MODEL_COL_MTIME)
6873           g_value_set_long (value, tv.tv_sec);
6874         else if (tv.tv_sec == 0)
6875           g_value_set_static_string (value, _("Unknown"));
6876         else
6877           g_value_take_string (value, my_g_format_time_for_display (tv.tv_sec));
6878         break;
6879       }
6880     case MODEL_COL_ELLIPSIZE:
6881       g_value_set_enum (value, info ? PANGO_ELLIPSIZE_END : PANGO_ELLIPSIZE_NONE);
6882       break;
6883     default:
6884       g_assert_not_reached ();
6885       break;
6886     }
6887
6888   return TRUE;
6889 }
6890
6891 /* Gets rid of the old list model and creates a new one for the current folder */
6892 static gboolean
6893 set_list_model (GtkFileChooserDefault *impl,
6894                 GError               **error)
6895 {
6896   g_assert (impl->current_folder != NULL);
6897
6898   profile_start ("start", NULL);
6899
6900   stop_loading_and_clear_list_model (impl, TRUE);
6901
6902   set_busy_cursor (impl, TRUE);
6903
6904   impl->browse_files_model =
6905     _gtk_file_system_model_new_for_directory (impl->current_folder,
6906                                               MODEL_ATTRIBUTES,
6907                                               file_system_model_set,
6908                                               impl,
6909                                               MODEL_COLUMN_TYPES);
6910
6911   _gtk_file_system_model_set_show_hidden (impl->browse_files_model, impl->show_hidden);
6912
6913   profile_msg ("    set sort function", NULL);
6914   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_NAME, name_sort_func, impl, NULL);
6915   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_SIZE, size_sort_func, impl, NULL);
6916   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_MTIME, mtime_sort_func, impl, NULL);
6917   gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), NULL, NULL, NULL);
6918   set_sort_column (impl);
6919   impl->list_sort_ascending = TRUE;
6920   g_signal_connect (impl->browse_files_model, "sort-column-changed",
6921                     G_CALLBACK (list_sort_column_changed_cb), impl);
6922
6923   load_setup_timer (impl); /* This changes the state to LOAD_PRELOAD */
6924
6925   g_signal_connect (impl->browse_files_model, "finished-loading",
6926                     G_CALLBACK (browse_files_model_finished_loading_cb), impl);
6927
6928   _gtk_file_system_model_set_filter (impl->browse_files_model, impl->current_filter);
6929
6930   profile_end ("end", NULL);
6931
6932   return TRUE;
6933 }
6934
6935 struct update_chooser_entry_selected_foreach_closure {
6936   int num_selected;
6937   GtkTreeIter first_selected_iter;
6938 };
6939
6940 static gint
6941 compare_utf8_filenames (const gchar *a,
6942                         const gchar *b)
6943 {
6944   gchar *a_folded, *b_folded;
6945   gint retval;
6946
6947   a_folded = g_utf8_strdown (a, -1);
6948   b_folded = g_utf8_strdown (b, -1);
6949
6950   retval = strcmp (a_folded, b_folded);
6951
6952   g_free (a_folded);
6953   g_free (b_folded);
6954
6955   return retval;
6956 }
6957
6958 static void
6959 update_chooser_entry_selected_foreach (GtkTreeModel *model,
6960                                        GtkTreePath *path,
6961                                        GtkTreeIter *iter,
6962                                        gpointer data)
6963 {
6964   struct update_chooser_entry_selected_foreach_closure *closure;
6965
6966   closure = data;
6967   closure->num_selected++;
6968
6969   if (closure->num_selected == 1)
6970     closure->first_selected_iter = *iter;
6971 }
6972
6973 static void
6974 update_chooser_entry (GtkFileChooserDefault *impl)
6975 {
6976   GtkTreeSelection *selection;
6977   struct update_chooser_entry_selected_foreach_closure closure;
6978
6979   /* no need to update the file chooser's entry if there's no entry */
6980   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
6981       !impl->location_entry)
6982     return;
6983
6984   if (!(impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
6985         || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
6986         || ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
6987              || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
6988             && impl->location_mode == LOCATION_MODE_FILENAME_ENTRY)))
6989     return;
6990
6991   g_assert (impl->location_entry != NULL);
6992
6993   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
6994   closure.num_selected = 0;
6995   gtk_tree_selection_selected_foreach (selection, update_chooser_entry_selected_foreach, &closure);
6996
6997   if (closure.num_selected == 0)
6998     {
6999       if (impl->operation_mode == OPERATION_MODE_RECENT)
7000         _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), NULL);
7001       else
7002         goto maybe_clear_entry;
7003     }
7004   else if (closure.num_selected == 1)
7005     {
7006       if (impl->operation_mode == OPERATION_MODE_BROWSE)
7007         {
7008           GFileInfo *info;
7009           gboolean change_entry;
7010
7011           info = _gtk_file_system_model_get_info (impl->browse_files_model, &closure.first_selected_iter);
7012
7013           /* If the cursor moved to the row of the newly created folder,
7014            * retrieving info will return NULL.
7015            */
7016           if (!info)
7017             return;
7018
7019           g_free (impl->browse_files_last_selected_name);
7020           impl->browse_files_last_selected_name =
7021             g_strdup (g_file_info_get_display_name (info));
7022
7023           if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
7024               impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7025               impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
7026             {
7027               /* Don't change the name when clicking on a folder... */
7028               change_entry = (! _gtk_file_info_consider_as_directory (info));
7029             }
7030           else
7031             change_entry = TRUE; /* ... unless we are in SELECT_FOLDER mode */
7032
7033           if (change_entry)
7034             {
7035               gtk_entry_set_text (GTK_ENTRY (impl->location_entry), impl->browse_files_last_selected_name);
7036
7037               if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7038                 _gtk_file_chooser_entry_select_filename (GTK_FILE_CHOOSER_ENTRY (impl->location_entry));
7039             }
7040
7041           return;
7042         }
7043       else if (impl->operation_mode == OPERATION_MODE_RECENT
7044                && impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7045         {
7046           GFile *folder;
7047
7048           /* Set the base folder on the name entry, so it will do completion relative to the correct recent-folder */
7049
7050           gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &closure.first_selected_iter,
7051                               MODEL_COL_FILE, &folder,
7052                               -1);
7053           _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), folder);
7054           g_object_unref (folder);
7055           return;
7056         }
7057     }
7058   else
7059     {
7060       g_assert (!(impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7061                   impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER));
7062
7063       /* Multiple selection, so just clear the entry. */
7064       g_free (impl->browse_files_last_selected_name);
7065       impl->browse_files_last_selected_name = NULL;
7066
7067       gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
7068       return;
7069     }
7070
7071  maybe_clear_entry:
7072
7073   if ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
7074       && impl->browse_files_last_selected_name)
7075     {
7076       const char *entry_text;
7077       int len;
7078       gboolean clear_entry;
7079
7080       entry_text = gtk_entry_get_text (GTK_ENTRY (impl->location_entry));
7081       len = strlen (entry_text);
7082       if (len != 0)
7083         {
7084           /* The file chooser entry may have appended a "/" to its text.
7085            * So take it out, and compare the result to the old selection.
7086            */
7087           if (entry_text[len - 1] == G_DIR_SEPARATOR)
7088             {
7089               gchar *tmp;
7090
7091               tmp = g_strndup (entry_text, len - 1);
7092               clear_entry = (compare_utf8_filenames (impl->browse_files_last_selected_name, tmp) == 0);
7093               g_free (tmp);
7094             }
7095           else
7096             clear_entry = (compare_utf8_filenames (impl->browse_files_last_selected_name, entry_text) == 0);
7097         }
7098       else
7099         clear_entry = FALSE;
7100
7101       if (clear_entry)
7102         gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
7103     }
7104 }
7105
7106 static gboolean
7107 gtk_file_chooser_default_set_current_folder (GtkFileChooser  *chooser,
7108                                              GFile           *file,
7109                                              GError         **error)
7110 {
7111   return gtk_file_chooser_default_update_current_folder (chooser, file, FALSE, FALSE, error);
7112 }
7113
7114
7115 struct UpdateCurrentFolderData
7116 {
7117   GtkFileChooserDefault *impl;
7118   GFile *file;
7119   gboolean keep_trail;
7120   gboolean clear_entry;
7121   GFile *original_file;
7122   GError *original_error;
7123 };
7124
7125 static void
7126 update_current_folder_mount_enclosing_volume_cb (GCancellable        *cancellable,
7127                                                  GtkFileSystemVolume *volume,
7128                                                  const GError        *error,
7129                                                  gpointer             user_data)
7130 {
7131   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
7132   struct UpdateCurrentFolderData *data = user_data;
7133   GtkFileChooserDefault *impl = data->impl;
7134
7135   if (cancellable != impl->update_current_folder_cancellable)
7136     goto out;
7137
7138   impl->update_current_folder_cancellable = NULL;
7139   set_busy_cursor (impl, FALSE);
7140
7141   if (cancelled)
7142     goto out;
7143
7144   if (error)
7145     {
7146       error_changing_folder_dialog (data->impl, data->file, g_error_copy (error));
7147       impl->reload_state = RELOAD_EMPTY;
7148       goto out;
7149     }
7150
7151   change_folder_and_display_error (impl, data->file, data->clear_entry);
7152
7153 out:
7154   g_object_unref (data->file);
7155   g_free (data);
7156
7157   g_object_unref (cancellable);
7158 }
7159
7160 static void
7161 update_current_folder_get_info_cb (GCancellable *cancellable,
7162                                    GFileInfo    *info,
7163                                    const GError *error,
7164                                    gpointer      user_data)
7165 {
7166   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
7167   struct UpdateCurrentFolderData *data = user_data;
7168   GtkFileChooserDefault *impl = data->impl;
7169
7170   if (cancellable != impl->update_current_folder_cancellable)
7171     goto out;
7172
7173   impl->update_current_folder_cancellable = NULL;
7174   impl->reload_state = RELOAD_EMPTY;
7175
7176   set_busy_cursor (impl, FALSE);
7177
7178   if (cancelled)
7179     goto out;
7180
7181   if (error)
7182     {
7183       GFile *parent_file;
7184
7185       if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED))
7186         {
7187           GMountOperation *mount_operation;
7188           GtkWidget *toplevel;
7189
7190           g_object_unref (cancellable);
7191           toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
7192
7193           mount_operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
7194
7195           set_busy_cursor (impl, TRUE);
7196
7197           impl->update_current_folder_cancellable =
7198             _gtk_file_system_mount_enclosing_volume (impl->file_system, data->file,
7199                                                      mount_operation,
7200                                                      update_current_folder_mount_enclosing_volume_cb,
7201                                                      data);
7202
7203           return;
7204         }
7205
7206       if (!data->original_file)
7207         {
7208           data->original_file = g_object_ref (data->file);
7209           data->original_error = g_error_copy (error);
7210         }
7211
7212       parent_file = g_file_get_parent (data->file);
7213
7214       /* get parent path and try to change the folder to that */
7215       if (parent_file)
7216         {
7217           g_object_unref (data->file);
7218           data->file = parent_file;
7219
7220           g_object_unref (cancellable);
7221
7222           /* restart the update current folder operation */
7223           impl->reload_state = RELOAD_HAS_FOLDER;
7224
7225           impl->update_current_folder_cancellable =
7226             _gtk_file_system_get_info (impl->file_system, data->file,
7227                                        "standard::type",
7228                                        update_current_folder_get_info_cb,
7229                                        data);
7230
7231           set_busy_cursor (impl, TRUE);
7232
7233           return;
7234         }
7235       else
7236         {
7237           /* Error and bail out, ignoring "not found" errors since they're useless:
7238            * they only happen when a program defaults to a folder that has been (re)moved.
7239            */
7240           if (!g_error_matches (data->original_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
7241             error_changing_folder_dialog (impl, data->original_file, data->original_error);
7242           else
7243             g_error_free (data->original_error);
7244
7245           g_object_unref (data->original_file);
7246
7247           goto out;
7248         }
7249     }
7250
7251   if (data->original_file)
7252     {
7253       /* Error and bail out, ignoring "not found" errors since they're useless:
7254        * they only happen when a program defaults to a folder that has been (re)moved.
7255        */
7256       if (!g_error_matches (data->original_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
7257         error_changing_folder_dialog (impl, data->original_file, data->original_error);
7258       else
7259         g_error_free (data->original_error);
7260
7261       g_object_unref (data->original_file);
7262     }
7263
7264   if (! _gtk_file_info_consider_as_directory (info))
7265     goto out;
7266
7267   _gtk_path_bar_set_file (GTK_PATH_BAR (impl->browse_path_bar), data->file, data->keep_trail);
7268
7269   if (impl->current_folder != data->file)
7270     {
7271       if (impl->current_folder)
7272         g_object_unref (impl->current_folder);
7273
7274       impl->current_folder = g_object_ref (data->file);
7275     }
7276
7277   impl->reload_state = RELOAD_HAS_FOLDER;
7278
7279   /* Update the widgets that may trigger a folder change themselves.  */
7280
7281   if (!impl->changing_folder)
7282     {
7283       impl->changing_folder = TRUE;
7284
7285       shortcuts_update_current_folder (impl);
7286
7287       impl->changing_folder = FALSE;
7288     }
7289
7290   /* Set the folder on the save entry */
7291
7292   if (impl->location_entry)
7293     {
7294       _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry),
7295                                                impl->current_folder);
7296
7297       if (data->clear_entry)
7298         gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
7299     }
7300
7301   /* Create a new list model.  This is slightly evil; we store the result value
7302    * but perform more actions rather than returning immediately even if it
7303    * generates an error.
7304    */
7305   set_list_model (impl, NULL);
7306
7307   /* Refresh controls */
7308
7309   shortcuts_find_current_folder (impl);
7310
7311   g_signal_emit_by_name (impl, "current-folder-changed", 0);
7312
7313   check_preview_change (impl);
7314   bookmarks_check_add_sensitivity (impl);
7315
7316   g_signal_emit_by_name (impl, "selection-changed", 0);
7317
7318 out:
7319   g_object_unref (data->file);
7320   g_free (data);
7321
7322   g_object_unref (cancellable);
7323 }
7324
7325 static gboolean
7326 gtk_file_chooser_default_update_current_folder (GtkFileChooser    *chooser,
7327                                                 GFile             *file,
7328                                                 gboolean           keep_trail,
7329                                                 gboolean           clear_entry,
7330                                                 GError           **error)
7331 {
7332   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7333   struct UpdateCurrentFolderData *data;
7334
7335   profile_start ("start", NULL);
7336
7337   g_object_ref (file);
7338
7339   operation_mode_set (impl, OPERATION_MODE_BROWSE);
7340
7341   if (impl->local_only && !_gtk_file_has_native_path (file))
7342     {
7343       g_set_error_literal (error,
7344                            GTK_FILE_CHOOSER_ERROR,
7345                            GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
7346                            _("Cannot change to folder because it is not local"));
7347
7348       g_object_unref (file);
7349       profile_end ("end - not local", NULL);
7350       return FALSE;
7351     }
7352
7353   if (impl->update_current_folder_cancellable)
7354     g_cancellable_cancel (impl->update_current_folder_cancellable);
7355
7356   /* Test validity of path here.  */
7357   data = g_new0 (struct UpdateCurrentFolderData, 1);
7358   data->impl = impl;
7359   data->file = g_object_ref (file);
7360   data->keep_trail = keep_trail;
7361   data->clear_entry = clear_entry;
7362
7363   impl->reload_state = RELOAD_HAS_FOLDER;
7364
7365   impl->update_current_folder_cancellable =
7366     _gtk_file_system_get_info (impl->file_system, file,
7367                                "standard::type",
7368                                update_current_folder_get_info_cb,
7369                                data);
7370
7371   set_busy_cursor (impl, TRUE);
7372   g_object_unref (file);
7373
7374   profile_end ("end", NULL);
7375   return TRUE;
7376 }
7377
7378 static GFile *
7379 gtk_file_chooser_default_get_current_folder (GtkFileChooser *chooser)
7380 {
7381   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7382
7383   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
7384       impl->operation_mode == OPERATION_MODE_RECENT)
7385     return NULL;
7386
7387   if (impl->current_folder)
7388     return g_object_ref (impl->current_folder);
7389
7390   return NULL;
7391 }
7392
7393 static void
7394 gtk_file_chooser_default_set_current_name (GtkFileChooser *chooser,
7395                                            const gchar    *name)
7396 {
7397   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7398
7399   g_return_if_fail (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7400                     impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER);
7401
7402   pending_select_files_free (impl);
7403   gtk_entry_set_text (GTK_ENTRY (impl->location_entry), name);
7404 }
7405
7406 static gboolean
7407 gtk_file_chooser_default_select_file (GtkFileChooser  *chooser,
7408                                       GFile           *file,
7409                                       GError         **error)
7410 {
7411   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7412   GFile *parent_file;
7413   gboolean same_path;
7414
7415   parent_file = g_file_get_parent (file);
7416
7417   if (!parent_file)
7418     return gtk_file_chooser_set_current_folder_file (chooser, file, error);
7419
7420   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
7421       impl->operation_mode == OPERATION_MODE_RECENT ||
7422       impl->load_state == LOAD_EMPTY)
7423     {
7424       same_path = FALSE;
7425     }
7426   else
7427     {
7428       g_assert (impl->current_folder != NULL);
7429
7430       same_path = g_file_equal (parent_file, impl->current_folder);
7431     }
7432
7433   if (same_path && impl->load_state == LOAD_FINISHED)
7434     {
7435       gboolean result;
7436       GSList files;
7437
7438       files.data = (gpointer) file;
7439       files.next = NULL;
7440
7441       result = show_and_select_files (impl, &files);
7442       g_object_unref (parent_file);
7443       return result;
7444     }
7445
7446   pending_select_files_add (impl, file);
7447
7448   if (!same_path)
7449     {
7450       gboolean result;
7451
7452       result = gtk_file_chooser_set_current_folder_file (chooser, parent_file, error);
7453       g_object_unref (parent_file);
7454       return result;
7455     }
7456
7457   g_object_unref (parent_file);
7458   return TRUE;
7459 }
7460
7461 static void
7462 gtk_file_chooser_default_unselect_file (GtkFileChooser *chooser,
7463                                         GFile          *file)
7464 {
7465   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7466   GtkTreeView *tree_view = GTK_TREE_VIEW (impl->browse_files_tree_view);
7467   GtkTreeIter iter;
7468
7469   if (!impl->browse_files_model)
7470     return;
7471
7472   if (!_gtk_file_system_model_get_iter_for_file (impl->browse_files_model,
7473                                                  &iter,
7474                                                  file))
7475     return;
7476
7477   gtk_tree_selection_unselect_iter (gtk_tree_view_get_selection (tree_view),
7478                                     &iter);
7479 }
7480
7481 static gboolean
7482 maybe_select (GtkTreeModel *model,
7483               GtkTreePath  *path,
7484               GtkTreeIter  *iter,
7485               gpointer     data)
7486 {
7487   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (data);
7488   GtkTreeSelection *selection;
7489   gboolean is_sensitive;
7490   gboolean is_folder;
7491
7492   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7493
7494   gtk_tree_model_get (model, iter,
7495                       MODEL_COL_IS_FOLDER, &is_folder,
7496                       MODEL_COL_IS_SENSITIVE, &is_sensitive,
7497                       -1);
7498
7499   if (is_sensitive &&
7500       ((is_folder && impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ||
7501        (!is_folder && impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)))
7502     gtk_tree_selection_select_iter (selection, iter);
7503   else
7504     gtk_tree_selection_unselect_iter (selection, iter);
7505
7506   return FALSE;
7507 }
7508
7509 static void
7510 gtk_file_chooser_default_select_all (GtkFileChooser *chooser)
7511 {
7512   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7513
7514   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
7515       impl->operation_mode == OPERATION_MODE_RECENT)
7516     {
7517       GtkTreeSelection *selection;
7518
7519       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7520       gtk_tree_selection_select_all (selection);
7521       return;
7522     }
7523
7524   if (impl->select_multiple)
7525     gtk_tree_model_foreach (GTK_TREE_MODEL (impl->browse_files_model),
7526                             maybe_select, impl);
7527 }
7528
7529 static void
7530 gtk_file_chooser_default_unselect_all (GtkFileChooser *chooser)
7531 {
7532   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7533   GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7534
7535   gtk_tree_selection_unselect_all (selection);
7536   pending_select_files_free (impl);
7537 }
7538
7539 /* Checks whether the filename entry for the Save modes contains a well-formed filename.
7540  *
7541  * is_well_formed_ret - whether what the user typed passes gkt_file_system_make_path()
7542  *
7543  * is_empty_ret - whether the file entry is totally empty
7544  *
7545  * is_file_part_empty_ret - whether the file part is empty (will be if user types "foobar/", and
7546  *                          the path will be "$cwd/foobar")
7547  */
7548 static void
7549 check_save_entry (GtkFileChooserDefault *impl,
7550                   GFile                **file_ret,
7551                   gboolean              *is_well_formed_ret,
7552                   gboolean              *is_empty_ret,
7553                   gboolean              *is_file_part_empty_ret,
7554                   gboolean              *is_folder)
7555 {
7556   GtkFileChooserEntry *chooser_entry;
7557   GFile *current_folder;
7558   const char *file_part;
7559   GFile *file;
7560   GError *error;
7561
7562   g_assert (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
7563             || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
7564             || ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
7565                  || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
7566                 && impl->location_mode == LOCATION_MODE_FILENAME_ENTRY));
7567
7568   chooser_entry = GTK_FILE_CHOOSER_ENTRY (impl->location_entry);
7569
7570   if (strlen (gtk_entry_get_text (GTK_ENTRY (chooser_entry))) == 0)
7571     {
7572       *file_ret = NULL;
7573       *is_well_formed_ret = TRUE;
7574       *is_empty_ret = TRUE;
7575       *is_file_part_empty_ret = TRUE;
7576       *is_folder = FALSE;
7577
7578       return;
7579     }
7580
7581   *is_empty_ret = FALSE;
7582
7583   current_folder = _gtk_file_chooser_entry_get_current_folder (chooser_entry);
7584   if (!current_folder)
7585     {
7586       *file_ret = NULL;
7587       *is_well_formed_ret = FALSE;
7588       *is_file_part_empty_ret = FALSE;
7589       *is_folder = FALSE;
7590
7591       return;
7592     }
7593
7594   file_part = _gtk_file_chooser_entry_get_file_part (chooser_entry);
7595
7596   if (!file_part || file_part[0] == '\0')
7597     {
7598       *file_ret = current_folder;
7599       *is_well_formed_ret = TRUE;
7600       *is_file_part_empty_ret = TRUE;
7601       *is_folder = TRUE;
7602
7603       return;
7604     }
7605
7606   *is_file_part_empty_ret = FALSE;
7607
7608   error = NULL;
7609   file = g_file_get_child_for_display_name (current_folder, file_part, &error);
7610   g_object_unref (current_folder);
7611
7612   if (!file)
7613     {
7614       error_building_filename_dialog (impl, error);
7615       *file_ret = NULL;
7616       *is_well_formed_ret = FALSE;
7617       *is_folder = FALSE;
7618
7619       return;
7620     }
7621
7622   *file_ret = file;
7623   *is_well_formed_ret = TRUE;
7624   *is_folder = _gtk_file_chooser_entry_get_is_folder (chooser_entry, file);
7625 }
7626
7627 struct get_files_closure {
7628   GtkFileChooserDefault *impl;
7629   GSList *result;
7630   GFile *file_from_entry;
7631 };
7632
7633 static void
7634 get_files_foreach (GtkTreeModel *model,
7635                    GtkTreePath  *path,
7636                    GtkTreeIter  *iter,
7637                    gpointer      data)
7638 {
7639   struct get_files_closure *info;
7640   GFile *file;
7641   GtkFileSystemModel *fs_model;
7642
7643   info = data;
7644   fs_model = info->impl->browse_files_model;
7645
7646   file = _gtk_file_system_model_get_file (fs_model, iter);
7647   if (!file)
7648     return; /* We are on the editable row */
7649
7650   if (!info->file_from_entry || !g_file_equal (info->file_from_entry, file))
7651     info->result = g_slist_prepend (info->result, g_object_ref (file));
7652 }
7653
7654 static GSList *
7655 gtk_file_chooser_default_get_files (GtkFileChooser *chooser)
7656 {
7657   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7658   struct get_files_closure info;
7659   GtkWindow *toplevel;
7660   GtkWidget *current_focus;
7661   gboolean file_list_seen;
7662
7663   info.impl = impl;
7664   info.result = NULL;
7665   info.file_from_entry = NULL;
7666
7667   if (impl->operation_mode == OPERATION_MODE_SEARCH)
7668     return search_get_selected_files (impl);
7669
7670   if (impl->operation_mode == OPERATION_MODE_RECENT)
7671     {
7672       if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7673         {
7674           file_list_seen = TRUE;
7675           goto file_entry;
7676         }
7677       else
7678         return recent_get_selected_files (impl);
7679     }
7680
7681   toplevel = get_toplevel (GTK_WIDGET (impl));
7682   if (toplevel)
7683     current_focus = gtk_window_get_focus (toplevel);
7684   else
7685     current_focus = NULL;
7686
7687   file_list_seen = FALSE;
7688   if (current_focus == impl->browse_files_tree_view)
7689     {
7690       GtkTreeSelection *selection;
7691
7692     file_list:
7693
7694       file_list_seen = TRUE;
7695       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7696       gtk_tree_selection_selected_foreach (selection, get_files_foreach, &info);
7697
7698       /* If there is no selection in the file list, we probably have this situation:
7699        *
7700        * 1. The user typed a filename in the SAVE filename entry ("foo.txt").
7701        * 2. He then double-clicked on a folder ("bar") in the file list
7702        *
7703        * So we want the selection to be "bar/foo.txt".  Jump to the case for the
7704        * filename entry to see if that is the case.
7705        */
7706       if (info.result == NULL && impl->location_entry)
7707         goto file_entry;
7708     }
7709   else if (impl->location_entry && current_focus == impl->location_entry)
7710     {
7711       gboolean is_well_formed, is_empty, is_file_part_empty, is_folder;
7712
7713     file_entry:
7714
7715       check_save_entry (impl, &info.file_from_entry, &is_well_formed, &is_empty, &is_file_part_empty, &is_folder);
7716
7717       if (is_empty)
7718         goto out;
7719
7720       if (!is_well_formed)
7721         return NULL;
7722
7723       if (is_file_part_empty && impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7724         {
7725           g_object_unref (info.file_from_entry);
7726           return NULL;
7727         }
7728
7729       if (info.file_from_entry)
7730         info.result = g_slist_prepend (info.result, info.file_from_entry);
7731       else if (!file_list_seen)
7732         goto file_list;
7733       else
7734         return NULL;
7735     }
7736   else if (impl->toplevel_last_focus_widget == impl->browse_files_tree_view)
7737     goto file_list;
7738   else if (impl->location_entry && impl->toplevel_last_focus_widget == impl->location_entry)
7739     goto file_entry;
7740   else
7741     {
7742       /* The focus is on a dialog's action area button or something else */
7743       if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7744           impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
7745         goto file_entry;
7746       else
7747         goto file_list;
7748     }
7749
7750  out:
7751
7752   /* If there's no folder selected, and we're in SELECT_FOLDER mode, then we
7753    * fall back to the current directory */
7754   if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER &&
7755       info.result == NULL)
7756     {
7757       GFile *current_folder;
7758
7759       current_folder = gtk_file_chooser_get_current_folder_file (chooser);
7760
7761       if (current_folder)
7762         info.result = g_slist_prepend (info.result, current_folder);
7763     }
7764
7765   return g_slist_reverse (info.result);
7766 }
7767
7768 GFile *
7769 gtk_file_chooser_default_get_preview_file (GtkFileChooser *chooser)
7770 {
7771   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7772
7773   if (impl->preview_file)
7774     return g_object_ref (impl->preview_file);
7775   else
7776     return NULL;
7777 }
7778
7779 static GtkFileSystem *
7780 gtk_file_chooser_default_get_file_system (GtkFileChooser *chooser)
7781 {
7782   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7783
7784   return impl->file_system;
7785 }
7786
7787 /* Shows or hides the filter widgets */
7788 static void
7789 show_filters (GtkFileChooserDefault *impl,
7790               gboolean               show)
7791 {
7792   if (show)
7793     gtk_widget_show (impl->filter_combo_hbox);
7794   else
7795     gtk_widget_hide (impl->filter_combo_hbox);
7796 }
7797
7798 static void
7799 gtk_file_chooser_default_add_filter (GtkFileChooser *chooser,
7800                                      GtkFileFilter  *filter)
7801 {
7802   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7803   const gchar *name;
7804
7805   if (g_slist_find (impl->filters, filter))
7806     {
7807       g_warning ("gtk_file_chooser_add_filter() called on filter already in list\n");
7808       return;
7809     }
7810
7811   g_object_ref_sink (filter);
7812   impl->filters = g_slist_append (impl->filters, filter);
7813
7814   name = gtk_file_filter_get_name (filter);
7815   if (!name)
7816     name = "Untitled filter";   /* Place-holder, doesn't need to be marked for translation */
7817
7818   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (impl->filter_combo), name);
7819
7820   if (!g_slist_find (impl->filters, impl->current_filter))
7821     set_current_filter (impl, filter);
7822
7823   show_filters (impl, TRUE);
7824 }
7825
7826 static void
7827 gtk_file_chooser_default_remove_filter (GtkFileChooser *chooser,
7828                                         GtkFileFilter  *filter)
7829 {
7830   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7831   GtkTreeModel *model;
7832   GtkTreeIter iter;
7833   gint filter_index;
7834
7835   filter_index = g_slist_index (impl->filters, filter);
7836
7837   if (filter_index < 0)
7838     {
7839       g_warning ("gtk_file_chooser_remove_filter() called on filter not in list\n");
7840       return;
7841     }
7842
7843   impl->filters = g_slist_remove (impl->filters, filter);
7844
7845   if (filter == impl->current_filter)
7846     {
7847       if (impl->filters)
7848         set_current_filter (impl, impl->filters->data);
7849       else
7850         set_current_filter (impl, NULL);
7851     }
7852
7853   /* Remove row from the combo box */
7854   model = gtk_combo_box_get_model (GTK_COMBO_BOX (impl->filter_combo));
7855   if (!gtk_tree_model_iter_nth_child  (model, &iter, NULL, filter_index))
7856     g_assert_not_reached ();
7857
7858   gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
7859
7860   g_object_unref (filter);
7861
7862   if (!impl->filters)
7863     show_filters (impl, FALSE);
7864 }
7865
7866 static GSList *
7867 gtk_file_chooser_default_list_filters (GtkFileChooser *chooser)
7868 {
7869   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7870
7871   return g_slist_copy (impl->filters);
7872 }
7873
7874 /* Returns the position in the shortcuts tree where the nth specified shortcut would appear */
7875 static int
7876 shortcuts_get_pos_for_shortcut_folder (GtkFileChooserDefault *impl,
7877                                        int                    pos)
7878 {
7879   return pos + shortcuts_get_index (impl, SHORTCUTS_SHORTCUTS);
7880 }
7881
7882 struct AddShortcutData
7883 {
7884   GtkFileChooserDefault *impl;
7885   GFile *file;
7886 };
7887
7888 static void
7889 add_shortcut_get_info_cb (GCancellable *cancellable,
7890                           GFileInfo    *info,
7891                           const GError *error,
7892                           gpointer      user_data)
7893 {
7894   int pos;
7895   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
7896   struct AddShortcutData *data = user_data;
7897
7898   if (!g_slist_find (data->impl->loading_shortcuts, cancellable))
7899     goto out;
7900
7901   data->impl->loading_shortcuts = g_slist_remove (data->impl->loading_shortcuts, cancellable);
7902
7903   if (cancelled || error || (! _gtk_file_info_consider_as_directory (info)))
7904     goto out;
7905
7906   pos = shortcuts_get_pos_for_shortcut_folder (data->impl, data->impl->num_shortcuts);
7907
7908   shortcuts_insert_file (data->impl, pos, SHORTCUT_TYPE_FILE, NULL, data->file, NULL, FALSE, SHORTCUTS_SHORTCUTS);
7909
7910   /* need to call shortcuts_add_bookmarks to flush out any duplicates bug #577806 */
7911   shortcuts_add_bookmarks (data->impl);
7912
7913 out:
7914   g_object_unref (data->impl);
7915   g_object_unref (data->file);
7916   g_free (data);
7917
7918   g_object_unref (cancellable);
7919 }
7920
7921 static gboolean
7922 gtk_file_chooser_default_add_shortcut_folder (GtkFileChooser  *chooser,
7923                                               GFile           *file,
7924                                               GError         **error)
7925 {
7926   GCancellable *cancellable;
7927   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7928   struct AddShortcutData *data;
7929   GSList *l;
7930   int pos;
7931
7932   /* Avoid adding duplicates */
7933   pos = shortcut_find_position (impl, file);
7934   if (pos >= 0 && pos < shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS_SEPARATOR))
7935     {
7936       gchar *uri;
7937
7938       uri = g_file_get_uri (file);
7939       /* translators, "Shortcut" means "Bookmark" here */
7940       g_set_error (error,
7941                    GTK_FILE_CHOOSER_ERROR,
7942                    GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
7943                    _("Shortcut %s already exists"),
7944                    uri);
7945       g_free (uri);
7946
7947       return FALSE;
7948     }
7949
7950   for (l = impl->loading_shortcuts; l; l = l->next)
7951     {
7952       GCancellable *c = l->data;
7953       GFile *f;
7954
7955       f = g_object_get_data (G_OBJECT (c), "add-shortcut-path-key");
7956       if (f && g_file_equal (file, f))
7957         {
7958           gchar *uri;
7959
7960           uri = g_file_get_uri (file);
7961           g_set_error (error,
7962                        GTK_FILE_CHOOSER_ERROR,
7963                        GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
7964                        _("Shortcut %s already exists"),
7965                        uri);
7966           g_free (uri);
7967
7968           return FALSE;
7969         }
7970     }
7971
7972   data = g_new0 (struct AddShortcutData, 1);
7973   data->impl = g_object_ref (impl);
7974   data->file = g_object_ref (file);
7975
7976   cancellable = _gtk_file_system_get_info (impl->file_system, file,
7977                                            "standard::type",
7978                                            add_shortcut_get_info_cb, data);
7979
7980   if (!cancellable)
7981     return FALSE;
7982
7983   impl->loading_shortcuts = g_slist_append (impl->loading_shortcuts, cancellable);
7984   g_object_set_data (G_OBJECT (cancellable), "add-shortcut-path-key", data->file);
7985
7986   return TRUE;
7987 }
7988
7989 static gboolean
7990 gtk_file_chooser_default_remove_shortcut_folder (GtkFileChooser  *chooser,
7991                                                  GFile           *file,
7992                                                  GError         **error)
7993 {
7994   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7995   int pos;
7996   GtkTreeIter iter;
7997   GSList *l;
7998   char *uri;
7999   int i;
8000
8001   for (l = impl->loading_shortcuts; l; l = l->next)
8002     {
8003       GCancellable *c = l->data;
8004       GFile *f;
8005
8006       f = g_object_get_data (G_OBJECT (c), "add-shortcut-path-key");
8007       if (f && g_file_equal (file, f))
8008         {
8009           impl->loading_shortcuts = g_slist_remove (impl->loading_shortcuts, c);
8010           g_cancellable_cancel (c);
8011           return TRUE;
8012         }
8013     }
8014
8015   if (impl->num_shortcuts == 0)
8016     goto out;
8017
8018   pos = shortcuts_get_pos_for_shortcut_folder (impl, 0);
8019   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
8020     g_assert_not_reached ();
8021
8022   for (i = 0; i < impl->num_shortcuts; i++)
8023     {
8024       gpointer col_data;
8025       ShortcutType shortcut_type;
8026       GFile *shortcut;
8027
8028       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
8029                           SHORTCUTS_COL_DATA, &col_data,
8030                           SHORTCUTS_COL_TYPE, &shortcut_type,
8031                           -1);
8032       g_assert (col_data != NULL);
8033       g_assert (shortcut_type == SHORTCUT_TYPE_FILE);
8034
8035       shortcut = col_data;
8036       if (g_file_equal (shortcut, file))
8037         {
8038           shortcuts_remove_rows (impl, pos + i, 1);
8039           impl->num_shortcuts--;
8040           return TRUE;
8041         }
8042
8043       if (!gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
8044         g_assert_not_reached ();
8045     }
8046
8047  out:
8048
8049   uri = g_file_get_uri (file);
8050   /* translators, "Shortcut" means "Bookmark" here */
8051   g_set_error (error,
8052                GTK_FILE_CHOOSER_ERROR,
8053                GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
8054                _("Shortcut %s does not exist"),
8055                uri);
8056   g_free (uri);
8057
8058   return FALSE;
8059 }
8060
8061 static GSList *
8062 gtk_file_chooser_default_list_shortcut_folders (GtkFileChooser *chooser)
8063 {
8064   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
8065   int pos;
8066   GtkTreeIter iter;
8067   int i;
8068   GSList *list;
8069
8070   if (impl->num_shortcuts == 0)
8071     return NULL;
8072
8073   pos = shortcuts_get_pos_for_shortcut_folder (impl, 0);
8074   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
8075     g_assert_not_reached ();
8076
8077   list = NULL;
8078
8079   for (i = 0; i < impl->num_shortcuts; i++)
8080     {
8081       gpointer col_data;
8082       ShortcutType shortcut_type;
8083       GFile *shortcut;
8084
8085       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
8086                           SHORTCUTS_COL_DATA, &col_data,
8087                           SHORTCUTS_COL_TYPE, &shortcut_type,
8088                           -1);
8089       g_assert (col_data != NULL);
8090       g_assert (shortcut_type == SHORTCUT_TYPE_FILE);
8091
8092       shortcut = col_data;
8093       list = g_slist_prepend (list, g_object_ref (shortcut));
8094
8095       if (i != impl->num_shortcuts - 1)
8096         {
8097           if (!gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
8098             g_assert_not_reached ();
8099         }
8100     }
8101
8102   return g_slist_reverse (list);
8103 }
8104
8105 /* Guesses a size based upon font sizes */
8106 static void
8107 find_good_size_from_style (GtkWidget *widget,
8108                            gint      *width,
8109                            gint      *height)
8110 {
8111   GtkStyleContext *context;
8112   GtkStateFlags state;
8113   double font_size;
8114   GdkScreen *screen;
8115   double resolution;
8116
8117   context = gtk_widget_get_style_context (widget);
8118   state = gtk_widget_get_state_flags (widget);
8119
8120   screen = gtk_widget_get_screen (widget);
8121   if (screen)
8122     {
8123       resolution = gdk_screen_get_resolution (screen);
8124       if (resolution < 0.0) /* will be -1 if the resolution is not defined in the GdkScreen */
8125         resolution = 96.0;
8126     }
8127   else
8128     resolution = 96.0; /* wheeee */
8129
8130   gtk_style_context_get (context, state, "font-size", &font_size, NULL);
8131   font_size = font_size * resolution / 72.0 + 0.5;
8132
8133   *width = font_size * NUM_CHARS;
8134   *height = font_size * NUM_LINES;
8135 }
8136
8137 static void
8138 gtk_file_chooser_default_get_default_size (GtkFileChooserEmbed *chooser_embed,
8139                                            gint                *default_width,
8140                                            gint                *default_height)
8141 {
8142   GtkFileChooserDefault *impl;
8143   GtkRequisition req;
8144   int x, y, width, height;
8145   GSettings *settings;
8146
8147   impl = GTK_FILE_CHOOSER_DEFAULT (chooser_embed);
8148
8149   settings = _gtk_file_chooser_get_settings_for_widget (GTK_WIDGET (impl));
8150
8151   g_settings_get (settings, SETTINGS_KEY_WINDOW_POSITION, "(ii)", &x, &y);
8152   g_settings_get (settings, SETTINGS_KEY_WINDOW_SIZE, "(ii)", &width, &height);
8153
8154   if (x >= 0 && y >= 0 && width > 0 && height > 0)
8155     {
8156       *default_width = width;
8157       *default_height = height;
8158       return;
8159     }
8160
8161   find_good_size_from_style (GTK_WIDGET (chooser_embed), default_width, default_height);
8162
8163   if (impl->preview_widget_active &&
8164       impl->preview_widget &&
8165       gtk_widget_get_visible (impl->preview_widget))
8166     {
8167       gtk_widget_get_preferred_size (impl->preview_box,
8168                                      &req, NULL);
8169       *default_width += PREVIEW_HBOX_SPACING + req.width;
8170     }
8171
8172   if (impl->extra_widget &&
8173       gtk_widget_get_visible (impl->extra_widget))
8174     {
8175       gtk_widget_get_preferred_size (impl->extra_align,
8176                                      &req, NULL);
8177       *default_height += gtk_box_get_spacing (GTK_BOX (chooser_embed)) + req.height;
8178     }
8179 }
8180
8181 struct switch_folder_closure {
8182   GtkFileChooserDefault *impl;
8183   GFile *file;
8184   int num_selected;
8185 };
8186
8187 /* Used from gtk_tree_selection_selected_foreach() in switch_to_selected_folder() */
8188 static void
8189 switch_folder_foreach_cb (GtkTreeModel      *model,
8190                           GtkTreePath       *path,
8191                           GtkTreeIter       *iter,
8192                           gpointer           data)
8193 {
8194   struct switch_folder_closure *closure;
8195
8196   closure = data;
8197
8198   closure->file = _gtk_file_system_model_get_file (closure->impl->browse_files_model, iter);
8199   closure->num_selected++;
8200 }
8201
8202 /* Changes to the selected folder in the list view */
8203 static void
8204 switch_to_selected_folder (GtkFileChooserDefault *impl)
8205 {
8206   GtkTreeSelection *selection;
8207   struct switch_folder_closure closure;
8208
8209   /* We do this with foreach() rather than get_selected() as we may be in
8210    * multiple selection mode
8211    */
8212
8213   closure.impl = impl;
8214   closure.file = NULL;
8215   closure.num_selected = 0;
8216
8217   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
8218   gtk_tree_selection_selected_foreach (selection, switch_folder_foreach_cb, &closure);
8219
8220   g_assert (closure.file && closure.num_selected == 1);
8221
8222   change_folder_and_display_error (impl, closure.file, FALSE);
8223 }
8224
8225 /* Gets the GFileInfo for the selected row in the file list; assumes single
8226  * selection mode.
8227  */
8228 static GFileInfo *
8229 get_selected_file_info_from_file_list (GtkFileChooserDefault *impl,
8230                                        gboolean              *had_selection)
8231 {
8232   GtkTreeSelection *selection;
8233   GtkTreeIter iter;
8234   GFileInfo *info;
8235
8236   g_assert (!impl->select_multiple);
8237   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
8238   if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
8239     {
8240       *had_selection = FALSE;
8241       return NULL;
8242     }
8243
8244   *had_selection = TRUE;
8245
8246   info = _gtk_file_system_model_get_info (impl->browse_files_model, &iter);
8247   return info;
8248 }
8249
8250 /* Gets the display name of the selected file in the file list; assumes single
8251  * selection mode and that something is selected.
8252  */
8253 static const gchar *
8254 get_display_name_from_file_list (GtkFileChooserDefault *impl)
8255 {
8256   GFileInfo *info;
8257   gboolean had_selection;
8258
8259   info = get_selected_file_info_from_file_list (impl, &had_selection);
8260   g_assert (had_selection);
8261   g_assert (info != NULL);
8262
8263   return g_file_info_get_display_name (info);
8264 }
8265
8266 static void
8267 add_custom_button_to_dialog (GtkDialog   *dialog,
8268                              const gchar *mnemonic_label,
8269                              const gchar *stock_id,
8270                              gint         response_id)
8271 {
8272   GtkWidget *button;
8273
8274   button = gtk_button_new_with_mnemonic (mnemonic_label);
8275   gtk_widget_set_can_default (button, TRUE);
8276   gtk_button_set_image (GTK_BUTTON (button),
8277                         gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON));
8278   gtk_widget_show (button);
8279
8280   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, response_id);
8281 }
8282
8283 /* Presents an overwrite confirmation dialog; returns whether we should accept
8284  * the filename.
8285  */
8286 static gboolean
8287 confirm_dialog_should_accept_filename (GtkFileChooserDefault *impl,
8288                                        const gchar           *file_part,
8289                                        const gchar           *folder_display_name)
8290 {
8291   GtkWindow *toplevel;
8292   GtkWidget *dialog;
8293   int response;
8294
8295   toplevel = get_toplevel (GTK_WIDGET (impl));
8296
8297   dialog = gtk_message_dialog_new (toplevel,
8298                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
8299                                    GTK_MESSAGE_QUESTION,
8300                                    GTK_BUTTONS_NONE,
8301                                    _("A file named \"%s\" already exists.  Do you want to replace it?"),
8302                                    file_part);
8303   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
8304                                             _("The file already exists in \"%s\".  Replacing it will "
8305                                               "overwrite its contents."),
8306                                             folder_display_name);
8307
8308   gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
8309   add_custom_button_to_dialog (GTK_DIALOG (dialog), _("_Replace"),
8310                                GTK_STOCK_SAVE_AS, GTK_RESPONSE_ACCEPT);
8311   gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
8312                                            GTK_RESPONSE_ACCEPT,
8313                                            GTK_RESPONSE_CANCEL,
8314                                            -1);
8315   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
8316
8317   if (gtk_window_has_group (toplevel))
8318     gtk_window_group_add_window (gtk_window_get_group (toplevel),
8319                                  GTK_WINDOW (dialog));
8320
8321   response = gtk_dialog_run (GTK_DIALOG (dialog));
8322
8323   gtk_widget_destroy (dialog);
8324
8325   return (response == GTK_RESPONSE_ACCEPT);
8326 }
8327
8328 struct GetDisplayNameData
8329 {
8330   GtkFileChooserDefault *impl;
8331   gchar *file_part;
8332 };
8333
8334 /* Every time we request a response explicitly, we need to save the selection to the recently-used list,
8335  * as requesting a response means, "the dialog is confirmed".
8336  */
8337 static void
8338 request_response_and_add_to_recent_list (GtkFileChooserDefault *impl)
8339 {
8340   g_signal_emit_by_name (impl, "response-requested");
8341   add_selection_to_recent_list (impl);
8342 }
8343
8344 static void
8345 confirmation_confirm_get_info_cb (GCancellable *cancellable,
8346                                   GFileInfo    *info,
8347                                   const GError *error,
8348                                   gpointer      user_data)
8349 {
8350   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
8351   gboolean should_respond = FALSE;
8352   struct GetDisplayNameData *data = user_data;
8353
8354   if (cancellable != data->impl->should_respond_get_info_cancellable)
8355     goto out;
8356
8357   data->impl->should_respond_get_info_cancellable = NULL;
8358
8359   if (cancelled)
8360     goto out;
8361
8362   if (error)
8363     /* Huh?  Did the folder disappear?  Let the caller deal with it */
8364     should_respond = TRUE;
8365   else
8366     should_respond = confirm_dialog_should_accept_filename (data->impl, data->file_part, g_file_info_get_display_name (info));
8367
8368   set_busy_cursor (data->impl, FALSE);
8369   if (should_respond)
8370     request_response_and_add_to_recent_list (data->impl);
8371
8372 out:
8373   g_object_unref (data->impl);
8374   g_free (data->file_part);
8375   g_free (data);
8376
8377   g_object_unref (cancellable);
8378 }
8379
8380 /* Does overwrite confirmation if appropriate, and returns whether the dialog
8381  * should respond.  Can get the file part from the file list or the save entry.
8382  */
8383 static gboolean
8384 should_respond_after_confirm_overwrite (GtkFileChooserDefault *impl,
8385                                         const gchar           *file_part,
8386                                         GFile                 *parent_file)
8387 {
8388   GtkFileChooserConfirmation conf;
8389
8390   if (!impl->do_overwrite_confirmation)
8391     return TRUE;
8392
8393   conf = GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM;
8394
8395   g_signal_emit_by_name (impl, "confirm-overwrite", &conf);
8396
8397   switch (conf)
8398     {
8399     case GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM:
8400       {
8401         struct GetDisplayNameData *data;
8402
8403         g_assert (file_part != NULL);
8404
8405         data = g_new0 (struct GetDisplayNameData, 1);
8406         data->impl = g_object_ref (impl);
8407         data->file_part = g_strdup (file_part);
8408
8409         if (impl->should_respond_get_info_cancellable)
8410           g_cancellable_cancel (impl->should_respond_get_info_cancellable);
8411
8412         impl->should_respond_get_info_cancellable =
8413           _gtk_file_system_get_info (impl->file_system, parent_file,
8414                                      "standard::display-name",
8415                                      confirmation_confirm_get_info_cb,
8416                                      data);
8417         set_busy_cursor (data->impl, TRUE);
8418         return FALSE;
8419       }
8420
8421     case GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME:
8422       return TRUE;
8423
8424     case GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN:
8425       return FALSE;
8426
8427     default:
8428       g_assert_not_reached ();
8429       return FALSE;
8430     }
8431 }
8432
8433 struct FileExistsData
8434 {
8435   GtkFileChooserDefault *impl;
8436   gboolean file_exists_and_is_not_folder;
8437   GFile *parent_file;
8438   GFile *file;
8439 };
8440
8441 static void
8442 name_entry_get_parent_info_cb (GCancellable *cancellable,
8443                                GFileInfo    *info,
8444                                const GError *error,
8445                                gpointer      user_data)
8446 {
8447   gboolean parent_is_folder;
8448   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
8449   struct FileExistsData *data = user_data;
8450
8451   if (cancellable != data->impl->should_respond_get_info_cancellable)
8452     goto out;
8453
8454   data->impl->should_respond_get_info_cancellable = NULL;
8455
8456   set_busy_cursor (data->impl, FALSE);
8457
8458   if (cancelled)
8459     goto out;
8460
8461   if (!info)
8462     parent_is_folder = FALSE;
8463   else
8464     parent_is_folder = _gtk_file_info_consider_as_directory (info);
8465
8466   if (parent_is_folder)
8467     {
8468       if (data->impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
8469         {
8470           request_response_and_add_to_recent_list (data->impl); /* even if the file doesn't exist, apps can make good use of that (e.g. Emacs) */
8471         }
8472       else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8473         {
8474           if (data->file_exists_and_is_not_folder)
8475             {
8476               gboolean retval;
8477               char *file_part;
8478
8479               /* Dup the string because the string may be modified
8480                * depending on what clients do in the confirm-overwrite
8481                * signal and this corrupts the pointer
8482                */
8483               file_part = g_strdup (_gtk_file_chooser_entry_get_file_part (GTK_FILE_CHOOSER_ENTRY (data->impl->location_entry)));
8484               retval = should_respond_after_confirm_overwrite (data->impl, file_part, data->parent_file);
8485               g_free (file_part);
8486
8487               if (retval)
8488                 request_response_and_add_to_recent_list (data->impl);
8489             }
8490           else
8491             request_response_and_add_to_recent_list (data->impl);
8492         }
8493       else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
8494                || data->impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8495         {
8496           GError *mkdir_error = NULL;
8497
8498           /* In both cases (SELECT_FOLDER and CREATE_FOLDER), if you type
8499            * "/blah/nonexistent" you *will* want a folder created.
8500            */
8501
8502           set_busy_cursor (data->impl, TRUE);
8503           g_file_make_directory (data->file, NULL, &mkdir_error);
8504           set_busy_cursor (data->impl, FALSE);
8505
8506           if (!mkdir_error)
8507             request_response_and_add_to_recent_list (data->impl);
8508           else
8509             error_creating_folder_dialog (data->impl, data->file, mkdir_error);
8510         }
8511       else
8512         g_assert_not_reached ();
8513     }
8514   else
8515     {
8516       if (info)
8517         {
8518           /* The parent exists, but it's not a folder!  Someone probably typed existing_file.txt/subfile.txt */
8519           error_with_file_under_nonfolder (data->impl, data->parent_file);
8520         }
8521       else
8522         {
8523           GError *error_copy;
8524
8525           /* The parent folder is not readable for some reason */
8526
8527           error_copy = g_error_copy (error);
8528           error_changing_folder_dialog (data->impl, data->parent_file, error_copy);
8529         }
8530     }
8531
8532 out:
8533   g_object_unref (data->impl);
8534   g_object_unref (data->file);
8535   g_object_unref (data->parent_file);
8536   g_free (data);
8537
8538   g_object_unref (cancellable);
8539 }
8540
8541 static void
8542 file_exists_get_info_cb (GCancellable *cancellable,
8543                          GFileInfo    *info,
8544                          const GError *error,
8545                          gpointer      user_data)
8546 {
8547   gboolean data_ownership_taken = FALSE;
8548   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
8549   gboolean file_exists;
8550   gboolean is_folder;
8551   gboolean needs_parent_check = FALSE;
8552   struct FileExistsData *data = user_data;
8553
8554   if (cancellable != data->impl->file_exists_get_info_cancellable)
8555     goto out;
8556
8557   data->impl->file_exists_get_info_cancellable = NULL;
8558
8559   set_busy_cursor (data->impl, FALSE);
8560
8561   if (cancelled)
8562     goto out;
8563
8564   file_exists = (info != NULL);
8565   is_folder = (file_exists && _gtk_file_info_consider_as_directory (info));
8566
8567   if (data->impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
8568     {
8569       if (is_folder)
8570         change_folder_and_display_error (data->impl, data->file, TRUE);
8571       else
8572         {
8573           if (file_exists)
8574             request_response_and_add_to_recent_list (data->impl); /* user typed an existing filename; we are done */
8575           else
8576             needs_parent_check = TRUE; /* file doesn't exist; see if its parent exists */
8577         }
8578     }
8579   else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8580     {
8581       if (file_exists && !is_folder)
8582         {
8583           /* Oops, the user typed the name of an existing path which is not
8584            * a folder
8585            */
8586           error_creating_folder_over_existing_file_dialog (data->impl, data->file,
8587                                                            g_error_copy (error));
8588         }
8589       else
8590         {
8591           needs_parent_check = TRUE;
8592         }
8593     }
8594   else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
8595     {
8596       if (!file_exists)
8597         {
8598           needs_parent_check = TRUE;
8599         }
8600       else
8601         {
8602           if (is_folder)
8603             {
8604               /* User typed a folder; we are done */
8605               request_response_and_add_to_recent_list (data->impl);
8606             }
8607           else
8608             error_selecting_folder_over_existing_file_dialog (data->impl, data->file);
8609         }
8610     }
8611   else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8612     {
8613       if (is_folder)
8614         change_folder_and_display_error (data->impl, data->file, TRUE);
8615       else
8616         needs_parent_check = TRUE;
8617     }
8618   else
8619     {
8620       g_assert_not_reached();
8621     }
8622
8623   if (needs_parent_check) {
8624     /* check that everything up to the last path component exists (i.e. the parent) */
8625
8626     data->file_exists_and_is_not_folder = file_exists && !is_folder;
8627     data_ownership_taken = TRUE;
8628
8629     if (data->impl->should_respond_get_info_cancellable)
8630       g_cancellable_cancel (data->impl->should_respond_get_info_cancellable);
8631
8632       data->impl->should_respond_get_info_cancellable =
8633         _gtk_file_system_get_info (data->impl->file_system,
8634                                    data->parent_file,
8635                                    "standard::type",
8636                                    name_entry_get_parent_info_cb,
8637                                    data);
8638       set_busy_cursor (data->impl, TRUE);
8639     }
8640
8641 out:
8642   if (!data_ownership_taken)
8643     {
8644       g_object_unref (data->impl);
8645       g_object_unref (data->file);
8646       g_object_unref (data->parent_file);
8647       g_free (data);
8648     }
8649
8650   g_object_unref (cancellable);
8651 }
8652
8653 static void
8654 paste_text_received (GtkClipboard          *clipboard,
8655                      const gchar           *text,
8656                      GtkFileChooserDefault *impl)
8657 {
8658   GFile *file;
8659
8660   if (!text)
8661     return;
8662
8663   file = g_file_new_for_uri (text);
8664
8665   if (!gtk_file_chooser_default_select_file (GTK_FILE_CHOOSER (impl), file, NULL))
8666     location_popup_handler (impl, text);
8667
8668   g_object_unref (file);
8669 }
8670
8671 /* Handler for the "location-popup-on-paste" keybinding signal */
8672 static void
8673 location_popup_on_paste_handler (GtkFileChooserDefault *impl)
8674 {
8675   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (impl),
8676                                                       GDK_SELECTION_CLIPBOARD);
8677   gtk_clipboard_request_text (clipboard,
8678                               (GtkClipboardTextReceivedFunc) paste_text_received,
8679                               impl);
8680 }
8681
8682 /* Implementation for GtkFileChooserEmbed::should_respond() */
8683 static void
8684 add_selection_to_recent_list (GtkFileChooserDefault *impl)
8685 {
8686   GSList *files;
8687   GSList *l;
8688
8689   files = gtk_file_chooser_default_get_files (GTK_FILE_CHOOSER (impl));
8690
8691   for (l = files; l; l = l->next)
8692     {
8693       GFile *file = l->data;
8694       char *uri;
8695
8696       uri = g_file_get_uri (file);
8697       if (uri)
8698         {
8699           gtk_recent_manager_add_item (impl->recent_manager, uri);
8700           g_free (uri);
8701         }
8702     }
8703
8704   g_slist_foreach (files, (GFunc) g_object_unref, NULL);
8705   g_slist_free (files);
8706 }
8707
8708 static gboolean
8709 gtk_file_chooser_default_should_respond (GtkFileChooserEmbed *chooser_embed)
8710 {
8711   GtkFileChooserDefault *impl;
8712   GtkWidget *toplevel;
8713   GtkWidget *current_focus;
8714   gboolean retval;
8715
8716   impl = GTK_FILE_CHOOSER_DEFAULT (chooser_embed);
8717
8718   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
8719   g_assert (GTK_IS_WINDOW (toplevel));
8720
8721   retval = FALSE;
8722
8723   current_focus = gtk_window_get_focus (GTK_WINDOW (toplevel));
8724
8725   if (current_focus == impl->browse_files_tree_view)
8726     {
8727       /* The following array encodes what we do based on the impl->action and the
8728        * number of files selected.
8729        */
8730       typedef enum {
8731         NOOP,                   /* Do nothing (don't respond) */
8732         RESPOND,                /* Respond immediately */
8733         RESPOND_OR_SWITCH,      /* Respond immediately if the selected item is a file; switch to it if it is a folder */
8734         ALL_FILES,              /* Respond only if everything selected is a file */
8735         ALL_FOLDERS,            /* Respond only if everything selected is a folder */
8736         SAVE_ENTRY,             /* Go to the code for handling the save entry */
8737         NOT_REACHED             /* Sanity check */
8738       } ActionToTake;
8739       static const ActionToTake what_to_do[4][3] = {
8740         /*                                0 selected            1 selected              many selected */
8741         /* ACTION_OPEN */               { NOOP,                 RESPOND_OR_SWITCH,      ALL_FILES   },
8742         /* ACTION_SAVE */               { SAVE_ENTRY,           RESPOND_OR_SWITCH,      NOT_REACHED },
8743         /* ACTION_SELECT_FOLDER */      { RESPOND,              ALL_FOLDERS,            ALL_FOLDERS },
8744         /* ACTION_CREATE_FOLDER */      { SAVE_ENTRY,           ALL_FOLDERS,            NOT_REACHED }
8745       };
8746
8747       int num_selected;
8748       gboolean all_files, all_folders;
8749       int k;
8750       ActionToTake action;
8751
8752     file_list:
8753
8754       g_assert (impl->action >= GTK_FILE_CHOOSER_ACTION_OPEN && impl->action <= GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER);
8755
8756       if (impl->operation_mode == OPERATION_MODE_SEARCH)
8757         {
8758           retval = search_should_respond (impl);
8759           goto out;
8760         }
8761
8762       if (impl->operation_mode == OPERATION_MODE_RECENT)
8763         {
8764           if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8765             goto save_entry;
8766           else
8767             {
8768               retval = recent_should_respond (impl);
8769               goto out;
8770             }
8771         }
8772
8773       selection_check (impl, &num_selected, &all_files, &all_folders);
8774
8775       if (num_selected > 2)
8776         k = 2;
8777       else
8778         k = num_selected;
8779
8780       action = what_to_do [impl->action] [k];
8781
8782       switch (action)
8783         {
8784         case NOOP:
8785           return FALSE;
8786
8787         case RESPOND:
8788           retval = TRUE;
8789           goto out;
8790
8791         case RESPOND_OR_SWITCH:
8792           g_assert (num_selected == 1);
8793
8794           if (all_folders)
8795             {
8796               switch_to_selected_folder (impl);
8797               return FALSE;
8798             }
8799           else if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8800             {
8801               retval = should_respond_after_confirm_overwrite (impl,
8802                                                                get_display_name_from_file_list (impl),
8803                                                                impl->current_folder);
8804               goto out;
8805             }
8806           else
8807             {
8808               retval = TRUE;
8809               goto out;
8810             }
8811
8812         case ALL_FILES:
8813           retval = all_files;
8814           goto out;
8815
8816         case ALL_FOLDERS:
8817           retval = all_folders;
8818           goto out;
8819
8820         case SAVE_ENTRY:
8821           goto save_entry;
8822
8823         default:
8824           g_assert_not_reached ();
8825         }
8826     }
8827   else if ((impl->location_entry != NULL) && (current_focus == impl->location_entry))
8828     {
8829       GFile *file;
8830       gboolean is_well_formed, is_empty, is_file_part_empty;
8831       gboolean is_folder;
8832       GtkFileChooserEntry *entry;
8833       GError *error;
8834
8835     save_entry:
8836
8837       g_assert (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8838                 || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
8839                 || ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
8840                      || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
8841                     && impl->location_mode == LOCATION_MODE_FILENAME_ENTRY));
8842
8843       entry = GTK_FILE_CHOOSER_ENTRY (impl->location_entry);
8844       check_save_entry (impl, &file, &is_well_formed, &is_empty, &is_file_part_empty, &is_folder);
8845
8846       if (!is_well_formed)
8847         {
8848           if (!is_empty
8849               && impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8850               && impl->operation_mode == OPERATION_MODE_RECENT)
8851             {
8852               path_bar_set_mode (impl, PATH_BAR_ERROR_NO_FOLDER);
8853 #if 0
8854               /* We'll #ifdef this out, as the fucking treeview selects its first row,
8855                * thus changing our assumption that no selection is present - setting
8856                * a selection causes the error message from path_bar_set_mode() to go away,
8857                * but we want the user to see that message!
8858                */
8859               gtk_widget_grab_focus (impl->browse_files_tree_view);
8860 #endif
8861             }
8862           /* FIXME: else show an "invalid filename" error as the pathbar mode? */
8863
8864           return FALSE;
8865         }
8866
8867       if (is_empty)
8868         {
8869           if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8870               || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8871             {
8872               path_bar_set_mode (impl, PATH_BAR_ERROR_NO_FILENAME);
8873               gtk_widget_grab_focus (impl->location_entry);
8874               return FALSE;
8875             }
8876
8877           goto file_list;
8878         }
8879
8880       g_assert (file != NULL);
8881
8882       error = NULL;
8883       if (is_folder)
8884         {
8885           if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
8886               impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8887             {
8888               change_folder_and_display_error (impl, file, TRUE);
8889             }
8890           else if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
8891                    impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8892             {
8893               /* The folder already exists, so we do not need to create it.
8894                * Just respond to terminate the dialog.
8895                */
8896               retval = TRUE;
8897             }
8898           else
8899             {
8900               g_assert_not_reached ();
8901             }
8902         }
8903       else
8904         {
8905           struct FileExistsData *data;
8906
8907           /* We need to check whether file exists and whether it is a folder -
8908            * the GtkFileChooserEntry *does* report is_folder==FALSE as a false
8909            * negative (it doesn't know yet if your last path component is a
8910            * folder).
8911            */
8912
8913           data = g_new0 (struct FileExistsData, 1);
8914           data->impl = g_object_ref (impl);
8915           data->file = g_object_ref (file);
8916           data->parent_file = _gtk_file_chooser_entry_get_current_folder (entry);
8917
8918           if (impl->file_exists_get_info_cancellable)
8919             g_cancellable_cancel (impl->file_exists_get_info_cancellable);
8920
8921           impl->file_exists_get_info_cancellable =
8922             _gtk_file_system_get_info (impl->file_system, file,
8923                                        "standard::type",
8924                                        file_exists_get_info_cb,
8925                                        data);
8926
8927           set_busy_cursor (impl, TRUE);
8928
8929           if (error != NULL)
8930             g_error_free (error);
8931         }
8932
8933       g_object_unref (file);
8934     }
8935   else if (impl->toplevel_last_focus_widget == impl->browse_files_tree_view)
8936     {
8937       /* The focus is on a dialog's action area button, *and* the widget that
8938        * was focused immediately before it is the file list.
8939        */
8940       goto file_list;
8941     }
8942   else if (impl->operation_mode == OPERATION_MODE_SEARCH && impl->toplevel_last_focus_widget == impl->search_entry)
8943     {
8944       search_entry_activate_cb (GTK_ENTRY (impl->search_entry), impl);
8945       return FALSE;
8946     }
8947   else if (impl->location_entry && impl->toplevel_last_focus_widget == impl->location_entry)
8948     {
8949       /* The focus is on a dialog's action area button, *and* the widget that
8950        * was focused immediately before it is the location entry.
8951        */
8952       goto save_entry;
8953     }
8954   else
8955     /* The focus is on a dialog's action area button or something else */
8956     if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8957         || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8958       goto save_entry;
8959     else
8960       goto file_list;
8961
8962  out:
8963
8964   if (retval)
8965     add_selection_to_recent_list (impl);
8966
8967   return retval;
8968 }
8969
8970 /* Implementation for GtkFileChooserEmbed::initial_focus() */
8971 static void
8972 gtk_file_chooser_default_initial_focus (GtkFileChooserEmbed *chooser_embed)
8973 {
8974   GtkFileChooserDefault *impl;
8975   GtkWidget *widget;
8976
8977   impl = GTK_FILE_CHOOSER_DEFAULT (chooser_embed);
8978
8979   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
8980       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
8981     {
8982       if (impl->location_mode == LOCATION_MODE_PATH_BAR
8983           || impl->operation_mode == OPERATION_MODE_RECENT)
8984         widget = impl->browse_files_tree_view;
8985       else
8986         widget = impl->location_entry;
8987     }
8988   else if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
8989            impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8990     widget = impl->location_entry;
8991   else
8992     {
8993       g_assert_not_reached ();
8994       widget = NULL;
8995     }
8996
8997   g_assert (widget != NULL);
8998   gtk_widget_grab_focus (widget);
8999 }
9000
9001 /* Callback used from gtk_tree_selection_selected_foreach(); gets the selected GFiles */
9002 static void
9003 search_selected_foreach_get_file_cb (GtkTreeModel *model,
9004                                      GtkTreePath  *path,
9005                                      GtkTreeIter  *iter,
9006                                      gpointer      data)
9007 {
9008   GSList **list;
9009   GFile *file;
9010
9011   list = data;
9012
9013   gtk_tree_model_get (model, iter, MODEL_COL_FILE, &file, -1);
9014   *list = g_slist_prepend (*list, file); /* The file already has a new ref courtesy of gtk_tree_model_get(); this will be unreffed by the caller */
9015 }
9016
9017 /* Constructs a list of the selected paths in search mode */
9018 static GSList *
9019 search_get_selected_files (GtkFileChooserDefault *impl)
9020 {
9021   GSList *result;
9022   GtkTreeSelection *selection;
9023
9024   result = NULL;
9025
9026   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9027   gtk_tree_selection_selected_foreach (selection, search_selected_foreach_get_file_cb, &result);
9028   result = g_slist_reverse (result);
9029
9030   return result;
9031 }
9032
9033 /* Called from ::should_respond().  We return whether there are selected files
9034  * in the search list.
9035  */
9036 static gboolean
9037 search_should_respond (GtkFileChooserDefault *impl)
9038 {
9039   GtkTreeSelection *selection;
9040
9041   g_assert (impl->operation_mode == OPERATION_MODE_SEARCH);
9042
9043   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9044   return (gtk_tree_selection_count_selected_rows (selection) != 0);
9045 }
9046
9047 /* Adds one hit from the search engine to the search_model */
9048 static void
9049 search_add_hit (GtkFileChooserDefault *impl,
9050                 gchar                 *uri)
9051 {
9052   GFile *file;
9053
9054   file = g_file_new_for_uri (uri);
9055   if (!file)
9056     return;
9057
9058   if (!g_file_is_native (file))
9059     {
9060       g_object_unref (file);
9061       return;
9062     }
9063
9064   _gtk_file_system_model_add_and_query_file (impl->search_model,
9065                                              file,
9066                                              MODEL_ATTRIBUTES);
9067
9068   g_object_unref (file);
9069 }
9070
9071 /* Callback used from GtkSearchEngine when we get new hits */
9072 static void
9073 search_engine_hits_added_cb (GtkSearchEngine *engine,
9074                              GList           *hits,
9075                              gpointer         data)
9076 {
9077   GtkFileChooserDefault *impl;
9078   GList *l;
9079
9080   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9081
9082   for (l = hits; l; l = l->next)
9083     search_add_hit (impl, (gchar*)l->data);
9084 }
9085
9086 /* Callback used from GtkSearchEngine when the query is done running */
9087 static void
9088 search_engine_finished_cb (GtkSearchEngine *engine,
9089                            gpointer         data)
9090 {
9091   GtkFileChooserDefault *impl;
9092
9093   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9094
9095 #if 0
9096   /* EB: setting the model here will avoid loads of row events,
9097    * but it'll make the search look like blocked.
9098    */
9099   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
9100                            GTK_TREE_MODEL (impl->search_model));
9101   file_list_set_sort_column_ids (impl);
9102 #endif
9103
9104   /* FMQ: if search was empty, say that we got no hits */
9105   set_busy_cursor (impl, FALSE);
9106 }
9107
9108 /* Displays a generic error when we cannot create a GtkSearchEngine.
9109  * It would be better if _gtk_search_engine_new() gave us a GError
9110  * with a better message, but it doesn't do that right now.
9111  */
9112 static void
9113 search_error_could_not_create_client (GtkFileChooserDefault *impl)
9114 {
9115   error_message (impl,
9116                  _("Could not start the search process"),
9117                  _("The program was not able to create a connection to the indexer "
9118                    "daemon.  Please make sure it is running."));
9119 }
9120
9121 static void
9122 search_engine_error_cb (GtkSearchEngine *engine,
9123                         const gchar     *message,
9124                         gpointer         data)
9125 {
9126   GtkFileChooserDefault *impl;
9127
9128   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9129
9130   search_stop_searching (impl, TRUE);
9131   error_message (impl, _("Could not send the search request"), message);
9132
9133   set_busy_cursor (impl, FALSE);
9134 }
9135
9136 /* Frees the data in the search_model */
9137 static void
9138 search_clear_model (GtkFileChooserDefault *impl,
9139                     gboolean               remove_from_treeview)
9140 {
9141   if (!impl->search_model)
9142     return;
9143
9144   g_object_unref (impl->search_model);
9145   impl->search_model = NULL;
9146
9147   if (remove_from_treeview)
9148     gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
9149 }
9150
9151 /* Stops any ongoing searches; does not touch the search_model */
9152 static void
9153 search_stop_searching (GtkFileChooserDefault *impl,
9154                        gboolean               remove_query)
9155 {
9156   if (remove_query && impl->search_query)
9157     {
9158       g_object_unref (impl->search_query);
9159       impl->search_query = NULL;
9160     }
9161
9162   if (impl->search_engine)
9163     {
9164       _gtk_search_engine_stop (impl->search_engine);
9165
9166       g_object_unref (impl->search_engine);
9167       impl->search_engine = NULL;
9168     }
9169 }
9170
9171 /* Creates the search_model and puts it in the tree view */
9172 static void
9173 search_setup_model (GtkFileChooserDefault *impl)
9174 {
9175   g_assert (impl->search_model == NULL);
9176
9177   impl->search_model = _gtk_file_system_model_new (file_system_model_set,
9178                                                    impl,
9179                                                    MODEL_COLUMN_TYPES);
9180
9181   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
9182                                    MODEL_COL_NAME,
9183                                    name_sort_func,
9184                                    impl, NULL);
9185   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
9186                                    MODEL_COL_MTIME,
9187                                    mtime_sort_func,
9188                                    impl, NULL);
9189   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
9190                                    MODEL_COL_SIZE,
9191                                    size_sort_func,
9192                                    impl, NULL);
9193   set_sort_column (impl);
9194
9195   /* EB: setting the model here will make the hits list update feel
9196    * more "alive" than setting the model at the end of the search
9197    * run
9198    */
9199   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
9200                            GTK_TREE_MODEL (impl->search_model));
9201   file_list_set_sort_column_ids (impl);
9202 }
9203
9204 /* Creates a new query with the specified text and launches it */
9205 static void
9206 search_start_query (GtkFileChooserDefault *impl,
9207                     const gchar           *query_text)
9208 {
9209   search_stop_searching (impl, FALSE);
9210   search_clear_model (impl, TRUE);
9211   search_setup_model (impl);
9212   set_busy_cursor (impl, TRUE);
9213
9214   if (impl->search_engine == NULL)
9215     impl->search_engine = _gtk_search_engine_new ();
9216
9217   if (!impl->search_engine)
9218     {
9219       set_busy_cursor (impl, FALSE);
9220       search_error_could_not_create_client (impl); /* lame; we don't get an error code or anything */
9221       return;
9222     }
9223
9224   if (!impl->search_query)
9225     {
9226       impl->search_query = _gtk_query_new ();
9227       _gtk_query_set_text (impl->search_query, query_text);
9228     }
9229
9230   _gtk_search_engine_set_query (impl->search_engine, impl->search_query);
9231
9232   g_signal_connect (impl->search_engine, "hits-added",
9233                     G_CALLBACK (search_engine_hits_added_cb), impl);
9234   g_signal_connect (impl->search_engine, "finished",
9235                     G_CALLBACK (search_engine_finished_cb), impl);
9236   g_signal_connect (impl->search_engine, "error",
9237                     G_CALLBACK (search_engine_error_cb), impl);
9238
9239   _gtk_search_engine_start (impl->search_engine);
9240 }
9241
9242 /* Callback used when the user presses Enter while typing on the search
9243  * entry; starts the query
9244  */
9245 static void
9246 search_entry_activate_cb (GtkEntry *entry,
9247                           gpointer data)
9248 {
9249   GtkFileChooserDefault *impl;
9250   const char *text;
9251
9252   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9253
9254   text = gtk_entry_get_text (GTK_ENTRY (impl->search_entry));
9255   if (strlen (text) == 0)
9256     return;
9257
9258   /* reset any existing query object */
9259   if (impl->search_query)
9260     {
9261       g_object_unref (impl->search_query);
9262       impl->search_query = NULL;
9263     }
9264
9265   search_start_query (impl, text);
9266 }
9267
9268 static gboolean
9269 focus_entry_idle_cb (GtkFileChooserDefault *impl)
9270 {
9271   gdk_threads_enter ();
9272
9273   g_source_destroy (impl->focus_entry_idle);
9274   impl->focus_entry_idle = NULL;
9275
9276   if (impl->search_entry)
9277     gtk_widget_grab_focus (impl->search_entry);
9278
9279   gdk_threads_leave ();
9280
9281   return FALSE;
9282 }
9283
9284 static void
9285 focus_search_entry_in_idle (GtkFileChooserDefault *impl)
9286 {
9287   /* bgo#634558 - When the user clicks on the Search entry in the shortcuts
9288    * pane, we get a selection-changed signal and we set up the search widgets.
9289    * However, gtk_tree_view_button_press() focuses the treeview *after* making
9290    * the change to the selection.  So, we need to re-focus the search entry
9291    * after the treeview has finished doing its work; we'll do that in an idle
9292    * handler.
9293    */
9294
9295   if (!impl->focus_entry_idle)
9296     impl->focus_entry_idle = add_idle_while_impl_is_alive (impl, G_CALLBACK (focus_entry_idle_cb));
9297 }
9298
9299 /* Hides the path bar and creates the search entry */
9300 static void
9301 search_setup_widgets (GtkFileChooserDefault *impl)
9302 {
9303   impl->search_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
9304
9305   path_bar_update (impl);
9306
9307   impl->search_entry = gtk_entry_new ();
9308   g_signal_connect (impl->search_entry, "activate",
9309                     G_CALLBACK (search_entry_activate_cb),
9310                     impl);
9311   gtk_box_pack_start (GTK_BOX (impl->search_hbox), impl->search_entry, TRUE, TRUE, 0);
9312
9313   /* if there already is a query, restart it */
9314   if (impl->search_query)
9315     {
9316       gchar *query = _gtk_query_get_text (impl->search_query);
9317
9318       if (query)
9319         {
9320           gtk_entry_set_text (GTK_ENTRY (impl->search_entry), query);
9321           search_start_query (impl, query);
9322
9323           g_free (query);
9324         }
9325       else
9326         {
9327           g_object_unref (impl->search_query);
9328           impl->search_query = NULL;
9329         }
9330     }
9331
9332   /* Box for search widgets */
9333   gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->search_hbox, TRUE, TRUE, 0);
9334   gtk_widget_show_all (impl->search_hbox);
9335   gtk_size_group_add_widget (GTK_SIZE_GROUP (impl->browse_path_bar_size_group), impl->search_hbox);
9336
9337   /* Hide the location widgets temporarily */
9338
9339   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
9340       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
9341     {
9342       gtk_widget_hide (impl->location_button);
9343       gtk_widget_hide (impl->location_entry_box);
9344     }
9345
9346   focus_search_entry_in_idle (impl);
9347
9348   /* FMQ: hide the filter combo? */
9349 }
9350
9351 /*
9352  * Recent files support
9353  */
9354
9355 /* Frees the data in the recent_model */
9356 static void
9357 recent_clear_model (GtkFileChooserDefault *impl,
9358                     gboolean               remove_from_treeview)
9359 {
9360   if (!impl->recent_model)
9361     return;
9362
9363   if (remove_from_treeview)
9364     gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
9365
9366   g_object_unref (impl->recent_model);
9367   impl->recent_model = NULL;
9368 }
9369
9370 /* Stops any ongoing loading of the recent files list; does
9371  * not touch the recent_model
9372  */
9373 static void
9374 recent_stop_loading (GtkFileChooserDefault *impl)
9375 {
9376   if (impl->load_recent_id)
9377     {
9378       g_source_remove (impl->load_recent_id);
9379       impl->load_recent_id = 0;
9380     }
9381 }
9382
9383 static void
9384 recent_setup_model (GtkFileChooserDefault *impl)
9385 {
9386   g_assert (impl->recent_model == NULL);
9387
9388   impl->recent_model = _gtk_file_system_model_new (file_system_model_set,
9389                                                    impl,
9390                                                    MODEL_COLUMN_TYPES);
9391
9392   _gtk_file_system_model_set_filter (impl->recent_model,
9393                                      impl->current_filter);
9394   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
9395                                    MODEL_COL_NAME,
9396                                    name_sort_func,
9397                                    impl, NULL);
9398   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
9399                                    MODEL_COL_SIZE,
9400                                    size_sort_func,
9401                                    impl, NULL);
9402   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
9403                                    MODEL_COL_MTIME,
9404                                    mtime_sort_func,
9405                                    impl, NULL);
9406   set_sort_column (impl);
9407 }
9408
9409 typedef struct
9410 {
9411   GtkFileChooserDefault *impl;
9412   GList *items;
9413 } RecentLoadData;
9414
9415 static void
9416 recent_idle_cleanup (gpointer data)
9417 {
9418   RecentLoadData *load_data = data;
9419   GtkFileChooserDefault *impl = load_data->impl;
9420
9421   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
9422                            GTK_TREE_MODEL (impl->recent_model));
9423   file_list_set_sort_column_ids (impl);
9424   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (impl->recent_model), MODEL_COL_MTIME, GTK_SORT_DESCENDING);
9425
9426   set_busy_cursor (impl, FALSE);
9427
9428   impl->load_recent_id = 0;
9429
9430   g_free (load_data);
9431 }
9432
9433 static gint
9434 get_recent_files_limit (GtkWidget *widget)
9435 {
9436   GtkSettings *settings;
9437   gint limit;
9438
9439   if (gtk_widget_has_screen (widget))
9440     settings = gtk_settings_get_for_screen (gtk_widget_get_screen (widget));
9441   else
9442     settings = gtk_settings_get_default ();
9443
9444   g_object_get (G_OBJECT (settings), "gtk-recent-files-limit", &limit, NULL);
9445
9446   return limit;
9447 }
9448
9449 /* Populates the file system model with the GtkRecentInfo* items in the provided list; frees the items */
9450 static void
9451 populate_model_with_recent_items (GtkFileChooserDefault *impl, GList *items)
9452 {
9453   gint limit;
9454   GList *l;
9455   int n;
9456
9457   limit = get_recent_files_limit (GTK_WIDGET (impl));
9458
9459   n = 0;
9460
9461   for (l = items; l; l = l->next)
9462     {
9463       GtkRecentInfo *info = l->data;
9464       GFile *file;
9465
9466       file = g_file_new_for_uri (gtk_recent_info_get_uri (info));
9467       _gtk_file_system_model_add_and_query_file (impl->recent_model,
9468                                                  file,
9469                                                  MODEL_ATTRIBUTES);
9470       g_object_unref (file);
9471
9472       n++;
9473       if (limit != -1 && n >= limit)
9474         break;
9475     }
9476 }
9477
9478 static void
9479 populate_model_with_folders (GtkFileChooserDefault *impl, GList *items)
9480 {
9481   GList *folders;
9482   GList *l;
9483
9484   folders = _gtk_file_chooser_extract_recent_folders (items);
9485
9486   for (l = folders; l; l = l->next)
9487     {
9488       GFile *folder = l->data;
9489
9490       _gtk_file_system_model_add_and_query_file (impl->recent_model,
9491                                                  folder,
9492                                                  MODEL_ATTRIBUTES);
9493     }
9494
9495   g_list_foreach (folders, (GFunc) g_object_unref, NULL);
9496   g_list_free (folders);
9497 }
9498
9499 static gboolean
9500 recent_idle_load (gpointer data)
9501 {
9502   RecentLoadData *load_data = data;
9503   GtkFileChooserDefault *impl = load_data->impl;
9504
9505   if (!impl->recent_manager)
9506     return FALSE;
9507
9508   load_data->items = gtk_recent_manager_get_items (impl->recent_manager);
9509   if (!load_data->items)
9510     return FALSE;
9511
9512   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
9513     populate_model_with_recent_items (impl, load_data->items);
9514   else
9515     populate_model_with_folders (impl, load_data->items);
9516
9517   g_list_foreach (load_data->items, (GFunc) gtk_recent_info_unref, NULL);
9518   g_list_free (load_data->items);
9519   load_data->items = NULL;
9520
9521   return FALSE;
9522 }
9523
9524 static void
9525 recent_start_loading (GtkFileChooserDefault *impl)
9526 {
9527   RecentLoadData *load_data;
9528
9529   recent_stop_loading (impl);
9530   recent_clear_model (impl, TRUE);
9531   recent_setup_model (impl);
9532   set_busy_cursor (impl, TRUE);
9533
9534   g_assert (impl->load_recent_id == 0);
9535
9536   load_data = g_new (RecentLoadData, 1);
9537   load_data->impl = impl;
9538   load_data->items = NULL;
9539
9540   /* begin lazy loading the recent files into the model */
9541   impl->load_recent_id = gdk_threads_add_idle_full (G_PRIORITY_HIGH_IDLE + 30,
9542                                                     recent_idle_load,
9543                                                     load_data,
9544                                                     recent_idle_cleanup);
9545 }
9546
9547 static void
9548 recent_selected_foreach_get_file_cb (GtkTreeModel *model,
9549                                      GtkTreePath  *path,
9550                                      GtkTreeIter  *iter,
9551                                      gpointer      data)
9552 {
9553   GSList **list;
9554   GFile *file;
9555
9556   list = data;
9557
9558   gtk_tree_model_get (model, iter, MODEL_COL_FILE, &file, -1);
9559   *list = g_slist_prepend (*list, file);
9560 }
9561
9562 /* Constructs a list of the selected paths in recent files mode */
9563 static GSList *
9564 recent_get_selected_files (GtkFileChooserDefault *impl)
9565 {
9566   GSList *result;
9567   GtkTreeSelection *selection;
9568
9569   result = NULL;
9570
9571   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9572   gtk_tree_selection_selected_foreach (selection, recent_selected_foreach_get_file_cb, &result);
9573   result = g_slist_reverse (result);
9574
9575   return result;
9576 }
9577
9578 /* Called from ::should_respond().  We return whether there are selected
9579  * files in the recent files list.
9580  */
9581 static gboolean
9582 recent_should_respond (GtkFileChooserDefault *impl)
9583 {
9584   GtkTreeSelection *selection;
9585
9586   g_assert (impl->operation_mode == OPERATION_MODE_RECENT);
9587
9588   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9589   return (gtk_tree_selection_count_selected_rows (selection) != 0);
9590 }
9591
9592 static void
9593 set_current_filter (GtkFileChooserDefault *impl,
9594                     GtkFileFilter         *filter)
9595 {
9596   if (impl->current_filter != filter)
9597     {
9598       int filter_index;
9599
9600       /* NULL filters are allowed to reset to non-filtered status
9601        */
9602       filter_index = g_slist_index (impl->filters, filter);
9603       if (impl->filters && filter && filter_index < 0)
9604         return;
9605
9606       if (impl->current_filter)
9607         g_object_unref (impl->current_filter);
9608       impl->current_filter = filter;
9609       if (impl->current_filter)
9610         {
9611           g_object_ref_sink (impl->current_filter);
9612         }
9613
9614       if (impl->filters)
9615         gtk_combo_box_set_active (GTK_COMBO_BOX (impl->filter_combo),
9616                                   filter_index);
9617
9618       if (impl->browse_files_model)
9619         {
9620           _gtk_file_system_model_set_filter (impl->browse_files_model, impl->current_filter);
9621           _gtk_file_system_model_clear_cache (impl->browse_files_model, MODEL_COL_IS_SENSITIVE);
9622         }
9623
9624       if (impl->search_model)
9625         {
9626           _gtk_file_system_model_set_filter (impl->search_model, filter);
9627           _gtk_file_system_model_clear_cache (impl->search_model, MODEL_COL_IS_SENSITIVE);
9628         }
9629
9630       if (impl->recent_model)
9631         {
9632           _gtk_file_system_model_set_filter (impl->recent_model, filter);
9633           _gtk_file_system_model_clear_cache (impl->recent_model, MODEL_COL_IS_SENSITIVE);
9634         }
9635
9636       g_object_notify (G_OBJECT (impl), "filter");
9637     }
9638 }
9639
9640 static void
9641 filter_combo_changed (GtkComboBox           *combo_box,
9642                       GtkFileChooserDefault *impl)
9643 {
9644   gint new_index = gtk_combo_box_get_active (combo_box);
9645   GtkFileFilter *new_filter = g_slist_nth_data (impl->filters, new_index);
9646
9647   set_current_filter (impl, new_filter);
9648 }
9649
9650 static void
9651 check_preview_change (GtkFileChooserDefault *impl)
9652 {
9653   GtkTreePath *cursor_path;
9654   GFile *new_file;
9655   char *new_display_name;
9656   GtkTreeModel *model;
9657
9658   gtk_tree_view_get_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view), &cursor_path, NULL);
9659   model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
9660   if (cursor_path)
9661     {
9662       GtkTreeIter iter;
9663
9664       gtk_tree_model_get_iter (model, &iter, cursor_path);
9665       gtk_tree_model_get (model, &iter,
9666                           MODEL_COL_FILE, &new_file,
9667                           MODEL_COL_NAME, &new_display_name,
9668                           -1);
9669
9670       gtk_tree_path_free (cursor_path);
9671     }
9672   else
9673     {
9674       new_file = NULL;
9675       new_display_name = NULL;
9676     }
9677
9678   if (new_file != impl->preview_file &&
9679       !(new_file && impl->preview_file &&
9680         g_file_equal (new_file, impl->preview_file)))
9681     {
9682       if (impl->preview_file)
9683         {
9684           g_object_unref (impl->preview_file);
9685           g_free (impl->preview_display_name);
9686         }
9687
9688       if (new_file)
9689         {
9690           impl->preview_file = new_file;
9691           impl->preview_display_name = new_display_name;
9692         }
9693       else
9694         {
9695           impl->preview_file = NULL;
9696           impl->preview_display_name = NULL;
9697           g_free (new_display_name);
9698         }
9699
9700       if (impl->use_preview_label && impl->preview_label)
9701         gtk_label_set_text (GTK_LABEL (impl->preview_label), impl->preview_display_name);
9702
9703       g_signal_emit_by_name (impl, "update-preview");
9704     }
9705   else
9706     {
9707       if (new_file)
9708         g_object_unref (new_file);
9709
9710       g_free (new_display_name);
9711     }
9712 }
9713
9714 static void
9715 shortcuts_activate_volume_mount_cb (GCancellable        *cancellable,
9716                                     GtkFileSystemVolume *volume,
9717                                     const GError        *error,
9718                                     gpointer             data)
9719 {
9720   GFile *file;
9721   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
9722   GtkFileChooserDefault *impl = data;
9723
9724   if (cancellable != impl->shortcuts_activate_iter_cancellable)
9725     goto out;
9726
9727   impl->shortcuts_activate_iter_cancellable = NULL;
9728
9729   set_busy_cursor (impl, FALSE);
9730
9731   if (cancelled)
9732     goto out;
9733
9734   if (error)
9735     {
9736       if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED))
9737         {
9738           char *msg, *name;
9739
9740           name = _gtk_file_system_volume_get_display_name (volume);
9741           msg = g_strdup_printf (_("Could not mount %s"), name);
9742
9743           error_message (impl, msg, error->message);
9744
9745           g_free (msg);
9746           g_free (name);
9747         }
9748
9749       goto out;
9750     }
9751
9752   file = _gtk_file_system_volume_get_root (volume);
9753   if (file != NULL)
9754     {
9755       change_folder_and_display_error (impl, file, FALSE);
9756       g_object_unref (file);
9757     }
9758
9759 out:
9760   g_object_unref (impl);
9761   g_object_unref (cancellable);
9762 }
9763
9764
9765 /* Activates a volume by mounting it if necessary and then switching to its
9766  * base path.
9767  */
9768 static void
9769 shortcuts_activate_volume (GtkFileChooserDefault *impl,
9770                            GtkFileSystemVolume   *volume)
9771 {
9772   GFile *file;
9773
9774   operation_mode_set (impl, OPERATION_MODE_BROWSE);
9775
9776   /* We ref the file chooser since volume_mount() may run a main loop, and the
9777    * user could close the file chooser window in the meantime.
9778    */
9779   g_object_ref (impl);
9780
9781   if (!_gtk_file_system_volume_is_mounted (volume))
9782     {
9783       GMountOperation *mount_op;
9784
9785       set_busy_cursor (impl, TRUE);
9786
9787       mount_op = gtk_mount_operation_new (get_toplevel (GTK_WIDGET (impl)));
9788       impl->shortcuts_activate_iter_cancellable =
9789         _gtk_file_system_mount_volume (impl->file_system, volume, mount_op,
9790                                        shortcuts_activate_volume_mount_cb,
9791                                        g_object_ref (impl));
9792       g_object_unref (mount_op);
9793     }
9794   else
9795     {
9796       file = _gtk_file_system_volume_get_root (volume);
9797       if (file != NULL)
9798         {
9799           change_folder_and_display_error (impl, file, FALSE);
9800           g_object_unref (file);
9801         }
9802     }
9803
9804   g_object_unref (impl);
9805 }
9806
9807 /* Opens the folder or volume at the specified iter in the shortcuts model */
9808 struct ShortcutsActivateData
9809 {
9810   GtkFileChooserDefault *impl;
9811   GFile *file;
9812 };
9813
9814 static void
9815 shortcuts_activate_get_info_cb (GCancellable *cancellable,
9816                                 GFileInfo    *info,
9817                                 const GError *error,
9818                                 gpointer      user_data)
9819 {
9820   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
9821   struct ShortcutsActivateData *data = user_data;
9822
9823   if (cancellable != data->impl->shortcuts_activate_iter_cancellable)
9824     goto out;
9825
9826   data->impl->shortcuts_activate_iter_cancellable = NULL;
9827
9828   if (cancelled)
9829     goto out;
9830
9831   if (!error && _gtk_file_info_consider_as_directory (info))
9832     change_folder_and_display_error (data->impl, data->file, FALSE);
9833   else
9834     gtk_file_chooser_default_select_file (GTK_FILE_CHOOSER (data->impl),
9835                                           data->file,
9836                                           NULL);
9837
9838 out:
9839   g_object_unref (data->impl);
9840   g_object_unref (data->file);
9841   g_free (data);
9842
9843   g_object_unref (cancellable);
9844 }
9845
9846 static void
9847 shortcuts_activate_mount_enclosing_volume (GCancellable        *cancellable,
9848                                            GtkFileSystemVolume *volume,
9849                                            const GError        *error,
9850                                            gpointer             user_data)
9851 {
9852   struct ShortcutsActivateData *data = user_data;
9853
9854   if (error)
9855     {
9856       error_changing_folder_dialog (data->impl, data->file, g_error_copy (error));
9857
9858       g_object_unref (data->impl);
9859       g_object_unref (data->file);
9860       g_free (data);
9861
9862       return;
9863     }
9864
9865   data->impl->shortcuts_activate_iter_cancellable =
9866     _gtk_file_system_get_info (data->impl->file_system, data->file,
9867                                "standard::type",
9868                                shortcuts_activate_get_info_cb, data);
9869
9870   if (volume)
9871     _gtk_file_system_volume_unref (volume);
9872 }
9873
9874 static void
9875 shortcuts_activate_iter (GtkFileChooserDefault *impl,
9876                          GtkTreeIter           *iter)
9877 {
9878   gpointer col_data;
9879   ShortcutType shortcut_type;
9880
9881   /* In the Save modes, we want to preserve what the uesr typed in the filename
9882    * entry, so that he may choose another folder without erasing his typed name.
9883    */
9884   if (impl->location_entry
9885       && !(impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
9886            || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER))
9887     gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
9888
9889   gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), iter,
9890                       SHORTCUTS_COL_DATA, &col_data,
9891                       SHORTCUTS_COL_TYPE, &shortcut_type,
9892                       -1);
9893
9894   if (impl->shortcuts_activate_iter_cancellable)
9895     {
9896       g_cancellable_cancel (impl->shortcuts_activate_iter_cancellable);
9897       impl->shortcuts_activate_iter_cancellable = NULL;
9898     }
9899
9900   if (shortcut_type == SHORTCUT_TYPE_SEPARATOR)
9901     return;
9902   else if (shortcut_type == SHORTCUT_TYPE_VOLUME)
9903     {
9904       GtkFileSystemVolume *volume;
9905
9906       volume = col_data;
9907
9908       operation_mode_set (impl, OPERATION_MODE_BROWSE);
9909
9910       shortcuts_activate_volume (impl, volume);
9911     }
9912   else if (shortcut_type == SHORTCUT_TYPE_FILE)
9913     {
9914       struct ShortcutsActivateData *data;
9915       GtkFileSystemVolume *volume;
9916
9917       operation_mode_set (impl, OPERATION_MODE_BROWSE);
9918
9919       volume = _gtk_file_system_get_volume_for_file (impl->file_system, col_data);
9920
9921       data = g_new0 (struct ShortcutsActivateData, 1);
9922       data->impl = g_object_ref (impl);
9923       data->file = g_object_ref (col_data);
9924
9925       if (!volume || !_gtk_file_system_volume_is_mounted (volume))
9926         {
9927           GMountOperation *mount_operation;
9928           GtkWidget *toplevel;
9929
9930           toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
9931
9932           mount_operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
9933
9934           impl->shortcuts_activate_iter_cancellable =
9935             _gtk_file_system_mount_enclosing_volume (impl->file_system, col_data,
9936                                                      mount_operation,
9937                                                      shortcuts_activate_mount_enclosing_volume,
9938                                                      data);
9939         }
9940       else
9941         {
9942           impl->shortcuts_activate_iter_cancellable =
9943             _gtk_file_system_get_info (impl->file_system, data->file,
9944                                        "standard::type",
9945                                        shortcuts_activate_get_info_cb, data);
9946         }
9947     }
9948   else if (shortcut_type == SHORTCUT_TYPE_SEARCH)
9949     {
9950       operation_mode_set (impl, OPERATION_MODE_SEARCH);
9951     }
9952   else if (shortcut_type == SHORTCUT_TYPE_RECENT)
9953     {
9954       operation_mode_set (impl, OPERATION_MODE_RECENT);
9955     }
9956 }
9957
9958 /* Handler for GtkWidget::key-press-event on the shortcuts list */
9959 static gboolean
9960 shortcuts_key_press_event_cb (GtkWidget             *widget,
9961                               GdkEventKey           *event,
9962                               GtkFileChooserDefault *impl)
9963 {
9964   guint modifiers;
9965
9966   modifiers = gtk_accelerator_get_default_mod_mask ();
9967
9968   if (key_is_left_or_right (event))
9969     {
9970       gtk_widget_grab_focus (impl->browse_files_tree_view);
9971       return TRUE;
9972     }
9973
9974   if ((event->keyval == GDK_KEY_BackSpace
9975       || event->keyval == GDK_KEY_Delete
9976       || event->keyval == GDK_KEY_KP_Delete)
9977       && (event->state & modifiers) == 0)
9978     {
9979       remove_selected_bookmarks (impl);
9980       return TRUE;
9981     }
9982
9983   if ((event->keyval == GDK_KEY_F2)
9984       && (event->state & modifiers) == 0)
9985     {
9986       rename_selected_bookmark (impl);
9987       return TRUE;
9988     }
9989
9990   return FALSE;
9991 }
9992
9993 static gboolean
9994 shortcuts_select_func  (GtkTreeSelection  *selection,
9995                         GtkTreeModel      *model,
9996                         GtkTreePath       *path,
9997                         gboolean           path_currently_selected,
9998                         gpointer           data)
9999 {
10000   GtkFileChooserDefault *impl = data;
10001   GtkTreeIter filter_iter;
10002   ShortcutType shortcut_type;
10003
10004   if (!gtk_tree_model_get_iter (impl->shortcuts_pane_filter_model, &filter_iter, path))
10005     g_assert_not_reached ();
10006
10007   gtk_tree_model_get (impl->shortcuts_pane_filter_model, &filter_iter, SHORTCUTS_COL_TYPE, &shortcut_type, -1);
10008
10009   return shortcut_type != SHORTCUT_TYPE_SEPARATOR;
10010 }
10011
10012 static gboolean
10013 list_select_func  (GtkTreeSelection  *selection,
10014                    GtkTreeModel      *model,
10015                    GtkTreePath       *path,
10016                    gboolean           path_currently_selected,
10017                    gpointer           data)
10018 {
10019   GtkFileChooserDefault *impl = data;
10020
10021   if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
10022       impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
10023     {
10024       GtkTreeIter iter;
10025       gboolean is_sensitive;
10026       gboolean is_folder;
10027
10028       if (!gtk_tree_model_get_iter (model, &iter, path))
10029         return FALSE;
10030       gtk_tree_model_get (model, &iter,
10031                           MODEL_COL_IS_SENSITIVE, &is_sensitive,
10032                           MODEL_COL_IS_FOLDER, &is_folder,
10033                           -1);
10034       if (!is_sensitive || !is_folder)
10035         return FALSE;
10036     }
10037
10038   return TRUE;
10039 }
10040
10041 static void
10042 list_selection_changed (GtkTreeSelection      *selection,
10043                         GtkFileChooserDefault *impl)
10044 {
10045   /* See if we are in the new folder editable row for Save mode */
10046   if (impl->operation_mode == OPERATION_MODE_BROWSE &&
10047       impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
10048     {
10049       GFileInfo *info;
10050       gboolean had_selection;
10051
10052       info = get_selected_file_info_from_file_list (impl, &had_selection);
10053       if (!had_selection)
10054         goto out; /* normal processing */
10055
10056       if (!info)
10057         return; /* We are on the editable row for New Folder */
10058     }
10059
10060  out:
10061
10062   if (impl->location_entry)
10063     update_chooser_entry (impl);
10064
10065   path_bar_update (impl);
10066
10067   check_preview_change (impl);
10068   bookmarks_check_add_sensitivity (impl);
10069   check_copy_file_location_sensitivity (impl);
10070
10071   g_signal_emit_by_name (impl, "selection-changed", 0);
10072 }
10073
10074 /* Callback used when a row in the file list is activated */
10075 static void
10076 list_row_activated (GtkTreeView           *tree_view,
10077                     GtkTreePath           *path,
10078                     GtkTreeViewColumn     *column,
10079                     GtkFileChooserDefault *impl)
10080 {
10081   GFile *file;
10082   GtkTreeIter iter;
10083   GtkTreeModel *model;
10084   gboolean is_folder;
10085   gboolean is_sensitive;
10086
10087   model = gtk_tree_view_get_model (tree_view);
10088
10089   if (!gtk_tree_model_get_iter (model, &iter, path))
10090     return;
10091
10092   gtk_tree_model_get (model, &iter,
10093                       MODEL_COL_FILE, &file,
10094                       MODEL_COL_IS_FOLDER, &is_folder,
10095                       MODEL_COL_IS_SENSITIVE, &is_sensitive,
10096                       -1);
10097
10098   if (is_sensitive && is_folder && file)
10099     {
10100       change_folder_and_display_error (impl, file, FALSE);
10101       goto out;
10102     }
10103
10104   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
10105       impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
10106     g_signal_emit_by_name (impl, "file-activated");
10107
10108  out:
10109
10110   if (file)
10111     g_object_unref (file);
10112 }
10113
10114 static void
10115 path_bar_clicked (GtkPathBar            *path_bar,
10116                   GFile                 *file,
10117                   GFile                 *child_file,
10118                   gboolean               child_is_hidden,
10119                   GtkFileChooserDefault *impl)
10120 {
10121   if (child_file)
10122     pending_select_files_add (impl, child_file);
10123
10124   if (!change_folder_and_display_error (impl, file, FALSE))
10125     return;
10126
10127   /* Say we have "/foo/bar/[.baz]" and the user clicks on "bar".  We should then
10128    * show hidden files so that ".baz" appears in the file list, as it will still
10129    * be shown in the path bar: "/foo/[bar]/.baz"
10130    */
10131   if (child_is_hidden)
10132     g_object_set (impl, "show-hidden", TRUE, NULL);
10133 }
10134
10135 static void
10136 update_cell_renderer_attributes (GtkFileChooserDefault *impl)
10137 {
10138   GtkTreeViewColumn *column;
10139   GtkCellRenderer *renderer;
10140   GList *walk, *list;
10141
10142   /* Keep the following column numbers in sync with create_file_list() */
10143
10144   /* name */
10145   column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 0);
10146   list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
10147   for (walk = list; walk; walk = walk->next)
10148     {
10149       renderer = walk->data;
10150       if (GTK_IS_CELL_RENDERER_PIXBUF (renderer))
10151         {
10152           gtk_tree_view_column_set_attributes (column, renderer,
10153                                                "pixbuf", MODEL_COL_PIXBUF,
10154                                                NULL);
10155         }
10156       else
10157         {
10158           gtk_tree_view_column_set_attributes (column, renderer,
10159                                                "text", MODEL_COL_NAME,
10160                                                "ellipsize", MODEL_COL_ELLIPSIZE,
10161                                                NULL);
10162         }
10163
10164       gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_SENSITIVE);
10165     }
10166   g_list_free (list);
10167
10168   /* size */
10169   column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 1);
10170   list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
10171   renderer = list->data;
10172   gtk_tree_view_column_set_attributes (column, renderer,
10173                                        "text", MODEL_COL_SIZE_TEXT,
10174                                        NULL);
10175
10176   gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_SENSITIVE);
10177   g_list_free (list);
10178
10179   /* mtime */
10180   column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 2);
10181   list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
10182   renderer = list->data;
10183   gtk_tree_view_column_set_attributes (column, renderer,
10184                                        "text", MODEL_COL_MTIME_TEXT,
10185                                        NULL);
10186   gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_SENSITIVE);
10187   g_list_free (list);
10188 }
10189
10190 GtkWidget *
10191 _gtk_file_chooser_default_new (void)
10192 {
10193   return g_object_new (GTK_TYPE_FILE_CHOOSER_DEFAULT, NULL);
10194 }
10195
10196 static void
10197 location_set_user_text (GtkFileChooserDefault *impl,
10198                         const gchar           *path)
10199 {
10200   gtk_entry_set_text (GTK_ENTRY (impl->location_entry), path);
10201   gtk_editable_set_position (GTK_EDITABLE (impl->location_entry), -1);
10202 }
10203
10204 static void
10205 location_popup_handler (GtkFileChooserDefault *impl,
10206                         const gchar           *path)
10207 {
10208   if (impl->operation_mode != OPERATION_MODE_BROWSE)
10209     {
10210       GtkWidget *widget_to_focus;
10211
10212       operation_mode_set (impl, OPERATION_MODE_BROWSE);
10213
10214       if (impl->current_folder)
10215         change_folder_and_display_error (impl, impl->current_folder, FALSE);
10216
10217       if (impl->location_mode == LOCATION_MODE_PATH_BAR)
10218         widget_to_focus = impl->browse_files_tree_view;
10219       else
10220         widget_to_focus = impl->location_entry;
10221
10222       gtk_widget_grab_focus (widget_to_focus);
10223       return;
10224     }
10225
10226   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
10227       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
10228     {
10229       if (!path)
10230         return;
10231
10232       location_mode_set (impl, LOCATION_MODE_FILENAME_ENTRY, TRUE);
10233       location_set_user_text (impl, path);
10234     }
10235   else if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
10236            impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
10237     {
10238       gtk_widget_grab_focus (impl->location_entry);
10239       if (path != NULL)
10240         location_set_user_text (impl, path);
10241     }
10242   else
10243     g_assert_not_reached ();
10244 }
10245
10246 /* Handler for the "up-folder" keybinding signal */
10247 static void
10248 up_folder_handler (GtkFileChooserDefault *impl)
10249 {
10250   _gtk_path_bar_up (GTK_PATH_BAR (impl->browse_path_bar));
10251 }
10252
10253 /* Handler for the "down-folder" keybinding signal */
10254 static void
10255 down_folder_handler (GtkFileChooserDefault *impl)
10256 {
10257   _gtk_path_bar_down (GTK_PATH_BAR (impl->browse_path_bar));
10258 }
10259
10260 /* Switches to the shortcut in the specified index */
10261 static void
10262 switch_to_shortcut (GtkFileChooserDefault *impl,
10263                     int pos)
10264 {
10265   GtkTreeIter iter;
10266
10267   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
10268     g_assert_not_reached ();
10269
10270   shortcuts_activate_iter (impl, &iter);
10271 }
10272
10273 /* Handler for the "home-folder" keybinding signal */
10274 static void
10275 home_folder_handler (GtkFileChooserDefault *impl)
10276 {
10277   if (impl->has_home)
10278     switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_HOME));
10279 }
10280
10281 /* Handler for the "desktop-folder" keybinding signal */
10282 static void
10283 desktop_folder_handler (GtkFileChooserDefault *impl)
10284 {
10285   if (impl->has_desktop)
10286     switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_DESKTOP));
10287 }
10288
10289 /* Handler for the "search-shortcut" keybinding signal */
10290 static void
10291 search_shortcut_handler (GtkFileChooserDefault *impl)
10292 {
10293   if (impl->has_search)
10294     {
10295       switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_SEARCH));
10296
10297       /* we want the entry widget to grab the focus the first
10298        * time, not the browse_files_tree_view widget.
10299        */
10300       if (impl->search_entry)
10301         gtk_widget_grab_focus (impl->search_entry);
10302     }
10303 }
10304
10305 /* Handler for the "recent-shortcut" keybinding signal */
10306 static void
10307 recent_shortcut_handler (GtkFileChooserDefault *impl)
10308 {
10309   switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_RECENT));
10310 }
10311
10312 static void
10313 quick_bookmark_handler (GtkFileChooserDefault *impl,
10314                         gint bookmark_index)
10315 {
10316   int bookmark_pos;
10317   GtkTreePath *path;
10318
10319   if (bookmark_index < 0 || bookmark_index >= impl->num_bookmarks)
10320     return;
10321
10322   bookmark_pos = shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS) + bookmark_index;
10323
10324   path = gtk_tree_path_new_from_indices (bookmark_pos, -1);
10325   gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view),
10326                                 path, NULL,
10327                                 FALSE, 0.0, 0.0);
10328   gtk_tree_path_free (path);
10329
10330   switch_to_shortcut (impl, bookmark_pos);
10331 }
10332
10333 static void
10334 show_hidden_handler (GtkFileChooserDefault *impl)
10335 {
10336   g_object_set (impl,
10337                 "show-hidden", !impl->show_hidden,
10338                 NULL);
10339 }
10340
10341
10342 /* Drag and drop interfaces */
10343
10344 static void
10345 _shortcuts_pane_model_filter_class_init (ShortcutsPaneModelFilterClass *class)
10346 {
10347 }
10348
10349 static void
10350 _shortcuts_pane_model_filter_init (ShortcutsPaneModelFilter *model)
10351 {
10352   model->impl = NULL;
10353 }
10354
10355 /* GtkTreeDragSource::row_draggable implementation for the shortcuts filter model */
10356 static gboolean
10357 shortcuts_pane_model_filter_row_draggable (GtkTreeDragSource *drag_source,
10358                                            GtkTreePath       *path)
10359 {
10360   ShortcutsPaneModelFilter *model;
10361   int pos;
10362   int bookmarks_pos;
10363
10364   model = SHORTCUTS_PANE_MODEL_FILTER (drag_source);
10365
10366   pos = *gtk_tree_path_get_indices (path);
10367   bookmarks_pos = shortcuts_get_index (model->impl, SHORTCUTS_BOOKMARKS);
10368
10369   return (pos >= bookmarks_pos && pos < bookmarks_pos + model->impl->num_bookmarks);
10370 }
10371
10372 /* GtkTreeDragSource::drag_data_get implementation for the shortcuts
10373  * filter model
10374  */
10375 static gboolean
10376 shortcuts_pane_model_filter_drag_data_get (GtkTreeDragSource *drag_source,
10377                                            GtkTreePath       *path,
10378                                            GtkSelectionData  *selection_data)
10379 {
10380   /* FIXME */
10381
10382   return FALSE;
10383 }
10384
10385 /* Fill the GtkTreeDragSourceIface vtable */
10386 static void
10387 shortcuts_pane_model_filter_drag_source_iface_init (GtkTreeDragSourceIface *iface)
10388 {
10389   iface->row_draggable = shortcuts_pane_model_filter_row_draggable;
10390   iface->drag_data_get = shortcuts_pane_model_filter_drag_data_get;
10391 }
10392
10393 #if 0
10394 /* Fill the GtkTreeDragDestIface vtable */
10395 static void
10396 shortcuts_pane_model_filter_drag_dest_iface_init (GtkTreeDragDestIface *iface)
10397 {
10398   iface->drag_data_received = shortcuts_pane_model_filter_drag_data_received;
10399   iface->row_drop_possible = shortcuts_pane_model_filter_row_drop_possible;
10400 }
10401 #endif
10402
10403 static GtkTreeModel *
10404 shortcuts_pane_model_filter_new (GtkFileChooserDefault *impl,
10405                                  GtkTreeModel          *child_model,
10406                                  GtkTreePath           *root)
10407 {
10408   ShortcutsPaneModelFilter *model;
10409
10410   model = g_object_new (SHORTCUTS_PANE_MODEL_FILTER_TYPE,
10411                         "child-model", child_model,
10412                         "virtual-root", root,
10413                         NULL);
10414
10415   model->impl = impl;
10416
10417   return GTK_TREE_MODEL (model);
10418 }
10419