1 files changed, 345 insertions, 0 deletions
diff --git a/libcaja-private/caja-undo-signal-handlers.c b/libcaja-private/caja-undo-signal-handlers.c
new file mode 100644
index 00000000..04d5360e
--- /dev/null
+++ b/libcaja-private/caja-undo-signal-handlers.c
@@ -0,0 +1,345 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* Signal handlers to enable undo in Gtk Widgets.
+ *
+ * Copyright (C) 2000 Eazel, Inc.
+ *
+ * Author: Gene Z. Ragan <[email protected]>
+ *
+ * This 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.
+ *
+ * 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library 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 <config.h>
+#include <gtk/gtk.h>
+
+#include <glib/gi18n.h>
+#include <libcaja-private/caja-undo.h>
+
+#include <eel/eel-gtk-macros.h>
+#include <string.h>
+
+#include "caja-undo-signal-handlers.h"
+
+
+typedef struct
+{
+ char *undo_text;
+ gint position;
+ guint selection_start;
+ guint selection_end;
+} EditableUndoData;
+
+typedef struct
+{
+ gboolean undo_registered;
+} EditableUndoObjectData;
+
+
+static void restore_editable_from_undo_snapshot_callback (GObject *target,
+ gpointer callback_data);
+static void editable_register_edit_undo (GtkEditable *editable);
+static void free_editable_object_data (gpointer data);
+
+/* caja_undo_set_up_caja_entry_for_undo
+ *
+ * Functions and callback methods to handle undo
+ * in a CajaEntry
+ */
+
+static void
+caja_entry_user_changed_callback (CajaEntry *entry)
+{
+ /* Register undo transaction */
+ editable_register_edit_undo (GTK_EDITABLE (entry));
+}
+
+void
+caja_undo_set_up_caja_entry_for_undo (CajaEntry *entry)
+{
+ EditableUndoObjectData *data;
+
+ if (!CAJA_IS_ENTRY (entry) )
+ {
+ return;
+ }
+
+ data = g_new(EditableUndoObjectData, 1);
+ data->undo_registered = FALSE;
+ g_object_set_data_full (G_OBJECT (entry), "undo_registered",
+ data, free_editable_object_data);
+
+ /* Connect to entry signals */
+ g_signal_connect (entry, "user_changed",
+ G_CALLBACK (caja_entry_user_changed_callback),
+ NULL);
+}
+
+void
+caja_undo_tear_down_caja_entry_for_undo (CajaEntry *entry)
+{
+ if (!CAJA_IS_ENTRY (entry) )
+ {
+ return;
+ }
+
+ /* Disconnect from entry signals */
+ g_signal_handlers_disconnect_by_func
+ (entry, G_CALLBACK (caja_entry_user_changed_callback), NULL);
+
+}
+
+/* caja_undo_set_up_caja_entry_for_undo
+ *
+ * Functions and callback methods to handle undo
+ * in a CajaEntry
+ */
+
+static void
+free_editable_undo_data (gpointer data)
+{
+ EditableUndoData *undo_data;
+
+ undo_data = (EditableUndoData *) data;
+
+ g_free (undo_data->undo_text);
+ g_free (undo_data);
+}
+
+static void
+free_editable_object_data (gpointer data)
+{
+ g_free (data);
+}
+
+
+static void
+editable_insert_text_callback (GtkEditable *editable)
+{
+ /* Register undo transaction */
+ editable_register_edit_undo (editable);
+}
+
+static void
+editable_delete_text_callback (GtkEditable *editable)
+{
+ /* Register undo transaction */
+ editable_register_edit_undo (editable);
+}
+
+static void
+editable_register_edit_undo (GtkEditable *editable)
+{
+ EditableUndoData *undo_data;
+ EditableUndoObjectData *undo_info;
+ gpointer data;
+
+ if (!GTK_IS_EDITABLE (editable) )
+ {
+ return;
+ }
+
+ /* Check our undo registered flag */
+ data = g_object_get_data (G_OBJECT (editable), "undo_registered");
+ if (data == NULL)
+ {
+ g_warning ("Undo data is NULL");
+ return;
+ }
+
+ undo_info = (EditableUndoObjectData *)data;
+ if (undo_info->undo_registered)
+ {
+ return;
+ }
+
+ undo_data = g_new0 (EditableUndoData, 1);
+ undo_data->undo_text = gtk_editable_get_chars (editable, 0, -1);
+ undo_data->position = gtk_editable_get_position (editable);
+ gtk_editable_get_selection_bounds (editable,
+ &undo_data->selection_start,
+ &undo_data->selection_end);
+
+ caja_undo_register
+ (G_OBJECT (editable),
+ restore_editable_from_undo_snapshot_callback,
+ undo_data,
+ (GDestroyNotify) free_editable_undo_data,
+ _("Edit"),
+ _("Undo Edit"),
+ _("Undo the edit"),
+ _("Redo Edit"),
+ _("Redo the edit"));
+
+ undo_info->undo_registered = TRUE;
+}
+
+void
+caja_undo_set_up_editable_for_undo (GtkEditable *editable)
+{
+ EditableUndoObjectData *data;
+
+ if (!GTK_IS_EDITABLE (editable) )
+ {
+ return;
+ }
+
+ /* Connect to editable signals */
+ g_signal_connect (editable, "insert_text",
+ G_CALLBACK (editable_insert_text_callback), NULL);
+ g_signal_connect (editable, "delete_text",
+ G_CALLBACK (editable_delete_text_callback), NULL);
+
+
+ data = g_new (EditableUndoObjectData, 1);
+ data->undo_registered = FALSE;
+ g_object_set_data_full (G_OBJECT (editable), "undo_registered",
+ data, free_editable_object_data);
+}
+
+void
+caja_undo_tear_down_editable_for_undo (GtkEditable *editable)
+{
+ if (!GTK_IS_EDITABLE (editable) )
+ {
+ return;
+ }
+
+ /* Disconnect from entry signals */
+ g_signal_handlers_disconnect_by_func
+ (editable, G_CALLBACK (editable_insert_text_callback), NULL);
+ g_signal_handlers_disconnect_by_func
+ (editable, G_CALLBACK (editable_delete_text_callback), NULL);
+}
+
+/* restore_editable_from_undo_snapshot_callback
+ *
+ * Restore edited text.
+ */
+static void
+restore_editable_from_undo_snapshot_callback (GObject *target, gpointer callback_data)
+{
+ GtkEditable *editable;
+ GtkWindow *window;
+ EditableUndoData *undo_data;
+ EditableUndoObjectData *data;
+ gint position;
+
+ editable = GTK_EDITABLE (target);
+ undo_data = (EditableUndoData *) callback_data;
+
+ /* Check our undo registered flag */
+ data = g_object_get_data (target, "undo_registered");
+ if (data == NULL)
+ {
+ g_warning ("Undo regisetred flag not found");
+ return;
+ }
+
+ /* Reset the registered flag so we get a new item for future editing. */
+ data->undo_registered = FALSE;
+
+ /* Register a new undo transaction for redo. */
+ editable_register_edit_undo (editable);
+
+ /* Restore the text. */
+ position = 0;
+ gtk_editable_delete_text (editable, 0, -1);
+ gtk_editable_insert_text (editable, undo_data->undo_text,
+ strlen (undo_data->undo_text), &position);
+
+ /* Set focus to widget */
+ window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (target)));
+ gtk_window_set_focus (window, GTK_WIDGET (editable));
+
+ /* We have to do this call, because the previous call selects all text */
+ gtk_editable_select_region (editable, 0, 0);
+
+ /* Restore selection */
+ gtk_editable_select_region (editable, undo_data->selection_start,
+ undo_data->selection_end);
+
+ /* Set the i-beam to the saved position */
+ gtk_editable_set_position (editable, undo_data->position);
+
+ /* Reset the registered flag so we get a new item for future editing. */
+ data->undo_registered = FALSE;
+}
+
+
+/* editable_set_undo_key
+ *
+ * Allow the use of ctrl-z from within widget.
+ */
+
+/* Undo is disabled until we have a better implementation.
+ * Both here and in caja-shell-ui.xml.
+ */
+
+/* FIXME bugzilla.gnome.org 43515: Undo doesn't work */
+#ifdef UNDO_ENABLED
+
+static gboolean
+editable_key_press_event (GtkEditable *editable, GdkEventKey *event, gpointer user_data)
+{
+ switch (event->keyval)
+ {
+ /* Undo */
+ case 'z':
+ if ((event->state & GDK_CONTROL_MASK) != 0)
+ {
+ caja_undo (GTK_OBJECT (editable));
+ return TRUE;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
+#endif
+
+/* editable_set_undo_key
+ *
+ * Allow the use of ctrl-z from within widget. This should only be
+ * set if there is no menu bar to use to undo the widget.
+ */
+
+void
+caja_undo_editable_set_undo_key (GtkEditable *editable, gboolean value)
+{
+ /* FIXME bugzilla.gnome.org 43515: Undo doesn't work */
+#ifdef UNDO_ENABLED
+ if (value)
+ {
+ /* Connect to entry signals */
+ g_signal_connect (editable, "key_press_event",
+ G_CALLBACK (editable_key_press_event), NULL);
+ }
+ else
+ {
+ /* FIXME bugzilla.gnome.org 45092: Warns if the handler
+ * is not already connected. We could use object data
+ * to prevent that little problem.
+ */
+ g_signal_disconnect_by_func (editable,
+ G_CALLBACK (editable_key_press_event), NULL);
+ }
+#endif
+}