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

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */
   2
   3 /* GTK+: gtkfilechooserbutton.c
   4  *
   5  * Copyright (c) 2004 James M. Cape <jcape@ignore-your.tv>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #ifdef HAVE_UNISTD_H
  28 #include <unistd.h>
  29 #endif
  30
  31 #include <string.h>
  32
  33 #include "gtkintl.h"
  34 #include "gtkbutton.h"
  35 #include "gtkcelllayout.h"
  36 #include "gtkcellrenderertext.h"
  37 #include "gtkcellrendererpixbuf.h"
  38 #include "gtkcombobox.h"
  39 #include "gtkdnd.h"
  40 #include "gtkicontheme.h"
  41 #include "gtkiconfactory.h"
  42 #include "gtkimage.h"
  43 #include "gtklabel.h"
  44 #include "gtkliststore.h"
  45 #include "gtkstock.h"
  46 #include "gtktreemodelfilter.h"
  47 #include "gtkvseparator.h"
  48 #include "gtkfilechooserdialog.h"
  49 #include "gtkfilechooserprivate.h"
  50 #include "gtkfilechooserutils.h"
  51 #include "gtkmarshalers.h"
  52
  53 #include "gtkfilechooserbutton.h"
  54
  55 #include "gtkprivate.h"
  56
  57 /* **************** *
  58  *  Private Macros  *
  59  * **************** */
  60
  61 #define DEFAULT_TITLE           N_("Select A File")
  62 #define DESKTOP_DISPLAY_NAME    N_("Desktop")
  63 #define FALLBACK_DISPLAY_NAME   N_("(None)")
  64 #define FALLBACK_ICON_NAME      "stock_unknown"
  65 #define FALLBACK_ICON_SIZE      16
  66
  67
  68 /* ********************** *
  69  *  Private Enumerations  *
  70  * ********************** */
  71
  72 /* Property IDs */
  73 enum
  74 {
  75   PROP_0,
  76
  77   PROP_DIALOG,
  78   PROP_FOCUS_ON_CLICK,
  79   PROP_TITLE,
  80   PROP_WIDTH_CHARS
  81 };
  82
  83 /* Signals */
  84 enum
  85 {
  86   FILE_SET,
  87   LAST_SIGNAL
  88 };
  89
  90 /* TreeModel Columns */
  91 enum
  92 {
  93   ICON_COLUMN,
  94   DISPLAY_NAME_COLUMN,
  95   TYPE_COLUMN,
  96   DATA_COLUMN,
  97   IS_FOLDER_COLUMN,
  98   CANCELLABLE_COLUMN,
  99   NUM_COLUMNS
 100 };
 101
 102 /* TreeModel Row Types */
 103 typedef enum
 104 {
 105   ROW_TYPE_SPECIAL,
 106   ROW_TYPE_VOLUME,
 107   ROW_TYPE_SHORTCUT,
 108   ROW_TYPE_BOOKMARK_SEPARATOR,
 109   ROW_TYPE_BOOKMARK,
 110   ROW_TYPE_CURRENT_FOLDER_SEPARATOR,
 111   ROW_TYPE_CURRENT_FOLDER,
 112   ROW_TYPE_OTHER_SEPARATOR,
 113   ROW_TYPE_OTHER,
 114
 115   ROW_TYPE_INVALID = -1
 116 }
 117 RowType;
 118
 119
 120 /* ******************** *
 121  *  Private Structures  *
 122  * ******************** */
 123
 124 struct _GtkFileChooserButtonPrivate
 125 {
 126   GtkWidget *dialog;
 127   GtkWidget *button;
 128   GtkWidget *image;
 129   GtkWidget *label;
 130   GtkWidget *combo_box;
 131   GtkCellRenderer *icon_cell;
 132   GtkCellRenderer *name_cell;
 133
 134   GtkTreeModel *model;
 135   GtkTreeModel *filter_model;
 136
 137   GtkFileSystem *fs;
 138   GFile *old_file;
 139
 140   gulong combo_box_changed_id;
 141   gulong dialog_file_activated_id;
 142   gulong dialog_folder_changed_id;
 143   gulong dialog_selection_changed_id;
 144   gulong fs_volumes_changed_id;
 145   gulong fs_bookmarks_changed_id;
 146
 147   GCancellable *dnd_select_folder_cancellable;
 148   GCancellable *update_button_cancellable;
 149   GSList *change_icon_theme_cancellables;
 150
 151   gint icon_size;
 152
 153   guint8 n_special;
 154   guint8 n_volumes;
 155   guint8 n_shortcuts;
 156   guint8 n_bookmarks;
 157   guint  has_bookmark_separator       : 1;
 158   guint  has_current_folder_separator : 1;
 159   guint  has_current_folder           : 1;
 160   guint  has_other_separator          : 1;
 161
 162   /* Used for hiding/showing the dialog when the button is hidden */
 163   guint  active                       : 1;
 164
 165   /* Used to track whether we need to set a default current folder on ::map() */
 166   guint  folder_has_been_set          : 1;
 167
 168   guint  focus_on_click               : 1;
 169 };
 170
 171
 172 /* ************* *
 173  *  DnD Support  *
 174  * ************* */
 175
 176 enum
 177 {
 178   TEXT_PLAIN,
 179   TEXT_URI_LIST
 180 };
 181
 182
 183 /* ********************* *
 184  *  Function Prototypes  *
 185  * ********************* */
 186
 187 /* GtkFileChooserIface Functions */
 188 static void     gtk_file_chooser_button_file_chooser_iface_init (GtkFileChooserIface *iface);
 189 static gboolean gtk_file_chooser_button_add_shortcut_folder     (GtkFileChooser      *chooser,
 190                                                                  GFile               *file,
 191                                                                  GError             **error);
 192 static gboolean gtk_file_chooser_button_remove_shortcut_folder  (GtkFileChooser      *chooser,
 193                                                                  GFile               *file,
 194                                                                  GError             **error);
 195
 196 /* GObject Functions */
 197 static GObject *gtk_file_chooser_button_constructor        (GType             type,
 198                                                             guint             n_params,
 199                                                             GObjectConstructParam *params);
 200 static void     gtk_file_chooser_button_set_property       (GObject          *object,
 201                                                             guint             param_id,
 202                                                             const GValue     *value,
 203                                                             GParamSpec       *pspec);
 204 static void     gtk_file_chooser_button_get_property       (GObject          *object,
 205                                                             guint             param_id,
 206                                                             GValue           *value,
 207                                                             GParamSpec       *pspec);
 208 static void     gtk_file_chooser_button_finalize           (GObject          *object);
 209
 210 /* GtkWidget Functions */
 211 static void     gtk_file_chooser_button_destroy            (GtkWidget        *widget);
 212 static void     gtk_file_chooser_button_drag_data_received (GtkWidget        *widget,
 213                                                             GdkDragContext   *context,
 214                                                             gint              x,
 215                                                             gint              y,
 216                                                             GtkSelectionData *data,
 217                                                             guint             type,
 218                                                             guint             drag_time);
 219 static void     gtk_file_chooser_button_show_all           (GtkWidget        *widget);
 220 static void     gtk_file_chooser_button_hide_all           (GtkWidget        *widget);
 221 static void     gtk_file_chooser_button_show               (GtkWidget        *widget);
 222 static void     gtk_file_chooser_button_hide               (GtkWidget        *widget);
 223 static void     gtk_file_chooser_button_map                (GtkWidget        *widget);
 224 static gboolean gtk_file_chooser_button_mnemonic_activate  (GtkWidget        *widget,
 225                                                             gboolean          group_cycling);
 226 static void     gtk_file_chooser_button_style_set          (GtkWidget        *widget,
 227                                                             GtkStyle         *old_style);
 228 static void     gtk_file_chooser_button_screen_changed     (GtkWidget        *widget,
 229                                                             GdkScreen        *old_screen);
 230
 231 /* Utility Functions */
 232 static GtkIconTheme *get_icon_theme               (GtkWidget            *widget);
 233 static void          set_info_for_file_at_iter         (GtkFileChooserButton *fs,
 234                                                         GFile                *file,
 235                                                         GtkTreeIter          *iter);
 236
 237 static gint          model_get_type_position      (GtkFileChooserButton *button,
 238                                                    RowType               row_type);
 239 static void          model_free_row_data          (GtkFileChooserButton *button,
 240                                                    GtkTreeIter          *iter);
 241 static inline void   model_add_special            (GtkFileChooserButton *button);
 242 static inline void   model_add_other              (GtkFileChooserButton *button);
 243 static void          model_add_volumes            (GtkFileChooserButton *button,
 244                                                    GSList               *volumes);
 245 static void          model_add_bookmarks          (GtkFileChooserButton *button,
 246                                                    GSList               *bookmarks);
 247 static void          model_update_current_folder  (GtkFileChooserButton *button,
 248                                                    GFile                *file);
 249 static void          model_remove_rows            (GtkFileChooserButton *button,
 250                                                    gint                  pos,
 251                                                    gint                  n_rows);
 252
 253 static gboolean      filter_model_visible_func    (GtkTreeModel         *model,
 254                                                    GtkTreeIter          *iter,
 255                                                    gpointer              user_data);
 256
 257 static gboolean      combo_box_row_separator_func (GtkTreeModel         *model,
 258                                                    GtkTreeIter          *iter,
 259                                                    gpointer              user_data);
 260 static void          name_cell_data_func          (GtkCellLayout        *layout,
 261                                                    GtkCellRenderer      *cell,
 262                                                    GtkTreeModel         *model,
 263                                                    GtkTreeIter          *iter,
 264                                                    gpointer              user_data);
 265 static void          open_dialog                  (GtkFileChooserButton *button);
 266 static void          update_combo_box             (GtkFileChooserButton *button);
 267 static void          update_label_and_image       (GtkFileChooserButton *button);
 268
 269 /* Child Object Callbacks */
 270 static void     fs_volumes_changed_cb            (GtkFileSystem  *fs,
 271                                                   gpointer        user_data);
 272 static void     fs_bookmarks_changed_cb          (GtkFileSystem  *fs,
 273                                                   gpointer        user_data);
 274
 275 static void     combo_box_changed_cb             (GtkComboBox    *combo_box,
 276                                                   gpointer        user_data);
 277
 278 static void     button_clicked_cb                (GtkButton      *real_button,
 279                                                   gpointer        user_data);
 280
 281 static void     dialog_update_preview_cb         (GtkFileChooser *dialog,
 282                                                   gpointer        user_data);
 283 static void     dialog_selection_changed_cb      (GtkFileChooser *dialog,
 284                                                   gpointer        user_data);
 285 static void     dialog_file_activated_cb         (GtkFileChooser *dialog,
 286                                                   gpointer        user_data);
 287 static void     dialog_current_folder_changed_cb (GtkFileChooser *dialog,
 288                                                   gpointer        user_data);
 289 static void     dialog_notify_cb                 (GObject        *dialog,
 290                                                   GParamSpec     *pspec,
 291                                                   gpointer        user_data);
 292 static gboolean dialog_delete_event_cb           (GtkWidget      *dialog,
 293                                                   GdkEvent       *event,
 294                                                   gpointer        user_data);
 295 static void     dialog_response_cb               (GtkDialog      *dialog,
 296                                                   gint            response,
 297                                                   gpointer        user_data);
 298
 299 static guint file_chooser_button_signals[LAST_SIGNAL] = { 0 };
 300
 301 /* ******************* *
 302  *  GType Declaration  *
 303  * ******************* */
 304
 305 G_DEFINE_TYPE_WITH_CODE (GtkFileChooserButton, gtk_file_chooser_button, GTK_TYPE_HBOX, { \
 306     G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER, gtk_file_chooser_button_file_chooser_iface_init) \
 307 })
 308
 309
 310 /* ***************** *
 311  *  GType Functions  *
 312  * ***************** */
 313
 314 static void
 315 gtk_file_chooser_button_class_init (GtkFileChooserButtonClass * class)
 316 {
 317   GObjectClass *gobject_class;
 318   GtkWidgetClass *widget_class;
 319
 320   gobject_class = G_OBJECT_CLASS (class);
 321   widget_class = GTK_WIDGET_CLASS (class);
 322
 323   gobject_class->constructor = gtk_file_chooser_button_constructor;
 324   gobject_class->set_property = gtk_file_chooser_button_set_property;
 325   gobject_class->get_property = gtk_file_chooser_button_get_property;
 326   gobject_class->finalize = gtk_file_chooser_button_finalize;
 327
 328   widget_class->destroy = gtk_file_chooser_button_destroy;
 329   widget_class->drag_data_received = gtk_file_chooser_button_drag_data_received;
 330   widget_class->show_all = gtk_file_chooser_button_show_all;
 331   widget_class->hide_all = gtk_file_chooser_button_hide_all;
 332   widget_class->show = gtk_file_chooser_button_show;
 333   widget_class->hide = gtk_file_chooser_button_hide;
 334   widget_class->map = gtk_file_chooser_button_map;
 335   widget_class->style_set = gtk_file_chooser_button_style_set;
 336   widget_class->screen_changed = gtk_file_chooser_button_screen_changed;
 337   widget_class->mnemonic_activate = gtk_file_chooser_button_mnemonic_activate;
 338
 339   /**
 340    * GtkFileChooserButton::file-set:
 341    * @widget: the object which received the signal.
 342    *
 343    * The ::file-set signal is emitted when the user selects a file.
 344    *
 345    * Note that this signal is only emitted when the <emphasis>user</emphasis>
 346    * changes the file.
 347    *
 348    * Since: 2.12
 349    */
 350   file_chooser_button_signals[FILE_SET] =
 351     g_signal_new (I_("file-set"),
 352                   G_TYPE_FROM_CLASS (gobject_class),
 353                   G_SIGNAL_RUN_FIRST,
 354                   G_STRUCT_OFFSET (GtkFileChooserButtonClass, file_set),
 355                   NULL, NULL,
 356                   _gtk_marshal_VOID__VOID,
 357                   G_TYPE_NONE, 0);
 358
 359   /**
 360    * GtkFileChooserButton:dialog:
 361    *
 362    * Instance of the #GtkFileChooserDialog associated with the button.
 363    *
 364    * Since: 2.6
 365    */
 366   g_object_class_install_property (gobject_class, PROP_DIALOG,
 367                                    g_param_spec_object ("dialog",
 368                                                         P_("Dialog"),
 369                                                         P_("The file chooser dialog to use."),
 370                                                         GTK_TYPE_FILE_CHOOSER,
 371                                                         (GTK_PARAM_WRITABLE |
 372                                                          G_PARAM_CONSTRUCT_ONLY)));
 373
 374   /**
 375    * GtkFileChooserButton:focus-on-click:
 376    *
 377    * Whether the #GtkFileChooserButton button grabs focus when it is clicked
 378    * with the mouse.
 379    *
 380    * Since: 2.10
 381    */
 382   g_object_class_install_property (gobject_class,
 383                                    PROP_FOCUS_ON_CLICK,
 384                                    g_param_spec_boolean ("focus-on-click",
 385                                                          P_("Focus on click"),
 386                                                          P_("Whether the button grabs focus when it is clicked with the mouse"),
 387                                                          TRUE,
 388                                                          GTK_PARAM_READWRITE));
 389
 390   /**
 391    * GtkFileChooserButton:title:
 392    *
 393    * Title to put on the #GtkFileChooserDialog associated with the button.
 394    *
 395    * Since: 2.6
 396    */
 397   g_object_class_install_property (gobject_class, PROP_TITLE,
 398                                    g_param_spec_string ("title",
 399                                                         P_("Title"),
 400                                                         P_("The title of the file chooser dialog."),
 401                                                         _(DEFAULT_TITLE),
 402                                                         GTK_PARAM_READWRITE));
 403
 404   /**
 405    * GtkFileChooserButton:width-chars:
 406    *
 407    * The width of the entry and label inside the button, in characters.
 408    *
 409    * Since: 2.6
 410    */
 411   g_object_class_install_property (gobject_class, PROP_WIDTH_CHARS,
 412                                    g_param_spec_int ("width-chars",
 413                                                      P_("Width In Characters"),
 414                                                      P_("The desired width of the button widget, in characters."),
 415                                                      -1, G_MAXINT, -1,
 416                                                      GTK_PARAM_READWRITE));
 417
 418   _gtk_file_chooser_install_properties (gobject_class);
 419
 420   g_type_class_add_private (class, sizeof (GtkFileChooserButtonPrivate));
 421 }
 422
 423 static void
 424 gtk_file_chooser_button_init (GtkFileChooserButton *button)
 425 {
 426   GtkFileChooserButtonPrivate *priv;
 427   GtkWidget *box, *image, *sep;
 428   GtkTargetList *target_list;
 429
 430   priv = button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
 431                                                      GTK_TYPE_FILE_CHOOSER_BUTTON,
 432                                                      GtkFileChooserButtonPrivate);
 433
 434   priv->icon_size = FALLBACK_ICON_SIZE;
 435   priv->focus_on_click = TRUE;
 436
 437   gtk_widget_push_composite_child ();
 438
 439   /* Button */
 440   priv->button = gtk_button_new ();
 441   g_signal_connect (priv->button, "clicked", G_CALLBACK (button_clicked_cb),
 442                     button);
 443   gtk_container_add (GTK_CONTAINER (button), priv->button);
 444   gtk_widget_show (priv->button);
 445
 446   box = gtk_hbox_new (FALSE, 4);
 447   gtk_container_add (GTK_CONTAINER (priv->button), box);
 448   gtk_widget_show (box);
 449
 450   priv->image = gtk_image_new ();
 451   gtk_box_pack_start (GTK_BOX (box), priv->image, FALSE, FALSE, 0);
 452   gtk_widget_show (priv->image);
 453
 454   priv->label = gtk_label_new (_(FALLBACK_DISPLAY_NAME));
 455   gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
 456   gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);
 457   gtk_container_add (GTK_CONTAINER (box), priv->label);
 458   gtk_widget_show (priv->label);
 459
 460   sep = gtk_vseparator_new ();
 461   gtk_box_pack_start (GTK_BOX (box), sep, FALSE, FALSE, 0);
 462   gtk_widget_show (sep);
 463
 464   image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
 465                                     GTK_ICON_SIZE_MENU);
 466   gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 0);
 467   gtk_widget_show (image);
 468
 469   /* Combo Box */
 470   /* Keep in sync with columns enum, line 88 */
 471   priv->model =
 472     GTK_TREE_MODEL (gtk_list_store_new (NUM_COLUMNS,
 473                                         GDK_TYPE_PIXBUF, /* Icon */
 474                                         G_TYPE_STRING,   /* Display Name */
 475                                         G_TYPE_CHAR,     /* Row Type */
 476                                         G_TYPE_POINTER   /* Volume || Path */,
 477                                         G_TYPE_BOOLEAN   /* Is Folder? */,
 478                                         G_TYPE_POINTER   /* cancellable */));
 479
 480   priv->combo_box = gtk_combo_box_new ();
 481   priv->combo_box_changed_id =
 482     g_signal_connect (priv->combo_box, "changed",
 483                       G_CALLBACK (combo_box_changed_cb), button);
 484   gtk_container_add (GTK_CONTAINER (button), priv->combo_box);
 485
 486   priv->icon_cell = gtk_cell_renderer_pixbuf_new ();
 487   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->combo_box),
 488                               priv->icon_cell, FALSE);
 489   gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->combo_box),
 490                                  priv->icon_cell, "pixbuf", ICON_COLUMN);
 491
 492   priv->name_cell = gtk_cell_renderer_text_new ();
 493   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->combo_box),
 494                               priv->name_cell, TRUE);
 495   gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->combo_box),
 496                                  priv->name_cell, "text", DISPLAY_NAME_COLUMN);
 497   gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (priv->combo_box),
 498                                       priv->name_cell, name_cell_data_func,
 499                                       NULL, NULL);
 500
 501   gtk_widget_pop_composite_child ();
 502
 503   /* DnD */
 504   gtk_drag_dest_set (GTK_WIDGET (button),
 505                      (GTK_DEST_DEFAULT_ALL),
 506                      NULL, 0,
 507                      GDK_ACTION_COPY);
 508   target_list = gtk_target_list_new (NULL, 0);
 509   gtk_target_list_add_uri_targets (target_list, TEXT_URI_LIST);
 510   gtk_target_list_add_text_targets (target_list, TEXT_PLAIN);
 511   gtk_drag_dest_set_target_list (GTK_WIDGET (button), target_list);
 512   gtk_target_list_unref (target_list);
 513 }
 514
 515
 516 /* ******************************* *
 517  *  GtkFileChooserIface Functions  *
 518  * ******************************* */
 519 static void
 520 gtk_file_chooser_button_file_chooser_iface_init (GtkFileChooserIface *iface)
 521 {
 522   _gtk_file_chooser_delegate_iface_init (iface);
 523
 524   iface->add_shortcut_folder = gtk_file_chooser_button_add_shortcut_folder;
 525   iface->remove_shortcut_folder = gtk_file_chooser_button_remove_shortcut_folder;
 526 }
 527
 528 static gboolean
 529 gtk_file_chooser_button_add_shortcut_folder (GtkFileChooser  *chooser,
 530                                              GFile           *file,
 531                                              GError         **error)
 532 {
 533   GtkFileChooser *delegate;
 534   gboolean retval;
 535
 536   delegate = g_object_get_qdata (G_OBJECT (chooser),
 537                                  GTK_FILE_CHOOSER_DELEGATE_QUARK);
 538   retval = _gtk_file_chooser_add_shortcut_folder (delegate, file, error);
 539
 540   if (retval)
 541     {
 542       GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (chooser);
 543       GtkFileChooserButtonPrivate *priv = button->priv;
 544       GtkTreeIter iter;
 545       gint pos;
 546
 547       pos = model_get_type_position (button, ROW_TYPE_SHORTCUT);
 548       pos += priv->n_shortcuts;
 549
 550       gtk_list_store_insert (GTK_LIST_STORE (priv->model), &iter, pos);
 551       gtk_list_store_set (GTK_LIST_STORE (priv->model), &iter,
 552                           ICON_COLUMN, NULL,
 553                           DISPLAY_NAME_COLUMN, _(FALLBACK_DISPLAY_NAME),
 554                           TYPE_COLUMN, ROW_TYPE_SHORTCUT,
 555                           DATA_COLUMN, g_object_ref (file),
 556                           IS_FOLDER_COLUMN, FALSE,
 557                           -1);
 558       set_info_for_file_at_iter (button, file, &iter);
 559       priv->n_shortcuts++;
 560
 561       gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter_model));
 562     }
 563
 564   return retval;
 565 }
 566
 567 static gboolean
 568 gtk_file_chooser_button_remove_shortcut_folder (GtkFileChooser  *chooser,
 569                                                 GFile           *file,
 570                                                 GError         **error)
 571 {
 572   GtkFileChooser *delegate;
 573   gboolean retval;
 574
 575   delegate = g_object_get_qdata (G_OBJECT (chooser),
 576                                  GTK_FILE_CHOOSER_DELEGATE_QUARK);
 577
 578   retval = _gtk_file_chooser_remove_shortcut_folder (delegate, file, error);
 579
 580   if (retval)
 581     {
 582       GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (chooser);
 583       GtkFileChooserButtonPrivate *priv = button->priv;
 584       GtkTreeIter iter;
 585       gint pos;
 586       gchar type;
 587
 588       pos = model_get_type_position (button, ROW_TYPE_SHORTCUT);
 589       gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, pos);
 590
 591       do
 592         {
 593           gpointer data;
 594
 595           gtk_tree_model_get (priv->model, &iter,
 596                               TYPE_COLUMN, &type,
 597                               DATA_COLUMN, &data,
 598                               -1);
 599
 600           if (type == ROW_TYPE_SHORTCUT &&
 601               data && g_file_equal (data, file))
 602             {
 603               model_free_row_data (GTK_FILE_CHOOSER_BUTTON (chooser), &iter);
 604               gtk_list_store_remove (GTK_LIST_STORE (priv->model), &iter);
 605               priv->n_shortcuts--;
 606               gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter_model));
 607               update_combo_box (GTK_FILE_CHOOSER_BUTTON (chooser));
 608               break;
 609             }
 610         }
 611       while (type == ROW_TYPE_SHORTCUT &&
 612              gtk_tree_model_iter_next (priv->model, &iter));
 613     }
 614
 615   return retval;
 616 }
 617
 618
 619 /* ******************* *
 620  *  GObject Functions  *
 621  * ******************* */
 622
 623 static GObject *
 624 gtk_file_chooser_button_constructor (GType                  type,
 625                                      guint                  n_params,
 626                                      GObjectConstructParam *params)
 627 {
 628   GObject *object;
 629   GtkFileChooserButton *button;
 630   GtkFileChooserButtonPrivate *priv;
 631   GSList *list;
 632   char *current_folder;
 633
 634   object = G_OBJECT_CLASS (gtk_file_chooser_button_parent_class)->constructor (type,
 635                                                                                n_params,
 636                                                                                params);
 637   button = GTK_FILE_CHOOSER_BUTTON (object);
 638   priv = button->priv;
 639
 640   if (!priv->dialog)
 641     {
 642       priv->dialog = gtk_file_chooser_dialog_new (NULL, NULL,
 643                                                   GTK_FILE_CHOOSER_ACTION_OPEN,
 644                                                   GTK_STOCK_CANCEL,
 645                                                   GTK_RESPONSE_CANCEL,
 646                                                   GTK_STOCK_OPEN,
 647                                                   GTK_RESPONSE_ACCEPT,
 648                                                   NULL);
 649
 650       gtk_dialog_set_default_response (GTK_DIALOG (priv->dialog),
 651                                        GTK_RESPONSE_ACCEPT);
 652       gtk_dialog_set_alternative_button_order (GTK_DIALOG (priv->dialog),
 653                                                GTK_RESPONSE_ACCEPT,
 654                                                GTK_RESPONSE_CANCEL,
 655                                                -1);
 656
 657       gtk_file_chooser_button_set_title (button, _(DEFAULT_TITLE));
 658     }
 659   else if (!gtk_window_get_title (GTK_WINDOW (priv->dialog)))
 660     {
 661       gtk_file_chooser_button_set_title (button, _(DEFAULT_TITLE));
 662     }
 663
 664   current_folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (priv->dialog));
 665   if (current_folder != NULL)
 666     {
 667       priv->folder_has_been_set = TRUE;
 668       g_free (current_folder);
 669     }
 670
 671   g_signal_connect (priv->dialog, "delete-event",
 672                     G_CALLBACK (dialog_delete_event_cb), object);
 673   g_signal_connect (priv->dialog, "response",
 674                     G_CALLBACK (dialog_response_cb), object);
 675
 676   /* This is used, instead of the standard delegate, to ensure that signals are only
 677    * delegated when the OK button is pressed. */
 678   g_object_set_qdata (object, GTK_FILE_CHOOSER_DELEGATE_QUARK, priv->dialog);
 679   priv->dialog_folder_changed_id =
 680     g_signal_connect (priv->dialog, "current-folder-changed",
 681                       G_CALLBACK (dialog_current_folder_changed_cb), object);
 682   priv->dialog_file_activated_id =
 683     g_signal_connect (priv->dialog, "file-activated",
 684                       G_CALLBACK (dialog_file_activated_cb), object);
 685   priv->dialog_selection_changed_id =
 686     g_signal_connect (priv->dialog, "selection-changed",
 687                       G_CALLBACK (dialog_selection_changed_cb), object);
 688   g_signal_connect (priv->dialog, "update-preview",
 689                     G_CALLBACK (dialog_update_preview_cb), object);
 690   g_signal_connect (priv->dialog, "notify",
 691                     G_CALLBACK (dialog_notify_cb), object);
 692   g_object_add_weak_pointer (G_OBJECT (priv->dialog),
 693                              (gpointer) (&priv->dialog));
 694
 695   priv->fs =
 696     g_object_ref (_gtk_file_chooser_get_file_system (GTK_FILE_CHOOSER (priv->dialog)));
 697
 698   model_add_special (button);
 699
 700   list = _gtk_file_system_list_volumes (priv->fs);
 701   model_add_volumes (button, list);
 702   g_slist_free (list);
 703
 704   list = _gtk_file_system_list_bookmarks (priv->fs);
 705   model_add_bookmarks (button, list);
 706   g_slist_foreach (list, (GFunc) g_object_unref, NULL);
 707   g_slist_free (list);
 708
 709   model_add_other (button);
 710
 711   priv->filter_model = gtk_tree_model_filter_new (priv->model, NULL);
 712   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter_model),
 713                                           filter_model_visible_func,
 714                                           object, NULL);
 715
 716   gtk_combo_box_set_model (GTK_COMBO_BOX (priv->combo_box), priv->filter_model);
 717   gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (priv->combo_box),
 718                                         combo_box_row_separator_func,
 719                                         NULL, NULL);
 720
 721   /* set up the action for a user-provided dialog, this also updates
 722    * the label, image and combobox
 723    */
 724   g_object_set (object,
 725                 "action", gtk_file_chooser_get_action (GTK_FILE_CHOOSER (priv->dialog)),
 726                 NULL);
 727
 728   priv->fs_volumes_changed_id =
 729     g_signal_connect (priv->fs, "volumes-changed",
 730                       G_CALLBACK (fs_volumes_changed_cb), object);
 731   priv->fs_bookmarks_changed_id =
 732     g_signal_connect (priv->fs, "bookmarks-changed",
 733                       G_CALLBACK (fs_bookmarks_changed_cb), object);
 734
 735   return object;
 736 }
 737
 738 static void
 739 gtk_file_chooser_button_set_property (GObject      *object,
 740                                       guint         param_id,
 741                                       const GValue *value,
 742                                       GParamSpec   *pspec)
 743 {
 744   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (object);
 745   GtkFileChooserButtonPrivate *priv = button->priv;
 746
 747   switch (param_id)
 748     {
 749     case PROP_DIALOG:
 750       /* Construct-only */
 751       priv->dialog = g_value_get_object (value);
 752       break;
 753     case PROP_FOCUS_ON_CLICK:
 754       gtk_file_chooser_button_set_focus_on_click (button, g_value_get_boolean (value));
 755       break;
 756     case PROP_WIDTH_CHARS:
 757       gtk_file_chooser_button_set_width_chars (GTK_FILE_CHOOSER_BUTTON (object),
 758                                                g_value_get_int (value));
 759       break;
 760     case GTK_FILE_CHOOSER_PROP_ACTION:
 761       switch (g_value_get_enum (value))
 762         {
 763         case GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER:
 764         case GTK_FILE_CHOOSER_ACTION_SAVE:
 765           {
 766             GEnumClass *eclass;
 767             GEnumValue *eval;
 768
 769             eclass = g_type_class_peek (GTK_TYPE_FILE_CHOOSER_ACTION);
 770             eval = g_enum_get_value (eclass, g_value_get_enum (value));
 771             g_warning ("%s: Choosers of type `%s' do not support `%s'.",
 772                        G_STRFUNC, G_OBJECT_TYPE_NAME (object), eval->value_name);
 773
 774             g_value_set_enum ((GValue *) value, GTK_FILE_CHOOSER_ACTION_OPEN);
 775           }
 776           break;
 777         }
 778
 779       g_object_set_property (G_OBJECT (priv->dialog), pspec->name, value);
 780       update_label_and_image (GTK_FILE_CHOOSER_BUTTON (object));
 781       update_combo_box (GTK_FILE_CHOOSER_BUTTON (object));
 782
 783       switch (g_value_get_enum (value))
 784         {
 785         case GTK_FILE_CHOOSER_ACTION_OPEN:
 786           gtk_widget_hide (priv->combo_box);
 787           gtk_widget_show (priv->button);
 788           break;
 789         case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
 790           gtk_widget_hide (priv->button);
 791           gtk_widget_show (priv->combo_box);
 792           break;
 793         default:
 794           g_assert_not_reached ();
 795           break;
 796         }
 797       break;
 798
 799     case PROP_TITLE:
 800     case GTK_FILE_CHOOSER_PROP_FILTER:
 801     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET:
 802     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE:
 803     case GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL:
 804     case GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET:
 805     case GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN:
 806     case GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION:
 807     case GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS:
 808       g_object_set_property (G_OBJECT (priv->dialog), pspec->name, value);
 809       break;
 810
 811     case GTK_FILE_CHOOSER_PROP_LOCAL_ONLY:
 812       g_object_set_property (G_OBJECT (priv->dialog), pspec->name, value);
 813       fs_volumes_changed_cb (priv->fs, button);
 814       fs_bookmarks_changed_cb (priv->fs, button);
 815       break;
 816
 817     case GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE:
 818       g_warning ("%s: Choosers of type `%s` do not support selecting multiple files.",
 819                  G_STRFUNC, G_OBJECT_TYPE_NAME (object));
 820       break;
 821     default:
 822       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 823       break;
 824     }
 825 }
 826
 827 static void
 828 gtk_file_chooser_button_get_property (GObject    *object,
 829                                       guint       param_id,
 830                                       GValue     *value,
 831                                       GParamSpec *pspec)
 832 {
 833   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (object);
 834   GtkFileChooserButtonPrivate *priv = button->priv;
 835
 836   switch (param_id)
 837     {
 838     case PROP_WIDTH_CHARS:
 839       g_value_set_int (value,
 840                        gtk_label_get_width_chars (GTK_LABEL (priv->label)));
 841       break;
 842     case PROP_FOCUS_ON_CLICK:
 843       g_value_set_boolean (value,
 844                            gtk_file_chooser_button_get_focus_on_click (button));
 845       break;
 846
 847     case PROP_TITLE:
 848     case GTK_FILE_CHOOSER_PROP_ACTION:
 849     case GTK_FILE_CHOOSER_PROP_FILTER:
 850     case GTK_FILE_CHOOSER_PROP_LOCAL_ONLY:
 851     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET:
 852     case GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE:
 853     case GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL:
 854     case GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET:
 855     case GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE:
 856     case GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN:
 857     case GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION:
 858     case GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS:
 859       g_object_get_property (G_OBJECT (priv->dialog), pspec->name, value);
 860       break;
 861
 862     default:
 863       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 864       break;
 865     }
 866 }
 867
 868 static void
 869 gtk_file_chooser_button_finalize (GObject *object)
 870 {
 871   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (object);
 872   GtkFileChooserButtonPrivate *priv = button->priv;
 873
 874   if (priv->old_file)
 875     g_object_unref (priv->old_file);
 876
 877   G_OBJECT_CLASS (gtk_file_chooser_button_parent_class)->finalize (object);
 878 }
 879
 880 /* ********************* *
 881  *  GtkWidget Functions  *
 882  * ********************* */
 883
 884 static void
 885 gtk_file_chooser_button_destroy (GtkWidget *widget)
 886 {
 887   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (widget);
 888   GtkFileChooserButtonPrivate *priv = button->priv;
 889   GtkTreeIter iter;
 890   GSList *l;
 891
 892   if (priv->dialog != NULL)
 893     {
 894       gtk_widget_destroy (priv->dialog);
 895       priv->dialog = NULL;
 896     }
 897
 898   if (priv->model && gtk_tree_model_get_iter_first (priv->model, &iter)) do
 899     {
 900       model_free_row_data (button, &iter);
 901     }
 902   while (gtk_tree_model_iter_next (priv->model, &iter));
 903
 904   if (priv->dnd_select_folder_cancellable)
 905     {
 906       g_cancellable_cancel (priv->dnd_select_folder_cancellable);
 907       priv->dnd_select_folder_cancellable = NULL;
 908     }
 909
 910   if (priv->update_button_cancellable)
 911     {
 912       g_cancellable_cancel (priv->update_button_cancellable);
 913       priv->update_button_cancellable = NULL;
 914     }
 915
 916   if (priv->change_icon_theme_cancellables)
 917     {
 918       for (l = priv->change_icon_theme_cancellables; l; l = l->next)
 919         {
 920           GCancellable *cancellable = G_CANCELLABLE (l->data);
 921           g_cancellable_cancel (cancellable);
 922         }
 923       g_slist_free (priv->change_icon_theme_cancellables);
 924       priv->change_icon_theme_cancellables = NULL;
 925     }
 926
 927   if (priv->model)
 928     {
 929       g_object_unref (priv->model);
 930       priv->model = NULL;
 931     }
 932
 933   if (priv->filter_model)
 934     {
 935       g_object_unref (priv->filter_model);
 936       priv->filter_model = NULL;
 937     }
 938
 939   if (priv->fs)
 940     {
 941       g_signal_handler_disconnect (priv->fs, priv->fs_volumes_changed_id);
 942       g_signal_handler_disconnect (priv->fs, priv->fs_bookmarks_changed_id);
 943       g_object_unref (priv->fs);
 944       priv->fs = NULL;
 945     }
 946
 947   GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->destroy (widget);
 948 }
 949
 950 struct DndSelectFolderData
 951 {
 952   GtkFileSystem *file_system;
 953   GtkFileChooserButton *button;
 954   GtkFileChooserAction action;
 955   GFile *file;
 956   gchar **uris;
 957   guint i;
 958   gboolean selected;
 959 };
 960
 961 static void
 962 dnd_select_folder_get_info_cb (GCancellable *cancellable,
 963                                GFileInfo    *info,
 964                                const GError *error,
 965                                gpointer      user_data)
 966 {
 967   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
 968   struct DndSelectFolderData *data = user_data;
 969
 970   if (cancellable != data->button->priv->dnd_select_folder_cancellable)
 971     {
 972       g_object_unref (data->button);
 973       g_object_unref (data->file);
 974       g_strfreev (data->uris);
 975       g_free (data);
 976
 977       g_object_unref (cancellable);
 978       return;
 979     }
 980
 981   data->button->priv->dnd_select_folder_cancellable = NULL;
 982
 983   if (!cancelled && !error && info != NULL)
 984     {
 985       gboolean is_folder;
 986
 987       is_folder = _gtk_file_info_consider_as_directory (info);
 988
 989       data->selected =
 990         (((data->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER && is_folder) ||
 991           (data->action == GTK_FILE_CHOOSER_ACTION_OPEN && !is_folder)) &&
 992          gtk_file_chooser_select_file (GTK_FILE_CHOOSER (data->button->priv->dialog),
 993                                        data->file, NULL));
 994     }
 995   else
 996     data->selected = FALSE;
 997
 998   if (data->selected || data->uris[++data->i] == NULL)
 999     {
1000       g_signal_emit (data->button, file_chooser_button_signals[FILE_SET], 0);
1001
1002       g_object_unref (data->button);
1003       g_object_unref (data->file);
1004       g_strfreev (data->uris);
1005       g_free (data);
1006
1007       g_object_unref (cancellable);
1008       return;
1009     }
1010
1011   if (data->file)
1012     g_object_unref (data->file);
1013
1014   data->file = g_file_new_for_uri (data->uris[data->i]);
1015
1016   data->button->priv->dnd_select_folder_cancellable =
1017     _gtk_file_system_get_info (data->file_system, data->file,
1018                                "standard::type",
1019                                dnd_select_folder_get_info_cb, user_data);
1020
1021   g_object_unref (cancellable);
1022 }
1023
1024 static void
1025 gtk_file_chooser_button_drag_data_received (GtkWidget        *widget,
1026                                             GdkDragContext   *context,
1027                                             gint              x,
1028                                             gint              y,
1029                                             GtkSelectionData *data,
1030                                             guint             type,
1031                                             guint             drag_time)
1032 {
1033   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (widget);
1034   GtkFileChooserButtonPrivate *priv = button->priv;
1035   GFile *file;
1036   gchar *text;
1037
1038   if (GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->drag_data_received != NULL)
1039     GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->drag_data_received (widget,
1040                                                                                  context,
1041                                                                                  x, y,
1042                                                                                  data, type,
1043                                                                                  drag_time);
1044
1045   if (widget == NULL || context == NULL || data == NULL || data->length < 0)
1046     return;
1047
1048   switch (type)
1049     {
1050     case TEXT_URI_LIST:
1051       {
1052         gchar **uris;
1053         struct DndSelectFolderData *info;
1054
1055         uris = gtk_selection_data_get_uris (data);
1056
1057         if (uris == NULL)
1058           break;
1059
1060         info = g_new0 (struct DndSelectFolderData, 1);
1061         info->button = g_object_ref (button);
1062         info->i = 0;
1063         info->uris = uris;
1064         info->selected = FALSE;
1065         info->file_system = priv->fs;
1066         g_object_get (priv->dialog, "action", &info->action, NULL);
1067
1068         info->file = g_file_new_for_uri (info->uris[info->i]);
1069
1070         if (priv->dnd_select_folder_cancellable)
1071           g_cancellable_cancel (priv->dnd_select_folder_cancellable);
1072
1073         priv->dnd_select_folder_cancellable =
1074           _gtk_file_system_get_info (priv->fs, info->file,
1075                                      "standard::type",
1076                                      dnd_select_folder_get_info_cb, info);
1077       }
1078       break;
1079
1080     case TEXT_PLAIN:
1081       text = (char*) gtk_selection_data_get_text (data);
1082       file = g_file_new_for_uri (text);
1083       gtk_file_chooser_select_file (GTK_FILE_CHOOSER (priv->dialog), file,
1084                                     NULL);
1085       g_object_unref (file);
1086       g_free (text);
1087       g_signal_emit (button, file_chooser_button_signals[FILE_SET], 0);
1088       break;
1089
1090     default:
1091       break;
1092     }
1093
1094   gtk_drag_finish (context, TRUE, FALSE, drag_time);
1095 }
1096
1097 static void
1098 gtk_file_chooser_button_show_all (GtkWidget *widget)
1099 {
1100   gtk_widget_show (widget);
1101 }
1102
1103 static void
1104 gtk_file_chooser_button_hide_all (GtkWidget *widget)
1105 {
1106   gtk_widget_hide (widget);
1107 }
1108
1109 static void
1110 gtk_file_chooser_button_show (GtkWidget *widget)
1111 {
1112   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (widget);
1113   GtkFileChooserButtonPrivate *priv = button->priv;
1114
1115   if (GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->show)
1116     GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->show (widget);
1117
1118   if (priv->active)
1119     open_dialog (GTK_FILE_CHOOSER_BUTTON (widget));
1120 }
1121
1122 static void
1123 gtk_file_chooser_button_hide (GtkWidget *widget)
1124 {
1125   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (widget);
1126   GtkFileChooserButtonPrivate *priv = button->priv;
1127
1128   gtk_widget_hide (priv->dialog);
1129
1130   if (GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->hide)
1131     GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->hide (widget);
1132 }
1133
1134 static void
1135 gtk_file_chooser_button_map (GtkWidget *widget)
1136 {
1137   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (widget);
1138   GtkFileChooserButtonPrivate *priv = button->priv;
1139
1140   if (!priv->folder_has_been_set)
1141     {
1142       char *current_working_dir;
1143
1144       current_working_dir = g_get_current_dir ();
1145       gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (widget), current_working_dir);
1146       g_free (current_working_dir);
1147
1148       priv->folder_has_been_set = TRUE;
1149     }
1150
1151   GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->map (widget);
1152 }
1153
1154 static gboolean
1155 gtk_file_chooser_button_mnemonic_activate (GtkWidget *widget,
1156                                            gboolean   group_cycling)
1157 {
1158   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (widget);
1159   GtkFileChooserButtonPrivate *priv = button->priv;
1160
1161   switch (gtk_file_chooser_get_action (GTK_FILE_CHOOSER (priv->dialog)))
1162     {
1163     case GTK_FILE_CHOOSER_ACTION_OPEN:
1164       gtk_widget_grab_focus (priv->button);
1165       break;
1166     case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
1167       return gtk_widget_mnemonic_activate (priv->combo_box, group_cycling);
1168       break;
1169     default:
1170       g_assert_not_reached ();
1171       break;
1172     }
1173
1174   return TRUE;
1175 }
1176
1177 /* Changes the icons wherever it is needed */
1178 struct ChangeIconThemeData
1179 {
1180   GtkFileChooserButton *button;
1181   GtkTreeRowReference *row_ref;
1182 };
1183
1184 static void
1185 change_icon_theme_get_info_cb (GCancellable *cancellable,
1186                                GFileInfo    *info,
1187                                const GError *error,
1188                                gpointer      user_data)
1189 {
1190   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
1191   GdkPixbuf *pixbuf;
1192   struct ChangeIconThemeData *data = user_data;
1193
1194   if (!g_slist_find (data->button->priv->change_icon_theme_cancellables, cancellable))
1195     goto out;
1196
1197   data->button->priv->change_icon_theme_cancellables =
1198     g_slist_remove (data->button->priv->change_icon_theme_cancellables, cancellable);
1199
1200   if (cancelled || error)
1201     goto out;
1202
1203   pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (data->button), data->button->priv->icon_size);
1204
1205   if (pixbuf)
1206     {
1207       gint width = 0;
1208       GtkTreeIter iter;
1209       GtkTreePath *path;
1210
1211       width = MAX (width, gdk_pixbuf_get_width (pixbuf));
1212
1213       path = gtk_tree_row_reference_get_path (data->row_ref);
1214       if (path)
1215         {
1216           gtk_tree_model_get_iter (data->button->priv->model, &iter, path);
1217           gtk_tree_path_free (path);
1218
1219           gtk_list_store_set (GTK_LIST_STORE (data->button->priv->model), &iter,
1220                               ICON_COLUMN, pixbuf,
1221                               -1);
1222
1223           g_object_set (data->button->priv->icon_cell,
1224                         "width", width,
1225                         NULL);
1226         }
1227       g_object_unref (pixbuf);
1228     }
1229
1230 out:
1231   g_object_unref (data->button);
1232   gtk_tree_row_reference_free (data->row_ref);
1233   g_free (data);
1234
1235   g_object_unref (cancellable);
1236 }
1237
1238 static void
1239 change_icon_theme (GtkFileChooserButton *button)
1240 {
1241   GtkFileChooserButtonPrivate *priv = button->priv;
1242   GtkSettings *settings;
1243   GtkIconTheme *theme;
1244   GtkTreeIter iter;
1245   GSList *l;
1246   gint width = 0, height = 0;
1247
1248   for (l = button->priv->change_icon_theme_cancellables; l; l = l->next)
1249     {
1250       GCancellable *cancellable = G_CANCELLABLE (l->data);
1251       g_cancellable_cancel (cancellable);
1252     }
1253   g_slist_free (button->priv->change_icon_theme_cancellables);
1254   button->priv->change_icon_theme_cancellables = NULL;
1255
1256   settings = gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (button)));
1257
1258   if (gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
1259                                          &width, &height))
1260     priv->icon_size = MAX (width, height);
1261   else
1262     priv->icon_size = FALLBACK_ICON_SIZE;
1263
1264   update_label_and_image (button);
1265
1266   gtk_tree_model_get_iter_first (priv->model, &iter);
1267
1268   theme = get_icon_theme (GTK_WIDGET (button));
1269
1270   do
1271     {
1272       GdkPixbuf *pixbuf;
1273       gchar type;
1274       gpointer data;
1275
1276       type = ROW_TYPE_INVALID;
1277       gtk_tree_model_get (priv->model, &iter,
1278                           TYPE_COLUMN, &type,
1279                           DATA_COLUMN, &data,
1280                           -1);
1281
1282       switch (type)
1283         {
1284         case ROW_TYPE_SPECIAL:
1285         case ROW_TYPE_SHORTCUT:
1286         case ROW_TYPE_BOOKMARK:
1287         case ROW_TYPE_CURRENT_FOLDER:
1288           if (data)
1289             {
1290               if (g_file_is_native (G_FILE (data)))
1291                 {
1292                   GtkTreePath *path;
1293                   GCancellable *cancellable;
1294                   struct ChangeIconThemeData *info;
1295
1296                   info = g_new0 (struct ChangeIconThemeData, 1);
1297                   info->button = g_object_ref (button);
1298                   path = gtk_tree_model_get_path (priv->model, &iter);
1299                   info->row_ref = gtk_tree_row_reference_new (priv->model, path);
1300                   gtk_tree_path_free (path);
1301
1302                   cancellable =
1303                     _gtk_file_system_get_info (priv->fs, data,
1304                                                "standard::icon",
1305                                                change_icon_theme_get_info_cb,
1306                                                info);
1307                   button->priv->change_icon_theme_cancellables =
1308                     g_slist_append (button->priv->change_icon_theme_cancellables, cancellable);
1309                   pixbuf = NULL;
1310                 }
1311               else
1312                 /* Don't call get_info for remote paths to avoid latency and
1313                  * auth dialogs.
1314                  * If we switch to a better bookmarks file format (XBEL), we
1315                  * should use mime info to get a better icon.
1316                  */
1317                 pixbuf = gtk_icon_theme_load_icon (theme, "folder-remote",
1318                                                    priv->icon_size, 0, NULL);
1319             }
1320           else
1321             pixbuf = gtk_icon_theme_load_icon (theme, FALLBACK_ICON_NAME,
1322                                                priv->icon_size, 0, NULL);
1323           break;
1324         case ROW_TYPE_VOLUME:
1325           if (data)
1326             pixbuf = _gtk_file_system_volume_render_icon (data,
1327                                                           GTK_WIDGET (button),
1328                                                           priv->icon_size,
1329                                                           NULL);
1330           else
1331             pixbuf = gtk_icon_theme_load_icon (theme, FALLBACK_ICON_NAME,
1332                                                priv->icon_size, 0, NULL);
1333           break;
1334         default:
1335           continue;
1336           break;
1337         }
1338
1339       if (pixbuf)
1340         width = MAX (width, gdk_pixbuf_get_width (pixbuf));
1341
1342       gtk_list_store_set (GTK_LIST_STORE (priv->model), &iter,
1343                           ICON_COLUMN, pixbuf,
1344                           -1);
1345
1346       if (pixbuf)
1347         g_object_unref (pixbuf);
1348     }
1349   while (gtk_tree_model_iter_next (priv->model, &iter));
1350
1351   g_object_set (button->priv->icon_cell,
1352                 "width", width,
1353                 NULL);
1354 }
1355
1356 static void
1357 gtk_file_chooser_button_style_set (GtkWidget *widget,
1358                                    GtkStyle  *old_style)
1359 {
1360   GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->style_set (widget,
1361                                                                       old_style);
1362
1363   if (gtk_widget_has_screen (widget))
1364     change_icon_theme (GTK_FILE_CHOOSER_BUTTON (widget));
1365 }
1366
1367 static void
1368 gtk_file_chooser_button_screen_changed (GtkWidget *widget,
1369                                         GdkScreen *old_screen)
1370 {
1371   if (GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->screen_changed)
1372     GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->screen_changed (widget,
1373                                                                              old_screen);
1374
1375   change_icon_theme (GTK_FILE_CHOOSER_BUTTON (widget));
1376 }
1377
1378
1379 /* ******************* *
1380  *  Utility Functions  *
1381  * ******************* */
1382
1383 /* General */
1384 static GtkIconTheme *
1385 get_icon_theme (GtkWidget *widget)
1386 {
1387   if (gtk_widget_has_screen (widget))
1388     return gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
1389
1390   return gtk_icon_theme_get_default ();
1391 }
1392
1393
1394 struct SetDisplayNameData
1395 {
1396   GtkFileChooserButton *button;
1397   char *label;
1398   GtkTreeRowReference *row_ref;
1399 };
1400
1401 static void
1402 set_info_get_info_cb (GCancellable *cancellable,
1403                       GFileInfo    *info,
1404                       const GError *error,
1405                       gpointer      callback_data)
1406 {
1407   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
1408   GdkPixbuf *pixbuf;
1409   GtkTreePath *path;
1410   GtkTreeIter iter;
1411   GCancellable *model_cancellable;
1412   struct SetDisplayNameData *data = callback_data;
1413   gboolean is_folder;
1414
1415   if (!data->button->priv->model)
1416     /* button got destroyed */
1417     goto out;
1418
1419   path = gtk_tree_row_reference_get_path (data->row_ref);
1420   if (!path)
1421     /* Cancellable doesn't exist anymore in the model */
1422     goto out;
1423
1424   gtk_tree_model_get_iter (data->button->priv->model, &iter, path);
1425   gtk_tree_path_free (path);
1426
1427   /* Validate the cancellable */
1428   gtk_tree_model_get (data->button->priv->model, &iter,
1429                       CANCELLABLE_COLUMN, &model_cancellable,
1430                       -1);
1431   if (cancellable != model_cancellable)
1432     goto out;
1433
1434   gtk_list_store_set (GTK_LIST_STORE (data->button->priv->model), &iter,
1435                       CANCELLABLE_COLUMN, NULL,
1436                       -1);
1437
1438   if (cancelled || error)
1439     /* There was an error, leave the fallback name in there */
1440     goto out;
1441
1442   pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (data->button), data->button->priv->icon_size);
1443
1444   if (!data->label)
1445     data->label = g_strdup (g_file_info_get_display_name (info));
1446
1447   is_folder = _gtk_file_info_consider_as_directory (info);
1448
1449   gtk_list_store_set (GTK_LIST_STORE (data->button->priv->model), &iter,
1450                       ICON_COLUMN, pixbuf,
1451                       DISPLAY_NAME_COLUMN, data->label,
1452                       IS_FOLDER_COLUMN, is_folder,
1453                       -1);
1454
1455   if (pixbuf)
1456     g_object_unref (pixbuf);
1457
1458 out:
1459   g_object_unref (data->button);
1460   g_free (data->label);
1461   gtk_tree_row_reference_free (data->row_ref);
1462   g_free (data);
1463
1464   g_object_unref (cancellable);
1465 }
1466
1467 static void
1468 set_info_for_file_at_iter (GtkFileChooserButton *button,
1469                            GFile                *file,
1470                            GtkTreeIter          *iter)
1471 {
1472   struct SetDisplayNameData *data;
1473   GtkTreePath *tree_path;
1474   GCancellable *cancellable;
1475
1476   data = g_new0 (struct SetDisplayNameData, 1);
1477   data->button = g_object_ref (button);
1478   data->label = _gtk_file_system_get_bookmark_label (button->priv->fs, file);
1479
1480   tree_path = gtk_tree_model_get_path (button->priv->model, iter);
1481   data->row_ref = gtk_tree_row_reference_new (button->priv->model, tree_path);
1482   gtk_tree_path_free (tree_path);
1483
1484   cancellable = _gtk_file_system_get_info (button->priv->fs, file,
1485                                            "standard::type,standard::icon,standard::display-name",
1486                                            set_info_get_info_cb, data);
1487
1488   gtk_list_store_set (GTK_LIST_STORE (button->priv->model), iter,
1489                       CANCELLABLE_COLUMN, cancellable,
1490                       -1);
1491 }
1492
1493 /* Shortcuts Model */
1494 static gint
1495 model_get_type_position (GtkFileChooserButton *button,
1496                          RowType               row_type)
1497 {
1498   gint retval = 0;
1499
1500   if (row_type == ROW_TYPE_SPECIAL)
1501     return retval;
1502
1503   retval += button->priv->n_special;
1504
1505   if (row_type == ROW_TYPE_VOLUME)
1506     return retval;
1507
1508   retval += button->priv->n_volumes;
1509
1510   if (row_type == ROW_TYPE_SHORTCUT)
1511     return retval;
1512
1513   retval += button->priv->n_shortcuts;
1514
1515   if (row_type == ROW_TYPE_BOOKMARK_SEPARATOR)
1516     return retval;
1517
1518   retval += button->priv->has_bookmark_separator;
1519
1520   if (row_type == ROW_TYPE_BOOKMARK)
1521     return retval;
1522
1523   retval += button->priv->n_bookmarks;
1524
1525   if (row_type == ROW_TYPE_CURRENT_FOLDER_SEPARATOR)
1526     return retval;
1527
1528   retval += button->priv->has_current_folder_separator;
1529
1530   if (row_type == ROW_TYPE_CURRENT_FOLDER)
1531     return retval;
1532
1533   retval += button->priv->has_current_folder;
1534
1535   if (row_type == ROW_TYPE_OTHER_SEPARATOR)
1536     return retval;
1537
1538   retval += button->priv->has_other_separator;
1539
1540   if (row_type == ROW_TYPE_OTHER)
1541     return retval;
1542
1543   g_assert_not_reached ();
1544   return -1;
1545 }
1546
1547 static void
1548 model_free_row_data (GtkFileChooserButton *button,
1549                      GtkTreeIter          *iter)
1550 {
1551   gchar type;
1552   gpointer data;
1553   GCancellable *cancellable;
1554
1555   gtk_tree_model_get (button->priv->model, iter,
1556                       TYPE_COLUMN, &type,
1557                       DATA_COLUMN, &data,
1558                       CANCELLABLE_COLUMN, &cancellable,
1559                       -1);
1560
1561   if (cancellable)
1562     g_cancellable_cancel (cancellable);
1563
1564   switch (type)
1565     {
1566     case ROW_TYPE_SPECIAL:
1567     case ROW_TYPE_SHORTCUT:
1568     case ROW_TYPE_BOOKMARK:
1569     case ROW_TYPE_CURRENT_FOLDER:
1570       g_object_unref (data);
1571       break;
1572     case ROW_TYPE_VOLUME:
1573       _gtk_file_system_volume_unref (data);
1574       break;
1575     default:
1576       break;
1577     }
1578 }
1579
1580 static void
1581 model_add_special_get_info_cb (GCancellable *cancellable,
1582                                GFileInfo    *info,
1583                                const GError *error,
1584                                gpointer      user_data)
1585 {
1586   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
1587   GtkTreeIter iter;
1588   GtkTreePath *path;
1589   GdkPixbuf *pixbuf;
1590   GCancellable *model_cancellable;
1591   struct ChangeIconThemeData *data = user_data;
1592   gchar *name;
1593
1594   if (!data->button->priv->model)
1595     /* button got destroyed */
1596     goto out;
1597
1598   path = gtk_tree_row_reference_get_path (data->row_ref);
1599   if (!path)
1600     /* Cancellable doesn't exist anymore in the model */
1601     goto out;
1602
1603   gtk_tree_model_get_iter (data->button->priv->model, &iter, path);
1604   gtk_tree_path_free (path);
1605
1606   gtk_tree_model_get (data->button->priv->model, &iter,
1607                       CANCELLABLE_COLUMN, &model_cancellable,
1608                       -1);
1609   if (cancellable != model_cancellable)
1610     goto out;
1611
1612   gtk_list_store_set (GTK_LIST_STORE (data->button->priv->model), &iter,
1613                       CANCELLABLE_COLUMN, NULL,
1614                       -1);
1615
1616   if (cancelled || error)
1617     goto out;
1618
1619   pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (data->button), data->button->priv->icon_size);
1620
1621   if (pixbuf)
1622     {
1623       gtk_list_store_set (GTK_LIST_STORE (data->button->priv->model), &iter,
1624                           ICON_COLUMN, pixbuf,
1625                           -1);
1626       g_object_unref (pixbuf);
1627     }
1628
1629   gtk_tree_model_get (data->button->priv->model, &iter,
1630                       DISPLAY_NAME_COLUMN, &name,
1631                       -1);
1632   if (!name)
1633     gtk_list_store_set (GTK_LIST_STORE (data->button->priv->model), &iter,
1634                         DISPLAY_NAME_COLUMN, g_file_info_get_display_name (info),
1635                         -1);
1636   g_free (name);
1637
1638 out:
1639   g_object_unref (data->button);
1640   gtk_tree_row_reference_free (data->row_ref);
1641   g_free (data);
1642
1643   g_object_unref (cancellable);
1644 }
1645
1646 static inline void
1647 model_add_special (GtkFileChooserButton *button)
1648 {
1649   const gchar *homedir;
1650   const gchar *desktopdir;
1651   GtkListStore *store;
1652   GtkTreeIter iter;
1653   GFile *file;
1654   gint pos;
1655
1656   store = GTK_LIST_STORE (button->priv->model);
1657   pos = model_get_type_position (button, ROW_TYPE_SPECIAL);
1658
1659   homedir = g_get_home_dir ();
1660
1661   if (homedir)
1662     {
1663       GtkTreePath *tree_path;
1664       GCancellable *cancellable;
1665       struct ChangeIconThemeData *info;
1666
1667       file = g_file_new_for_path (homedir);
1668       gtk_list_store_insert (store, &iter, pos);
1669       pos++;
1670
1671       info = g_new0 (struct ChangeIconThemeData, 1);
1672       info->button = g_object_ref (button);
1673       tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
1674       info->row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (store),
1675                                                   tree_path);
1676       gtk_tree_path_free (tree_path);
1677
1678       cancellable = _gtk_file_system_get_info (button->priv->fs, file,
1679                                                "standard::icon,standard::display-name",
1680                                                model_add_special_get_info_cb, info);
1681
1682       gtk_list_store_set (store, &iter,
1683                           ICON_COLUMN, NULL,
1684                           DISPLAY_NAME_COLUMN, NULL,
1685                           TYPE_COLUMN, ROW_TYPE_SPECIAL,
1686                           DATA_COLUMN, file,
1687                           IS_FOLDER_COLUMN, TRUE,
1688                           CANCELLABLE_COLUMN, cancellable,
1689                           -1);
1690
1691       button->priv->n_special++;
1692     }
1693
1694   desktopdir = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
1695
1696   if (desktopdir)
1697     {
1698       GtkTreePath *tree_path;
1699       GCancellable *cancellable;
1700       struct ChangeIconThemeData *info;
1701
1702       file = g_file_new_for_path (desktopdir);
1703       gtk_list_store_insert (store, &iter, pos);
1704       pos++;
1705
1706       info = g_new0 (struct ChangeIconThemeData, 1);
1707       info->button = g_object_ref (button);
1708       tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
1709       info->row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (store),
1710                                                   tree_path);
1711       gtk_tree_path_free (tree_path);
1712
1713       cancellable = _gtk_file_system_get_info (button->priv->fs, file,
1714                                                "standard::icon,standard::display-name",
1715                                                model_add_special_get_info_cb, info);
1716
1717       gtk_list_store_set (store, &iter,
1718                           TYPE_COLUMN, ROW_TYPE_SPECIAL,
1719                           ICON_COLUMN, NULL,
1720                           DISPLAY_NAME_COLUMN, _(DESKTOP_DISPLAY_NAME),
1721                           DATA_COLUMN, file,
1722                           IS_FOLDER_COLUMN, TRUE,
1723                           CANCELLABLE_COLUMN, cancellable,
1724                           -1);
1725
1726       button->priv->n_special++;
1727     }
1728 }
1729
1730 static void
1731 model_add_volumes (GtkFileChooserButton *button,
1732                    GSList               *volumes)
1733 {
1734   GtkListStore *store;
1735   gint pos;
1736   gboolean local_only;
1737   GtkFileSystem *file_system;
1738   GSList *l;
1739
1740   if (!volumes)
1741     return;
1742
1743   store = GTK_LIST_STORE (button->priv->model);
1744   pos = model_get_type_position (button, ROW_TYPE_VOLUME);
1745   local_only = gtk_file_chooser_get_local_only (GTK_FILE_CHOOSER (button->priv->dialog));
1746   file_system = button->priv->fs;
1747
1748   for (l = volumes; l; l = l->next)
1749     {
1750       GtkFileSystemVolume *volume;
1751       GtkTreeIter iter;
1752       GdkPixbuf *pixbuf;
1753       gchar *display_name;
1754
1755       volume = l->data;
1756
1757       if (local_only)
1758         {
1759           if (_gtk_file_system_volume_is_mounted (volume))
1760             {
1761               GFile *base_file;
1762
1763               base_file = _gtk_file_system_volume_get_root (volume);
1764               if (base_file != NULL)
1765                 {
1766                   if (!g_file_is_native (base_file))
1767                     {
1768                       g_object_unref (base_file);
1769                       continue;
1770                     }
1771                   else
1772                     g_object_unref (base_file);
1773                 }
1774             }
1775         }
1776
1777       pixbuf = _gtk_file_system_volume_render_icon (volume,
1778                                                     GTK_WIDGET (button),
1779                                                     button->priv->icon_size,
1780                                                     NULL);
1781       display_name = _gtk_file_system_volume_get_display_name (volume);
1782
1783       gtk_list_store_insert (store, &iter, pos);
1784       gtk_list_store_set (store, &iter,
1785                           ICON_COLUMN, pixbuf,
1786                           DISPLAY_NAME_COLUMN, display_name,
1787                           TYPE_COLUMN, ROW_TYPE_VOLUME,
1788                           DATA_COLUMN, _gtk_file_system_volume_ref (volume),
1789                           IS_FOLDER_COLUMN, TRUE,
1790                           -1);
1791
1792       if (pixbuf)
1793         g_object_unref (pixbuf);
1794       g_free (display_name);
1795
1796       button->priv->n_volumes++;
1797       pos++;
1798     }
1799 }
1800
1801 extern gchar * _gtk_file_chooser_label_for_file (GFile *file);
1802
1803 static void
1804 model_add_bookmarks (GtkFileChooserButton *button,
1805                      GSList               *bookmarks)
1806 {
1807   GtkListStore *store;
1808   GtkTreeIter iter;
1809   gint pos;
1810   gboolean local_only;
1811   GSList *l;
1812
1813   if (!bookmarks)
1814     return;
1815
1816   store = GTK_LIST_STORE (button->priv->model);
1817   pos = model_get_type_position (button, ROW_TYPE_BOOKMARK);
1818   local_only = gtk_file_chooser_get_local_only (GTK_FILE_CHOOSER (button->priv->dialog));
1819
1820   for (l = bookmarks; l; l = l->next)
1821     {
1822       GFile *file;
1823
1824       file = l->data;
1825
1826       if (g_file_is_native (file))
1827         {
1828           gtk_list_store_insert (store, &iter, pos);
1829           gtk_list_store_set (store, &iter,
1830                               ICON_COLUMN, NULL,
1831                               DISPLAY_NAME_COLUMN, _(FALLBACK_DISPLAY_NAME),
1832                               TYPE_COLUMN, ROW_TYPE_BOOKMARK,
1833                               DATA_COLUMN, g_object_ref (file),
1834                               IS_FOLDER_COLUMN, FALSE,
1835                               -1);
1836           set_info_for_file_at_iter (button, file, &iter);
1837         }
1838       else
1839         {
1840           gchar *label;
1841           GtkIconTheme *icon_theme;
1842           GdkPixbuf *pixbuf;
1843
1844           if (local_only)
1845             continue;
1846
1847           /* Don't call get_info for remote paths to avoid latency and
1848            * auth dialogs.
1849            * If we switch to a better bookmarks file format (XBEL), we
1850            * should use mime info to get a better icon.
1851            */
1852           label = _gtk_file_system_get_bookmark_label (button->priv->fs, file);
1853           if (!label)
1854             label = _gtk_file_chooser_label_for_file (file);
1855
1856           icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (button)));
1857           pixbuf = gtk_icon_theme_load_icon (icon_theme, "folder-remote",
1858                                              button->priv->icon_size, 0, NULL);
1859
1860           gtk_list_store_insert (store, &iter, pos);
1861           gtk_list_store_set (store, &iter,
1862                               ICON_COLUMN, pixbuf,
1863                               DISPLAY_NAME_COLUMN, label,
1864                               TYPE_COLUMN, ROW_TYPE_BOOKMARK,
1865                               DATA_COLUMN, g_object_ref (file),
1866                               IS_FOLDER_COLUMN, TRUE,
1867                               -1);
1868
1869           g_free (label);
1870           g_object_unref (pixbuf);
1871         }
1872
1873       button->priv->n_bookmarks++;
1874       pos++;
1875     }
1876
1877   if (button->priv->n_bookmarks > 0 &&
1878       !button->priv->has_bookmark_separator)
1879     {
1880       pos = model_get_type_position (button, ROW_TYPE_BOOKMARK_SEPARATOR);
1881
1882       gtk_list_store_insert (store, &iter, pos);
1883       gtk_list_store_set (store, &iter,
1884                           ICON_COLUMN, NULL,
1885                           DISPLAY_NAME_COLUMN, NULL,
1886                           TYPE_COLUMN, ROW_TYPE_BOOKMARK_SEPARATOR,
1887                           DATA_COLUMN, NULL,
1888                           IS_FOLDER_COLUMN, FALSE,
1889                           -1);
1890       button->priv->has_bookmark_separator = TRUE;
1891     }
1892 }
1893
1894 static void
1895 model_update_current_folder (GtkFileChooserButton *button,
1896                              GFile                *file)
1897 {
1898   GtkListStore *store;
1899   GtkTreeIter iter;
1900   gint pos;
1901
1902   if (!file)
1903     return;
1904
1905   store = GTK_LIST_STORE (button->priv->model);
1906
1907   if (!button->priv->has_current_folder_separator)
1908     {
1909       pos = model_get_type_position (button, ROW_TYPE_CURRENT_FOLDER_SEPARATOR);
1910       gtk_list_store_insert (store, &iter, pos);
1911       gtk_list_store_set (store, &iter,
1912                           ICON_COLUMN, NULL,
1913                           DISPLAY_NAME_COLUMN, NULL,
1914                           TYPE_COLUMN, ROW_TYPE_CURRENT_FOLDER_SEPARATOR,
1915                           DATA_COLUMN, NULL,
1916                           IS_FOLDER_COLUMN, FALSE,
1917                           -1);
1918       button->priv->has_current_folder_separator = TRUE;
1919     }
1920
1921   pos = model_get_type_position (button, ROW_TYPE_CURRENT_FOLDER);
1922   if (!button->priv->has_current_folder)
1923     {
1924       gtk_list_store_insert (store, &iter, pos);
1925       button->priv->has_current_folder = TRUE;
1926     }
1927   else
1928     {
1929       gtk_tree_model_iter_nth_child (button->priv->model, &iter, NULL, pos);
1930       model_free_row_data (button, &iter);
1931     }
1932
1933   if (g_file_is_native (file))
1934     {
1935       gtk_list_store_set (store, &iter,
1936                           ICON_COLUMN, NULL,
1937                           DISPLAY_NAME_COLUMN, _(FALLBACK_DISPLAY_NAME),
1938                           TYPE_COLUMN, ROW_TYPE_CURRENT_FOLDER,
1939                           DATA_COLUMN, g_object_ref (file),
1940                           IS_FOLDER_COLUMN, FALSE,
1941                           -1);
1942       set_info_for_file_at_iter (button, file, &iter);
1943     }
1944   else
1945     {
1946       gchar *label;
1947       GtkIconTheme *icon_theme;
1948       GdkPixbuf *pixbuf;
1949
1950       /* Don't call get_info for remote paths to avoid latency and
1951        * auth dialogs.
1952        * If we switch to a better bookmarks file format (XBEL), we
1953        * should use mime info to get a better icon.
1954        */
1955       label = _gtk_file_system_get_bookmark_label (button->priv->fs, file);
1956       if (!label)
1957         label = _gtk_file_chooser_label_for_file (file);
1958
1959       icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (button)));
1960
1961       if (g_file_is_native (file))
1962           pixbuf = gtk_icon_theme_load_icon (icon_theme, "folder",
1963                                              button->priv->icon_size, 0, NULL);
1964       else
1965           pixbuf = gtk_icon_theme_load_icon (icon_theme, "folder-remote",
1966                                              button->priv->icon_size, 0, NULL);
1967
1968       gtk_list_store_set (store, &iter,
1969                           ICON_COLUMN, pixbuf,
1970                           DISPLAY_NAME_COLUMN, label,
1971                           TYPE_COLUMN, ROW_TYPE_CURRENT_FOLDER,
1972                           DATA_COLUMN, g_object_ref (file),
1973                           IS_FOLDER_COLUMN, TRUE,
1974                           -1);
1975
1976       g_free (label);
1977       g_object_unref (pixbuf);
1978     }
1979 }
1980
1981 static inline void
1982 model_add_other (GtkFileChooserButton *button)
1983 {
1984   GtkListStore *store;
1985   GtkTreeIter iter;
1986   gint pos;
1987
1988   store = GTK_LIST_STORE (button->priv->model);
1989   pos = model_get_type_position (button, ROW_TYPE_OTHER_SEPARATOR);
1990
1991   gtk_list_store_insert (store, &iter, pos);
1992   gtk_list_store_set (store, &iter,
1993                       ICON_COLUMN, NULL,
1994                       DISPLAY_NAME_COLUMN, NULL,
1995                       TYPE_COLUMN, ROW_TYPE_OTHER_SEPARATOR,
1996                       DATA_COLUMN, NULL,
1997                       IS_FOLDER_COLUMN, FALSE,
1998                       -1);
1999   button->priv->has_other_separator = TRUE;
2000   pos++;
2001
2002   gtk_list_store_insert (store, &iter, pos);
2003   gtk_list_store_set (store, &iter,
2004                       ICON_COLUMN, NULL,
2005                       DISPLAY_NAME_COLUMN, _("Other..."),
2006                       TYPE_COLUMN, ROW_TYPE_OTHER,
2007                       DATA_COLUMN, NULL,
2008                       IS_FOLDER_COLUMN, FALSE,
2009                       -1);
2010 }
2011
2012 static void
2013 model_remove_rows (GtkFileChooserButton *button,
2014                    gint                  pos,
2015                    gint                  n_rows)
2016 {
2017   GtkListStore *store;
2018
2019   if (!n_rows)
2020     return;
2021
2022   store = GTK_LIST_STORE (button->priv->model);
2023
2024   do
2025     {
2026       GtkTreeIter iter;
2027
2028       if (!gtk_tree_model_iter_nth_child (button->priv->model, &iter, NULL, pos))
2029         g_assert_not_reached ();
2030
2031       model_free_row_data (button, &iter);
2032       gtk_list_store_remove (store, &iter);
2033       n_rows--;
2034     }
2035   while (n_rows);
2036 }
2037
2038 /* Filter Model */
2039 static inline gboolean
2040 test_if_file_is_visible (GtkFileSystem *fs,
2041                          GFile         *file,
2042                          gboolean       local_only,
2043                          gboolean       is_folder)
2044 {
2045   if (!file)
2046     return FALSE;
2047
2048   if (local_only && !g_file_is_native (file))
2049     return FALSE;
2050
2051   if (!is_folder)
2052     return FALSE;
2053
2054   return TRUE;
2055 }
2056
2057 static gboolean
2058 filter_model_visible_func (GtkTreeModel *model,
2059                            GtkTreeIter  *iter,
2060                            gpointer      user_data)
2061 {
2062   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
2063   GtkFileChooserButtonPrivate *priv = button->priv;
2064   gchar type;
2065   gpointer data;
2066   gboolean local_only, retval, is_folder;
2067
2068   type = ROW_TYPE_INVALID;
2069   data = NULL;
2070   local_only = gtk_file_chooser_get_local_only (GTK_FILE_CHOOSER (priv->dialog));
2071
2072   gtk_tree_model_get (model, iter,
2073                       TYPE_COLUMN, &type,
2074                       DATA_COLUMN, &data,
2075                       IS_FOLDER_COLUMN, &is_folder,
2076                       -1);
2077
2078   switch (type)
2079     {
2080     case ROW_TYPE_CURRENT_FOLDER:
2081       retval = TRUE;
2082       break;
2083     case ROW_TYPE_SPECIAL:
2084     case ROW_TYPE_SHORTCUT:
2085     case ROW_TYPE_BOOKMARK:
2086       retval = test_if_file_is_visible (priv->fs, data, local_only, is_folder);
2087       break;
2088     case ROW_TYPE_VOLUME:
2089       {
2090         retval = TRUE;
2091         if (local_only)
2092           {
2093             if (_gtk_file_system_volume_is_mounted (data))
2094               {
2095                 GFile *base_file;
2096
2097                 base_file = _gtk_file_system_volume_get_root (data);
2098
2099                 if (base_file)
2100                   {
2101                     if (!g_file_is_native (base_file))
2102                       retval = FALSE;
2103                     g_object_unref (base_file);
2104                   }
2105                 else
2106                   retval = FALSE;
2107               }
2108           }
2109       }
2110       break;
2111     default:
2112       retval = TRUE;
2113       break;
2114     }
2115
2116   return retval;
2117 }
2118
2119 /* Combo Box */
2120 static void
2121 name_cell_data_func (GtkCellLayout   *layout,
2122                      GtkCellRenderer *cell,
2123                      GtkTreeModel    *model,
2124                      GtkTreeIter     *iter,
2125                      gpointer         user_data)
2126 {
2127   gchar type;
2128
2129   type = 0;
2130   gtk_tree_model_get (model, iter,
2131                       TYPE_COLUMN, &type,
2132                       -1);
2133
2134   if (type == ROW_TYPE_CURRENT_FOLDER)
2135     g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2136   else
2137     g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_NONE, NULL);
2138 }
2139
2140 static gboolean
2141 combo_box_row_separator_func (GtkTreeModel *model,
2142                               GtkTreeIter  *iter,
2143                               gpointer      user_data)
2144 {
2145   gchar type = ROW_TYPE_INVALID;
2146
2147   gtk_tree_model_get (model, iter, TYPE_COLUMN, &type, -1);
2148
2149   return (type == ROW_TYPE_BOOKMARK_SEPARATOR ||
2150           type == ROW_TYPE_CURRENT_FOLDER_SEPARATOR ||
2151           type == ROW_TYPE_OTHER_SEPARATOR);
2152 }
2153
2154 static void
2155 update_combo_box (GtkFileChooserButton *button)
2156 {
2157   GtkFileChooserButtonPrivate *priv = button->priv;
2158   GSList *files;
2159   GtkTreeIter iter;
2160   gboolean row_found;
2161
2162   gtk_tree_model_get_iter_first (priv->filter_model, &iter);
2163
2164   files = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (priv->dialog));
2165
2166   row_found = FALSE;
2167
2168   do
2169     {
2170       gchar type;
2171       gpointer data;
2172
2173       type = ROW_TYPE_INVALID;
2174       data = NULL;
2175
2176       gtk_tree_model_get (priv->filter_model, &iter,
2177                           TYPE_COLUMN, &type,
2178                           DATA_COLUMN, &data,
2179                           -1);
2180
2181       switch (type)
2182         {
2183         case ROW_TYPE_SPECIAL:
2184         case ROW_TYPE_SHORTCUT:
2185         case ROW_TYPE_BOOKMARK:
2186         case ROW_TYPE_CURRENT_FOLDER:
2187           row_found = (files &&
2188                        files->data &&
2189                        g_file_equal (data, files->data));
2190           break;
2191         case ROW_TYPE_VOLUME:
2192           {
2193             GFile *base_file;
2194
2195             base_file = _gtk_file_system_volume_get_root (data);
2196             if (base_file)
2197               {
2198                 row_found = (files &&
2199                              files->data &&
2200                              g_file_equal (base_file, files->data));
2201                 g_object_unref (base_file);
2202               }
2203           }
2204           break;
2205         default:
2206           row_found = FALSE;
2207           break;
2208         }
2209
2210       if (row_found)
2211         {
2212           g_signal_handler_block (priv->combo_box, priv->combo_box_changed_id);
2213           gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->combo_box),
2214                                          &iter);
2215           g_signal_handler_unblock (priv->combo_box,
2216                                     priv->combo_box_changed_id);
2217         }
2218     }
2219   while (!row_found && gtk_tree_model_iter_next (priv->filter_model, &iter));
2220
2221   /* If it hasn't been found already, update & select the current-folder row. */
2222   if (!row_found && files && files->data)
2223     {
2224       GtkTreeIter filter_iter;
2225       gint pos;
2226
2227       model_update_current_folder (button, files->data);
2228       gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter_model));
2229
2230       pos = model_get_type_position (button, ROW_TYPE_CURRENT_FOLDER);
2231       gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, pos);
2232
2233       gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (priv->filter_model),
2234                                                         &filter_iter, &iter);
2235
2236       g_signal_handler_block (priv->combo_box, priv->combo_box_changed_id);
2237       gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->combo_box), &filter_iter);
2238       g_signal_handler_unblock (priv->combo_box, priv->combo_box_changed_id);
2239     }
2240
2241   g_slist_foreach (files, (GFunc) g_object_unref, NULL);
2242   g_slist_free (files);
2243 }
2244
2245 /* Button */
2246 static void
2247 update_label_get_info_cb (GCancellable *cancellable,
2248                           GFileInfo    *info,
2249                           const GError *error,
2250                           gpointer      data)
2251 {
2252   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
2253   GdkPixbuf *pixbuf;
2254   GtkFileChooserButton *button = data;
2255   GtkFileChooserButtonPrivate *priv = button->priv;
2256
2257   if (cancellable != priv->update_button_cancellable)
2258     goto out;
2259
2260   priv->update_button_cancellable = NULL;
2261
2262   if (cancelled || error)
2263     goto out;
2264
2265   gtk_label_set_text (GTK_LABEL (priv->label), g_file_info_get_display_name (info));
2266
2267   pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (priv->image), priv->icon_size);
2268
2269   if (!pixbuf)
2270     pixbuf = gtk_icon_theme_load_icon (get_icon_theme (GTK_WIDGET (priv->image)),
2271                                        FALLBACK_ICON_NAME,
2272                                        priv->icon_size, 0, NULL);
2273
2274   gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), pixbuf);
2275   if (pixbuf)
2276     g_object_unref (pixbuf);
2277
2278 out:
2279   g_object_unref (button);
2280   g_object_unref (cancellable);
2281 }
2282
2283 static void
2284 update_label_and_image (GtkFileChooserButton *button)
2285 {
2286   GtkFileChooserButtonPrivate *priv = button->priv;
2287   GdkPixbuf *pixbuf;
2288   gchar *label_text;
2289   GSList *files;
2290
2291   files = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (priv->dialog));
2292   label_text = NULL;
2293   pixbuf = NULL;
2294
2295   if (priv->update_button_cancellable)
2296     {
2297       g_cancellable_cancel (priv->update_button_cancellable);
2298       priv->update_button_cancellable = NULL;
2299     }
2300
2301   if (files && files->data)
2302     {
2303       GFile *file;
2304       GtkFileSystemVolume *volume = NULL;
2305
2306       file = files->data;
2307
2308       volume = _gtk_file_system_get_volume_for_file (priv->fs, file);
2309       if (volume)
2310         {
2311           GFile *base_file;
2312
2313           base_file = _gtk_file_system_volume_get_root (volume);
2314           if (base_file && g_file_equal (base_file, file))
2315             {
2316               label_text = _gtk_file_system_volume_get_display_name (volume);
2317               pixbuf = _gtk_file_system_volume_render_icon (volume,
2318                                                             GTK_WIDGET (button),
2319                                                             priv->icon_size,
2320                                                             NULL);
2321             }
2322
2323           if (base_file)
2324             g_object_unref (base_file);
2325
2326           _gtk_file_system_volume_unref (volume);
2327
2328           if (label_text)
2329             goto out;
2330         }
2331
2332       if (g_file_is_native (file))
2333         {
2334           priv->update_button_cancellable =
2335             _gtk_file_system_get_info (priv->fs, file,
2336                                        "standard::icon,standard::display-name",
2337                                        update_label_get_info_cb,
2338                                        g_object_ref (button));
2339         }
2340       else
2341         {
2342           GdkPixbuf *pixbuf;
2343
2344           label_text = _gtk_file_system_get_bookmark_label (button->priv->fs, file);
2345
2346           pixbuf = gtk_icon_theme_load_icon (get_icon_theme (GTK_WIDGET (priv->image)),
2347                                              "text-x-generic",
2348                                              priv->icon_size, 0, NULL);
2349
2350           gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), pixbuf);
2351
2352           if (pixbuf)
2353             g_object_unref (pixbuf);
2354         }
2355     }
2356 out:
2357   g_slist_foreach (files, (GFunc) g_object_unref, NULL);
2358   g_slist_free (files);
2359
2360   if (label_text)
2361     {
2362       gtk_label_set_text (GTK_LABEL (priv->label), label_text);
2363       g_free (label_text);
2364     }
2365   else
2366     {
2367       gtk_label_set_text (GTK_LABEL (priv->label), _(FALLBACK_DISPLAY_NAME));
2368       gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), NULL);
2369     }
2370 }
2371
2372
2373 /* ************************ *
2374  *  Child Object Callbacks  *
2375  * ************************ */
2376
2377 /* File System */
2378 static void
2379 fs_volumes_changed_cb (GtkFileSystem *fs,
2380                        gpointer       user_data)
2381 {
2382   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
2383   GtkFileChooserButtonPrivate *priv = button->priv;
2384   GSList *volumes;
2385
2386   model_remove_rows (user_data,
2387                      model_get_type_position (user_data, ROW_TYPE_VOLUME),
2388                      priv->n_volumes);
2389
2390   priv->n_volumes = 0;
2391
2392   volumes = _gtk_file_system_list_volumes (fs);
2393   model_add_volumes (user_data, volumes);
2394   g_slist_free (volumes);
2395
2396   gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter_model));
2397
2398   update_label_and_image (user_data);
2399   update_combo_box (user_data);
2400 }
2401
2402 static void
2403 fs_bookmarks_changed_cb (GtkFileSystem *fs,
2404                          gpointer       user_data)
2405 {
2406   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
2407   GtkFileChooserButtonPrivate *priv = button->priv;
2408   GSList *bookmarks;
2409
2410   bookmarks = _gtk_file_system_list_bookmarks (fs);
2411   model_remove_rows (user_data,
2412                      model_get_type_position (user_data,
2413                                               ROW_TYPE_BOOKMARK_SEPARATOR),
2414                      (priv->n_bookmarks + priv->has_bookmark_separator));
2415   priv->has_bookmark_separator = FALSE;
2416   priv->n_bookmarks = 0;
2417   model_add_bookmarks (user_data, bookmarks);
2418   g_slist_foreach (bookmarks, (GFunc) g_object_unref, NULL);
2419   g_slist_free (bookmarks);
2420
2421   gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter_model));
2422
2423   update_label_and_image (user_data);
2424   update_combo_box (user_data);
2425 }
2426
2427 /* Dialog */
2428 static void
2429 open_dialog (GtkFileChooserButton *button)
2430 {
2431   GtkFileChooserButtonPrivate *priv = button->priv;
2432
2433   /* Setup the dialog parent to be chooser button's toplevel, and be modal
2434      as needed. */
2435   if (!gtk_widget_get_visible (priv->dialog))
2436     {
2437       GtkWidget *toplevel;
2438
2439       toplevel = gtk_widget_get_toplevel (GTK_WIDGET (button));
2440
2441       if (gtk_widget_is_toplevel (toplevel) && GTK_IS_WINDOW (toplevel))
2442         {
2443           if (GTK_WINDOW (toplevel) != gtk_window_get_transient_for (GTK_WINDOW (priv->dialog)))
2444             gtk_window_set_transient_for (GTK_WINDOW (priv->dialog),
2445                                           GTK_WINDOW (toplevel));
2446
2447           gtk_window_set_modal (GTK_WINDOW (priv->dialog),
2448                                 gtk_window_get_modal (GTK_WINDOW (toplevel)));
2449         }
2450     }
2451
2452   if (!priv->active)
2453     {
2454       GSList *files;
2455
2456       g_signal_handler_block (priv->dialog,
2457                               priv->dialog_folder_changed_id);
2458       g_signal_handler_block (priv->dialog,
2459                               priv->dialog_file_activated_id);
2460       g_signal_handler_block (priv->dialog,
2461                               priv->dialog_selection_changed_id);
2462       files = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (priv->dialog));
2463       if (files)
2464         {
2465           if (files->data)
2466             priv->old_file = g_object_ref (files->data);
2467
2468           g_slist_foreach (files, (GFunc) g_object_unref, NULL);
2469           g_slist_free (files);
2470         }
2471
2472       priv->active = TRUE;
2473     }
2474
2475   gtk_widget_set_sensitive (priv->combo_box, FALSE);
2476   gtk_window_present (GTK_WINDOW (priv->dialog));
2477 }
2478
2479 /* Combo Box */
2480 static void
2481 combo_box_changed_cb (GtkComboBox *combo_box,
2482                       gpointer     user_data)
2483 {
2484   GtkTreeIter iter;
2485
2486   if (gtk_combo_box_get_active_iter (combo_box, &iter))
2487     {
2488       GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
2489       GtkFileChooserButtonPrivate *priv = button->priv;
2490       gchar type;
2491       gpointer data;
2492
2493       type = ROW_TYPE_INVALID;
2494       data = NULL;
2495
2496       gtk_tree_model_get (priv->filter_model, &iter,
2497                           TYPE_COLUMN, &type,
2498                           DATA_COLUMN, &data,
2499                           -1);
2500
2501       switch (type)
2502         {
2503         case ROW_TYPE_SPECIAL:
2504         case ROW_TYPE_SHORTCUT:
2505         case ROW_TYPE_BOOKMARK:
2506         case ROW_TYPE_CURRENT_FOLDER:
2507           gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (priv->dialog));
2508           if (data)
2509             gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (priv->dialog),
2510                                                       data, NULL);
2511           break;
2512         case ROW_TYPE_VOLUME:
2513           {
2514             GFile *base_file;
2515
2516             gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (priv->dialog));
2517             base_file = _gtk_file_system_volume_get_root (data);
2518             if (base_file)
2519               {
2520                 gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (priv->dialog),
2521                                                           base_file, NULL);
2522                 g_object_unref (base_file);
2523               }
2524           }
2525           break;
2526         case ROW_TYPE_OTHER:
2527           open_dialog (user_data);
2528           break;
2529         default:
2530           break;
2531         }
2532     }
2533 }
2534
2535 /* Button */
2536 static void
2537 button_clicked_cb (GtkButton *real_button,
2538                    gpointer   user_data)
2539 {
2540   open_dialog (user_data);
2541 }
2542
2543 /* Dialog */
2544 static void
2545 dialog_current_folder_changed_cb (GtkFileChooser *dialog,
2546                                   gpointer        user_data)
2547 {
2548   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
2549   GtkFileChooserButtonPrivate *priv = button->priv;
2550
2551   priv->folder_has_been_set = TRUE;
2552
2553   g_signal_emit_by_name (button, "current-folder-changed");
2554 }
2555
2556 static void
2557 dialog_file_activated_cb (GtkFileChooser *dialog,
2558                           gpointer        user_data)
2559 {
2560   g_signal_emit_by_name (user_data, "file-activated");
2561 }
2562
2563 static void
2564 dialog_selection_changed_cb (GtkFileChooser *dialog,
2565                              gpointer        user_data)
2566 {
2567   update_label_and_image (user_data);
2568   update_combo_box (user_data);
2569   g_signal_emit_by_name (user_data, "selection-changed");
2570 }
2571
2572 static void
2573 dialog_update_preview_cb (GtkFileChooser *dialog,
2574                           gpointer        user_data)
2575 {
2576   g_signal_emit_by_name (user_data, "update-preview");
2577 }
2578
2579 static void
2580 dialog_notify_cb (GObject    *dialog,
2581                   GParamSpec *pspec,
2582                   gpointer    user_data)
2583 {
2584   gpointer iface;
2585
2586   iface = g_type_interface_peek (g_type_class_peek (G_OBJECT_TYPE (dialog)),
2587                                  GTK_TYPE_FILE_CHOOSER);
2588   if (g_object_interface_find_property (iface, pspec->name))
2589     g_object_notify (user_data, pspec->name);
2590
2591   if (g_ascii_strcasecmp (pspec->name, "local-only") == 0)
2592     {
2593       GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
2594       GtkFileChooserButtonPrivate *priv = button->priv;
2595
2596       if (priv->has_current_folder)
2597         {
2598           GtkTreeIter iter;
2599           gint pos;
2600           gpointer data;
2601
2602           pos = model_get_type_position (user_data,
2603                                          ROW_TYPE_CURRENT_FOLDER);
2604           gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, pos);
2605
2606           data = NULL;
2607           gtk_tree_model_get (priv->model, &iter, DATA_COLUMN, &data, -1);
2608
2609           /* If the path isn't local but we're in local-only mode now, remove
2610            * the custom-folder row */
2611           if (data && g_file_is_native (G_FILE (data)) &&
2612               gtk_file_chooser_get_local_only (GTK_FILE_CHOOSER (priv->dialog)))
2613             {
2614               pos--;
2615               model_remove_rows (user_data, pos, 2);
2616             }
2617         }
2618
2619       gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter_model));
2620       update_combo_box (user_data);
2621     }
2622 }
2623
2624 static gboolean
2625 dialog_delete_event_cb (GtkWidget *dialog,
2626                         GdkEvent  *event,
2627                         gpointer   user_data)
2628 {
2629   g_signal_emit_by_name (dialog, "response", GTK_RESPONSE_DELETE_EVENT);
2630
2631   return TRUE;
2632 }
2633
2634 static void
2635 dialog_response_cb (GtkDialog *dialog,
2636                     gint       response,
2637                     gpointer   user_data)
2638 {
2639   GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
2640   GtkFileChooserButtonPrivate *priv = button->priv;
2641
2642   if (response == GTK_RESPONSE_ACCEPT ||
2643       response == GTK_RESPONSE_OK)
2644     {
2645       g_signal_emit_by_name (user_data, "current-folder-changed");
2646       g_signal_emit_by_name (user_data, "selection-changed");
2647     }
2648   else if (priv->old_file)
2649     {
2650       switch (gtk_file_chooser_get_action (GTK_FILE_CHOOSER (dialog)))
2651         {
2652         case GTK_FILE_CHOOSER_ACTION_OPEN:
2653           gtk_file_chooser_select_file (GTK_FILE_CHOOSER (dialog), priv->old_file,
2654                                         NULL);
2655           break;
2656         case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
2657           gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog),
2658                                                     priv->old_file, NULL);
2659           break;
2660         default:
2661           g_assert_not_reached ();
2662           break;
2663         }
2664     }
2665   else
2666     gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog));
2667
2668   if (priv->old_file)
2669     {
2670       g_object_unref (priv->old_file);
2671       priv->old_file = NULL;
2672     }
2673
2674   update_label_and_image (user_data);
2675   update_combo_box (user_data);
2676
2677   if (priv->active)
2678     {
2679       g_signal_handler_unblock (priv->dialog,
2680                                 priv->dialog_folder_changed_id);
2681       g_signal_handler_unblock (priv->dialog,
2682                                 priv->dialog_file_activated_id);
2683       g_signal_handler_unblock (priv->dialog,
2684                                 priv->dialog_selection_changed_id);
2685       priv->active = FALSE;
2686     }
2687
2688   gtk_widget_set_sensitive (priv->combo_box, TRUE);
2689   gtk_widget_hide (priv->dialog);
2690
2691   if (response == GTK_RESPONSE_ACCEPT ||
2692       response == GTK_RESPONSE_OK)
2693     g_signal_emit (user_data, file_chooser_button_signals[FILE_SET], 0);
2694 }
2695
2696
2697 /* ************************************************************************** *
2698  *  Public API                                                                *
2699  * ************************************************************************** */
2700
2701 /**
2702  * gtk_file_chooser_button_new:
2703  * @title: the title of the browse dialog.
2704  * @action: the open mode for the widget.
2705  *
2706  * Creates a new file-selecting button widget.
2707  *
2708  * Returns: a new button widget.
2709  *
2710  * Since: 2.6
2711  **/
2712 GtkWidget *
2713 gtk_file_chooser_button_new (const gchar          *title,
2714                              GtkFileChooserAction  action)
2715 {
2716   g_return_val_if_fail (action == GTK_FILE_CHOOSER_ACTION_OPEN ||
2717                         action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, NULL);
2718
2719   return g_object_new (GTK_TYPE_FILE_CHOOSER_BUTTON,
2720                        "action", action,
2721                        "title", (title ? title : _(DEFAULT_TITLE)),
2722                        NULL);
2723 }
2724
2725 /**
2726  * gtk_file_chooser_button_new_with_dialog:
2727  * @dialog: the widget to use as dialog
2728  *
2729  * Creates a #GtkFileChooserButton widget which uses @dialog as its
2730  * file-picking window.
2731  *
2732  * Note that @dialog must be a #GtkDialog (or subclass) which
2733  * implements the #GtkFileChooser interface and must not have
2734  * %GTK_DIALOG_DESTROY_WITH_PARENT set.
2735  *
2736  * Also note that the dialog needs to have its confirmative button
2737  * added with response %GTK_RESPONSE_ACCEPT or %GTK_RESPONSE_OK in
2738  * order for the button to take over the file selected in the dialog.
2739  *
2740  * Returns: a new button widget.
2741  *
2742  * Since: 2.6
2743  **/
2744 GtkWidget *
2745 gtk_file_chooser_button_new_with_dialog (GtkWidget *dialog)
2746 {
2747   g_return_val_if_fail (GTK_IS_FILE_CHOOSER (dialog) && GTK_IS_DIALOG (dialog), NULL);
2748
2749   return g_object_new (GTK_TYPE_FILE_CHOOSER_BUTTON,
2750                        "dialog", dialog,
2751                        NULL);
2752 }
2753
2754 /**
2755  * gtk_file_chooser_button_set_title:
2756  * @button: the button widget to modify.
2757  * @title: the new browse dialog title.
2758  *
2759  * Modifies the @title of the browse dialog used by @button.
2760  *
2761  * Since: 2.6
2762  **/
2763 void
2764 gtk_file_chooser_button_set_title (GtkFileChooserButton *button,
2765                                    const gchar          *title)
2766 {
2767   g_return_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button));
2768
2769   gtk_window_set_title (GTK_WINDOW (button->priv->dialog), title);
2770   g_object_notify (G_OBJECT (button), "title");
2771 }
2772
2773 /**
2774  * gtk_file_chooser_button_get_title:
2775  * @button: the button widget to examine.
2776  *
2777  * Retrieves the title of the browse dialog used by @button. The returned value
2778  * should not be modified or freed.
2779  *
2780  * Returns: a pointer to the browse dialog's title.
2781  *
2782  * Since: 2.6
2783  **/
2784 G_CONST_RETURN gchar *
2785 gtk_file_chooser_button_get_title (GtkFileChooserButton *button)
2786 {
2787   g_return_val_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button), NULL);
2788
2789   return gtk_window_get_title (GTK_WINDOW (button->priv->dialog));
2790 }
2791
2792 /**
2793  * gtk_file_chooser_button_get_width_chars:
2794  * @button: the button widget to examine.
2795  *
2796  * Retrieves the width in characters of the @button widget's entry and/or label.
2797  *
2798  * Returns: an integer width (in characters) that the button will use to size itself.
2799  *
2800  * Since: 2.6
2801  **/
2802 gint
2803 gtk_file_chooser_button_get_width_chars (GtkFileChooserButton *button)
2804 {
2805   g_return_val_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button), -1);
2806
2807   return gtk_label_get_width_chars (GTK_LABEL (button->priv->label));
2808 }
2809
2810 /**
2811  * gtk_file_chooser_button_set_width_chars:
2812  * @button: the button widget to examine.
2813  * @n_chars: the new width, in characters.
2814  *
2815  * Sets the width (in characters) that @button will use to @n_chars.
2816  *
2817  * Since: 2.6
2818  **/
2819 void
2820 gtk_file_chooser_button_set_width_chars (GtkFileChooserButton *button,
2821                                          gint                  n_chars)
2822 {
2823   g_return_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button));
2824
2825   gtk_label_set_width_chars (GTK_LABEL (button->priv->label), n_chars);
2826   g_object_notify (G_OBJECT (button), "width-chars");
2827 }
2828
2829 /**
2830  * gtk_file_chooser_button_set_focus_on_click:
2831  * @button: a #GtkFileChooserButton
2832  * @focus_on_click: whether the button grabs focus when clicked with the mouse
2833  *
2834  * Sets whether the button will grab focus when it is clicked with the mouse.
2835  * Making mouse clicks not grab focus is useful in places like toolbars where
2836  * you don't want the keyboard focus removed from the main area of the
2837  * application.
2838  *
2839  * Since: 2.10
2840  **/
2841 void
2842 gtk_file_chooser_button_set_focus_on_click (GtkFileChooserButton *button,
2843                                             gboolean              focus_on_click)
2844 {
2845   GtkFileChooserButtonPrivate *priv;
2846
2847   g_return_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button));
2848
2849   priv = button->priv;
2850
2851   focus_on_click = focus_on_click != FALSE;
2852
2853   if (priv->focus_on_click != focus_on_click)
2854     {
2855       priv->focus_on_click = focus_on_click;
2856       gtk_button_set_focus_on_click (GTK_BUTTON (priv->button), focus_on_click);
2857       gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (priv->combo_box), focus_on_click);
2858
2859       g_object_notify (G_OBJECT (button), "focus-on-click");
2860     }
2861 }
2862
2863 /**
2864  * gtk_file_chooser_button_get_focus_on_click:
2865  * @button: a #GtkFileChooserButton
2866  *
2867  * Returns whether the button grabs focus when it is clicked with the mouse.
2868  * See gtk_file_chooser_button_set_focus_on_click().
2869  *
2870  * Return value: %TRUE if the button grabs focus when it is clicked with
2871  *               the mouse.
2872  *
2873  * Since: 2.10
2874  **/
2875 gboolean
2876 gtk_file_chooser_button_get_focus_on_click (GtkFileChooserButton *button)
2877 {
2878   g_return_val_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button), FALSE);
2879
2880   return button->priv->focus_on_click;
2881 }