diff options
Diffstat (limited to 'e-util/e-focus-tracker.c')
| -rw-r--r-- | e-util/e-focus-tracker.c | 886 |
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)); +} |