/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* fm-canvas-view.c - implementation of canvas view of directory. Copyright (C) 2000, 2001 Eazel, Inc. The Gnome Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The Gnome Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the Gnome Library; see the file COPYING.LIB. If not, see . Authors: John Sullivan */ #include #include "nautilus-canvas-view.h" #include "nautilus-canvas-view-container.h" #include "nautilus-desktop-canvas-view.h" #include "nautilus-error-reporting.h" #include "nautilus-view-dnd.h" #include "nautilus-toolbar.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DEBUG_FLAG NAUTILUS_DEBUG_CANVAS_VIEW #include #include #include #include #include #include #include enum { PROP_SUPPORTS_AUTO_LAYOUT = 1, PROP_SUPPORTS_SCALING, PROP_SUPPORTS_KEEP_ALIGNED, PROP_SUPPORTS_MANUAL_LAYOUT, NUM_PROPERTIES }; static GParamSpec *properties[NUM_PROPERTIES] = { NULL, }; typedef gboolean (* SortCriterionMatchFunc) (NautilusFile *file); typedef struct { const NautilusFileSortType sort_type; const char *metadata_text; const char *action_target_name; SortCriterionMatchFunc match_func; } SortCriterion; typedef enum { MENU_ITEM_TYPE_STANDARD, MENU_ITEM_TYPE_CHECK, MENU_ITEM_TYPE_RADIO, MENU_ITEM_TYPE_TREE } MenuItemType; struct NautilusCanvasViewDetails { GList *icons_not_positioned; guint react_to_canvas_change_idle_id; const SortCriterion *sort; gboolean sort_reversed; gulong clipboard_handler_id; GtkWidget *canvas_container; gboolean supports_auto_layout; gboolean supports_manual_layout; gboolean supports_scaling; gboolean supports_keep_aligned; GIcon *icon; }; /* Note that the first item in this list is the default sort, * and that the items show up in the menu in the order they * appear in this list. */ static const SortCriterion sort_criteria[] = { { NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, "name", "name" }, { NAUTILUS_FILE_SORT_BY_SIZE, "size", "size" }, { NAUTILUS_FILE_SORT_BY_TYPE, "type", "type" }, { NAUTILUS_FILE_SORT_BY_MTIME, "modification date", "modification-date", }, { NAUTILUS_FILE_SORT_BY_ATIME, "access date", "access-date", }, { NAUTILUS_FILE_SORT_BY_TRASHED_TIME, "trashed", "trash-time", nautilus_file_is_in_trash }, { NAUTILUS_FILE_SORT_BY_SEARCH_RELEVANCE, NULL, "search-relevance", nautilus_file_is_in_search } }; static void nautilus_canvas_view_set_directory_sort_by (NautilusCanvasView *canvas_view, NautilusFile *file, const char *sort_by); static void nautilus_canvas_view_update_click_mode (NautilusCanvasView *canvas_view); static gboolean nautilus_canvas_view_supports_scaling (NautilusCanvasView *canvas_view); static void nautilus_canvas_view_reveal_selection (NautilusView *view); static const SortCriterion *get_sort_criterion_by_sort_type (NautilusFileSortType sort_type); static gboolean set_sort_reversed (NautilusCanvasView *canvas_view, gboolean new_value, gboolean set_metadata); static void switch_to_manual_layout (NautilusCanvasView *view); static NautilusFileSortType get_default_sort_order (NautilusFile *file, gboolean *reversed); static void nautilus_canvas_view_clear (NautilusView *view); G_DEFINE_TYPE (NautilusCanvasView, nautilus_canvas_view, NAUTILUS_TYPE_VIEW); static void nautilus_canvas_view_destroy (GtkWidget *object) { NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (object); nautilus_canvas_view_clear (NAUTILUS_VIEW (object)); if (canvas_view->details->react_to_canvas_change_idle_id != 0) { g_source_remove (canvas_view->details->react_to_canvas_change_idle_id); canvas_view->details->react_to_canvas_change_idle_id = 0; } if (canvas_view->details->clipboard_handler_id != 0) { g_signal_handler_disconnect (nautilus_clipboard_monitor_get (), canvas_view->details->clipboard_handler_id); canvas_view->details->clipboard_handler_id = 0; } if (canvas_view->details->icons_not_positioned) { nautilus_file_list_free (canvas_view->details->icons_not_positioned); canvas_view->details->icons_not_positioned = NULL; } GTK_WIDGET_CLASS (nautilus_canvas_view_parent_class)->destroy (object); } static NautilusCanvasContainer * get_canvas_container (NautilusCanvasView *canvas_view) { return NAUTILUS_CANVAS_CONTAINER (canvas_view->details->canvas_container); } NautilusCanvasContainer * nautilus_canvas_view_get_canvas_container (NautilusCanvasView *canvas_view) { return get_canvas_container (canvas_view); } static gboolean nautilus_canvas_view_supports_manual_layout (NautilusCanvasView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE); return view->details->supports_manual_layout; } static gboolean get_stored_icon_position_callback (NautilusCanvasContainer *container, NautilusFile *file, NautilusCanvasPosition *position, NautilusCanvasView *canvas_view) { char *position_string, *scale_string; gboolean position_good; char c; g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container)); g_assert (NAUTILUS_IS_FILE (file)); g_assert (position != NULL); g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); if (!nautilus_canvas_view_supports_manual_layout (canvas_view)) { return FALSE; } /* Get the current position of this canvas from the metadata. */ position_string = nautilus_file_get_metadata (file, NAUTILUS_METADATA_KEY_ICON_POSITION, ""); position_good = sscanf (position_string, " %d , %d %c", &position->x, &position->y, &c) == 2; g_free (position_string); /* If it is the desktop directory, maybe the gnome-libs metadata has information about it */ /* Disable scaling if not on the desktop */ if (nautilus_canvas_view_supports_scaling (canvas_view)) { /* Get the scale of the canvas from the metadata. */ scale_string = nautilus_file_get_metadata (file, NAUTILUS_METADATA_KEY_ICON_SCALE, "1"); position->scale = g_ascii_strtod (scale_string, NULL); if (errno != 0) { position->scale = 1.0; } g_free (scale_string); } else { position->scale = 1.0; } return position_good; } static void real_set_sort_criterion (NautilusCanvasView *canvas_view, const SortCriterion *sort, gboolean clear, gboolean set_metadata) { NautilusFile *file; file = nautilus_view_get_directory_as_file (NAUTILUS_VIEW (canvas_view)); if (clear) { nautilus_file_set_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_BY, NULL, NULL); nautilus_file_set_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_REVERSED, NULL, NULL); canvas_view->details->sort = get_sort_criterion_by_sort_type (get_default_sort_order (file, &canvas_view->details->sort_reversed)); } else if (set_metadata) { /* Store the new sort setting. */ nautilus_canvas_view_set_directory_sort_by (canvas_view, file, sort->metadata_text); } } static void set_sort_criterion (NautilusCanvasView *canvas_view, const SortCriterion *sort, gboolean set_metadata) { if (sort == NULL || canvas_view->details->sort == sort) { return; } canvas_view->details->sort = sort; real_set_sort_criterion (canvas_view, sort, FALSE, set_metadata); } void nautilus_canvas_view_clean_up_by_name (NautilusCanvasView *canvas_view) { NautilusCanvasContainer *canvas_container; gboolean saved_sort_reversed; canvas_container = get_canvas_container (canvas_view); /* Hardwire Clean Up to always be by name, in forward order */ saved_sort_reversed = canvas_view->details->sort_reversed; set_sort_reversed (canvas_view, FALSE, FALSE); set_sort_criterion (canvas_view, &sort_criteria[0], FALSE); nautilus_canvas_container_sort (canvas_container); nautilus_canvas_container_freeze_icon_positions (canvas_container); set_sort_reversed (canvas_view, saved_sort_reversed, FALSE); } static gboolean nautilus_canvas_view_using_auto_layout (NautilusCanvasView *canvas_view) { return nautilus_canvas_container_is_auto_layout (get_canvas_container (canvas_view)); } static void list_covers (NautilusCanvasIconData *data, gpointer callback_data) { GSList **file_list; file_list = callback_data; *file_list = g_slist_prepend (*file_list, data); } static void unref_cover (NautilusCanvasIconData *data, gpointer callback_data) { nautilus_file_unref (NAUTILUS_FILE (data)); } static void nautilus_canvas_view_clear (NautilusView *view) { NautilusCanvasContainer *canvas_container; GSList *file_list; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view)); if (!canvas_container) return; /* Clear away the existing icons. */ file_list = NULL; nautilus_canvas_container_for_each (canvas_container, list_covers, &file_list); nautilus_canvas_container_clear (canvas_container); g_slist_foreach (file_list, (GFunc)unref_cover, NULL); g_slist_free (file_list); } static void nautilus_canvas_view_remove_file (NautilusView *view, NautilusFile *file, NautilusDirectory *directory) { NautilusCanvasView *canvas_view; /* This used to assert that 'directory == nautilus_view_get_model (view)', but that * resulted in a lot of crash reports (bug #352592). I don't see how that trace happens. * It seems that somehow we get a files_changed event sent to the view from a directory * that isn't the model, but the code disables the monitor and signal callback handlers when * changing directories. Maybe we can get some more information when this happens. * Further discussion in bug #368178. */ if (directory != nautilus_view_get_model (view)) { char *file_uri, *dir_uri, *model_uri; file_uri = nautilus_file_get_uri (file); dir_uri = nautilus_directory_get_uri (directory); model_uri = nautilus_directory_get_uri (nautilus_view_get_model (view)); g_warning ("nautilus_canvas_view_remove_file() - directory not canvas view model, shouldn't happen.\n" "file: %p:%s, dir: %p:%s, model: %p:%s, view loading: %d\n" "If you see this, please add this info to http://bugzilla.gnome.org/show_bug.cgi?id=368178", file, file_uri, directory, dir_uri, nautilus_view_get_model (view), model_uri, nautilus_view_get_loading (view)); g_free (file_uri); g_free (dir_uri); g_free (model_uri); } canvas_view = NAUTILUS_CANVAS_VIEW (view); if (nautilus_canvas_container_remove (get_canvas_container (canvas_view), NAUTILUS_CANVAS_ICON_DATA (file))) { nautilus_file_unref (file); } } static void nautilus_canvas_view_add_file (NautilusView *view, NautilusFile *file, NautilusDirectory *directory) { NautilusCanvasView *canvas_view; NautilusCanvasContainer *canvas_container; g_assert (directory == nautilus_view_get_model (view)); canvas_view = NAUTILUS_CANVAS_VIEW (view); canvas_container = get_canvas_container (canvas_view); /* Reset scroll region for the first canvas added when loading a directory. */ if (nautilus_view_get_loading (view) && nautilus_canvas_container_is_empty (canvas_container)) { nautilus_canvas_container_reset_scroll_region (canvas_container); } if (nautilus_canvas_container_add (canvas_container, NAUTILUS_CANVAS_ICON_DATA (file))) { nautilus_file_ref (file); } } static void nautilus_canvas_view_file_changed (NautilusView *view, NautilusFile *file, NautilusDirectory *directory) { NautilusCanvasView *canvas_view; g_assert (directory == nautilus_view_get_model (view)); g_return_if_fail (view != NULL); canvas_view = NAUTILUS_CANVAS_VIEW (view); nautilus_canvas_container_request_update (get_canvas_container (canvas_view), NAUTILUS_CANVAS_ICON_DATA (file)); } static gboolean nautilus_canvas_view_supports_auto_layout (NautilusCanvasView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE); return view->details->supports_auto_layout; } static gboolean nautilus_canvas_view_supports_scaling (NautilusCanvasView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE); return view->details->supports_scaling; } static gboolean nautilus_canvas_view_supports_keep_aligned (NautilusCanvasView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE); return view->details->supports_keep_aligned; } static char * nautilus_canvas_view_get_directory_sort_by (NautilusCanvasView *canvas_view, NautilusFile *file) { const SortCriterion *default_sort_criterion; if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) { return g_strdup ("name"); } default_sort_criterion = get_sort_criterion_by_sort_type (get_default_sort_order (file, NULL)); g_return_val_if_fail (default_sort_criterion != NULL, NULL); return nautilus_file_get_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_BY, default_sort_criterion->metadata_text); } static NautilusFileSortType get_default_sort_order (NautilusFile *file, gboolean *reversed) { NautilusFileSortType retval, default_sort_order; gboolean default_sort_in_reverse_order; default_sort_order = g_settings_get_enum (nautilus_preferences, NAUTILUS_PREFERENCES_DEFAULT_SORT_ORDER); default_sort_in_reverse_order = g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_DEFAULT_SORT_IN_REVERSE_ORDER); retval = nautilus_file_get_default_sort_type (file, reversed); if (retval == NAUTILUS_FILE_SORT_NONE) { if (reversed != NULL) { *reversed = default_sort_in_reverse_order; } retval = CLAMP (default_sort_order, NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, NAUTILUS_FILE_SORT_BY_ATIME); } return retval; } static void nautilus_canvas_view_set_directory_sort_by (NautilusCanvasView *canvas_view, NautilusFile *file, const char *sort_by) { const SortCriterion *default_sort_criterion; if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) { return; } default_sort_criterion = get_sort_criterion_by_sort_type (get_default_sort_order (file, NULL)); g_return_if_fail (default_sort_criterion != NULL); nautilus_file_set_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_BY, default_sort_criterion->metadata_text, sort_by); } static gboolean nautilus_canvas_view_get_directory_sort_reversed (NautilusCanvasView *canvas_view, NautilusFile *file) { gboolean reversed; if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) { return FALSE; } get_default_sort_order (file, &reversed); return nautilus_file_get_boolean_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_REVERSED, reversed); } static void nautilus_canvas_view_set_directory_sort_reversed (NautilusCanvasView *canvas_view, NautilusFile *file, gboolean sort_reversed) { gboolean reversed; if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) { return; } get_default_sort_order (file, &reversed); nautilus_file_set_boolean_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_REVERSED, reversed, sort_reversed); } static gboolean get_default_directory_keep_aligned (void) { return TRUE; } static gboolean nautilus_canvas_view_get_directory_keep_aligned (NautilusCanvasView *canvas_view, NautilusFile *file) { if (!nautilus_canvas_view_supports_keep_aligned (canvas_view)) { return FALSE; } return nautilus_file_get_boolean_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_KEEP_ALIGNED, get_default_directory_keep_aligned ()); } static void nautilus_canvas_view_set_directory_keep_aligned (NautilusCanvasView *canvas_view, NautilusFile *file, gboolean keep_aligned) { if (!nautilus_canvas_view_supports_keep_aligned (canvas_view)) { return; } nautilus_file_set_boolean_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_KEEP_ALIGNED, get_default_directory_keep_aligned (), keep_aligned); } static gboolean nautilus_canvas_view_get_directory_auto_layout (NautilusCanvasView *canvas_view, NautilusFile *file) { if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) { return FALSE; } if (!nautilus_canvas_view_supports_manual_layout (canvas_view)) { return TRUE; } return nautilus_file_get_boolean_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_AUTO_LAYOUT, TRUE); } static void nautilus_canvas_view_set_directory_auto_layout (NautilusCanvasView *canvas_view, NautilusFile *file, gboolean auto_layout) { if (!nautilus_canvas_view_supports_auto_layout (canvas_view) || !nautilus_canvas_view_supports_manual_layout (canvas_view)) { return; } nautilus_file_set_boolean_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_AUTO_LAYOUT, TRUE, auto_layout); } static gboolean set_sort_reversed (NautilusCanvasView *canvas_view, gboolean new_value, gboolean set_metadata) { if (canvas_view->details->sort_reversed == new_value) { return FALSE; } canvas_view->details->sort_reversed = new_value; if (set_metadata) { /* Store the new sort setting. */ nautilus_canvas_view_set_directory_sort_reversed (canvas_view, nautilus_view_get_directory_as_file (NAUTILUS_VIEW (canvas_view)), new_value); } return TRUE; } static const SortCriterion * get_sort_criterion_by_metadata_text (const char *metadata_text) { guint i; /* Figure out what the new sort setting should be. */ for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++) { if (g_strcmp0 (sort_criteria[i].metadata_text, metadata_text) == 0) { return &sort_criteria[i]; } } return NULL; } static const SortCriterion * get_sort_criterion_by_action_target_name (const char *action_target_name) { guint i; /* Figure out what the new sort setting should be. */ for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++) { if (g_strcmp0 (sort_criteria[i].action_target_name, action_target_name) == 0) { return &sort_criteria[i]; } } return NULL; } static const SortCriterion * get_sort_criterion_by_sort_type (NautilusFileSortType sort_type) { guint i; /* Figure out what the new sort setting should be. */ for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++) { if (sort_type == sort_criteria[i].sort_type) { return &sort_criteria[i]; } } return &sort_criteria[0]; } static NautilusCanvasZoomLevel get_default_zoom_level (NautilusCanvasView *canvas_view) { NautilusCanvasZoomLevel default_zoom_level; default_zoom_level = g_settings_get_enum (nautilus_icon_view_preferences, NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL); return CLAMP (default_zoom_level, NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL, NAUTILUS_CANVAS_ZOOM_LEVEL_LARGE); } static void nautilus_canvas_view_begin_loading (NautilusView *view) { NautilusCanvasView *canvas_view; GtkWidget *canvas_container; NautilusFile *file; char *sort_name, *uri; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); canvas_view = NAUTILUS_CANVAS_VIEW (view); file = nautilus_view_get_directory_as_file (view); uri = nautilus_file_get_uri (file); canvas_container = GTK_WIDGET (get_canvas_container (canvas_view)); nautilus_canvas_container_begin_loading (NAUTILUS_CANVAS_CONTAINER (canvas_container)); g_free (uri); /* Set the sort mode. * It's OK not to resort the icons because the * container doesn't have any icons at this point. */ sort_name = nautilus_canvas_view_get_directory_sort_by (canvas_view, file); set_sort_criterion (canvas_view, get_sort_criterion_by_metadata_text (sort_name), FALSE); g_free (sort_name); /* Set the sort direction from the metadata. */ set_sort_reversed (canvas_view, nautilus_canvas_view_get_directory_sort_reversed (canvas_view, file), FALSE); nautilus_canvas_container_set_keep_aligned (get_canvas_container (canvas_view), nautilus_canvas_view_get_directory_keep_aligned (canvas_view, file)); /* We must set auto-layout last, because it invokes the layout_changed * callback, which works incorrectly if the other layout criteria are * not already set up properly (see bug 6500, e.g.) */ nautilus_canvas_container_set_auto_layout (get_canvas_container (canvas_view), nautilus_canvas_view_get_directory_auto_layout (canvas_view, file)); /* We could changed to the trash directory or to searching, and then we * need to update the menus */ nautilus_view_update_context_menus(view); nautilus_view_update_toolbar_menus(view); } static void canvas_view_notify_clipboard_info (NautilusClipboardMonitor *monitor, NautilusClipboardInfo *info, NautilusCanvasView *canvas_view) { GList *icon_data; icon_data = NULL; if (info && info->cut) { icon_data = info->files; } nautilus_canvas_container_set_highlighted_for_clipboard ( get_canvas_container (canvas_view), icon_data); } static void nautilus_canvas_view_end_loading (NautilusView *view, gboolean all_files_seen) { NautilusCanvasView *canvas_view; GtkWidget *canvas_container; NautilusClipboardMonitor *monitor; NautilusClipboardInfo *info; canvas_view = NAUTILUS_CANVAS_VIEW (view); canvas_container = GTK_WIDGET (get_canvas_container (canvas_view)); nautilus_canvas_container_end_loading (NAUTILUS_CANVAS_CONTAINER (canvas_container), all_files_seen); monitor = nautilus_clipboard_monitor_get (); info = nautilus_clipboard_monitor_get_clipboard_info (monitor); canvas_view_notify_clipboard_info (monitor, info, canvas_view); } static NautilusCanvasZoomLevel nautilus_canvas_view_get_zoom_level (NautilusView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NAUTILUS_CANVAS_ZOOM_LEVEL_STANDARD); return nautilus_canvas_container_get_zoom_level (get_canvas_container (NAUTILUS_CANVAS_VIEW (view))); } static void nautilus_canvas_view_zoom_to_level (NautilusView *view, gint new_level) { NautilusCanvasView *canvas_view; NautilusCanvasContainer *canvas_container; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); g_return_if_fail (new_level >= NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL && new_level <= NAUTILUS_CANVAS_ZOOM_LEVEL_LARGE); canvas_view = NAUTILUS_CANVAS_VIEW (view); canvas_container = get_canvas_container (canvas_view); if (nautilus_canvas_container_get_zoom_level (canvas_container) == new_level) return; nautilus_canvas_container_set_zoom_level (canvas_container, new_level); g_action_group_change_action_state (nautilus_view_get_action_group (view), "zoom-to-level", g_variant_new_int32 (new_level)); nautilus_view_update_toolbar_menus (view); } static void nautilus_canvas_view_bump_zoom_level (NautilusView *view, int zoom_increment) { NautilusCanvasZoomLevel new_level; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); if (!nautilus_view_supports_zooming (view)) { return; } new_level = nautilus_canvas_view_get_zoom_level (view) + zoom_increment; if (new_level >= NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL && new_level <= NAUTILUS_CANVAS_ZOOM_LEVEL_LARGE) { nautilus_canvas_view_zoom_to_level (view, new_level); } } static void nautilus_canvas_view_restore_default_zoom_level (NautilusView *view) { NautilusCanvasView *canvas_view; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); canvas_view = NAUTILUS_CANVAS_VIEW (view); nautilus_canvas_view_zoom_to_level (view, get_default_zoom_level (canvas_view)); } static gboolean nautilus_canvas_view_can_zoom_in (NautilusView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE); return nautilus_canvas_view_get_zoom_level (view) < NAUTILUS_CANVAS_ZOOM_LEVEL_LARGE; } static gboolean nautilus_canvas_view_can_zoom_out (NautilusView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE); return nautilus_canvas_view_get_zoom_level (view) > NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL; } static gboolean nautilus_canvas_view_is_empty (NautilusView *view) { g_assert (NAUTILUS_IS_CANVAS_VIEW (view)); return nautilus_canvas_container_is_empty (get_canvas_container (NAUTILUS_CANVAS_VIEW (view))); } static GList * nautilus_canvas_view_get_selection (NautilusView *view) { GList *list; g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NULL); list = nautilus_canvas_container_get_selection (get_canvas_container (NAUTILUS_CANVAS_VIEW (view))); nautilus_file_list_ref (list); return list; } static void action_reversed_order (GSimpleAction *action, GVariant *state, gpointer user_data) { gboolean reversed_order; g_assert (NAUTILUS_IS_CANVAS_VIEW (user_data)); reversed_order = g_variant_get_boolean (state); if (set_sort_reversed (user_data, reversed_order, TRUE)) { nautilus_canvas_container_sort (get_canvas_container (user_data)); nautilus_canvas_view_reveal_selection (NAUTILUS_VIEW (user_data)); } g_simple_action_set_state (action, state); } static void action_keep_aligned (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFile *file; NautilusCanvasView *canvas_view; gboolean keep_aligned; canvas_view = NAUTILUS_CANVAS_VIEW (user_data); file = nautilus_view_get_directory_as_file (NAUTILUS_VIEW (canvas_view)); keep_aligned = g_variant_get_boolean (state); nautilus_canvas_view_set_directory_keep_aligned (canvas_view, file, keep_aligned); nautilus_canvas_container_set_keep_aligned (get_canvas_container (canvas_view), keep_aligned); g_simple_action_set_state (action, state); } static void action_sort_order_changed (GSimpleAction *action, GVariant *value, gpointer user_data) { const gchar *target_name; const SortCriterion *sort_criterion; g_assert (NAUTILUS_IS_CANVAS_VIEW (user_data)); target_name = g_variant_get_string (value, NULL); sort_criterion = get_sort_criterion_by_action_target_name (target_name); g_assert (sort_criterion != NULL); /* Note that id might be a toggle item. * Ignore non-sort ids so that they don't cause sorting. */ if (sort_criterion->sort_type == NAUTILUS_FILE_SORT_NONE) { switch_to_manual_layout (user_data); } else { set_sort_criterion (user_data, sort_criterion, TRUE); nautilus_canvas_container_sort (get_canvas_container (user_data)); nautilus_canvas_view_reveal_selection (NAUTILUS_VIEW (user_data)); } g_simple_action_set_state (action, value); } static void action_zoom_to_level (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusView *view; NautilusCanvasZoomLevel zoom_level; g_assert (NAUTILUS_IS_VIEW (user_data)); view = NAUTILUS_VIEW (user_data); zoom_level = g_variant_get_int32 (state); nautilus_canvas_view_zoom_to_level (view, zoom_level); g_simple_action_set_state (G_SIMPLE_ACTION (action), state); g_settings_set_enum (nautilus_icon_view_preferences, NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL, zoom_level); } static void switch_to_manual_layout (NautilusCanvasView *canvas_view) { if (!nautilus_canvas_view_using_auto_layout (canvas_view) || !nautilus_view_is_editable (NAUTILUS_VIEW (canvas_view))) { return; } canvas_view->details->sort = &sort_criteria[0]; nautilus_canvas_container_set_auto_layout (get_canvas_container (canvas_view), FALSE); } static void layout_changed_callback (NautilusCanvasContainer *container, NautilusCanvasView *canvas_view) { NautilusFile *file; g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); file = nautilus_view_get_directory_as_file (NAUTILUS_VIEW (canvas_view)); if (file != NULL) { nautilus_canvas_view_set_directory_auto_layout (canvas_view, file, nautilus_canvas_view_using_auto_layout (canvas_view)); } } static gboolean nautilus_canvas_view_can_rename_file (NautilusView *view, NautilusFile *file) { return NAUTILUS_VIEW_CLASS(nautilus_canvas_view_parent_class)->can_rename_file (view, file); } const GActionEntry canvas_view_entries[] = { { "keep-aligned", NULL, NULL, "true", action_keep_aligned }, { "reversed-order", NULL, NULL, "false", action_reversed_order }, { "sort", NULL, "s", "'name'", action_sort_order_changed }, { "zoom-to-level", NULL, NULL, "1", action_zoom_to_level } }; static void update_sort_action_state_hint (NautilusCanvasView *canvas_view) { NautilusFile *file; GVariantBuilder builder; GActionGroup *action_group; GAction *action; GVariant *state_hint; gint idx; file = nautilus_view_get_directory_as_file (NAUTILUS_VIEW (canvas_view)); g_variant_builder_init (&builder, G_VARIANT_TYPE ("as")); for (idx = 0; idx < G_N_ELEMENTS (sort_criteria); idx++) { if (sort_criteria[idx].match_func == NULL || (file != NULL && sort_criteria[idx].match_func (file))) g_variant_builder_add (&builder, "s", sort_criteria[idx].action_target_name); } state_hint = g_variant_builder_end (&builder); action_group = nautilus_view_get_action_group (NAUTILUS_VIEW (canvas_view)); action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "sort"); g_simple_action_set_state_hint (G_SIMPLE_ACTION (action), state_hint); g_variant_unref (state_hint); } static gboolean showing_recent_directory (NautilusView *view) { NautilusFile *file; file = nautilus_view_get_directory_as_file (view); if (file != NULL) { return nautilus_file_is_in_recent (file); } return FALSE; } static gboolean showing_search_directory (NautilusView *view) { NautilusFile *file; file = nautilus_view_get_directory_as_file (view); if (file != NULL) { return nautilus_file_is_in_search (file); } return FALSE; } static void nautilus_canvas_view_update_actions_state (NautilusView *view) { GActionGroup *view_action_group; GAction *action; gboolean keep_aligned; NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (view); NAUTILUS_VIEW_CLASS (nautilus_canvas_view_parent_class)->update_actions_state (view); view_action_group = nautilus_view_get_action_group (view); if (nautilus_canvas_view_supports_auto_layout (canvas_view)) { GVariant *sort_state; GVariant *reversed_state; /* When we change the sort action state, even using the same value, it triggers * the sort action changed handler, which reveals the selection, since we expect * the selection to be visible when the user changes the sort order. But we may * need to update the actions state for others reason than an actual sort change, * so we need to prevent to trigger the sort action changed handler for those cases. * To achieve this, check if the action state value actually changed before setting * it. The same happens to the reversed-order state. */ sort_state = g_action_group_get_action_state (view_action_group, "sort"); reversed_state = g_action_group_get_action_state (view_action_group, "reversed-order"); if (NAUTILUS_CANVAS_VIEW (view)->details->sort_reversed != g_variant_get_boolean (reversed_state)) { g_action_group_change_action_state (view_action_group, "reversed-order", g_variant_new_boolean (NAUTILUS_CANVAS_VIEW (view)->details->sort_reversed)); } if (g_strcmp0 (g_variant_get_string (sort_state, NULL), NAUTILUS_CANVAS_VIEW (view)->details->sort->action_target_name) != 0) { g_action_group_change_action_state (view_action_group, "sort", g_variant_new_string (NAUTILUS_CANVAS_VIEW (view)->details->sort->action_target_name)); } g_variant_unref (reversed_state); g_variant_unref (sort_state); } action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "keep-aligned"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), canvas_view->details->supports_keep_aligned); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "sort"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !showing_recent_directory (view) && !showing_search_directory (view)); if (canvas_view->details->supports_keep_aligned) { keep_aligned = nautilus_canvas_container_is_keep_aligned (get_canvas_container (canvas_view)); g_action_change_state (action, g_variant_new_boolean (keep_aligned)); } update_sort_action_state_hint (canvas_view); } static void nautilus_canvas_view_select_all (NautilusView *view) { NautilusCanvasContainer *canvas_container; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view)); nautilus_canvas_container_select_all (canvas_container); } static void nautilus_canvas_view_select_first (NautilusView *view) { NautilusCanvasContainer *canvas_container; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view)); nautilus_canvas_container_select_first (canvas_container); } static void nautilus_canvas_view_reveal_selection (NautilusView *view) { GList *selection; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); selection = nautilus_view_get_selection (view); /* Make sure at least one of the selected items is scrolled into view */ if (selection != NULL) { nautilus_canvas_container_reveal (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), selection->data); } nautilus_file_list_free (selection); } static GArray * nautilus_canvas_view_get_selected_icon_locations (NautilusView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NULL); return nautilus_canvas_container_get_selected_icon_locations (get_canvas_container (NAUTILUS_CANVAS_VIEW (view))); } static void nautilus_canvas_view_set_selection (NautilusView *view, GList *selection) { g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); nautilus_canvas_container_set_selection (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), selection); } static void nautilus_canvas_view_invert_selection (NautilusView *view) { g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view)); nautilus_canvas_container_invert_selection (get_canvas_container (NAUTILUS_CANVAS_VIEW (view))); } static gboolean nautilus_canvas_view_using_manual_layout (NautilusView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE); return !nautilus_canvas_view_using_auto_layout (NAUTILUS_CANVAS_VIEW (view)); } static void nautilus_canvas_view_widget_to_file_operation_position (NautilusView *view, GdkPoint *position) { g_assert (NAUTILUS_IS_CANVAS_VIEW (view)); nautilus_canvas_container_widget_to_file_operation_position (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), position); } static void canvas_container_activate_callback (NautilusCanvasContainer *container, GList *file_list, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); nautilus_view_activate_files (NAUTILUS_VIEW (canvas_view), file_list, 0, TRUE); } static void canvas_container_activate_previewer_callback (NautilusCanvasContainer *container, GList *file_list, GArray *locations, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); nautilus_view_preview_files (NAUTILUS_VIEW (canvas_view), file_list, locations); } /* this is called in one of these cases: * - we activate with enter holding shift * - we activate with space holding shift * - we double click an canvas holding shift * - we middle click an canvas * * If we don't open in new windows by default, the behavior should be * - middle click, shift + activate -> open in new tab * - shift + double click -> open in new window * * If we open in new windows by default, the behaviour should be * - middle click, or shift + activate, or shift + double-click -> close parent */ static void canvas_container_activate_alternate_callback (NautilusCanvasContainer *container, GList *file_list, NautilusCanvasView *canvas_view) { GdkEvent *event; GdkEventButton *button_event; GdkEventKey *key_event; gboolean open_in_tab, open_in_window, close_behind; NautilusWindowOpenFlags flags; g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); flags = 0; event = gtk_get_current_event (); open_in_tab = FALSE; open_in_window = FALSE; close_behind = FALSE; if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE || event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS) { button_event = (GdkEventButton *) event; open_in_window = ((button_event->state & GDK_SHIFT_MASK) != 0); open_in_tab = !open_in_window; } else if (event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE) { key_event = (GdkEventKey *) event; open_in_tab = ((key_event->state & GDK_SHIFT_MASK) != 0); } if (open_in_tab) { flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB; } if (open_in_window) { flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW; } if (close_behind) { flags |= NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND; } DEBUG ("Activate alternate, open in tab %d, close behind %d, new window %d\n", open_in_tab, close_behind, open_in_window); nautilus_view_activate_files (NAUTILUS_VIEW (canvas_view), file_list, flags, TRUE); } static void band_select_started_callback (NautilusCanvasContainer *container, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); nautilus_view_start_batching_selection_changes (NAUTILUS_VIEW (canvas_view)); } static void band_select_ended_callback (NautilusCanvasContainer *container, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); nautilus_view_stop_batching_selection_changes (NAUTILUS_VIEW (canvas_view)); } int nautilus_canvas_view_compare_files (NautilusCanvasView *canvas_view, NautilusFile *a, NautilusFile *b) { return nautilus_file_compare_for_sort (a, b, canvas_view->details->sort->sort_type, /* Use type-unsafe cast for performance */ nautilus_view_should_sort_directories_first ((NautilusView *)canvas_view), canvas_view->details->sort_reversed); } static int compare_files (NautilusView *canvas_view, NautilusFile *a, NautilusFile *b) { return nautilus_canvas_view_compare_files ((NautilusCanvasView *)canvas_view, a, b); } static void selection_changed_callback (NautilusCanvasContainer *container, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); nautilus_view_notify_selection_changed (NAUTILUS_VIEW (canvas_view)); } static void canvas_container_context_click_selection_callback (NautilusCanvasContainer *container, GdkEventButton *event, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container)); g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); nautilus_view_pop_up_selection_context_menu (NAUTILUS_VIEW (canvas_view), event); } static void canvas_container_context_click_background_callback (NautilusCanvasContainer *container, GdkEventButton *event, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container)); g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); nautilus_view_pop_up_background_context_menu (NAUTILUS_VIEW (canvas_view), event); } static void icon_position_changed_callback (NautilusCanvasContainer *container, NautilusFile *file, const NautilusCanvasPosition *position, NautilusCanvasView *canvas_view) { char *position_string; char scale_string[G_ASCII_DTOSTR_BUF_SIZE]; g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); g_assert (container == get_canvas_container (canvas_view)); g_assert (NAUTILUS_IS_FILE (file)); /* Store the new position of the canvas in the metadata. */ if (!nautilus_canvas_view_using_auto_layout (canvas_view)) { position_string = g_strdup_printf ("%d,%d", position->x, position->y); nautilus_file_set_metadata (file, NAUTILUS_METADATA_KEY_ICON_POSITION, NULL, position_string); g_free (position_string); } g_ascii_dtostr (scale_string, sizeof (scale_string), position->scale); nautilus_file_set_metadata (file, NAUTILUS_METADATA_KEY_ICON_SCALE, "1.0", scale_string); } static char * get_icon_uri_callback (NautilusCanvasContainer *container, NautilusFile *file, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container)); g_assert (NAUTILUS_IS_FILE (file)); g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); return nautilus_file_get_uri (file); } static char * get_icon_activation_uri_callback (NautilusCanvasContainer *container, NautilusFile *file, NautilusCanvasView *canvas_view) { g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container)); g_assert (NAUTILUS_IS_FILE (file)); g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view)); return nautilus_file_get_activation_uri (file); } static char * get_icon_drop_target_uri_callback (NautilusCanvasContainer *container, NautilusFile *file, NautilusCanvasView *canvas_view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (container), NULL); g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL); g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (canvas_view), NULL); return nautilus_file_get_drop_target_uri (file); } /* Preferences changed callbacks */ static void nautilus_canvas_view_click_policy_changed (NautilusView *directory_view) { g_assert (NAUTILUS_IS_CANVAS_VIEW (directory_view)); nautilus_canvas_view_update_click_mode (NAUTILUS_CANVAS_VIEW (directory_view)); } static void image_display_policy_changed_callback (gpointer callback_data) { NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (callback_data); nautilus_canvas_container_request_update_all (get_canvas_container (canvas_view)); } static void text_attribute_names_changed_callback (gpointer callback_data) { NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (callback_data); nautilus_canvas_container_request_update_all (get_canvas_container (canvas_view)); } static void default_sort_order_changed_callback (gpointer callback_data) { NautilusCanvasView *canvas_view; NautilusFile *file; char *sort_name; NautilusCanvasContainer *canvas_container; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (callback_data)); canvas_view = NAUTILUS_CANVAS_VIEW (callback_data); file = nautilus_view_get_directory_as_file (NAUTILUS_VIEW (canvas_view)); sort_name = nautilus_canvas_view_get_directory_sort_by (canvas_view, file); set_sort_criterion (canvas_view, get_sort_criterion_by_metadata_text (sort_name), FALSE); g_free (sort_name); canvas_container = get_canvas_container (canvas_view); g_return_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (canvas_container)); nautilus_canvas_container_request_update_all (canvas_container); } static void default_sort_in_reverse_order_changed_callback (gpointer callback_data) { NautilusCanvasView *canvas_view; NautilusFile *file; NautilusCanvasContainer *canvas_container; g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (callback_data)); canvas_view = NAUTILUS_CANVAS_VIEW (callback_data); file = nautilus_view_get_directory_as_file (NAUTILUS_VIEW (canvas_view)); set_sort_reversed (canvas_view, nautilus_canvas_view_get_directory_sort_reversed (canvas_view, file), FALSE); canvas_container = get_canvas_container (canvas_view); g_return_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (canvas_container)); nautilus_canvas_container_request_update_all (canvas_container); } static void nautilus_canvas_view_sort_directories_first_changed (NautilusView *directory_view) { NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (directory_view); if (nautilus_canvas_view_using_auto_layout (canvas_view)) { nautilus_canvas_container_sort (get_canvas_container (canvas_view)); } } static gboolean canvas_view_can_accept_item (NautilusCanvasContainer *container, NautilusFile *target_item, const char *item_uri, NautilusView *view) { return nautilus_drag_can_accept_item (target_item, item_uri); } static char * canvas_view_get_container_uri (NautilusCanvasContainer *container, NautilusView *view) { return nautilus_view_get_uri (view); } static void canvas_view_move_copy_items (NautilusCanvasContainer *container, const GList *item_uris, GArray *relative_item_points, const char *target_dir, int copy_action, int x, int y, NautilusView *view) { nautilus_clipboard_clear_if_colliding_uris (GTK_WIDGET (view), item_uris, nautilus_view_get_copied_files_atom (view)); nautilus_view_move_copy_items (view, item_uris, relative_item_points, target_dir, copy_action, x, y); } static void nautilus_canvas_view_update_click_mode (NautilusCanvasView *canvas_view) { NautilusCanvasContainer *canvas_container; int click_mode; canvas_container = get_canvas_container (canvas_view); g_assert (canvas_container != NULL); click_mode = g_settings_get_enum (nautilus_preferences, NAUTILUS_PREFERENCES_CLICK_POLICY); nautilus_canvas_container_set_single_click_mode (canvas_container, click_mode == NAUTILUS_CLICK_POLICY_SINGLE); } static gboolean get_stored_layout_timestamp (NautilusCanvasContainer *container, NautilusCanvasIconData *icon_data, time_t *timestamp, NautilusCanvasView *view) { NautilusFile *file; NautilusDirectory *directory; if (icon_data == NULL) { directory = nautilus_view_get_model (NAUTILUS_VIEW (view)); if (directory == NULL) { return FALSE; } file = nautilus_directory_get_corresponding_file (directory); *timestamp = nautilus_file_get_time_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_LAYOUT_TIMESTAMP); nautilus_file_unref (file); } else { *timestamp = nautilus_file_get_time_metadata (NAUTILUS_FILE (icon_data), NAUTILUS_METADATA_KEY_ICON_POSITION_TIMESTAMP); } return TRUE; } static gboolean store_layout_timestamp (NautilusCanvasContainer *container, NautilusCanvasIconData *icon_data, const time_t *timestamp, NautilusCanvasView *view) { NautilusFile *file; NautilusDirectory *directory; if (icon_data == NULL) { directory = nautilus_view_get_model (NAUTILUS_VIEW (view)); if (directory == NULL) { return FALSE; } file = nautilus_directory_get_corresponding_file (directory); nautilus_file_set_time_metadata (file, NAUTILUS_METADATA_KEY_ICON_VIEW_LAYOUT_TIMESTAMP, (time_t) *timestamp); nautilus_file_unref (file); } else { nautilus_file_set_time_metadata (NAUTILUS_FILE (icon_data), NAUTILUS_METADATA_KEY_ICON_POSITION_TIMESTAMP, (time_t) *timestamp); } return TRUE; } static NautilusCanvasContainer * create_canvas_container (NautilusCanvasView *canvas_view) { NautilusCanvasContainer *canvas_container; GtkWidget *content_widget; content_widget = nautilus_view_get_content_widget (NAUTILUS_VIEW (canvas_view)); canvas_container = nautilus_canvas_view_container_new (canvas_view); canvas_view->details->canvas_container = GTK_WIDGET (canvas_container); g_object_add_weak_pointer (G_OBJECT (canvas_container), (gpointer *) &canvas_view->details->canvas_container); gtk_widget_set_can_focus (GTK_WIDGET (canvas_container), TRUE); g_signal_connect_object (canvas_container, "activate", G_CALLBACK (canvas_container_activate_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "activate-alternate", G_CALLBACK (canvas_container_activate_alternate_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "activate-previewer", G_CALLBACK (canvas_container_activate_previewer_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "band-select-started", G_CALLBACK (band_select_started_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "band-select-ended", G_CALLBACK (band_select_ended_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "context-click-selection", G_CALLBACK (canvas_container_context_click_selection_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "context-click-background", G_CALLBACK (canvas_container_context_click_background_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "icon-position-changed", G_CALLBACK (icon_position_changed_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "selection-changed", G_CALLBACK (selection_changed_callback), canvas_view, 0); /* FIXME: many of these should move into fm-canvas-container as virtual methods */ g_signal_connect_object (canvas_container, "get-icon-uri", G_CALLBACK (get_icon_uri_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "get-icon-activation-uri", G_CALLBACK (get_icon_activation_uri_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "get-icon-drop-target-uri", G_CALLBACK (get_icon_drop_target_uri_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "move-copy-items", G_CALLBACK (canvas_view_move_copy_items), canvas_view, 0); g_signal_connect_object (canvas_container, "get-container-uri", G_CALLBACK (canvas_view_get_container_uri), canvas_view, 0); g_signal_connect_object (canvas_container, "can-accept-item", G_CALLBACK (canvas_view_can_accept_item), canvas_view, 0); g_signal_connect_object (canvas_container, "get-stored-icon-position", G_CALLBACK (get_stored_icon_position_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "layout-changed", G_CALLBACK (layout_changed_callback), canvas_view, 0); g_signal_connect_object (canvas_container, "icon-stretch-started", G_CALLBACK (nautilus_view_update_context_menus), canvas_view, G_CONNECT_SWAPPED); g_signal_connect_object (canvas_container, "icon-stretch-ended", G_CALLBACK (nautilus_view_update_context_menus), canvas_view, G_CONNECT_SWAPPED); g_signal_connect_object (canvas_container, "get-stored-layout-timestamp", G_CALLBACK (get_stored_layout_timestamp), canvas_view, 0); g_signal_connect_object (canvas_container, "store-layout-timestamp", G_CALLBACK (store_layout_timestamp), canvas_view, 0); gtk_container_add (GTK_CONTAINER (content_widget), GTK_WIDGET (canvas_container)); nautilus_canvas_view_update_click_mode (canvas_view); nautilus_canvas_container_set_zoom_level (canvas_container, get_default_zoom_level (canvas_view)); gtk_widget_show (GTK_WIDGET (canvas_container)); return canvas_container; } /* Handles an URL received from Mozilla */ static void canvas_view_handle_netscape_url (NautilusCanvasContainer *container, const char *encoded_url, const char *target_uri, GdkDragAction action, int x, int y, NautilusCanvasView *view) { nautilus_view_handle_netscape_url_drop (NAUTILUS_VIEW (view), encoded_url, target_uri, action, x, y); } static void canvas_view_handle_uri_list (NautilusCanvasContainer *container, const char *item_uris, const char *target_uri, GdkDragAction action, int x, int y, NautilusCanvasView *view) { nautilus_view_handle_uri_list_drop (NAUTILUS_VIEW (view), item_uris, target_uri, action, x, y); } static void canvas_view_handle_text (NautilusCanvasContainer *container, const char *text, const char *target_uri, GdkDragAction action, int x, int y, NautilusCanvasView *view) { nautilus_view_handle_text_drop (NAUTILUS_VIEW (view), text, target_uri, action, x, y); } static void canvas_view_handle_raw (NautilusCanvasContainer *container, const char *raw_data, int length, const char *target_uri, const char *direct_save_uri, GdkDragAction action, int x, int y, NautilusCanvasView *view) { nautilus_view_handle_raw_drop (NAUTILUS_VIEW (view), raw_data, length, target_uri, direct_save_uri, action, x, y); } static void canvas_view_handle_hover (NautilusCanvasContainer *container, const char *target_uri, NautilusCanvasView *view) { nautilus_view_handle_hover (NAUTILUS_VIEW (view), target_uri); } static char * canvas_view_get_first_visible_file (NautilusView *view) { NautilusFile *file; NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (view); file = NAUTILUS_FILE (nautilus_canvas_container_get_first_visible_icon (get_canvas_container (canvas_view))); if (file) { return nautilus_file_get_uri (file); } return NULL; } static void canvas_view_scroll_to_file (NautilusView *view, const char *uri) { NautilusFile *file; NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (view); if (uri != NULL) { /* Only if existing, since we don't want to add the file to the directory if it has been removed since then */ file = nautilus_file_get_existing_by_uri (uri); if (file != NULL) { nautilus_canvas_container_scroll_to_canvas (get_canvas_container (canvas_view), NAUTILUS_CANVAS_ICON_DATA (file)); nautilus_file_unref (file); } } } static const char * nautilus_canvas_view_get_id (NautilusView *view) { return NAUTILUS_CANVAS_VIEW_ID; } static void nautilus_canvas_view_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (object); switch (prop_id) { case PROP_SUPPORTS_AUTO_LAYOUT: canvas_view->details->supports_auto_layout = g_value_get_boolean (value); break; case PROP_SUPPORTS_MANUAL_LAYOUT: canvas_view->details->supports_manual_layout = g_value_get_boolean (value); break; case PROP_SUPPORTS_SCALING: canvas_view->details->supports_scaling = g_value_get_boolean (value); break; case PROP_SUPPORTS_KEEP_ALIGNED: canvas_view->details->supports_keep_aligned = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void nautilus_canvas_view_finalize (GObject *object) { NautilusCanvasView *canvas_view; canvas_view = NAUTILUS_CANVAS_VIEW (object); g_clear_object (&canvas_view->details->icon); g_free (canvas_view->details); g_signal_handlers_disconnect_by_func (nautilus_preferences, default_sort_order_changed_callback, canvas_view); g_signal_handlers_disconnect_by_func (nautilus_preferences, default_sort_in_reverse_order_changed_callback, canvas_view); g_signal_handlers_disconnect_by_func (nautilus_preferences, image_display_policy_changed_callback, canvas_view); g_signal_handlers_disconnect_by_func (nautilus_icon_view_preferences, text_attribute_names_changed_callback, canvas_view); G_OBJECT_CLASS (nautilus_canvas_view_parent_class)->finalize (object); } static GIcon* nautilus_canvas_view_get_icon (NautilusView *view) { g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NULL); return NAUTILUS_CANVAS_VIEW (view)->details->icon; } static void nautilus_canvas_view_class_init (NautilusCanvasViewClass *klass) { NautilusViewClass *nautilus_view_class; GObjectClass *oclass; nautilus_view_class = NAUTILUS_VIEW_CLASS (klass); oclass = G_OBJECT_CLASS (klass); oclass->set_property = nautilus_canvas_view_set_property; oclass->finalize = nautilus_canvas_view_finalize; GTK_WIDGET_CLASS (klass)->destroy = nautilus_canvas_view_destroy; nautilus_view_class->add_file = nautilus_canvas_view_add_file; nautilus_view_class->begin_loading = nautilus_canvas_view_begin_loading; nautilus_view_class->bump_zoom_level = nautilus_canvas_view_bump_zoom_level; nautilus_view_class->can_rename_file = nautilus_canvas_view_can_rename_file; nautilus_view_class->can_zoom_in = nautilus_canvas_view_can_zoom_in; nautilus_view_class->can_zoom_out = nautilus_canvas_view_can_zoom_out; nautilus_view_class->clear = nautilus_canvas_view_clear; nautilus_view_class->end_loading = nautilus_canvas_view_end_loading; nautilus_view_class->file_changed = nautilus_canvas_view_file_changed; nautilus_view_class->get_selected_icon_locations = nautilus_canvas_view_get_selected_icon_locations; nautilus_view_class->get_selection = nautilus_canvas_view_get_selection; nautilus_view_class->get_selection_for_file_transfer = nautilus_canvas_view_get_selection; nautilus_view_class->is_empty = nautilus_canvas_view_is_empty; nautilus_view_class->remove_file = nautilus_canvas_view_remove_file; nautilus_view_class->restore_default_zoom_level = nautilus_canvas_view_restore_default_zoom_level; nautilus_view_class->reveal_selection = nautilus_canvas_view_reveal_selection; nautilus_view_class->select_all = nautilus_canvas_view_select_all; nautilus_view_class->select_first = nautilus_canvas_view_select_first; nautilus_view_class->set_selection = nautilus_canvas_view_set_selection; nautilus_view_class->invert_selection = nautilus_canvas_view_invert_selection; nautilus_view_class->compare_files = compare_files; nautilus_view_class->click_policy_changed = nautilus_canvas_view_click_policy_changed; nautilus_view_class->update_actions_state = nautilus_canvas_view_update_actions_state; nautilus_view_class->sort_directories_first_changed = nautilus_canvas_view_sort_directories_first_changed; nautilus_view_class->using_manual_layout = nautilus_canvas_view_using_manual_layout; nautilus_view_class->widget_to_file_operation_position = nautilus_canvas_view_widget_to_file_operation_position; nautilus_view_class->get_view_id = nautilus_canvas_view_get_id; nautilus_view_class->get_first_visible_file = canvas_view_get_first_visible_file; nautilus_view_class->scroll_to_file = canvas_view_scroll_to_file; nautilus_view_class->get_icon = nautilus_canvas_view_get_icon; properties[PROP_SUPPORTS_AUTO_LAYOUT] = g_param_spec_boolean ("supports-auto-layout", "Supports auto layout", "Whether this view supports auto layout", TRUE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); properties[PROP_SUPPORTS_MANUAL_LAYOUT] = g_param_spec_boolean ("supports-manual-layout", "Supports manual layout", "Whether this view supports manual layout", FALSE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); properties[PROP_SUPPORTS_SCALING] = g_param_spec_boolean ("supports-scaling", "Supports scaling", "Whether this view supports scaling", FALSE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); properties[PROP_SUPPORTS_KEEP_ALIGNED] = g_param_spec_boolean ("supports-keep-aligned", "Supports keep aligned", "Whether this view supports keep aligned", FALSE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); g_object_class_install_properties (oclass, NUM_PROPERTIES, properties); } static void nautilus_canvas_view_init (NautilusCanvasView *canvas_view) { NautilusCanvasContainer *canvas_container; GActionGroup *view_action_group; canvas_view->details = g_new0 (NautilusCanvasViewDetails, 1); canvas_view->details->sort = &sort_criteria[0]; canvas_view->details->icon = g_themed_icon_new ("view-grid-symbolic"); canvas_container = create_canvas_container (canvas_view); g_signal_connect_swapped (nautilus_preferences, "changed::" NAUTILUS_PREFERENCES_DEFAULT_SORT_ORDER, G_CALLBACK (default_sort_order_changed_callback), canvas_view); g_signal_connect_swapped (nautilus_preferences, "changed::" NAUTILUS_PREFERENCES_DEFAULT_SORT_IN_REVERSE_ORDER, G_CALLBACK (default_sort_in_reverse_order_changed_callback), canvas_view); g_signal_connect_swapped (nautilus_preferences, "changed::" NAUTILUS_PREFERENCES_SHOW_FILE_THUMBNAILS, G_CALLBACK (image_display_policy_changed_callback), canvas_view); g_signal_connect_swapped (nautilus_icon_view_preferences, "changed::" NAUTILUS_PREFERENCES_ICON_VIEW_CAPTIONS, G_CALLBACK (text_attribute_names_changed_callback), canvas_view); g_signal_connect_object (canvas_container, "handle-netscape-url", G_CALLBACK (canvas_view_handle_netscape_url), canvas_view, 0); g_signal_connect_object (canvas_container, "handle-uri-list", G_CALLBACK (canvas_view_handle_uri_list), canvas_view, 0); g_signal_connect_object (canvas_container, "handle-text", G_CALLBACK (canvas_view_handle_text), canvas_view, 0); g_signal_connect_object (canvas_container, "handle-raw", G_CALLBACK (canvas_view_handle_raw), canvas_view, 0); g_signal_connect_object (canvas_container, "handle-hover", G_CALLBACK (canvas_view_handle_hover), canvas_view, 0); canvas_view->details->clipboard_handler_id = g_signal_connect (nautilus_clipboard_monitor_get (), "clipboard-info", G_CALLBACK (canvas_view_notify_clipboard_info), canvas_view); view_action_group = nautilus_view_get_action_group (NAUTILUS_VIEW (canvas_view)); g_action_map_add_action_entries (G_ACTION_MAP (view_action_group), canvas_view_entries, G_N_ELEMENTS (canvas_view_entries), canvas_view); /* Keep the action synced with the actual value, so the toolbar can poll it */ g_action_group_change_action_state (nautilus_view_get_action_group (NAUTILUS_VIEW (canvas_view)), "zoom-to-level", g_variant_new_int32 (get_default_zoom_level (canvas_view))); } NautilusView * nautilus_canvas_view_new (NautilusWindowSlot *slot) { return g_object_new (NAUTILUS_TYPE_CANVAS_VIEW, "window-slot", slot, NULL); }