/*
* 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)
*
*/
#include "e-focus-tracker.h"
#include <config.h>
#include <glib/gi18n-lib.h>
#include <misc/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
};
static gpointer parent_class;
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 (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);
}
static void
focus_tracker_class_init (EFocusTrackerClass *class)
{
GObjectClass *object_class;
parent_class = g_type_class_peek_parent (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
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;
}
GType
e_focus_tracker_get_type (void)
{
static GType type = 0;
if (G_UNLIKELY (type == 0)) {
static const GTypeInfo type_info = {
sizeof (EFocusTrackerClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) focus_tracker_class_init,
(GClassFinalizeFunc) NULL,
NULL, /* class_data */
sizeof (EFocusTracker),
0, /* n_preallocs */
(GInstanceInitFunc) focus_tracker_init,
NULL /* value_table */
};
type = g_type_register_static (
G_TYPE_OBJECT, "EFocusTracker", &type_info, 0);
}
return type;
}
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));
}
