1 files changed, 442 insertions, 0 deletions
diff --git a/libcaja-private/caja-entry.c b/libcaja-private/caja-entry.c
new file mode 100644
index 00000000..5ebb62a6
--- /dev/null
+++ b/libcaja-private/caja-entry.c
@@ -0,0 +1,442 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* CajaEntry: one-line text editing widget. This consists of bug fixes
+ * and other improvements to GtkEntry, and all the changes could be rolled
+ * into GtkEntry some day.
+ *
+ * Copyright (C) 2000 Eazel, Inc.
+ *
+ * Author: John Sullivan <[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 "caja-entry.h"
+
+#include <string.h>
+#include "caja-global-preferences.h"
+#include "caja-undo-signal-handlers.h"
+#include <eel/eel-gdk-extensions.h>
+#include <eel/eel-gtk-macros.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+
+struct CajaEntryDetails
+{
+ gboolean user_edit;
+ gboolean special_tab_handling;
+
+ guint select_idle_id;
+};
+
+enum
+{
+ USER_CHANGED,
+ SELECTION_CHANGED,
+ LAST_SIGNAL
+};
+static guint signals[LAST_SIGNAL];
+
+static void caja_entry_editable_init (GtkEditableClass *iface);
+
+G_DEFINE_TYPE_WITH_CODE (CajaEntry, caja_entry, GTK_TYPE_ENTRY,
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,
+ caja_entry_editable_init));
+
+static GtkEditableClass *parent_editable_interface = NULL;
+
+static void
+caja_entry_init (CajaEntry *entry)
+{
+ GtkWidget *widget;
+
+ widget = GTK_WIDGET (entry);
+ entry->details = g_new0 (CajaEntryDetails, 1);
+
+ entry->details->user_edit = TRUE;
+
+ caja_undo_set_up_caja_entry_for_undo (entry);
+}
+
+GtkWidget *
+caja_entry_new (void)
+{
+ return gtk_widget_new (CAJA_TYPE_ENTRY, NULL);
+}
+
+GtkWidget *
+caja_entry_new_with_max_length (guint16 max)
+{
+ GtkWidget *widget;
+
+ widget = gtk_widget_new (CAJA_TYPE_ENTRY, NULL);
+ gtk_entry_set_max_length (GTK_ENTRY (widget), max);
+
+ return widget;
+}
+
+static void
+caja_entry_finalize (GObject *object)
+{
+ CajaEntry *entry;
+
+ entry = CAJA_ENTRY (object);
+
+ if (entry->details->select_idle_id != 0)
+ {
+ g_source_remove (entry->details->select_idle_id);
+ }
+
+ g_free (entry->details);
+
+ G_OBJECT_CLASS (caja_entry_parent_class)->finalize (object);
+}
+
+static gboolean
+caja_entry_key_press (GtkWidget *widget, GdkEventKey *event)
+{
+ CajaEntry *entry;
+ GtkEditable *editable;
+ int position;
+ gboolean old_has, new_has;
+ gboolean result;
+
+ entry = CAJA_ENTRY (widget);
+ editable = GTK_EDITABLE (widget);
+
+ if (!gtk_editable_get_editable (editable))
+ {
+ return FALSE;
+ }
+
+ switch (event->keyval)
+ {
+ case GDK_Tab:
+ /* The location bar entry wants TAB to work kind of
+ * like it does in the shell for command completion,
+ * so if we get a tab and there's a selection, we
+ * should position the insertion point at the end of
+ * the selection.
+ */
+ if (entry->details->special_tab_handling && gtk_editable_get_selection_bounds (editable, NULL, NULL))
+ {
+ position = strlen (gtk_entry_get_text (GTK_ENTRY (editable)));
+ gtk_editable_select_region (editable, position, position);
+ return TRUE;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ old_has = gtk_editable_get_selection_bounds (editable, NULL, NULL);
+
+ result = GTK_WIDGET_CLASS (caja_entry_parent_class)->key_press_event (widget, event);
+
+ /* Pressing a key usually changes the selection if there is a selection.
+ * If there is not selection, we can save work by not emitting a signal.
+ */
+ if (result)
+ {
+ new_has = gtk_editable_get_selection_bounds (editable, NULL, NULL);
+ if (old_has || new_has)
+ {
+ g_signal_emit (widget, signals[SELECTION_CHANGED], 0);
+ }
+ }
+
+ return result;
+
+}
+
+static gboolean
+caja_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event)
+{
+ int result;
+ gboolean old_had, new_had;
+ int old_start, old_end, new_start, new_end;
+ CajaEntry *entry;
+ GtkEditable *editable;
+
+ entry = CAJA_ENTRY (widget);
+ editable = GTK_EDITABLE (widget);
+
+ old_had = gtk_editable_get_selection_bounds (editable, &old_start, &old_end);
+
+ result = GTK_WIDGET_CLASS (caja_entry_parent_class)->motion_notify_event (widget, event);
+
+ /* Send a signal if dragging the mouse caused the selection to change. */
+ if (result)
+ {
+ new_had = gtk_editable_get_selection_bounds (editable, &new_start, &new_end);
+ if (old_had != new_had || (old_had && (old_start != new_start || old_end != new_end)))
+ {
+ g_signal_emit (widget, signals[SELECTION_CHANGED], 0);
+ }
+ }
+
+ return result;
+}
+
+/**
+ * caja_entry_select_all
+ *
+ * Select all text, leaving the text cursor position at the end.
+ *
+ * @entry: A CajaEntry
+ **/
+void
+caja_entry_select_all (CajaEntry *entry)
+{
+ g_return_if_fail (CAJA_IS_ENTRY (entry));
+
+ gtk_editable_set_position (GTK_EDITABLE (entry), -1);
+ gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
+}
+
+static gboolean
+select_all_at_idle (gpointer callback_data)
+{
+ CajaEntry *entry;
+
+ entry = CAJA_ENTRY (callback_data);
+
+ caja_entry_select_all (entry);
+
+ entry->details->select_idle_id = 0;
+
+ return FALSE;
+}
+
+/**
+ * caja_entry_select_all_at_idle
+ *
+ * Select all text at the next idle, not immediately.
+ * This is useful when reacting to a key press, because
+ * changing the selection and the text cursor position doesn't
+ * work in a key_press signal handler.
+ *
+ * @entry: A CajaEntry
+ **/
+void
+caja_entry_select_all_at_idle (CajaEntry *entry)
+{
+ g_return_if_fail (CAJA_IS_ENTRY (entry));
+
+ /* If the text cursor position changes in this routine
+ * then gtk_entry_key_press will unselect (and we want
+ * to move the text cursor position to the end).
+ */
+
+ if (entry->details->select_idle_id == 0)
+ {
+ entry->details->select_idle_id = g_idle_add (select_all_at_idle, entry);
+ }
+}
+
+/**
+ * caja_entry_set_text
+ *
+ * This function wraps gtk_entry_set_text. It sets undo_registered
+ * to TRUE and preserves the old value for a later restore. This is
+ * done so the programmatic changes to the entry do not register
+ * with the undo manager.
+ *
+ * @entry: A CajaEntry
+ * @test: The text to set
+ **/
+
+void
+caja_entry_set_text (CajaEntry *entry, const gchar *text)
+{
+ g_return_if_fail (CAJA_IS_ENTRY (entry));
+
+ entry->details->user_edit = FALSE;
+ gtk_entry_set_text (GTK_ENTRY (entry), text);
+ entry->details->user_edit = TRUE;
+
+ g_signal_emit (entry, signals[SELECTION_CHANGED], 0);
+}
+
+static void
+caja_entry_set_selection_bounds (GtkEditable *editable,
+ int start_pos,
+ int end_pos)
+{
+ parent_editable_interface->set_selection_bounds (editable, start_pos, end_pos);
+
+ g_signal_emit (editable, signals[SELECTION_CHANGED], 0);
+}
+
+static gboolean
+caja_entry_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ gboolean result;
+
+ result = GTK_WIDGET_CLASS (caja_entry_parent_class)->button_press_event (widget, event);
+
+ if (result)
+ {
+ g_signal_emit (widget, signals[SELECTION_CHANGED], 0);
+ }
+
+ return result;
+}
+
+static gboolean
+caja_entry_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ gboolean result;
+
+ result = GTK_WIDGET_CLASS (caja_entry_parent_class)->button_release_event (widget, event);
+
+ if (result)
+ {
+ g_signal_emit (widget, signals[SELECTION_CHANGED], 0);
+ }
+
+ return result;
+}
+
+static void
+caja_entry_insert_text (GtkEditable *editable, const gchar *text,
+ int length, int *position)
+{
+ CajaEntry *entry;
+
+ entry = CAJA_ENTRY(editable);
+
+ /* Fire off user changed signals */
+ if (entry->details->user_edit)
+ {
+ g_signal_emit (editable, signals[USER_CHANGED], 0);
+ }
+
+ parent_editable_interface->insert_text (editable, text, length, position);
+
+ g_signal_emit (editable, signals[SELECTION_CHANGED], 0);
+}
+
+static void
+caja_entry_delete_text (GtkEditable *editable, int start_pos, int end_pos)
+{
+ CajaEntry *entry;
+
+ entry = CAJA_ENTRY (editable);
+
+ /* Fire off user changed signals */
+ if (entry->details->user_edit)
+ {
+ g_signal_emit (editable, signals[USER_CHANGED], 0);
+ }
+
+ parent_editable_interface->delete_text (editable, start_pos, end_pos);
+
+ g_signal_emit (editable, signals[SELECTION_CHANGED], 0);
+}
+
+/* Overridden to work around GTK bug. The selection_clear_event is queued
+ * when the selection changes. Changing the selection to NULL and then
+ * back to the original selection owner still sends the event, so the
+ * selection owner then gets the selection ripped away from it. We ran into
+ * this with type-completion behavior in CajaLocationBar (see bug 5313).
+ * There's a FIXME comment that seems to be about this same issue in
+ * gtk+/gtkselection.c, gtk_selection_clear.
+ */
+static gboolean
+caja_entry_selection_clear (GtkWidget *widget,
+ GdkEventSelection *event)
+{
+ g_assert (CAJA_IS_ENTRY (widget));
+
+ if (gdk_selection_owner_get (event->selection) == gtk_widget_get_window (widget))
+ {
+ return FALSE;
+ }
+
+ return GTK_WIDGET_CLASS (caja_entry_parent_class)->selection_clear_event (widget, event);
+}
+
+static void
+caja_entry_editable_init (GtkEditableClass *iface)
+{
+ parent_editable_interface = g_type_interface_peek_parent (iface);
+
+ iface->insert_text = caja_entry_insert_text;
+ iface->delete_text = caja_entry_delete_text;
+ iface->set_selection_bounds = caja_entry_set_selection_bounds;
+
+ /* Otherwise we might need some memcpy loving */
+ g_assert (iface->do_insert_text != NULL);
+ g_assert (iface->get_position != NULL);
+ g_assert (iface->get_chars != NULL);
+}
+
+static void
+caja_entry_class_init (CajaEntryClass *class)
+{
+ GtkWidgetClass *widget_class;
+ GtkObjectClass *object_class;
+ GObjectClass *gobject_class;
+
+ widget_class = GTK_WIDGET_CLASS (class);
+ gobject_class = G_OBJECT_CLASS (class);
+ object_class = GTK_OBJECT_CLASS (class);
+
+ widget_class->button_press_event = caja_entry_button_press;
+ widget_class->button_release_event = caja_entry_button_release;
+ widget_class->key_press_event = caja_entry_key_press;
+ widget_class->motion_notify_event = caja_entry_motion_notify;
+ widget_class->selection_clear_event = caja_entry_selection_clear;
+
+ gobject_class->finalize = caja_entry_finalize;
+
+ /* Set up signals */
+ signals[USER_CHANGED] = g_signal_new
+ ("user_changed",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaEntryClass,
+ user_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[SELECTION_CHANGED] = g_signal_new
+ ("selection_changed",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaEntryClass,
+ selection_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+void
+caja_entry_set_special_tab_handling (CajaEntry *entry,
+ gboolean special_tab_handling)
+{
+ g_return_if_fail (CAJA_IS_ENTRY (entry));
+
+ entry->details->special_tab_handling = special_tab_handling;
+}
+
+