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