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