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

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