diff options
Diffstat (limited to 'libcaja-private/caja-undostack-manager.c')
| -rw-r--r-- | libcaja-private/caja-undostack-manager.c | 1988 |
1 files changed, 1988 insertions, 0 deletions
diff --git a/libcaja-private/caja-undostack-manager.c b/libcaja-private/caja-undostack-manager.c new file mode 100644 index 00000000..0b63e972 --- /dev/null +++ b/libcaja-private/caja-undostack-manager.c @@ -0,0 +1,1988 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ + +/* CajaUndoStackManager - Manages undo of file operations (implementation) + * + * Copyright (C) 2007-2010 Amos Brocco + * Copyright (C) 2011 Stefano Karapetsas + * + * Authors: Amos Brocco <[email protected]>, + * Stefano Karapetsas <[email protected]> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include "caja-undostack-manager.h" +#include "caja-file-operations.h" +#include "caja-file.h" +#include <gio/gio.h> +#include <glib/gprintf.h> +#include <glib-object.h> +#include <glib/gi18n.h> +#include <locale.h> +#include <gdk/gdk.h> +#include <eel/eel-glib-extensions.h> + +/* ***************************************************************** + Private fields + ***************************************************************** */ + +struct _CajaUndoStackActionData +{ + /* Common stuff */ + CajaUndoStackActionType type; + gboolean isValid; + gboolean locked; /* True if the action is being undone/redone */ + gboolean freed; /* True if the action must be freed after undo/redo */ + guint count; /* Size of affected uris (count of items) */ + CajaUndoStackManager *manager; /* Pointer to the manager */ + + /* Copy / Move stuff */ + GFile *src_dir; + GFile *dest_dir; + GList *sources; /* Relative to src_dir */ + GList *destinations; /* Relative to dest_dir */ + + /* Cached labels/descriptions */ + char *undo_label; + char *undo_description; + char *redo_label; + char *redo_description; + + /* Create new file/folder stuff/set permissions */ + char *template; + char *target_uri; + + /* Rename stuff */ + char *old_uri; + char *new_uri; + + /* Trash stuff */ + GHashTable *trashed; + + /* Recursive change permissions stuff */ + GHashTable *original_permissions; + guint32 dir_mask; + guint32 dir_permissions; + guint32 file_mask; + guint32 file_permissions; + + /* Single file change permissions stuff */ + guint32 current_permissions; + guint32 new_permissions; + + /* Group */ + char *original_group_name_or_id; + char *new_group_name_or_id; + + /* Owner */ + char *original_user_name_or_id; + char *new_user_name_or_id; + +}; + +struct _CajaUndoStackManagerPrivate +{ + /* Private fields */ + GQueue *stack; + guint undo_levels; + guint index; + GMutex *mutex; /* Used to protect access to stack (because of async file ops) */ + gboolean dispose_has_run; + gboolean undo_redo_flag; + gboolean confirm_delete; +}; + +#define CAJA_UNDOSTACK_MANAGER_GET_PRIVATE(o) \ + (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_CAJA_UNDOSTACK_MANAGER, CajaUndoStackManagerPrivate)) + +/* ***************************************************************** + Properties management prototypes + ***************************************************************** */ +enum +{ + PROP_UNDOSTACK_MANAGER_0, PROP_UNDO_LEVELS, PROP_CONFIRM_DELETE +}; + +static void caja_undostack_manager_set_property (GObject * object, + guint prop_id, const GValue * value, GParamSpec * pspec); + +static void caja_undostack_manager_get_property (GObject * object, + guint prop_id, GValue * value, GParamSpec * pspec); + +/* ***************************************************************** + Destructors prototypes + ***************************************************************** */ +static void caja_undostack_manager_finalize (GObject * object); + +static void caja_undostack_manager_dispose (GObject * object); + +/* ***************************************************************** + Type definition + ***************************************************************** */ +G_DEFINE_TYPE (CajaUndoStackManager, caja_undostack_manager, + G_TYPE_OBJECT); + +/* ***************************************************************** + Private methods prototypes + ***************************************************************** */ + +static void stack_clear_n_oldest (GQueue * stack, guint n); + +static void stack_fix_size (CajaUndoStackManagerPrivate * priv); + +static gboolean can_undo (CajaUndoStackManagerPrivate * priv); + +static gboolean can_redo (CajaUndoStackManagerPrivate * priv); + +static void stack_push_action (CajaUndoStackManagerPrivate * priv, + CajaUndoStackActionData * action); + +static CajaUndoStackActionData + * stack_scroll_left (CajaUndoStackManagerPrivate * priv); + +static CajaUndoStackActionData + * stack_scroll_right (CajaUndoStackManagerPrivate * priv); + +static CajaUndoStackActionData + * get_next_redo_action (CajaUndoStackManagerPrivate * priv); + +static CajaUndoStackActionData + * get_next_undo_action (CajaUndoStackManagerPrivate * priv); + +static gchar *get_undo_label (CajaUndoStackActionData * action); + +static gchar *get_undo_description (CajaUndoStackActionData * action); + +static gchar *get_redo_label (CajaUndoStackActionData * action); + +static gchar *get_redo_description (CajaUndoStackActionData * action); + +static void do_menu_update (CajaUndoStackManager * manager); + +static void free_undostack_action (gpointer data, gpointer user_data); + +static void undostack_dispose_all (GQueue * queue); + +static void undo_redo_done_transfer_callback (GHashTable * debuting_uris, + gpointer data); + +static void undo_redo_op_callback (gpointer callback_data); + +static void undo_redo_done_rename_callback (CajaFile * file, + GFile * result_location, GError * error, gpointer callback_data); + +static void undo_redo_done_delete_callback (GHashTable * debuting_uris, + gboolean user_cancel, gpointer callback_data); + +static void undo_redo_done_create_callback (GFile * new_file, + gpointer callback_data); + +static void clear_redo_actions (CajaUndoStackManagerPrivate * priv); + +static gchar *get_first_target_short_name (CajaUndoStackActionData * + action); + +static GList *construct_gfile_list (const GList * urilist, GFile * parent); + +static GList *construct_gfile_list_from_uri (char *uri); + +static GList *uri_list_to_gfile_list (GList * urilist); + +static char *get_uri_basename (char *uri); + +static char *get_uri_parent (char *uri); + +static char *get_uri_parent_path (char *uri); + +static GHashTable *retrieve_files_to_restore (GHashTable * trashed); + +/* ***************************************************************** + Base functions + ***************************************************************** */ +static void +caja_undostack_manager_class_init (CajaUndoStackManagerClass * klass) +{ + GParamSpec *undo_levels; + GParamSpec *confirm_delete; + GObjectClass *g_object_class; + + /* Add private structure */ + g_type_class_add_private (klass, sizeof (CajaUndoStackManagerPrivate)); + + /* Create properties */ + undo_levels = g_param_spec_uint ("undo-levels", "undo levels", + "Number of undo levels to be stored", + 1, UINT_MAX, 30, G_PARAM_READWRITE | G_PARAM_CONSTRUCT); + + confirm_delete = + g_param_spec_boolean ("confirm-delete", "confirm delete", + "Always confirm file deletion", FALSE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT); + + /* Set properties get/set methods */ + g_object_class = G_OBJECT_CLASS (klass); + + g_object_class->set_property = caja_undostack_manager_set_property; + g_object_class->get_property = caja_undostack_manager_get_property; + + /* Install properties */ + g_object_class_install_property (g_object_class, PROP_UNDO_LEVELS, + undo_levels); + + g_object_class_install_property (g_object_class, PROP_CONFIRM_DELETE, + confirm_delete); + + /* The UI menu needs to update its status */ + g_signal_new ("request-menu-update", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | + G_SIGNAL_NO_HOOKS, 0, NULL, NULL, + g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER); + + /* Hook deconstructors */ + g_object_class->dispose = caja_undostack_manager_dispose; + g_object_class->finalize = caja_undostack_manager_finalize; +} + +static void +caja_undostack_manager_init (CajaUndoStackManager * self) +{ + CajaUndoStackManagerPrivate *priv; + + priv = CAJA_UNDOSTACK_MANAGER_GET_PRIVATE (self); + + self->priv = priv; + + /* Initialize private fields */ + priv->stack = g_queue_new (); + priv->mutex = g_mutex_new (); + priv->index = 0; + priv->dispose_has_run = FALSE; + priv->undo_redo_flag = FALSE; + priv->confirm_delete = FALSE; +} + +static void +caja_undostack_manager_dispose (GObject * object) +{ + CajaUndoStackManager *self = CAJA_UNDOSTACK_MANAGER (object); + CajaUndoStackManagerPrivate *priv = self->priv; + + if (priv->dispose_has_run) + return; + + g_mutex_lock (priv->mutex); + + /* Free each undoable action in the stack and the stack itself */ + undostack_dispose_all (priv->stack); + g_queue_free (priv->stack); + g_mutex_unlock (priv->mutex); + + g_mutex_free (priv->mutex); + + priv->dispose_has_run = TRUE; + + G_OBJECT_CLASS (caja_undostack_manager_parent_class)->dispose (object); +} + +static void +caja_undostack_manager_finalize (GObject * object) +{ + G_OBJECT_CLASS (caja_undostack_manager_parent_class)->finalize (object); +} + +/* ***************************************************************** + Property management + ***************************************************************** */ +static void +caja_undostack_manager_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + g_return_if_fail (IS_CAJA_UNDOSTACK_MANAGER (object)); + + CajaUndoStackManager *manager = CAJA_UNDOSTACK_MANAGER (object); + CajaUndoStackManagerPrivate *priv = manager->priv; + guint new_undo_levels; + + switch (prop_id) { + case PROP_UNDO_LEVELS: + new_undo_levels = g_value_get_uint (value); + if (new_undo_levels > 0 && (priv->undo_levels != new_undo_levels)) { + priv->undo_levels = new_undo_levels; + g_mutex_lock (priv->mutex); + stack_fix_size (priv); + g_mutex_unlock (priv->mutex); + do_menu_update (manager); + } + break; + case PROP_CONFIRM_DELETE: + priv->confirm_delete = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +caja_undostack_manager_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + g_return_if_fail (IS_CAJA_UNDOSTACK_MANAGER (object)); + + CajaUndoStackManager *manager = CAJA_UNDOSTACK_MANAGER (object); + CajaUndoStackManagerPrivate *priv = manager->priv; + + switch (prop_id) { + case PROP_UNDO_LEVELS: + g_value_set_uint (value, priv->undo_levels); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +/* ***************************************************************** + Public methods + ***************************************************************** */ + +/** **************************************************************** + * Returns the undo stack manager instance (singleton pattern) + ** ****************************************************************/ +CajaUndoStackManager * +caja_undostack_manager_instance (void) +{ + static CajaUndoStackManager *manager = NULL; + + if (manager == NULL) { + manager = + g_object_new (TYPE_CAJA_UNDOSTACK_MANAGER, "undo-levels", 32, NULL); + } + + return manager; +} + +/** **************************************************************** + * True if undoing / redoing + ** ****************************************************************/ +gboolean +caja_undostack_manager_is_undo_redo (CajaUndoStackManager * manager) +{ + CajaUndoStackManagerPrivate *priv = manager->priv; + if (priv->undo_redo_flag) { + priv->undo_redo_flag = FALSE; + return TRUE; + } + + return FALSE; +} + +void +caja_undostack_manager_request_menu_update (CajaUndoStackManager * + manager) +{ + do_menu_update (manager); +} + +/** **************************************************************** + * Redoes the last file operation + ** ****************************************************************/ +void +caja_undostack_manager_redo (CajaUndoStackManager * manager, + GtkWidget * parent_view, CajaUndostackFinishCallback cb) +{ + GList *uris; + CajaFile *file; + char *new_name; + char *puri; + CajaUndoStackManagerPrivate *priv = manager->priv; + + g_mutex_lock (priv->mutex); + + CajaUndoStackActionData *action = stack_scroll_left (priv); + + /* Action will be NULL if redo is not possible */ + if (action != NULL) { + action->locked = TRUE; + } + + g_mutex_unlock (priv->mutex); + + do_menu_update (manager); + + if (action != NULL) { + action->locked = TRUE; /* Remember to unlock when redo is finished */ + priv->undo_redo_flag = TRUE; + switch (action->type) { + case CAJA_UNDOSTACK_COPY: + uris = construct_gfile_list (action->sources, action->src_dir); + caja_file_operations_copy (uris, NULL, + action->dest_dir, NULL, undo_redo_done_transfer_callback, action); + eel_g_object_list_free (uris); + break; + case CAJA_UNDOSTACK_CREATEFILEFROMTEMPLATE: + puri = get_uri_parent (action->target_uri); + new_name = get_uri_basename (action->target_uri); + caja_file_operations_new_file_from_template (NULL, + NULL, + puri, + new_name, action->template, undo_redo_done_create_callback, action); + g_free (puri); + g_free (new_name); + break; + case CAJA_UNDOSTACK_DUPLICATE: + uris = construct_gfile_list (action->sources, action->src_dir); + caja_file_operations_duplicate (uris, NULL, NULL, + undo_redo_done_transfer_callback, action); + eel_g_object_list_free (uris); + break; + case CAJA_UNDOSTACK_RESTOREFROMTRASH: + case CAJA_UNDOSTACK_MOVE: + uris = construct_gfile_list (action->sources, action->src_dir); + caja_file_operations_move (uris, NULL, + action->dest_dir, NULL, undo_redo_done_transfer_callback, action); + eel_g_object_list_free (uris); + break; + case CAJA_UNDOSTACK_RENAME: + new_name = get_uri_basename (action->new_uri); + file = caja_file_get_by_uri (action->old_uri); + caja_file_rename (file, new_name, + undo_redo_done_rename_callback, action); + g_object_unref (file); + g_free (new_name); + break; + case CAJA_UNDOSTACK_CREATEEMPTYFILE: + puri = get_uri_parent (action->target_uri); + new_name = get_uri_basename (action->target_uri); + caja_file_operations_new_file (NULL, NULL, puri, + new_name, + action->template, + 0, undo_redo_done_create_callback, action); + g_free (puri); + g_free (new_name); + break; + case CAJA_UNDOSTACK_CREATEFOLDER: + puri = get_uri_parent (action->target_uri); + caja_file_operations_new_folder (NULL, NULL, puri, + undo_redo_done_create_callback, action); + g_free (puri); + break; + case CAJA_UNDOSTACK_MOVETOTRASH: + if (g_hash_table_size (action->trashed) > 0) { + GList *uri_to_trash = g_hash_table_get_keys (action->trashed); + uris = uri_list_to_gfile_list (uri_to_trash); + priv->undo_redo_flag = TRUE; + caja_file_operations_trash_or_delete + (uris, NULL, undo_redo_done_delete_callback, action); + g_list_free (uri_to_trash); + eel_g_object_list_free (uris); + } + break; + case CAJA_UNDOSTACK_CREATELINK: + uris = construct_gfile_list (action->sources, action->src_dir); + caja_file_operations_link (uris, NULL, + action->dest_dir, NULL, undo_redo_done_transfer_callback, action); + eel_g_object_list_free (uris); + break; + case CAJA_UNDOSTACK_SETPERMISSIONS: + file = caja_file_get_by_uri (action->target_uri); + caja_file_set_permissions (file, + action->new_permissions, undo_redo_done_rename_callback, action); + g_object_unref (file); + break; + case CAJA_UNDOSTACK_RECURSIVESETPERMISSIONS: + puri = g_file_get_uri (action->dest_dir); + caja_file_set_permissions_recursive (puri, + action->file_permissions, + action->file_mask, + action->dir_permissions, + action->dir_mask, undo_redo_op_callback, action); + g_free (puri); + break; + case CAJA_UNDOSTACK_CHANGEGROUP: + file = caja_file_get_by_uri (action->target_uri); + caja_file_set_group (file, + action->new_group_name_or_id, + undo_redo_done_rename_callback, action); + g_object_unref (file); + break; + case CAJA_UNDOSTACK_CHANGEOWNER: + file = caja_file_get_by_uri (action->target_uri); + caja_file_set_owner (file, + action->new_user_name_or_id, + undo_redo_done_rename_callback, action); + g_object_unref (file); + break; + case CAJA_UNDOSTACK_DELETE: + default: + priv->undo_redo_flag = FALSE; + break; /* We shouldn't be here */ + } + } + + (*cb) ((gpointer) parent_view); +} + +/** **************************************************************** + * Undoes the last file operation + ** ****************************************************************/ +void +caja_undostack_manager_undo (CajaUndoStackManager * manager, + GtkWidget * parent_view, CajaUndostackFinishCallback cb) +{ + GList *uris = NULL; + GHashTable *files_to_restore; + CajaFile *file; + char *new_name; + CajaUndoStackManagerPrivate *priv = manager->priv; + + g_mutex_lock (priv->mutex); + + CajaUndoStackActionData *action = stack_scroll_right (priv); + + if (action != NULL) { + action->locked = TRUE; + } + + g_mutex_unlock (priv->mutex); + + do_menu_update (manager); + + if (action != NULL) { + priv->undo_redo_flag = TRUE; + switch (action->type) { + case CAJA_UNDOSTACK_CREATEEMPTYFILE: + case CAJA_UNDOSTACK_CREATEFILEFROMTEMPLATE: + case CAJA_UNDOSTACK_CREATEFOLDER: + uris = construct_gfile_list_from_uri (action->target_uri); + case CAJA_UNDOSTACK_COPY: + case CAJA_UNDOSTACK_DUPLICATE: + case CAJA_UNDOSTACK_CREATELINK: + if (!uris) { + uris = construct_gfile_list (action->destinations, action->dest_dir); + uris = g_list_reverse (uris); // Deleting must be done in reverse + } + if (priv->confirm_delete) { + caja_file_operations_delete (uris, NULL, + undo_redo_done_delete_callback, action); + eel_g_object_list_free (uris); + } else { + /* We skip the confirmation message + */ + GList *f; + for (f = uris; f != NULL; f = f->next) { + char *name; + name = g_file_get_uri (f->data); + g_free (name); + g_file_delete (f->data, NULL, NULL); + g_object_unref (f->data); + } + g_list_free (uris); + /* Here we must do what's necessary for the callback */ + undo_redo_done_transfer_callback (NULL, action); + } + break; + case CAJA_UNDOSTACK_RESTOREFROMTRASH: + uris = construct_gfile_list (action->destinations, action->dest_dir); + caja_file_operations_trash_or_delete (uris, NULL, + undo_redo_done_delete_callback, action); + eel_g_object_list_free (uris); + break; + case CAJA_UNDOSTACK_MOVETOTRASH: + files_to_restore = retrieve_files_to_restore (action->trashed); + if (g_hash_table_size (files_to_restore) > 0) { + GList *l; + GList *gfiles_in_trash = g_hash_table_get_keys (files_to_restore); + GFile *item; + GFile *dest; + char *value; + + for (l = gfiles_in_trash; l != NULL; l = l->next) { + item = l->data; + value = g_hash_table_lookup (files_to_restore, item); + dest = g_file_new_for_uri (value); + g_file_move (item, dest, + G_FILE_COPY_NOFOLLOW_SYMLINKS, NULL, NULL, NULL, NULL); + g_object_unref (dest); + } + + g_list_free (gfiles_in_trash); + } + g_hash_table_destroy (files_to_restore); + /* Here we must do what's necessary for the callback */ + undo_redo_done_transfer_callback (NULL, action); + break; + case CAJA_UNDOSTACK_MOVE: + uris = construct_gfile_list (action->destinations, action->dest_dir); + caja_file_operations_move (uris, NULL, + action->src_dir, NULL, undo_redo_done_transfer_callback, action); + eel_g_object_list_free (uris); + break; + case CAJA_UNDOSTACK_RENAME: + new_name = get_uri_basename (action->old_uri); + file = caja_file_get_by_uri (action->new_uri); + caja_file_rename (file, new_name, + undo_redo_done_rename_callback, action); + g_object_unref (file); + g_free (new_name); + break; + case CAJA_UNDOSTACK_SETPERMISSIONS: + file = caja_file_get_by_uri (action->target_uri); + caja_file_set_permissions (file, + action->current_permissions, + undo_redo_done_rename_callback, action); + g_object_unref (file); + break; + case CAJA_UNDOSTACK_RECURSIVESETPERMISSIONS: + if (g_hash_table_size (action->original_permissions) > 0) { + GList *gfiles_list = + g_hash_table_get_keys (action->original_permissions); + guint32 *perm; + GList *l; + GFile *dest; + char *item; + + for (l = gfiles_list; l != NULL; l = l->next) { + item = l->data; + perm = g_hash_table_lookup (action->original_permissions, item); + dest = g_file_new_for_uri (item); + g_file_set_attribute_uint32 (dest, + G_FILE_ATTRIBUTE_UNIX_MODE, + *perm, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL); + g_object_unref (dest); + } + + g_list_free (gfiles_list); + /* Here we must do what's necessary for the callback */ + undo_redo_done_transfer_callback (NULL, action); + } + break; + case CAJA_UNDOSTACK_CHANGEGROUP: + file = caja_file_get_by_uri (action->target_uri); + caja_file_set_group (file, + action->original_group_name_or_id, + undo_redo_done_rename_callback, action); + g_object_unref (file); + break; + case CAJA_UNDOSTACK_CHANGEOWNER: + file = caja_file_get_by_uri (action->target_uri); + caja_file_set_owner (file, + action->original_user_name_or_id, + undo_redo_done_rename_callback, action); + g_object_unref (file); + break; + case CAJA_UNDOSTACK_DELETE: + default: + priv->undo_redo_flag = FALSE; + break; /* We shouldn't be here */ + } + } + + (*cb) ((gpointer) parent_view); +} + +/** **************************************************************** + * Adds an operation to the stack + ** ****************************************************************/ +void +caja_undostack_manager_add_action (CajaUndoStackManager * manager, + CajaUndoStackActionData * action) +{ + CajaUndoStackManagerPrivate *priv = manager->priv; + + if (!action) + return; + + if (!(action && action->isValid)) { + free_undostack_action ((gpointer) action, NULL); + return; + } + + action->manager = manager; + + g_mutex_lock (priv->mutex); + + stack_push_action (priv, action); + + g_mutex_unlock (priv->mutex); + + do_menu_update (manager); + +} + +/** **************************************************************** + * Callback after emptying the trash + ** ****************************************************************/ +void +caja_undostack_manager_trash_has_emptied (CajaUndoStackManager * + manager) +{ + CajaUndoStackManagerPrivate *priv = manager->priv; + + /* Clear actions from the oldest to the newest move to trash */ + + g_mutex_lock (priv->mutex); + + clear_redo_actions (priv); + + /* Search newest move to trash */ + guint i; + guint length = g_queue_get_length (priv->stack); + guint newest_move_to_trash_position = -1; + CajaUndoStackActionData *action = NULL; + + for (i = 0; i < length; i++) { + action = (CajaUndoStackActionData *) + g_queue_peek_nth (priv->stack, i); + if (action->type == CAJA_UNDOSTACK_MOVETOTRASH) { + newest_move_to_trash_position = i; + break; + } + } + + if (newest_move_to_trash_position >= 0) { + guint to_clear = length - newest_move_to_trash_position; + stack_clear_n_oldest (priv->stack, to_clear); + } + + g_mutex_unlock (priv->mutex); +} + +/** **************************************************************** + * Returns the modification time for the given file (used for undo trash) + ** ****************************************************************/ +guint64 +caja_undostack_manager_get_file_modification_time (GFile * file) +{ + GFileInfo *info; + guint64 mtime; + + info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, + G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, FALSE, NULL); + if (info == NULL) { + return -1; + } + + mtime = g_file_info_get_attribute_uint64 (info, + G_FILE_ATTRIBUTE_TIME_MODIFIED); + + g_object_unref (info); + + return mtime; +} + +/** **************************************************************** + * Returns a new undo data container + ** ****************************************************************/ +CajaUndoStackActionData * +caja_undostack_manager_data_new (CajaUndoStackActionType type, + gint items_count) +{ + CajaUndoStackActionData *data = + g_slice_new0 (CajaUndoStackActionData); + data->type = type; + data->count = items_count; + + if (type == CAJA_UNDOSTACK_MOVETOTRASH) { + data->trashed = + g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); + } else if (type == CAJA_UNDOSTACK_RECURSIVESETPERMISSIONS) { + data->original_permissions = + g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); + } + + return data; +} + +/** **************************************************************** + * Sets the source directory + ** ****************************************************************/ +void +caja_undostack_manager_data_set_src_dir (CajaUndoStackActionData * + data, GFile * src) +{ + if (!data) + return; + + data->src_dir = src; +} + +/** **************************************************************** + * Sets the destination directory + ** ****************************************************************/ +void +caja_undostack_manager_data_set_dest_dir (CajaUndoStackActionData * + data, GFile * dest) +{ + if (!data) + return; + + data->dest_dir = dest; +} + +/** **************************************************************** + * Pushes an origin, target pair in an existing undo data container + ** ****************************************************************/ +void caja_undostack_manager_data_add_origin_target_pair + (CajaUndoStackActionData * data, GFile * origin, GFile * target) +{ + + if (!data) + return; + + char *src_relative = g_file_get_relative_path (data->src_dir, origin); + data->sources = g_list_append (data->sources, src_relative); + char *dest_relative = g_file_get_relative_path (data->dest_dir, target); + data->destinations = g_list_append (data->destinations, dest_relative); + + data->isValid = TRUE; +} + +/** **************************************************************** + * Pushes an trashed file with modification time in an existing undo data container + ** ****************************************************************/ +void +caja_undostack_manager_data_add_trashed_file (CajaUndoStackActionData + * data, GFile * file, guint64 mtime) +{ + + if (!data) + return; + + guint64 *modificationTime; + modificationTime = (guint64 *) malloc (sizeof (guint64)); + *modificationTime = mtime; + + char *originalURI = g_file_get_uri (file); + + g_hash_table_insert (data->trashed, originalURI, modificationTime); + + data->isValid = TRUE; +} + +/** **************************************************************** + * Pushes a recursive permission change data in an existing undo data container + ** ****************************************************************/ +void caja_undostack_manager_data_add_file_permissions + (CajaUndoStackActionData * data, GFile * file, guint32 permission) +{ + + if (!data) + return; + + guint32 *currentPermission; + currentPermission = (guint32 *) malloc (sizeof (guint32)); + *currentPermission = permission; + + char *originalURI = g_file_get_uri (file); + + g_hash_table_insert (data->original_permissions, originalURI, + currentPermission); + + data->isValid = TRUE; +} + +/** **************************************************************** + * Sets the original file permission in an existing undo data container + ** ****************************************************************/ +void caja_undostack_manager_data_set_file_permissions + (CajaUndoStackActionData * data, char *uri, + guint32 current_permissions, guint32 new_permissions) +{ + + if (!data) + return; + + data->target_uri = uri; + + data->current_permissions = current_permissions; + data->new_permissions = new_permissions; + + data->isValid = TRUE; +} + +/** **************************************************************** + * Sets the change owner information in an existing undo data container + ** ****************************************************************/ +void caja_undostack_manager_data_set_owner_change_information + (CajaUndoStackActionData * data, char *uri, + const char *current_user, const char *new_user) +{ + + if (!data) + return; + + data->target_uri = uri; + + data->original_user_name_or_id = g_strdup (current_user); + data->new_user_name_or_id = g_strdup (new_user); + + data->isValid = TRUE; +} + +/** **************************************************************** + * Sets the change group information in an existing undo data container + ** ****************************************************************/ +void caja_undostack_manager_data_set_group_change_information + (CajaUndoStackActionData * data, char *uri, + const char *current_group, const char *new_group) +{ + + if (!data) + return; + + data->target_uri = uri; + + data->original_group_name_or_id = g_strdup (current_group); + data->new_group_name_or_id = g_strdup (new_group); + + data->isValid = TRUE; +} + +/** **************************************************************** + * Sets the permission change mask + ** ****************************************************************/ +void caja_undostack_manager_data_set_recursive_permissions + (CajaUndoStackActionData * data, guint32 file_permissions, + guint32 file_mask, guint32 dir_permissions, guint32 dir_mask) +{ + + if (!data) + return; + + data->file_permissions = file_permissions; + data->file_mask = file_mask; + data->dir_permissions = dir_permissions; + data->dir_mask = dir_mask; + + data->isValid = TRUE; +} + +/** **************************************************************** + * Sets create file information + ** ****************************************************************/ +void +caja_undostack_manager_data_set_create_data (CajaUndoStackActionData * + data, char *target_uri, char *template) +{ + + if (!data) + return; + + data->template = g_strdup (template); + data->target_uri = g_strdup (target_uri); + + data->isValid = TRUE; +} + +/** **************************************************************** + * Sets rename information + ** ****************************************************************/ +void caja_undostack_manager_data_set_rename_information + (CajaUndoStackActionData * data, GFile * old_file, GFile * new_file) +{ + + if (!data) + return; + + data->old_uri = g_file_get_uri (old_file); + data->new_uri = g_file_get_uri (new_file); + + data->isValid = TRUE; +} + +/* ***************************************************************** + Private methods (nothing to see here, move along) + ***************************************************************** */ + +static CajaUndoStackActionData * +stack_scroll_right (CajaUndoStackManagerPrivate * priv) +{ + gpointer data = NULL; + + if (!can_undo (priv)) + return NULL; + + data = g_queue_peek_nth (priv->stack, priv->index); + if (priv->index < g_queue_get_length (priv->stack)) { + priv->index++; + } + + return data; +} + +/** ---------------------------------------------------------------- */ +static CajaUndoStackActionData * +stack_scroll_left (CajaUndoStackManagerPrivate * priv) +{ + gpointer data = NULL; + + if (!can_redo (priv)) + return NULL; + + priv->index--; + data = g_queue_peek_nth (priv->stack, priv->index); + + return data; +} + +/** ---------------------------------------------------------------- */ +static void +stack_clear_n_oldest (GQueue * stack, guint n) +{ + CajaUndoStackActionData *action; + guint i; + + for (i = 0; i < n; i++) { + action = (CajaUndoStackActionData *) + g_queue_pop_tail (stack); + if (action->locked) { + action->freed = TRUE; + } else { + free_undostack_action (action, NULL); + } + } +} + +/** ---------------------------------------------------------------- */ +static void +stack_fix_size (CajaUndoStackManagerPrivate * priv) +{ + guint length = g_queue_get_length (priv->stack); + + if (length > priv->undo_levels) { + if (priv->index > (priv->undo_levels + 1)) { + /* If the index will fall off the stack + * move it back to the maximum position */ + priv->index = priv->undo_levels + 1; + } + stack_clear_n_oldest (priv->stack, length - (priv->undo_levels)); + } +} + +/** ---------------------------------------------------------------- */ +static void +clear_redo_actions (CajaUndoStackManagerPrivate * priv) +{ + while (priv->index > 0) { + CajaUndoStackActionData *head = (CajaUndoStackActionData *) + g_queue_pop_head (priv->stack); + free_undostack_action (head, NULL); + priv->index--; + } +} + +/** ---------------------------------------------------------------- */ +static void +stack_push_action (CajaUndoStackManagerPrivate * priv, + CajaUndoStackActionData * action) +{ + guint length; + + clear_redo_actions (priv); + + g_queue_push_head (priv->stack, (gpointer) action); + length = g_queue_get_length (priv->stack); + + if (length > priv->undo_levels) { + stack_fix_size (priv); + } +} + +/** ---------------------------------------------------------------- */ +static gchar * +get_first_target_short_name (CajaUndoStackActionData * action) +{ + GList *targets_first; + gchar *file_name; + + targets_first = g_list_first (action->destinations); + file_name = (gchar *) g_strdup (targets_first->data); + + return file_name; +} + +/** ---------------------------------------------------------------- */ +static gchar * +get_undo_description (CajaUndoStackActionData * action) +{ + gchar *description = NULL; + gchar *source = NULL; + guint count; + + if (action != NULL) { + if (action->undo_description == NULL) { + if (action->src_dir) { + source = g_file_get_path (action->src_dir); + } + count = action->count; + switch (action->type) { + case CAJA_UNDOSTACK_COPY: + if (count != 1) { + description = g_strdup_printf (_("Delete %d copied items"), count); + } else { + gchar *name = get_first_target_short_name (action); + description = g_strdup_printf (_("Delete '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_DUPLICATE: + if (count != 1) { + description = + g_strdup_printf (_("Delete %d duplicated items"), count); + } else { + gchar *name = get_first_target_short_name (action); + description = g_strdup_printf (_("Delete '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_MOVE: + if (count != 1) { + description = + g_strdup_printf (_ + ("Move %d items back to '%s'"), count, source); + } else { + gchar *name = get_first_target_short_name (action); + description = + g_strdup_printf (_("Move '%s' back to '%s'"), name, source); + g_free (name); + } + break; + case CAJA_UNDOSTACK_RENAME: + { + char *from_name = get_uri_basename (action->new_uri); + char *to_name = get_uri_basename (action->old_uri); + description = + g_strdup_printf (_("Rename '%s' as '%s'"), from_name, to_name); + g_free (from_name); + g_free (to_name); + } + break; + case CAJA_UNDOSTACK_CREATEFILEFROMTEMPLATE: + case CAJA_UNDOSTACK_CREATEEMPTYFILE: + case CAJA_UNDOSTACK_CREATEFOLDER: + { + char *name = get_uri_basename (action->target_uri); + description = g_strdup_printf (_("Delete '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_MOVETOTRASH: + { + count = g_hash_table_size (action->trashed); + if (count != 1) { + description = + g_strdup_printf (_("Restore %d items from trash"), count); + } else { + GList *keys = g_hash_table_get_keys (action->trashed); + GList *first = g_list_first (keys); + char *item = (char *) first->data; + char *name = get_uri_basename (item); + char *orig_path = get_uri_parent_path (item); + description = + g_strdup_printf (_("Restore '%s' to '%s'"), name, orig_path); + g_free (name); + g_free (orig_path); + g_list_free (keys); + } + } + break; + case CAJA_UNDOSTACK_RESTOREFROMTRASH: + { + if (count != 1) { + description = + g_strdup_printf (_("Move %d items back to trash"), count); + } else { + gchar *name = get_first_target_short_name (action); + description = g_strdup_printf (_("Move '%s' back to trash"), name); + g_free (name); + } + } + break; + case CAJA_UNDOSTACK_CREATELINK: + { + if (count != 1) { + description = + g_strdup_printf (_("Delete links to %d items"), count); + } else { + gchar *name = get_first_target_short_name (action); + description = g_strdup_printf (_("Delete link to '%s'"), name); + g_free (name); + } + } + break; + case CAJA_UNDOSTACK_RECURSIVESETPERMISSIONS: + { + char *name = g_file_get_path (action->dest_dir); + description = + g_strdup_printf (_ + ("Restore original permissions of items enclosed in '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_SETPERMISSIONS: + { + char *name = get_uri_basename (action->target_uri); + description = + g_strdup_printf (_("Restore original permissions of '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_CHANGEGROUP: + { + char *name = get_uri_basename (action->target_uri); + description = + g_strdup_printf (_ + ("Restore group of '%s' to '%s'"), + name, action->original_group_name_or_id); + g_free (name); + } + break; + case CAJA_UNDOSTACK_CHANGEOWNER: + { + char *name = get_uri_basename (action->target_uri); + description = + g_strdup_printf (_ + ("Restore owner of '%s' to '%s'"), + name, action->original_user_name_or_id); + g_free (name); + } + break; + default: + break; + } + if (source) { + g_free (source); + } + action->undo_description = description; + } else { + return action->undo_description; + } + } + + return description; +} + +/** ---------------------------------------------------------------- */ +static gchar * +get_redo_description (CajaUndoStackActionData * action) +{ + gchar *description = NULL; + gchar *destination = NULL; + guint count; + + if (action != NULL) { + if (action->redo_description == NULL) { + if (action->dest_dir) { + destination = g_file_get_path (action->dest_dir); + } + count = action->count; + switch (action->type) { + case CAJA_UNDOSTACK_COPY: + if (count != 1) { + description = + g_strdup_printf (_ + ("Copy %d items to '%s'"), count, destination); + } else { + gchar *name = get_first_target_short_name (action); + description = + g_strdup_printf (_("Copy '%s' to '%s'"), name, destination); + g_free (name); + } + break; + case CAJA_UNDOSTACK_DUPLICATE: + if (count != 1) { + description = + g_strdup_printf (_ + ("Duplicate of %d items in '%s'"), count, destination); + } else { + gchar *name = get_first_target_short_name (action); + description = + g_strdup_printf (_ + ("Duplicate '%s' in '%s'"), name, destination); + g_free (name); + } + break; + case CAJA_UNDOSTACK_MOVE: + if (count != 1) { + description = + g_strdup_printf (_ + ("Move %d items to '%s'"), count, destination); + } else { + gchar *name = get_first_target_short_name (action); + description = + g_strdup_printf (_("Move '%s' to '%s'"), name, destination); + g_free (name); + } + break; + case CAJA_UNDOSTACK_RENAME: + { + char *from_name = get_uri_basename (action->old_uri); + char *to_name = get_uri_basename (action->new_uri); + description = + g_strdup_printf (_("Rename '%s' as '%s'"), from_name, to_name); + g_free (from_name); + g_free (to_name); + } + break; + case CAJA_UNDOSTACK_CREATEFILEFROMTEMPLATE: + { + char *name = get_uri_basename (action->target_uri); + description = + g_strdup_printf (_("Create new file '%s' from template "), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_CREATEEMPTYFILE: + { + char *name = get_uri_basename (action->target_uri); + description = g_strdup_printf (_("Create an empty file '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_CREATEFOLDER: + { + char *name = get_uri_basename (action->target_uri); + description = g_strdup_printf (_("Create a new folder '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_MOVETOTRASH: + { + count = g_hash_table_size (action->trashed); + if (count != 1) { + description = g_strdup_printf (_("Move %d items to trash"), count); + } else { + GList *keys = g_hash_table_get_keys (action->trashed); + GList *first = g_list_first (keys); + char *item = (char *) first->data; + char *name = get_uri_basename (item); + description = g_strdup_printf (_("Move '%s' to trash"), name); + g_free (name); + g_list_free (keys); + } + } + break; + case CAJA_UNDOSTACK_RESTOREFROMTRASH: + { + if (count != 1) { + description = + g_strdup_printf (_("Restore %d items from trash"), count); + } else { + gchar *name = get_first_target_short_name (action); + description = g_strdup_printf (_("Restore '%s' from trash"), name); + g_free (name); + } + } + break; + case CAJA_UNDOSTACK_CREATELINK: + { + if (count != 1) { + description = + g_strdup_printf (_("Create links to %d items"), count); + } else { + gchar *name = get_first_target_short_name (action); + description = g_strdup_printf (_("Create link to '%s'"), name); + g_free (name); + } + } + break; + case CAJA_UNDOSTACK_RECURSIVESETPERMISSIONS: + { + char *name = g_file_get_path (action->dest_dir); + description = + g_strdup_printf (_("Set permissions of items enclosed in '%s'"), + name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_SETPERMISSIONS: + { + char *name = get_uri_basename (action->target_uri); + description = g_strdup_printf (_("Set permissions of '%s'"), name); + g_free (name); + } + break; + case CAJA_UNDOSTACK_CHANGEGROUP: + { + char *name = get_uri_basename (action->target_uri); + description = + g_strdup_printf (_ + ("Set group of '%s' to '%s'"), + name, action->new_group_name_or_id); + g_free (name); + } + break; + case CAJA_UNDOSTACK_CHANGEOWNER: + { + char *name = get_uri_basename (action->target_uri); + description = + g_strdup_printf (_ + ("Set owner of '%s' to '%s'"), name, action->new_user_name_or_id); + g_free (name); + } + break; + default: + break; + } + if (destination) { + g_free (destination); + } + action->redo_description = description; + } else { + return action->redo_description; + } + } + + return description; +} + +/** ---------------------------------------------------------------- */ +static gchar * +get_undo_label (CajaUndoStackActionData * action) +{ + gchar *label = NULL; + guint count; + + if (action != NULL) { + if (action->undo_label == NULL) { + count = action->count; + switch (action->type) { + case CAJA_UNDOSTACK_COPY: + label = g_strdup_printf (ngettext + ("_Undo copy of %d item", + "_Undo copy of %d items", count), count); + break; + case CAJA_UNDOSTACK_DUPLICATE: + label = g_strdup_printf (ngettext + ("_Undo duplicate of %d item", + "_Undo duplicate of %d items", count), count); + break; + case CAJA_UNDOSTACK_MOVE: + label = g_strdup_printf (ngettext + ("_Undo move of %d item", + "_Undo move of %d items", count), count); + break; + case CAJA_UNDOSTACK_RENAME: + label = g_strdup_printf (ngettext + ("_Undo rename of %d item", + "_Undo rename of %d items", count), count); + break; + case CAJA_UNDOSTACK_CREATEEMPTYFILE: + label = g_strdup_printf (_("_Undo creation of an empty file")); + break; + case CAJA_UNDOSTACK_CREATEFILEFROMTEMPLATE: + label = g_strdup_printf (_("_Undo creation of a file from template")); + break; + case CAJA_UNDOSTACK_CREATEFOLDER: + label = g_strdup_printf (ngettext + ("_Undo creation of %d folder", + "_Undo creation of %d folders", count), count); + break; + case CAJA_UNDOSTACK_MOVETOTRASH: + label = g_strdup_printf (ngettext + ("_Undo move to trash of %d item", + "_Undo move to trash of %d items", count), count); + break; + case CAJA_UNDOSTACK_RESTOREFROMTRASH: + label = g_strdup_printf (ngettext + ("_Undo restore from trash of %d item", + "_Undo restore from trash of %d items", count), count); + break; + case CAJA_UNDOSTACK_CREATELINK: + label = g_strdup_printf (ngettext + ("_Undo create link to %d item", + "_Undo create link to %d items", count), count); + break; + case CAJA_UNDOSTACK_DELETE: + label = g_strdup_printf (ngettext + ("_Undo delete of %d item", + "_Undo delete of %d items", count), count); + break; + case CAJA_UNDOSTACK_RECURSIVESETPERMISSIONS: + label = g_strdup_printf (ngettext + ("Undo recursive change permissions of %d item", + "Undo recursive change permissions of %d items", + count), count); + break; + case CAJA_UNDOSTACK_SETPERMISSIONS: + label = g_strdup_printf (ngettext + ("Undo change permissions of %d item", + "Undo change permissions of %d items", count), count); + break; + case CAJA_UNDOSTACK_CHANGEGROUP: + label = g_strdup_printf (ngettext + ("Undo change group of %d item", + "Undo change group of %d items", count), count); + break; + case CAJA_UNDOSTACK_CHANGEOWNER: + label = g_strdup_printf (ngettext + ("Undo change owner of %d item", + "Undo change owner of %d items", count), count); + break; + default: + break; + } + action->undo_label = label; + } else { + return action->undo_label; + } + } + + return label; +} + +/** ---------------------------------------------------------------- */ +static gchar * +get_redo_label (CajaUndoStackActionData * action) +{ + gchar *label = NULL; + guint count; + + if (action != NULL) { + if (action->redo_label == NULL) { + count = action->count; + switch (action->type) { + case CAJA_UNDOSTACK_COPY: + label = g_strdup_printf (ngettext + ("_Redo copy of %d item", + "_Redo copy of %d items", count), count); + break; + case CAJA_UNDOSTACK_DUPLICATE: + label = g_strdup_printf (ngettext + ("_Redo duplicate of %d item", + "_Redo duplicate of %d items", count), count); + break; + case CAJA_UNDOSTACK_MOVE: + label = g_strdup_printf (ngettext + ("_Redo move of %d item", + "_Redo move of %d items", count), count); + break; + case CAJA_UNDOSTACK_RENAME: + label = g_strdup_printf (ngettext + ("_Redo rename of %d item", + "_Redo rename of %d items", count), count); + break; + case CAJA_UNDOSTACK_CREATEEMPTYFILE: + label = g_strdup_printf (_("_Redo creation of an empty file")); + break; + case CAJA_UNDOSTACK_CREATEFILEFROMTEMPLATE: + label = g_strdup_printf (_("_Redo creation of a file from template")); + break; + case CAJA_UNDOSTACK_CREATEFOLDER: + label = g_strdup_printf (ngettext + ("_Redo creation of %d folder", + "_Redo creation of %d folders", count), count); + break; + case CAJA_UNDOSTACK_MOVETOTRASH: + label = g_strdup_printf (ngettext + ("_Redo move to trash of %d item", + "_Redo move to trash of %d items", count), count); + break; + case CAJA_UNDOSTACK_RESTOREFROMTRASH: + label = g_strdup_printf (ngettext + ("_Redo restore from trash of %d item", + "_Redo restore from trash of %d items", count), count); + break; + case CAJA_UNDOSTACK_CREATELINK: + label = g_strdup_printf (ngettext + ("_Redo create link to %d item", + "_Redo create link to %d items", count), count); + break; + case CAJA_UNDOSTACK_DELETE: + label = g_strdup_printf (ngettext + ("_Redo delete of %d item", + "_Redo delete of %d items", count), count); + break; + case CAJA_UNDOSTACK_RECURSIVESETPERMISSIONS: + label = g_strdup_printf (ngettext + ("Redo recursive change permissions of %d item", + "Redo recursive change permissions of %d items", + count), count); + break; + case CAJA_UNDOSTACK_SETPERMISSIONS: + label = g_strdup_printf (ngettext + ("Redo change permissions of %d item", + "Redo change permissions of %d items", count), count); + break; + case CAJA_UNDOSTACK_CHANGEGROUP: + label = g_strdup_printf (ngettext + ("Redo change group of %d item", + "Redo change group of %d items", count), count); + break; + case CAJA_UNDOSTACK_CHANGEOWNER: + label = g_strdup_printf (ngettext + ("Redo change owner of %d item", + "Redo change owner of %d items", count), count); + break; + default: + break; + } + action->redo_label = label; + } else { + return action->redo_label; + } + } + + return label; +} + +/** ---------------------------------------------------------------- */ +static void +undo_redo_done_transfer_callback (GHashTable * debuting_uris, gpointer data) +{ + CajaUndoStackActionData *action; + + action = (CajaUndoStackActionData *) data; + + /* If the action needed to be freed but was locked, free now */ + if (action->freed) { + free_undostack_action (action, NULL); + } else { + action->locked = FALSE; + } + + /* Update menus */ + do_menu_update (action->manager); +} + +/** ---------------------------------------------------------------- */ +static void +undo_redo_done_delete_callback (GHashTable * + debuting_uris, gboolean user_cancel, gpointer callback_data) +{ + undo_redo_done_transfer_callback (debuting_uris, callback_data); +} + +/** ---------------------------------------------------------------- */ +static void +undo_redo_done_create_callback (GFile * new_file, gpointer callback_data) +{ + undo_redo_done_transfer_callback (NULL, callback_data); +} + +/** ---------------------------------------------------------------- */ +static void +undo_redo_op_callback (gpointer callback_data) +{ + undo_redo_done_transfer_callback (NULL, callback_data); +} + +/** ---------------------------------------------------------------- */ +static void +undo_redo_done_rename_callback (CajaFile * file, + GFile * result_location, GError * error, gpointer callback_data) +{ + undo_redo_done_transfer_callback (NULL, callback_data); +} + +/** ---------------------------------------------------------------- */ +static void +free_undostack_action (gpointer data, gpointer user_data) +{ + CajaUndoStackActionData *action = (CajaUndoStackActionData *) data; + + if (!action) + return; + + g_free (action->template); + g_free (action->target_uri); + g_free (action->old_uri); + g_free (action->new_uri); + + g_free (action->undo_label); + g_free (action->undo_description); + g_free (action->redo_label); + g_free (action->redo_description); + + g_free (action->original_group_name_or_id); + g_free (action->original_user_name_or_id); + g_free (action->new_group_name_or_id); + g_free (action->new_user_name_or_id); + + if (action->sources) { + g_list_foreach (action->sources, (GFunc) g_free, NULL); + g_list_free (action->sources); + } + if (action->destinations) { + g_list_foreach (action->destinations, (GFunc) g_free, NULL); + g_list_free (action->destinations); + } + + if (action->trashed) { + g_hash_table_destroy (action->trashed); + } + + if (action->original_permissions) { + g_hash_table_destroy (action->original_permissions); + } + + if (action->src_dir) + g_object_unref (action->src_dir); + if (action->dest_dir) + g_object_unref (action->dest_dir); + + if (action) + g_slice_free (CajaUndoStackActionData, action); +} + +/** ---------------------------------------------------------------- */ +static void +undostack_dispose_all (GQueue * queue) +{ + g_queue_foreach (queue, free_undostack_action, NULL); +} + +/** ---------------------------------------------------------------- */ +static gboolean +can_undo (CajaUndoStackManagerPrivate * priv) +{ + return (get_next_undo_action (priv) != NULL); +} + +/** ---------------------------------------------------------------- */ +static gboolean +can_redo (CajaUndoStackManagerPrivate * priv) +{ + return (get_next_redo_action (priv) != NULL); +} + +/** ---------------------------------------------------------------- */ +static CajaUndoStackActionData * +get_next_redo_action (CajaUndoStackManagerPrivate * priv) +{ + if (g_queue_is_empty (priv->stack)) { + return NULL; + } + + if (priv->index == 0) { + /* ... no redo actions */ + return NULL; + } + + CajaUndoStackActionData *action = g_queue_peek_nth (priv->stack, + priv->index - 1); + + if (action->locked) { + return NULL; + } else { + return action; + } +} + +/** ---------------------------------------------------------------- */ +static CajaUndoStackActionData * +get_next_undo_action (CajaUndoStackManagerPrivate * priv) +{ + if (g_queue_is_empty (priv->stack)) { + return NULL; + } + + guint stack_size = g_queue_get_length (priv->stack); + + if (priv->index == stack_size) { + return NULL; + } + + CajaUndoStackActionData *action = g_queue_peek_nth (priv->stack, + priv->index); + + if (action->locked) { + return NULL; + } else { + return action; + } +} + +/** ---------------------------------------------------------------- */ +static void +do_menu_update (CajaUndoStackManager * manager) +{ + + if (!manager) + return; + + CajaUndoStackActionData *action; + CajaUndoStackManagerPrivate *priv = manager->priv; + CajaUndoStackMenuData *data = g_slice_new0 (CajaUndoStackMenuData); + + g_mutex_lock (priv->mutex); + + action = get_next_undo_action (priv); + data->undo_label = get_undo_label (action); + data->undo_description = get_undo_description (action); + + action = get_next_redo_action (priv); + + data->redo_label = get_redo_label (action); + data->redo_description = get_redo_description (action); + + g_mutex_unlock (priv->mutex); + + /* Update menus */ + g_signal_emit_by_name (manager, "request-menu-update", data); + + /* Free the signal data */ + // Note: we do not own labels and descriptions, they are part of the action. + g_slice_free (CajaUndoStackMenuData, data); +} + +/** ---------------------------------------------------------------- */ +static GList * +construct_gfile_list (const GList * urilist, GFile * parent) +{ + const GList *l; + GList *file_list = NULL; + GFile *file; + + for (l = urilist; l != NULL; l = l->next) { + file = g_file_get_child (parent, l->data); + file_list = g_list_append (file_list, file); + } + + return file_list; +} + +/** ---------------------------------------------------------------- */ +static GList * +construct_gfile_list_from_uri (char *uri) +{ + GList *file_list = NULL; + GFile *file; + + file = g_file_new_for_uri (uri); + file_list = g_list_append (file_list, file); + + return file_list; +} + +/** ---------------------------------------------------------------- */ +static GList * +uri_list_to_gfile_list (GList * urilist) +{ + const GList *l; + GList *file_list = NULL; + GFile *file; + + for (l = urilist; l != NULL; l = l->next) { + file = g_file_new_for_uri (l->data); + file_list = g_list_append (file_list, file); + } + + return file_list; +} + +/** ---------------------------------------------------------------- */ +static char * +get_uri_basename (char *uri) +{ + GFile *f = g_file_new_for_uri (uri); + char *basename = g_file_get_basename (f); + g_object_unref (f); + return basename; +} + +/** ---------------------------------------------------------------- */ +static char * +get_uri_parent (char *uri) +{ + GFile *f = g_file_new_for_uri (uri); + GFile *p = g_file_get_parent (f); + char *parent = g_file_get_uri (p); + g_object_unref (f); + g_object_unref (p); + return parent; +} + +/** ---------------------------------------------------------------- */ +static char * +get_uri_parent_path (char *uri) +{ + GFile *f = g_file_new_for_uri (uri); + GFile *p = g_file_get_parent (f); + char *parent = g_file_get_path (p); + g_object_unref (f); + g_object_unref (p); + return parent; +} + +/** ---------------------------------------------------------------- */ +static GHashTable * +retrieve_files_to_restore (GHashTable * trashed) +{ + GFileEnumerator *enumerator; + GFileInfo *info; + GFile *trash; + GFile *item; + guint64 mtime_item; + guint64 *mtime; + char *origpath; + GFile *origfile; + char *origuri; + gpointer lookupvalue; + GHashTable *to_restore; + + to_restore = + g_hash_table_new_full (g_direct_hash, + g_direct_equal, g_object_unref, g_free); + + trash = g_file_new_for_uri ("trash:"); + + enumerator = g_file_enumerate_children (trash, + G_FILE_ATTRIBUTE_STANDARD_NAME + "," + G_FILE_ATTRIBUTE_TIME_MODIFIED + ",trash::orig-path", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, FALSE, NULL); + + mtime = 0; + if (enumerator) { + while ((info = + g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL) { + /* Retrieve the original file uri */ + origpath = g_file_info_get_attribute_as_string (info, "trash::orig-path"); + origfile = g_file_new_for_path (origpath); + origuri = g_file_get_uri (origfile); + g_object_unref (origfile); + g_free (origpath); + + lookupvalue = g_hash_table_lookup (trashed, origuri); + + if (lookupvalue) { + mtime = (guint64 *) + lookupvalue; + mtime_item = + g_file_info_get_attribute_uint64 + (info, G_FILE_ATTRIBUTE_TIME_MODIFIED); + if (*mtime == mtime_item) { + item = g_file_get_child (trash, g_file_info_get_name (info)); /* File in the trash */ + g_hash_table_insert (to_restore, item, origuri); + } + } else { + g_free (origuri); + } + + } + g_file_enumerator_close (enumerator, FALSE, NULL); + g_object_unref (enumerator); + } + g_object_unref (trash); + + return to_restore; +} + +/** ---------------------------------------------------------------- */ |