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