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);
 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 && !g_file_is_native (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_is_native = TRUE;
1980
1981               base_file = _gtk_file_system_volume_get_root (volume);
1982               if (base_file != NULL)
1983                 {
1984                   base_is_native = g_file_is_native (base_file);
1985                   g_object_unref (base_file);
1986                 }
1987
1988               if (!base_is_native)
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            !g_file_is_native (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 and switches to the LOAD_FINISHED state */
6320 static void
6321 load_remove_timer (GtkFileChooserDefault *impl)
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       impl->load_state = LOAD_EMPTY;
6330     }
6331   else
6332     g_assert (impl->load_state == LOAD_EMPTY ||
6333               impl->load_state == LOAD_LOADING ||
6334               impl->load_state == LOAD_FINISHED);
6335 }
6336
6337 /* Selects the first row in the file list */
6338 static void
6339 browse_files_select_first_row (GtkFileChooserDefault *impl)
6340 {
6341   GtkTreePath *path;
6342   GtkTreeIter dummy_iter;
6343   GtkTreeModel *tree_model;
6344
6345   tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
6346
6347   if (!tree_model)
6348     return;
6349
6350   path = gtk_tree_path_new_from_indices (0, -1);
6351
6352   /* If the list is empty, do nothing. */
6353   if (gtk_tree_model_get_iter (tree_model, &dummy_iter, path))
6354       gtk_tree_view_set_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view), path, NULL, FALSE);
6355
6356   gtk_tree_path_free (path);
6357 }
6358
6359 struct center_selected_row_closure {
6360   GtkFileChooserDefault *impl;
6361   gboolean already_centered;
6362 };
6363
6364 /* Callback used from gtk_tree_selection_selected_foreach(); centers the
6365  * selected row in the tree view.
6366  */
6367 static void
6368 center_selected_row_foreach_cb (GtkTreeModel      *model,
6369                                 GtkTreePath       *path,
6370                                 GtkTreeIter       *iter,
6371                                 gpointer           data)
6372 {
6373   struct center_selected_row_closure *closure;
6374
6375   closure = data;
6376   if (closure->already_centered)
6377     return;
6378
6379   gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (closure->impl->browse_files_tree_view), path, NULL, TRUE, 0.5, 0.0);
6380   closure->already_centered = TRUE;
6381 }
6382
6383 /* Centers the selected row in the tree view */
6384 static void
6385 browse_files_center_selected_row (GtkFileChooserDefault *impl)
6386 {
6387   struct center_selected_row_closure closure;
6388   GtkTreeSelection *selection;
6389
6390   closure.impl = impl;
6391   closure.already_centered = FALSE;
6392
6393   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
6394   gtk_tree_selection_selected_foreach (selection, center_selected_row_foreach_cb, &closure);
6395 }
6396
6397 static gboolean
6398 show_and_select_files (GtkFileChooserDefault *impl,
6399                        GSList                *files)
6400 {
6401   GtkTreeSelection *selection;
6402   GtkFileSystemModel *fsmodel;
6403   gboolean enabled_hidden, removed_filters;
6404   gboolean selected_a_file;
6405   GSList *walk;
6406
6407   g_assert (impl->load_state == LOAD_FINISHED);
6408   g_assert (impl->browse_files_model != NULL);
6409
6410   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
6411   fsmodel = GTK_FILE_SYSTEM_MODEL (gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view)));
6412
6413   g_assert (fsmodel == impl->browse_files_model);
6414
6415   enabled_hidden = impl->show_hidden;
6416   removed_filters = (impl->current_filter == NULL);
6417
6418   selected_a_file = FALSE;
6419
6420   for (walk = files; walk; walk = walk->next)
6421     {
6422       GFile *file = walk->data;
6423       GtkTreeIter iter;
6424
6425       /* Is it a hidden file? */
6426
6427       if (!_gtk_file_system_model_get_iter_for_file (fsmodel, &iter, file))
6428         continue;
6429
6430       if (!_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
6431         {
6432           GFileInfo *info = _gtk_file_system_model_get_info (fsmodel, &iter);
6433
6434           if (!enabled_hidden &&
6435               (g_file_info_get_is_hidden (info) ||
6436                g_file_info_get_is_backup (info)))
6437             {
6438               g_object_set (impl, "show-hidden", TRUE, NULL);
6439               enabled_hidden = TRUE;
6440             }
6441         }
6442
6443       /* Is it a filtered file? */
6444
6445       if (!_gtk_file_system_model_get_iter_for_file (fsmodel, &iter, file))
6446         continue; /* re-get the iter as it may change when the model refilters */
6447
6448       if (!_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
6449         {
6450           /* Maybe we should have a way to ask the fsmodel if it had filtered a file */
6451           if (!removed_filters)
6452             {
6453               set_current_filter (impl, NULL);
6454               removed_filters = TRUE;
6455             }
6456         }
6457
6458       /* Okay, can we select the file now? */
6459
6460       if (!_gtk_file_system_model_get_iter_for_file (fsmodel, &iter, file))
6461         continue;
6462
6463       if (_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
6464         {
6465           GtkTreePath *path;
6466
6467           gtk_tree_selection_select_iter (selection, &iter);
6468
6469           path = gtk_tree_model_get_path (GTK_TREE_MODEL (fsmodel), &iter);
6470           gtk_tree_view_set_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view),
6471                                     path, NULL, FALSE);
6472           gtk_tree_path_free (path);
6473
6474           selected_a_file = TRUE;
6475         }
6476     }
6477
6478   browse_files_center_selected_row (impl);
6479
6480   return selected_a_file;
6481 }
6482
6483 /* Processes the pending operation when a folder is finished loading */
6484 static void
6485 pending_select_files_process (GtkFileChooserDefault *impl)
6486 {
6487   g_assert (impl->load_state == LOAD_FINISHED);
6488   g_assert (impl->browse_files_model != NULL);
6489
6490   if (impl->pending_select_files)
6491     {
6492       show_and_select_files (impl, impl->pending_select_files);
6493       pending_select_files_free (impl);
6494       browse_files_center_selected_row (impl);
6495     }
6496   else
6497     {
6498       /* We only select the first row if the chooser is actually mapped ---
6499        * selecting the first row is to help the user when he is interacting with
6500        * the chooser, but sometimes a chooser works not on behalf of the user,
6501        * but rather on behalf of something else like GtkFileChooserButton.  In
6502        * that case, the chooser's selection should be what the caller expects,
6503        * as the user can't see that something else got selected.  See bug #165264.
6504        */
6505       if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN &&
6506           gtk_widget_get_mapped (GTK_WIDGET (impl)))
6507         browse_files_select_first_row (impl);
6508     }
6509
6510   g_assert (impl->pending_select_files == NULL);
6511 }
6512
6513 static void
6514 show_error_on_reading_current_folder (GtkFileChooserDefault *impl, GError *error)
6515 {
6516   GFileInfo *info;
6517   char *msg;
6518
6519   info = g_file_query_info (impl->current_folder,
6520                             G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
6521                             G_FILE_QUERY_INFO_NONE,
6522                             NULL,
6523                             NULL);
6524   if (info)
6525     {
6526       msg = g_strdup_printf (_("Could not read the contents of %s"), g_file_info_get_display_name (info));
6527       g_object_unref (info);
6528     }
6529   else
6530     msg = g_strdup (_("Could not read the contents of the folder"));
6531
6532   error_message (impl, msg, error->message);
6533   g_free (msg);
6534 }
6535
6536 /* Callback used when the file system model finishes loading */
6537 static void
6538 browse_files_model_finished_loading_cb (GtkFileSystemModel    *model,
6539                                         GError                *error,
6540                                         GtkFileChooserDefault *impl)
6541 {
6542   profile_start ("start", NULL);
6543
6544   if (error)
6545     show_error_on_reading_current_folder (impl, error);
6546
6547   if (impl->load_state == LOAD_PRELOAD)
6548     {
6549       load_remove_timer (impl);
6550       load_set_model (impl);
6551     }
6552   else if (impl->load_state == LOAD_LOADING)
6553     {
6554       /* Nothing */
6555     }
6556   else
6557     {
6558       /* We can't g_assert_not_reached(), as something other than us may have
6559        *  initiated a folder reload.  See #165556.
6560        */
6561       profile_end ("end", NULL);
6562       return;
6563     }
6564
6565   g_assert (impl->load_timeout_id == 0);
6566
6567   impl->load_state = LOAD_FINISHED;
6568
6569   pending_select_files_process (impl);
6570   set_busy_cursor (impl, FALSE);
6571 #ifdef PROFILE_FILE_CHOOSER
6572   access ("MARK: *** FINISHED LOADING", F_OK);
6573 #endif
6574
6575   profile_end ("end", NULL);
6576 }
6577
6578 static void
6579 stop_loading_and_clear_list_model (GtkFileChooserDefault *impl,
6580                                    gboolean remove_from_treeview)
6581 {
6582   load_remove_timer (impl); /* This changes the state to LOAD_EMPTY */
6583
6584   if (impl->browse_files_model)
6585     {
6586       g_object_unref (impl->browse_files_model);
6587       impl->browse_files_model = NULL;
6588     }
6589
6590   if (remove_from_treeview)
6591     gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
6592 }
6593
6594 static char *
6595 my_g_format_time_for_display (glong secs)
6596 {
6597   GDate mtime, now;
6598   gint days_diff;
6599   struct tm tm_mtime;
6600   time_t time_mtime, time_now;
6601   const gchar *format;
6602   gchar *locale_format = NULL;
6603   gchar buf[256];
6604   char *date_str = NULL;
6605 #ifdef G_OS_WIN32
6606   const char *locale, *dot = NULL;
6607   gint64 codepage = -1;
6608   char charset[20];
6609 #endif
6610
6611   time_mtime = secs;
6612
6613 #ifdef HAVE_LOCALTIME_R
6614   localtime_r ((time_t *) &time_mtime, &tm_mtime);
6615 #else
6616   {
6617     struct tm *ptm = localtime ((time_t *) &time_mtime);
6618
6619     if (!ptm)
6620       {
6621         g_warning ("ptm != NULL failed");
6622
6623         return g_strdup (_("Unknown"));
6624       }
6625     else
6626       memcpy ((void *) &tm_mtime, (void *) ptm, sizeof (struct tm));
6627   }
6628 #endif /* HAVE_LOCALTIME_R */
6629
6630   g_date_set_time_t (&mtime, time_mtime);
6631   time_now = time (NULL);
6632   g_date_set_time_t (&now, time_now);
6633
6634   days_diff = g_date_get_julian (&now) - g_date_get_julian (&mtime);
6635
6636   /* Translators: %H means "hours" and %M means "minutes" */
6637   if (days_diff == 0)
6638     format = _("%H:%M");
6639   else if (days_diff == 1)
6640     format = _("Yesterday at %H:%M");
6641   else
6642     {
6643       if (days_diff > 1 && days_diff < 7)
6644         format = "%A"; /* Days from last week */
6645       else
6646         format = "%x"; /* Any other date */
6647     }
6648
6649 #ifdef G_OS_WIN32
6650   /* g_locale_from_utf8() returns a string in the system
6651    * code-page, which is not always the same as that used by the C
6652    * library. For instance when running a GTK+ program with
6653    * LANG=ko on an English version of Windows, the system
6654    * code-page is 1252, but the code-page used by the C library is
6655    * 949. (It's GTK+ itself that sets the C library locale when it
6656    * notices the LANG environment variable. See gtkmain.c The
6657    * Microsoft C library doesn't look at any locale environment
6658    * variables.) We need to pass strftime() a string in the C
6659    * library's code-page. See bug #509885.
6660    */
6661   locale = setlocale (LC_ALL, NULL);
6662   if (locale != NULL)
6663     dot = strchr (locale, '.');
6664   if (dot != NULL)
6665     {
6666       codepage = g_ascii_strtoll (dot+1, NULL, 10);
6667
6668       /* All codepages should fit in 16 bits AFAIK */
6669       if (codepage > 0 && codepage < 65536)
6670         {
6671           sprintf (charset, "CP%u", (guint) codepage);
6672           locale_format = g_convert (format, -1, charset, "UTF-8", NULL, NULL, NULL);
6673         }
6674     }
6675 #else
6676   locale_format = g_locale_from_utf8 (format, -1, NULL, NULL, NULL);
6677 #endif
6678   if (locale_format != NULL &&
6679       strftime (buf, sizeof (buf), locale_format, &tm_mtime) != 0)
6680     {
6681 #ifdef G_OS_WIN32
6682       /* As above but in opposite direction... */
6683       if (codepage > 0 && codepage < 65536)
6684         date_str = g_convert (buf, -1, "UTF-8", charset, NULL, NULL, NULL);
6685 #else
6686       date_str = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
6687 #endif
6688     }
6689
6690   if (date_str == NULL)
6691     date_str = g_strdup (_("Unknown"));
6692
6693   g_free (locale_format);
6694   return date_str;
6695 }
6696
6697 static void
6698 copy_attribute (GFileInfo *to, GFileInfo *from, const char *attribute)
6699 {
6700   GFileAttributeType type;
6701   gpointer value;
6702
6703   if (g_file_info_get_attribute_data (from, attribute, &type, &value, NULL))
6704     g_file_info_set_attribute (to, attribute, type, value);
6705 }
6706
6707 static void
6708 file_system_model_got_thumbnail (GObject *object, GAsyncResult *res, gpointer data)
6709 {
6710   GtkFileSystemModel *model = data; /* might be unreffed if operation was cancelled */
6711   GFile *file = G_FILE (object);
6712   GFileInfo *queried, *info;
6713   GtkTreeIter iter;
6714
6715   queried = g_file_query_info_finish (file, res, NULL);
6716   if (queried == NULL)
6717     return;
6718
6719   gdk_threads_enter ();
6720
6721   /* now we know model is valid */
6722
6723   /* file was deleted */
6724   if (!_gtk_file_system_model_get_iter_for_file (model, &iter, file))
6725     {
6726       gdk_threads_leave ();
6727       return;
6728     }
6729
6730   info = g_file_info_dup (_gtk_file_system_model_get_info (model, &iter));
6731
6732   copy_attribute (info, queried, G_FILE_ATTRIBUTE_THUMBNAIL_PATH);
6733   copy_attribute (info, queried, G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
6734   copy_attribute (info, queried, G_FILE_ATTRIBUTE_STANDARD_ICON);
6735
6736   _gtk_file_system_model_update_file (model, file, info);
6737
6738   g_object_unref (info);
6739
6740   gdk_threads_leave ();
6741 }
6742
6743 static gboolean
6744 file_system_model_set (GtkFileSystemModel *model,
6745                        GFile              *file,
6746                        GFileInfo          *info,
6747                        int                 column,
6748                        GValue             *value,
6749                        gpointer            data)
6750 {
6751   GtkFileChooserDefault *impl = data;
6752
6753   switch (column)
6754     {
6755     case MODEL_COL_FILE:
6756       g_value_set_object (value, file);
6757       break;
6758     case MODEL_COL_NAME:
6759       if (info == NULL)
6760         g_value_set_string (value, DEFAULT_NEW_FOLDER_NAME);
6761       else
6762         g_value_set_string (value, g_file_info_get_display_name (info));
6763       break;
6764     case MODEL_COL_NAME_COLLATED:
6765       if (info == NULL)
6766         g_value_take_string (value, g_utf8_collate_key_for_filename (DEFAULT_NEW_FOLDER_NAME, -1));
6767       else
6768         g_value_take_string (value, g_utf8_collate_key_for_filename (g_file_info_get_display_name (info), -1));
6769       break;
6770     case MODEL_COL_IS_FOLDER:
6771       g_value_set_boolean (value, info == NULL || _gtk_file_info_consider_as_directory (info));
6772       break;
6773     case MODEL_COL_IS_SENSITIVE:
6774       if (info)
6775         {
6776           gboolean sensitive = TRUE;
6777
6778           if (!(impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
6779                 || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER))
6780             {
6781               sensitive = TRUE; /* for file modes... */
6782             }
6783           else if (!_gtk_file_info_consider_as_directory (info))
6784             {
6785               sensitive = FALSE; /* for folder modes, files are not sensitive... */
6786             }
6787           else
6788             {
6789               /* ... and for folder modes, folders are sensitive only if the filter says so */
6790               GtkTreeIter iter;
6791               if (!_gtk_file_system_model_get_iter_for_file (model, &iter, file))
6792                 g_assert_not_reached ();
6793               sensitive = !_gtk_file_system_model_iter_is_filtered_out (model, &iter);
6794             }
6795
6796           g_value_set_boolean (value, sensitive);
6797         }
6798       else
6799         g_value_set_boolean (value, TRUE);
6800       break;
6801     case MODEL_COL_PIXBUF:
6802       if (info)
6803         {
6804           if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_ICON))
6805             {
6806               g_value_take_object (value, _gtk_file_info_render_icon (info, GTK_WIDGET (impl), impl->icon_size));
6807             }
6808           else
6809             {
6810               GtkTreeModel *tree_model;
6811               GtkTreePath *path, *start, *end;
6812               GtkTreeIter iter;
6813
6814               if (impl->browse_files_tree_view == NULL ||
6815                   g_file_info_has_attribute (info, "filechooser::queried"))
6816                 return FALSE;
6817
6818               tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
6819               if (tree_model != GTK_TREE_MODEL (model))
6820                 return FALSE;
6821
6822               if (!_gtk_file_system_model_get_iter_for_file (model,
6823                                                              &iter,
6824                                                              file))
6825                 g_assert_not_reached ();
6826               if (!gtk_tree_view_get_visible_range (GTK_TREE_VIEW (impl->browse_files_tree_view), &start, &end))
6827                 return FALSE;
6828               path = gtk_tree_model_get_path (tree_model, &iter);
6829               if (gtk_tree_path_compare (start, path) != 1 &&
6830                   gtk_tree_path_compare (path, end) != 1)
6831                 {
6832                   g_file_info_set_attribute_boolean (info, "filechooser::queried", TRUE);
6833                   g_file_query_info_async (file,
6834                                            G_FILE_ATTRIBUTE_THUMBNAIL_PATH ","
6835                                            G_FILE_ATTRIBUTE_THUMBNAILING_FAILED ","
6836                                            G_FILE_ATTRIBUTE_STANDARD_ICON,
6837                                            G_FILE_QUERY_INFO_NONE,
6838                                            G_PRIORITY_DEFAULT,
6839                                            _gtk_file_system_model_get_cancellable (model),
6840                                            file_system_model_got_thumbnail,
6841                                            model);
6842                 }
6843               gtk_tree_path_free (path);
6844               gtk_tree_path_free (start);
6845               gtk_tree_path_free (end);
6846               return FALSE;
6847             }
6848         }
6849       else
6850         g_value_set_object (value, NULL);
6851       break;
6852     case MODEL_COL_SIZE:
6853       g_value_set_int64 (value, info ? g_file_info_get_size (info) : 0);
6854       break;
6855     case MODEL_COL_SIZE_TEXT:
6856       if (info == NULL || _gtk_file_info_consider_as_directory (info))
6857         g_value_set_string (value, NULL);
6858       else
6859         g_value_take_string (value, g_format_size (g_file_info_get_size (info)));
6860       break;
6861     case MODEL_COL_MTIME:
6862     case MODEL_COL_MTIME_TEXT:
6863       {
6864         GTimeVal tv;
6865         if (info == NULL)
6866           break;
6867         g_file_info_get_modification_time (info, &tv);
6868         if (column == MODEL_COL_MTIME)
6869           g_value_set_long (value, tv.tv_sec);
6870         else if (tv.tv_sec == 0)
6871           g_value_set_static_string (value, _("Unknown"));
6872         else
6873           g_value_take_string (value, my_g_format_time_for_display (tv.tv_sec));
6874         break;
6875       }
6876     case MODEL_COL_ELLIPSIZE:
6877       g_value_set_enum (value, info ? PANGO_ELLIPSIZE_END : PANGO_ELLIPSIZE_NONE);
6878       break;
6879     default:
6880       g_assert_not_reached ();
6881       break;
6882     }
6883
6884   return TRUE;
6885 }
6886
6887 /* Gets rid of the old list model and creates a new one for the current folder */
6888 static gboolean
6889 set_list_model (GtkFileChooserDefault *impl,
6890                 GError               **error)
6891 {
6892   g_assert (impl->current_folder != NULL);
6893
6894   profile_start ("start", NULL);
6895
6896   stop_loading_and_clear_list_model (impl, TRUE);
6897
6898   set_busy_cursor (impl, TRUE);
6899
6900   impl->browse_files_model =
6901     _gtk_file_system_model_new_for_directory (impl->current_folder,
6902                                               MODEL_ATTRIBUTES,
6903                                               file_system_model_set,
6904                                               impl,
6905                                               MODEL_COLUMN_TYPES);
6906
6907   _gtk_file_system_model_set_show_hidden (impl->browse_files_model, impl->show_hidden);
6908
6909   profile_msg ("    set sort function", NULL);
6910   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_NAME, name_sort_func, impl, NULL);
6911   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_SIZE, size_sort_func, impl, NULL);
6912   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_MTIME, mtime_sort_func, impl, NULL);
6913   gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), NULL, NULL, NULL);
6914   set_sort_column (impl);
6915   impl->list_sort_ascending = TRUE;
6916   g_signal_connect (impl->browse_files_model, "sort-column-changed",
6917                     G_CALLBACK (list_sort_column_changed_cb), impl);
6918
6919   load_setup_timer (impl); /* This changes the state to LOAD_PRELOAD */
6920
6921   g_signal_connect (impl->browse_files_model, "finished-loading",
6922                     G_CALLBACK (browse_files_model_finished_loading_cb), impl);
6923
6924   _gtk_file_system_model_set_filter (impl->browse_files_model, impl->current_filter);
6925
6926   profile_end ("end", NULL);
6927
6928   return TRUE;
6929 }
6930
6931 struct update_chooser_entry_selected_foreach_closure {
6932   int num_selected;
6933   GtkTreeIter first_selected_iter;
6934 };
6935
6936 static gint
6937 compare_utf8_filenames (const gchar *a,
6938                         const gchar *b)
6939 {
6940   gchar *a_folded, *b_folded;
6941   gint retval;
6942
6943   a_folded = g_utf8_strdown (a, -1);
6944   b_folded = g_utf8_strdown (b, -1);
6945
6946   retval = strcmp (a_folded, b_folded);
6947
6948   g_free (a_folded);
6949   g_free (b_folded);
6950
6951   return retval;
6952 }
6953
6954 static void
6955 update_chooser_entry_selected_foreach (GtkTreeModel *model,
6956                                        GtkTreePath *path,
6957                                        GtkTreeIter *iter,
6958                                        gpointer data)
6959 {
6960   struct update_chooser_entry_selected_foreach_closure *closure;
6961
6962   closure = data;
6963   closure->num_selected++;
6964
6965   if (closure->num_selected == 1)
6966     closure->first_selected_iter = *iter;
6967 }
6968
6969 static void
6970 update_chooser_entry (GtkFileChooserDefault *impl)
6971 {
6972   GtkTreeSelection *selection;
6973   struct update_chooser_entry_selected_foreach_closure closure;
6974
6975   /* no need to update the file chooser's entry if there's no entry */
6976   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
6977       !impl->location_entry)
6978     return;
6979
6980   if (!(impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
6981         || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
6982         || ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
6983              || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
6984             && impl->location_mode == LOCATION_MODE_FILENAME_ENTRY)))
6985     return;
6986
6987   g_assert (impl->location_entry != NULL);
6988
6989   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
6990   closure.num_selected = 0;
6991   gtk_tree_selection_selected_foreach (selection, update_chooser_entry_selected_foreach, &closure);
6992
6993   if (closure.num_selected == 0)
6994     {
6995       if (impl->operation_mode == OPERATION_MODE_RECENT)
6996         _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), NULL);
6997       else
6998         goto maybe_clear_entry;
6999     }
7000   else if (closure.num_selected == 1)
7001     {
7002       if (impl->operation_mode == OPERATION_MODE_BROWSE)
7003         {
7004           GFileInfo *info;
7005           gboolean change_entry;
7006
7007           info = _gtk_file_system_model_get_info (impl->browse_files_model, &closure.first_selected_iter);
7008
7009           /* If the cursor moved to the row of the newly created folder,
7010            * retrieving info will return NULL.
7011            */
7012           if (!info)
7013             return;
7014
7015           g_free (impl->browse_files_last_selected_name);
7016           impl->browse_files_last_selected_name =
7017             g_strdup (g_file_info_get_display_name (info));
7018
7019           if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
7020               impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7021               impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
7022             {
7023               /* Don't change the name when clicking on a folder... */
7024               change_entry = (! _gtk_file_info_consider_as_directory (info));
7025             }
7026           else
7027             change_entry = TRUE; /* ... unless we are in SELECT_FOLDER mode */
7028
7029           if (change_entry)
7030             {
7031               gtk_entry_set_text (GTK_ENTRY (impl->location_entry), impl->browse_files_last_selected_name);
7032
7033               if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7034                 _gtk_file_chooser_entry_select_filename (GTK_FILE_CHOOSER_ENTRY (impl->location_entry));
7035             }
7036
7037           return;
7038         }
7039       else if (impl->operation_mode == OPERATION_MODE_RECENT
7040                && impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7041         {
7042           GFile *folder;
7043
7044           /* Set the base folder on the name entry, so it will do completion relative to the correct recent-folder */
7045
7046           gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &closure.first_selected_iter,
7047                               MODEL_COL_FILE, &folder,
7048                               -1);
7049           _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), folder);
7050           g_object_unref (folder);
7051           return;
7052         }
7053     }
7054   else
7055     {
7056       g_assert (!(impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7057                   impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER));
7058
7059       /* Multiple selection, so just clear the entry. */
7060       g_free (impl->browse_files_last_selected_name);
7061       impl->browse_files_last_selected_name = NULL;
7062
7063       gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
7064       return;
7065     }
7066
7067  maybe_clear_entry:
7068
7069   if ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
7070       && impl->browse_files_last_selected_name)
7071     {
7072       const char *entry_text;
7073       int len;
7074       gboolean clear_entry;
7075
7076       entry_text = gtk_entry_get_text (GTK_ENTRY (impl->location_entry));
7077       len = strlen (entry_text);
7078       if (len != 0)
7079         {
7080           /* The file chooser entry may have appended a "/" to its text.
7081            * So take it out, and compare the result to the old selection.
7082            */
7083           if (entry_text[len - 1] == G_DIR_SEPARATOR)
7084             {
7085               gchar *tmp;
7086
7087               tmp = g_strndup (entry_text, len - 1);
7088               clear_entry = (compare_utf8_filenames (impl->browse_files_last_selected_name, tmp) == 0);
7089               g_free (tmp);
7090             }
7091           else
7092             clear_entry = (compare_utf8_filenames (impl->browse_files_last_selected_name, entry_text) == 0);
7093         }
7094       else
7095         clear_entry = FALSE;
7096
7097       if (clear_entry)
7098         gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
7099     }
7100 }
7101
7102 static gboolean
7103 gtk_file_chooser_default_set_current_folder (GtkFileChooser  *chooser,
7104                                              GFile           *file,
7105                                              GError         **error)
7106 {
7107   return gtk_file_chooser_default_update_current_folder (chooser, file, FALSE, FALSE, error);
7108 }
7109
7110
7111 struct UpdateCurrentFolderData
7112 {
7113   GtkFileChooserDefault *impl;
7114   GFile *file;
7115   gboolean keep_trail;
7116   gboolean clear_entry;
7117   GFile *original_file;
7118   GError *original_error;
7119 };
7120
7121 static void
7122 update_current_folder_mount_enclosing_volume_cb (GCancellable        *cancellable,
7123                                                  GtkFileSystemVolume *volume,
7124                                                  const GError        *error,
7125                                                  gpointer             user_data)
7126 {
7127   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
7128   struct UpdateCurrentFolderData *data = user_data;
7129   GtkFileChooserDefault *impl = data->impl;
7130
7131   if (cancellable != impl->update_current_folder_cancellable)
7132     goto out;
7133
7134   impl->update_current_folder_cancellable = NULL;
7135   set_busy_cursor (impl, FALSE);
7136
7137   if (cancelled)
7138     goto out;
7139
7140   if (error)
7141     {
7142       error_changing_folder_dialog (data->impl, data->file, g_error_copy (error));
7143       impl->reload_state = RELOAD_EMPTY;
7144       goto out;
7145     }
7146
7147   change_folder_and_display_error (impl, data->file, data->clear_entry);
7148
7149 out:
7150   g_object_unref (data->file);
7151   g_free (data);
7152
7153   g_object_unref (cancellable);
7154 }
7155
7156 static void
7157 update_current_folder_get_info_cb (GCancellable *cancellable,
7158                                    GFileInfo    *info,
7159                                    const GError *error,
7160                                    gpointer      user_data)
7161 {
7162   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
7163   struct UpdateCurrentFolderData *data = user_data;
7164   GtkFileChooserDefault *impl = data->impl;
7165
7166   if (cancellable != impl->update_current_folder_cancellable)
7167     goto out;
7168
7169   impl->update_current_folder_cancellable = NULL;
7170   impl->reload_state = RELOAD_EMPTY;
7171
7172   set_busy_cursor (impl, FALSE);
7173
7174   if (cancelled)
7175     goto out;
7176
7177   if (error)
7178     {
7179       GFile *parent_file;
7180
7181       if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED))
7182         {
7183           GMountOperation *mount_operation;
7184           GtkWidget *toplevel;
7185
7186           g_object_unref (cancellable);
7187           toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
7188
7189           mount_operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
7190
7191           set_busy_cursor (impl, TRUE);
7192
7193           impl->update_current_folder_cancellable =
7194             _gtk_file_system_mount_enclosing_volume (impl->file_system, data->file,
7195                                                      mount_operation,
7196                                                      update_current_folder_mount_enclosing_volume_cb,
7197                                                      data);
7198
7199           return;
7200         }
7201
7202       if (!data->original_file)
7203         {
7204           data->original_file = g_object_ref (data->file);
7205           data->original_error = g_error_copy (error);
7206         }
7207
7208       parent_file = g_file_get_parent (data->file);
7209
7210       /* get parent path and try to change the folder to that */
7211       if (parent_file)
7212         {
7213           g_object_unref (data->file);
7214           data->file = parent_file;
7215
7216           g_object_unref (cancellable);
7217
7218           /* restart the update current folder operation */
7219           impl->reload_state = RELOAD_HAS_FOLDER;
7220
7221           impl->update_current_folder_cancellable =
7222             _gtk_file_system_get_info (impl->file_system, data->file,
7223                                        "standard::type",
7224                                        update_current_folder_get_info_cb,
7225                                        data);
7226
7227           set_busy_cursor (impl, TRUE);
7228
7229           return;
7230         }
7231       else
7232         {
7233           /* Error and bail out, ignoring "not found" errors since they're useless:
7234            * they only happen when a program defaults to a folder that has been (re)moved.
7235            */
7236           if (!g_error_matches (data->original_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
7237             error_changing_folder_dialog (impl, data->original_file, data->original_error);
7238           else
7239             g_error_free (data->original_error);
7240
7241           g_object_unref (data->original_file);
7242
7243           goto out;
7244         }
7245     }
7246
7247   if (data->original_file)
7248     {
7249       /* Error and bail out, ignoring "not found" errors since they're useless:
7250        * they only happen when a program defaults to a folder that has been (re)moved.
7251        */
7252       if (!g_error_matches (data->original_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
7253         error_changing_folder_dialog (impl, data->original_file, data->original_error);
7254       else
7255         g_error_free (data->original_error);
7256
7257       g_object_unref (data->original_file);
7258     }
7259
7260   if (! _gtk_file_info_consider_as_directory (info))
7261     goto out;
7262
7263   _gtk_path_bar_set_file (GTK_PATH_BAR (impl->browse_path_bar), data->file, data->keep_trail);
7264
7265   if (impl->current_folder != data->file)
7266     {
7267       if (impl->current_folder)
7268         g_object_unref (impl->current_folder);
7269
7270       impl->current_folder = g_object_ref (data->file);
7271     }
7272
7273   impl->reload_state = RELOAD_HAS_FOLDER;
7274
7275   /* Update the widgets that may trigger a folder change themselves.  */
7276
7277   if (!impl->changing_folder)
7278     {
7279       impl->changing_folder = TRUE;
7280
7281       shortcuts_update_current_folder (impl);
7282
7283       impl->changing_folder = FALSE;
7284     }
7285
7286   /* Set the folder on the save entry */
7287
7288   if (impl->location_entry)
7289     {
7290       _gtk_file_chooser_entry_set_base_folder (GTK_FILE_CHOOSER_ENTRY (impl->location_entry),
7291                                                impl->current_folder);
7292
7293       if (data->clear_entry)
7294         gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
7295     }
7296
7297   /* Create a new list model.  This is slightly evil; we store the result value
7298    * but perform more actions rather than returning immediately even if it
7299    * generates an error.
7300    */
7301   set_list_model (impl, NULL);
7302
7303   /* Refresh controls */
7304
7305   shortcuts_find_current_folder (impl);
7306
7307   g_signal_emit_by_name (impl, "current-folder-changed", 0);
7308
7309   check_preview_change (impl);
7310   bookmarks_check_add_sensitivity (impl);
7311
7312   g_signal_emit_by_name (impl, "selection-changed", 0);
7313
7314 out:
7315   g_object_unref (data->file);
7316   g_free (data);
7317
7318   g_object_unref (cancellable);
7319 }
7320
7321 static gboolean
7322 gtk_file_chooser_default_update_current_folder (GtkFileChooser    *chooser,
7323                                                 GFile             *file,
7324                                                 gboolean           keep_trail,
7325                                                 gboolean           clear_entry,
7326                                                 GError           **error)
7327 {
7328   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7329   struct UpdateCurrentFolderData *data;
7330
7331   profile_start ("start", NULL);
7332
7333   g_object_ref (file);
7334
7335   operation_mode_set (impl, OPERATION_MODE_BROWSE);
7336
7337   if (impl->local_only && !g_file_is_native (file))
7338     {
7339       g_set_error_literal (error,
7340                            GTK_FILE_CHOOSER_ERROR,
7341                            GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
7342                            _("Cannot change to folder because it is not local"));
7343
7344       g_object_unref (file);
7345       profile_end ("end - not local", NULL);
7346       return FALSE;
7347     }
7348
7349   if (impl->update_current_folder_cancellable)
7350     g_cancellable_cancel (impl->update_current_folder_cancellable);
7351
7352   /* Test validity of path here.  */
7353   data = g_new0 (struct UpdateCurrentFolderData, 1);
7354   data->impl = impl;
7355   data->file = g_object_ref (file);
7356   data->keep_trail = keep_trail;
7357   data->clear_entry = clear_entry;
7358
7359   impl->reload_state = RELOAD_HAS_FOLDER;
7360
7361   impl->update_current_folder_cancellable =
7362     _gtk_file_system_get_info (impl->file_system, file,
7363                                "standard::type",
7364                                update_current_folder_get_info_cb,
7365                                data);
7366
7367   set_busy_cursor (impl, TRUE);
7368   g_object_unref (file);
7369
7370   profile_end ("end", NULL);
7371   return TRUE;
7372 }
7373
7374 static GFile *
7375 gtk_file_chooser_default_get_current_folder (GtkFileChooser *chooser)
7376 {
7377   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7378
7379   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
7380       impl->operation_mode == OPERATION_MODE_RECENT)
7381     return NULL;
7382
7383   if (impl->current_folder)
7384     return g_object_ref (impl->current_folder);
7385
7386   return NULL;
7387 }
7388
7389 static void
7390 gtk_file_chooser_default_set_current_name (GtkFileChooser *chooser,
7391                                            const gchar    *name)
7392 {
7393   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7394
7395   g_return_if_fail (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7396                     impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER);
7397
7398   pending_select_files_free (impl);
7399   gtk_entry_set_text (GTK_ENTRY (impl->location_entry), name);
7400 }
7401
7402 static gboolean
7403 gtk_file_chooser_default_select_file (GtkFileChooser  *chooser,
7404                                       GFile           *file,
7405                                       GError         **error)
7406 {
7407   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7408   GFile *parent_file;
7409   gboolean same_path;
7410
7411   parent_file = g_file_get_parent (file);
7412
7413   if (!parent_file)
7414     return gtk_file_chooser_set_current_folder_file (chooser, file, error);
7415
7416   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
7417       impl->operation_mode == OPERATION_MODE_RECENT ||
7418       impl->load_state == LOAD_EMPTY)
7419     {
7420       same_path = FALSE;
7421     }
7422   else
7423     {
7424       g_assert (impl->current_folder != NULL);
7425
7426       same_path = g_file_equal (parent_file, impl->current_folder);
7427     }
7428
7429   if (same_path && impl->load_state == LOAD_FINISHED)
7430     {
7431       gboolean result;
7432       GSList files;
7433
7434       files.data = (gpointer) file;
7435       files.next = NULL;
7436
7437       result = show_and_select_files (impl, &files);
7438       g_object_unref (parent_file);
7439       return result;
7440     }
7441
7442   pending_select_files_add (impl, file);
7443
7444   if (!same_path)
7445     {
7446       gboolean result;
7447
7448       result = gtk_file_chooser_set_current_folder_file (chooser, parent_file, error);
7449       g_object_unref (parent_file);
7450       return result;
7451     }
7452
7453   g_object_unref (parent_file);
7454   return TRUE;
7455 }
7456
7457 static void
7458 gtk_file_chooser_default_unselect_file (GtkFileChooser *chooser,
7459                                         GFile          *file)
7460 {
7461   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7462   GtkTreeView *tree_view = GTK_TREE_VIEW (impl->browse_files_tree_view);
7463   GtkTreeIter iter;
7464
7465   if (!impl->browse_files_model)
7466     return;
7467
7468   if (!_gtk_file_system_model_get_iter_for_file (impl->browse_files_model,
7469                                                  &iter,
7470                                                  file))
7471     return;
7472
7473   gtk_tree_selection_unselect_iter (gtk_tree_view_get_selection (tree_view),
7474                                     &iter);
7475 }
7476
7477 static gboolean
7478 maybe_select (GtkTreeModel *model,
7479               GtkTreePath  *path,
7480               GtkTreeIter  *iter,
7481               gpointer     data)
7482 {
7483   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (data);
7484   GtkTreeSelection *selection;
7485   gboolean is_sensitive;
7486   gboolean is_folder;
7487
7488   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7489
7490   gtk_tree_model_get (model, iter,
7491                       MODEL_COL_IS_FOLDER, &is_folder,
7492                       MODEL_COL_IS_SENSITIVE, &is_sensitive,
7493                       -1);
7494
7495   if (is_sensitive &&
7496       ((is_folder && impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ||
7497        (!is_folder && impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)))
7498     gtk_tree_selection_select_iter (selection, iter);
7499   else
7500     gtk_tree_selection_unselect_iter (selection, iter);
7501
7502   return FALSE;
7503 }
7504
7505 static void
7506 gtk_file_chooser_default_select_all (GtkFileChooser *chooser)
7507 {
7508   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7509
7510   if (impl->operation_mode == OPERATION_MODE_SEARCH ||
7511       impl->operation_mode == OPERATION_MODE_RECENT)
7512     {
7513       GtkTreeSelection *selection;
7514
7515       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7516       gtk_tree_selection_select_all (selection);
7517       return;
7518     }
7519
7520   if (impl->select_multiple)
7521     gtk_tree_model_foreach (GTK_TREE_MODEL (impl->browse_files_model),
7522                             maybe_select, impl);
7523 }
7524
7525 static void
7526 gtk_file_chooser_default_unselect_all (GtkFileChooser *chooser)
7527 {
7528   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7529   GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7530
7531   gtk_tree_selection_unselect_all (selection);
7532   pending_select_files_free (impl);
7533 }
7534
7535 /* Checks whether the filename entry for the Save modes contains a well-formed filename.
7536  *
7537  * is_well_formed_ret - whether what the user typed passes gkt_file_system_make_path()
7538  *
7539  * is_empty_ret - whether the file entry is totally empty
7540  *
7541  * is_file_part_empty_ret - whether the file part is empty (will be if user types "foobar/", and
7542  *                          the path will be "$cwd/foobar")
7543  */
7544 static void
7545 check_save_entry (GtkFileChooserDefault *impl,
7546                   GFile                **file_ret,
7547                   gboolean              *is_well_formed_ret,
7548                   gboolean              *is_empty_ret,
7549                   gboolean              *is_file_part_empty_ret,
7550                   gboolean              *is_folder)
7551 {
7552   GtkFileChooserEntry *chooser_entry;
7553   GFile *current_folder;
7554   const char *file_part;
7555   GFile *file;
7556   GError *error;
7557
7558   g_assert (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
7559             || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
7560             || ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
7561                  || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
7562                 && impl->location_mode == LOCATION_MODE_FILENAME_ENTRY));
7563
7564   chooser_entry = GTK_FILE_CHOOSER_ENTRY (impl->location_entry);
7565
7566   if (strlen (gtk_entry_get_text (GTK_ENTRY (chooser_entry))) == 0)
7567     {
7568       *file_ret = NULL;
7569       *is_well_formed_ret = TRUE;
7570       *is_empty_ret = TRUE;
7571       *is_file_part_empty_ret = TRUE;
7572       *is_folder = FALSE;
7573
7574       return;
7575     }
7576
7577   *is_empty_ret = FALSE;
7578
7579   current_folder = _gtk_file_chooser_entry_get_current_folder (chooser_entry);
7580   if (!current_folder)
7581     {
7582       *file_ret = NULL;
7583       *is_well_formed_ret = FALSE;
7584       *is_file_part_empty_ret = FALSE;
7585       *is_folder = FALSE;
7586
7587       return;
7588     }
7589
7590   file_part = _gtk_file_chooser_entry_get_file_part (chooser_entry);
7591
7592   if (!file_part || file_part[0] == '\0')
7593     {
7594       *file_ret = current_folder;
7595       *is_well_formed_ret = TRUE;
7596       *is_file_part_empty_ret = TRUE;
7597       *is_folder = TRUE;
7598
7599       return;
7600     }
7601
7602   *is_file_part_empty_ret = FALSE;
7603
7604   error = NULL;
7605   file = g_file_get_child_for_display_name (current_folder, file_part, &error);
7606   g_object_unref (current_folder);
7607
7608   if (!file)
7609     {
7610       error_building_filename_dialog (impl, error);
7611       *file_ret = NULL;
7612       *is_well_formed_ret = FALSE;
7613       *is_folder = FALSE;
7614
7615       return;
7616     }
7617
7618   *file_ret = file;
7619   *is_well_formed_ret = TRUE;
7620   *is_folder = _gtk_file_chooser_entry_get_is_folder (chooser_entry, file);
7621 }
7622
7623 struct get_files_closure {
7624   GtkFileChooserDefault *impl;
7625   GSList *result;
7626   GFile *file_from_entry;
7627 };
7628
7629 static void
7630 get_files_foreach (GtkTreeModel *model,
7631                    GtkTreePath  *path,
7632                    GtkTreeIter  *iter,
7633                    gpointer      data)
7634 {
7635   struct get_files_closure *info;
7636   GFile *file;
7637   GtkFileSystemModel *fs_model;
7638
7639   info = data;
7640   fs_model = info->impl->browse_files_model;
7641
7642   file = _gtk_file_system_model_get_file (fs_model, iter);
7643   if (!file)
7644     return; /* We are on the editable row */
7645
7646   if (!info->file_from_entry || !g_file_equal (info->file_from_entry, file))
7647     info->result = g_slist_prepend (info->result, g_object_ref (file));
7648 }
7649
7650 static GSList *
7651 gtk_file_chooser_default_get_files (GtkFileChooser *chooser)
7652 {
7653   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7654   struct get_files_closure info;
7655   GtkWindow *toplevel;
7656   GtkWidget *current_focus;
7657   gboolean file_list_seen;
7658
7659   info.impl = impl;
7660   info.result = NULL;
7661   info.file_from_entry = NULL;
7662
7663   if (impl->operation_mode == OPERATION_MODE_SEARCH)
7664     return search_get_selected_files (impl);
7665
7666   if (impl->operation_mode == OPERATION_MODE_RECENT)
7667     {
7668       if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7669         {
7670           file_list_seen = TRUE;
7671           goto file_entry;
7672         }
7673       else
7674         return recent_get_selected_files (impl);
7675     }
7676
7677   toplevel = get_toplevel (GTK_WIDGET (impl));
7678   if (toplevel)
7679     current_focus = gtk_window_get_focus (toplevel);
7680   else
7681     current_focus = NULL;
7682
7683   file_list_seen = FALSE;
7684   if (current_focus == impl->browse_files_tree_view)
7685     {
7686       GtkTreeSelection *selection;
7687
7688     file_list:
7689
7690       file_list_seen = TRUE;
7691       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
7692       gtk_tree_selection_selected_foreach (selection, get_files_foreach, &info);
7693
7694       /* If there is no selection in the file list, we probably have this situation:
7695        *
7696        * 1. The user typed a filename in the SAVE filename entry ("foo.txt").
7697        * 2. He then double-clicked on a folder ("bar") in the file list
7698        *
7699        * So we want the selection to be "bar/foo.txt".  Jump to the case for the
7700        * filename entry to see if that is the case.
7701        */
7702       if (info.result == NULL && impl->location_entry)
7703         goto file_entry;
7704     }
7705   else if (impl->location_entry && current_focus == impl->location_entry)
7706     {
7707       gboolean is_well_formed, is_empty, is_file_part_empty, is_folder;
7708
7709     file_entry:
7710
7711       check_save_entry (impl, &info.file_from_entry, &is_well_formed, &is_empty, &is_file_part_empty, &is_folder);
7712
7713       if (is_empty)
7714         goto out;
7715
7716       if (!is_well_formed)
7717         return NULL;
7718
7719       if (is_file_part_empty && impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
7720         {
7721           g_object_unref (info.file_from_entry);
7722           return NULL;
7723         }
7724
7725       if (info.file_from_entry)
7726         info.result = g_slist_prepend (info.result, info.file_from_entry);
7727       else if (!file_list_seen)
7728         goto file_list;
7729       else
7730         return NULL;
7731     }
7732   else if (impl->toplevel_last_focus_widget == impl->browse_files_tree_view)
7733     goto file_list;
7734   else if (impl->location_entry && impl->toplevel_last_focus_widget == impl->location_entry)
7735     goto file_entry;
7736   else
7737     {
7738       /* The focus is on a dialog's action area button or something else */
7739       if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
7740           impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
7741         goto file_entry;
7742       else
7743         goto file_list;
7744     }
7745
7746  out:
7747
7748   /* If there's no folder selected, and we're in SELECT_FOLDER mode, then we
7749    * fall back to the current directory */
7750   if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER &&
7751       info.result == NULL)
7752     {
7753       GFile *current_folder;
7754
7755       current_folder = gtk_file_chooser_get_current_folder_file (chooser);
7756
7757       if (current_folder)
7758         info.result = g_slist_prepend (info.result, current_folder);
7759     }
7760
7761   return g_slist_reverse (info.result);
7762 }
7763
7764 GFile *
7765 gtk_file_chooser_default_get_preview_file (GtkFileChooser *chooser)
7766 {
7767   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7768
7769   if (impl->preview_file)
7770     return g_object_ref (impl->preview_file);
7771   else
7772     return NULL;
7773 }
7774
7775 static GtkFileSystem *
7776 gtk_file_chooser_default_get_file_system (GtkFileChooser *chooser)
7777 {
7778   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7779
7780   return impl->file_system;
7781 }
7782
7783 /* Shows or hides the filter widgets */
7784 static void
7785 show_filters (GtkFileChooserDefault *impl,
7786               gboolean               show)
7787 {
7788   if (show)
7789     gtk_widget_show (impl->filter_combo_hbox);
7790   else
7791     gtk_widget_hide (impl->filter_combo_hbox);
7792 }
7793
7794 static void
7795 gtk_file_chooser_default_add_filter (GtkFileChooser *chooser,
7796                                      GtkFileFilter  *filter)
7797 {
7798   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7799   const gchar *name;
7800
7801   if (g_slist_find (impl->filters, filter))
7802     {
7803       g_warning ("gtk_file_chooser_add_filter() called on filter already in list\n");
7804       return;
7805     }
7806
7807   g_object_ref_sink (filter);
7808   impl->filters = g_slist_append (impl->filters, filter);
7809
7810   name = gtk_file_filter_get_name (filter);
7811   if (!name)
7812     name = "Untitled filter";   /* Place-holder, doesn't need to be marked for translation */
7813
7814   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (impl->filter_combo), name);
7815
7816   if (!g_slist_find (impl->filters, impl->current_filter))
7817     set_current_filter (impl, filter);
7818
7819   show_filters (impl, TRUE);
7820 }
7821
7822 static void
7823 gtk_file_chooser_default_remove_filter (GtkFileChooser *chooser,
7824                                         GtkFileFilter  *filter)
7825 {
7826   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7827   GtkTreeModel *model;
7828   GtkTreeIter iter;
7829   gint filter_index;
7830
7831   filter_index = g_slist_index (impl->filters, filter);
7832
7833   if (filter_index < 0)
7834     {
7835       g_warning ("gtk_file_chooser_remove_filter() called on filter not in list\n");
7836       return;
7837     }
7838
7839   impl->filters = g_slist_remove (impl->filters, filter);
7840
7841   if (filter == impl->current_filter)
7842     {
7843       if (impl->filters)
7844         set_current_filter (impl, impl->filters->data);
7845       else
7846         set_current_filter (impl, NULL);
7847     }
7848
7849   /* Remove row from the combo box */
7850   model = gtk_combo_box_get_model (GTK_COMBO_BOX (impl->filter_combo));
7851   if (!gtk_tree_model_iter_nth_child  (model, &iter, NULL, filter_index))
7852     g_assert_not_reached ();
7853
7854   gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
7855
7856   g_object_unref (filter);
7857
7858   if (!impl->filters)
7859     show_filters (impl, FALSE);
7860 }
7861
7862 static GSList *
7863 gtk_file_chooser_default_list_filters (GtkFileChooser *chooser)
7864 {
7865   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7866
7867   return g_slist_copy (impl->filters);
7868 }
7869
7870 /* Returns the position in the shortcuts tree where the nth specified shortcut would appear */
7871 static int
7872 shortcuts_get_pos_for_shortcut_folder (GtkFileChooserDefault *impl,
7873                                        int                    pos)
7874 {
7875   return pos + shortcuts_get_index (impl, SHORTCUTS_SHORTCUTS);
7876 }
7877
7878 struct AddShortcutData
7879 {
7880   GtkFileChooserDefault *impl;
7881   GFile *file;
7882 };
7883
7884 static void
7885 add_shortcut_get_info_cb (GCancellable *cancellable,
7886                           GFileInfo    *info,
7887                           const GError *error,
7888                           gpointer      user_data)
7889 {
7890   int pos;
7891   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
7892   struct AddShortcutData *data = user_data;
7893
7894   if (!g_slist_find (data->impl->loading_shortcuts, cancellable))
7895     goto out;
7896
7897   data->impl->loading_shortcuts = g_slist_remove (data->impl->loading_shortcuts, cancellable);
7898
7899   if (cancelled || error || (! _gtk_file_info_consider_as_directory (info)))
7900     goto out;
7901
7902   pos = shortcuts_get_pos_for_shortcut_folder (data->impl, data->impl->num_shortcuts);
7903
7904   shortcuts_insert_file (data->impl, pos, SHORTCUT_TYPE_FILE, NULL, data->file, NULL, FALSE, SHORTCUTS_SHORTCUTS);
7905
7906   /* need to call shortcuts_add_bookmarks to flush out any duplicates bug #577806 */
7907   shortcuts_add_bookmarks (data->impl);
7908
7909 out:
7910   g_object_unref (data->impl);
7911   g_object_unref (data->file);
7912   g_free (data);
7913
7914   g_object_unref (cancellable);
7915 }
7916
7917 static gboolean
7918 gtk_file_chooser_default_add_shortcut_folder (GtkFileChooser  *chooser,
7919                                               GFile           *file,
7920                                               GError         **error)
7921 {
7922   GCancellable *cancellable;
7923   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7924   struct AddShortcutData *data;
7925   GSList *l;
7926   int pos;
7927
7928   /* Avoid adding duplicates */
7929   pos = shortcut_find_position (impl, file);
7930   if (pos >= 0 && pos < shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS_SEPARATOR))
7931     {
7932       gchar *uri;
7933
7934       uri = g_file_get_uri (file);
7935       /* translators, "Shortcut" means "Bookmark" here */
7936       g_set_error (error,
7937                    GTK_FILE_CHOOSER_ERROR,
7938                    GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
7939                    _("Shortcut %s already exists"),
7940                    uri);
7941       g_free (uri);
7942
7943       return FALSE;
7944     }
7945
7946   for (l = impl->loading_shortcuts; l; l = l->next)
7947     {
7948       GCancellable *c = l->data;
7949       GFile *f;
7950
7951       f = g_object_get_data (G_OBJECT (c), "add-shortcut-path-key");
7952       if (f && g_file_equal (file, f))
7953         {
7954           gchar *uri;
7955
7956           uri = g_file_get_uri (file);
7957           g_set_error (error,
7958                        GTK_FILE_CHOOSER_ERROR,
7959                        GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
7960                        _("Shortcut %s already exists"),
7961                        uri);
7962           g_free (uri);
7963
7964           return FALSE;
7965         }
7966     }
7967
7968   data = g_new0 (struct AddShortcutData, 1);
7969   data->impl = g_object_ref (impl);
7970   data->file = g_object_ref (file);
7971
7972   cancellable = _gtk_file_system_get_info (impl->file_system, file,
7973                                            "standard::type",
7974                                            add_shortcut_get_info_cb, data);
7975
7976   if (!cancellable)
7977     return FALSE;
7978
7979   impl->loading_shortcuts = g_slist_append (impl->loading_shortcuts, cancellable);
7980   g_object_set_data (G_OBJECT (cancellable), "add-shortcut-path-key", data->file);
7981
7982   return TRUE;
7983 }
7984
7985 static gboolean
7986 gtk_file_chooser_default_remove_shortcut_folder (GtkFileChooser  *chooser,
7987                                                  GFile           *file,
7988                                                  GError         **error)
7989 {
7990   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
7991   int pos;
7992   GtkTreeIter iter;
7993   GSList *l;
7994   char *uri;
7995   int i;
7996
7997   for (l = impl->loading_shortcuts; l; l = l->next)
7998     {
7999       GCancellable *c = l->data;
8000       GFile *f;
8001
8002       f = g_object_get_data (G_OBJECT (c), "add-shortcut-path-key");
8003       if (f && g_file_equal (file, f))
8004         {
8005           impl->loading_shortcuts = g_slist_remove (impl->loading_shortcuts, c);
8006           g_cancellable_cancel (c);
8007           return TRUE;
8008         }
8009     }
8010
8011   if (impl->num_shortcuts == 0)
8012     goto out;
8013
8014   pos = shortcuts_get_pos_for_shortcut_folder (impl, 0);
8015   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
8016     g_assert_not_reached ();
8017
8018   for (i = 0; i < impl->num_shortcuts; i++)
8019     {
8020       gpointer col_data;
8021       ShortcutType shortcut_type;
8022       GFile *shortcut;
8023
8024       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
8025                           SHORTCUTS_COL_DATA, &col_data,
8026                           SHORTCUTS_COL_TYPE, &shortcut_type,
8027                           -1);
8028       g_assert (col_data != NULL);
8029       g_assert (shortcut_type == SHORTCUT_TYPE_FILE);
8030
8031       shortcut = col_data;
8032       if (g_file_equal (shortcut, file))
8033         {
8034           shortcuts_remove_rows (impl, pos + i, 1);
8035           impl->num_shortcuts--;
8036           return TRUE;
8037         }
8038
8039       if (!gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
8040         g_assert_not_reached ();
8041     }
8042
8043  out:
8044
8045   uri = g_file_get_uri (file);
8046   /* translators, "Shortcut" means "Bookmark" here */
8047   g_set_error (error,
8048                GTK_FILE_CHOOSER_ERROR,
8049                GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
8050                _("Shortcut %s does not exist"),
8051                uri);
8052   g_free (uri);
8053
8054   return FALSE;
8055 }
8056
8057 static GSList *
8058 gtk_file_chooser_default_list_shortcut_folders (GtkFileChooser *chooser)
8059 {
8060   GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
8061   int pos;
8062   GtkTreeIter iter;
8063   int i;
8064   GSList *list;
8065
8066   if (impl->num_shortcuts == 0)
8067     return NULL;
8068
8069   pos = shortcuts_get_pos_for_shortcut_folder (impl, 0);
8070   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
8071     g_assert_not_reached ();
8072
8073   list = NULL;
8074
8075   for (i = 0; i < impl->num_shortcuts; i++)
8076     {
8077       gpointer col_data;
8078       ShortcutType shortcut_type;
8079       GFile *shortcut;
8080
8081       gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
8082                           SHORTCUTS_COL_DATA, &col_data,
8083                           SHORTCUTS_COL_TYPE, &shortcut_type,
8084                           -1);
8085       g_assert (col_data != NULL);
8086       g_assert (shortcut_type == SHORTCUT_TYPE_FILE);
8087
8088       shortcut = col_data;
8089       list = g_slist_prepend (list, g_object_ref (shortcut));
8090
8091       if (i != impl->num_shortcuts - 1)
8092         {
8093           if (!gtk_tree_model_iter_next (GTK_TREE_MODEL (impl->shortcuts_model), &iter))
8094             g_assert_not_reached ();
8095         }
8096     }
8097
8098   return g_slist_reverse (list);
8099 }
8100
8101 /* Guesses a size based upon font sizes */
8102 static void
8103 find_good_size_from_style (GtkWidget *widget,
8104                            gint      *width,
8105                            gint      *height)
8106 {
8107   GtkStyleContext *context;
8108   GtkStateFlags state;
8109   double font_size;
8110   GdkScreen *screen;
8111   double resolution;
8112
8113   context = gtk_widget_get_style_context (widget);
8114   state = gtk_widget_get_state_flags (widget);
8115
8116   screen = gtk_widget_get_screen (widget);
8117   if (screen)
8118     {
8119       resolution = gdk_screen_get_resolution (screen);
8120       if (resolution < 0.0) /* will be -1 if the resolution is not defined in the GdkScreen */
8121         resolution = 96.0;
8122     }
8123   else
8124     resolution = 96.0; /* wheeee */
8125
8126   gtk_style_context_get (context, state, "font-size", &font_size, NULL);
8127   font_size = font_size * resolution / 72.0 + 0.5;
8128
8129   *width = font_size * NUM_CHARS;
8130   *height = font_size * NUM_LINES;
8131 }
8132
8133 static void
8134 gtk_file_chooser_default_get_default_size (GtkFileChooserEmbed *chooser_embed,
8135                                            gint                *default_width,
8136                                            gint                *default_height)
8137 {
8138   GtkFileChooserDefault *impl;
8139   GtkRequisition req;
8140   int x, y, width, height;
8141   GSettings *settings;
8142
8143   impl = GTK_FILE_CHOOSER_DEFAULT (chooser_embed);
8144
8145   settings = _gtk_file_chooser_get_settings_for_widget (GTK_WIDGET (impl));
8146
8147   g_settings_get (settings, SETTINGS_KEY_WINDOW_POSITION, "(ii)", &x, &y);
8148   g_settings_get (settings, SETTINGS_KEY_WINDOW_SIZE, "(ii)", &width, &height);
8149
8150   if (x >= 0 && y >= 0 && width > 0 && height > 0)
8151     {
8152       *default_width = width;
8153       *default_height = height;
8154       return;
8155     }
8156
8157   find_good_size_from_style (GTK_WIDGET (chooser_embed), default_width, default_height);
8158
8159   if (impl->preview_widget_active &&
8160       impl->preview_widget &&
8161       gtk_widget_get_visible (impl->preview_widget))
8162     {
8163       gtk_widget_get_preferred_size (impl->preview_box,
8164                                      &req, NULL);
8165       *default_width += PREVIEW_HBOX_SPACING + req.width;
8166     }
8167
8168   if (impl->extra_widget &&
8169       gtk_widget_get_visible (impl->extra_widget))
8170     {
8171       gtk_widget_get_preferred_size (impl->extra_align,
8172                                      &req, NULL);
8173       *default_height += gtk_box_get_spacing (GTK_BOX (chooser_embed)) + req.height;
8174     }
8175 }
8176
8177 struct switch_folder_closure {
8178   GtkFileChooserDefault *impl;
8179   GFile *file;
8180   int num_selected;
8181 };
8182
8183 /* Used from gtk_tree_selection_selected_foreach() in switch_to_selected_folder() */
8184 static void
8185 switch_folder_foreach_cb (GtkTreeModel      *model,
8186                           GtkTreePath       *path,
8187                           GtkTreeIter       *iter,
8188                           gpointer           data)
8189 {
8190   struct switch_folder_closure *closure;
8191
8192   closure = data;
8193
8194   closure->file = _gtk_file_system_model_get_file (closure->impl->browse_files_model, iter);
8195   closure->num_selected++;
8196 }
8197
8198 /* Changes to the selected folder in the list view */
8199 static void
8200 switch_to_selected_folder (GtkFileChooserDefault *impl)
8201 {
8202   GtkTreeSelection *selection;
8203   struct switch_folder_closure closure;
8204
8205   /* We do this with foreach() rather than get_selected() as we may be in
8206    * multiple selection mode
8207    */
8208
8209   closure.impl = impl;
8210   closure.file = NULL;
8211   closure.num_selected = 0;
8212
8213   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
8214   gtk_tree_selection_selected_foreach (selection, switch_folder_foreach_cb, &closure);
8215
8216   g_assert (closure.file && closure.num_selected == 1);
8217
8218   change_folder_and_display_error (impl, closure.file, FALSE);
8219 }
8220
8221 /* Gets the GFileInfo for the selected row in the file list; assumes single
8222  * selection mode.
8223  */
8224 static GFileInfo *
8225 get_selected_file_info_from_file_list (GtkFileChooserDefault *impl,
8226                                        gboolean              *had_selection)
8227 {
8228   GtkTreeSelection *selection;
8229   GtkTreeIter iter;
8230   GFileInfo *info;
8231
8232   g_assert (!impl->select_multiple);
8233   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
8234   if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
8235     {
8236       *had_selection = FALSE;
8237       return NULL;
8238     }
8239
8240   *had_selection = TRUE;
8241
8242   info = _gtk_file_system_model_get_info (impl->browse_files_model, &iter);
8243   return info;
8244 }
8245
8246 /* Gets the display name of the selected file in the file list; assumes single
8247  * selection mode and that something is selected.
8248  */
8249 static const gchar *
8250 get_display_name_from_file_list (GtkFileChooserDefault *impl)
8251 {
8252   GFileInfo *info;
8253   gboolean had_selection;
8254
8255   info = get_selected_file_info_from_file_list (impl, &had_selection);
8256   g_assert (had_selection);
8257   g_assert (info != NULL);
8258
8259   return g_file_info_get_display_name (info);
8260 }
8261
8262 static void
8263 add_custom_button_to_dialog (GtkDialog   *dialog,
8264                              const gchar *mnemonic_label,
8265                              const gchar *stock_id,
8266                              gint         response_id)
8267 {
8268   GtkWidget *button;
8269
8270   button = gtk_button_new_with_mnemonic (mnemonic_label);
8271   gtk_widget_set_can_default (button, TRUE);
8272   gtk_button_set_image (GTK_BUTTON (button),
8273                         gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON));
8274   gtk_widget_show (button);
8275
8276   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, response_id);
8277 }
8278
8279 /* Presents an overwrite confirmation dialog; returns whether we should accept
8280  * the filename.
8281  */
8282 static gboolean
8283 confirm_dialog_should_accept_filename (GtkFileChooserDefault *impl,
8284                                        const gchar           *file_part,
8285                                        const gchar           *folder_display_name)
8286 {
8287   GtkWindow *toplevel;
8288   GtkWidget *dialog;
8289   int response;
8290
8291   toplevel = get_toplevel (GTK_WIDGET (impl));
8292
8293   dialog = gtk_message_dialog_new (toplevel,
8294                                    GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
8295                                    GTK_MESSAGE_QUESTION,
8296                                    GTK_BUTTONS_NONE,
8297                                    _("A file named \"%s\" already exists.  Do you want to replace it?"),
8298                                    file_part);
8299   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
8300                                             _("The file already exists in \"%s\".  Replacing it will "
8301                                               "overwrite its contents."),
8302                                             folder_display_name);
8303
8304   gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
8305   add_custom_button_to_dialog (GTK_DIALOG (dialog), _("_Replace"),
8306                                GTK_STOCK_SAVE_AS, GTK_RESPONSE_ACCEPT);
8307   gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
8308                                            GTK_RESPONSE_ACCEPT,
8309                                            GTK_RESPONSE_CANCEL,
8310                                            -1);
8311   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
8312
8313   if (gtk_window_has_group (toplevel))
8314     gtk_window_group_add_window (gtk_window_get_group (toplevel),
8315                                  GTK_WINDOW (dialog));
8316
8317   response = gtk_dialog_run (GTK_DIALOG (dialog));
8318
8319   gtk_widget_destroy (dialog);
8320
8321   return (response == GTK_RESPONSE_ACCEPT);
8322 }
8323
8324 struct GetDisplayNameData
8325 {
8326   GtkFileChooserDefault *impl;
8327   gchar *file_part;
8328 };
8329
8330 /* Every time we request a response explicitly, we need to save the selection to the recently-used list,
8331  * as requesting a response means, "the dialog is confirmed".
8332  */
8333 static void
8334 request_response_and_add_to_recent_list (GtkFileChooserDefault *impl)
8335 {
8336   g_signal_emit_by_name (impl, "response-requested");
8337   add_selection_to_recent_list (impl);
8338 }
8339
8340 static void
8341 confirmation_confirm_get_info_cb (GCancellable *cancellable,
8342                                   GFileInfo    *info,
8343                                   const GError *error,
8344                                   gpointer      user_data)
8345 {
8346   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
8347   gboolean should_respond = FALSE;
8348   struct GetDisplayNameData *data = user_data;
8349
8350   if (cancellable != data->impl->should_respond_get_info_cancellable)
8351     goto out;
8352
8353   data->impl->should_respond_get_info_cancellable = NULL;
8354
8355   if (cancelled)
8356     goto out;
8357
8358   if (error)
8359     /* Huh?  Did the folder disappear?  Let the caller deal with it */
8360     should_respond = TRUE;
8361   else
8362     should_respond = confirm_dialog_should_accept_filename (data->impl, data->file_part, g_file_info_get_display_name (info));
8363
8364   set_busy_cursor (data->impl, FALSE);
8365   if (should_respond)
8366     request_response_and_add_to_recent_list (data->impl);
8367
8368 out:
8369   g_object_unref (data->impl);
8370   g_free (data->file_part);
8371   g_free (data);
8372
8373   g_object_unref (cancellable);
8374 }
8375
8376 /* Does overwrite confirmation if appropriate, and returns whether the dialog
8377  * should respond.  Can get the file part from the file list or the save entry.
8378  */
8379 static gboolean
8380 should_respond_after_confirm_overwrite (GtkFileChooserDefault *impl,
8381                                         const gchar           *file_part,
8382                                         GFile                 *parent_file)
8383 {
8384   GtkFileChooserConfirmation conf;
8385
8386   if (!impl->do_overwrite_confirmation)
8387     return TRUE;
8388
8389   conf = GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM;
8390
8391   g_signal_emit_by_name (impl, "confirm-overwrite", &conf);
8392
8393   switch (conf)
8394     {
8395     case GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM:
8396       {
8397         struct GetDisplayNameData *data;
8398
8399         g_assert (file_part != NULL);
8400
8401         data = g_new0 (struct GetDisplayNameData, 1);
8402         data->impl = g_object_ref (impl);
8403         data->file_part = g_strdup (file_part);
8404
8405         if (impl->should_respond_get_info_cancellable)
8406           g_cancellable_cancel (impl->should_respond_get_info_cancellable);
8407
8408         impl->should_respond_get_info_cancellable =
8409           _gtk_file_system_get_info (impl->file_system, parent_file,
8410                                      "standard::display-name",
8411                                      confirmation_confirm_get_info_cb,
8412                                      data);
8413         set_busy_cursor (data->impl, TRUE);
8414         return FALSE;
8415       }
8416
8417     case GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME:
8418       return TRUE;
8419
8420     case GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN:
8421       return FALSE;
8422
8423     default:
8424       g_assert_not_reached ();
8425       return FALSE;
8426     }
8427 }
8428
8429 struct FileExistsData
8430 {
8431   GtkFileChooserDefault *impl;
8432   gboolean file_exists_and_is_not_folder;
8433   GFile *parent_file;
8434   GFile *file;
8435 };
8436
8437 static void
8438 name_entry_get_parent_info_cb (GCancellable *cancellable,
8439                                GFileInfo    *info,
8440                                const GError *error,
8441                                gpointer      user_data)
8442 {
8443   gboolean parent_is_folder;
8444   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
8445   struct FileExistsData *data = user_data;
8446
8447   if (cancellable != data->impl->should_respond_get_info_cancellable)
8448     goto out;
8449
8450   data->impl->should_respond_get_info_cancellable = NULL;
8451
8452   set_busy_cursor (data->impl, FALSE);
8453
8454   if (cancelled)
8455     goto out;
8456
8457   if (!info)
8458     parent_is_folder = FALSE;
8459   else
8460     parent_is_folder = _gtk_file_info_consider_as_directory (info);
8461
8462   if (parent_is_folder)
8463     {
8464       if (data->impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
8465         {
8466           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) */
8467         }
8468       else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8469         {
8470           if (data->file_exists_and_is_not_folder)
8471             {
8472               gboolean retval;
8473               char *file_part;
8474
8475               /* Dup the string because the string may be modified
8476                * depending on what clients do in the confirm-overwrite
8477                * signal and this corrupts the pointer
8478                */
8479               file_part = g_strdup (_gtk_file_chooser_entry_get_file_part (GTK_FILE_CHOOSER_ENTRY (data->impl->location_entry)));
8480               retval = should_respond_after_confirm_overwrite (data->impl, file_part, data->parent_file);
8481               g_free (file_part);
8482
8483               if (retval)
8484                 request_response_and_add_to_recent_list (data->impl);
8485             }
8486           else
8487             request_response_and_add_to_recent_list (data->impl);
8488         }
8489       else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
8490                || data->impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8491         {
8492           GError *mkdir_error = NULL;
8493
8494           /* In both cases (SELECT_FOLDER and CREATE_FOLDER), if you type
8495            * "/blah/nonexistent" you *will* want a folder created.
8496            */
8497
8498           set_busy_cursor (data->impl, TRUE);
8499           g_file_make_directory (data->file, NULL, &mkdir_error);
8500           set_busy_cursor (data->impl, FALSE);
8501
8502           if (!mkdir_error)
8503             request_response_and_add_to_recent_list (data->impl);
8504           else
8505             error_creating_folder_dialog (data->impl, data->file, mkdir_error);
8506         }
8507       else
8508         g_assert_not_reached ();
8509     }
8510   else
8511     {
8512       if (info)
8513         {
8514           /* The parent exists, but it's not a folder!  Someone probably typed existing_file.txt/subfile.txt */
8515           error_with_file_under_nonfolder (data->impl, data->parent_file);
8516         }
8517       else
8518         {
8519           GError *error_copy;
8520
8521           /* The parent folder is not readable for some reason */
8522
8523           error_copy = g_error_copy (error);
8524           error_changing_folder_dialog (data->impl, data->parent_file, error_copy);
8525         }
8526     }
8527
8528 out:
8529   g_object_unref (data->impl);
8530   g_object_unref (data->file);
8531   g_object_unref (data->parent_file);
8532   g_free (data);
8533
8534   g_object_unref (cancellable);
8535 }
8536
8537 static void
8538 file_exists_get_info_cb (GCancellable *cancellable,
8539                          GFileInfo    *info,
8540                          const GError *error,
8541                          gpointer      user_data)
8542 {
8543   gboolean data_ownership_taken = FALSE;
8544   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
8545   gboolean file_exists;
8546   gboolean is_folder;
8547   gboolean needs_parent_check = FALSE;
8548   struct FileExistsData *data = user_data;
8549
8550   if (cancellable != data->impl->file_exists_get_info_cancellable)
8551     goto out;
8552
8553   data->impl->file_exists_get_info_cancellable = NULL;
8554
8555   set_busy_cursor (data->impl, FALSE);
8556
8557   if (cancelled)
8558     goto out;
8559
8560   file_exists = (info != NULL);
8561   is_folder = (file_exists && _gtk_file_info_consider_as_directory (info));
8562
8563   if (data->impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
8564     {
8565       if (is_folder)
8566         change_folder_and_display_error (data->impl, data->file, TRUE);
8567       else
8568         {
8569           if (file_exists)
8570             request_response_and_add_to_recent_list (data->impl); /* user typed an existing filename; we are done */
8571           else
8572             needs_parent_check = TRUE; /* file doesn't exist; see if its parent exists */
8573         }
8574     }
8575   else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8576     {
8577       if (file_exists && !is_folder)
8578         {
8579           /* Oops, the user typed the name of an existing path which is not
8580            * a folder
8581            */
8582           error_creating_folder_over_existing_file_dialog (data->impl, data->file,
8583                                                            g_error_copy (error));
8584         }
8585       else
8586         {
8587           needs_parent_check = TRUE;
8588         }
8589     }
8590   else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
8591     {
8592       if (!file_exists)
8593         {
8594           needs_parent_check = TRUE;
8595         }
8596       else
8597         {
8598           if (is_folder)
8599             {
8600               /* User typed a folder; we are done */
8601               request_response_and_add_to_recent_list (data->impl);
8602             }
8603           else
8604             error_selecting_folder_over_existing_file_dialog (data->impl, data->file);
8605         }
8606     }
8607   else if (data->impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8608     {
8609       if (is_folder)
8610         change_folder_and_display_error (data->impl, data->file, TRUE);
8611       else
8612         needs_parent_check = TRUE;
8613     }
8614   else
8615     {
8616       g_assert_not_reached();
8617     }
8618
8619   if (needs_parent_check) {
8620     /* check that everything up to the last path component exists (i.e. the parent) */
8621
8622     data->file_exists_and_is_not_folder = file_exists && !is_folder;
8623     data_ownership_taken = TRUE;
8624
8625     if (data->impl->should_respond_get_info_cancellable)
8626       g_cancellable_cancel (data->impl->should_respond_get_info_cancellable);
8627
8628       data->impl->should_respond_get_info_cancellable =
8629         _gtk_file_system_get_info (data->impl->file_system,
8630                                    data->parent_file,
8631                                    "standard::type",
8632                                    name_entry_get_parent_info_cb,
8633                                    data);
8634       set_busy_cursor (data->impl, TRUE);
8635     }
8636
8637 out:
8638   if (!data_ownership_taken)
8639     {
8640       g_object_unref (data->impl);
8641       g_object_unref (data->file);
8642       g_object_unref (data->parent_file);
8643       g_free (data);
8644     }
8645
8646   g_object_unref (cancellable);
8647 }
8648
8649 static void
8650 paste_text_received (GtkClipboard          *clipboard,
8651                      const gchar           *text,
8652                      GtkFileChooserDefault *impl)
8653 {
8654   GFile *file;
8655
8656   if (!text)
8657     return;
8658
8659   file = g_file_new_for_uri (text);
8660
8661   if (!gtk_file_chooser_default_select_file (GTK_FILE_CHOOSER (impl), file, NULL))
8662     location_popup_handler (impl, text);
8663
8664   g_object_unref (file);
8665 }
8666
8667 /* Handler for the "location-popup-on-paste" keybinding signal */
8668 static void
8669 location_popup_on_paste_handler (GtkFileChooserDefault *impl)
8670 {
8671   GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (impl),
8672                                                       GDK_SELECTION_CLIPBOARD);
8673   gtk_clipboard_request_text (clipboard,
8674                               (GtkClipboardTextReceivedFunc) paste_text_received,
8675                               impl);
8676 }
8677
8678 /* Implementation for GtkFileChooserEmbed::should_respond() */
8679 static void
8680 add_selection_to_recent_list (GtkFileChooserDefault *impl)
8681 {
8682   GSList *files;
8683   GSList *l;
8684
8685   files = gtk_file_chooser_default_get_files (GTK_FILE_CHOOSER (impl));
8686
8687   for (l = files; l; l = l->next)
8688     {
8689       GFile *file = l->data;
8690       char *uri;
8691
8692       uri = g_file_get_uri (file);
8693       if (uri)
8694         {
8695           gtk_recent_manager_add_item (impl->recent_manager, uri);
8696           g_free (uri);
8697         }
8698     }
8699
8700   g_slist_foreach (files, (GFunc) g_object_unref, NULL);
8701   g_slist_free (files);
8702 }
8703
8704 static gboolean
8705 gtk_file_chooser_default_should_respond (GtkFileChooserEmbed *chooser_embed)
8706 {
8707   GtkFileChooserDefault *impl;
8708   GtkWidget *toplevel;
8709   GtkWidget *current_focus;
8710   gboolean retval;
8711
8712   impl = GTK_FILE_CHOOSER_DEFAULT (chooser_embed);
8713
8714   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
8715   g_assert (GTK_IS_WINDOW (toplevel));
8716
8717   retval = FALSE;
8718
8719   current_focus = gtk_window_get_focus (GTK_WINDOW (toplevel));
8720
8721   if (current_focus == impl->browse_files_tree_view)
8722     {
8723       /* The following array encodes what we do based on the impl->action and the
8724        * number of files selected.
8725        */
8726       typedef enum {
8727         NOOP,                   /* Do nothing (don't respond) */
8728         RESPOND,                /* Respond immediately */
8729         RESPOND_OR_SWITCH,      /* Respond immediately if the selected item is a file; switch to it if it is a folder */
8730         ALL_FILES,              /* Respond only if everything selected is a file */
8731         ALL_FOLDERS,            /* Respond only if everything selected is a folder */
8732         SAVE_ENTRY,             /* Go to the code for handling the save entry */
8733         NOT_REACHED             /* Sanity check */
8734       } ActionToTake;
8735       static const ActionToTake what_to_do[4][3] = {
8736         /*                                0 selected            1 selected              many selected */
8737         /* ACTION_OPEN */               { NOOP,                 RESPOND_OR_SWITCH,      ALL_FILES   },
8738         /* ACTION_SAVE */               { SAVE_ENTRY,           RESPOND_OR_SWITCH,      NOT_REACHED },
8739         /* ACTION_SELECT_FOLDER */      { RESPOND,              ALL_FOLDERS,            ALL_FOLDERS },
8740         /* ACTION_CREATE_FOLDER */      { SAVE_ENTRY,           ALL_FOLDERS,            NOT_REACHED }
8741       };
8742
8743       int num_selected;
8744       gboolean all_files, all_folders;
8745       int k;
8746       ActionToTake action;
8747
8748     file_list:
8749
8750       g_assert (impl->action >= GTK_FILE_CHOOSER_ACTION_OPEN && impl->action <= GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER);
8751
8752       if (impl->operation_mode == OPERATION_MODE_SEARCH)
8753         {
8754           retval = search_should_respond (impl);
8755           goto out;
8756         }
8757
8758       if (impl->operation_mode == OPERATION_MODE_RECENT)
8759         {
8760           if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8761             goto save_entry;
8762           else
8763             {
8764               retval = recent_should_respond (impl);
8765               goto out;
8766             }
8767         }
8768
8769       selection_check (impl, &num_selected, &all_files, &all_folders);
8770
8771       if (num_selected > 2)
8772         k = 2;
8773       else
8774         k = num_selected;
8775
8776       action = what_to_do [impl->action] [k];
8777
8778       switch (action)
8779         {
8780         case NOOP:
8781           return FALSE;
8782
8783         case RESPOND:
8784           retval = TRUE;
8785           goto out;
8786
8787         case RESPOND_OR_SWITCH:
8788           g_assert (num_selected == 1);
8789
8790           if (all_folders)
8791             {
8792               switch_to_selected_folder (impl);
8793               return FALSE;
8794             }
8795           else if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8796             {
8797               retval = should_respond_after_confirm_overwrite (impl,
8798                                                                get_display_name_from_file_list (impl),
8799                                                                impl->current_folder);
8800               goto out;
8801             }
8802           else
8803             {
8804               retval = TRUE;
8805               goto out;
8806             }
8807
8808         case ALL_FILES:
8809           retval = all_files;
8810           goto out;
8811
8812         case ALL_FOLDERS:
8813           retval = all_folders;
8814           goto out;
8815
8816         case SAVE_ENTRY:
8817           goto save_entry;
8818
8819         default:
8820           g_assert_not_reached ();
8821         }
8822     }
8823   else if ((impl->location_entry != NULL) && (current_focus == impl->location_entry))
8824     {
8825       GFile *file;
8826       gboolean is_well_formed, is_empty, is_file_part_empty;
8827       gboolean is_folder;
8828       GtkFileChooserEntry *entry;
8829       GError *error;
8830
8831     save_entry:
8832
8833       g_assert (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8834                 || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
8835                 || ((impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
8836                      || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
8837                     && impl->location_mode == LOCATION_MODE_FILENAME_ENTRY));
8838
8839       entry = GTK_FILE_CHOOSER_ENTRY (impl->location_entry);
8840       check_save_entry (impl, &file, &is_well_formed, &is_empty, &is_file_part_empty, &is_folder);
8841
8842       if (!is_well_formed)
8843         {
8844           if (!is_empty
8845               && impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8846               && impl->operation_mode == OPERATION_MODE_RECENT)
8847             {
8848               path_bar_set_mode (impl, PATH_BAR_ERROR_NO_FOLDER);
8849 #if 0
8850               /* We'll #ifdef this out, as the fucking treeview selects its first row,
8851                * thus changing our assumption that no selection is present - setting
8852                * a selection causes the error message from path_bar_set_mode() to go away,
8853                * but we want the user to see that message!
8854                */
8855               gtk_widget_grab_focus (impl->browse_files_tree_view);
8856 #endif
8857             }
8858           /* FIXME: else show an "invalid filename" error as the pathbar mode? */
8859
8860           return FALSE;
8861         }
8862
8863       if (is_empty)
8864         {
8865           if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8866               || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8867             {
8868               path_bar_set_mode (impl, PATH_BAR_ERROR_NO_FILENAME);
8869               gtk_widget_grab_focus (impl->location_entry);
8870               return FALSE;
8871             }
8872
8873           goto file_list;
8874         }
8875
8876       g_assert (file != NULL);
8877
8878       error = NULL;
8879       if (is_folder)
8880         {
8881           if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
8882               impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
8883             {
8884               change_folder_and_display_error (impl, file, TRUE);
8885             }
8886           else if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
8887                    impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8888             {
8889               /* The folder already exists, so we do not need to create it.
8890                * Just respond to terminate the dialog.
8891                */
8892               retval = TRUE;
8893             }
8894           else
8895             {
8896               g_assert_not_reached ();
8897             }
8898         }
8899       else
8900         {
8901           struct FileExistsData *data;
8902
8903           /* We need to check whether file exists and whether it is a folder -
8904            * the GtkFileChooserEntry *does* report is_folder==FALSE as a false
8905            * negative (it doesn't know yet if your last path component is a
8906            * folder).
8907            */
8908
8909           data = g_new0 (struct FileExistsData, 1);
8910           data->impl = g_object_ref (impl);
8911           data->file = g_object_ref (file);
8912           data->parent_file = _gtk_file_chooser_entry_get_current_folder (entry);
8913
8914           if (impl->file_exists_get_info_cancellable)
8915             g_cancellable_cancel (impl->file_exists_get_info_cancellable);
8916
8917           impl->file_exists_get_info_cancellable =
8918             _gtk_file_system_get_info (impl->file_system, file,
8919                                        "standard::type",
8920                                        file_exists_get_info_cb,
8921                                        data);
8922
8923           set_busy_cursor (impl, TRUE);
8924
8925           if (error != NULL)
8926             g_error_free (error);
8927         }
8928
8929       g_object_unref (file);
8930     }
8931   else if (impl->toplevel_last_focus_widget == impl->browse_files_tree_view)
8932     {
8933       /* The focus is on a dialog's action area button, *and* the widget that
8934        * was focused immediately before it is the file list.
8935        */
8936       goto file_list;
8937     }
8938   else if (impl->operation_mode == OPERATION_MODE_SEARCH && impl->toplevel_last_focus_widget == impl->search_entry)
8939     {
8940       search_entry_activate_cb (GTK_ENTRY (impl->search_entry), impl);
8941       return FALSE;
8942     }
8943   else if (impl->location_entry && impl->toplevel_last_focus_widget == impl->location_entry)
8944     {
8945       /* The focus is on a dialog's action area button, *and* the widget that
8946        * was focused immediately before it is the location entry.
8947        */
8948       goto save_entry;
8949     }
8950   else
8951     /* The focus is on a dialog's action area button or something else */
8952     if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
8953         || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8954       goto save_entry;
8955     else
8956       goto file_list;
8957
8958  out:
8959
8960   if (retval)
8961     add_selection_to_recent_list (impl);
8962
8963   return retval;
8964 }
8965
8966 /* Implementation for GtkFileChooserEmbed::initial_focus() */
8967 static void
8968 gtk_file_chooser_default_initial_focus (GtkFileChooserEmbed *chooser_embed)
8969 {
8970   GtkFileChooserDefault *impl;
8971   GtkWidget *widget;
8972
8973   impl = GTK_FILE_CHOOSER_DEFAULT (chooser_embed);
8974
8975   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
8976       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
8977     {
8978       if (impl->location_mode == LOCATION_MODE_PATH_BAR
8979           || impl->operation_mode == OPERATION_MODE_RECENT)
8980         widget = impl->browse_files_tree_view;
8981       else
8982         widget = impl->location_entry;
8983     }
8984   else if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
8985            impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
8986     widget = impl->location_entry;
8987   else
8988     {
8989       g_assert_not_reached ();
8990       widget = NULL;
8991     }
8992
8993   g_assert (widget != NULL);
8994   gtk_widget_grab_focus (widget);
8995 }
8996
8997 /* Callback used from gtk_tree_selection_selected_foreach(); gets the selected GFiles */
8998 static void
8999 search_selected_foreach_get_file_cb (GtkTreeModel *model,
9000                                      GtkTreePath  *path,
9001                                      GtkTreeIter  *iter,
9002                                      gpointer      data)
9003 {
9004   GSList **list;
9005   GFile *file;
9006
9007   list = data;
9008
9009   gtk_tree_model_get (model, iter, MODEL_COL_FILE, &file, -1);
9010   *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 */
9011 }
9012
9013 /* Constructs a list of the selected paths in search mode */
9014 static GSList *
9015 search_get_selected_files (GtkFileChooserDefault *impl)
9016 {
9017   GSList *result;
9018   GtkTreeSelection *selection;
9019
9020   result = NULL;
9021
9022   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9023   gtk_tree_selection_selected_foreach (selection, search_selected_foreach_get_file_cb, &result);
9024   result = g_slist_reverse (result);
9025
9026   return result;
9027 }
9028
9029 /* Called from ::should_respond().  We return whether there are selected files
9030  * in the search list.
9031  */
9032 static gboolean
9033 search_should_respond (GtkFileChooserDefault *impl)
9034 {
9035   GtkTreeSelection *selection;
9036
9037   g_assert (impl->operation_mode == OPERATION_MODE_SEARCH);
9038
9039   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9040   return (gtk_tree_selection_count_selected_rows (selection) != 0);
9041 }
9042
9043 /* Adds one hit from the search engine to the search_model */
9044 static void
9045 search_add_hit (GtkFileChooserDefault *impl,
9046                 gchar                 *uri)
9047 {
9048   GFile *file;
9049
9050   file = g_file_new_for_uri (uri);
9051   if (!file)
9052     return;
9053
9054   if (!g_file_is_native (file))
9055     {
9056       g_object_unref (file);
9057       return;
9058     }
9059
9060   _gtk_file_system_model_add_and_query_file (impl->search_model,
9061                                              file,
9062                                              MODEL_ATTRIBUTES);
9063
9064   g_object_unref (file);
9065 }
9066
9067 /* Callback used from GtkSearchEngine when we get new hits */
9068 static void
9069 search_engine_hits_added_cb (GtkSearchEngine *engine,
9070                              GList           *hits,
9071                              gpointer         data)
9072 {
9073   GtkFileChooserDefault *impl;
9074   GList *l;
9075
9076   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9077
9078   for (l = hits; l; l = l->next)
9079     search_add_hit (impl, (gchar*)l->data);
9080 }
9081
9082 /* Callback used from GtkSearchEngine when the query is done running */
9083 static void
9084 search_engine_finished_cb (GtkSearchEngine *engine,
9085                            gpointer         data)
9086 {
9087   GtkFileChooserDefault *impl;
9088
9089   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9090
9091 #if 0
9092   /* EB: setting the model here will avoid loads of row events,
9093    * but it'll make the search look like blocked.
9094    */
9095   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
9096                            GTK_TREE_MODEL (impl->search_model));
9097   file_list_set_sort_column_ids (impl);
9098 #endif
9099
9100   /* FMQ: if search was empty, say that we got no hits */
9101   set_busy_cursor (impl, FALSE);
9102 }
9103
9104 /* Displays a generic error when we cannot create a GtkSearchEngine.
9105  * It would be better if _gtk_search_engine_new() gave us a GError
9106  * with a better message, but it doesn't do that right now.
9107  */
9108 static void
9109 search_error_could_not_create_client (GtkFileChooserDefault *impl)
9110 {
9111   error_message (impl,
9112                  _("Could not start the search process"),
9113                  _("The program was not able to create a connection to the indexer "
9114                    "daemon.  Please make sure it is running."));
9115 }
9116
9117 static void
9118 search_engine_error_cb (GtkSearchEngine *engine,
9119                         const gchar     *message,
9120                         gpointer         data)
9121 {
9122   GtkFileChooserDefault *impl;
9123
9124   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9125
9126   search_stop_searching (impl, TRUE);
9127   error_message (impl, _("Could not send the search request"), message);
9128
9129   set_busy_cursor (impl, FALSE);
9130 }
9131
9132 /* Frees the data in the search_model */
9133 static void
9134 search_clear_model (GtkFileChooserDefault *impl,
9135                     gboolean               remove_from_treeview)
9136 {
9137   if (!impl->search_model)
9138     return;
9139
9140   g_object_unref (impl->search_model);
9141   impl->search_model = NULL;
9142
9143   if (remove_from_treeview)
9144     gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
9145 }
9146
9147 /* Stops any ongoing searches; does not touch the search_model */
9148 static void
9149 search_stop_searching (GtkFileChooserDefault *impl,
9150                        gboolean               remove_query)
9151 {
9152   if (remove_query && impl->search_query)
9153     {
9154       g_object_unref (impl->search_query);
9155       impl->search_query = NULL;
9156     }
9157
9158   if (impl->search_engine)
9159     {
9160       _gtk_search_engine_stop (impl->search_engine);
9161
9162       g_object_unref (impl->search_engine);
9163       impl->search_engine = NULL;
9164     }
9165 }
9166
9167 /* Creates the search_model and puts it in the tree view */
9168 static void
9169 search_setup_model (GtkFileChooserDefault *impl)
9170 {
9171   g_assert (impl->search_model == NULL);
9172
9173   impl->search_model = _gtk_file_system_model_new (file_system_model_set,
9174                                                    impl,
9175                                                    MODEL_COLUMN_TYPES);
9176
9177   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
9178                                    MODEL_COL_NAME,
9179                                    name_sort_func,
9180                                    impl, NULL);
9181   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
9182                                    MODEL_COL_MTIME,
9183                                    mtime_sort_func,
9184                                    impl, NULL);
9185   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
9186                                    MODEL_COL_SIZE,
9187                                    size_sort_func,
9188                                    impl, NULL);
9189   set_sort_column (impl);
9190
9191   /* EB: setting the model here will make the hits list update feel
9192    * more "alive" than setting the model at the end of the search
9193    * run
9194    */
9195   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
9196                            GTK_TREE_MODEL (impl->search_model));
9197   file_list_set_sort_column_ids (impl);
9198 }
9199
9200 /* Creates a new query with the specified text and launches it */
9201 static void
9202 search_start_query (GtkFileChooserDefault *impl,
9203                     const gchar           *query_text)
9204 {
9205   search_stop_searching (impl, FALSE);
9206   search_clear_model (impl, TRUE);
9207   search_setup_model (impl);
9208   set_busy_cursor (impl, TRUE);
9209
9210   if (impl->search_engine == NULL)
9211     impl->search_engine = _gtk_search_engine_new ();
9212
9213   if (!impl->search_engine)
9214     {
9215       set_busy_cursor (impl, FALSE);
9216       search_error_could_not_create_client (impl); /* lame; we don't get an error code or anything */
9217       return;
9218     }
9219
9220   if (!impl->search_query)
9221     {
9222       impl->search_query = _gtk_query_new ();
9223       _gtk_query_set_text (impl->search_query, query_text);
9224     }
9225
9226   _gtk_search_engine_set_query (impl->search_engine, impl->search_query);
9227
9228   g_signal_connect (impl->search_engine, "hits-added",
9229                     G_CALLBACK (search_engine_hits_added_cb), impl);
9230   g_signal_connect (impl->search_engine, "finished",
9231                     G_CALLBACK (search_engine_finished_cb), impl);
9232   g_signal_connect (impl->search_engine, "error",
9233                     G_CALLBACK (search_engine_error_cb), impl);
9234
9235   _gtk_search_engine_start (impl->search_engine);
9236 }
9237
9238 /* Callback used when the user presses Enter while typing on the search
9239  * entry; starts the query
9240  */
9241 static void
9242 search_entry_activate_cb (GtkEntry *entry,
9243                           gpointer data)
9244 {
9245   GtkFileChooserDefault *impl;
9246   const char *text;
9247
9248   impl = GTK_FILE_CHOOSER_DEFAULT (data);
9249
9250   text = gtk_entry_get_text (GTK_ENTRY (impl->search_entry));
9251   if (strlen (text) == 0)
9252     return;
9253
9254   /* reset any existing query object */
9255   if (impl->search_query)
9256     {
9257       g_object_unref (impl->search_query);
9258       impl->search_query = NULL;
9259     }
9260
9261   search_start_query (impl, text);
9262 }
9263
9264 static gboolean
9265 focus_entry_idle_cb (GtkFileChooserDefault *impl)
9266 {
9267   gdk_threads_enter ();
9268
9269   g_source_destroy (impl->focus_entry_idle);
9270   impl->focus_entry_idle = NULL;
9271
9272   if (impl->search_entry)
9273     gtk_widget_grab_focus (impl->search_entry);
9274
9275   gdk_threads_leave ();
9276
9277   return FALSE;
9278 }
9279
9280 static void
9281 focus_search_entry_in_idle (GtkFileChooserDefault *impl)
9282 {
9283   /* bgo#634558 - When the user clicks on the Search entry in the shortcuts
9284    * pane, we get a selection-changed signal and we set up the search widgets.
9285    * However, gtk_tree_view_button_press() focuses the treeview *after* making
9286    * the change to the selection.  So, we need to re-focus the search entry
9287    * after the treeview has finished doing its work; we'll do that in an idle
9288    * handler.
9289    */
9290
9291   if (!impl->focus_entry_idle)
9292     impl->focus_entry_idle = add_idle_while_impl_is_alive (impl, G_CALLBACK (focus_entry_idle_cb));
9293 }
9294
9295 /* Hides the path bar and creates the search entry */
9296 static void
9297 search_setup_widgets (GtkFileChooserDefault *impl)
9298 {
9299   impl->search_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
9300
9301   path_bar_update (impl);
9302
9303   impl->search_entry = gtk_entry_new ();
9304   g_signal_connect (impl->search_entry, "activate",
9305                     G_CALLBACK (search_entry_activate_cb),
9306                     impl);
9307   gtk_box_pack_start (GTK_BOX (impl->search_hbox), impl->search_entry, TRUE, TRUE, 0);
9308
9309   /* if there already is a query, restart it */
9310   if (impl->search_query)
9311     {
9312       gchar *query = _gtk_query_get_text (impl->search_query);
9313
9314       if (query)
9315         {
9316           gtk_entry_set_text (GTK_ENTRY (impl->search_entry), query);
9317           search_start_query (impl, query);
9318
9319           g_free (query);
9320         }
9321       else
9322         {
9323           g_object_unref (impl->search_query);
9324           impl->search_query = NULL;
9325         }
9326     }
9327
9328   /* Box for search widgets */
9329   gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->search_hbox, TRUE, TRUE, 0);
9330   gtk_widget_show_all (impl->search_hbox);
9331   gtk_size_group_add_widget (GTK_SIZE_GROUP (impl->browse_path_bar_size_group), impl->search_hbox);
9332
9333   /* Hide the location widgets temporarily */
9334
9335   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
9336       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
9337     {
9338       gtk_widget_hide (impl->location_button);
9339       gtk_widget_hide (impl->location_entry_box);
9340     }
9341
9342   focus_search_entry_in_idle (impl);
9343
9344   /* FMQ: hide the filter combo? */
9345 }
9346
9347 /*
9348  * Recent files support
9349  */
9350
9351 /* Frees the data in the recent_model */
9352 static void
9353 recent_clear_model (GtkFileChooserDefault *impl,
9354                     gboolean               remove_from_treeview)
9355 {
9356   if (!impl->recent_model)
9357     return;
9358
9359   if (remove_from_treeview)
9360     gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
9361
9362   g_object_unref (impl->recent_model);
9363   impl->recent_model = NULL;
9364 }
9365
9366 /* Stops any ongoing loading of the recent files list; does
9367  * not touch the recent_model
9368  */
9369 static void
9370 recent_stop_loading (GtkFileChooserDefault *impl)
9371 {
9372   if (impl->load_recent_id)
9373     {
9374       g_source_remove (impl->load_recent_id);
9375       impl->load_recent_id = 0;
9376     }
9377 }
9378
9379 static void
9380 recent_setup_model (GtkFileChooserDefault *impl)
9381 {
9382   g_assert (impl->recent_model == NULL);
9383
9384   impl->recent_model = _gtk_file_system_model_new (file_system_model_set,
9385                                                    impl,
9386                                                    MODEL_COLUMN_TYPES);
9387
9388   _gtk_file_system_model_set_filter (impl->recent_model,
9389                                      impl->current_filter);
9390   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
9391                                    MODEL_COL_NAME,
9392                                    name_sort_func,
9393                                    impl, NULL);
9394   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
9395                                    MODEL_COL_SIZE,
9396                                    size_sort_func,
9397                                    impl, NULL);
9398   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
9399                                    MODEL_COL_MTIME,
9400                                    mtime_sort_func,
9401                                    impl, NULL);
9402   set_sort_column (impl);
9403 }
9404
9405 typedef struct
9406 {
9407   GtkFileChooserDefault *impl;
9408   GList *items;
9409 } RecentLoadData;
9410
9411 static void
9412 recent_idle_cleanup (gpointer data)
9413 {
9414   RecentLoadData *load_data = data;
9415   GtkFileChooserDefault *impl = load_data->impl;
9416
9417   gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
9418                            GTK_TREE_MODEL (impl->recent_model));
9419   file_list_set_sort_column_ids (impl);
9420   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (impl->recent_model), MODEL_COL_MTIME, GTK_SORT_DESCENDING);
9421
9422   set_busy_cursor (impl, FALSE);
9423
9424   impl->load_recent_id = 0;
9425
9426   g_free (load_data);
9427 }
9428
9429 static gint
9430 get_recent_files_limit (GtkWidget *widget)
9431 {
9432   GtkSettings *settings;
9433   gint limit;
9434
9435   if (gtk_widget_has_screen (widget))
9436     settings = gtk_settings_get_for_screen (gtk_widget_get_screen (widget));
9437   else
9438     settings = gtk_settings_get_default ();
9439
9440   g_object_get (G_OBJECT (settings), "gtk-recent-files-limit", &limit, NULL);
9441
9442   return limit;
9443 }
9444
9445 /* Populates the file system model with the GtkRecentInfo* items in the provided list; frees the items */
9446 static void
9447 populate_model_with_recent_items (GtkFileChooserDefault *impl, GList *items)
9448 {
9449   gint limit;
9450   GList *l;
9451   int n;
9452
9453   limit = get_recent_files_limit (GTK_WIDGET (impl));
9454
9455   n = 0;
9456
9457   for (l = items; l; l = l->next)
9458     {
9459       GtkRecentInfo *info = l->data;
9460       GFile *file;
9461
9462       file = g_file_new_for_uri (gtk_recent_info_get_uri (info));
9463       _gtk_file_system_model_add_and_query_file (impl->recent_model,
9464                                                  file,
9465                                                  MODEL_ATTRIBUTES);
9466       g_object_unref (file);
9467
9468       n++;
9469       if (limit != -1 && n >= limit)
9470         break;
9471     }
9472 }
9473
9474 static void
9475 populate_model_with_folders (GtkFileChooserDefault *impl, GList *items)
9476 {
9477   GList *folders;
9478   GList *l;
9479
9480   folders = _gtk_file_chooser_extract_recent_folders (items);
9481
9482   for (l = folders; l; l = l->next)
9483     {
9484       GFile *folder = l->data;
9485
9486       _gtk_file_system_model_add_and_query_file (impl->recent_model,
9487                                                  folder,
9488                                                  MODEL_ATTRIBUTES);
9489     }
9490
9491   g_list_foreach (folders, (GFunc) g_object_unref, NULL);
9492   g_list_free (folders);
9493 }
9494
9495 static gboolean
9496 recent_idle_load (gpointer data)
9497 {
9498   RecentLoadData *load_data = data;
9499   GtkFileChooserDefault *impl = load_data->impl;
9500
9501   if (!impl->recent_manager)
9502     return FALSE;
9503
9504   load_data->items = gtk_recent_manager_get_items (impl->recent_manager);
9505   if (!load_data->items)
9506     return FALSE;
9507
9508   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
9509     populate_model_with_recent_items (impl, load_data->items);
9510   else
9511     populate_model_with_folders (impl, load_data->items);
9512
9513   g_list_foreach (load_data->items, (GFunc) gtk_recent_info_unref, NULL);
9514   g_list_free (load_data->items);
9515   load_data->items = NULL;
9516
9517   return FALSE;
9518 }
9519
9520 static void
9521 recent_start_loading (GtkFileChooserDefault *impl)
9522 {
9523   RecentLoadData *load_data;
9524
9525   recent_stop_loading (impl);
9526   recent_clear_model (impl, TRUE);
9527   recent_setup_model (impl);
9528   set_busy_cursor (impl, TRUE);
9529
9530   g_assert (impl->load_recent_id == 0);
9531
9532   load_data = g_new (RecentLoadData, 1);
9533   load_data->impl = impl;
9534   load_data->items = NULL;
9535
9536   /* begin lazy loading the recent files into the model */
9537   impl->load_recent_id = gdk_threads_add_idle_full (G_PRIORITY_HIGH_IDLE + 30,
9538                                                     recent_idle_load,
9539                                                     load_data,
9540                                                     recent_idle_cleanup);
9541 }
9542
9543 static void
9544 recent_selected_foreach_get_file_cb (GtkTreeModel *model,
9545                                      GtkTreePath  *path,
9546                                      GtkTreeIter  *iter,
9547                                      gpointer      data)
9548 {
9549   GSList **list;
9550   GFile *file;
9551
9552   list = data;
9553
9554   gtk_tree_model_get (model, iter, MODEL_COL_FILE, &file, -1);
9555   *list = g_slist_prepend (*list, file);
9556 }
9557
9558 /* Constructs a list of the selected paths in recent files mode */
9559 static GSList *
9560 recent_get_selected_files (GtkFileChooserDefault *impl)
9561 {
9562   GSList *result;
9563   GtkTreeSelection *selection;
9564
9565   result = NULL;
9566
9567   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9568   gtk_tree_selection_selected_foreach (selection, recent_selected_foreach_get_file_cb, &result);
9569   result = g_slist_reverse (result);
9570
9571   return result;
9572 }
9573
9574 /* Called from ::should_respond().  We return whether there are selected
9575  * files in the recent files list.
9576  */
9577 static gboolean
9578 recent_should_respond (GtkFileChooserDefault *impl)
9579 {
9580   GtkTreeSelection *selection;
9581
9582   g_assert (impl->operation_mode == OPERATION_MODE_RECENT);
9583
9584   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
9585   return (gtk_tree_selection_count_selected_rows (selection) != 0);
9586 }
9587
9588 static void
9589 set_current_filter (GtkFileChooserDefault *impl,
9590                     GtkFileFilter         *filter)
9591 {
9592   if (impl->current_filter != filter)
9593     {
9594       int filter_index;
9595
9596       /* NULL filters are allowed to reset to non-filtered status
9597        */
9598       filter_index = g_slist_index (impl->filters, filter);
9599       if (impl->filters && filter && filter_index < 0)
9600         return;
9601
9602       if (impl->current_filter)
9603         g_object_unref (impl->current_filter);
9604       impl->current_filter = filter;
9605       if (impl->current_filter)
9606         {
9607           g_object_ref_sink (impl->current_filter);
9608         }
9609
9610       if (impl->filters)
9611         gtk_combo_box_set_active (GTK_COMBO_BOX (impl->filter_combo),
9612                                   filter_index);
9613
9614       if (impl->browse_files_model)
9615         {
9616           _gtk_file_system_model_set_filter (impl->browse_files_model, impl->current_filter);
9617           _gtk_file_system_model_clear_cache (impl->browse_files_model, MODEL_COL_IS_SENSITIVE);
9618         }
9619
9620       if (impl->search_model)
9621         {
9622           _gtk_file_system_model_set_filter (impl->search_model, filter);
9623           _gtk_file_system_model_clear_cache (impl->search_model, MODEL_COL_IS_SENSITIVE);
9624         }
9625
9626       if (impl->recent_model)
9627         {
9628           _gtk_file_system_model_set_filter (impl->recent_model, filter);
9629           _gtk_file_system_model_clear_cache (impl->recent_model, MODEL_COL_IS_SENSITIVE);
9630         }
9631
9632       g_object_notify (G_OBJECT (impl), "filter");
9633     }
9634 }
9635
9636 static void
9637 filter_combo_changed (GtkComboBox           *combo_box,
9638                       GtkFileChooserDefault *impl)
9639 {
9640   gint new_index = gtk_combo_box_get_active (combo_box);
9641   GtkFileFilter *new_filter = g_slist_nth_data (impl->filters, new_index);
9642
9643   set_current_filter (impl, new_filter);
9644 }
9645
9646 static void
9647 check_preview_change (GtkFileChooserDefault *impl)
9648 {
9649   GtkTreePath *cursor_path;
9650   GFile *new_file;
9651   char *new_display_name;
9652   GtkTreeModel *model;
9653
9654   gtk_tree_view_get_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view), &cursor_path, NULL);
9655   model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
9656   if (cursor_path)
9657     {
9658       GtkTreeIter iter;
9659
9660       gtk_tree_model_get_iter (model, &iter, cursor_path);
9661       gtk_tree_model_get (model, &iter,
9662                           MODEL_COL_FILE, &new_file,
9663                           MODEL_COL_NAME, &new_display_name,
9664                           -1);
9665
9666       gtk_tree_path_free (cursor_path);
9667     }
9668   else
9669     {
9670       new_file = NULL;
9671       new_display_name = NULL;
9672     }
9673
9674   if (new_file != impl->preview_file &&
9675       !(new_file && impl->preview_file &&
9676         g_file_equal (new_file, impl->preview_file)))
9677     {
9678       if (impl->preview_file)
9679         {
9680           g_object_unref (impl->preview_file);
9681           g_free (impl->preview_display_name);
9682         }
9683
9684       if (new_file)
9685         {
9686           impl->preview_file = new_file;
9687           impl->preview_display_name = new_display_name;
9688         }
9689       else
9690         {
9691           impl->preview_file = NULL;
9692           impl->preview_display_name = NULL;
9693           g_free (new_display_name);
9694         }
9695
9696       if (impl->use_preview_label && impl->preview_label)
9697         gtk_label_set_text (GTK_LABEL (impl->preview_label), impl->preview_display_name);
9698
9699       g_signal_emit_by_name (impl, "update-preview");
9700     }
9701   else
9702     {
9703       if (new_file)
9704         g_object_unref (new_file);
9705
9706       g_free (new_display_name);
9707     }
9708 }
9709
9710 static void
9711 shortcuts_activate_volume_mount_cb (GCancellable        *cancellable,
9712                                     GtkFileSystemVolume *volume,
9713                                     const GError        *error,
9714                                     gpointer             data)
9715 {
9716   GFile *file;
9717   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
9718   GtkFileChooserDefault *impl = data;
9719
9720   if (cancellable != impl->shortcuts_activate_iter_cancellable)
9721     goto out;
9722
9723   impl->shortcuts_activate_iter_cancellable = NULL;
9724
9725   set_busy_cursor (impl, FALSE);
9726
9727   if (cancelled)
9728     goto out;
9729
9730   if (error)
9731     {
9732       if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED))
9733         {
9734           char *msg, *name;
9735
9736           name = _gtk_file_system_volume_get_display_name (volume);
9737           msg = g_strdup_printf (_("Could not mount %s"), name);
9738
9739           error_message (impl, msg, error->message);
9740
9741           g_free (msg);
9742           g_free (name);
9743         }
9744
9745       goto out;
9746     }
9747
9748   file = _gtk_file_system_volume_get_root (volume);
9749   if (file != NULL)
9750     {
9751       change_folder_and_display_error (impl, file, FALSE);
9752       g_object_unref (file);
9753     }
9754
9755 out:
9756   g_object_unref (impl);
9757   g_object_unref (cancellable);
9758 }
9759
9760
9761 /* Activates a volume by mounting it if necessary and then switching to its
9762  * base path.
9763  */
9764 static void
9765 shortcuts_activate_volume (GtkFileChooserDefault *impl,
9766                            GtkFileSystemVolume   *volume)
9767 {
9768   GFile *file;
9769
9770   operation_mode_set (impl, OPERATION_MODE_BROWSE);
9771
9772   /* We ref the file chooser since volume_mount() may run a main loop, and the
9773    * user could close the file chooser window in the meantime.
9774    */
9775   g_object_ref (impl);
9776
9777   if (!_gtk_file_system_volume_is_mounted (volume))
9778     {
9779       GMountOperation *mount_op;
9780
9781       set_busy_cursor (impl, TRUE);
9782
9783       mount_op = gtk_mount_operation_new (get_toplevel (GTK_WIDGET (impl)));
9784       impl->shortcuts_activate_iter_cancellable =
9785         _gtk_file_system_mount_volume (impl->file_system, volume, mount_op,
9786                                        shortcuts_activate_volume_mount_cb,
9787                                        g_object_ref (impl));
9788       g_object_unref (mount_op);
9789     }
9790   else
9791     {
9792       file = _gtk_file_system_volume_get_root (volume);
9793       if (file != NULL)
9794         {
9795           change_folder_and_display_error (impl, file, FALSE);
9796           g_object_unref (file);
9797         }
9798     }
9799
9800   g_object_unref (impl);
9801 }
9802
9803 /* Opens the folder or volume at the specified iter in the shortcuts model */
9804 struct ShortcutsActivateData
9805 {
9806   GtkFileChooserDefault *impl;
9807   GFile *file;
9808 };
9809
9810 static void
9811 shortcuts_activate_get_info_cb (GCancellable *cancellable,
9812                                 GFileInfo    *info,
9813                                 const GError *error,
9814                                 gpointer      user_data)
9815 {
9816   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
9817   struct ShortcutsActivateData *data = user_data;
9818
9819   if (cancellable != data->impl->shortcuts_activate_iter_cancellable)
9820     goto out;
9821
9822   data->impl->shortcuts_activate_iter_cancellable = NULL;
9823
9824   if (cancelled)
9825     goto out;
9826
9827   if (!error && _gtk_file_info_consider_as_directory (info))
9828     change_folder_and_display_error (data->impl, data->file, FALSE);
9829   else
9830     gtk_file_chooser_default_select_file (GTK_FILE_CHOOSER (data->impl),
9831                                           data->file,
9832                                           NULL);
9833
9834 out:
9835   g_object_unref (data->impl);
9836   g_object_unref (data->file);
9837   g_free (data);
9838
9839   g_object_unref (cancellable);
9840 }
9841
9842 static void
9843 shortcuts_activate_mount_enclosing_volume (GCancellable        *cancellable,
9844                                            GtkFileSystemVolume *volume,
9845                                            const GError        *error,
9846                                            gpointer             user_data)
9847 {
9848   struct ShortcutsActivateData *data = user_data;
9849
9850   if (error)
9851     {
9852       error_changing_folder_dialog (data->impl, data->file, g_error_copy (error));
9853
9854       g_object_unref (data->impl);
9855       g_object_unref (data->file);
9856       g_free (data);
9857
9858       return;
9859     }
9860
9861   data->impl->shortcuts_activate_iter_cancellable =
9862     _gtk_file_system_get_info (data->impl->file_system, data->file,
9863                                "standard::type",
9864                                shortcuts_activate_get_info_cb, data);
9865
9866   if (volume)
9867     _gtk_file_system_volume_unref (volume);
9868 }
9869
9870 static void
9871 shortcuts_activate_iter (GtkFileChooserDefault *impl,
9872                          GtkTreeIter           *iter)
9873 {
9874   gpointer col_data;
9875   ShortcutType shortcut_type;
9876
9877   /* In the Save modes, we want to preserve what the uesr typed in the filename
9878    * entry, so that he may choose another folder without erasing his typed name.
9879    */
9880   if (impl->location_entry
9881       && !(impl->action == GTK_FILE_CHOOSER_ACTION_SAVE
9882            || impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER))
9883     gtk_entry_set_text (GTK_ENTRY (impl->location_entry), "");
9884
9885   gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), iter,
9886                       SHORTCUTS_COL_DATA, &col_data,
9887                       SHORTCUTS_COL_TYPE, &shortcut_type,
9888                       -1);
9889
9890   if (impl->shortcuts_activate_iter_cancellable)
9891     {
9892       g_cancellable_cancel (impl->shortcuts_activate_iter_cancellable);
9893       impl->shortcuts_activate_iter_cancellable = NULL;
9894     }
9895
9896   if (shortcut_type == SHORTCUT_TYPE_SEPARATOR)
9897     return;
9898   else if (shortcut_type == SHORTCUT_TYPE_VOLUME)
9899     {
9900       GtkFileSystemVolume *volume;
9901
9902       volume = col_data;
9903
9904       operation_mode_set (impl, OPERATION_MODE_BROWSE);
9905
9906       shortcuts_activate_volume (impl, volume);
9907     }
9908   else if (shortcut_type == SHORTCUT_TYPE_FILE)
9909     {
9910       struct ShortcutsActivateData *data;
9911       GtkFileSystemVolume *volume;
9912
9913       operation_mode_set (impl, OPERATION_MODE_BROWSE);
9914
9915       volume = _gtk_file_system_get_volume_for_file (impl->file_system, col_data);
9916
9917       data = g_new0 (struct ShortcutsActivateData, 1);
9918       data->impl = g_object_ref (impl);
9919       data->file = g_object_ref (col_data);
9920
9921       if (!volume || !_gtk_file_system_volume_is_mounted (volume))
9922         {
9923           GMountOperation *mount_operation;
9924           GtkWidget *toplevel;
9925
9926           toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
9927
9928           mount_operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
9929
9930           impl->shortcuts_activate_iter_cancellable =
9931             _gtk_file_system_mount_enclosing_volume (impl->file_system, col_data,
9932                                                      mount_operation,
9933                                                      shortcuts_activate_mount_enclosing_volume,
9934                                                      data);
9935         }
9936       else
9937         {
9938           impl->shortcuts_activate_iter_cancellable =
9939             _gtk_file_system_get_info (impl->file_system, data->file,
9940                                        "standard::type",
9941                                        shortcuts_activate_get_info_cb, data);
9942         }
9943     }
9944   else if (shortcut_type == SHORTCUT_TYPE_SEARCH)
9945     {
9946       operation_mode_set (impl, OPERATION_MODE_SEARCH);
9947     }
9948   else if (shortcut_type == SHORTCUT_TYPE_RECENT)
9949     {
9950       operation_mode_set (impl, OPERATION_MODE_RECENT);
9951     }
9952 }
9953
9954 /* Handler for GtkWidget::key-press-event on the shortcuts list */
9955 static gboolean
9956 shortcuts_key_press_event_cb (GtkWidget             *widget,
9957                               GdkEventKey           *event,
9958                               GtkFileChooserDefault *impl)
9959 {
9960   guint modifiers;
9961
9962   modifiers = gtk_accelerator_get_default_mod_mask ();
9963
9964   if (key_is_left_or_right (event))
9965     {
9966       gtk_widget_grab_focus (impl->browse_files_tree_view);
9967       return TRUE;
9968     }
9969
9970   if ((event->keyval == GDK_KEY_BackSpace
9971       || event->keyval == GDK_KEY_Delete
9972       || event->keyval == GDK_KEY_KP_Delete)
9973       && (event->state & modifiers) == 0)
9974     {
9975       remove_selected_bookmarks (impl);
9976       return TRUE;
9977     }
9978
9979   if ((event->keyval == GDK_KEY_F2)
9980       && (event->state & modifiers) == 0)
9981     {
9982       rename_selected_bookmark (impl);
9983       return TRUE;
9984     }
9985
9986   return FALSE;
9987 }
9988
9989 static gboolean
9990 shortcuts_select_func  (GtkTreeSelection  *selection,
9991                         GtkTreeModel      *model,
9992                         GtkTreePath       *path,
9993                         gboolean           path_currently_selected,
9994                         gpointer           data)
9995 {
9996   GtkFileChooserDefault *impl = data;
9997   GtkTreeIter filter_iter;
9998   ShortcutType shortcut_type;
9999
10000   if (!gtk_tree_model_get_iter (impl->shortcuts_pane_filter_model, &filter_iter, path))
10001     g_assert_not_reached ();
10002
10003   gtk_tree_model_get (impl->shortcuts_pane_filter_model, &filter_iter, SHORTCUTS_COL_TYPE, &shortcut_type, -1);
10004
10005   return shortcut_type != SHORTCUT_TYPE_SEPARATOR;
10006 }
10007
10008 static gboolean
10009 list_select_func  (GtkTreeSelection  *selection,
10010                    GtkTreeModel      *model,
10011                    GtkTreePath       *path,
10012                    gboolean           path_currently_selected,
10013                    gpointer           data)
10014 {
10015   GtkFileChooserDefault *impl = data;
10016
10017   if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
10018       impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
10019     {
10020       GtkTreeIter iter;
10021       gboolean is_sensitive;
10022       gboolean is_folder;
10023
10024       if (!gtk_tree_model_get_iter (model, &iter, path))
10025         return FALSE;
10026       gtk_tree_model_get (model, &iter,
10027                           MODEL_COL_IS_SENSITIVE, &is_sensitive,
10028                           MODEL_COL_IS_FOLDER, &is_folder,
10029                           -1);
10030       if (!is_sensitive || !is_folder)
10031         return FALSE;
10032     }
10033
10034   return TRUE;
10035 }
10036
10037 static void
10038 list_selection_changed (GtkTreeSelection      *selection,
10039                         GtkFileChooserDefault *impl)
10040 {
10041   /* See if we are in the new folder editable row for Save mode */
10042   if (impl->operation_mode == OPERATION_MODE_BROWSE &&
10043       impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
10044     {
10045       GFileInfo *info;
10046       gboolean had_selection;
10047
10048       info = get_selected_file_info_from_file_list (impl, &had_selection);
10049       if (!had_selection)
10050         goto out; /* normal processing */
10051
10052       if (!info)
10053         return; /* We are on the editable row for New Folder */
10054     }
10055
10056  out:
10057
10058   if (impl->location_entry)
10059     update_chooser_entry (impl);
10060
10061   path_bar_update (impl);
10062
10063   check_preview_change (impl);
10064   bookmarks_check_add_sensitivity (impl);
10065   check_copy_file_location_sensitivity (impl);
10066
10067   g_signal_emit_by_name (impl, "selection-changed", 0);
10068 }
10069
10070 /* Callback used when a row in the file list is activated */
10071 static void
10072 list_row_activated (GtkTreeView           *tree_view,
10073                     GtkTreePath           *path,
10074                     GtkTreeViewColumn     *column,
10075                     GtkFileChooserDefault *impl)
10076 {
10077   GFile *file;
10078   GtkTreeIter iter;
10079   GtkTreeModel *model;
10080   gboolean is_folder;
10081   gboolean is_sensitive;
10082
10083   model = gtk_tree_view_get_model (tree_view);
10084
10085   if (!gtk_tree_model_get_iter (model, &iter, path))
10086     return;
10087
10088   gtk_tree_model_get (model, &iter,
10089                       MODEL_COL_FILE, &file,
10090                       MODEL_COL_IS_FOLDER, &is_folder,
10091                       MODEL_COL_IS_SENSITIVE, &is_sensitive,
10092                       -1);
10093
10094   if (is_sensitive && is_folder && file)
10095     {
10096       change_folder_and_display_error (impl, file, FALSE);
10097       goto out;
10098     }
10099
10100   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
10101       impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
10102     g_signal_emit_by_name (impl, "file-activated");
10103
10104  out:
10105
10106   if (file)
10107     g_object_unref (file);
10108 }
10109
10110 static void
10111 path_bar_clicked (GtkPathBar            *path_bar,
10112                   GFile                 *file,
10113                   GFile                 *child_file,
10114                   gboolean               child_is_hidden,
10115                   GtkFileChooserDefault *impl)
10116 {
10117   if (child_file)
10118     pending_select_files_add (impl, child_file);
10119
10120   if (!change_folder_and_display_error (impl, file, FALSE))
10121     return;
10122
10123   /* Say we have "/foo/bar/[.baz]" and the user clicks on "bar".  We should then
10124    * show hidden files so that ".baz" appears in the file list, as it will still
10125    * be shown in the path bar: "/foo/[bar]/.baz"
10126    */
10127   if (child_is_hidden)
10128     g_object_set (impl, "show-hidden", TRUE, NULL);
10129 }
10130
10131 static void
10132 update_cell_renderer_attributes (GtkFileChooserDefault *impl)
10133 {
10134   GtkTreeViewColumn *column;
10135   GtkCellRenderer *renderer;
10136   GList *walk, *list;
10137
10138   /* Keep the following column numbers in sync with create_file_list() */
10139
10140   /* name */
10141   column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 0);
10142   list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
10143   for (walk = list; walk; walk = walk->next)
10144     {
10145       renderer = walk->data;
10146       if (GTK_IS_CELL_RENDERER_PIXBUF (renderer))
10147         {
10148           gtk_tree_view_column_set_attributes (column, renderer,
10149                                                "pixbuf", MODEL_COL_PIXBUF,
10150                                                NULL);
10151         }
10152       else
10153         {
10154           gtk_tree_view_column_set_attributes (column, renderer,
10155                                                "text", MODEL_COL_NAME,
10156                                                "ellipsize", MODEL_COL_ELLIPSIZE,
10157                                                NULL);
10158         }
10159
10160       gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_SENSITIVE);
10161     }
10162   g_list_free (list);
10163
10164   /* size */
10165   column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 1);
10166   list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
10167   renderer = list->data;
10168   gtk_tree_view_column_set_attributes (column, renderer,
10169                                        "text", MODEL_COL_SIZE_TEXT,
10170                                        NULL);
10171
10172   gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_SENSITIVE);
10173   g_list_free (list);
10174
10175   /* mtime */
10176   column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 2);
10177   list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
10178   renderer = list->data;
10179   gtk_tree_view_column_set_attributes (column, renderer,
10180                                        "text", MODEL_COL_MTIME_TEXT,
10181                                        NULL);
10182   gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_SENSITIVE);
10183   g_list_free (list);
10184 }
10185
10186 GtkWidget *
10187 _gtk_file_chooser_default_new (void)
10188 {
10189   return g_object_new (GTK_TYPE_FILE_CHOOSER_DEFAULT, NULL);
10190 }
10191
10192 static void
10193 location_set_user_text (GtkFileChooserDefault *impl,
10194                         const gchar           *path)
10195 {
10196   gtk_entry_set_text (GTK_ENTRY (impl->location_entry), path);
10197   gtk_editable_set_position (GTK_EDITABLE (impl->location_entry), -1);
10198 }
10199
10200 static void
10201 location_popup_handler (GtkFileChooserDefault *impl,
10202                         const gchar           *path)
10203 {
10204   if (impl->operation_mode != OPERATION_MODE_BROWSE)
10205     {
10206       GtkWidget *widget_to_focus;
10207
10208       operation_mode_set (impl, OPERATION_MODE_BROWSE);
10209
10210       if (impl->current_folder)
10211         change_folder_and_display_error (impl, impl->current_folder, FALSE);
10212
10213       if (impl->location_mode == LOCATION_MODE_PATH_BAR)
10214         widget_to_focus = impl->browse_files_tree_view;
10215       else
10216         widget_to_focus = impl->location_entry;
10217
10218       gtk_widget_grab_focus (widget_to_focus);
10219       return;
10220     }
10221
10222   if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
10223       impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
10224     {
10225       if (!path)
10226         return;
10227
10228       location_mode_set (impl, LOCATION_MODE_FILENAME_ENTRY, TRUE);
10229       location_set_user_text (impl, path);
10230     }
10231   else if (impl->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
10232            impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
10233     {
10234       gtk_widget_grab_focus (impl->location_entry);
10235       if (path != NULL)
10236         location_set_user_text (impl, path);
10237     }
10238   else
10239     g_assert_not_reached ();
10240 }
10241
10242 /* Handler for the "up-folder" keybinding signal */
10243 static void
10244 up_folder_handler (GtkFileChooserDefault *impl)
10245 {
10246   _gtk_path_bar_up (GTK_PATH_BAR (impl->browse_path_bar));
10247 }
10248
10249 /* Handler for the "down-folder" keybinding signal */
10250 static void
10251 down_folder_handler (GtkFileChooserDefault *impl)
10252 {
10253   _gtk_path_bar_down (GTK_PATH_BAR (impl->browse_path_bar));
10254 }
10255
10256 /* Switches to the shortcut in the specified index */
10257 static void
10258 switch_to_shortcut (GtkFileChooserDefault *impl,
10259                     int pos)
10260 {
10261   GtkTreeIter iter;
10262
10263   if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (impl->shortcuts_model), &iter, NULL, pos))
10264     g_assert_not_reached ();
10265
10266   shortcuts_activate_iter (impl, &iter);
10267 }
10268
10269 /* Handler for the "home-folder" keybinding signal */
10270 static void
10271 home_folder_handler (GtkFileChooserDefault *impl)
10272 {
10273   if (impl->has_home)
10274     switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_HOME));
10275 }
10276
10277 /* Handler for the "desktop-folder" keybinding signal */
10278 static void
10279 desktop_folder_handler (GtkFileChooserDefault *impl)
10280 {
10281   if (impl->has_desktop)
10282     switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_DESKTOP));
10283 }
10284
10285 /* Handler for the "search-shortcut" keybinding signal */
10286 static void
10287 search_shortcut_handler (GtkFileChooserDefault *impl)
10288 {
10289   if (impl->has_search)
10290     {
10291       switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_SEARCH));
10292
10293       /* we want the entry widget to grab the focus the first
10294        * time, not the browse_files_tree_view widget.
10295        */
10296       if (impl->search_entry)
10297         gtk_widget_grab_focus (impl->search_entry);
10298     }
10299 }
10300
10301 /* Handler for the "recent-shortcut" keybinding signal */
10302 static void
10303 recent_shortcut_handler (GtkFileChooserDefault *impl)
10304 {
10305   switch_to_shortcut (impl, shortcuts_get_index (impl, SHORTCUTS_RECENT));
10306 }
10307
10308 static void
10309 quick_bookmark_handler (GtkFileChooserDefault *impl,
10310                         gint bookmark_index)
10311 {
10312   int bookmark_pos;
10313   GtkTreePath *path;
10314
10315   if (bookmark_index < 0 || bookmark_index >= impl->num_bookmarks)
10316     return;
10317
10318   bookmark_pos = shortcuts_get_index (impl, SHORTCUTS_BOOKMARKS) + bookmark_index;
10319
10320   path = gtk_tree_path_new_from_indices (bookmark_pos, -1);
10321   gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view),
10322                                 path, NULL,
10323                                 FALSE, 0.0, 0.0);
10324   gtk_tree_path_free (path);
10325
10326   switch_to_shortcut (impl, bookmark_pos);
10327 }
10328
10329 static void
10330 show_hidden_handler (GtkFileChooserDefault *impl)
10331 {
10332   g_object_set (impl,
10333                 "show-hidden", !impl->show_hidden,
10334                 NULL);
10335 }
10336
10337
10338 /* Drag and drop interfaces */
10339
10340 static void
10341 _shortcuts_pane_model_filter_class_init (ShortcutsPaneModelFilterClass *class)
10342 {
10343 }
10344
10345 static void
10346 _shortcuts_pane_model_filter_init (ShortcutsPaneModelFilter *model)
10347 {
10348   model->impl = NULL;
10349 }
10350
10351 /* GtkTreeDragSource::row_draggable implementation for the shortcuts filter model */
10352 static gboolean
10353 shortcuts_pane_model_filter_row_draggable (GtkTreeDragSource *drag_source,
10354                                            GtkTreePath       *path)
10355 {
10356   ShortcutsPaneModelFilter *model;
10357   int pos;
10358   int bookmarks_pos;
10359
10360   model = SHORTCUTS_PANE_MODEL_FILTER (drag_source);
10361
10362   pos = *gtk_tree_path_get_indices (path);
10363   bookmarks_pos = shortcuts_get_index (model->impl, SHORTCUTS_BOOKMARKS);
10364
10365   return (pos >= bookmarks_pos && pos < bookmarks_pos + model->impl->num_bookmarks);
10366 }
10367
10368 /* GtkTreeDragSource::drag_data_get implementation for the shortcuts
10369  * filter model
10370  */
10371 static gboolean
10372 shortcuts_pane_model_filter_drag_data_get (GtkTreeDragSource *drag_source,
10373                                            GtkTreePath       *path,
10374                                            GtkSelectionData  *selection_data)
10375 {
10376   /* FIXME */
10377
10378   return FALSE;
10379 }
10380
10381 /* Fill the GtkTreeDragSourceIface vtable */
10382 static void
10383 shortcuts_pane_model_filter_drag_source_iface_init (GtkTreeDragSourceIface *iface)
10384 {
10385   iface->row_draggable = shortcuts_pane_model_filter_row_draggable;
10386   iface->drag_data_get = shortcuts_pane_model_filter_drag_data_get;
10387 }
10388
10389 #if 0
10390 /* Fill the GtkTreeDragDestIface vtable */
10391 static void
10392 shortcuts_pane_model_filter_drag_dest_iface_init (GtkTreeDragDestIface *iface)
10393 {
10394   iface->drag_data_received = shortcuts_pane_model_filter_drag_data_received;
10395   iface->row_drop_possible = shortcuts_pane_model_filter_row_drop_possible;
10396 }
10397 #endif
10398
10399 static GtkTreeModel *
10400 shortcuts_pane_model_filter_new (GtkFileChooserDefault *impl,
10401                                  GtkTreeModel          *child_model,
10402                                  GtkTreePath           *root)
10403 {
10404   ShortcutsPaneModelFilter *model;
10405
10406   model = g_object_new (SHORTCUTS_PANE_MODEL_FILTER_TYPE,
10407                         "child-model", child_model,
10408                         "virtual-root", root,
10409                         NULL);
10410
10411   model->impl = impl;
10412
10413   return GTK_TREE_MODEL (model);
10414 }
10415