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