#include "gtkexpander.h"
#include "gtkfilechooserprivate.h"
#include "gtkfilechooserdefault.h"
+#include "gtkfilechooserdialog.h"
#include "gtkfilechooserembed.h"
#include "gtkfilechooserentry.h"
#include "gtkfilechoosersettings.h"
#define MAX_LOADING_TIME 500
+#define DEFAULT_NEW_FOLDER_NAME _("Type name of new folder")
+
struct _GtkFileChooserDefaultClass
{
GtkVBoxClass parent_class;
SHORTCUT_TYPE_RECENT
} ShortcutType;
-/* Column numbers for the file list */
-enum {
- FILE_LIST_COL_NAME,
- FILE_LIST_COL_SIZE,
- FILE_LIST_COL_MTIME,
- FILE_LIST_COL_NUM_COLUMNS
-};
-
-/* Column numbers for the search model.
- * Keep this in sync with search_setup_model()
- */
+#define MODEL_ATTRIBUTES "standard::name,standard::type,standard::display-name," \
+ "standard::is-hidden,standard::is-backup,standard::size," \
+ "standard::content-type,time::modified"
enum {
- SEARCH_MODEL_COL_FILE,
- SEARCH_MODEL_COL_DISPLAY_NAME,
- SEARCH_MODEL_COL_COLLATION_KEY,
- SEARCH_MODEL_COL_MTIME,
- SEARCH_MODEL_COL_SIZE,
- SEARCH_MODEL_COL_CANCELLABLE,
- SEARCH_MODEL_COL_PIXBUF,
- SEARCH_MODEL_COL_MIME_TYPE,
- SEARCH_MODEL_COL_IS_FOLDER,
- SEARCH_MODEL_COL_NUM_COLUMNS
+ /* the first 3 must be these due to settings caching sort column */
+ MODEL_COL_NAME,
+ MODEL_COL_SIZE,
+ MODEL_COL_MTIME,
+ MODEL_COL_FILE,
+ MODEL_COL_NAME_COLLATED,
+ MODEL_COL_IS_FOLDER,
+ MODEL_COL_PIXBUF,
+ MODEL_COL_SIZE_TEXT,
+ MODEL_COL_MTIME_TEXT,
+ MODEL_COL_ELLIPSIZE,
+ MODEL_COL_NUM_COLUMNS
};
-enum {
- RECENT_MODEL_COL_FILE,
- RECENT_MODEL_COL_DISPLAY_NAME,
- RECENT_MODEL_COL_INFO,
- RECENT_MODEL_COL_IS_FOLDER,
- RECENT_MODEL_COL_CANCELLABLE,
- RECENT_MODEL_COL_NUM_COLUMNS
-};
+/* This list of types is passed to _gtk_file_system_model_new*() */
+#define MODEL_COLUMN_TYPES \
+ MODEL_COL_NUM_COLUMNS, \
+ G_TYPE_STRING, /* MODEL_COL_NAME */ \
+ G_TYPE_INT64, /* MODEL_COL_SIZE */ \
+ G_TYPE_LONG, /* MODEL_COL_MTIME */ \
+ G_TYPE_FILE, /* MODEL_COL_FILE */ \
+ G_TYPE_STRING, /* MODEL_COL_NAME_COLLATED */ \
+ G_TYPE_BOOLEAN, /* MODEL_COL_IS_FOLDER */ \
+ GDK_TYPE_PIXBUF, /* MODEL_COL_PIXBUF */ \
+ G_TYPE_STRING, /* MODEL_COL_SIZE_TEXT */ \
+ G_TYPE_STRING, /* MODEL_COL_MTIME_TEXT */ \
+ PANGO_TYPE_ELLIPSIZE_MODE /* MODEL_COL_ELLIPSIZE */
/* Identifiers for target types */
enum {
GParamSpec *pspec);
static void gtk_file_chooser_default_dispose (GObject *object);
static void gtk_file_chooser_default_show_all (GtkWidget *widget);
+static void gtk_file_chooser_default_realize (GtkWidget *widget);
static void gtk_file_chooser_default_map (GtkWidget *widget);
static void gtk_file_chooser_default_unmap (GtkWidget *widget);
static void gtk_file_chooser_default_hierarchy_changed (GtkWidget *widget,
GtkTreeViewColumn *column,
GtkFileChooserDefault *impl);
-static void select_func (GtkFileSystemModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer user_data);
-
static void path_bar_clicked (GtkPathBar *path_bar,
GFile *file,
GFile *child,
static void save_folder_combo_changed_cb (GtkComboBox *combo,
GtkFileChooserDefault *impl);
-static void list_icon_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data);
-static void list_name_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data);
-static void list_size_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data);
-static void list_mtime_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data);
-
-static GFileInfo *get_list_file_info (GtkFileChooserDefault *impl,
- GtkTreeIter *iter);
+static void update_cell_renderer_attributes (GtkFileChooserDefault *impl);
static void load_remove_timer (GtkFileChooserDefault *impl);
static void browse_files_center_selected_row (GtkFileChooserDefault *impl);
GtkFileChooserDefault *impl);
static void location_switch_to_path_bar (GtkFileChooserDefault *impl);
+static void stop_loading_and_clear_list_model (GtkFileChooserDefault *impl,
+ gboolean remove_from_treeview);
static void search_stop_searching (GtkFileChooserDefault *impl,
gboolean remove_query);
-static void search_clear_model_row (GtkTreeModel *model,
- GtkTreeIter *iter);
static void search_clear_model (GtkFileChooserDefault *impl,
gboolean remove_from_treeview);
static gboolean search_should_respond (GtkFileChooserDefault *impl);
static void search_entry_activate_cb (GtkEntry *entry,
gpointer data);
static void settings_load (GtkFileChooserDefault *impl);
-static void search_get_valid_child_iter (GtkFileChooserDefault *impl,
- GtkTreeIter *child_iter,
- GtkTreeIter *iter);
static void recent_stop_loading (GtkFileChooserDefault *impl);
static void recent_clear_model (GtkFileChooserDefault *impl,
static gboolean recent_should_respond (GtkFileChooserDefault *impl);
static void recent_switch_to_browse_mode (GtkFileChooserDefault *impl);
static GSList * recent_get_selected_files (GtkFileChooserDefault *impl);
-static void recent_get_valid_child_iter (GtkFileChooserDefault *impl,
- GtkTreeIter *child_iter,
- GtkTreeIter *iter);
static void set_file_system_backend (GtkFileChooserDefault *impl);
static void unset_file_system_backend (GtkFileChooserDefault *impl);
GtkTreeModel *child_model,
GtkTreePath *root);
-
-typedef struct {
- GtkTreeModelSort parent;
-
- GtkFileChooserDefault *impl;
-} RecentModelSort;
-
-typedef struct {
- GtkTreeModelSortClass parent_class;
-} RecentModelSortClass;
-
-#define RECENT_MODEL_SORT_TYPE (_recent_model_sort_get_type ())
-#define RECENT_MODEL_SORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RECENT_MODEL_SORT_TYPE, RecentModelSort))
-
-static void recent_model_sort_drag_source_iface_init (GtkTreeDragSourceIface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (RecentModelSort,
- _recent_model_sort,
- GTK_TYPE_TREE_MODEL_SORT,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
- recent_model_sort_drag_source_iface_init));
-
-static GtkTreeModel *recent_model_sort_new (GtkFileChooserDefault *impl,
- GtkTreeModel *child_model);
-
-
-typedef struct {
- GtkTreeModelSort parent;
-
- GtkFileChooserDefault *impl;
-} SearchModelSort;
-
-typedef struct {
- GtkTreeModelSortClass parent_class;
-} SearchModelSortClass;
-
-#define SEARCH_MODEL_SORT_TYPE (_search_model_sort_get_type ())
-#define SEARCH_MODEL_SORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SEARCH_MODEL_SORT_TYPE, SearchModelSort))
-
-static void search_model_sort_drag_source_iface_init (GtkTreeDragSourceIface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (SearchModelSort,
- _search_model_sort,
- GTK_TYPE_TREE_MODEL_SORT,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
- search_model_sort_drag_source_iface_init));
-
-static GtkTreeModel *search_model_sort_new (GtkFileChooserDefault *impl,
- GtkTreeModel *child_model);
-
\f
G_DEFINE_TYPE_WITH_CODE (GtkFileChooserDefault, _gtk_file_chooser_default, GTK_TYPE_VBOX,
gobject_class->dispose = gtk_file_chooser_default_dispose;
widget_class->show_all = gtk_file_chooser_default_show_all;
+ widget_class->realize = gtk_file_chooser_default_realize;
widget_class->map = gtk_file_chooser_default_map;
widget_class->unmap = gtk_file_chooser_default_unmap;
widget_class->hierarchy_changed = gtk_file_chooser_default_hierarchy_changed;
impl->use_preview_label = TRUE;
impl->select_multiple = FALSE;
impl->show_hidden = FALSE;
- impl->show_size_column = FALSE;
+ impl->show_size_column = TRUE;
impl->icon_size = FALLBACK_ICON_SIZE;
impl->load_state = LOAD_EMPTY;
impl->reload_state = RELOAD_EMPTY;
impl->pending_select_files = NULL;
impl->location_mode = LOCATION_MODE_PATH_BAR;
impl->operation_mode = OPERATION_MODE_BROWSE;
+ impl->sort_column = MODEL_COL_NAME;
+ impl->sort_order = GTK_SORT_ASCENDING;
impl->recent_manager = gtk_recent_manager_get_default ();
+ impl->create_folders = TRUE;
gtk_box_set_spacing (GTK_BOX (impl), 12);
gpointer data)
{
GtkFileChooserDefault *impl;
- GtkTreeIter child_iter;
GFile *file;
impl = GTK_FILE_CHOOSER_DEFAULT (data);
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model, &child_iter, iter);
-
- file = _gtk_file_system_model_get_file (impl->browse_files_model, &child_iter);
+ file = _gtk_file_system_model_get_file (GTK_FILE_SYSTEM_MODEL (model), iter);
pending_select_files_add (impl, file);
}
if (impl->preview_file)
g_object_unref (impl->preview_file);
- load_remove_timer (impl);
+ if (impl->browse_path_bar_size_group)
+ g_object_unref (impl->browse_path_bar_size_group);
/* Free all the Models we have */
- if (impl->browse_files_model)
- g_object_unref (impl->browse_files_model);
-
- if (impl->sort_model)
- g_object_unref (impl->sort_model);
-
+ stop_loading_and_clear_list_model (impl, FALSE);
search_clear_model (impl, FALSE);
recent_clear_model (impl, FALSE);
+ /* stopping the load above should have cleared this */
+ g_assert (impl->load_timeout_id == 0);
+
g_free (impl->preview_display_name);
g_free (impl->edited_new_text);
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (widget);
- if (!GTK_WIDGET_TOPLEVEL (toplevel))
+ if (!gtk_widget_is_toplevel (toplevel))
return NULL;
else
return GTK_WINDOW (toplevel);
static void
emit_default_size_changed (GtkFileChooserDefault *impl)
{
- if (!GTK_WIDGET_MAPPED (impl))
- return;
-
profile_msg (" emit default-size-changed start", NULL);
g_signal_emit_by_name (impl, "default-size-changed");
profile_msg (" emit default-size-changed end", NULL);
else
gtk_widget_hide (impl->preview_box);
- emit_default_size_changed (impl);
+ if (!gtk_widget_get_mapped (GTK_WIDGET (impl)))
+ emit_default_size_changed (impl);
}
static void
gtk_tree_path_free (p);
cancellable = _gtk_file_system_get_info (request->impl->file_system, request->file,
- "standard::is-hidden,standard::display-name,standard::icon",
+ "standard::is-hidden,standard::is-backup,standard::display-name,standard::icon",
get_file_info_finished, request);
gtk_list_store_set (impl->shortcuts_model, &iter,
profile_start ("start", NULL);
name = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
+ /* "To disable a directory, point it to the homedir."
+ * See http://freedesktop.org/wiki/Software/xdg-user-dirs
+ **/
+ if (!g_strcmp0 (name, g_get_home_dir ()))
+ {
+ profile_end ("end", NULL);
+ return;
+ }
+
file = g_file_new_for_path (name);
shortcuts_insert_file (impl, -1, SHORTCUT_TYPE_FILE, NULL, file, _("Desktop"), FALSE, SHORTCUTS_DESKTOP);
impl->has_desktop = TRUE;
bookmarks = _gtk_file_system_list_bookmarks (impl->file_system);
shortcuts_append_bookmarks (impl, bookmarks);
+ g_slist_foreach (bookmarks, (GFunc) g_object_unref, NULL);
g_slist_free (bookmarks);
if (impl->num_bookmarks == 0)
gtk_widget_set_sensitive (impl->browse_new_folder_button, TRUE);
- if (impl->edited_new_text) /* not cancelled? */
+ if (impl->edited_new_text /* not cancelled? */
+ && (strlen (impl->edited_new_text) != 0)
+ && (strcmp (impl->edited_new_text, DEFAULT_NEW_FOLDER_NAME) != 0)) /* Don't create folder if name is empty or has not been edited */
{
GError *error = NULL;
GFile *file;
{
GError *error = NULL;
- if (!g_file_make_directory (file, NULL, &error))
+ if (g_file_make_directory (file, NULL, &error))
change_folder_and_display_error (impl, file, FALSE);
else
error_creating_folder_dialog (impl, file, error);
gpointer data)
{
GtkFileChooserDefault *impl;
- GtkFileSystemModel *fs_model;
- GtkTreeIter child_iter;
GFile *file;
impl = (GtkFileChooserDefault *) data;
- switch (impl->operation_mode)
- {
- case OPERATION_MODE_BROWSE:
- fs_model = impl->browse_files_model;
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model, &child_iter, iter);
- file = _gtk_file_system_model_get_file (fs_model, &child_iter);
- break;
-
- case OPERATION_MODE_SEARCH:
- search_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_FILE, &file,
- -1);
- break;
-
- case OPERATION_MODE_RECENT:
- recent_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_FILE, &file,
- -1);
- break;
- }
+ gtk_tree_model_get (model, iter,
+ MODEL_COL_FILE, &file,
+ -1);
shortcuts_add_bookmark_from_file (impl, file, -1);
+
+ g_object_unref (file);
}
/* Adds a bookmark from the currently selected item in the file list */
gpointer data)
{
struct selection_check_closure *closure;
- GtkTreeIter child_iter;
- GFileInfo *info;
gboolean is_folder;
+ GFile *file;
- closure = data;
- closure->num_selected++;
+ gtk_tree_model_get (model, iter,
+ MODEL_COL_FILE, &file,
+ MODEL_COL_IS_FOLDER, &is_folder,
+ -1);
- switch (closure->impl->operation_mode)
- {
- case OPERATION_MODE_BROWSE:
- gtk_tree_model_sort_convert_iter_to_child_iter (closure->impl->sort_model, &child_iter, iter);
- info = _gtk_file_system_model_get_info (closure->impl->browse_files_model, &child_iter);
- is_folder = info ? (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY) : FALSE;
- break;
+ if (file == NULL)
+ return;
- case OPERATION_MODE_SEARCH:
- search_get_valid_child_iter (closure->impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (closure->impl->search_model), &child_iter,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
- break;
+ g_object_unref (file);
- case OPERATION_MODE_RECENT:
- recent_get_valid_child_iter (closure->impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (closure->impl->recent_model), &child_iter,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
- break;
- }
+ closure = data;
+ closure->num_selected++;
closure->all_folders = closure->all_folders && is_folder;
closure->all_files = closure->all_files && !is_folder;
GtkTreeIter *iter,
gpointer data)
{
- struct get_selected_file_closure *closure;
- GtkTreeIter child_iter;
-
- closure = data;
+ struct get_selected_file_closure *closure = data;
- switch (closure->impl->operation_mode)
+ if (closure->file)
{
- case OPERATION_MODE_BROWSE:
- gtk_tree_model_sort_convert_iter_to_child_iter (closure->impl->sort_model, &child_iter, iter);
- closure->file = _gtk_file_system_model_get_file (closure->impl->browse_files_model, &child_iter);
- break;
-
- case OPERATION_MODE_SEARCH:
- search_get_valid_child_iter (closure->impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (closure->impl->search_model), &child_iter,
- SEARCH_MODEL_COL_FILE, &closure->file,
- -1);
- break;
-
- case OPERATION_MODE_RECENT:
- recent_get_valid_child_iter (closure->impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (closure->impl->recent_model), &child_iter,
- RECENT_MODEL_COL_FILE, &closure->file,
- -1);
- break;
+ /* Just in case this function gets run more than once with a multiple selection; we only care about one file */
+ g_object_unref (closure->file);
+ closure->file = NULL;
}
+
+ gtk_tree_model_get (model, iter,
+ MODEL_COL_FILE, &closure->file, /* this will give us a reffed file */
+ -1);
}
/* Returns a selected path from the file list */
gpointer data)
{
UpdateTooltipData *udata = data;
- GtkTreeIter child_iter;
- GFileInfo *info;
if (udata->tip == NULL)
{
- const gchar *display_name;
-
- switch (udata->impl->operation_mode)
- {
- case OPERATION_MODE_BROWSE:
- gtk_tree_model_sort_convert_iter_to_child_iter (udata->impl->sort_model,
- &child_iter,
- iter);
- info = _gtk_file_system_model_get_info (udata->impl->browse_files_model, &child_iter);
- display_name = g_file_info_get_display_name (info);
- break;
-
- case OPERATION_MODE_SEARCH:
- search_get_valid_child_iter (udata->impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (udata->impl->search_model), &child_iter,
- SEARCH_MODEL_COL_DISPLAY_NAME, &display_name,
- -1);
- break;
+ gchar *display_name;
- case OPERATION_MODE_RECENT:
- recent_get_valid_child_iter (udata->impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (udata->impl->recent_model), &child_iter,
- RECENT_MODEL_COL_DISPLAY_NAME, &display_name,
- -1);
- break;
- }
+ gtk_tree_model_get (model, iter,
+ MODEL_COL_NAME, &display_name,
+ -1);
udata->tip = g_strdup_printf (_("Add the folder '%s' to the bookmarks"),
display_name);
+ g_free (display_name);
}
}
GFile *file;
file = get_selected_file (impl);
- active = all_folders && (shortcut_find_position (impl, file) == -1);
+ active = file && all_folders && (shortcut_find_position (impl, file) == -1);
+ if (file)
+ g_object_unref (file);
}
else
active = all_folders;
GtkTreeIter iter;
gboolean removable = FALSE;
gchar *name = NULL;
+ gchar *tip;
if (shortcuts_get_selected (impl, &iter))
- gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
- SHORTCUTS_COL_REMOVABLE, &removable,
- SHORTCUTS_COL_NAME, &name,
- -1);
-
- gtk_widget_set_sensitive (impl->browse_shortcuts_remove_button, removable);
-
- if (removable)
{
- gchar *tip;
+ gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &iter,
+ SHORTCUTS_COL_REMOVABLE, &removable,
+ SHORTCUTS_COL_NAME, &name,
+ -1);
+ gtk_widget_set_sensitive (impl->browse_shortcuts_remove_button, removable);
+
+ if (removable)
+ tip = g_strdup_printf (_("Remove the bookmark '%s'"), name);
+ else
+ tip = g_strdup_printf (_("Bookmark '%s' cannot be removed"), name);
- tip = g_strdup_printf (_("Remove the bookmark '%s'"), name);
gtk_widget_set_tooltip_text (impl->browse_shortcuts_remove_button, tip);
g_free (tip);
}
-
+ else
+ gtk_widget_set_tooltip_text (impl->browse_shortcuts_remove_button,
+ _("Remove the selected bookmark"));
g_free (name);
}
return shortcut_type == SHORTCUT_TYPE_SEPARATOR;
}
-/* Since GtkTreeView has a keybinding attached to '/', we need to catch
- * keypresses before the TreeView gets them.
- */
static gboolean
-tree_view_keybinding_cb (GtkWidget *tree_view,
- GdkEventKey *event,
- GtkFileChooserDefault *impl)
+shortcuts_key_press_event_after_cb (GtkWidget *tree_view,
+ GdkEventKey *event,
+ GtkFileChooserDefault *impl)
{
- if ((event->keyval == GDK_slash
- || event->keyval == GDK_KP_Divide
-#ifdef G_OS_UNIX
- || event->keyval == GDK_asciitilde
-#endif
- ) && ! (event->state & (~GDK_SHIFT_MASK & gtk_accelerator_get_default_mod_mask ())))
+ GtkWidget *entry;
+
+ /* don't screw up focus switching with Tab */
+ if (event->keyval == GDK_Tab
+ || event->keyval == GDK_KP_Tab
+ || event->keyval == GDK_ISO_Left_Tab
+ || event->length < 1)
+ return FALSE;
+
+ if (impl->location_entry)
+ entry = impl->location_entry;
+ else if (impl->search_entry)
+ entry = impl->search_entry;
+ else
+ entry = NULL;
+
+ if (entry)
{
- location_popup_handler (impl, event->string);
- return TRUE;
+ gtk_widget_grab_focus (entry);
+ return gtk_widget_event (entry, (GdkEvent *) event);
}
-
- return FALSE;
+ else
+ return FALSE;
}
/* Callback used when the file list's popup menu is detached */
{
path = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->shortcuts_model), &iter);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view), 0);
- renderers = gtk_tree_view_column_get_cell_renderers (column);
+ renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
cell = g_list_nth_data (renderers, 1);
g_list_free (renderers);
g_object_set (cell, "editable", TRUE, NULL);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
- GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin),
GTK_SHADOW_IN);
gtk_widget_show (swin);
/* Tree */
impl->browse_shortcuts_tree_view = gtk_tree_view_new ();
+ gtk_tree_view_set_enable_search (GTK_TREE_VIEW (impl->browse_shortcuts_tree_view), FALSE);
#ifdef PROFILE_FILE_CHOOSER
g_object_set_data (G_OBJECT (impl->browse_shortcuts_tree_view), "fmq-name", "shortcuts");
#endif
- g_signal_connect (impl->browse_shortcuts_tree_view, "key-press-event",
- G_CALLBACK (tree_view_keybinding_cb), impl);
+
+ /* Connect "after" to key-press-event on the shortcuts pane. We want this action to be possible:
+ *
+ * 1. user brings up a SAVE dialog
+ * 2. user clicks on a shortcut in the shortcuts pane
+ * 3. user starts typing a filename
+ *
+ * Normally, the user's typing would be ignored, as the shortcuts treeview doesn't
+ * support interactive search. However, we'd rather focus the location entry
+ * so that the user can type *there*.
+ *
+ * To preserve keyboard navigation in the shortcuts pane, we don't focus the
+ * filename entry if one clicks on a shortcut; rather, we focus the entry only
+ * if the user starts typing while the focus is in the shortcuts pane.
+ */
+ g_signal_connect_after (impl->browse_shortcuts_tree_view, "key-press-event",
+ G_CALLBACK (shortcuts_key_press_event_after_cb), impl);
+
g_signal_connect (impl->browse_shortcuts_tree_view, "popup-menu",
G_CALLBACK (shortcuts_popup_menu_cb), impl);
g_signal_connect (impl->browse_shortcuts_tree_view, "button-press-event",
NULL);
renderer = gtk_cell_renderer_text_new ();
+ g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (shortcuts_edited), impl);
g_signal_connect (renderer, "editing-canceled",
return vbox;
}
+static gboolean
+key_is_left_or_right (GdkEventKey *event)
+{
+ guint modifiers;
+
+ modifiers = gtk_accelerator_get_default_mod_mask ();
+
+ return ((event->keyval == GDK_Right
+ || event->keyval == GDK_KP_Right
+ || event->keyval == GDK_Left
+ || event->keyval == GDK_KP_Left)
+ && (event->state & modifiers) == 0);
+}
+
/* Handles key press events on the file list, so that we can trap Enter to
* activate the default button on our own. Also, checks to see if '/' has been
* pressed. See comment by tree_view_keybinding_cb() for more details.
*/
static gboolean
-trap_activate_cb (GtkWidget *widget,
- GdkEventKey *event,
- gpointer data)
+browse_files_key_press_event_cb (GtkWidget *widget,
+ GdkEventKey *event,
+ gpointer data)
{
GtkFileChooserDefault *impl;
int modifiers;
return TRUE;
}
+ if (key_is_left_or_right (event))
+ {
+ gtk_widget_grab_focus (impl->browse_shortcuts_tree_view);
+ return TRUE;
+ }
+
if ((event->keyval == GDK_Return
|| event->keyval == GDK_ISO_Enter
|| event->keyval == GDK_KP_Enter
if (window
&& widget != window->default_widget
&& !(widget == window->focus_widget &&
- (!window->default_widget || !GTK_WIDGET_SENSITIVE (window->default_widget))))
+ (!window->default_widget || !gtk_widget_get_sensitive (window->default_widget))))
{
gtk_window_activate_default (window);
return TRUE;
{
impl->show_size_column = gtk_check_menu_item_get_active (item);
- if (impl->list_size_column)
- gtk_tree_view_column_set_visible (impl->list_size_column,
- impl->show_size_column);
+ gtk_tree_view_column_set_visible (impl->list_size_column,
+ impl->show_size_column);
}
/* Shows an error dialog about not being able to select a dragged file */
if ((data->impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
data->impl->action == GTK_FILE_CHOOSER_ACTION_SAVE) &&
- data->uris[1] == 0 && !error &&
- g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
+ data->uris[1] == 0 && !error && _gtk_file_info_consider_as_directory (info))
change_folder_and_display_error (data->impl, data->file, FALSE);
else
{
impl->browse_files_popup_menu_add_shortcut_item = item;
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
- gtk_widget_set_sensitive (item, FALSE);
g_signal_connect (item, "activate",
G_CALLBACK (add_to_shortcuts_cb), impl);
gtk_widget_show (item);
G_CALLBACK (show_size_column_toggled_cb), impl);
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (impl->browse_files_popup_menu), item);
+
+ bookmarks_check_add_sensitivity (impl);
}
/* Updates the popup menu for the file list, creating it if necessary */
return TRUE;
}
+typedef struct {
+ OperationMode operation_mode;
+ gint general_column;
+ gint model_column;
+} ColumnMap;
+
/* Sets the sort column IDs for the file list based on the operation mode */
static void
file_list_set_sort_column_ids (GtkFileChooserDefault *impl)
{
- int name_id, mtime_id, size_id;
-
- name_id = mtime_id = size_id = 0;
-
- switch (impl->operation_mode)
- {
- case OPERATION_MODE_BROWSE:
- name_id = FILE_LIST_COL_NAME;
- mtime_id = FILE_LIST_COL_MTIME;
- size_id = FILE_LIST_COL_SIZE;
- break;
- case OPERATION_MODE_SEARCH:
- name_id = SEARCH_MODEL_COL_FILE;
- mtime_id = SEARCH_MODEL_COL_MTIME;
- size_id = SEARCH_MODEL_COL_SIZE;
- break;
- case OPERATION_MODE_RECENT:
- name_id = RECENT_MODEL_COL_FILE;
- mtime_id = RECENT_MODEL_COL_INFO;
- break;
- }
-
- gtk_tree_view_column_set_sort_column_id (impl->list_name_column, name_id);
- gtk_tree_view_column_set_sort_column_id (impl->list_mtime_column, mtime_id);
- gtk_tree_view_column_set_sort_column_id (impl->list_size_column, size_id);
+ gtk_tree_view_column_set_sort_column_id (impl->list_name_column, MODEL_COL_NAME);
+ gtk_tree_view_column_set_sort_column_id (impl->list_mtime_column, MODEL_COL_MTIME);
+ gtk_tree_view_column_set_sort_column_id (impl->list_size_column, MODEL_COL_SIZE);
}
static gboolean
gpointer user_data)
{
GtkFileChooserDefault *impl = user_data;
- GtkTreeIter iter, child_iter;
- GtkTreePath *path = NULL;
+ GtkTreeModel *model;
+ GtkTreePath *path;
+ GtkTreeIter iter;
GFile *file;
gchar *filename;
return FALSE;
- gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (impl->browse_files_tree_view),
- &x, &y,
- keyboard_tip,
- NULL, &path, NULL);
-
- if (!path)
+ if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (impl->browse_files_tree_view),
+ &x, &y,
+ keyboard_tip,
+ &model, &path, &iter))
return FALSE;
+
+ gtk_tree_model_get (model, &iter,
+ MODEL_COL_FILE, &file,
+ -1);
- switch (impl->operation_mode)
- {
- case OPERATION_MODE_SEARCH:
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->search_model_sort), &iter, path))
- {
- gtk_tree_path_free (path);
- return FALSE;
- }
-
- search_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_FILE, &file,
- -1);
- break;
-
- case OPERATION_MODE_RECENT:
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->recent_model_sort), &iter, path))
- {
- gtk_tree_path_free (path);
- return FALSE;
- }
-
- recent_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_FILE, &file,
- -1);
- break;
-
- case OPERATION_MODE_BROWSE:
- g_assert_not_reached ();
- return FALSE;
- }
-
- if (!file)
+ if (file == NULL)
{
gtk_tree_path_free (path);
return FALSE;
path);
g_free (filename);
+ g_object_unref (file);
gtk_tree_path_free (path);
return TRUE;
}
+static void
+set_icon_cell_renderer_fixed_size (GtkFileChooserDefault *impl, GtkCellRenderer *renderer)
+{
+ gtk_cell_renderer_set_fixed_size (renderer,
+ renderer->xpad * 2 + impl->icon_size,
+ renderer->ypad * 2 + impl->icon_size);
+}
+
/* Creates the widgets for the file list */
static GtkWidget *
create_file_list (GtkFileChooserDefault *impl)
g_signal_connect (impl->browse_files_tree_view, "row-activated",
G_CALLBACK (list_row_activated), impl);
g_signal_connect (impl->browse_files_tree_view, "key-press-event",
- G_CALLBACK (trap_activate_cb), impl);
+ G_CALLBACK (browse_files_key_press_event_cb), impl);
g_signal_connect (impl->browse_files_tree_view, "popup-menu",
G_CALLBACK (list_popup_menu_cb), impl);
g_signal_connect (impl->browse_files_tree_view, "button-press-event",
g_signal_connect (selection, "changed",
G_CALLBACK (list_selection_changed), impl);
+ /* Keep the column order in sync with update_cell_renderer_attributes() */
+
/* Filename column */
impl->list_name_column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_expand (impl->list_name_column, TRUE);
gtk_tree_view_column_set_resizable (impl->list_name_column, TRUE);
gtk_tree_view_column_set_title (impl->list_name_column, _("Name"));
- gtk_tree_view_column_set_sort_column_id (impl->list_name_column, FILE_LIST_COL_NAME);
renderer = gtk_cell_renderer_pixbuf_new ();
+ /* We set a fixed size so that we get an empty slot even if no icons are loaded yet */
+ set_icon_cell_renderer_fixed_size (impl, renderer);
gtk_tree_view_column_pack_start (impl->list_name_column, renderer, FALSE);
- gtk_tree_view_column_set_cell_data_func (impl->list_name_column, renderer,
- list_icon_data_func, impl, NULL);
impl->list_name_renderer = gtk_cell_renderer_text_new ();
g_object_set (impl->list_name_renderer,
g_signal_connect (impl->list_name_renderer, "editing-canceled",
G_CALLBACK (renderer_editing_canceled_cb), impl);
gtk_tree_view_column_pack_start (impl->list_name_column, impl->list_name_renderer, TRUE);
- gtk_tree_view_column_set_cell_data_func (impl->list_name_column, impl->list_name_renderer,
- list_name_data_func, impl, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (impl->browse_files_tree_view), impl->list_name_column);
/* Size column */
column = gtk_tree_view_column_new ();
+ gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_title (column, _("Size"));
renderer = gtk_cell_renderer_text_new ();
+ g_object_set (renderer,
+ "alignment", PANGO_ALIGN_RIGHT,
+ NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE); /* bug: it doesn't expand */
- gtk_tree_view_column_set_cell_data_func (column, renderer,
- list_size_data_func, impl, NULL);
- gtk_tree_view_column_set_sort_column_id (column, FILE_LIST_COL_SIZE);
gtk_tree_view_append_column (GTK_TREE_VIEW (impl->browse_files_tree_view), column);
impl->list_size_column = column;
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
- gtk_tree_view_column_set_cell_data_func (column, renderer,
- list_mtime_data_func, impl, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (impl->browse_files_tree_view), column);
impl->list_mtime_column = column;
file_list_set_sort_column_ids (impl);
+ update_cell_renderer_attributes (impl);
gtk_widget_show_all (swin);
}
}
+static void
+save_folder_update_tooltip (GtkComboBox *combo,
+ GtkFileChooserDefault *impl)
+{
+ GtkTreeIter iter;
+ gchar *tooltip;
+
+ tooltip = NULL;
+
+ if (gtk_combo_box_get_active_iter (combo, &iter))
+ {
+ GtkTreeIter child_iter;
+ gpointer col_data;
+ ShortcutType shortcut_type;
+
+ gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (impl->shortcuts_combo_filter_model),
+ &child_iter,
+ &iter);
+ gtk_tree_model_get (GTK_TREE_MODEL (impl->shortcuts_model), &child_iter,
+ SHORTCUTS_COL_DATA, &col_data,
+ SHORTCUTS_COL_TYPE, &shortcut_type,
+ -1);
+
+ if (shortcut_type == SHORTCUT_TYPE_FILE)
+ tooltip = g_file_get_parse_name (G_FILE (col_data));
+ }
+
+ gtk_widget_set_tooltip_text (GTK_WIDGET (combo), tooltip);
+ gtk_widget_set_has_tooltip (GTK_WIDGET (combo),
+ gtk_widget_get_sensitive (GTK_WIDGET (combo)));
+ g_free (tooltip);
+}
+
/* Filter function used to filter out the Search item and its separator.
* Used for the "Save in folder" combo box, so that these items do not appear in it.
*/
NULL);
cell = gtk_cell_renderer_text_new ();
+ g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell,
"text", SHORTCUTS_COL_NAME,
g_signal_connect (combo, "changed",
G_CALLBACK (save_folder_combo_changed_cb), impl);
+ g_signal_connect (combo, "changed",
+ G_CALLBACK (save_folder_update_tooltip), impl);
return combo;
}
impl->location_entry = _gtk_file_chooser_entry_new (TRUE);
_gtk_file_chooser_entry_set_file_system (GTK_FILE_CHOOSER_ENTRY (impl->location_entry),
impl->file_system);
+ _gtk_file_chooser_entry_set_local_only (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), impl->local_only);
gtk_entry_set_width_chars (GTK_ENTRY (impl->location_entry), 45);
gtk_entry_set_activates_default (GTK_ENTRY (impl->location_entry), TRUE);
gtk_table_attach (GTK_TABLE (table), impl->location_entry,
}
else if (impl->location_mode == LOCATION_MODE_FILENAME_ENTRY)
{
- if (GTK_WIDGET_HAS_FOCUS (impl->location_entry))
+ if (gtk_widget_has_focus (impl->location_entry))
{
location_mode_set (impl, LOCATION_MODE_PATH_BAR, TRUE);
}
impl->location_button = g_object_new (GTK_TYPE_TOGGLE_BUTTON,
"image", image,
NULL);
+
+ gtk_size_group_add_widget (impl->browse_path_bar_size_group, impl->location_button);
g_signal_connect (impl->location_button, "toggled",
G_CALLBACK (location_button_toggled_cb), impl);
browse_widgets_create (GtkFileChooserDefault *impl)
{
GtkWidget *vbox;
- GtkWidget *hbox;
GtkWidget *hpaned;
GtkWidget *widget;
GtkSizeGroup *size_group;
vbox = gtk_vbox_new (FALSE, 12);
/* Location widgets */
- hbox = gtk_hbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
- gtk_widget_show (hbox);
- impl->browse_path_bar_hbox = hbox;
+ impl->browse_path_bar_hbox = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox), impl->browse_path_bar_hbox, FALSE, FALSE, 0);
+ gtk_widget_show (impl->browse_path_bar_hbox);
+
+ /* Size group that allows the path bar to be the same size between modes */
+ impl->browse_path_bar_size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+ gtk_size_group_set_ignore_hidden (impl->browse_path_bar_size_group, FALSE);
+
+ /* Location button */
location_button_create (impl);
- gtk_box_pack_start (GTK_BOX (hbox), impl->location_button, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->location_button, FALSE, FALSE, 0);
/* Path bar */
impl->browse_path_bar = create_path_bar (impl);
g_signal_connect (impl->browse_path_bar, "path-clicked", G_CALLBACK (path_bar_clicked), impl);
gtk_widget_show_all (impl->browse_path_bar);
- gtk_box_pack_start (GTK_BOX (hbox), impl->browse_path_bar, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->browse_path_bar, TRUE, TRUE, 0);
/* Create Folder */
impl->browse_new_folder_button = gtk_button_new_with_mnemonic (_("Create Fo_lder"));
g_signal_connect (impl->browse_new_folder_button, "clicked",
G_CALLBACK (new_folder_button_clicked), impl);
- gtk_box_pack_end (GTK_BOX (hbox), impl->browse_new_folder_button, FALSE, FALSE, 0);
+ gtk_box_pack_end (GTK_BOX (impl->browse_path_bar_hbox), impl->browse_new_folder_button, FALSE, FALSE, 0);
/* Box for the location label and entry */
{
impl->local_only = local_only;
+ if (impl->location_entry)
+ _gtk_file_chooser_entry_set_local_only (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), local_only);
+
if (impl->shortcuts_model && impl->file_system)
{
shortcuts_add_volumes (impl);
shortcuts_add_bookmarks (impl);
}
- if (local_only && !g_file_is_native (impl->current_folder))
+ if (local_only && impl->current_folder &&
+ !g_file_is_native (impl->current_folder))
{
/* If we are pointing to a non-local folder, make an effort to change
* back to a local folder, but it's really up to the app to not cause
{
gtk_widget_set_sensitive (impl->save_folder_label, FALSE);
gtk_widget_set_sensitive (impl->save_folder_combo, FALSE);
+ gtk_widget_set_has_tooltip (impl->save_folder_combo, FALSE);
gtk_widget_show (impl->browse_widgets);
}
else
{
gtk_widget_set_sensitive (impl->save_folder_label, TRUE);
gtk_widget_set_sensitive (impl->save_folder_combo, TRUE);
+ gtk_widget_set_has_tooltip (impl->save_folder_combo, TRUE);
gtk_widget_hide (impl->browse_widgets);
}
- gtk_widget_show (impl->browse_new_folder_button);
-
if (impl->select_multiple)
{
g_warning ("Save mode cannot be set in conjunction with multiple selection mode. "
if (impl->location_entry)
_gtk_file_chooser_entry_set_action (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), impl->action);
- if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
+ if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN || !impl->create_folders)
gtk_widget_hide (impl->browse_new_folder_button);
else
gtk_widget_show (impl->browse_new_folder_button);
set_select_multiple (impl, FALSE, TRUE);
}
impl->action = action;
+ update_cell_renderer_attributes (impl);
update_appearance (impl);
settings_load (impl);
}
}
break;
+ case GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS:
+ {
+ gboolean create_folders = g_value_get_boolean (value);
+ impl->create_folders = create_folders;
+ update_appearance (impl);
+ }
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
g_value_set_boolean (value, impl->do_overwrite_confirmation);
break;
+ case GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS:
+ g_value_set_boolean (value, impl->create_folders);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
impl->update_current_folder_cancellable = NULL;
}
- if (impl->show_and_select_files_cancellable)
- {
- g_cancellable_cancel (impl->show_and_select_files_cancellable);
- impl->show_and_select_files_cancellable = NULL;
- }
-
- if (impl->should_respond_get_info_cancellable)
+ if (impl->should_respond_get_info_cancellable)
{
g_cancellable_cancel (impl->should_respond_get_info_cancellable);
impl->should_respond_get_info_cancellable = NULL;
{
GtkSettings *settings;
gint width, height;
+ GtkCellRenderer *renderer;
+ GList *cells;
profile_start ("start", NULL);
impl->icon_size = FALLBACK_ICON_SIZE;
shortcuts_reload_icons (impl);
+ /* the first cell in the first column is the icon column, and we have a fixed size there */
+ cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (
+ gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 0)));
+ renderer = GTK_CELL_RENDERER (cells->data);
+ set_icon_cell_renderer_fixed_size (impl, renderer);
+ g_list_free (cells);
+ if (impl->browse_files_model)
+ _gtk_file_system_model_clear_cache (impl->browse_files_model, MODEL_COL_PIXBUF);
gtk_widget_queue_resize (impl->browse_files_tree_view);
profile_end ("end", NULL);
GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->size_allocate (widget, allocation);
}
-static gboolean
-get_is_file_filtered (GtkFileChooserDefault *impl,
- GFile *file,
- GFileInfo *file_info)
+static void
+set_sort_column (GtkFileChooserDefault *impl)
{
- GtkFileFilterInfo filter_info;
- GtkFileFilterFlags needed;
- gboolean result;
-
- if (!impl->current_filter)
- return FALSE;
-
- filter_info.contains = GTK_FILE_FILTER_DISPLAY_NAME | GTK_FILE_FILTER_MIME_TYPE;
-
- needed = gtk_file_filter_get_needed (impl->current_filter);
-
- filter_info.display_name = g_file_info_get_display_name (file_info);
- filter_info.mime_type = g_content_type_get_mime_type (g_file_info_get_content_type (file_info));
-
- if (needed & GTK_FILE_FILTER_FILENAME)
- {
- filter_info.filename = g_file_get_path (file);
- if (filter_info.filename)
- filter_info.contains |= GTK_FILE_FILTER_FILENAME;
- }
- else
- filter_info.filename = NULL;
-
- if (needed & GTK_FILE_FILTER_URI)
- {
- filter_info.uri = g_file_get_uri (file);
- if (filter_info.uri)
- filter_info.contains |= GTK_FILE_FILTER_URI;
- }
- else
- filter_info.uri = NULL;
+ GtkTreeSortable *sortable;
- result = gtk_file_filter_filter (impl->current_filter, &filter_info);
-
- g_free ((gchar *)filter_info.filename);
- g_free ((gchar *)filter_info.uri);
- g_free ((gchar *)filter_info.mime_type);
+ sortable = GTK_TREE_SORTABLE (gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view)));
+ /* can happen when we're still populating the model */
+ if (sortable == NULL)
+ return;
- return !result;
+ gtk_tree_sortable_set_sort_column_id (sortable,
+ impl->sort_column,
+ impl->sort_order);
}
static void
gboolean show_hidden;
gboolean expand_folders;
gboolean show_size_column;
+ gint sort_column;
+ GtkSortType sort_order;
settings = _gtk_file_chooser_settings_new ();
show_hidden = _gtk_file_chooser_settings_get_show_hidden (settings);
expand_folders = _gtk_file_chooser_settings_get_expand_folders (settings);
show_size_column = _gtk_file_chooser_settings_get_show_size_column (settings);
+ sort_column = _gtk_file_chooser_settings_get_sort_column (settings);
+ sort_order = _gtk_file_chooser_settings_get_sort_order (settings);
g_object_unref (settings);
gtk_expander_set_expanded (GTK_EXPANDER (impl->save_expander), expand_folders);
impl->show_size_column = show_size_column;
- if (impl->list_size_column)
- gtk_tree_view_column_set_visible (impl->list_size_column, show_size_column);
+ gtk_tree_view_column_set_visible (impl->list_size_column, show_size_column);
+
+ impl->sort_column = sort_column;
+ impl->sort_order = sort_order;
+ /* We don't call set_sort_column() here as the models may not have been
+ * created yet. The individual functions that create and set the models will
+ * call set_sort_column() themselves.
+ */
+}
+
+static void
+save_dialog_geometry (GtkFileChooserDefault *impl, GtkFileChooserSettings *settings)
+{
+ GtkWindow *toplevel;
+ int x, y, width, height;
+
+ /* We don't save the geometry in non-expanded "save" mode, so that the "little
+ * dialog" won't make future Open dialogs too small.
+ */
+ if (!(impl->action == GTK_FILE_CHOOSER_ACTION_OPEN
+ || impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
+ || impl->expand_folders))
+ return;
+
+ toplevel = get_toplevel (GTK_WIDGET (impl));
+
+ if (!(toplevel && GTK_IS_FILE_CHOOSER_DIALOG (toplevel)))
+ return;
+
+ gtk_window_get_position (toplevel, &x, &y);
+ gtk_window_get_size (toplevel, &width, &height);
+
+ _gtk_file_chooser_settings_set_geometry (settings, x, y, width, height);
}
static void
_gtk_file_chooser_settings_set_show_hidden (settings, gtk_file_chooser_get_show_hidden (GTK_FILE_CHOOSER (impl)));
_gtk_file_chooser_settings_set_expand_folders (settings, impl->expand_folders);
_gtk_file_chooser_settings_set_show_size_column (settings, impl->show_size_column);
+ _gtk_file_chooser_settings_set_sort_column (settings, impl->sort_column);
+ _gtk_file_chooser_settings_set_sort_order (settings, impl->sort_order);
+
+ save_dialog_geometry (impl, settings);
/* NULL GError */
_gtk_file_chooser_settings_save (settings, NULL);
g_object_unref (settings);
}
+/* GtkWidget::realize method */
+static void
+gtk_file_chooser_default_realize (GtkWidget *widget)
+{
+ GtkFileChooserDefault *impl;
+
+ impl = GTK_FILE_CHOOSER_DEFAULT (widget);
+
+ GTK_WIDGET_CLASS (_gtk_file_chooser_default_parent_class)->realize (widget);
+
+ emit_default_size_changed (impl);
+}
+
/* GtkWidget::map method */
static void
gtk_file_chooser_default_map (GtkWidget *widget)
settings_load (impl);
- emit_default_size_changed (impl);
-
profile_end ("end", NULL);
}
impl->reload_state = RELOAD_WAS_UNMAPPED;
}
-static gboolean
-list_model_filter_func (GtkFileSystemModel *model,
- GFile *file,
- GFileInfo *file_info,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
-
- if (!impl->current_filter)
- return TRUE;
-
- if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY)
- return TRUE;
-
- return !get_is_file_filtered (impl, file, file_info);
-}
-
static void
install_list_model_filter (GtkFileChooserDefault *impl)
{
- GtkFileSystemModelFilter filter;
- gpointer data;
-
- g_assert (impl->browse_files_model != NULL);
-
- if (impl->current_filter)
- {
- filter = list_model_filter_func;
- data = impl;
- }
- else
- {
- filter = NULL;
- data = NULL;
- }
-
_gtk_file_system_model_set_filter (impl->browse_files_model,
- filter,
- data);
+ impl->current_filter);
}
#define COMPARE_DIRECTORIES \
GtkFileChooserDefault *impl = user_data; \
- GFileInfo *info_a = _gtk_file_system_model_get_info (impl->browse_files_model, a); \
- GFileInfo *info_b = _gtk_file_system_model_get_info (impl->browse_files_model, b); \
+ GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model); \
gboolean dir_a, dir_b; \
\
- if (info_a) \
- dir_a = (g_file_info_get_file_type (info_a) == G_FILE_TYPE_DIRECTORY); \
- else \
- return impl->list_sort_ascending ? -1 : 1; \
- \
- if (info_b) \
- dir_b = (g_file_info_get_file_type (info_b) == G_FILE_TYPE_DIRECTORY); \
- else \
- return impl->list_sort_ascending ? 1 : -1; \
+ dir_a = g_value_get_boolean (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_IS_FOLDER)); \
+ dir_b = g_value_get_boolean (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_IS_FOLDER)); \
\
if (dir_a != dir_b) \
return impl->list_sort_ascending ? (dir_a ? -1 : 1) : (dir_a ? 1 : -1) /* Directories *always* go first */
COMPARE_DIRECTORIES;
else
{
- gchar *key_a, *key_b;
+ const char *key_a, *key_b;
gint result;
- key_a = g_utf8_collate_key_for_filename (g_file_info_get_display_name (info_a), -1);
- key_b = g_utf8_collate_key_for_filename (g_file_info_get_display_name (info_b), -1);
- result = strcmp (key_a, key_b);
+ key_a = g_value_get_string (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_NAME_COLLATED));
+ key_b = g_value_get_string (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_NAME_COLLATED));
- g_free (key_a);
- g_free (key_b);
+ if (key_a && key_b)
+ result = strcmp (key_a, key_b);
+ else if (key_a)
+ result = 1;
+ else if (key_b)
+ result = -1;
+ else
+ result = 0;
return result;
}
COMPARE_DIRECTORIES;
else
{
- goffset size_a = g_file_info_get_size (info_a);
- goffset size_b = g_file_info_get_size (info_b);
+ gint64 size_a, size_b;
+
+ size_a = g_value_get_int64 (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_SIZE));
+ size_b = g_value_get_int64 (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_SIZE));
return size_a > size_b ? -1 : (size_a == size_b ? 0 : 1);
}
COMPARE_DIRECTORIES;
else
{
- GTimeVal ta, tb;
+ glong ta, tb;
- g_file_info_get_modification_time (info_a, &ta);
- g_file_info_get_modification_time (info_b, &tb);
+ ta = g_value_get_long (_gtk_file_system_model_get_value (fs_model, a, MODEL_COL_MTIME));
+ tb = g_value_get_long (_gtk_file_system_model_get_value (fs_model, b, MODEL_COL_MTIME));
- return ta.tv_sec > tb.tv_sec ? -1 : (ta.tv_sec == tb.tv_sec ? 0 : 1);
+ return ta > tb ? -1 : (ta == tb ? 0 : 1);
}
}
list_sort_column_changed_cb (GtkTreeSortable *sortable,
GtkFileChooserDefault *impl)
{
+ gint sort_column_id;
GtkSortType sort_type;
- if (gtk_tree_sortable_get_sort_column_id (sortable, NULL, &sort_type))
- impl->list_sort_ascending = (sort_type == GTK_SORT_ASCENDING);
+ if (gtk_tree_sortable_get_sort_column_id (sortable, &sort_column_id, &sort_type))
+ {
+ impl->list_sort_ascending = (sort_type == GTK_SORT_ASCENDING);
+ impl->sort_column = sort_column_id;
+ impl->sort_order = sort_type;
+ }
}
static void
profile_start ("start", NULL);
g_assert (impl->browse_files_model != NULL);
- g_assert (impl->sort_model == NULL);
-
- profile_msg (" gtk_tree_model_sort_new_with_model start", NULL);
- impl->sort_model = (GtkTreeModelSort *)gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (impl->browse_files_model));
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_NAME, name_sort_func, impl, NULL);
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_SIZE, size_sort_func, impl, NULL);
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_MTIME, mtime_sort_func, impl, NULL);
- gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (impl->sort_model), NULL, NULL, NULL);
- gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (impl->sort_model), FILE_LIST_COL_NAME, GTK_SORT_ASCENDING);
- impl->list_sort_ascending = TRUE;
- profile_msg (" gtk_tree_model_sort_new_with_model end", NULL);
-
- g_signal_connect (impl->sort_model, "sort-column-changed",
- G_CALLBACK (list_sort_column_changed_cb), impl);
profile_msg (" gtk_tree_view_set_model start", NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
- GTK_TREE_MODEL (impl->sort_model));
+ GTK_TREE_MODEL (impl->browse_files_model));
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (impl->browse_files_tree_view));
gtk_tree_view_set_search_column (GTK_TREE_VIEW (impl->browse_files_tree_view),
- GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME);
+ MODEL_COL_NAME);
+ set_sort_column (impl);
profile_msg (" gtk_tree_view_set_model end", NULL);
+ impl->list_sort_ascending = TRUE;
profile_end ("end", NULL);
}
GtkTreeIter dummy_iter;
GtkTreeModel *tree_model;
- if (!impl->sort_model)
+ tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
+
+ if (!tree_model)
return;
path = gtk_tree_path_new_from_indices (0, -1);
- tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
/* If the list is empty, do nothing. */
if (gtk_tree_model_get_iter (tree_model, &dummy_iter, path))
gtk_tree_selection_selected_foreach (selection, center_selected_row_foreach_cb, &closure);
}
-struct ShowAndSelectPathsData
-{
- GtkFileChooserDefault *impl;
- GSList *files;
-};
-
-static void
-show_and_select_files_finished_loading (GtkFolder *folder,
- gpointer user_data)
+static gboolean
+show_and_select_files (GtkFileChooserDefault *impl,
+ GSList *files)
{
- gboolean have_hidden;
- gboolean have_filtered;
- GSList *l;
- struct ShowAndSelectPathsData *data = user_data;
-
- have_hidden = FALSE;
- have_filtered = FALSE;
-
- for (l = data->files; l; l = l->next)
- {
- GFile *file;
- GFileInfo *info;
-
- file = l->data;
-
- info = _gtk_folder_get_info (folder, file);
- if (info)
- {
- if (!have_hidden)
- have_hidden = g_file_info_get_is_hidden (info);
-
- if (!have_filtered)
- have_filtered = (g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY) &&
- get_is_file_filtered (data->impl, file, info);
-
- g_object_unref (info);
-
- if (have_hidden && have_filtered)
- break; /* we now have all the information we need */
- }
- }
-
- g_signal_handlers_disconnect_by_func (folder,
- show_and_select_files_finished_loading,
- user_data);
-
- if (have_hidden)
- g_object_set (data->impl, "show-hidden", TRUE, NULL);
+ GtkTreeSelection *selection;
+ GtkFileSystemModel *fsmodel;
+ gboolean can_have_hidden, can_have_filtered, selected_a_file;
+ GSList *walk;
- if (have_filtered)
- set_current_filter (data->impl, NULL);
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
+ fsmodel = GTK_FILE_SYSTEM_MODEL (gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view)));
+ can_have_hidden = !impl->show_hidden;
+ can_have_filtered = impl->current_filter != NULL;
+ selected_a_file = FALSE;
- for (l = data->files; l; l = l->next)
+ for (walk = files; walk && (can_have_hidden || can_have_filtered); walk = walk->next)
{
- GFile *file;
-
- file = l->data;
- _gtk_file_system_model_path_do (data->impl->browse_files_model, file,
- select_func, data->impl);
- }
-
- browse_files_center_selected_row (data->impl);
-
- g_object_unref (data->impl);
- g_slist_foreach (data->files, (GFunc) g_object_unref, NULL);
- g_slist_free (data->files);
- g_free (data);
-}
-
-static void
-show_and_select_files_get_folder_cb (GCancellable *cancellable,
- GtkFolder *folder,
- const GError *error,
- gpointer user_data)
-{
- gboolean cancelled = g_cancellable_is_cancelled (cancellable);
- struct ShowAndSelectPathsData *data = user_data;
-
- if (data->impl->show_and_select_files_cancellable != cancellable)
- goto out;
-
- data->impl->show_and_select_files_cancellable = NULL;
-
- if (cancelled || error)
- goto out;
-
- g_object_unref (cancellable);
-
- if (_gtk_folder_is_finished_loading (folder))
- show_and_select_files_finished_loading (folder, user_data);
- else
- g_signal_connect (folder, "finished-loading",
- G_CALLBACK (show_and_select_files_finished_loading),
- user_data);
-
- return;
-
-out:
- g_object_unref (data->impl);
- g_slist_foreach (data->files, (GFunc) g_object_unref, NULL);
- g_slist_free (data->files);
- g_free (data);
+ GFile *file = walk->data;
+ GtkTreeIter iter;
- g_object_unref (cancellable);
-}
+ if (!_gtk_file_system_model_get_iter_for_file (fsmodel, &iter, file))
+ continue;
-static gboolean
-show_and_select_files (GtkFileChooserDefault *impl,
- GFile *parent_file,
- GSList *files,
- GError **error)
-{
- struct ShowAndSelectPathsData *info;
+ if (!_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
+ {
+ GFileInfo *info = _gtk_file_system_model_get_info (fsmodel, &iter);
- profile_start ("start", NULL);
+ if (can_have_hidden &&
+ (g_file_info_get_is_hidden (info) ||
+ g_file_info_get_is_backup (info)))
+ {
+ g_object_set (impl, "show-hidden", TRUE, NULL);
+ can_have_hidden = FALSE;
+ }
- if (!files)
- {
- profile_end ("end", NULL);
- return TRUE;
+ if (can_have_filtered)
+ {
+ set_current_filter (impl, NULL);
+ can_have_filtered = FALSE;
+ }
+ }
+
+ if (_gtk_file_system_model_iter_is_visible (fsmodel, &iter))
+ {
+ gtk_tree_selection_select_iter (selection, &iter);
+ selected_a_file = TRUE;
+ }
}
- info = g_new (struct ShowAndSelectPathsData, 1);
- info->impl = g_object_ref (impl);
- info->files = g_slist_copy (files);
- g_slist_foreach (info->files, (GFunc) g_object_ref, NULL);
-
- if (impl->show_and_select_files_cancellable)
- g_cancellable_cancel (impl->show_and_select_files_cancellable);
-
- impl->show_and_select_files_cancellable =
- _gtk_file_system_get_folder (impl->file_system, parent_file,
- "standard::is-hidden,standard::type,standard::name,standard::content-type",
- show_and_select_files_get_folder_cb, info);
+ browse_files_center_selected_row (impl);
- profile_end ("end", NULL);
- return TRUE;
+ return selected_a_file;
}
/* Processes the pending operation when a folder is finished loading */
{
g_assert (impl->load_state == LOAD_FINISHED);
g_assert (impl->browse_files_model != NULL);
- g_assert (impl->sort_model != NULL);
if (impl->pending_select_files)
{
- /* NULL GError */
- show_and_select_files (impl, impl->current_folder, impl->pending_select_files, NULL);
+ show_and_select_files (impl, impl->pending_select_files);
pending_select_files_free (impl);
browse_files_center_selected_row (impl);
}
* that case, the chooser's selection should be what the caller expects,
* as the user can't see that something else got selected. See bug #165264.
*/
- if (GTK_WIDGET_MAPPED (impl) && impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
+ if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN &&
+ gtk_widget_get_mapped (GTK_WIDGET (impl)))
browse_files_select_first_row (impl);
}
g_assert (impl->pending_select_files == NULL);
}
+static void
+show_error_on_reading_current_folder (GtkFileChooserDefault *impl, GError *error)
+{
+ GFileInfo *info;
+ char *msg;
+
+ info = g_file_query_info (impl->current_folder,
+ G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
+ G_FILE_QUERY_INFO_NONE,
+ NULL,
+ NULL);
+ if (info)
+ {
+ msg = g_strdup_printf (_("Could not read the contents of %s"), g_file_info_get_display_name (info));
+ g_object_unref (info);
+ }
+ else
+ msg = g_strdup (_("Could not read the contents of the folder"));
+
+ error_message (impl, msg, error->message);
+ g_free (msg);
+}
+
/* Callback used when the file system model finishes loading */
static void
browse_files_model_finished_loading_cb (GtkFileSystemModel *model,
+ GError *error,
GtkFileChooserDefault *impl)
{
profile_start ("start", NULL);
+ if (error)
+ show_error_on_reading_current_folder (impl, error);
+
if (impl->load_state == LOAD_PRELOAD)
{
load_remove_timer (impl);
}
static void
-stop_loading_and_clear_list_model (GtkFileChooserDefault *impl)
+stop_loading_and_clear_list_model (GtkFileChooserDefault *impl,
+ gboolean remove_from_treeview)
{
load_remove_timer (impl); /* This changes the state to LOAD_EMPTY */
impl->browse_files_model = NULL;
}
- if (impl->sort_model)
- {
- g_object_unref (impl->sort_model);
- impl->sort_model = NULL;
- }
-
- gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
+ if (remove_from_treeview)
+ gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
}
-/* Gets rid of the old list model and creates a new one for the current folder */
-static gboolean
-set_list_model (GtkFileChooserDefault *impl,
- GError **error)
+static char *
+my_g_format_time_for_display (glong secs)
{
- g_assert (impl->current_folder != NULL);
+ GDate mtime, now;
+ gint days_diff;
+ struct tm tm_mtime;
+ time_t time_mtime, time_now;
+ const gchar *format;
+ gchar *locale_format = NULL;
+ gchar buf[256];
+ char *date_str = NULL;
+#ifdef G_OS_WIN32
+ const char *locale, *dot = NULL;
+ gint64 codepage = -1;
+ char charset[20];
+#endif
- profile_start ("start", NULL);
+ time_mtime = secs;
+
+#ifdef HAVE_LOCALTIME_R
+ localtime_r ((time_t *) &time_mtime, &tm_mtime);
+#else
+ {
+ struct tm *ptm = localtime ((time_t *) &time_mtime);
- stop_loading_and_clear_list_model (impl);
+ if (!ptm)
+ {
+ g_warning ("ptm != NULL failed");
+
+ return g_strdup (_("Unknown"));
+ }
+ else
+ memcpy ((void *) &tm_mtime, (void *) ptm, sizeof (struct tm));
+ }
+#endif /* HAVE_LOCALTIME_R */
- set_busy_cursor (impl, TRUE);
- gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
+ g_date_set_time_t (&mtime, time_mtime);
+ time_now = time (NULL);
+ g_date_set_time_t (&now, time_now);
- impl->browse_files_model = _gtk_file_system_model_new (impl->file_system,
- impl->current_folder, 0,
- "standard,time,thumbnail::*",
- error);
- if (!impl->browse_files_model)
+ days_diff = g_date_get_julian (&now) - g_date_get_julian (&mtime);
+
+ /* Translators: %H means "hours" and %M means "minutes" */
+ if (days_diff == 0)
+ format = _("%H:%M");
+ else if (days_diff == 1)
+ format = _("Yesterday at %H:%M");
+ else
{
- set_busy_cursor (impl, FALSE);
- profile_end ("end", NULL);
- return FALSE;
+ if (days_diff > 1 && days_diff < 7)
+ format = "%A"; /* Days from last week */
+ else
+ format = "%x"; /* Any other date */
}
- load_setup_timer (impl); /* This changes the state to LOAD_PRELOAD */
-
- g_signal_connect (impl->browse_files_model, "finished-loading",
- G_CALLBACK (browse_files_model_finished_loading_cb), impl);
+#ifdef G_OS_WIN32
+ /* g_locale_from_utf8() returns a string in the system
+ * code-page, which is not always the same as that used by the C
+ * library. For instance when running a GTK+ program with
+ * LANG=ko on an English version of Windows, the system
+ * code-page is 1252, but the code-page used by the C library is
+ * 949. (It's GTK+ itself that sets the C library locale when it
+ * notices the LANG environment variable. See gtkmain.c The
+ * Microsoft C library doesn't look at any locale environment
+ * variables.) We need to pass strftime() a string in the C
+ * library's code-page. See bug #509885.
+ */
+ locale = setlocale (LC_ALL, NULL);
+ if (locale != NULL)
+ dot = strchr (locale, '.');
+ if (dot != NULL)
+ {
+ codepage = g_ascii_strtoll (dot+1, NULL, 10);
+
+ /* All codepages should fit in 16 bits AFAIK */
+ if (codepage > 0 && codepage < 65536)
+ {
+ sprintf (charset, "CP%u", (guint) codepage);
+ locale_format = g_convert (format, -1, charset, "UTF-8", NULL, NULL, NULL);
+ }
+ }
+#else
+ locale_format = g_locale_from_utf8 (format, -1, NULL, NULL, NULL);
+#endif
+ if (locale_format != NULL &&
+ strftime (buf, sizeof (buf), locale_format, &tm_mtime) != 0)
+ {
+#ifdef G_OS_WIN32
+ /* As above but in opposite direction... */
+ if (codepage > 0 && codepage < 65536)
+ date_str = g_convert (buf, -1, "UTF-8", charset, NULL, NULL, NULL);
+#else
+ date_str = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
+#endif
+ }
- _gtk_file_system_model_set_show_hidden (impl->browse_files_model, impl->show_hidden);
+ if (date_str == NULL)
+ date_str = g_strdup (_("Unknown"));
- install_list_model_filter (impl);
+ g_free (locale_format);
+ return date_str;
+}
- profile_end ("end", NULL);
+static void
+copy_attribute (GFileInfo *to, GFileInfo *from, const char *attribute)
+{
+ GFileAttributeType type;
+ gpointer value;
- return TRUE;
+ if (g_file_info_get_attribute_data (from, attribute, &type, &value, NULL))
+ g_file_info_set_attribute (to, attribute, type, value);
}
-struct update_chooser_entry_selected_foreach_closure {
- int num_selected;
- GtkTreeIter first_selected_iter;
-};
-
-static gint
-compare_utf8_filenames (const gchar *a,
- const gchar *b)
+static void
+file_system_model_got_thumbnail (GObject *object, GAsyncResult *res, gpointer data)
{
- gchar *a_folded, *b_folded;
- gint retval;
+ GtkFileSystemModel *model = data; /* might be unreffed if operation was cancelled */
+ GFile *file = G_FILE (object);
+ GFileInfo *queried, *info;
+ GtkTreeIter iter;
- a_folded = g_utf8_strdown (a, -1);
- b_folded = g_utf8_strdown (b, -1);
+ queried = g_file_query_info_finish (file, res, NULL);
+ if (queried == NULL)
+ return;
- retval = strcmp (a_folded, b_folded);
+ /* now we know model is valid */
- g_free (a_folded);
- g_free (b_folded);
+ /* file was deleted */
+ if (!_gtk_file_system_model_get_iter_for_file (model, &iter, file))
+ return;
- return retval;
+ info = g_file_info_dup (_gtk_file_system_model_get_info (model, &iter));
+
+ copy_attribute (info, queried, G_FILE_ATTRIBUTE_THUMBNAIL_PATH);
+ copy_attribute (info, queried, G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
+ copy_attribute (info, queried, G_FILE_ATTRIBUTE_STANDARD_ICON);
+
+ _gtk_file_system_model_update_file (model, file, info, FALSE);
+
+ g_object_unref (info);
}
-static void
+static gboolean
+file_system_model_set (GtkFileSystemModel *model,
+ GFile *file,
+ GFileInfo *info,
+ int column,
+ GValue *value,
+ gpointer data)
+{
+ GtkFileChooserDefault *impl = data;
+
+ switch (column)
+ {
+ case MODEL_COL_FILE:
+ g_value_set_object (value, file);
+ break;
+ case MODEL_COL_NAME:
+ if (info == NULL)
+ g_value_set_string (value, DEFAULT_NEW_FOLDER_NAME);
+ else
+ g_value_set_string (value, g_file_info_get_display_name (info));
+ break;
+ case MODEL_COL_NAME_COLLATED:
+ if (info == NULL)
+ g_value_take_string (value, g_utf8_collate_key_for_filename (DEFAULT_NEW_FOLDER_NAME, -1));
+ else
+ g_value_take_string (value, g_utf8_collate_key_for_filename (g_file_info_get_display_name (info), -1));
+ break;
+ case MODEL_COL_IS_FOLDER:
+ g_value_set_boolean (value, info == NULL || _gtk_file_info_consider_as_directory (info));
+ break;
+ case MODEL_COL_PIXBUF:
+ if (info)
+ {
+ if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_ICON))
+ {
+ g_value_take_object (value, _gtk_file_info_render_icon (info, GTK_WIDGET (impl), impl->icon_size));
+ }
+ else
+ {
+ GtkTreeModel *tree_model;
+ GtkTreePath *path, *start, *end;
+ GtkTreeIter iter;
+
+ if (impl->browse_files_tree_view == NULL ||
+ g_file_info_has_attribute (info, "filechooser::queried"))
+ return FALSE;
+
+ tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
+ if (tree_model != GTK_TREE_MODEL (model))
+ return FALSE;
+
+ if (!_gtk_file_system_model_get_iter_for_file (model,
+ &iter,
+ file))
+ g_assert_not_reached ();
+ if (!gtk_tree_view_get_visible_range (GTK_TREE_VIEW (impl->browse_files_tree_view), &start, &end))
+ return FALSE;
+ path = gtk_tree_model_get_path (tree_model, &iter);
+ if (gtk_tree_path_compare (start, path) != 1 &&
+ gtk_tree_path_compare (path, end) != 1)
+ {
+ g_file_info_set_attribute_boolean (info, "filechooser::queried", TRUE);
+ g_file_query_info_async (file,
+ G_FILE_ATTRIBUTE_THUMBNAIL_PATH ","
+ G_FILE_ATTRIBUTE_THUMBNAILING_FAILED ","
+ G_FILE_ATTRIBUTE_STANDARD_ICON,
+ G_FILE_QUERY_INFO_NONE,
+ G_PRIORITY_DEFAULT,
+ _gtk_file_system_model_get_cancellable (model),
+ file_system_model_got_thumbnail,
+ model);
+ }
+ gtk_tree_path_free (path);
+ gtk_tree_path_free (start);
+ gtk_tree_path_free (end);
+ return FALSE;
+ }
+ }
+ else
+ g_value_set_object (value, NULL);
+ break;
+ case MODEL_COL_SIZE:
+ g_value_set_int64 (value, info ? g_file_info_get_size (info) : 0);
+ break;
+ case MODEL_COL_SIZE_TEXT:
+ if (info == NULL || _gtk_file_info_consider_as_directory (info))
+ g_value_set_string (value, NULL);
+ else
+ g_value_take_string (value, g_format_size_for_display (g_file_info_get_size (info)));
+ break;
+ case MODEL_COL_MTIME:
+ case MODEL_COL_MTIME_TEXT:
+ {
+ GTimeVal tv;
+ if (info == NULL)
+ break;
+ g_file_info_get_modification_time (info, &tv);
+ if (column == MODEL_COL_MTIME)
+ g_value_set_long (value, tv.tv_sec);
+ else if (tv.tv_sec == 0)
+ g_value_set_static_string (value, _("Unknown"));
+ else
+ g_value_take_string (value, my_g_format_time_for_display (tv.tv_sec));
+ break;
+ }
+ case MODEL_COL_ELLIPSIZE:
+ g_value_set_enum (value, info ? PANGO_ELLIPSIZE_END : PANGO_ELLIPSIZE_NONE);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ return TRUE;
+}
+
+/* Gets rid of the old list model and creates a new one for the current folder */
+static gboolean
+set_list_model (GtkFileChooserDefault *impl,
+ GError **error)
+{
+ g_assert (impl->current_folder != NULL);
+
+ profile_start ("start", NULL);
+
+ stop_loading_and_clear_list_model (impl, TRUE);
+
+ set_busy_cursor (impl, TRUE);
+
+ impl->browse_files_model =
+ _gtk_file_system_model_new_for_directory (impl->current_folder,
+ MODEL_ATTRIBUTES,
+ file_system_model_set,
+ impl,
+ MODEL_COLUMN_TYPES);
+
+ _gtk_file_system_model_set_show_hidden (impl->browse_files_model, impl->show_hidden);
+
+ profile_msg (" set sort function", NULL);
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_NAME, name_sort_func, impl, NULL);
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_SIZE, size_sort_func, impl, NULL);
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), MODEL_COL_MTIME, mtime_sort_func, impl, NULL);
+ gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (impl->browse_files_model), NULL, NULL, NULL);
+ set_sort_column (impl);
+ impl->list_sort_ascending = TRUE;
+ g_signal_connect (impl->browse_files_model, "sort-column-changed",
+ G_CALLBACK (list_sort_column_changed_cb), impl);
+
+ load_setup_timer (impl); /* This changes the state to LOAD_PRELOAD */
+
+ g_signal_connect (impl->browse_files_model, "finished-loading",
+ G_CALLBACK (browse_files_model_finished_loading_cb), impl);
+
+ install_list_model_filter (impl);
+
+ profile_end ("end", NULL);
+
+ return TRUE;
+}
+
+struct update_chooser_entry_selected_foreach_closure {
+ int num_selected;
+ GtkTreeIter first_selected_iter;
+};
+
+static gint
+compare_utf8_filenames (const gchar *a,
+ const gchar *b)
+{
+ gchar *a_folded, *b_folded;
+ gint retval;
+
+ a_folded = g_utf8_strdown (a, -1);
+ b_folded = g_utf8_strdown (b, -1);
+
+ retval = strcmp (a_folded, b_folded);
+
+ g_free (a_folded);
+ g_free (b_folded);
+
+ return retval;
+}
+
+static void
update_chooser_entry_selected_foreach (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
}
else if (closure.num_selected == 1)
{
- GtkTreeIter child_iter;
-
if (impl->operation_mode == OPERATION_MODE_BROWSE)
{
GFileInfo *info;
gboolean change_entry;
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
- &child_iter,
- &closure.first_selected_iter);
-
- info = _gtk_file_system_model_get_info (impl->browse_files_model, &child_iter);
+ info = _gtk_file_system_model_get_info (impl->browse_files_model, &closure.first_selected_iter);
/* If the cursor moved to the row of the newly created folder,
* retrieving info will return NULL.
impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
{
/* We don't want the name to change when clicking on a folder... */
- change_entry = (g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY);
+ change_entry = (! _gtk_file_info_consider_as_directory (info));
}
else
change_entry = TRUE; /* ... unless we are in SELECT_FOLDER mode */
GError *original_error;
};
+static void
+update_current_folder_mount_enclosing_volume_cb (GCancellable *cancellable,
+ GtkFileSystemVolume *volume,
+ const GError *error,
+ gpointer user_data)
+{
+ gboolean cancelled = g_cancellable_is_cancelled (cancellable);
+ struct UpdateCurrentFolderData *data = user_data;
+ GtkFileChooserDefault *impl = data->impl;
+
+ if (cancellable != impl->update_current_folder_cancellable)
+ goto out;
+
+ impl->update_current_folder_cancellable = NULL;
+ set_busy_cursor (impl, FALSE);
+
+ if (cancelled)
+ goto out;
+
+ if (error)
+ {
+ error_changing_folder_dialog (data->impl, data->file, g_error_copy (error));
+ impl->reload_state = RELOAD_EMPTY;
+ goto out;
+ }
+
+ change_folder_and_display_error (impl, data->file, data->clear_entry);
+
+out:
+ g_object_unref (data->file);
+ g_free (data);
+
+ g_object_unref (cancellable);
+}
+
static void
update_current_folder_get_info_cb (GCancellable *cancellable,
GFileInfo *info,
{
GFile *parent_file;
+ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED))
+ {
+ GMountOperation *mount_operation;
+ GtkWidget *toplevel;
+
+ g_object_unref (cancellable);
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (impl));
+
+ mount_operation = gtk_mount_operation_new (GTK_WINDOW (toplevel));
+
+ set_busy_cursor (impl, TRUE);
+
+ impl->update_current_folder_cancellable =
+ _gtk_file_system_mount_enclosing_volume (impl->file_system, data->file,
+ mount_operation,
+ update_current_folder_mount_enclosing_volume_cb,
+ data);
+
+ return;
+ }
+
if (!data->original_file)
{
data->original_file = g_object_ref (data->file);
}
else
{
- /* error and bail out */
- error_changing_folder_dialog (impl, data->original_file, data->original_error);
+ /* Error and bail out, ignoring "not found" errors since they're useless:
+ * they only happen when a program defaults to a folder that has been (re)moved.
+ */
+ if (!g_error_matches (data->original_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ error_changing_folder_dialog (impl, data->original_file, data->original_error);
+ else
+ g_error_free (data->original_error);
+
g_object_unref (data->original_file);
goto out;
if (data->original_file)
{
- error_changing_folder_dialog (impl, data->original_file, data->original_error);
+ /* Error and bail out, ignoring "not found" errors since they're useless:
+ * they only happen when a program defaults to a folder that has been (re)moved.
+ */
+ if (!g_error_matches (data->original_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ error_changing_folder_dialog (impl, data->original_file, data->original_error);
+ else
+ g_error_free (data->original_error);
g_object_unref (data->original_file);
}
- if (g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY)
+ if (! _gtk_file_info_consider_as_directory (info))
goto out;
if (!_gtk_path_bar_set_file (GTK_PATH_BAR (impl->browse_path_bar), data->file, data->keep_trail, NULL))
g_object_unref (impl->current_folder);
impl->current_folder = g_object_ref (data->file);
-
- impl->reload_state = RELOAD_HAS_FOLDER;
}
+ impl->reload_state = RELOAD_HAS_FOLDER;
+
/* Update the widgets that may trigger a folder change themselves. */
if (!impl->changing_folder)
_gtk_file_chooser_entry_set_file_part (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), name);
}
-static void
-select_func (GtkFileSystemModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeSelection *selection;
- GtkTreeIter sorted_iter;
-
- selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
-
- gtk_tree_model_sort_convert_child_iter_to_iter (impl->sort_model, &sorted_iter, iter);
- gtk_tree_selection_select_iter (selection, &sorted_iter);
-}
-
static gboolean
gtk_file_chooser_default_select_file (GtkFileChooser *chooser,
GFile *file,
files.data = (gpointer) file;
files.next = NULL;
- result = show_and_select_files (impl, parent_file, &files, error);
+ result = show_and_select_files (impl, &files);
g_object_unref (parent_file);
return result;
}
return TRUE;
}
-static void
-unselect_func (GtkFileSystemModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeView *tree_view = GTK_TREE_VIEW (impl->browse_files_tree_view);
- GtkTreePath *sorted_path;
-
- sorted_path = gtk_tree_model_sort_convert_child_path_to_path (impl->sort_model,
- path);
- gtk_tree_selection_unselect_path (gtk_tree_view_get_selection (tree_view),
- sorted_path);
- gtk_tree_path_free (sorted_path);
-}
-
static void
gtk_file_chooser_default_unselect_file (GtkFileChooser *chooser,
GFile *file)
{
GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
+ GtkTreeView *tree_view = GTK_TREE_VIEW (impl->browse_files_tree_view);
+ GtkTreeIter iter;
if (!impl->browse_files_model)
return;
- _gtk_file_system_model_path_do (impl->browse_files_model, file,
- unselect_func, impl);
+ if (!_gtk_file_system_model_get_iter_for_file (impl->browse_files_model,
+ &iter,
+ file))
+ return;
+
+ gtk_tree_selection_unselect_iter (gtk_tree_view_get_selection (tree_view),
+ &iter);
}
static gboolean
{
GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (data);
GtkTreeSelection *selection;
- GFileInfo *info;
gboolean is_folder;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
- info = get_list_file_info (impl, iter);
- is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
+ gtk_tree_model_get (model, iter,
+ MODEL_COL_IS_FOLDER, &is_folder,
+ -1);
if ((is_folder && impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ||
(!is_folder && impl->action == GTK_FILE_CHOOSER_ACTION_OPEN))
}
if (impl->select_multiple)
- gtk_tree_model_foreach (GTK_TREE_MODEL (impl->sort_model),
+ gtk_tree_model_foreach (GTK_TREE_MODEL (impl->browse_files_model),
maybe_select, impl);
}
struct get_files_closure *info;
GFile *file;
GtkFileSystemModel *fs_model;
- GtkTreeIter sel_iter;
info = data;
fs_model = info->impl->browse_files_model;
- gtk_tree_model_sort_convert_iter_to_child_iter (info->impl->sort_model, &sel_iter, iter);
- file = _gtk_file_system_model_get_file (fs_model, &sel_iter);
+ file = _gtk_file_system_model_get_file (fs_model, iter);
if (!file)
return; /* We are on the editable row */
data->impl->loading_shortcuts = g_slist_remove (data->impl->loading_shortcuts, cancellable);
- if (cancelled || error || g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY)
+ if (cancelled || error || (! _gtk_file_info_consider_as_directory (info)))
goto out;
pos = shortcuts_get_pos_for_shortcut_folder (data->impl, data->impl->num_shortcuts);
|| impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
|| impl->expand_folders)
{
+ GtkFileChooserSettings *settings;
+ int x, y, width, height;
+
+ settings = _gtk_file_chooser_settings_new ();
+ _gtk_file_chooser_settings_get_geometry (settings, &x, &y, &width, &height);
+ g_object_unref (settings);
+
+ if (x >= 0 && y >= 0 && width > 0 && height > 0)
+ {
+ *default_width = width;
+ *default_height = height;
+ return;
+ }
+
find_good_size_from_style (GTK_WIDGET (chooser_embed), default_width, default_height);
if (impl->preview_widget_active &&
impl->preview_widget &&
- GTK_WIDGET_VISIBLE (impl->preview_widget))
+ gtk_widget_get_visible (impl->preview_widget))
{
gtk_widget_size_request (impl->preview_box, &req);
*default_width += PREVIEW_HBOX_SPACING + req.width;
}
if (impl->extra_widget &&
- GTK_WIDGET_VISIBLE (impl->extra_widget))
+ gtk_widget_get_visible (impl->extra_widget))
{
gtk_widget_size_request (impl->extra_align, &req);
*default_height += GTK_BOX (chooser_embed)->spacing + req.height;
gpointer data)
{
struct switch_folder_closure *closure;
- GtkTreeIter child_iter;
closure = data;
- gtk_tree_model_sort_convert_iter_to_child_iter (closure->impl->sort_model, &child_iter, iter);
-
- closure->file = _gtk_file_system_model_get_file (closure->impl->browse_files_model, &child_iter);
+ closure->file = _gtk_file_system_model_get_file (closure->impl->browse_files_model, iter);
closure->num_selected++;
}
gboolean *had_selection)
{
GtkTreeSelection *selection;
- GtkTreeIter iter, child_iter;
+ GtkTreeIter iter;
GFileInfo *info;
g_assert (!impl->select_multiple);
*had_selection = TRUE;
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
- &child_iter,
- &iter);
-
- info = _gtk_file_system_model_get_info (impl->browse_files_model, &child_iter);
+ info = _gtk_file_system_model_get_info (impl->browse_files_model, &iter);
return info;
}
GtkWidget *button;
button = gtk_button_new_with_mnemonic (mnemonic_label);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON));
gtk_widget_show (button);
if (!info)
parent_is_folder = FALSE;
else
- parent_is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
+ parent_is_folder = _gtk_file_info_consider_as_directory (info);
if (parent_is_folder)
{
if (data->file_exists_and_is_not_folder)
{
gboolean retval;
- const char *file_part;
+ char *file_part;
- file_part = _gtk_file_chooser_entry_get_file_part (GTK_FILE_CHOOSER_ENTRY (data->impl->location_entry));
+ /* Dup the string because the string may be modified
+ * depending on what clients do in the confirm-overwrite
+ * signal and this corrupts the pointer
+ */
+ file_part = g_strdup (_gtk_file_chooser_entry_get_file_part (GTK_FILE_CHOOSER_ENTRY (data->impl->location_entry)));
retval = should_respond_after_confirm_overwrite (data->impl, file_part, data->parent_file);
+ g_free (file_part);
if (retval)
g_signal_emit_by_name (data->impl, "response-requested");
if (cancelled)
goto out;
- file_exists_and_is_not_folder = info && (g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY);
+ file_exists_and_is_not_folder = info && (! _gtk_file_info_consider_as_directory (info));
if (data->impl->action == GTK_FILE_CHOOSER_ACTION_OPEN)
/* user typed a filename; we are done */
list = data;
- gtk_tree_model_get (model, iter, SEARCH_MODEL_COL_FILE, &file, -1);
+ gtk_tree_model_get (model, iter, MODEL_COL_FILE, &file, -1);
*list = g_slist_prepend (*list, g_object_ref (file));
}
return (gtk_tree_selection_count_selected_rows (selection) != 0);
}
-struct SearchHitInsertRequest
-{
- GtkFileChooserDefault *impl;
- GFile *file;
- GtkTreeRowReference *row_ref;
-};
-
-static void
-search_hit_get_info_cb (GCancellable *cancellable,
- GFileInfo *info,
- const GError *error,
- gpointer data)
-{
- gboolean cancelled = g_cancellable_is_cancelled (cancellable);
- GdkPixbuf *pixbuf = NULL;
- GtkTreePath *path;
- GtkTreeIter iter;
- GCancellable *model_cancellable;
- gboolean is_folder = FALSE;
- GTimeVal mtime;
- guint64 modification_time = 0;
- goffset size;
- char *mime_type;
- char *display_name;
- struct SearchHitInsertRequest *request = data;
-
- if (!request->impl->search_model)
- goto out;
-
- path = gtk_tree_row_reference_get_path (request->row_ref);
- if (!path)
- goto out;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (request->impl->search_model),
- &iter, path);
- gtk_tree_path_free (path);
-
- gtk_tree_model_get (GTK_TREE_MODEL (request->impl->search_model), &iter,
- SEARCH_MODEL_COL_CANCELLABLE, &model_cancellable,
- -1);
- if (cancellable != model_cancellable)
- goto out;
-
- /* set the cancellable to NULL in the model */
- gtk_list_store_set (request->impl->search_model, &iter,
- SEARCH_MODEL_COL_CANCELLABLE, NULL,
- -1);
-
- if (cancelled)
- goto out;
-
- if (!info)
- {
- search_clear_model_row (GTK_TREE_MODEL (request->impl->search_model), &iter);
- gtk_list_store_remove (request->impl->search_model, &iter);
- goto out;
- }
-
- display_name = g_strdup (g_file_info_get_display_name (info));
- mime_type = g_content_type_get_mime_type (g_file_info_get_content_type (info));
- g_file_info_get_modification_time (info, &mtime);
- modification_time = (guint64) mtime.tv_sec;
- size = g_file_info_get_size (info);
- is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
- pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (request->impl),
- request->impl->icon_size);
-
- gtk_list_store_set (request->impl->search_model, &iter,
- SEARCH_MODEL_COL_PIXBUF, pixbuf,
- SEARCH_MODEL_COL_DISPLAY_NAME, display_name,
- SEARCH_MODEL_COL_MIME_TYPE, mime_type,
- SEARCH_MODEL_COL_IS_FOLDER, is_folder,
- SEARCH_MODEL_COL_MTIME, modification_time,
- SEARCH_MODEL_COL_SIZE, size,
- -1);
-
- if (pixbuf)
- g_object_unref (pixbuf);
-
-out:
- g_object_unref (request->impl);
- g_object_unref (request->file);
- gtk_tree_row_reference_free (request->row_ref);
- g_free (request);
-
- g_object_unref (cancellable);
-}
-
/* Adds one hit from the search engine to the search_model */
static void
search_add_hit (GtkFileChooserDefault *impl,
gchar *uri)
{
GFile *file;
- char *tmp;
- char *collation_key;
- GtkTreeIter iter;
- GtkTreePath *p;
- GCancellable *cancellable;
- struct SearchHitInsertRequest *request;
file = g_file_new_for_uri (uri);
if (!file)
return;
}
- tmp = g_file_get_parse_name (file);
- collation_key = g_utf8_collate_key_for_filename (tmp, -1);
- g_free (tmp);
-
- request = g_new0 (struct SearchHitInsertRequest, 1);
- request->impl = g_object_ref (impl);
- request->file = g_object_ref (file);
-
- gtk_list_store_append (impl->search_model, &iter);
- p = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->search_model), &iter);
-
- request->row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (impl->search_model), p);
- gtk_tree_path_free (p);
+ _gtk_file_system_model_add_and_query_file (impl->search_model,
+ file,
+ MODEL_ATTRIBUTES);
- cancellable = _gtk_file_system_get_info (impl->file_system, file,
- "standard::type,"
- "standard::icon,"
- "standard::content-type,"
- "standard::display-name,"
- "time::modified,"
- "standard::size",
- search_hit_get_info_cb,
- request);
-
- gtk_list_store_set (impl->search_model, &iter,
- SEARCH_MODEL_COL_FILE, file,
- SEARCH_MODEL_COL_COLLATION_KEY, collation_key,
- SEARCH_MODEL_COL_CANCELLABLE, cancellable,
- -1);
+ g_object_unref (file);
}
/* Callback used from GtkSearchEngine when we get new hits */
* but it'll make the search look like blocked.
*/
gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
- GTK_TREE_MODEL (impl->search_model_filter));
+ GTK_TREE_MODEL (impl->search_model));
#endif
/* FMQ: if search was empty, say that we got no hits */
set_busy_cursor (impl, FALSE);
}
-static void
-search_clear_model_row (GtkTreeModel *model,
- GtkTreeIter *iter)
-{
- GFile *file;
- gchar *display_name;
- gchar *collation_key;
- GCancellable *cancellable;
- gchar *mime_type;
-
- gtk_tree_model_get (model, iter,
- SEARCH_MODEL_COL_FILE, &file,
- SEARCH_MODEL_COL_DISPLAY_NAME, &display_name,
- SEARCH_MODEL_COL_COLLATION_KEY, &collation_key,
- SEARCH_MODEL_COL_CANCELLABLE, &cancellable,
- SEARCH_MODEL_COL_MIME_TYPE, &mime_type,
- -1);
-
- if (file)
- g_object_unref (file);
-
- g_free (display_name);
- g_free (collation_key);
- g_free (mime_type);
-
- if (cancellable)
- g_cancellable_cancel (cancellable);
-}
-
/* Frees the data in the search_model */
static void
search_clear_model (GtkFileChooserDefault *impl,
gboolean remove_from_treeview)
{
- GtkTreeModel *model;
- GtkTreeIter iter;
-
if (!impl->search_model)
return;
- model = GTK_TREE_MODEL (impl->search_model);
-
- if (gtk_tree_model_get_iter_first (model, &iter))
- do
- {
- search_clear_model_row (model, &iter);
- }
- while (gtk_tree_model_iter_next (model, &iter));
-
g_object_unref (impl->search_model);
impl->search_model = NULL;
- g_object_unref (impl->search_model_filter);
- impl->search_model_filter = NULL;
-
- g_object_unref (impl->search_model_sort);
- impl->search_model_sort = NULL;
-
if (remove_from_treeview)
gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
}
impl->search_entry = NULL;
gtk_widget_show (impl->browse_path_bar);
- gtk_widget_show (impl->browse_new_folder_button);
+ if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN || !impl->create_folders)
+ gtk_widget_hide (impl->browse_new_folder_button);
+ else
+ gtk_widget_show (impl->browse_new_folder_button);
+
if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
file_list_set_sort_column_ids (impl);
}
-/* Sort callback from the path column */
-static gint
-search_column_path_sort_func (GtkTreeModel *model,
- GtkTreeIter *a,
- GtkTreeIter *b,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeIter child_a, child_b;
- const char *collation_key_a, *collation_key_b;
- gboolean is_folder_a, is_folder_b;
-
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_a, a);
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_b, b);
-
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_a,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder_a,
- SEARCH_MODEL_COL_COLLATION_KEY, &collation_key_a,
- -1);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_b,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder_b,
- SEARCH_MODEL_COL_COLLATION_KEY, &collation_key_b,
- -1);
-
- if (!collation_key_a)
- return 1;
-
- if (!collation_key_b)
- return -1;
-
- /* always show folders first */
- if (is_folder_a != is_folder_b)
- return is_folder_a ? 1 : -1;
-
- return strcmp (collation_key_a, collation_key_b);
-}
-
-/* Sort callback from the size column */
-static gint
-search_column_size_sort_func (GtkTreeModel *model,
- GtkTreeIter *a,
- GtkTreeIter *b,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeIter child_a, child_b;
- gboolean is_folder_a, is_folder_b;
- goffset size_a, size_b;
-
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_a, a);
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_b, b);
-
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_a,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder_a,
- SEARCH_MODEL_COL_SIZE, &size_a,
- -1);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_b,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder_b,
- SEARCH_MODEL_COL_SIZE, &size_b,
- -1);
-
- if (is_folder_a != is_folder_b)
- return is_folder_a ? 1 : -1;
-
- if (size_a < size_b)
- return -1;
- else if (size_a > size_b)
- return 1;
- else
- return 0;
-}
-
-/* Sort callback from the modification time column */
-static gint
-search_column_mtime_sort_func (GtkTreeModel *model,
- GtkTreeIter *a,
- GtkTreeIter *b,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeIter child_a, child_b;
- gboolean is_folder_a, is_folder_b;
- guint64 mtime_a, mtime_b;
-
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_a, a);
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_b, b);
-
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_a,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder_a,
- SEARCH_MODEL_COL_MTIME, &mtime_a,
- -1);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_b,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder_b,
- SEARCH_MODEL_COL_MTIME, &mtime_b,
- -1);
-
- if (is_folder_a != is_folder_b)
- return is_folder_a ? 1 : -1;
-
- if (mtime_a < mtime_b)
- return -1;
- else if (mtime_a > mtime_b)
- return 1;
- else
- return 0;
-}
-
-static gboolean
-search_get_is_filtered (GtkFileChooserDefault *impl,
- GFile *file,
- const gchar *display_name,
- const gchar *mime_type)
-{
- GtkFileFilterInfo filter_info;
- GtkFileFilterFlags needed;
- gboolean result;
-
- if (!impl->current_filter)
- return FALSE;
-
- filter_info.contains = GTK_FILE_FILTER_DISPLAY_NAME | GTK_FILE_FILTER_MIME_TYPE;
- needed = gtk_file_filter_get_needed (impl->current_filter);
-
- filter_info.display_name = display_name;
- filter_info.mime_type = mime_type;
-
- if (needed & GTK_FILE_FILTER_FILENAME)
- {
- filter_info.filename = g_file_get_path (file);
- if (filter_info.filename)
- filter_info.contains |= GTK_FILE_FILTER_FILENAME;
- }
- else
- filter_info.filename = NULL;
-
- if (needed & GTK_FILE_FILTER_URI)
- {
- filter_info.uri = g_file_get_uri (file);
- if (filter_info.uri)
- filter_info.contains |= GTK_FILE_FILTER_URI;
- }
- else
- filter_info.uri = NULL;
-
- result = gtk_file_filter_filter (impl->current_filter, &filter_info);
-
- if (filter_info.filename)
- g_free ((gchar *) filter_info.filename);
- if (filter_info.uri)
- g_free ((gchar *) filter_info.uri);
-
- return !result;
-
-}
-
-/* Visibility function for the recent filter model */
-static gboolean
-search_model_visible_func (GtkTreeModel *model,
- GtkTreeIter *iter,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GFile *file;
- gchar *display_name, *mime_type;
- gboolean is_folder;
-
- if (!impl->current_filter)
- return TRUE;
-
- gtk_tree_model_get (model, iter,
- SEARCH_MODEL_COL_FILE, &file,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- SEARCH_MODEL_COL_DISPLAY_NAME, &display_name,
- SEARCH_MODEL_COL_MIME_TYPE, &mime_type,
- -1);
-
- if (!display_name)
- return TRUE;
-
- if (is_folder)
- return TRUE;
-
- return !search_get_is_filtered (impl, file, display_name, mime_type);
-}
-
/* Creates the search_model and puts it in the tree view */
static void
search_setup_model (GtkFileChooserDefault *impl)
{
g_assert (impl->search_model == NULL);
- g_assert (impl->search_model_filter == NULL);
- g_assert (impl->search_model_sort == NULL);
- /* We store these columns in the search model:
- *
- * SEARCH_MODEL_COL_FILE - a GFile for the hit's URI, stored
- * as a pointer not as a G_TYPE_FILE
- * SEARCH_MODEL_COL_DISPLAY_NAME - a string with the display name, stored
- * as a pointer not as a G_TYPE_STRING
- * SEARCH_MODEL_COL_COLLATION_KEY - collation key for the filename, stored
- * as a pointer not as a G_TYPE_STRING
- * SEARCH_MODEL_COL_MTIME - G_TYPE_UINT64 for the modification time
- * SEARCH_MODEL_COL_SIZE - G_TYPE_INT64 for the size
- * SEARCH_MODEL_COL_CANCELLABLE - cancellable used when getting the hit's info
- * SEARCH_MODEL_COL_PIXBUF - GdkPixbuf for the hit's icon
- * SEARCH_MODEL_COL_MIME_TYPE - a string with the hit's MIME type
- * SEARCH_MODEL_COL_IS_FOLDER - a boolean flag for folders
- *
- * Keep this in sync with the enumeration defined near the beginning
- * of this file.
- */
- impl->search_model = gtk_list_store_new (SEARCH_MODEL_COL_NUM_COLUMNS,
- G_TYPE_POINTER, /* file */
- G_TYPE_POINTER, /* display-name */
- G_TYPE_POINTER, /* collation-key */
- G_TYPE_UINT64, /* mtime */
- G_TYPE_INT64, /* size */
- G_TYPE_POINTER, /* cancellable */
- GDK_TYPE_PIXBUF, /* pixbuf */
- G_TYPE_POINTER, /* mime-type */
- G_TYPE_BOOLEAN /*is-folder */);
-
- impl->search_model_filter =
- GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL (impl->search_model), NULL));
- gtk_tree_model_filter_set_visible_func (impl->search_model_filter,
- search_model_visible_func,
- impl, NULL);
-
- impl->search_model_sort =
- GTK_TREE_MODEL_SORT (search_model_sort_new (impl, GTK_TREE_MODEL (impl->search_model_filter)));
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model_sort),
- SEARCH_MODEL_COL_FILE,
- search_column_path_sort_func,
+ impl->search_model = _gtk_file_system_model_new (file_system_model_set,
+ impl,
+ MODEL_COLUMN_TYPES);
+
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
+ MODEL_COL_NAME,
+ name_sort_func,
impl, NULL);
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model_sort),
- SEARCH_MODEL_COL_MTIME,
- search_column_mtime_sort_func,
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
+ MODEL_COL_MTIME,
+ mtime_sort_func,
impl, NULL);
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model_sort),
- SEARCH_MODEL_COL_SIZE,
- search_column_size_sort_func,
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->search_model),
+ MODEL_COL_SIZE,
+ size_sort_func,
impl, NULL);
- gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (impl->search_model_sort),
- SEARCH_MODEL_COL_MTIME,
- GTK_SORT_DESCENDING);
+ set_sort_column (impl);
/* EB: setting the model here will make the hits list update feel
* more "alive" than setting the model at the end of the search
* run
*/
gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
- GTK_TREE_MODEL (impl->search_model_sort));
-}
-
-static void
-search_get_valid_child_iter (GtkFileChooserDefault *impl,
- GtkTreeIter *child_iter,
- GtkTreeIter *iter)
-{
- GtkTreeIter middle;
-
- if (!impl->search_model)
- return;
-
- if (!impl->search_model_filter || !impl->search_model_sort)
- return;
-
- /* pass 1: get the iterator in the filter model */
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->search_model_sort,
- &middle, iter);
-
- /* pass 2: get the iterator in the real model */
- gtk_tree_model_filter_convert_iter_to_child_iter (impl->search_model_filter,
- child_iter, &middle);
+ GTK_TREE_MODEL (impl->search_model));
}
/* Creates a new query with the specified text and launches it */
search_setup_widgets (GtkFileChooserDefault *impl)
{
GtkWidget *label;
+ GtkWidget *image;
+ gchar *tmp;
impl->search_hbox = gtk_hbox_new (FALSE, 12);
+
+ /* Image */
+
+ image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON);
+ gtk_size_group_add_widget (GTK_SIZE_GROUP (impl->browse_path_bar_size_group), image);
+ gtk_box_pack_start (GTK_BOX (impl->search_hbox), image, FALSE, FALSE, 5);
/* Label */
- label = gtk_label_new_with_mnemonic (_("_Search:"));
+ label = gtk_label_new (NULL);
+ tmp = g_strdup_printf ("<b>%s</b>", _("Search:"));
+ gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), tmp);
gtk_box_pack_start (GTK_BOX (impl->search_hbox), label, FALSE, FALSE, 0);
+ g_free (tmp);
/* Entry */
/* FMQ: hide the filter combo? */
}
+/* Stops running operations like populating the browse model, searches, and the recent-files model */
+static void
+stop_operation (GtkFileChooserDefault *impl, OperationMode mode)
+{
+ switch (mode)
+ {
+ case OPERATION_MODE_BROWSE:
+ stop_loading_and_clear_list_model (impl, TRUE);
+ break;
+
+ case OPERATION_MODE_SEARCH:
+ search_stop_searching (impl, FALSE);
+ search_clear_model (impl, TRUE);
+
+ gtk_widget_destroy (impl->search_hbox);
+ impl->search_hbox = NULL;
+ impl->search_entry = NULL;
+ break;
+
+ case OPERATION_MODE_RECENT:
+ recent_stop_loading (impl);
+ recent_clear_model (impl, TRUE);
+
+ gtk_widget_destroy (impl->recent_hbox);
+ impl->recent_hbox = NULL;
+ break;
+ }
+}
+
/* Main entry point to the searching functions; this gets called when the user
* activates the Search shortcut.
*/
previous_mode = impl->operation_mode;
impl->operation_mode = OPERATION_MODE_SEARCH;
- switch (previous_mode)
- {
- case OPERATION_MODE_RECENT:
- recent_stop_loading (impl);
- recent_clear_model (impl, TRUE);
- break;
-
- case OPERATION_MODE_BROWSE:
- stop_loading_and_clear_list_model (impl);
- break;
-
- case OPERATION_MODE_SEARCH:
- g_assert_not_reached ();
- break;
- }
+ stop_operation (impl, previous_mode);
g_assert (impl->search_hbox == NULL);
g_assert (impl->search_entry == NULL);
g_assert (impl->search_model == NULL);
- g_assert (impl->search_model_filter == NULL);
search_setup_widgets (impl);
file_list_set_sort_column_ids (impl);
gboolean remove_from_treeview)
{
GtkTreeModel *model;
- GtkTreeIter iter;
if (!impl->recent_model)
return;
if (remove_from_treeview)
gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
- if (gtk_tree_model_get_iter_first (model, &iter))
- {
- do
- {
- GFile *file;
- GCancellable *cancellable;
- GtkRecentInfo *recent_info;
- gchar *display_name;
-
- gtk_tree_model_get (model, &iter,
- RECENT_MODEL_COL_DISPLAY_NAME, &display_name,
- RECENT_MODEL_COL_FILE, &file,
- RECENT_MODEL_COL_CANCELLABLE, &cancellable,
- RECENT_MODEL_COL_INFO, &recent_info,
- -1);
-
- if (cancellable)
- g_cancellable_cancel (cancellable);
-
- g_object_unref (file);
- gtk_recent_info_unref (recent_info);
- g_free (display_name);
- }
- while (gtk_tree_model_iter_next (model, &iter));
- }
-
g_object_unref (impl->recent_model);
impl->recent_model = NULL;
-
- g_object_unref (impl->recent_model_filter);
- impl->recent_model_filter = NULL;
-
- g_object_unref (impl->recent_model_sort);
- impl->recent_model_sort = NULL;
}
/* Stops any ongoing loading of the recent files list; does
recent_stop_loading (impl);
recent_clear_model (impl, TRUE);
+ gtk_widget_destroy (impl->recent_hbox);
+ impl->recent_hbox = NULL;
+
gtk_widget_show (impl->browse_path_bar);
- gtk_widget_show (impl->browse_new_folder_button);
+ if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN || !impl->create_folders)
+ gtk_widget_hide (impl->browse_new_folder_button);
+ else
+ gtk_widget_show (impl->browse_new_folder_button);
if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
file_list_set_sort_column_ids (impl);
}
-/* Sort callback from the modification time column */
-static gint
-recent_column_mtime_sort_func (GtkTreeModel *model,
- GtkTreeIter *a,
- GtkTreeIter *b,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeIter child_a, child_b;
- GtkRecentInfo *info_a, *info_b;
- gboolean is_folder_a, is_folder_b;
-
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_a, a);
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_b, b);
-
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_a,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder_a,
- RECENT_MODEL_COL_INFO, &info_a,
- -1);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_b,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder_b,
- RECENT_MODEL_COL_INFO, &info_b,
- -1);
-
- if (!info_a)
- return 1;
-
- if (!info_b)
- return -1;
-
- /* folders always go first */
- if (is_folder_a != is_folder_b)
- return is_folder_a ? 1 : -1;
-
- if (gtk_recent_info_get_modified (info_a) < gtk_recent_info_get_modified (info_b))
- return -1;
- else if (gtk_recent_info_get_modified (info_a) > gtk_recent_info_get_modified (info_b))
- return 1;
- else
- return 0;
-}
-
-static gint
-recent_column_path_sort_func (GtkTreeModel *model,
- GtkTreeIter *a,
- GtkTreeIter *b,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeIter child_a, child_b;
- gboolean is_folder_a, is_folder_b;
- gchar *name_a, *name_b;
-
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_a, a);
- gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_b, b);
-
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_a,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder_a,
- RECENT_MODEL_COL_DISPLAY_NAME, &name_a,
- -1);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_b,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder_b,
- RECENT_MODEL_COL_DISPLAY_NAME, &name_b,
- -1);
-
- if (!name_a)
- return 1;
-
- if (!name_b)
- return -1;
-
- if (is_folder_a != is_folder_b)
- return is_folder_a ? 1 : -1;
-
- return strcmp (name_a, name_b);
-}
-
-static gboolean
-recent_get_is_filtered (GtkFileChooserDefault *impl,
- GFile *file,
- GtkRecentInfo *recent_info)
-{
- GtkFileFilterInfo filter_info;
- GtkFileFilterFlags needed;
- gboolean result;
-
- if (!impl->current_filter)
- return FALSE;
-
- filter_info.contains = GTK_FILE_FILTER_DISPLAY_NAME | GTK_FILE_FILTER_MIME_TYPE;
- needed = gtk_file_filter_get_needed (impl->current_filter);
-
- filter_info.display_name = gtk_recent_info_get_display_name (recent_info);
- filter_info.mime_type = gtk_recent_info_get_mime_type (recent_info);
-
- if (needed & GTK_FILE_FILTER_FILENAME)
- {
- filter_info.filename = g_file_get_path (file);
- if (filter_info.filename)
- filter_info.contains |= GTK_FILE_FILTER_FILENAME;
- }
- else
- filter_info.filename = NULL;
-
- if (needed & GTK_FILE_FILTER_URI)
- {
- filter_info.uri = g_file_get_uri (file);
- if (filter_info.uri)
- filter_info.contains |= GTK_FILE_FILTER_URI;
- }
- else
- filter_info.uri = NULL;
-
- result = gtk_file_filter_filter (impl->current_filter, &filter_info);
-
- if (filter_info.filename)
- g_free ((gchar *) filter_info.filename);
- if (filter_info.uri)
- g_free ((gchar *) filter_info.uri);
-
- return !result;
-}
-
-/* Visibility function for the recent filter model */
-static gboolean
-recent_model_visible_func (GtkTreeModel *model,
- GtkTreeIter *iter,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GFile *file;
- GtkRecentInfo *recent_info;
- gboolean is_folder;
-
- if (!impl->current_filter)
- return TRUE;
-
- gtk_tree_model_get (model, iter,
- RECENT_MODEL_COL_INFO, &recent_info,
- RECENT_MODEL_COL_FILE, &file,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- if (!recent_info)
- return TRUE;
-
- if (is_folder)
- return TRUE;
-
- return !recent_get_is_filtered (impl, file, recent_info);
-}
-
static void
recent_setup_model (GtkFileChooserDefault *impl)
{
g_assert (impl->recent_model == NULL);
- g_assert (impl->recent_model_filter == NULL);
- g_assert (impl->recent_model_sort == NULL);
- /* We store these columns in the search model:
- *
- * RECENT_MODEL_COL_FILE - a pointer to GFile for the hit's URI,
- * stored as a pointer and not as a G_TYPE_FILE;
- * RECENT_MODEL_COL_DISPLAY_NAME - a string with the display name,
- * stored as a pointer and not as a G_TYPE_STRING;
- * RECENT_MODEL_COL_INFO - GtkRecentInfo, stored as a pointer and not
- * as a GTK_TYPE_RECENT_INFO;
- * RECENT_MODEL_COL_IS_FOLDER - boolean flag;
- * RECENT_MODEL_COL_CANCELLABLE - GCancellable, stored as a pointer
- * and not as a G_TYPE_CANCELLABLE;
- *
- * Keep this in sync with the enumeration defined near the beginning of
- * this file.
- */
- impl->recent_model = gtk_list_store_new (RECENT_MODEL_COL_NUM_COLUMNS,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_BOOLEAN,
- G_TYPE_POINTER);
-
- impl->recent_model_filter =
- GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL (impl->recent_model), NULL));
- gtk_tree_model_filter_set_visible_func (impl->recent_model_filter,
- recent_model_visible_func,
- impl,
- NULL);
-
- /* this is the model that will actually be added to
- * the browse_files_tree_view widget; remember: we are
- * stuffing the real model into a filter model and then
- * into a sort model; this means we'll have to translate
- * the child iterator *twice* to get from a path or an
- * iterator coming from the tree view widget to the
- * real data inside the model.
- */
- impl->recent_model_sort =
- GTK_TREE_MODEL_SORT (recent_model_sort_new (impl, GTK_TREE_MODEL (impl->recent_model_filter)));
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model_sort),
- RECENT_MODEL_COL_FILE,
- recent_column_path_sort_func,
+ impl->recent_model = _gtk_file_system_model_new (file_system_model_set,
+ impl,
+ MODEL_COLUMN_TYPES);
+
+ _gtk_file_system_model_set_filter (impl->recent_model,
+ impl->current_filter);
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
+ MODEL_COL_NAME,
+ name_sort_func,
impl, NULL);
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model_sort),
- RECENT_MODEL_COL_INFO,
- recent_column_mtime_sort_func,
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
+ MODEL_COL_SIZE,
+ size_sort_func,
+ impl, NULL);
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (impl->recent_model),
+ MODEL_COL_MTIME,
+ mtime_sort_func,
impl, NULL);
- gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (impl->recent_model_sort),
- RECENT_MODEL_COL_INFO,
- GTK_SORT_DESCENDING);
+ set_sort_column (impl);
}
typedef struct
GtkFileChooserDefault *impl = load_data->impl;
gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view),
- GTK_TREE_MODEL (impl->recent_model_sort));
+ GTK_TREE_MODEL (impl->recent_model));
set_busy_cursor (impl, FALSE);
g_free (load_data);
}
-struct RecentItemInsertRequest
+static gint
+recent_sort_mru (gconstpointer a,
+ gconstpointer b)
{
- GtkFileChooserDefault *impl;
- GFile *file;
- GtkTreeRowReference *row_ref;
-};
+ GtkRecentInfo *info_a = (GtkRecentInfo *) a;
+ GtkRecentInfo *info_b = (GtkRecentInfo *) b;
-static void
-recent_item_get_info_cb (GCancellable *cancellable,
- GFileInfo *info,
- const GError *error,
- gpointer data)
-{
- gboolean cancelled = g_cancellable_is_cancelled (cancellable);
- GtkTreePath *path;
- GtkTreeIter iter;
- GCancellable *model_cancellable;
- gboolean is_folder = FALSE;
- struct RecentItemInsertRequest *request = data;
-
- if (!request->impl->recent_model)
- goto out;
-
- path = gtk_tree_row_reference_get_path (request->row_ref);
- if (!path)
- goto out;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (request->impl->recent_model),
- &iter, path);
- gtk_tree_path_free (path);
-
- gtk_tree_model_get (GTK_TREE_MODEL (request->impl->recent_model), &iter,
- RECENT_MODEL_COL_CANCELLABLE, &model_cancellable,
- -1);
- if (cancellable != model_cancellable)
- goto out;
-
- gtk_list_store_set (request->impl->recent_model, &iter,
- RECENT_MODEL_COL_CANCELLABLE, NULL,
- -1);
-
- if (cancelled)
- goto out;
-
- if (!info)
- {
- gtk_list_store_remove (request->impl->recent_model, &iter);
- goto out;
- }
-
- is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
-
- gtk_list_store_set (request->impl->recent_model, &iter,
- RECENT_MODEL_COL_IS_FOLDER, is_folder,
- -1);
-
-out:
- g_object_unref (request->impl);
- g_object_unref (request->file);
- gtk_tree_row_reference_free (request->row_ref);
- g_free (request);
-
- g_object_unref (cancellable);
-}
-
-static gint
-recent_sort_mru (gconstpointer a,
- gconstpointer b)
-{
- GtkRecentInfo *info_a = (GtkRecentInfo *) a;
- GtkRecentInfo *info_b = (GtkRecentInfo *) b;
-
- return (gtk_recent_info_get_modified (info_b) - gtk_recent_info_get_modified (info_a));
-}
-
-static gint
-get_recent_files_limit (GtkWidget *widget)
+ return (gtk_recent_info_get_modified (info_b) - gtk_recent_info_get_modified (info_a));
+}
+
+static gint
+get_recent_files_limit (GtkWidget *widget)
{
GtkSettings *settings;
gint limit;
{
RecentLoadData *load_data = data;
GtkFileChooserDefault *impl = load_data->impl;
- GtkTreeIter iter;
- GtkTreePath *p;
- GtkRecentInfo *info;
- const gchar *uri, *display_name;
+ GList *walk;
GFile *file;
- GCancellable *cancellable;
- struct RecentItemInsertRequest *request;
if (!impl->recent_manager)
return FALSE;
return TRUE;
}
- info = g_list_nth_data (load_data->items, load_data->n_loaded_items);
- g_assert (info != NULL);
-
- uri = gtk_recent_info_get_uri (info);
- display_name = gtk_recent_info_get_display_name (info);
- file = g_file_new_for_uri (uri);
-
- gtk_list_store_append (impl->recent_model, &iter);
- p = gtk_tree_model_get_path (GTK_TREE_MODEL (impl->recent_model), &iter);
-
- request = g_new0 (struct RecentItemInsertRequest, 1);
- request->impl = g_object_ref (impl);
- request->file = g_object_ref (file);
- request->row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (impl->recent_model), p);
- gtk_tree_path_free (p);
-
- cancellable = _gtk_file_system_get_info (impl->file_system, file,
- "standard::type",
- recent_item_get_info_cb,
- request);
-
- gtk_list_store_set (impl->recent_model, &iter,
- RECENT_MODEL_COL_FILE, file,
- RECENT_MODEL_COL_DISPLAY_NAME, g_strdup (display_name),
- RECENT_MODEL_COL_INFO, gtk_recent_info_ref (info),
- RECENT_MODEL_COL_CANCELLABLE, cancellable,
- -1);
-
- load_data->n_loaded_items += 1;
-
/* finished loading items */
- if (load_data->n_loaded_items == load_data->n_items)
+ for (walk = load_data->items; walk; walk = walk->next)
{
- g_list_foreach (load_data->items, (GFunc) gtk_recent_info_unref, NULL);
- g_list_free (load_data->items);
- load_data->items = NULL;
+ GtkRecentInfo *info = walk->data;
+ file = g_file_new_for_uri (gtk_recent_info_get_uri (info));
- return FALSE;
+ _gtk_file_system_model_add_and_query_file (impl->recent_model,
+ file,
+ MODEL_ATTRIBUTES);
+ gtk_recent_info_unref (walk->data);
+ g_object_unref (file);
}
- return TRUE;
+ g_list_free (load_data->items);
+ load_data->items = NULL;
+
+ return FALSE;
}
static void
list = data;
- gtk_tree_model_get (model, iter, RECENT_MODEL_COL_FILE, &file, -1);
- *list = g_slist_prepend (*list, g_object_ref (file));
+ gtk_tree_model_get (model, iter, MODEL_COL_FILE, &file, -1);
+ *list = g_slist_prepend (*list, file);
}
/* Constructs a list of the selected paths in recent files mode */
static void
recent_hide_entry (GtkFileChooserDefault *impl)
{
+ GtkWidget *label;
+ GtkWidget *image;
+ gchar *tmp;
+
+ impl->recent_hbox = gtk_hbox_new (FALSE, 12);
+
+ /* Image */
+ image = gtk_image_new_from_icon_name ("document-open-recent", GTK_ICON_SIZE_BUTTON);
+ gtk_size_group_add_widget (impl->browse_path_bar_size_group, image);
+ gtk_box_pack_start (GTK_BOX (impl->recent_hbox), image, FALSE, FALSE, 5);
+
+ /* Label */
+ label = gtk_label_new (NULL);
+ tmp = g_strdup_printf ("<b>%s</b>", _("Recently Used"));
+ gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), tmp);
+ gtk_box_pack_start (GTK_BOX (impl->recent_hbox), label, FALSE, FALSE, 0);
+ g_free (tmp);
+
gtk_widget_hide (impl->browse_path_bar);
gtk_widget_hide (impl->browse_new_folder_button);
+ /* Box for recent widgets */
+ gtk_box_pack_start (GTK_BOX (impl->browse_path_bar_hbox), impl->recent_hbox, TRUE, TRUE, 0);
+ gtk_widget_show_all (impl->recent_hbox);
+
+ /* Hide the location widgets temporarily */
if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
{
previous_mode = impl->operation_mode;
impl->operation_mode = OPERATION_MODE_RECENT;
- switch (previous_mode)
- {
- case OPERATION_MODE_SEARCH:
- search_stop_searching (impl, FALSE);
- search_clear_model (impl, TRUE);
-
- gtk_widget_destroy (impl->search_hbox);
- impl->search_hbox = NULL;
- impl->search_entry = NULL;
- break;
-
- case OPERATION_MODE_BROWSE:
- stop_loading_and_clear_list_model (impl);
- break;
-
- case OPERATION_MODE_RECENT:
- g_assert_not_reached ();
- break;
- }
+ stop_operation (impl, previous_mode);
recent_hide_entry (impl);
- /* hide the file size column if it's visible */
- gtk_tree_view_column_set_visible (impl->list_size_column, FALSE);
-
file_list_set_sort_column_ids (impl);
recent_start_loading (impl);
}
-/* convert an iterator coming from the model bound to
- * browse_files_tree_view to an interator inside the
- * real recent_model
- */
-static void
-recent_get_valid_child_iter (GtkFileChooserDefault *impl,
- GtkTreeIter *child_iter,
- GtkTreeIter *iter)
-{
- GtkTreeIter middle;
-
- if (!impl->recent_model)
- return;
-
- if (!impl->recent_model_filter || !impl->recent_model_sort)
- return;
-
- /* pass 1: get the iterator in the filter model */
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->recent_model_sort,
- &middle, iter);
-
- /* pass 2: get the iterator in the real model */
- gtk_tree_model_filter_convert_iter_to_child_iter (impl->recent_model_filter,
- child_iter,
- &middle);
-}
-
-
static void
set_current_filter (GtkFileChooserDefault *impl,
GtkFileFilter *filter)
if (impl->browse_files_model)
install_list_model_filter (impl);
- if (impl->search_model_filter)
- gtk_tree_model_filter_refilter (impl->search_model_filter);
+ if (impl->search_model)
+ _gtk_file_system_model_set_filter (impl->search_model, filter);
- if (impl->recent_model_filter)
- gtk_tree_model_filter_refilter (impl->recent_model_filter);
+ if (impl->recent_model)
+ _gtk_file_system_model_set_filter (impl->recent_model, filter);
g_object_notify (G_OBJECT (impl), "filter");
}
{
GtkTreePath *cursor_path;
GFile *new_file;
- const char *new_display_name;
+ char *new_display_name;
+ GtkTreeModel *model;
gtk_tree_view_get_cursor (GTK_TREE_VIEW (impl->browse_files_tree_view), &cursor_path, NULL);
- new_file = NULL;
- new_display_name = NULL;
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (impl->browse_files_tree_view));
if (cursor_path)
{
- GtkTreeIter child_iter;
-
- if (impl->operation_mode == OPERATION_MODE_BROWSE)
- {
- if (impl->sort_model)
- {
- GtkTreeIter iter;
- GFileInfo *new_info;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->sort_model), &iter, cursor_path);
- gtk_tree_path_free (cursor_path);
-
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model, &child_iter, &iter);
-
- new_file = _gtk_file_system_model_get_file (impl->browse_files_model, &child_iter);
- new_info = _gtk_file_system_model_get_info (impl->browse_files_model, &child_iter);
- if (new_info)
- new_display_name = g_file_info_get_display_name (new_info);
- }
- }
- else if (impl->operation_mode == OPERATION_MODE_SEARCH)
- {
- GtkTreeIter iter;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->search_model_sort),
- &iter, cursor_path);
- gtk_tree_path_free (cursor_path);
-
- search_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_FILE, &new_file,
- SEARCH_MODEL_COL_DISPLAY_NAME, &new_display_name,
- -1);
- }
- else if (impl->operation_mode == OPERATION_MODE_RECENT)
- {
- GtkTreeIter iter;
-
- gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->recent_model_sort),
- &iter, cursor_path);
- gtk_tree_path_free (cursor_path);
+ GtkTreeIter iter;
- recent_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_FILE, &new_file,
- RECENT_MODEL_COL_DISPLAY_NAME, &new_display_name,
- -1);
- }
+ gtk_tree_model_get_iter (model, &iter, cursor_path);
+ gtk_tree_model_get (model, &iter,
+ MODEL_COL_FILE, &new_file,
+ MODEL_COL_NAME, &new_display_name,
+ -1);
+
+ gtk_tree_path_free (cursor_path);
+ }
+ else
+ {
+ new_file = NULL;
+ new_display_name = NULL;
}
if (new_file != impl->preview_file &&
if (new_file)
{
- impl->preview_file = g_object_ref (new_file);
- impl->preview_display_name = g_strdup (new_display_name);
+ impl->preview_file = new_file;
+ impl->preview_display_name = new_display_name;
}
else
{
impl->preview_file = NULL;
impl->preview_display_name = NULL;
+ g_free (new_display_name);
}
if (impl->use_preview_label && impl->preview_label)
if (!_gtk_file_system_volume_is_mounted (volume))
{
- GtkMountOperation *mount_op;
+ GMountOperation *mount_op;
set_busy_cursor (impl, TRUE);
if (cancelled)
goto out;
- if (!error && g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
+ if (!error && _gtk_file_info_consider_as_directory (info))
change_folder_and_display_error (data->impl, data->file, FALSE);
else
gtk_file_chooser_default_select_file (GTK_FILE_CHOOSER (data->impl),
modifiers = gtk_accelerator_get_default_mod_mask ();
+ if (key_is_left_or_right (event))
+ {
+ gtk_widget_grab_focus (impl->browse_files_tree_view);
+ return TRUE;
+ }
+
if ((event->keyval == GDK_BackSpace
|| event->keyval == GDK_Delete
|| event->keyval == GDK_KP_Delete)
if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
{
- GtkTreeIter iter, child_iter;
-
- switch (impl->operation_mode)
- {
- case OPERATION_MODE_SEARCH:
- {
- gboolean is_folder;
-
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->search_model_sort), &iter, path))
- return FALSE;
-
- search_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
- if (!is_folder)
- return FALSE;
- }
- break;
-
- case OPERATION_MODE_RECENT:
- {
- gboolean is_folder;
-
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->recent_model_sort), &iter, path))
- return FALSE;
-
- recent_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
- if (!is_folder)
- return FALSE;
- }
- break;
-
- case OPERATION_MODE_BROWSE:
- {
- GFileInfo *info;
-
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->sort_model), &iter, path))
- return FALSE;
+ GtkTreeIter iter;
+ gboolean is_folder;
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model, &child_iter, &iter);
- info = _gtk_file_system_model_get_info (impl->browse_files_model, &child_iter);
- if (info && g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY)
- return FALSE;
- }
- break;
- }
+ if (!gtk_tree_model_get_iter (model, &iter, path))
+ return FALSE;
+ gtk_tree_model_get (model, &iter,
+ MODEL_COL_IS_FOLDER, &is_folder,
+ -1);
+ if (!is_folder)
+ return FALSE;
}
return TRUE;
GtkTreeViewColumn *column,
GtkFileChooserDefault *impl)
{
+ GFile *file;
GtkTreeIter iter;
- GtkTreeIter child_iter;
-
- switch (impl->operation_mode)
- {
- case OPERATION_MODE_SEARCH:
- {
- GFile *file;
- gboolean is_folder;
-
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->search_model_sort), &iter, path))
- return;
-
- search_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_FILE, &file,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- if (is_folder)
- {
- change_folder_and_display_error (impl, file, FALSE);
- return;
- }
-
- g_signal_emit_by_name (impl, "file-activated");
- }
- break;
+ GtkTreeModel *model;
+ gboolean is_folder;
- case OPERATION_MODE_RECENT:
- {
- GFile *file;
- gboolean is_folder;
+ model = gtk_tree_view_get_model (tree_view);
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->recent_model_sort), &iter, path))
- return;
-
- recent_get_valid_child_iter (impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_FILE, &file,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- if (is_folder)
- {
- change_folder_and_display_error (impl, file, FALSE);
- return;
- }
-
- g_signal_emit_by_name (impl, "file-activated");
- }
- break;
-
- case OPERATION_MODE_BROWSE:
- {
- GFileInfo *info;
+ if (!gtk_tree_model_get_iter (model, &iter, path))
+ return;
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (impl->sort_model), &iter, path))
- return;
+ gtk_tree_model_get (model, &iter,
+ MODEL_COL_FILE, &file,
+ MODEL_COL_IS_FOLDER, &is_folder,
+ -1);
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
- &child_iter, &iter);
- info = _gtk_file_system_model_get_info (impl->browse_files_model,
- &child_iter);
-
- if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
- {
- GFile *file;
+ if (is_folder && file)
+ {
+ change_folder_and_display_error (impl, file, FALSE);
+ return;
+ }
- file = _gtk_file_system_model_get_file (impl->browse_files_model, &child_iter);
- change_folder_and_display_error (impl, file, FALSE);
- return;
- }
+ if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
+ impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
+ g_signal_emit_by_name (impl, "file-activated");
- if (impl->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
- impl->action == GTK_FILE_CHOOSER_ACTION_SAVE)
- g_signal_emit_by_name (impl, "file-activated");
- }
- break;
- }
+ if (file)
+ g_object_unref (file);
}
static void
g_object_set (impl, "show-hidden", TRUE, NULL);
}
-static GFileInfo *
-get_list_file_info (GtkFileChooserDefault *impl,
- GtkTreeIter *iter)
+static void
+update_cell_renderer_attributes (GtkFileChooserDefault *impl)
{
- GtkTreeIter child_iter;
+ GtkTreeViewColumn *column;
+ GtkCellRenderer *renderer;
+ GList *walk, *list;
+ gboolean always_sensitive;
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
- &child_iter,
- iter);
+ always_sensitive = impl->action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER &&
+ impl->action != GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER;
- return _gtk_file_system_model_get_info (impl->browse_files_model, &child_iter);
+ /* Keep the following column numbers in sync with create_file_list() */
+
+ /* name */
+ column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 0);
+ list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
+ for (walk = list; walk; walk = walk->next)
+ {
+ renderer = walk->data;
+ if (GTK_IS_CELL_RENDERER_PIXBUF (renderer))
+ {
+ gtk_tree_view_column_set_attributes (column, renderer,
+ "pixbuf", MODEL_COL_PIXBUF,
+ NULL);
+ }
+ else
+ {
+ gtk_tree_view_column_set_attributes (column, renderer,
+ "text", MODEL_COL_NAME,
+ "ellipsize", MODEL_COL_ELLIPSIZE,
+ NULL);
+ }
+ if (always_sensitive)
+ g_object_set (renderer, "sensitive", TRUE, NULL);
+ else
+ gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_FOLDER);
+ }
+ g_list_free (list);
+
+ /* size */
+ column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 1);
+ list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
+ renderer = list->data;
+ gtk_tree_view_column_set_attributes (column, renderer,
+ "text", MODEL_COL_SIZE_TEXT,
+ NULL);
+ if (always_sensitive)
+ g_object_set (renderer, "sensitive", TRUE, NULL);
+ else
+ gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_FOLDER);
+ g_list_free (list);
+
+ /* mtime */
+ column = gtk_tree_view_get_column (GTK_TREE_VIEW (impl->browse_files_tree_view), 2);
+ list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
+ renderer = list->data;
+ gtk_tree_view_column_set_attributes (column, renderer,
+ "text", MODEL_COL_MTIME_TEXT,
+ NULL);
+ if (always_sensitive)
+ g_object_set (renderer, "sensitive", TRUE, NULL);
+ else
+ gtk_tree_view_column_add_attribute (column, renderer, "sensitive", MODEL_COL_IS_FOLDER);
+ g_list_free (list);
+}
+
+GtkWidget *
+_gtk_file_chooser_default_new (void)
+{
+ return g_object_new (GTK_TYPE_FILE_CHOOSER_DEFAULT, NULL);
}
static void
-list_icon_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data)
+location_set_user_text (GtkFileChooserDefault *impl,
+ const gchar *path)
{
- GtkFileChooserDefault *impl = data;
- GtkTreeIter child_iter;
- GdkPixbuf *pixbuf = NULL;
- gboolean sensitive = TRUE;
+ _gtk_file_chooser_entry_set_file_part (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), path);
+ gtk_editable_set_position (GTK_EDITABLE (impl->location_entry), -1);
+}
- profile_start ("start", NULL);
-
- switch (impl->operation_mode)
- {
- case OPERATION_MODE_SEARCH:
- {
- GtkTreeIter child_iter;
- gboolean is_folder;
-
- search_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_PIXBUF, &pixbuf,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- sensitive = is_folder;
- }
- break;
-
- case OPERATION_MODE_RECENT:
- {
- GtkTreeIter child_iter;
- GtkRecentInfo *info;
- gboolean is_folder;
-
- recent_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_INFO, &info,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- pixbuf = gtk_recent_info_get_icon (info, impl->icon_size);
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- sensitive = is_folder;
- }
- break;
-
- case OPERATION_MODE_BROWSE:
- {
- GFileInfo *info;
- GFile *file;
-
- info = get_list_file_info (impl, iter);
-
- gtk_tree_model_sort_convert_iter_to_child_iter (impl->sort_model,
- &child_iter,
- iter);
- file = _gtk_file_system_model_get_file (impl->browse_files_model, &child_iter);
- if (file)
- {
- if (info)
- {
- /* FIXME: NULL GError */
- pixbuf = _gtk_file_info_render_icon (info, GTK_WIDGET (impl), impl->icon_size);
- }
- }
- else
- {
- /* We are on the editable row */
- pixbuf = NULL;
- }
-
- if (info &&
- (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER))
- sensitive = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
- }
- break;
- }
-
- g_object_set (cell,
- "pixbuf", pixbuf,
- "sensitive", sensitive,
- NULL);
-
- if (pixbuf)
- g_object_unref (pixbuf);
-
- profile_end ("end", NULL);
-}
-
-static void
-list_name_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data)
-{
- GtkFileChooserDefault *impl = data;
- GFileInfo *info;
- gboolean sensitive = TRUE;
-
- if (impl->operation_mode == OPERATION_MODE_SEARCH)
- {
- GtkTreeIter child_iter;
- gchar *display_name;
- gboolean is_folder;
-
- search_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_DISPLAY_NAME, &display_name,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- {
- sensitive = is_folder;
- }
-
- g_object_set (cell,
- "text", display_name,
- "sensitive", sensitive,
- "ellipsize", PANGO_ELLIPSIZE_END,
- NULL);
-
- return;
- }
-
- if (impl->operation_mode == OPERATION_MODE_RECENT)
- {
- GtkTreeIter child_iter;
- GtkRecentInfo *recent_info;
- gchar *display_name;
- gboolean is_folder;
-
- recent_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_INFO, &recent_info,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- display_name = gtk_recent_info_get_short_name (recent_info);
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- {
- sensitive = is_folder;
- }
-
- g_object_set (cell,
- "text", display_name,
- "sensitive", sensitive,
- "ellipsize", PANGO_ELLIPSIZE_END,
- NULL);
-
- g_free (display_name);
-
- return;
- }
-
- info = get_list_file_info (impl, iter);
- sensitive = TRUE;
-
- if (!info)
- {
- g_object_set (cell,
- "text", _("Type name of new folder"),
- "sensitive", TRUE,
- "ellipsize", PANGO_ELLIPSIZE_NONE,
- NULL);
-
- return;
- }
-
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- {
- sensitive = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
- }
-
- g_object_set (cell,
- "text", g_file_info_get_display_name (info),
- "sensitive", sensitive,
- "ellipsize", PANGO_ELLIPSIZE_END,
- NULL);
-}
-
-static void
-list_size_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data)
-{
- GtkFileChooserDefault *impl = data;
- GFileInfo *info;
- goffset size;
- gchar *str;
- gboolean sensitive = TRUE;
-
- if (impl->operation_mode == OPERATION_MODE_RECENT)
- return;
-
- if (impl->operation_mode == OPERATION_MODE_SEARCH)
- {
- GtkTreeIter child_iter;
- gboolean is_folder = FALSE;
-
- search_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_SIZE, &size,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- sensitive = is_folder ? TRUE : FALSE;
-
- if (!is_folder)
- str = g_format_size_for_display (size);
- else
- str = NULL;
-
- g_object_set (cell,
- "text", str,
- "sensitive", sensitive,
- NULL);
-
- g_free (str);
-
- return;
- }
-
- info = get_list_file_info (impl, iter);
-
- if (!info || g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
- {
- g_object_set (cell,
- "text", NULL,
- "sensitive", sensitive,
- NULL);
- return;
- }
-
- size = g_file_info_get_size (info);
- str = g_format_size_for_display (size);
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- sensitive = FALSE;
-
- g_object_set (cell,
- "text", str,
- "sensitive", sensitive,
- "alignment", PANGO_ALIGN_RIGHT,
- NULL);
-
- g_free (str);
-}
-
-/* Tree column data callback for the file list; fetches the mtime of a file */
-static void
-list_mtime_data_func (GtkTreeViewColumn *tree_column,
- GtkCellRenderer *cell,
- GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gpointer data)
-{
- GtkFileChooserDefault *impl;
- GTimeVal timeval = { 0, };
- time_t time_mtime;
- gchar *date_str = NULL;
- gboolean sensitive = TRUE;
-#ifdef G_OS_WIN32
- const char *locale, *dot = NULL;
- gint64 codepage = -1;
- char charset[20];
-#endif
-
- impl = data;
-
- if (impl->operation_mode == OPERATION_MODE_SEARCH)
- {
- GtkTreeIter child_iter;
- guint64 mtime;
- gboolean is_folder;
-
- search_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->search_model), &child_iter,
- SEARCH_MODEL_COL_MTIME, &mtime,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- time_mtime = (time_t) mtime;
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- sensitive = is_folder;
- }
- else if (impl->operation_mode == OPERATION_MODE_RECENT)
- {
- GtkTreeIter child_iter;
- GtkRecentInfo *info;
- gboolean is_folder;
-
- recent_get_valid_child_iter (impl, &child_iter, iter);
- gtk_tree_model_get (GTK_TREE_MODEL (impl->recent_model), &child_iter,
- RECENT_MODEL_COL_INFO, &info,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- if (info)
- time_mtime = gtk_recent_info_get_modified (info);
- else
- time_mtime = 0;
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- sensitive = is_folder;
- }
- else
- {
- GFileInfo *info;
-
- info = get_list_file_info (impl, iter);
- if (!info)
- {
- g_object_set (cell,
- "text", "",
- "sensitive", TRUE,
- NULL);
- return;
- }
-
- g_file_info_get_modification_time (info, &timeval);
- time_mtime = timeval.tv_sec;
-
- if (impl->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
- impl->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
- sensitive = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
- }
-
- if (G_UNLIKELY (time_mtime == 0))
- date_str = g_strdup (_("Unknown"));
- else
- {
- GDate mtime, now;
- gint days_diff;
- struct tm tm_mtime;
- time_t time_now;
- const gchar *format;
- gchar *locale_format = NULL;
- gchar buf[256];
-
-#ifdef HAVE_LOCALTIME_R
- localtime_r ((time_t *) &time_mtime, &tm_mtime);
-#else
- {
- struct tm *ptm = localtime ((time_t *) &timeval.tv_sec);
-
- if (!ptm)
- {
- g_warning ("ptm != NULL failed");
-
- g_object_set (cell,
- "text", _("Unknown"),
- "sensitive", sensitive,
- NULL);
- return;
- }
- else
- memcpy ((void *) &tm_mtime, (void *) ptm, sizeof (struct tm));
- }
-#endif /* HAVE_LOCALTIME_R */
-
- g_date_set_time_t (&mtime, time_mtime);
- time_now = time (NULL);
- g_date_set_time_t (&now, time_now);
-
- days_diff = g_date_get_julian (&now) - g_date_get_julian (&mtime);
-
- /* Translators: %H means "hours" and %M means "minutes" */
- if (days_diff == 0)
- format = _("%H:%M");
- else if (days_diff == 1)
- format = _("Yesterday at %H:%M");
- else
- {
- if (days_diff > 1 && days_diff < 7)
- format = "%A"; /* Days from last week */
- else
- format = "%x"; /* Any other date */
- }
-
-#ifdef G_OS_WIN32
- /* g_locale_from_utf8() returns a string in the system
- * code-page, which is not always the same as that used by the C
- * library. For instance when running a GTK+ program with
- * LANG=ko on an English version of Windows, the system
- * code-page is 1252, but the code-page used by the C library is
- * 949. (It's GTK+ itself that sets the C library locale when it
- * notices the LANG environment variable. See gtkmain.c The
- * Microsoft C library doesn't look at any locale environment
- * variables.) We need to pass strftime() a string in the C
- * library's code-page. See bug #509885.
- */
- locale = setlocale (LC_ALL, NULL);
- if (locale != NULL)
- dot = strchr (locale, '.');
- if (dot != NULL)
- {
- codepage = g_ascii_strtoll (dot+1, NULL, 10);
-
- /* All codepages should fit in 16 bits AFAIK */
- if (codepage > 0 && codepage < 65536)
- {
- sprintf (charset, "CP%u", (guint) codepage);
- locale_format = g_convert (format, -1, charset, "UTF-8", NULL, NULL, NULL);
- }
- }
-#else
- locale_format = g_locale_from_utf8 (format, -1, NULL, NULL, NULL);
-#endif
- if (locale_format != NULL &&
- strftime (buf, sizeof (buf), locale_format, &tm_mtime) != 0)
- {
-#ifdef G_OS_WIN32
- /* As above but in opposite direction... */
- if (codepage > 0 && codepage < 65536)
- date_str = g_convert (buf, -1, "UTF-8", charset, NULL, NULL, NULL);
-#else
- date_str = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
-#endif
- }
-
- if (date_str == NULL)
- date_str = g_strdup (_("Unknown"));
-
- g_free (locale_format);
- }
-
- g_object_set (cell,
- "text", date_str,
- "sensitive", sensitive,
- NULL);
- g_free (date_str);
-}
-
-GtkWidget *
-_gtk_file_chooser_default_new (void)
-{
- return g_object_new (GTK_TYPE_FILE_CHOOSER_DEFAULT, NULL);
-}
-
-static void
-location_set_user_text (GtkFileChooserDefault *impl,
- const gchar *path)
-{
- _gtk_file_chooser_entry_set_file_part (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), path);
- gtk_editable_set_position (GTK_EDITABLE (impl->location_entry), -1);
-}
-
-static void
-location_popup_handler (GtkFileChooserDefault *impl,
- const gchar *path)
-{
- if (impl->operation_mode != OPERATION_MODE_BROWSE)
+static void
+location_popup_handler (GtkFileChooserDefault *impl,
+ const gchar *path)
+{
+ if (impl->operation_mode != OPERATION_MODE_BROWSE)
{
GtkWidget *widget_to_focus;
return GTK_TREE_MODEL (model);
}
-\f
-
-static gboolean
-recent_model_sort_row_draggable (GtkTreeDragSource *drag_source,
- GtkTreePath *path)
-{
- RecentModelSort *model;
- GtkTreeIter iter, child_iter;
- gboolean is_folder;
-
- model = RECENT_MODEL_SORT (drag_source);
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
- return FALSE;
-
- recent_get_valid_child_iter (model->impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (model->impl->recent_model), &child_iter,
- RECENT_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- return is_folder;
-}
-
-static gboolean
-recent_model_sort_drag_data_get (GtkTreeDragSource *drag_source,
- GtkTreePath *path,
- GtkSelectionData *selection_data)
-{
- RecentModelSort *model;
- GtkTreeIter iter, child_iter;
- GFile *file;
- gchar *uris[2];
-
- model = RECENT_MODEL_SORT (drag_source);
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
- return FALSE;
-
- recent_get_valid_child_iter (model->impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (model->impl->recent_model), &child_iter,
- RECENT_MODEL_COL_FILE, &file,
- -1);
- g_assert (file != NULL);
-
- uris[0] = g_file_get_uri (file);
- uris[1] = NULL;
-
- gtk_selection_data_set_uris (selection_data, uris);
-
- g_free (uris[0]);
-
- return TRUE;
-}
-
-static void
-recent_model_sort_drag_source_iface_init (GtkTreeDragSourceIface *iface)
-{
- iface->row_draggable = recent_model_sort_row_draggable;
- iface->drag_data_get = recent_model_sort_drag_data_get;
-}
-
-static void
-_recent_model_sort_class_init (RecentModelSortClass *klass)
-{
-
-}
-
-static void
-_recent_model_sort_init (RecentModelSort *model)
-{
- model->impl = NULL;
-}
-
-static GtkTreeModel *
-recent_model_sort_new (GtkFileChooserDefault *impl,
- GtkTreeModel *child_model)
-{
- RecentModelSort *model;
-
- model = g_object_new (RECENT_MODEL_SORT_TYPE,
- "model", child_model,
- NULL);
- model->impl = impl;
-
- return GTK_TREE_MODEL (model);
-}
-
-\f
-
-static gboolean
-search_model_sort_row_draggable (GtkTreeDragSource *drag_source,
- GtkTreePath *path)
-{
- SearchModelSort *model;
- GtkTreeIter iter, child_iter;
- gboolean is_folder;
-
- model = SEARCH_MODEL_SORT (drag_source);
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
- return FALSE;
-
- search_get_valid_child_iter (model->impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (model->impl->search_model), &child_iter,
- SEARCH_MODEL_COL_IS_FOLDER, &is_folder,
- -1);
-
- return is_folder;
-}
-
-static gboolean
-search_model_sort_drag_data_get (GtkTreeDragSource *drag_source,
- GtkTreePath *path,
- GtkSelectionData *selection_data)
-{
- SearchModelSort *model;
- GtkTreeIter iter, child_iter;
- GFile *file;
- gchar *uris[2];
-
- model = SEARCH_MODEL_SORT (drag_source);
- if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
- return FALSE;
-
- search_get_valid_child_iter (model->impl, &child_iter, &iter);
- gtk_tree_model_get (GTK_TREE_MODEL (model->impl->search_model), &child_iter,
- RECENT_MODEL_COL_FILE, &file,
- -1);
- g_assert (file != NULL);
-
- uris[0] = g_file_get_uri (file);
- uris[1] = NULL;
-
- gtk_selection_data_set_uris (selection_data, uris);
-
- g_free (uris[0]);
-
- return TRUE;
-}
-
-static void
-search_model_sort_drag_source_iface_init (GtkTreeDragSourceIface *iface)
-{
- iface->row_draggable = search_model_sort_row_draggable;
- iface->drag_data_get = search_model_sort_drag_data_get;
-}
-
-static void
-_search_model_sort_class_init (SearchModelSortClass *klass)
-{
-
-}
-
-static void
-_search_model_sort_init (SearchModelSort *model)
-{
- model->impl = NULL;
-}
-
-static GtkTreeModel *
-search_model_sort_new (GtkFileChooserDefault *impl,
- GtkTreeModel *child_model)
-{
- SearchModelSort *model;
-
- model = g_object_new (SEARCH_MODEL_SORT_TYPE,
- "model", child_model,
- NULL);
- model->impl = impl;
-
- return GTK_TREE_MODEL (model);
-}