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

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