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