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