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

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