aboutsummaryrefslogtreecommitdiffstats
path: root/e-util/e-focus-tracker.c
diff options
context:
space:
mode:
Diffstat (limited to 'e-util/e-focus-tracker.c')
-rw-r--r--e-util/e-focus-tracker.c886
1 files changed, 886 insertions, 0 deletions
diff --git a/e-util/e-focus-tracker.c b/e-util/e-focus-tracker.c
new file mode 100644
index 0000000000..a610605987
--- /dev/null
+++ b/e-util/e-focus-tracker.c
@@ -0,0 +1,886 @@
+/*
+ * e-focus-tracker.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "e-focus-tracker.h"
+
+#include <glib/gi18n-lib.h>
+
+#include "e-selectable.h"
+
+#define E_FOCUS_TRACKER_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE \
+ ((obj), E_TYPE_FOCUS_TRACKER, EFocusTrackerPrivate))
+
+struct _EFocusTrackerPrivate {
+ GtkWidget *focus; /* not referenced */
+ GtkWindow *window;
+
+ GtkAction *cut_clipboard;
+ GtkAction *copy_clipboard;
+ GtkAction *paste_clipboard;
+ GtkAction *delete_selection;
+ GtkAction *select_all;
+};
+
+enum {
+ PROP_0,
+ PROP_FOCUS,
+ PROP_WINDOW,
+ PROP_CUT_CLIPBOARD_ACTION,
+ PROP_COPY_CLIPBOARD_ACTION,
+ PROP_PASTE_CLIPBOARD_ACTION,
+ PROP_DELETE_SELECTION_ACTION,
+ PROP_SELECT_ALL_ACTION
+};
+
+G_DEFINE_TYPE (
+ EFocusTracker,
+ e_focus_tracker,
+ G_TYPE_OBJECT)
+
+static void
+focus_tracker_disable_actions (EFocusTracker *focus_tracker)
+{
+ GtkAction *action;
+
+ action = e_focus_tracker_get_cut_clipboard_action (focus_tracker);
+ if (action != NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_copy_clipboard_action (focus_tracker);
+ if (action != NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_paste_clipboard_action (focus_tracker);
+ if (action != NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_delete_selection_action (focus_tracker);
+ if (action != NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_select_all_action (focus_tracker);
+ if (action != NULL)
+ gtk_action_set_sensitive (action, FALSE);
+}
+
+static void
+focus_tracker_editable_update_actions (EFocusTracker *focus_tracker,
+ GtkEditable *editable,
+ GdkAtom *targets,
+ gint n_targets)
+{
+ GtkAction *action;
+ gboolean can_edit_text;
+ gboolean clipboard_has_text;
+ gboolean text_is_selected;
+ gboolean sensitive;
+
+ can_edit_text =
+ gtk_editable_get_editable (editable);
+
+ clipboard_has_text = (targets != NULL) &&
+ gtk_targets_include_text (targets, n_targets);
+
+ text_is_selected =
+ gtk_editable_get_selection_bounds (editable, NULL, NULL);
+
+ action = e_focus_tracker_get_cut_clipboard_action (focus_tracker);
+ if (action != NULL) {
+ sensitive = can_edit_text && text_is_selected;
+ gtk_action_set_sensitive (action, sensitive);
+ gtk_action_set_tooltip (action, _("Cut the selection"));
+ }
+
+ action = e_focus_tracker_get_copy_clipboard_action (focus_tracker);
+ if (action != NULL) {
+ sensitive = text_is_selected;
+ gtk_action_set_sensitive (action, sensitive);
+ gtk_action_set_tooltip (action, _("Copy the selection"));
+ }
+
+ action = e_focus_tracker_get_paste_clipboard_action (focus_tracker);
+ if (action != NULL) {
+ sensitive = can_edit_text && clipboard_has_text;
+ gtk_action_set_sensitive (action, sensitive);
+ gtk_action_set_tooltip (action, _("Paste the clipboard"));
+ }
+
+ action = e_focus_tracker_get_delete_selection_action (focus_tracker);
+ if (action != NULL) {
+ sensitive = can_edit_text && text_is_selected;
+ gtk_action_set_sensitive (action, sensitive);
+ gtk_action_set_tooltip (action, _("Delete the selection"));
+ }
+
+ action = e_focus_tracker_get_select_all_action (focus_tracker);
+ if (action != NULL) {
+ sensitive = TRUE; /* always enabled */
+ gtk_action_set_sensitive (action, sensitive);
+ gtk_action_set_tooltip (action, _("Select all text"));
+ }
+}
+
+static void
+focus_tracker_selectable_update_actions (EFocusTracker *focus_tracker,
+ ESelectable *selectable,
+ GdkAtom *targets,
+ gint n_targets)
+{
+ ESelectableInterface *interface;
+ GtkAction *action;
+
+ interface = E_SELECTABLE_GET_INTERFACE (selectable);
+
+ e_selectable_update_actions (
+ selectable, focus_tracker, targets, n_targets);
+
+ /* Disable actions for which the corresponding method is not
+ * implemented. This allows update_actions() implementations
+ * to simply skip the actions they don't support, which in turn
+ * allows us to add new actions without disturbing the existing
+ * ESelectable implementations. */
+
+ action = e_focus_tracker_get_cut_clipboard_action (focus_tracker);
+ if (action != NULL && interface->cut_clipboard == NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_copy_clipboard_action (focus_tracker);
+ if (action != NULL && interface->copy_clipboard == NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_paste_clipboard_action (focus_tracker);
+ if (action != NULL && interface->paste_clipboard == NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_delete_selection_action (focus_tracker);
+ if (action != NULL && interface->delete_selection == NULL)
+ gtk_action_set_sensitive (action, FALSE);
+
+ action = e_focus_tracker_get_select_all_action (focus_tracker);
+ if (action != NULL && interface->select_all == NULL)
+ gtk_action_set_sensitive (action, FALSE);
+}
+
+static void
+focus_tracker_targets_received_cb (GtkClipboard *clipboard,
+ GdkAtom *targets,
+ gint n_targets,
+ EFocusTracker *focus_tracker)
+{
+ GtkWidget *focus;
+
+ focus = e_focus_tracker_get_focus (focus_tracker);
+
+ if (focus == NULL)
+ focus_tracker_disable_actions (focus_tracker);
+
+ else if (GTK_IS_EDITABLE (focus))
+ focus_tracker_editable_update_actions (
+ focus_tracker, GTK_EDITABLE (focus),
+ targets, n_targets);
+
+ else if (E_IS_SELECTABLE (focus))
+ focus_tracker_selectable_update_actions (
+ focus_tracker, E_SELECTABLE (focus),
+ targets, n_targets);
+
+ g_object_unref (focus_tracker);
+}
+
+static void
+focus_tracker_set_focus_cb (GtkWindow *window,
+ GtkWidget *focus,
+ EFocusTracker *focus_tracker)
+{
+ while (focus != NULL) {
+ if (GTK_IS_EDITABLE (focus))
+ break;
+
+ if (E_IS_SELECTABLE (focus))
+ break;
+
+ focus = gtk_widget_get_parent (focus);
+ }
+
+ if (focus == focus_tracker->priv->focus)
+ return;
+
+ focus_tracker->priv->focus = focus;
+ g_object_notify (G_OBJECT (focus_tracker), "focus");
+
+ e_focus_tracker_update_actions (focus_tracker);
+}
+
+static void
+focus_tracker_set_window (EFocusTracker *focus_tracker,
+ GtkWindow *window)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+ g_return_if_fail (focus_tracker->priv->window == NULL);
+
+ focus_tracker->priv->window = g_object_ref (window);
+
+ g_signal_connect (
+ window, "set-focus",
+ G_CALLBACK (focus_tracker_set_focus_cb), focus_tracker);
+}
+
+static void
+focus_tracker_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ switch (property_id) {
+ case PROP_WINDOW:
+ focus_tracker_set_window (
+ E_FOCUS_TRACKER (object),
+ g_value_get_object (value));
+ return;
+
+ case PROP_CUT_CLIPBOARD_ACTION:
+ e_focus_tracker_set_cut_clipboard_action (
+ E_FOCUS_TRACKER (object),
+ g_value_get_object (value));
+ return;
+
+ case PROP_COPY_CLIPBOARD_ACTION:
+ e_focus_tracker_set_copy_clipboard_action (
+ E_FOCUS_TRACKER (object),
+ g_value_get_object (value));
+ return;
+
+ case PROP_PASTE_CLIPBOARD_ACTION:
+ e_focus_tracker_set_paste_clipboard_action (
+ E_FOCUS_TRACKER (object),
+ g_value_get_object (value));
+ return;
+
+ case PROP_DELETE_SELECTION_ACTION:
+ e_focus_tracker_set_delete_selection_action (
+ E_FOCUS_TRACKER (object),
+ g_value_get_object (value));
+ return;
+
+ case PROP_SELECT_ALL_ACTION:
+ e_focus_tracker_set_select_all_action (
+ E_FOCUS_TRACKER (object),
+ g_value_get_object (value));
+ return;
+ }
+
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+focus_tracker_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ switch (property_id) {
+ case PROP_FOCUS:
+ g_value_set_object (
+ value,
+ e_focus_tracker_get_focus (
+ E_FOCUS_TRACKER (object)));
+ return;
+
+ case PROP_WINDOW:
+ g_value_set_object (
+ value,
+ e_focus_tracker_get_window (
+ E_FOCUS_TRACKER (object)));
+ return;
+
+ case PROP_CUT_CLIPBOARD_ACTION:
+ g_value_set_object (
+ value,
+ e_focus_tracker_get_cut_clipboard_action (
+ E_FOCUS_TRACKER (object)));
+ return;
+
+ case PROP_COPY_CLIPBOARD_ACTION:
+ g_value_set_object (
+ value,
+ e_focus_tracker_get_copy_clipboard_action (
+ E_FOCUS_TRACKER (object)));
+ return;
+
+ case PROP_PASTE_CLIPBOARD_ACTION:
+ g_value_set_object (
+ value,
+ e_focus_tracker_get_paste_clipboard_action (
+ E_FOCUS_TRACKER (object)));
+ return;
+
+ case PROP_DELETE_SELECTION_ACTION:
+ g_value_set_object (
+ value,
+ e_focus_tracker_get_delete_selection_action (
+ E_FOCUS_TRACKER (object)));
+ return;
+
+ case PROP_SELECT_ALL_ACTION:
+ g_value_set_object (
+ value,
+ e_focus_tracker_get_select_all_action (
+ E_FOCUS_TRACKER (object)));
+ return;
+ }
+
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+focus_tracker_dispose (GObject *object)
+{
+ EFocusTrackerPrivate *priv;
+
+ priv = E_FOCUS_TRACKER_GET_PRIVATE (object);
+
+ g_signal_handlers_disconnect_matched (
+ gtk_clipboard_get (GDK_SELECTION_PRIMARY),
+ G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, object);
+
+ g_signal_handlers_disconnect_matched (
+ gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
+ G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, object);
+
+ if (priv->window != NULL) {
+ g_signal_handlers_disconnect_matched (
+ priv->window, G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, object);
+ g_object_unref (priv->window);
+ priv->window = NULL;
+ }
+
+ if (priv->cut_clipboard != NULL) {
+ g_signal_handlers_disconnect_matched (
+ priv->cut_clipboard, G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, object);
+ g_object_unref (priv->cut_clipboard);
+ priv->cut_clipboard = NULL;
+ }
+
+ if (priv->copy_clipboard != NULL) {
+ g_signal_handlers_disconnect_matched (
+ priv->copy_clipboard, G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, object);
+ g_object_unref (priv->copy_clipboard);
+ priv->copy_clipboard = NULL;
+ }
+
+ if (priv->paste_clipboard != NULL) {
+ g_signal_handlers_disconnect_matched (
+ priv->paste_clipboard, G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, object);
+ g_object_unref (priv->paste_clipboard);
+ priv->paste_clipboard = NULL;
+ }
+
+ if (priv->delete_selection != NULL) {
+ g_signal_handlers_disconnect_matched (
+ priv->delete_selection, G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, object);
+ g_object_unref (priv->delete_selection);
+ priv->delete_selection = NULL;
+ }
+
+ if (priv->select_all != NULL) {
+ g_signal_handlers_disconnect_matched (
+ priv->select_all, G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, object);
+ g_object_unref (priv->select_all);
+ priv->select_all = NULL;
+ }
+
+ /* Chain up to parent's dispose() method. */
+ G_OBJECT_CLASS (e_focus_tracker_parent_class)->dispose (object);
+}
+
+static void
+focus_tracker_constructed (GObject *object)
+{
+ GtkClipboard *clipboard;
+
+ /* Listen for "owner-change" signals from the primary selection
+ * clipboard to learn when text selections change in GtkEditable
+ * widgets. It's a bit of an overkill, but I don't know of any
+ * other notification mechanism. */
+
+ clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
+
+ g_signal_connect_swapped (
+ clipboard, "owner-change",
+ G_CALLBACK (e_focus_tracker_update_actions), object);
+
+ /* Listen for "owner-change" signals from the default clipboard
+ * so we can update the paste action when the user cuts or copies
+ * something. This is how GEdit does it. */
+
+ clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
+
+ g_signal_connect_swapped (
+ clipboard, "owner-change",
+ G_CALLBACK (e_focus_tracker_update_actions), object);
+
+ /* Chain up to parent's constructed() method. */
+ G_OBJECT_CLASS (e_focus_tracker_parent_class)->constructed (object);
+}
+
+static void
+e_focus_tracker_class_init (EFocusTrackerClass *class)
+{
+ GObjectClass *object_class;
+
+ g_type_class_add_private (class, sizeof (EFocusTrackerPrivate));
+
+ object_class = G_OBJECT_CLASS (class);
+ object_class->set_property = focus_tracker_set_property;
+ object_class->get_property = focus_tracker_get_property;
+ object_class->dispose = focus_tracker_dispose;
+ object_class->constructed = focus_tracker_constructed;
+
+ g_object_class_install_property (
+ object_class,
+ PROP_FOCUS,
+ g_param_spec_object (
+ "focus",
+ "Focus",
+ NULL,
+ GTK_TYPE_WIDGET,
+ G_PARAM_READABLE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_WINDOW,
+ g_param_spec_object (
+ "window",
+ "Window",
+ NULL,
+ GTK_TYPE_WINDOW,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_CUT_CLIPBOARD_ACTION,
+ g_param_spec_object (
+ "cut-clipboard-action",
+ "Cut Clipboard Action",
+ NULL,
+ GTK_TYPE_ACTION,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_COPY_CLIPBOARD_ACTION,
+ g_param_spec_object (
+ "copy-clipboard-action",
+ "Copy Clipboard Action",
+ NULL,
+ GTK_TYPE_ACTION,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_PASTE_CLIPBOARD_ACTION,
+ g_param_spec_object (
+ "paste-clipboard-action",
+ "Paste Clipboard Action",
+ NULL,
+ GTK_TYPE_ACTION,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_DELETE_SELECTION_ACTION,
+ g_param_spec_object (
+ "delete-selection-action",
+ "Delete Selection Action",
+ NULL,
+ GTK_TYPE_ACTION,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_SELECT_ALL_ACTION,
+ g_param_spec_object (
+ "select-all-action",
+ "Select All Action",
+ NULL,
+ GTK_TYPE_ACTION,
+ G_PARAM_READWRITE));
+}
+
+static void
+e_focus_tracker_init (EFocusTracker *focus_tracker)
+{
+ GtkAction *action;
+
+ focus_tracker->priv = E_FOCUS_TRACKER_GET_PRIVATE (focus_tracker);
+
+ /* Define dummy actions. These will most likely be overridden,
+ * but for cases where they're not it ensures ESelectable objects
+ * will always get a valid GtkAction when they ask us for one. */
+
+ action = gtk_action_new (
+ "cut-clipboard", NULL,
+ _("Cut the selection"), GTK_STOCK_CUT);
+ focus_tracker->priv->cut_clipboard = action;
+
+ action = gtk_action_new (
+ "copy-clipboard", NULL,
+ _("Copy the selection"), GTK_STOCK_COPY);
+ focus_tracker->priv->copy_clipboard = action;
+
+ action = gtk_action_new (
+ "paste-clipboard", NULL,
+ _("Paste the clipboard"), GTK_STOCK_PASTE);
+ focus_tracker->priv->paste_clipboard = action;
+
+ action = gtk_action_new (
+ "delete-selection", NULL,
+ _("Delete the selection"), GTK_STOCK_DELETE);
+ focus_tracker->priv->delete_selection = action;
+
+ action = gtk_action_new (
+ "select-all", NULL,
+ _("Select all text"), GTK_STOCK_SELECT_ALL);
+ focus_tracker->priv->select_all = action;
+}
+
+EFocusTracker *
+e_focus_tracker_new (GtkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
+
+ return g_object_new (E_TYPE_FOCUS_TRACKER, "window", window, NULL);
+}
+
+GtkWidget *
+e_focus_tracker_get_focus (EFocusTracker *focus_tracker)
+{
+ g_return_val_if_fail (E_IS_FOCUS_TRACKER (focus_tracker), NULL);
+
+ return focus_tracker->priv->focus;
+}
+
+GtkWindow *
+e_focus_tracker_get_window (EFocusTracker *focus_tracker)
+{
+ g_return_val_if_fail (E_IS_FOCUS_TRACKER (focus_tracker), NULL);
+
+ return focus_tracker->priv->window;
+}
+
+GtkAction *
+e_focus_tracker_get_cut_clipboard_action (EFocusTracker *focus_tracker)
+{
+ g_return_val_if_fail (E_IS_FOCUS_TRACKER (focus_tracker), NULL);
+
+ return focus_tracker->priv->cut_clipboard;
+}
+
+void
+e_focus_tracker_set_cut_clipboard_action (EFocusTracker *focus_tracker,
+ GtkAction *cut_clipboard)
+{
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ if (cut_clipboard != NULL) {
+ g_return_if_fail (GTK_IS_ACTION (cut_clipboard));
+ g_object_ref (cut_clipboard);
+ }
+
+ if (focus_tracker->priv->cut_clipboard != NULL) {
+ g_signal_handlers_disconnect_matched (
+ focus_tracker->priv->cut_clipboard,
+ G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
+ focus_tracker);
+ g_object_unref (focus_tracker->priv->cut_clipboard);
+ }
+
+ focus_tracker->priv->cut_clipboard = cut_clipboard;
+
+ if (cut_clipboard != NULL)
+ g_signal_connect_swapped (
+ cut_clipboard, "activate",
+ G_CALLBACK (e_focus_tracker_cut_clipboard),
+ focus_tracker);
+
+ g_object_notify (G_OBJECT (focus_tracker), "cut-clipboard-action");
+}
+
+GtkAction *
+e_focus_tracker_get_copy_clipboard_action (EFocusTracker *focus_tracker)
+{
+ g_return_val_if_fail (E_IS_FOCUS_TRACKER (focus_tracker), NULL);
+
+ return focus_tracker->priv->copy_clipboard;
+}
+
+void
+e_focus_tracker_set_copy_clipboard_action (EFocusTracker *focus_tracker,
+ GtkAction *copy_clipboard)
+{
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ if (copy_clipboard != NULL) {
+ g_return_if_fail (GTK_IS_ACTION (copy_clipboard));
+ g_object_ref (copy_clipboard);
+ }
+
+ if (focus_tracker->priv->copy_clipboard != NULL) {
+ g_signal_handlers_disconnect_matched (
+ focus_tracker->priv->copy_clipboard,
+ G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
+ focus_tracker);
+ g_object_unref (focus_tracker->priv->copy_clipboard);
+ }
+
+ focus_tracker->priv->copy_clipboard = copy_clipboard;
+
+ if (copy_clipboard != NULL)
+ g_signal_connect_swapped (
+ copy_clipboard, "activate",
+ G_CALLBACK (e_focus_tracker_copy_clipboard),
+ focus_tracker);
+
+ g_object_notify (G_OBJECT (focus_tracker), "copy-clipboard-action");
+}
+
+GtkAction *
+e_focus_tracker_get_paste_clipboard_action (EFocusTracker *focus_tracker)
+{
+ g_return_val_if_fail (E_IS_FOCUS_TRACKER (focus_tracker), NULL);
+
+ return focus_tracker->priv->paste_clipboard;
+}
+
+void
+e_focus_tracker_set_paste_clipboard_action (EFocusTracker *focus_tracker,
+ GtkAction *paste_clipboard)
+{
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ if (paste_clipboard != NULL) {
+ g_return_if_fail (GTK_IS_ACTION (paste_clipboard));
+ g_object_ref (paste_clipboard);
+ }
+
+ if (focus_tracker->priv->paste_clipboard != NULL) {
+ g_signal_handlers_disconnect_matched (
+ focus_tracker->priv->paste_clipboard,
+ G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
+ focus_tracker);
+ g_object_unref (focus_tracker->priv->paste_clipboard);
+ }
+
+ focus_tracker->priv->paste_clipboard = paste_clipboard;
+
+ if (paste_clipboard != NULL)
+ g_signal_connect_swapped (
+ paste_clipboard, "activate",
+ G_CALLBACK (e_focus_tracker_paste_clipboard),
+ focus_tracker);
+
+ g_object_notify (G_OBJECT (focus_tracker), "paste-clipboard-action");
+}
+
+GtkAction *
+e_focus_tracker_get_delete_selection_action (EFocusTracker *focus_tracker)
+{
+ g_return_val_if_fail (E_IS_FOCUS_TRACKER (focus_tracker), NULL);
+
+ return focus_tracker->priv->delete_selection;
+}
+
+void
+e_focus_tracker_set_delete_selection_action (EFocusTracker *focus_tracker,
+ GtkAction *delete_selection)
+{
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ if (delete_selection != NULL) {
+ g_return_if_fail (GTK_IS_ACTION (delete_selection));
+ g_object_ref (delete_selection);
+ }
+
+ if (focus_tracker->priv->delete_selection != NULL) {
+ g_signal_handlers_disconnect_matched (
+ focus_tracker->priv->delete_selection,
+ G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
+ focus_tracker);
+ g_object_unref (focus_tracker->priv->delete_selection);
+ }
+
+ focus_tracker->priv->delete_selection = delete_selection;
+
+ if (delete_selection != NULL)
+ g_signal_connect_swapped (
+ delete_selection, "activate",
+ G_CALLBACK (e_focus_tracker_delete_selection),
+ focus_tracker);
+
+ g_object_notify (G_OBJECT (focus_tracker), "delete-selection-action");
+}
+
+GtkAction *
+e_focus_tracker_get_select_all_action (EFocusTracker *focus_tracker)
+{
+ g_return_val_if_fail (E_IS_FOCUS_TRACKER (focus_tracker), NULL);
+
+ return focus_tracker->priv->select_all;
+}
+
+void
+e_focus_tracker_set_select_all_action (EFocusTracker *focus_tracker,
+ GtkAction *select_all)
+{
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ if (select_all != NULL) {
+ g_return_if_fail (GTK_IS_ACTION (select_all));
+ g_object_ref (select_all);
+ }
+
+ if (focus_tracker->priv->select_all != NULL) {
+ g_signal_handlers_disconnect_matched (
+ focus_tracker->priv->select_all,
+ G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
+ focus_tracker);
+ g_object_unref (focus_tracker->priv->select_all);
+ }
+
+ focus_tracker->priv->select_all = select_all;
+
+ if (select_all != NULL)
+ g_signal_connect_swapped (
+ select_all, "activate",
+ G_CALLBACK (e_focus_tracker_select_all),
+ focus_tracker);
+
+ g_object_notify (G_OBJECT (focus_tracker), "select-all-action");
+}
+
+void
+e_focus_tracker_update_actions (EFocusTracker *focus_tracker)
+{
+ GtkClipboard *clipboard;
+
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ /* Request clipboard targets asynchronously. */
+
+ clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
+
+ gtk_clipboard_request_targets (
+ clipboard, (GtkClipboardTargetsReceivedFunc)
+ focus_tracker_targets_received_cb,
+ g_object_ref (focus_tracker));
+}
+
+void
+e_focus_tracker_cut_clipboard (EFocusTracker *focus_tracker)
+{
+ GtkWidget *focus;
+
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ focus = e_focus_tracker_get_focus (focus_tracker);
+
+ if (GTK_IS_EDITABLE (focus))
+ gtk_editable_cut_clipboard (GTK_EDITABLE (focus));
+
+ else if (E_IS_SELECTABLE (focus))
+ e_selectable_cut_clipboard (E_SELECTABLE (focus));
+}
+
+void
+e_focus_tracker_copy_clipboard (EFocusTracker *focus_tracker)
+{
+ GtkWidget *focus;
+
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ focus = e_focus_tracker_get_focus (focus_tracker);
+
+ if (GTK_IS_EDITABLE (focus))
+ gtk_editable_copy_clipboard (GTK_EDITABLE (focus));
+
+ else if (E_IS_SELECTABLE (focus))
+ e_selectable_copy_clipboard (E_SELECTABLE (focus));
+}
+
+void
+e_focus_tracker_paste_clipboard (EFocusTracker *focus_tracker)
+{
+ GtkWidget *focus;
+
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ focus = e_focus_tracker_get_focus (focus_tracker);
+
+ if (GTK_IS_EDITABLE (focus))
+ gtk_editable_paste_clipboard (GTK_EDITABLE (focus));
+
+ else if (E_IS_SELECTABLE (focus))
+ e_selectable_paste_clipboard (E_SELECTABLE (focus));
+}
+
+void
+e_focus_tracker_delete_selection (EFocusTracker *focus_tracker)
+{
+ GtkWidget *focus;
+
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ focus = e_focus_tracker_get_focus (focus_tracker);
+
+ if (GTK_IS_EDITABLE (focus))
+ gtk_editable_delete_selection (GTK_EDITABLE (focus));
+
+ else if (E_IS_SELECTABLE (focus))
+ e_selectable_delete_selection (E_SELECTABLE (focus));
+}
+
+void
+e_focus_tracker_select_all (EFocusTracker *focus_tracker)
+{
+ GtkWidget *focus;
+
+ g_return_if_fail (E_IS_FOCUS_TRACKER (focus_tracker));
+
+ focus = e_focus_tracker_get_focus (focus_tracker);
+
+ if (GTK_IS_EDITABLE (focus))
+ gtk_editable_select_region (GTK_EDITABLE (focus), 0, -1);
+
+ else if (E_IS_SELECTABLE (focus))
+ e_selectable_select_all (E_SELECTABLE (focus));
+}