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

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