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

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