path: root/e-util/e-widget-undo.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.
 *
 * 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 General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 *
 * Authors:
 *      Milan Crha <mcrha@redhat.com>
 *
 * Copyright (C) 2014 Red Hat, Inc. (www.redhat.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gtk/gtk.h>
#include <glib/gi18n-lib.h>

#include <string.h>

#include "e-focus-tracker.h"
#include "e-widget-undo.h"

#define DEFAULT_MAX_UNDO_LEVEL 256
#define UNDO_DATA_KEY "e-undo-data-ptr"

/* calculates real index in EUndoData::undo_stack */
#define REAL_INDEX(x) ((data->undo_from + (x) + 2 * data->undo_len) % data->undo_len)

typedef enum {
    E_UNDO_INSERT,
    E_UNDO_DELETE
} EUndoType;

typedef enum {
    E_UNDO_DO_UNDO,
    E_UNDO_DO_REDO
} EUndoDoType;

typedef struct _EUndoInfo {
    EUndoType type;
    gchar *text;
    gint position_start;
    gint position_end; /* valid for delete type only */
} EUndoInfo;

typedef struct _EUndoData {
    EUndoInfo **undo_stack; /* stack for undo, with max_undo_level elements, some are NULL */
    gint undo_len; /* how many undo actions can be saved */
    gint undo_from; /* where the first undo action begins */
    gint n_undos; /* how many undo actions are saved;
        [(undo_from + n_undos) % undo_len] is the next free undo item (or the first redo) */
    gint n_redos; /* how many redo actions are saved */

    EUndoInfo *current_info; /* the top undo action */

    gulong insert_handler_id;
    gulong delete_handler_id;
} EUndoData;

static void
free_undo_info (gpointer ptr)
{
    EUndoInfo *info = ptr;

    if (info) {
        g_free (info->text);
        g_free (info);
    }
}

static void
free_undo_data (gpointer ptr)
{
    EUndoData *data = ptr;

    if (data) {
        gint ii;

        for (ii = 0; ii < data->undo_len; ii++) {
            free_undo_info (data->undo_stack[ii]);
        }
        g_free (data);
    }
}

static void
reset_redos (EUndoData *data)
{
    gint ii, index;

    for (ii = 0; ii < data->n_redos; ii++) {
        index = REAL_INDEX (data->n_undos + ii);

        free_undo_info (data->undo_stack[index]);
        data->undo_stack[index] = NULL;
    }

    data->n_redos = 0;
}

static void
push_undo (EUndoData *data,
           EUndoInfo *info)
{
    gint index;

    reset_redos (data);

    if (data->n_undos == data->undo_len) {
        data->undo_from = (data->undo_from + 1) % data->undo_len;
    } else {
        data->n_undos++;
    }

    index = REAL_INDEX (data->n_undos - 1);
    free_undo_info (data->undo_stack[index]);
    data->undo_stack[index] = info;
}

static gboolean
can_merge_insert_undos (EUndoInfo *current_info,
                        const gchar *text,
                        gint text_len,
                        gint position)
{
    gint len;

    /* allow only one letter merge */
    if (!current_info || current_info->type != E_UNDO_INSERT ||
        !text || text_len <= 0 || text_len > 1)
        return FALSE;

    if (text[0] == '\r' || text[0] == '\n')
        return FALSE;

    len = strlen (current_info->text);
    if (position != current_info->position_start + len)
        return FALSE;

    if (g_ascii_isspace (text[0])) {
        if (len <= 0 || !g_ascii_isspace (current_info->text[len - 1]))
            return FALSE;
    }

    return TRUE;
}

static void
push_insert_undo (GObject *object,
                  const gchar *text,
                  gint text_len,
                  gint position)
{
    EUndoData *data;
    EUndoInfo *info;

    data = g_object_get_data (object, UNDO_DATA_KEY);
    if (!data) {
        g_warn_if_reached ();
        return;
    }

    /* one letter long text, divide undos on spaces */
    if (data->current_info &&
        can_merge_insert_undos (data->current_info, text, text_len, position)) {
        gchar *new_text;

        new_text = g_strdup_printf ("%s%*s", data->current_info->text, text_len, text);
        g_free (data->current_info->text);
        data->current_info->text = new_text;

        return;
    }

    info = g_new0 (EUndoInfo, 1);
    info->type = E_UNDO_INSERT;
    info->text = g_strndup (text, text_len);
    info->position_start = position;

    push_undo (data, info);

    data->current_info = info;
}

static void
push_delete_undo (GObject *object,
                  gchar *text, /* takes ownership of the 'text' */
                  gint position_start,
                  gint position_end)
{
    EUndoData *data;
    EUndoInfo *info;

    data = g_object_get_data (object, UNDO_DATA_KEY);
    if (!data) {
        g_warn_if_reached ();
        return;
    }

    if (data->current_info && data->current_info->type == E_UNDO_DELETE &&
        position_end - position_start == 1 && !g_ascii_isspace (*text)) {
        info = data->current_info;

        if (info->position_start == position_start) {
            gchar *new_text;

            new_text = g_strconcat (info->text, text, NULL);
            g_free (info->text);
            info->text = new_text;
            g_free (text);

            info->position_end++;

            return;
        } else if (data->current_info->position_start == position_end) {
            gchar *new_text;

            new_text = g_strconcat (text, info->text, NULL);
            g_free (info->text);
            info->text = new_text;
            g_free (text);

            info->position_start = position_start;

            return;
        }
    }

    info = g_new0 (EUndoInfo, 1);
    info->type = E_UNDO_DELETE;
    info->text = text;
    info->position_start = position_start;
    info->position_end = position_end;

    push_undo (data, info);

    data->current_info = info;
}

static void
editable_undo_insert_text_cb (GtkEditable *editable,
                              gchar *text,
                              gint text_length,
                              gint *position,
                              gpointer user_data)
{
    push_insert_undo (G_OBJECT (editable), text, text_length, *position);
}

static void
editable_undo_delete_text_cb (GtkEditable *editable,
                              gint start_pos,
                              gint end_pos,
                              gpointer user_data)
{
    push_delete_undo (G_OBJECT (editable), gtk_editable_get_chars (editable, start_pos, end_pos), start_pos, end_pos);
}

static void
editable_undo_insert_text (GObject *object,
                           const gchar *text,
                           gint position)
{
    g_return_if_fail (GTK_IS_EDITABLE (object));

    gtk_editable_insert_text (GTK_EDITABLE (object), text, -1, &position);
}

static void
editable_undo_delete_text (GObject *object,
                           gint position_start,
                           gint position_end)
{
    g_return_if_fail (GTK_IS_EDITABLE (object));

    gtk_editable_delete_text (GTK_EDITABLE (object), position_start, position_end);
}

static void
text_buffer_undo_insert_text_cb (GtkTextBuffer *text_buffer,
                                 GtkTextIter *location,
                                 gchar *text,
                                 gint text_length,
                                 gpointer user_data)
{
    push_insert_undo (G_OBJECT (text_buffer), text, text_length, gtk_text_iter_get_offset (location));
}

static void
text_buffer_undo_delete_range_cb (GtkTextBuffer *text_buffer,
                                  GtkTextIter *start,
                                  GtkTextIter *end,
                                  gpointer user_data)
{
    push_delete_undo (
        G_OBJECT (text_buffer),
        gtk_text_iter_get_text (start, end),
        gtk_text_iter_get_offset (start),
        gtk_text_iter_get_offset (end));
}

static void
text_buffer_undo_insert_text (GObject *object,
                              const gchar *text,
                              gint position)
{
    GtkTextBuffer *text_buffer;
    GtkTextIter iter;

    g_return_if_fail (GTK_IS_TEXT_BUFFER (object));

    text_buffer = GTK_TEXT_BUFFER (object);

    gtk_text_buffer_get_iter_at_offset (text_buffer, &iter, position);
    gtk_text_buffer_insert (text_buffer, &iter, text, -1);
}

static void
text_buffer_undo_delete_text (GObject *object,
                              gint position_start,
                              gint position_end)
{
    GtkTextBuffer *text_buffer;
    GtkTextIter start_iter, end_iter;

    g_return_if_fail (GTK_IS_TEXT_BUFFER (object));

    text_buffer = GTK_TEXT_BUFFER (object);

    gtk_text_buffer_get_iter_at_offset (text_buffer, &start_iter, position_start);
    gtk_text_buffer_get_iter_at_offset (text_buffer, &end_iter, position_end);
    gtk_text_buffer_delete (text_buffer, &start_iter, &end_iter);
}

static void
widget_undo_place_cursor_at (GObject *object,
                             gint char_pos)
{
    if (GTK_IS_EDITABLE (object))
        gtk_editable_set_position (GTK_EDITABLE (object), char_pos);
    else if (GTK_IS_TEXT_BUFFER (object)) {
        GtkTextBuffer *buffer;
        GtkTextIter pos;

        buffer = GTK_TEXT_BUFFER (object);

        gtk_text_buffer_get_iter_at_offset (buffer, &pos, char_pos);
        gtk_text_buffer_place_cursor (buffer, &pos);
    }
}

static void
undo_do_something (GObject *object,
                   EUndoDoType todo,
                   void (* insert_func) (GObject *object,
                   const gchar *text,
                   gint position),
                   void (* delete_func) (GObject *object,
                   gint position_start,
                   gint position_end))
{
    EUndoData *data;
    EUndoInfo *info = NULL;

    data = g_object_get_data (object, UNDO_DATA_KEY);
    if (!data)
        return;

    if (todo == E_UNDO_DO_UNDO && data->n_undos > 0) {
        info = data->undo_stack[REAL_INDEX (data->n_undos - 1)];
        data->n_undos--;
        data->n_redos++;
    } else if (todo == E_UNDO_DO_REDO && data->n_redos > 0) {
        info = data->undo_stack[REAL_INDEX (data->n_undos)];
        data->n_undos++;
        data->n_redos--;
    }

    if (!info)
        return;

    g_signal_handler_block (object, data->insert_handler_id);
    g_signal_handler_block (object, data->delete_handler_id);

    if (info->type == E_UNDO_INSERT) {
        if (todo == E_UNDO_DO_UNDO) {
            delete_func (object, info->position_start, info->position_start + g_utf8_strlen (info->text, -1));
            widget_undo_place_cursor_at (object, info->position_start);
        } else {
            insert_func (object, info->text, info->position_start);
            widget_undo_place_cursor_at (object, info->position_start + g_utf8_strlen (info->text, -1));
        }
    } else if (info->type == E_UNDO_DELETE) {
        if (todo == E_UNDO_DO_UNDO) {
            insert_func (object, info->text, info->position_start);
            widget_undo_place_cursor_at (object, info->position_start + g_utf8_strlen (info->text, -1));
        } else {
            delete_func (object, info->position_start, info->position_end);
            widget_undo_place_cursor_at (object, info->position_start);
        }
    }

    data->current_info = NULL;

    g_signal_handler_unblock (object, data->delete_handler_id);
    g_signal_handler_unblock (object, data->insert_handler_id);
}

static gchar *
undo_describe_info (EUndoInfo *info,
                    EUndoDoType undo_type)
{
    if (!info)
        return NULL;

    if (info->type == E_UNDO_INSERT) {
        if (undo_type == E_UNDO_DO_UNDO)
            return g_strdup (_("Undo 'Insert text'"));
        else
            return g_strdup (_("Redo 'Insert text'"));
        /* if (strlen (info->text) > 15) {
            if (undo_type == E_UNDO_DO_UNDO)
                return g_strdup_printf (_("Undo 'Insert '%.12s...''"), info->text);
            else
                return g_strdup_printf (_("Redo 'Insert '%.12s...''"), info->text);
        }
 *
        if (undo_type == E_UNDO_DO_UNDO)
            return g_strdup_printf (_("Undo 'Insert '%s''"), info->text);
        else
            return g_strdup_printf (_("Redo 'Insert '%s''"), info->text); */
    } else if (info->type == E_UNDO_DELETE) {
        if (undo_type == E_UNDO_DO_UNDO)
            return g_strdup (_("Undo 'Delete text'"));
        else
            return g_strdup (_("Redo 'Delete text'"));
        /* if (strlen (info->text) > 15) {
            if (undo_type == E_UNDO_DO_UNDO)
                return g_strdup_printf (_("Undo 'Delete '%.12s...''"), info->text);
            else
                return g_strdup_printf (_("Redo 'Delete '%.12s...''"), info->text);
        }
 *
        if (undo_type == E_UNDO_DO_UNDO)
            return g_strdup_printf (_("Undo 'Delete '%s''"), info->text);
        else
            return g_strdup_printf (_("Redo 'Delete '%s''"), info->text); */
    }

    return NULL;
}

static gboolean
undo_check_undo (GObject *object,
                 gchar **description)
{
    EUndoData *data;

    data = g_object_get_data (object, UNDO_DATA_KEY);
    if (!data)
        return FALSE;

    if (data->n_undos <= 0)
        return FALSE;

    if (description)
        *description = undo_describe_info (data->undo_stack[REAL_INDEX (data->n_undos - 1)], E_UNDO_DO_UNDO);

    return TRUE;
}

static gboolean
undo_check_redo (GObject *object,
                 gchar **description)
{
    EUndoData *data;

    data = g_object_get_data (object, UNDO_DATA_KEY);
    if (!data)
        return FALSE;

    if (data->n_redos <= 0)
        return FALSE;

    if (description)
        *description = undo_describe_info (data->undo_stack[REAL_INDEX (data->n_undos)], E_UNDO_DO_REDO);

    return TRUE;
}

static void
undo_reset (GObject *object)
{
    EUndoData *data;

    data = g_object_get_data (object, UNDO_DATA_KEY);
    if (!data)
        return;

    data->n_undos = 0;
    data->n_redos = 0;
}

static void
widget_undo_popup_activate_cb (GObject *menu_item,
                               GtkWidget *widget)
{
    EUndoDoType undo_type = GPOINTER_TO_INT (g_object_get_data (menu_item, UNDO_DATA_KEY));

    if (undo_type == E_UNDO_DO_UNDO)
        e_widget_undo_do_undo (widget);
    else
        e_widget_undo_do_redo (widget);
}

static gboolean
widget_undo_prepend_popup (GtkWidget *widget,
                           GtkMenuShell *menu,
                           EUndoDoType undo_type,
                           gboolean already_added)
{
    gchar *description = NULL;
    const gchar *icon_name = NULL;

    if (undo_type == E_UNDO_DO_UNDO && e_widget_undo_has_undo (widget)) {
        description = e_widget_undo_describe_undo (widget);
        icon_name = "edit-undo";
    } else if (undo_type == E_UNDO_DO_REDO && e_widget_undo_has_redo (widget)) {
        description = e_widget_undo_describe_redo (widget);
        icon_name = "edit-redo";
    }

    if (description) {
        GtkWidget *item, *image;

        if (!already_added) {
            item = gtk_separator_menu_item_new ();
            gtk_widget_show (item);
            gtk_menu_shell_prepend (menu, item);

            already_added = TRUE;
        }

        image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
        item = gtk_image_menu_item_new_with_label (description);
        gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
        gtk_widget_show (item);

        g_object_set_data (G_OBJECT (item), UNDO_DATA_KEY, GINT_TO_POINTER (undo_type));
        g_signal_connect (item, "activate", G_CALLBACK (widget_undo_popup_activate_cb), widget);

        gtk_menu_shell_prepend (menu, item);

        g_free (description);
    }

    return already_added;
}

static void
widget_undo_populate_popup_cb (GtkWidget *widget,
                               GtkWidget *popup,
                               gpointer user_data)
{
    GtkMenuShell *menu;
    gboolean added = FALSE;

    if (!GTK_IS_MENU (popup))
        return;

    menu = GTK_MENU_SHELL (popup);

    /* first redo, because prependend, thus undo gets before it */
    if (e_widget_undo_has_redo (widget))
        added = widget_undo_prepend_popup (widget, menu, E_UNDO_DO_REDO, added);

    if (e_widget_undo_has_undo (widget))
        widget_undo_prepend_popup (widget, menu, E_UNDO_DO_UNDO, added);
}

/**
 * e_widget_undo_attach:
 * @widget: a #GtkWidget, where to attach undo functionality
 * @focus_tracker: an #EFocusTracker, can be %NULL
 *
 * The function does nothing, if the widget is not of a supported type
 * for undo functionality, same as when the undo is already attached.
 * It is ensured that the actions of the provided @focus_tracker are
 * updated on change of the @widget.
 *
 * See @e_widget_undo_is_attached().
 *
 * Since: 3.12
 **/
void
e_widget_undo_attach (GtkWidget *widget,
                      EFocusTracker *focus_tracker)
{
    EUndoData *data;

    if (e_widget_undo_is_attached (widget))
        return;

    if (GTK_IS_EDITABLE (widget)) {
        data = g_new0 (EUndoData, 1);
        data->undo_len = DEFAULT_MAX_UNDO_LEVEL;
        data->undo_stack = g_new0 (EUndoInfo *, data->undo_len);

        g_object_set_data_full (G_OBJECT (widget), UNDO_DATA_KEY, data, free_undo_data);

        data->insert_handler_id = g_signal_connect (
            widget, "insert-text",
            G_CALLBACK (editable_undo_insert_text_cb), NULL);
        data->delete_handler_id = g_signal_connect (
            widget, "delete-text",
            G_CALLBACK (editable_undo_delete_text_cb), NULL);

        if (focus_tracker)
            g_signal_connect_swapped (
                widget, "changed",
                G_CALLBACK (e_focus_tracker_update_actions), focus_tracker);

        if (GTK_IS_ENTRY (widget))
            g_signal_connect (
                widget, "populate-popup",
                G_CALLBACK (widget_undo_populate_popup_cb), NULL);
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        data = g_new0 (EUndoData, 1);
        data->undo_len = DEFAULT_MAX_UNDO_LEVEL;
        data->undo_stack = g_new0 (EUndoInfo *, data->undo_len);

        g_object_set_data_full (G_OBJECT (text_buffer), UNDO_DATA_KEY, data, free_undo_data);

        data->insert_handler_id = g_signal_connect (
            text_buffer, "insert-text",
            G_CALLBACK (text_buffer_undo_insert_text_cb), NULL);
        data->delete_handler_id = g_signal_connect (
            text_buffer, "delete-range",
            G_CALLBACK (text_buffer_undo_delete_range_cb), NULL);

        if (focus_tracker)
            g_signal_connect_swapped (
                text_buffer, "changed",
                G_CALLBACK (e_focus_tracker_update_actions), focus_tracker);

        g_signal_connect (
            widget, "populate-popup",
            G_CALLBACK (widget_undo_populate_popup_cb), NULL);
    }
}

/**
 * e_widget_undo_is_attached:
 * @widget: a #GtkWidget, where to test whether undo functionality is attached.
 *
 * Checks whether the given widget has already attached an undo
 * functionality - it is done with @e_widget_undo_attach().
 *
 * Returns: Whether the given @widget has already attached undo functionality.
 *
 * Since: 3.12
 **/
gboolean
e_widget_undo_is_attached (GtkWidget *widget)
{
    gboolean res = FALSE;

    if (GTK_IS_EDITABLE (widget)) {
        res = g_object_get_data (G_OBJECT (widget), UNDO_DATA_KEY) != NULL;
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        res = g_object_get_data (G_OBJECT (text_buffer), UNDO_DATA_KEY) != NULL;
    }

    return res;
}

/**
 * e_widget_undo_has_undo:
 * @widget: a #GtkWidget
 *
 * Returns: Whether the given @widget has any undo available.
 *
 * See: @e_widget_undo_describe_undo, @e_widget_undo_do_undo
 *
 * Since: 3.12
 **/
gboolean
e_widget_undo_has_undo (GtkWidget *widget)
{
    if (GTK_IS_EDITABLE (widget)) {
        return undo_check_undo (G_OBJECT (widget), NULL);
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        return undo_check_undo (G_OBJECT (text_buffer), NULL);
    }

    return FALSE;
}

/**
 * e_widget_undo_has_redo:
 * @widget: a #GtkWidget
 *
 * Returns: Whether the given @widget has any redo available.
 *
 * See: @e_widget_undo_describe_redo, @e_widget_undo_do_redo
 *
 * Since: 3.12
 **/
gboolean
e_widget_undo_has_redo (GtkWidget *widget)
{
    if (GTK_IS_EDITABLE (widget)) {
        return undo_check_redo (G_OBJECT (widget), NULL);
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        return undo_check_redo (G_OBJECT (text_buffer), NULL);
    }

    return FALSE;
}

/**
 * e_widget_undo_describe_undo:
 * @widget: a #GtkWidget
 *
 * Returns: (transfer full): Description of a top undo action available
 *    for the @widget, %NULL when there is no undo action. Returned pointer,
 *    if not %NULL, should be freed with g_free().
 *
 * See: @e_widget_undo_has_undo, @e_widget_undo_do_undo
 *
 * Since: 3.12
 **/
gchar *
e_widget_undo_describe_undo (GtkWidget *widget)
{
    gchar *res = NULL;

    if (GTK_IS_EDITABLE (widget)) {
        if (!undo_check_undo (G_OBJECT (widget), &res)) {
            g_warn_if_fail (res == NULL);
        }
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        if (!undo_check_undo (G_OBJECT (text_buffer), &res)) {
            g_warn_if_fail (res == NULL);
        }
    }

    return res;
}

/**
 * e_widget_undo_describe_redo:
 * @widget: a #GtkWidget
 *
 * Returns: (transfer full): Description of a top redo action available
 *    for the @widget, %NULL when there is no redo action. Returned pointer,
 *    if not %NULL, should be freed with g_free().
 *
 * See: @e_widget_undo_has_redo, @e_widget_undo_do_redo
 *
 * Since: 3.12
 **/
gchar *
e_widget_undo_describe_redo (GtkWidget *widget)
{
    gchar *res = NULL;

    if (GTK_IS_EDITABLE (widget)) {
        if (!undo_check_redo (G_OBJECT (widget), &res)) {
            g_warn_if_fail (res == NULL);
        }
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        if (!undo_check_redo (G_OBJECT (text_buffer), &res)) {
            g_warn_if_fail (res == NULL);
        }
    }

    return res;
}

/**
 * e_widget_undo_do_undo:
 * @widget: a #GtkWidget
 *
 * Applies the top undo action on the @widget, which also remembers
 * a redo action. It does nothing if the widget doesn't have
 * attached undo functionality (@e_widget_undo_attach()), neither
 * when there is no undo action available.
 *
 * See: @e_widget_undo_attach, @e_widget_undo_has_undo, @e_widget_undo_describe_undo
 *
 * Since: 3.12
 **/
void
e_widget_undo_do_undo (GtkWidget *widget)
{
    if (GTK_IS_EDITABLE (widget)) {
        undo_do_something (
            G_OBJECT (widget),
            E_UNDO_DO_UNDO,
            editable_undo_insert_text,
            editable_undo_delete_text);
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        undo_do_something (
            G_OBJECT (text_buffer),
            E_UNDO_DO_UNDO,
            text_buffer_undo_insert_text,
            text_buffer_undo_delete_text);
    }
}

/**
 * e_widget_undo_do_redo:
 * @widget: a #GtkWidget
 *
 * Applies the top redo action on the @widget, which also remembers
 * an undo action. It does nothing if the widget doesn't have
 * attached undo functionality (@e_widget_undo_attach()), neither
 * when there is no redo action available.
 *
 * See: @e_widget_undo_attach, @e_widget_undo_has_redo, @e_widget_undo_describe_redo
 *
 * Since: 3.12
 **/
void
e_widget_undo_do_redo (GtkWidget *widget)
{
    if (GTK_IS_EDITABLE (widget)) {
        undo_do_something (
            G_OBJECT (widget),
            E_UNDO_DO_REDO,
            editable_undo_insert_text,
            editable_undo_delete_text);
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        undo_do_something (
            G_OBJECT (text_buffer),
            E_UNDO_DO_REDO,
            text_buffer_undo_insert_text,
            text_buffer_undo_delete_text);
    }
}

/**
 * e_widget_undo_reset:
 * @widget: a #GtkWidget, on which might be attached undo functionality
 *
 * Resets undo and redo stack to empty on a widget with attached
 * undo functionality. It does nothing, if the widget does not have
 * the undo functionality attached (see @e_widget_undo_attach()).
 *
 * Since: 3.12
 **/
void
e_widget_undo_reset (GtkWidget *widget)
{
    if (GTK_IS_EDITABLE (widget)) {
        undo_reset (G_OBJECT (widget));
    } else if (GTK_IS_TEXT_VIEW (widget)) {
        GtkTextBuffer *text_buffer;

        text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget));

        undo_reset (G_OBJECT (text_buffer));
    }
}