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

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