[gtk/wip/chergert/textundo: 3/12] texthistory: add GtkTextHistory helper



commit 5e341210a1cfa08a34cb257039416a97a0ab4929
Author: Christian Hergert <chergert redhat com>
Date:   Wed Oct 23 19:13:11 2019 -0700

    texthistory: add GtkTextHistory helper
    
    The GtkTextHistory helper provides the fundamental undo/redo stack that
    can be integrated with other text widgets. It allows coalescing related
    actions to reduce both the number of undo actions to the user as well as
    the memory overhead.
    
    A new istring helper is used by GtkTextHistory to allow for "inline
    strings" that gracefully grow to using allocations with g_realloc(). This
    ensure that most undo operations require no additional allocations other
    than the struct for the action itself.
    
    A queue of undoable and redoable actions are maintained and the link for
    the queue is embedded in the undo action union. This allows again, for
    reducing the number of allocations involved for undo operations.

 gtk/gtkistringprivate.h     |  171 +++++++
 gtk/gtktexthistory.c        | 1062 +++++++++++++++++++++++++++++++++++++++++++
 gtk/gtktexthistoryprivate.h |   84 ++++
 gtk/meson.build             |    1 +
 tests/meson.build           |    1 +
 tests/testtexthistory.c     |  600 ++++++++++++++++++++++++
 6 files changed, 1919 insertions(+)
---
diff --git a/gtk/gtkistringprivate.h b/gtk/gtkistringprivate.h
new file mode 100644
index 0000000000..0af8cb1593
--- /dev/null
+++ b/gtk/gtkistringprivate.h
@@ -0,0 +1,171 @@
+#ifndef __GTK_ISTRING_PRIVATE_H__
+#define __GTK_ISTRING_PRIVATE_H__
+
+#include <glib.h>
+#include <string.h>
+
+typedef struct
+{
+  guint n_bytes;
+  guint n_chars;
+  union {
+    char  buf[24];
+    char *str;
+  } u;
+} IString;
+
+static inline gboolean
+istring_is_inline (const IString *str)
+{
+  return str->n_bytes <= (sizeof str->u.buf - 1);
+}
+
+static inline char *
+istring_str (IString *str)
+{
+  if (istring_is_inline (str))
+    return str->u.buf;
+  else
+    return str->u.str;
+}
+
+static inline void
+istring_clear (IString *str)
+{
+  if (istring_is_inline (str))
+    str->u.buf[0] = 0;
+  else
+    g_clear_pointer (&str->u.str, g_free);
+
+  str->n_bytes = 0;
+  str->n_chars = 0;
+}
+
+static inline void
+istring_set (IString    *str,
+             const char *text,
+             guint       n_bytes,
+             guint       n_chars)
+{
+  if G_LIKELY (n_bytes <= (sizeof str->u.buf - 1))
+    {
+      memcpy (str->u.buf, text, n_bytes);
+      str->u.buf[n_bytes] = 0;
+    }
+  else
+    {
+      str->u.str = g_strndup (text, n_bytes);
+    }
+
+  str->n_bytes = n_bytes;
+  str->n_chars = n_chars;
+}
+
+static inline gboolean
+istring_empty (IString *str)
+{
+  return str->n_bytes == 0;
+}
+
+static inline gboolean
+istring_ends_with_space (IString *str)
+{
+  return g_ascii_isspace (istring_str (str)[str->n_bytes - 1]);
+}
+
+static inline gboolean
+istring_starts_with_space (IString *str)
+{
+  return g_unichar_isspace (g_utf8_get_char (istring_str (str)));
+}
+
+static inline gboolean
+istring_contains_unichar (IString  *str,
+                          gunichar  ch)
+{
+  return g_utf8_strchr (istring_str (str), str->n_bytes, ch) != NULL;
+}
+
+static inline gboolean
+istring_only_contains_space (IString *str)
+{
+  const char *iter;
+
+  for (iter = istring_str (str); *iter; iter = g_utf8_next_char (iter))
+    {
+      if (!g_unichar_isspace (g_utf8_get_char (iter)))
+        return FALSE;
+    }
+
+  return TRUE;
+}
+
+static inline gboolean
+istring_contains_space (IString *str)
+{
+  const char *iter;
+
+  for (iter = istring_str (str); *iter; iter = g_utf8_next_char (iter))
+    {
+      if (g_unichar_isspace (g_utf8_get_char (iter)))
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+static inline void
+istring_prepend (IString *str,
+                 IString *other)
+{
+  if G_LIKELY (str->n_bytes + other->n_bytes < sizeof str->u.buf - 1)
+    {
+      memmove (str->u.buf + other->n_bytes, str->u.buf, str->n_bytes);
+      memcpy (str->u.buf, other->u.buf, other->n_bytes);
+      str->n_bytes += other->n_bytes;
+      str->n_chars += other->n_chars;
+      str->u.buf[str->n_bytes] = 0;
+    }
+  else
+    {
+      gchar *old = NULL;
+
+      if (!istring_is_inline (str))
+        old = str->u.str;
+
+      str->u.str = g_strconcat (istring_str (str), istring_str (other), NULL);
+      str->n_bytes += other->n_bytes;
+      str->n_chars += other->n_chars;
+
+      g_free (old);
+    }
+}
+
+static inline void
+istring_append (IString *str,
+                IString *other)
+{
+  const gchar *text = istring_str (other);
+  guint n_bytes = other->n_bytes;
+  guint n_chars = other->n_chars;
+
+  if G_LIKELY (istring_is_inline (str))
+    {
+      if G_LIKELY (str->n_bytes + n_bytes <= (sizeof str->u.buf - 1))
+        memcpy (str->u.buf + str->n_bytes, text, n_bytes);
+      else
+        str->u.str = g_strconcat (str->u.buf, text, NULL);
+    }
+  else
+    {
+      str->u.str = g_realloc (str->u.str, str->n_bytes + n_bytes + 1);
+      memcpy (str->u.str + str->n_bytes, text, n_bytes);
+    }
+
+  str->n_bytes += n_bytes;
+  str->n_chars += n_chars;
+
+  istring_str (str)[str->n_bytes] = 0;
+}
+
+#endif /* __GTK_ISTRING_PRIVATE_H__ */
diff --git a/gtk/gtktexthistory.c b/gtk/gtktexthistory.c
new file mode 100644
index 0000000000..c6a787654b
--- /dev/null
+++ b/gtk/gtktexthistory.c
@@ -0,0 +1,1062 @@
+/* Copyright (C) 2019 Red Hat, Inc.
+ *
+ * This library 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) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gtkistringprivate.h"
+#include "gtktexthistoryprivate.h"
+
+/*
+ * The GtkTextHistory works in a way that allows text widgets to deliver
+ * information about changes to the underlying text at given offsets within
+ * their text. The GtkTextHistory object uses a series of callback functions
+ * (see GtkTextHistoryFuncs) to apply changes as undo/redo is performed.
+ *
+ * The GtkTextHistory object is careful to avoid tracking changes while
+ * applying specific undo/redo actions.
+ *
+ * Changes are tracked within a series of actions, contained in groups.  The
+ * group may be coalesced when gtk_text_history_end_user_action() is
+ * called.
+ *
+ * Calling gtk_text_history_begin_irreversible_action() and
+ * gtk_text_history_end_irreversible_action() can be used to denote a
+ * section of operations that cannot be undone. This will cause all previous
+ * changes tracked by the GtkTextHistory to be discared.
+ */
+
+typedef struct _Action     Action;
+typedef enum   _ActionKind ActionKind;
+
+enum _ActionKind
+{
+  ACTION_KIND_BARRIER             = 1,
+  ACTION_KIND_DELETE_BACKSPACE    = 2,
+  ACTION_KIND_DELETE_KEY          = 3,
+  ACTION_KIND_DELETE_PROGRAMMATIC = 4,
+  ACTION_KIND_DELETE_SELECTION    = 5,
+  ACTION_KIND_GROUP               = 6,
+  ACTION_KIND_INSERT              = 7,
+};
+
+struct _Action
+{
+  ActionKind kind;
+  GList link;
+  guint is_modified : 1;
+  guint is_modified_set : 1;
+  union {
+    struct {
+      IString istr;
+      guint begin;
+      guint end;
+    } insert;
+    struct {
+      IString istr;
+      guint begin;
+      guint end;
+      struct {
+        int insert;
+        int bound;
+      } selection;
+    } delete;
+    struct {
+      GQueue actions;
+      guint  depth;
+    } group;
+  } u;
+};
+
+struct _GtkTextHistory
+{
+  GObject             parent_instance;
+
+  GtkTextHistoryFuncs funcs;
+  gpointer            funcs_data;
+
+  GQueue              undo_queue;
+  GQueue              redo_queue;
+
+  struct {
+    int insert;
+    int bound;
+  } selection;
+
+  guint               irreversible;
+  guint               in_user;
+  guint               max_undo_levels;
+
+  guint               can_undo : 1;
+  guint               can_redo : 1;
+  guint               is_modified : 1;
+  guint               is_modified_set : 1;
+  guint               applying : 1;
+  guint               enabled : 1;
+};
+
+static void action_free (Action *action);
+
+G_DEFINE_TYPE (GtkTextHistory, gtk_text_history, G_TYPE_OBJECT)
+
+#define return_if_applying(instance)     \
+  G_STMT_START {                         \
+    if ((instance)->applying)            \
+      return;                            \
+  } G_STMT_END
+#define return_if_irreversible(instance) \
+  G_STMT_START {                         \
+    if ((instance)->irreversible)        \
+      return;                            \
+  } G_STMT_END
+#define return_if_not_enabled(instance)  \
+  G_STMT_START {                         \
+    if (!(instance)->enabled)            \
+      return;                            \
+  } G_STMT_END
+
+static inline void
+uint_order (guint *a,
+            guint *b)
+{
+  if (*a > *b)
+    {
+      guint tmp = *a;
+      *a = *b;
+      *b = tmp;
+    }
+}
+
+static void
+clear_action_queue (GQueue *queue)
+{
+  g_assert (queue != NULL);
+
+  while (queue->length > 0)
+    {
+      Action *action = g_queue_peek_head (queue);
+      g_queue_unlink (queue, &action->link);
+      action_free (action);
+    }
+}
+
+static Action *
+action_new (ActionKind kind)
+{
+  Action *action;
+
+  action = g_slice_new0 (Action);
+  action->kind = kind;
+  action->link.data = action;
+
+  return action;
+}
+
+static void
+action_free (Action *action)
+{
+  if (action->kind == ACTION_KIND_INSERT)
+    istring_clear (&action->u.insert.istr);
+  else if (action->kind == ACTION_KIND_DELETE_BACKSPACE ||
+           action->kind == ACTION_KIND_DELETE_KEY ||
+           action->kind == ACTION_KIND_DELETE_PROGRAMMATIC ||
+           action->kind == ACTION_KIND_DELETE_SELECTION)
+    istring_clear (&action->u.delete.istr);
+  else if (action->kind == ACTION_KIND_GROUP)
+    clear_action_queue (&action->u.group.actions);
+
+  g_slice_free (Action, action);
+}
+
+static gboolean
+action_group_is_empty (const Action *action)
+{
+  const GList *iter;
+
+  g_assert (action->kind == ACTION_KIND_GROUP);
+
+  for (iter = action->u.group.actions.head; iter; iter = iter->next)
+    {
+      const Action *child = iter->data;
+
+      if (child->kind == ACTION_KIND_BARRIER)
+        continue;
+
+      if (child->kind == ACTION_KIND_GROUP && action_group_is_empty (child))
+        continue;
+
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static gboolean
+action_chain (Action   *action,
+              Action   *other,
+              gboolean  in_user_action)
+{
+  g_assert (action != NULL);
+  g_assert (other != NULL);
+
+  if (action->kind == ACTION_KIND_GROUP)
+    {
+      /* Always push new items onto a group, so that we can coalesce
+       * items when gtk_text_history_end_user_action() is called.
+       *
+       * But we don't care if this is a barrier since we will always
+       * apply things as a group anyway.
+       */
+
+      if (other->kind == ACTION_KIND_BARRIER)
+        action_free (other);
+      else
+        g_queue_push_tail_link (&action->u.group.actions, &other->link);
+
+      return TRUE;
+    }
+
+  /* The rest can only be merged to themselves */
+  if (action->kind != other->kind)
+    return FALSE;
+
+  switch (action->kind)
+    {
+    case ACTION_KIND_INSERT: {
+
+      /* Make sure the new insert is at the end of the previous */
+      if (action->u.insert.end != other->u.insert.begin)
+        return FALSE;
+
+      /* If we are not within a user action, be more selective */
+      if (!in_user_action)
+        {
+          /* Avoid pathological cases */
+          if (other->u.insert.istr.n_chars > 1000)
+            return FALSE;
+
+          /* We will coalesce space, but not new lines. */
+          if (istring_contains_unichar (&action->u.insert.istr, '\n') ||
+              istring_contains_unichar (&other->u.insert.istr, '\n'))
+            return FALSE;
+
+          /* Chain space to items that ended in space. This is generally
+           * just at the start of a line where we could have indentation
+           * space.
+           */
+          if ((istring_empty (&action->u.insert.istr) ||
+               istring_ends_with_space (&action->u.insert.istr)) &&
+              istring_only_contains_space (&other->u.insert.istr))
+            goto do_chain;
+
+          /* Starting a new word, don't chain this */
+          if (istring_starts_with_space (&other->u.insert.istr))
+            return FALSE;
+
+          /* Check for possible paste (multi-character input) or word input that
+           * has spaces in it (and should treat as one operation).
+           */
+          if (other->u.insert.istr.n_chars > 1 &&
+              istring_contains_space (&other->u.insert.istr))
+            return FALSE;
+        }
+
+    do_chain:
+
+      istring_append (&action->u.insert.istr, &other->u.insert.istr);
+      action->u.insert.end += other->u.insert.end - other->u.insert.begin;
+      action_free (other);
+
+      return TRUE;
+    }
+
+    case ACTION_KIND_DELETE_PROGRAMMATIC:
+      /* We can't tell if this should be chained because we don't
+       * have a group to coalesce. But unless each action deletes
+       * a single character, the overhead isn't too bad as we embed
+       * the strings in the action.
+       */
+      return FALSE;
+
+    case ACTION_KIND_DELETE_SELECTION:
+      /* Don't join selection deletes as they should appear as a single
+       * operation and have selection reinstanted when performing undo.
+       */
+      return FALSE;
+
+    case ACTION_KIND_DELETE_BACKSPACE:
+      if (other->u.delete.end == action->u.delete.begin)
+        {
+          istring_prepend (&action->u.delete.istr,
+                           &other->u.delete.istr);
+          action->u.delete.begin = other->u.delete.begin;
+          action_free (other);
+          return TRUE;
+        }
+
+      return FALSE;
+
+    case ACTION_KIND_DELETE_KEY:
+      if (action->u.delete.begin == other->u.delete.begin)
+        {
+          if (!istring_contains_space (&other->u.delete.istr) ||
+              istring_only_contains_space (&action->u.delete.istr))
+            {
+              istring_append (&action->u.delete.istr, &other->u.delete.istr);
+              action->u.delete.end += other->u.delete.istr.n_chars;
+              action_free (other);
+              return TRUE;
+            }
+        }
+
+      return FALSE;
+
+    case ACTION_KIND_BARRIER:
+      /* Only allow a single barrier to be added. */
+      action_free (other);
+      return TRUE;
+
+    case ACTION_KIND_GROUP:
+    default:
+      g_return_val_if_reached (FALSE);
+    }
+}
+
+static void
+gtk_text_history_do_change_state (GtkTextHistory *self,
+                                  gboolean        is_modified,
+                                  gboolean        can_undo,
+                                  gboolean        can_redo)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+
+  self->funcs.change_state (self->funcs_data, is_modified, can_undo, can_redo);
+}
+
+static void
+gtk_text_history_do_insert (GtkTextHistory *self,
+                            guint           begin,
+                            guint           end,
+                            const char     *text,
+                            guint           len)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+  g_assert (text != NULL);
+
+  uint_order (&begin, &end);
+
+  self->funcs.insert (self->funcs_data, begin, end, text, len);
+}
+
+static void
+gtk_text_history_do_delete (GtkTextHistory *self,
+                            guint           begin,
+                            guint           end,
+                            const char     *expected_text,
+                            guint           len)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+
+  uint_order (&begin, &end);
+
+  self->funcs.delete (self->funcs_data, begin, end, expected_text, len);
+}
+
+static void
+gtk_text_history_do_select (GtkTextHistory *self,
+                            guint           selection_insert,
+                            guint           selection_bound)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+
+  self->funcs.select (self->funcs_data, selection_insert, selection_bound);
+}
+
+static void
+gtk_text_history_truncate_one (GtkTextHistory *self)
+{
+  if (self->undo_queue.length > 0)
+    {
+      Action *action = g_queue_peek_head (&self->undo_queue);
+      g_queue_unlink (&self->undo_queue, &action->link);
+      action_free (action);
+    }
+  else if (self->redo_queue.length > 0)
+    {
+      Action *action = g_queue_peek_tail (&self->redo_queue);
+      g_queue_unlink (&self->redo_queue, &action->link);
+      action_free (action);
+    }
+  else
+    {
+      g_assert_not_reached ();
+    }
+}
+
+static void
+gtk_text_history_truncate (GtkTextHistory *self)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+
+  if (self->max_undo_levels == 0)
+    return;
+
+  while (self->undo_queue.length + self->redo_queue.length > self->max_undo_levels)
+    gtk_text_history_truncate_one (self);
+}
+
+static void
+gtk_text_history_finalize (GObject *object)
+{
+  GtkTextHistory *self = (GtkTextHistory *)object;
+
+  clear_action_queue (&self->undo_queue);
+  clear_action_queue (&self->redo_queue);
+
+  G_OBJECT_CLASS (gtk_text_history_parent_class)->finalize (object);
+}
+
+static void
+gtk_text_history_class_init (GtkTextHistoryClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = gtk_text_history_finalize;
+}
+
+static void
+gtk_text_history_init (GtkTextHistory *self)
+{
+  self->enabled = TRUE;
+  self->selection.insert = -1;
+  self->selection.bound = -1;
+}
+
+static gboolean
+has_actionable (const GQueue *queue)
+{
+  const GList *iter;
+
+  for (iter = queue->head; iter; iter = iter->next)
+    {
+      const Action *action = iter->data;
+
+      if (action->kind == ACTION_KIND_BARRIER)
+        continue;
+
+      if (action->kind == ACTION_KIND_GROUP)
+        {
+          if (has_actionable (&action->u.group.actions))
+            return TRUE;
+        }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+gtk_text_history_update_state (GtkTextHistory *self)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+
+  if (self->irreversible || self->in_user)
+    {
+      self->can_undo = FALSE;
+      self->can_redo = FALSE;
+    }
+  else
+    {
+      self->can_undo = has_actionable (&self->undo_queue);
+      self->can_redo = has_actionable (&self->redo_queue);
+    }
+
+  gtk_text_history_do_change_state (self, self->is_modified, self->can_undo, self->can_redo);
+}
+
+static void
+gtk_text_history_push (GtkTextHistory *self,
+                       Action         *action)
+{
+  Action *peek;
+  gboolean in_user_action;
+
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+  g_assert (self->enabled);
+  g_assert (action != NULL);
+
+  while (self->redo_queue.length > 0)
+    {
+      peek = g_queue_peek_head (&self->redo_queue);
+      g_queue_unlink (&self->redo_queue, &peek->link);
+      action_free (peek);
+    }
+
+  peek = g_queue_peek_tail (&self->undo_queue);
+  in_user_action = self->in_user > 0;
+
+  if (peek == NULL || !action_chain (peek, action, in_user_action))
+    g_queue_push_tail_link (&self->undo_queue, &action->link);
+
+  gtk_text_history_truncate (self);
+  gtk_text_history_update_state (self);
+}
+
+GtkTextHistory *
+gtk_text_history_new (const GtkTextHistoryFuncs *funcs,
+                      gpointer                   funcs_data)
+{
+  GtkTextHistory *self;
+
+  g_return_val_if_fail (funcs != NULL, NULL);
+
+  self = g_object_new (GTK_TYPE_TEXT_HISTORY, NULL);
+  self->funcs = *funcs;
+  self->funcs_data = funcs_data;
+
+  return g_steal_pointer (&self);
+}
+
+gboolean
+gtk_text_history_get_can_undo (GtkTextHistory *self)
+{
+  g_return_val_if_fail (GTK_IS_TEXT_HISTORY (self), FALSE);
+
+  return self->can_undo;
+}
+
+gboolean
+gtk_text_history_get_can_redo (GtkTextHistory *self)
+{
+  g_return_val_if_fail (GTK_IS_TEXT_HISTORY (self), FALSE);
+
+  return self->can_redo;
+}
+
+static void
+gtk_text_history_apply (GtkTextHistory *self,
+                        Action         *action,
+                        Action         *peek)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+  g_assert (action != NULL);
+
+  switch (action->kind)
+    {
+    case ACTION_KIND_INSERT:
+      gtk_text_history_do_insert (self,
+                                  action->u.insert.begin,
+                                  action->u.insert.end,
+                                  istring_str (&action->u.insert.istr),
+                                  action->u.insert.istr.n_bytes);
+
+      /* If the next item is a DELETE_SELECTION, then we want to
+       * pre-select the text for the user. Otherwise, just place
+       * the cursor were we think it was.
+       */
+      if (peek != NULL && peek->kind == ACTION_KIND_DELETE_SELECTION)
+        gtk_text_history_do_select (self,
+                                    peek->u.delete.begin,
+                                    peek->u.delete.end);
+      else
+        gtk_text_history_do_select (self,
+                                    action->u.insert.end,
+                                    action->u.insert.end);
+
+      break;
+
+    case ACTION_KIND_DELETE_BACKSPACE:
+    case ACTION_KIND_DELETE_KEY:
+    case ACTION_KIND_DELETE_PROGRAMMATIC:
+    case ACTION_KIND_DELETE_SELECTION:
+      gtk_text_history_do_delete (self,
+                                  action->u.delete.begin,
+                                  action->u.delete.end,
+                                  istring_str (&action->u.delete.istr),
+                                  action->u.delete.istr.n_bytes);
+      gtk_text_history_do_select (self,
+                                  action->u.delete.begin,
+                                  action->u.delete.begin);
+      break;
+
+    case ACTION_KIND_GROUP: {
+      const GList *actions = action->u.group.actions.head;
+
+      for (const GList *iter = actions; iter; iter = iter->next)
+        gtk_text_history_apply (self, iter->data, NULL);
+
+      break;
+    }
+
+    case ACTION_KIND_BARRIER:
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+
+  if (action->is_modified_set)
+    self->is_modified = action->is_modified;
+}
+
+static void
+gtk_text_history_reverse (GtkTextHistory *self,
+                          Action         *action)
+{
+  g_assert (GTK_IS_TEXT_HISTORY (self));
+  g_assert (action != NULL);
+
+  switch (action->kind)
+    {
+    case ACTION_KIND_INSERT:
+      gtk_text_history_do_delete (self,
+                                  action->u.insert.begin,
+                                  action->u.insert.end,
+                                  istring_str (&action->u.insert.istr),
+                                  action->u.insert.istr.n_bytes);
+      gtk_text_history_do_select (self,
+                                  action->u.insert.begin,
+                                  action->u.insert.begin);
+      break;
+
+    case ACTION_KIND_DELETE_BACKSPACE:
+    case ACTION_KIND_DELETE_KEY:
+    case ACTION_KIND_DELETE_PROGRAMMATIC:
+    case ACTION_KIND_DELETE_SELECTION:
+      gtk_text_history_do_insert (self,
+                                  action->u.delete.begin,
+                                  action->u.delete.end,
+                                  istring_str (&action->u.delete.istr),
+                                  action->u.delete.istr.n_bytes);
+      if (action->u.delete.selection.insert != -1 &&
+          action->u.delete.selection.bound != -1)
+        gtk_text_history_do_select (self,
+                                    action->u.delete.selection.insert,
+                                    action->u.delete.selection.bound);
+      else if (action->u.delete.selection.insert != -1)
+        gtk_text_history_do_select (self,
+                                    action->u.delete.selection.insert,
+                                    action->u.delete.selection.insert);
+      break;
+
+    case ACTION_KIND_GROUP: {
+      const GList *actions = action->u.group.actions.tail;
+
+      for (const GList *iter = actions; iter; iter = iter->prev)
+        gtk_text_history_reverse (self, iter->data);
+
+      break;
+    }
+
+    case ACTION_KIND_BARRIER:
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+
+  if (action->is_modified_set)
+    self->is_modified = !action->is_modified;
+}
+
+static void
+move_barrier (GQueue   *from_queue,
+              Action   *action,
+              GQueue   *to_queue,
+              gboolean  head)
+{
+  g_queue_unlink (from_queue, &action->link);
+
+  if (head)
+    g_queue_push_head_link (to_queue, &action->link);
+  else
+    g_queue_push_tail_link (to_queue, &action->link);
+}
+
+void
+gtk_text_history_undo (GtkTextHistory *self)
+{
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  if (gtk_text_history_get_can_undo (self))
+    {
+      Action *action;
+
+      self->applying = TRUE;
+
+      action = g_queue_peek_tail (&self->undo_queue);
+
+      if (action->kind == ACTION_KIND_BARRIER)
+        {
+          move_barrier (&self->undo_queue, action, &self->redo_queue, TRUE);
+          action = g_queue_peek_tail (&self->undo_queue);
+        }
+
+      g_queue_unlink (&self->undo_queue, &action->link);
+      g_queue_push_head_link (&self->redo_queue, &action->link);
+      gtk_text_history_reverse (self, action);
+      gtk_text_history_update_state (self);
+
+      self->applying = FALSE;
+    }
+}
+
+void
+gtk_text_history_redo (GtkTextHistory *self)
+{
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  if (gtk_text_history_get_can_redo (self))
+    {
+      Action *action;
+      Action *peek;
+
+      self->applying = TRUE;
+
+      action = g_queue_peek_head (&self->redo_queue);
+
+      if (action->kind == ACTION_KIND_BARRIER)
+        {
+          move_barrier (&self->redo_queue, action, &self->undo_queue, FALSE);
+          action = g_queue_peek_head (&self->redo_queue);
+        }
+
+      g_queue_unlink (&self->redo_queue, &action->link);
+      g_queue_push_tail_link (&self->undo_queue, &action->link);
+
+      peek = g_queue_peek_head (&self->redo_queue);
+
+      gtk_text_history_apply (self, action, peek);
+      gtk_text_history_update_state (self);
+
+      self->applying = FALSE;
+    }
+}
+
+void
+gtk_text_history_begin_user_action (GtkTextHistory *self)
+{
+  Action *group;
+
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  self->in_user++;
+
+  group = g_queue_peek_tail (&self->undo_queue);
+
+  if (group == NULL || group->kind != ACTION_KIND_GROUP)
+    {
+      group = action_new (ACTION_KIND_GROUP);
+      gtk_text_history_push (self, group);
+    }
+
+  group->u.group.depth++;
+
+  gtk_text_history_update_state (self);
+}
+
+void
+gtk_text_history_end_user_action (GtkTextHistory *self)
+{
+  Action *peek;
+
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  clear_action_queue (&self->redo_queue);
+
+  peek = g_queue_peek_tail (&self->undo_queue);
+
+  if (peek->kind != ACTION_KIND_GROUP)
+    {
+      g_warning ("miss-matched %s end_user_action. Expected group, got %d",
+                 G_OBJECT_TYPE_NAME (self),
+                 peek->kind);
+      return;
+    }
+
+  self->in_user--;
+  peek->u.group.depth--;
+
+  /* Unless this is the last user action, short-circuit */
+  if (peek->u.group.depth > 0)
+    return;
+
+  /* Unlikely, but if the group is empty, just remove it */
+  if (action_group_is_empty (peek))
+    {
+      g_queue_unlink (&self->undo_queue, &peek->link);
+      action_free (peek);
+      goto update_state;
+    }
+
+  /* Now insert a barrier action so we don't allow
+   * joining items to this node in the future.
+   */
+  gtk_text_history_push (self, action_new (ACTION_KIND_BARRIER));
+
+update_state:
+  gtk_text_history_update_state (self);
+}
+
+void
+gtk_text_history_begin_irreversible_action (GtkTextHistory *self)
+{
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+
+  if (self->in_user)
+    {
+      g_warning ("Cannot begin irreversible action while in user action");
+      return;
+    }
+
+  self->irreversible++;
+
+  clear_action_queue (&self->undo_queue);
+  clear_action_queue (&self->redo_queue);
+
+  gtk_text_history_update_state (self);
+}
+
+void
+gtk_text_history_end_irreversible_action (GtkTextHistory *self)
+{
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+
+  if (self->in_user)
+    {
+      g_warning ("Cannot end irreversible action while in user action");
+      return;
+    }
+
+  self->irreversible--;
+
+  clear_action_queue (&self->undo_queue);
+  clear_action_queue (&self->redo_queue);
+
+  gtk_text_history_update_state (self);
+}
+
+static void
+gtk_text_history_clear_modified (GtkTextHistory *self)
+{
+  const GList *iter;
+
+  for (iter = self->undo_queue.head; iter; iter = iter->next)
+    {
+      Action *action = iter->data;
+
+      action->is_modified = FALSE;
+      action->is_modified_set = FALSE;
+    }
+
+  for (iter = self->redo_queue.head; iter; iter = iter->next)
+    {
+      Action *action = iter->data;
+
+      action->is_modified = FALSE;
+      action->is_modified_set = FALSE;
+    }
+}
+
+void
+gtk_text_history_modified_changed (GtkTextHistory *self,
+                                   gboolean        modified)
+{
+  Action *peek;
+
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  /* If we have a new save point, clear all previous modified states. */
+  gtk_text_history_clear_modified (self);
+
+  if ((peek = g_queue_peek_tail (&self->undo_queue)))
+    {
+      if (peek->kind == ACTION_KIND_BARRIER)
+        {
+          if (!(peek = peek->link.prev->data))
+            return;
+        }
+
+      peek->is_modified = !!modified;
+      peek->is_modified_set = TRUE;
+    }
+
+  self->is_modified = !!modified;
+  self->is_modified_set = TRUE;
+
+  gtk_text_history_update_state (self);
+}
+
+void
+gtk_text_history_selection_changed (GtkTextHistory *self,
+                                    int             selection_insert,
+                                    int             selection_bound)
+{
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  if (self->in_user == 0 && self->irreversible == 0)
+    {
+      self->selection.insert = CLAMP (selection_insert, -1, G_MAXINT);
+      self->selection.bound = CLAMP (selection_bound, -1, G_MAXINT);
+    }
+}
+
+void
+gtk_text_history_text_inserted (GtkTextHistory *self,
+                                guint           position,
+                                const char     *text,
+                                int             len)
+{
+  Action *action;
+
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  if (len < 0)
+    len = strlen (text);
+
+  action = action_new (ACTION_KIND_INSERT);
+  action->u.insert.begin = position;
+  action->u.insert.end = position + g_utf8_strlen (text, len);
+  istring_set (&action->u.insert.istr,
+               text,
+               len,
+               action->u.insert.end);
+
+  gtk_text_history_push (self, action);
+}
+
+void
+gtk_text_history_text_deleted (GtkTextHistory *self,
+                               guint           begin,
+                               guint           end,
+                               const char     *text,
+                               int             len)
+{
+  Action *action;
+  ActionKind kind;
+
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  return_if_not_enabled (self);
+  return_if_applying (self);
+  return_if_irreversible (self);
+
+  if (len < 0)
+    len = strlen (text);
+
+  if (self->selection.insert == -1 && self->selection.bound == -1)
+    kind = ACTION_KIND_DELETE_PROGRAMMATIC;
+  else if (self->selection.insert == end && self->selection.bound == -1)
+    kind = ACTION_KIND_DELETE_BACKSPACE;
+  else if (self->selection.insert == begin && self->selection.bound == -1)
+    kind = ACTION_KIND_DELETE_KEY;
+  else
+    kind = ACTION_KIND_DELETE_SELECTION;
+
+  action = action_new (kind);
+  action->u.delete.begin = begin;
+  action->u.delete.end = end;
+  action->u.delete.selection.insert = self->selection.insert;
+  action->u.delete.selection.bound = self->selection.bound;
+  istring_set (&action->u.delete.istr, text, len, ABS (end - begin));
+
+  gtk_text_history_push (self, action);
+}
+
+gboolean
+gtk_text_history_get_enabled (GtkTextHistory *self)
+{
+  g_return_val_if_fail (GTK_IS_TEXT_HISTORY (self), FALSE);
+
+  return self->enabled;
+}
+
+void
+gtk_text_history_set_enabled (GtkTextHistory *self,
+                              gboolean        enabled)
+{
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  enabled = !!enabled;
+
+  if (self->enabled != enabled)
+    {
+      self->enabled = enabled;
+
+      if (!self->enabled)
+        {
+          self->irreversible = 0;
+          self->in_user = 0;
+          clear_action_queue (&self->undo_queue);
+          clear_action_queue (&self->redo_queue);
+        }
+    }
+}
+
+guint
+gtk_text_history_get_max_undo_levels (GtkTextHistory *self)
+{
+  g_return_val_if_fail (GTK_IS_TEXT_HISTORY (self), 0);
+
+  return self->max_undo_levels;
+}
+
+void
+gtk_text_history_set_max_undo_levels (GtkTextHistory *self,
+                                      guint           max_undo_levels)
+{
+  g_return_if_fail (GTK_IS_TEXT_HISTORY (self));
+
+  if (self->max_undo_levels != max_undo_levels)
+    {
+      self->max_undo_levels = max_undo_levels;
+      gtk_text_history_truncate (self);
+    }
+}
diff --git a/gtk/gtktexthistoryprivate.h b/gtk/gtktexthistoryprivate.h
new file mode 100644
index 0000000000..b65682d295
--- /dev/null
+++ b/gtk/gtktexthistoryprivate.h
@@ -0,0 +1,84 @@
+/* Copyright (C) 2019 Red Hat, Inc.
+ *
+ * This library 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) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GTK_TEXT_HISTORY_PRIVATE_H__
+#define __GTK_TEXT_HISTORY_PRIVATE_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_TEXT_HISTORY (gtk_text_history_get_type())
+
+typedef struct _GtkTextHistoryFuncs GtkTextHistoryFuncs;
+
+G_DECLARE_FINAL_TYPE (GtkTextHistory, gtk_text_history, GTK, TEXT_HISTORY, GObject)
+
+struct _GtkTextHistoryFuncs
+{
+  void (*change_state) (gpointer     funcs_data,
+                        gboolean     is_modified,
+                        gboolean     can_undo,
+                        gboolean     can_redo);
+  void (*insert)       (gpointer     funcs_data,
+                        guint        begin,
+                        guint        end,
+                        const char  *text,
+                        guint        len);
+  void (*delete)       (gpointer     funcs_data,
+                        guint        begin,
+                        guint        end,
+                        const char  *expected_text,
+                        guint        len);
+  void (*select)       (gpointer     funcs_data,
+                        int          selection_insert,
+                        int          selection_bound);
+};
+
+GtkTextHistory *gtk_text_history_new                       (const GtkTextHistoryFuncs *funcs,
+                                                            gpointer                   funcs_data);
+void            gtk_text_history_begin_user_action         (GtkTextHistory            *self);
+void            gtk_text_history_end_user_action           (GtkTextHistory            *self);
+void            gtk_text_history_begin_irreversible_action (GtkTextHistory            *self);
+void            gtk_text_history_end_irreversible_action   (GtkTextHistory            *self);
+gboolean        gtk_text_history_get_can_undo              (GtkTextHistory            *self);
+gboolean        gtk_text_history_get_can_redo              (GtkTextHistory            *self);
+void            gtk_text_history_undo                      (GtkTextHistory            *self);
+void            gtk_text_history_redo                      (GtkTextHistory            *self);
+guint           gtk_text_history_get_max_undo_levels       (GtkTextHistory            *self);
+void            gtk_text_history_set_max_undo_levels       (GtkTextHistory            *self,
+                                                            guint                      max_undo_levels);
+void            gtk_text_history_modified_changed          (GtkTextHistory            *self,
+                                                            gboolean                   modified);
+void            gtk_text_history_selection_changed         (GtkTextHistory            *self,
+                                                            int                        selection_insert,
+                                                            int                        selection_bound);
+void            gtk_text_history_text_inserted             (GtkTextHistory            *self,
+                                                            guint                      position,
+                                                            const char                *text,
+                                                            int                        len);
+void            gtk_text_history_text_deleted              (GtkTextHistory            *self,
+                                                            guint                      begin,
+                                                            guint                      end,
+                                                            const char                *text,
+                                                            int                        len);
+gboolean        gtk_text_history_get_enabled               (GtkTextHistory            *self);
+void            gtk_text_history_set_enabled               (GtkTextHistory            *self,
+                                                            gboolean                   enabled);
+
+G_END_DECLS
+
+#endif /* __GTK_TEXT_HISTORY_PRIVATE_H__ */
diff --git a/gtk/meson.build b/gtk/meson.build
index 3119e05934..65576f92c6 100644
--- a/gtk/meson.build
+++ b/gtk/meson.build
@@ -145,6 +145,7 @@ gtk_private_sources = files([
   'gtkstylecascade.c',
   'gtkstyleproperty.c',
   'gtktextbtree.c',
+  'gtktexthistory.c',
   'gtktextviewchild.c',
   'gtktrashmonitor.c',
   'gtktreedatalist.c',
diff --git a/tests/meson.build b/tests/meson.build
index 176685fe50..7b28428102 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -126,6 +126,7 @@ gtk_tests = [
   ['testblur'],
   ['testtexture'],
   ['testwindowdrag'],
+  ['testtexthistory', ['../gtk/gtktexthistory.c']],
 ]
 
 if os_unix
diff --git a/tests/testtexthistory.c b/tests/testtexthistory.c
new file mode 100644
index 0000000000..8332b4d8a1
--- /dev/null
+++ b/tests/testtexthistory.c
@@ -0,0 +1,600 @@
+#include "gtktexthistoryprivate.h"
+
+#if 0
+# define DEBUG_COMMANDS
+#endif
+
+typedef struct
+{
+  GtkTextHistory *history;
+  GString *buf;
+  struct {
+    int insert;
+    int bound;
+  } selection;
+  guint can_redo : 1;
+  guint can_undo : 1;
+  guint is_modified : 1;
+} Text;
+
+enum {
+  IGNORE = 0,
+  SET = 1,
+  UNSET = 2,
+};
+
+enum {
+  IGNORE_SELECT = 0,
+  DO_SELECT = 1,
+};
+
+enum {
+  INSERT = 1,
+  INSERT_SEQ,
+  BACKSPACE,
+  DELETE_KEY,
+  UNDO,
+  REDO,
+  BEGIN_IRREVERSIBLE,
+  END_IRREVERSIBLE,
+  BEGIN_USER,
+  END_USER,
+  MODIFIED,
+  UNMODIFIED,
+  SELECT,
+  CHECK_SELECT,
+  SET_MAX_UNDO,
+};
+
+typedef struct
+{
+  int kind;
+  int location;
+  int end_location;
+  const char *text;
+  const char *expected;
+  int can_undo;
+  int can_redo;
+  int is_modified;
+  int select;
+} Command;
+
+static void
+do_change_state (gpointer funcs_data,
+                 gboolean is_modified,
+                 gboolean can_undo,
+                 gboolean can_redo)
+{
+  Text *text = funcs_data;
+
+  text->is_modified = is_modified;
+  text->can_undo = can_undo;
+  text->can_redo = can_redo;
+}
+
+static void
+do_insert (gpointer    funcs_data,
+           guint       begin,
+           guint       end,
+           const char *text,
+           guint       len)
+{
+  Text *t = funcs_data;
+
+#ifdef DEBUG_COMMANDS
+  g_printerr ("Insert Into '%s' (begin=%u end=%u text=%s)\n",
+              t->buf->str, begin, end, text);
+#endif
+
+  g_string_insert_len (t->buf, begin, text, len);
+}
+
+static void
+do_delete (gpointer     funcs_data,
+           guint        begin,
+           guint        end,
+           const gchar *expected_text,
+           guint        len)
+{
+  Text *t = funcs_data;
+
+#ifdef DEBUG_COMMANDS
+  g_printerr ("Delete(begin=%u end=%u expected_text=%s)\n", begin, end, expected_text);
+#endif
+
+  if (end < begin)
+    {
+      guint tmp = end;
+      end = begin;
+      begin = tmp;
+    }
+
+  g_assert_cmpint (memcmp (t->buf->str + begin, expected_text, len), ==, 0);
+
+  if (end >= t->buf->len)
+    {
+      t->buf->len = begin;
+      t->buf->str[begin] = 0;
+      return;
+    }
+
+  memmove (t->buf->str + begin,
+           t->buf->str + end,
+           t->buf->len - end);
+  g_string_truncate (t->buf, t->buf->len - (end - begin));
+}
+
+static void
+do_select (gpointer funcs_data,
+           gint     selection_insert,
+           gint     selection_bound)
+{
+  Text *text = funcs_data;
+
+  text->selection.insert = selection_insert;
+  text->selection.bound = selection_bound;
+}
+
+static GtkTextHistoryFuncs funcs = {
+  do_change_state,
+  do_insert,
+  do_delete,
+  do_select,
+};
+
+static Text *
+text_new (void)
+{
+  Text *text = g_slice_new0 (Text);
+
+  text->history = gtk_text_history_new (&funcs, text);
+  text->buf = g_string_new (NULL);
+  text->selection.insert = -1;
+  text->selection.bound = -1;
+
+  return text;
+}
+
+static void
+text_free (Text *text)
+{
+  g_object_unref (text->history);
+  g_string_free (text->buf, TRUE);
+  g_slice_free (Text, text);
+}
+
+static void
+command_insert (const Command *cmd,
+                Text          *text)
+{
+  do_insert (text,
+             cmd->location,
+             cmd->location + g_utf8_strlen (cmd->text, -1),
+             cmd->text,
+             strlen (cmd->text));
+  gtk_text_history_text_inserted (text->history, cmd->location, cmd->text, -1);
+}
+
+static void
+command_delete_key (const Command *cmd,
+                    Text          *text)
+{
+  do_delete (text,
+             cmd->location,
+             cmd->end_location,
+             cmd->text,
+             strlen (cmd->text));
+  gtk_text_history_text_deleted (text->history,
+                                 cmd->location,
+                                 cmd->end_location,
+                                 cmd->text,
+                                 ABS (cmd->end_location - cmd->location));
+}
+
+static void
+command_undo (const Command *cmd,
+              Text          *text)
+{
+  gtk_text_history_undo (text->history);
+}
+
+static void
+command_redo (const Command *cmd,
+              Text          *text)
+{
+  gtk_text_history_redo (text->history);
+}
+
+static void
+set_selection (Text *text,
+               int   begin,
+               int   end)
+{
+  gtk_text_history_selection_changed (text->history, begin, end);
+}
+
+static void
+run_test (const Command *commands,
+          guint          n_commands,
+          guint          max_undo)
+{
+  Text *text = text_new ();
+
+  if (max_undo)
+    gtk_text_history_set_max_undo_levels (text->history, max_undo);
+
+  for (guint i = 0; i < n_commands; i++)
+    {
+      const Command *cmd = &commands[i];
+
+#ifdef DEBUG_COMMANDS
+      g_printerr ("%d: %d\n", i, cmd->kind);
+#endif
+
+      switch (cmd->kind)
+        {
+        case INSERT:
+          command_insert (cmd, text);
+          break;
+
+        case INSERT_SEQ:
+          for (guint j = 0; cmd->text[j]; j++)
+            {
+              const char seqtext[2] = { cmd->text[j], 0 };
+              Command seq = { INSERT, cmd->location + j, 1, seqtext, NULL };
+              command_insert (&seq, text);
+            }
+          break;
+
+        case DELETE_KEY:
+          if (cmd->select == DO_SELECT)
+            set_selection (text, cmd->location, cmd->end_location);
+          else if (strlen (cmd->text) == 1)
+            set_selection (text, cmd->location, -1);
+          else
+            set_selection (text, -1, -1);
+          command_delete_key (cmd, text);
+          break;
+
+        case BACKSPACE:
+          if (cmd->select == DO_SELECT)
+            set_selection (text, cmd->location, cmd->end_location);
+          else if (strlen (cmd->text) == 1)
+            set_selection (text, cmd->end_location, -1);
+          else
+            set_selection (text, -1, -1);
+          command_delete_key (cmd, text);
+          break;
+
+        case UNDO:
+          command_undo (cmd, text);
+          break;
+
+        case REDO:
+          command_redo (cmd, text);
+          break;
+
+        case BEGIN_USER:
+          gtk_text_history_begin_user_action (text->history);
+          break;
+
+        case END_USER:
+          gtk_text_history_end_user_action (text->history);
+          break;
+
+        case BEGIN_IRREVERSIBLE:
+          gtk_text_history_begin_irreversible_action (text->history);
+          break;
+
+        case END_IRREVERSIBLE:
+          gtk_text_history_end_irreversible_action (text->history);
+          break;
+
+        case MODIFIED:
+          gtk_text_history_modified_changed (text->history, TRUE);
+          break;
+
+        case UNMODIFIED:
+          gtk_text_history_modified_changed (text->history, FALSE);
+          break;
+
+        case SELECT:
+          gtk_text_history_selection_changed (text->history,
+                                              cmd->location,
+                                              cmd->end_location);
+          break;
+
+        case CHECK_SELECT:
+          g_assert_cmpint (text->selection.insert, ==, cmd->location);
+          g_assert_cmpint (text->selection.bound, ==, cmd->end_location);
+          break;
+
+        case SET_MAX_UNDO:
+          /* Not ideal use of location, but fine */
+          gtk_text_history_set_max_undo_levels (text->history, cmd->location);
+          break;
+
+        default:
+          break;
+        }
+
+      if (cmd->expected)
+        g_assert_cmpstr (text->buf->str, ==, cmd->expected);
+
+      if (cmd->can_redo == SET)
+        g_assert_cmpint (text->can_redo, ==, TRUE);
+      else if (cmd->can_redo == UNSET)
+        g_assert_cmpint (text->can_redo, ==, FALSE);
+
+      if (cmd->can_undo == SET)
+        g_assert_cmpint (text->can_undo, ==, TRUE);
+      else if (cmd->can_undo == UNSET)
+        g_assert_cmpint (text->can_undo, ==, FALSE);
+
+      if (cmd->is_modified == SET)
+        g_assert_cmpint (text->is_modified, ==, TRUE);
+      else if (cmd->is_modified == UNSET)
+        g_assert_cmpint (text->is_modified, ==, FALSE);
+    }
+
+  text_free (text);
+}
+
+static void
+test1 (void)
+{
+  static const Command commands[] = {
+    { INSERT, 0, -1, "test", "test", SET, UNSET },
+    { INSERT, 2, -1, "s", "tesst", SET, UNSET },
+    { INSERT, 3, -1, "ss", "tesssst", SET, UNSET },
+    { DELETE_KEY, 2, 5, "sss", "test", SET, UNSET },
+    { UNDO, -1, -1, NULL, "tesssst", SET, SET },
+    { REDO, -1, -1, NULL, "test", SET, UNSET },
+    { UNDO, -1, -1, NULL, "tesssst", SET, SET },
+    { DELETE_KEY, 0, 7, "tesssst", "", SET, UNSET },
+    { INSERT, 0, -1, "z", "z", SET, UNSET },
+    { UNDO, -1, -1, NULL, "", SET, SET },
+    { UNDO, -1, -1, NULL, "tesssst", SET, SET },
+    { UNDO, -1, -1, NULL, "test", SET, SET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test2 (void)
+{
+  static const Command commands[] = {
+    { BEGIN_IRREVERSIBLE, -1, -1, NULL, "", UNSET, UNSET },
+    { INSERT, 0, -1, "this is a test", "this is a test", UNSET, UNSET },
+    { END_IRREVERSIBLE, -1, -1, NULL, "this is a test", UNSET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test", UNSET, UNSET },
+    { REDO, -1, -1, NULL, "this is a test", UNSET, UNSET },
+    { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
+    { INSERT, 0, -1, "first", "firstthis is a test", UNSET, UNSET },
+    { INSERT, 5, -1, " ", "first this is a test", UNSET, UNSET },
+    { END_USER, -1, -1, NULL, "first this is a test", SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test", UNSET, SET },
+    { UNDO, -1, -1, NULL, "this is a test", UNSET, SET },
+    { REDO, -1, -1, NULL, "first this is a test", SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test", UNSET, SET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test3 (void)
+{
+  static const Command commands[] = {
+    { INSERT_SEQ, 0, -1, "this is a test of insertions.", "this is a test of insertions.", SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test of", SET, SET },
+    { UNDO, -1, -1, NULL, "this is a test", SET, SET },
+    { UNDO, -1, -1, NULL, "this is a", SET, SET },
+    { UNDO, -1, -1, NULL, "this is", SET, SET },
+    { UNDO, -1, -1, NULL, "this", SET, SET },
+    { UNDO, -1, -1, NULL, "", UNSET, SET },
+    { UNDO, -1, -1, NULL, "" , UNSET, SET },
+    { REDO, -1, -1, NULL, "this", SET, SET },
+    { REDO, -1, -1, NULL, "this is", SET, SET },
+    { REDO, -1, -1, NULL, "this is a", SET, SET },
+    { REDO, -1, -1, NULL, "this is a test", SET, SET },
+    { REDO, -1, -1, NULL, "this is a test of", SET, SET },
+    { REDO, -1, -1, NULL, "this is a test of insertions.", SET, UNSET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test4 (void)
+{
+  static const Command commands[] = {
+    { INSERT, 0, -1, "initial text", "initial text", SET, UNSET },
+    /* Barrier */
+    { BEGIN_IRREVERSIBLE, -1, -1, NULL, NULL, UNSET, UNSET },
+    { END_IRREVERSIBLE, -1, -1, NULL, NULL, UNSET, UNSET },
+    { INSERT, 0, -1, "more text ", "more text initial text", SET, UNSET },
+    { UNDO, -1, -1, NULL, "initial text", UNSET, SET },
+    { UNDO, -1, -1, NULL, "initial text", UNSET, SET },
+    { REDO, -1, -1, NULL, "more text initial text", SET, UNSET },
+    /* Barrier */
+    { BEGIN_IRREVERSIBLE, UNSET, UNSET },
+    { END_IRREVERSIBLE, UNSET, UNSET },
+    { UNDO, -1, -1, NULL, "more text initial text", UNSET, UNSET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test5 (void)
+{
+  static const Command commands[] = {
+    { INSERT, 0, -1, "initial text", "initial text", SET, UNSET },
+    { DELETE_KEY, 0, 12, "initial text", "", SET, UNSET },
+    /* Add empty nested user action (should get ignored) */
+    { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
+      { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
+        { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
+        { END_USER, -1, -1, NULL, NULL, UNSET, UNSET },
+      { END_USER, -1, -1, NULL, NULL, UNSET, UNSET },
+    { END_USER, -1, -1, NULL, NULL, SET, UNSET },
+    { UNDO, -1, -1, NULL, "initial text" },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test6 (void)
+{
+  static const Command commands[] = {
+    { INSERT_SEQ, 0, -1, " \t\t    this is some text", " \t\t    this is some text", SET, UNSET },
+    { UNDO, -1, -1, NULL, " \t\t    this is some", SET, SET },
+    { UNDO, -1, -1, NULL, " \t\t    this is", SET, SET },
+    { UNDO, -1, -1, NULL, " \t\t    this", SET, SET },
+    { UNDO, -1, -1, NULL, "", UNSET, SET },
+    { UNDO, -1, -1, NULL, "", UNSET, SET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test7 (void)
+{
+  static const Command commands[] = {
+    { MODIFIED, -1, -1, NULL, NULL, UNSET, UNSET, SET },
+    { UNMODIFIED, -1, -1, NULL, NULL, UNSET, UNSET, UNSET },
+    { INSERT, 0, -1, "foo bar", "foo bar", SET, UNSET, UNSET },
+    { MODIFIED, -1, -1, NULL, NULL, SET, UNSET, SET },
+    { UNDO, -1, -1, NULL, "", UNSET, SET, UNSET },
+    { REDO, -1, -1, NULL, "foo bar", SET, UNSET, SET },
+    { UNDO, -1, -1, NULL, "", UNSET, SET, UNSET },
+    { REDO, -1, -1, NULL, "foo bar", SET, UNSET, SET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test8 (void)
+{
+  static const Command commands[] = {
+    { INSERT, 0, -1, "foo bar", "foo bar", SET, UNSET, UNSET },
+    { MODIFIED, -1, -1, NULL, NULL, SET, UNSET, SET },
+    { INSERT, 0, -1, "f", "ffoo bar", SET, UNSET, SET },
+    { UNMODIFIED, -1, -1, NULL, NULL, SET, UNSET, UNSET },
+    { UNDO, -1, -1, NULL, "foo bar", SET, SET, SET },
+    { UNDO, -1, -1, NULL, "", UNSET, SET, SET },
+    { REDO, -1, -1, NULL, "foo bar", SET, SET, SET },
+    { REDO, -1, -1, NULL, "ffoo bar", SET, UNSET, UNSET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test9 (void)
+{
+  static const Command commands[] = {
+    { INSERT, 0, -1, "foo bar", "foo bar", SET, UNSET, UNSET },
+    { DELETE_KEY, 0, 3, "foo", " bar", SET, UNSET, UNSET, DO_SELECT },
+    { DELETE_KEY, 0, 4, " bar", "", SET, UNSET, UNSET, DO_SELECT },
+    { UNDO, -1, -1, NULL, " bar", SET, SET, UNSET },
+    { CHECK_SELECT, 0, 4, NULL, " bar", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "foo bar", SET, SET, UNSET },
+    { CHECK_SELECT, 0, 3, NULL, "foo bar", SET, SET, UNSET },
+    { BEGIN_IRREVERSIBLE, -1, -1, NULL, "foo bar", UNSET, UNSET, UNSET },
+    { END_IRREVERSIBLE, -1, -1, NULL, "foo bar", UNSET, UNSET, UNSET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test10 (void)
+{
+  static const Command commands[] = {
+    { BEGIN_USER }, { INSERT, 0, -1, "t", "t", UNSET, UNSET, UNSET }, { END_USER },
+    { BEGIN_USER }, { INSERT, 1, -1, " ", "t ", UNSET, UNSET, UNSET }, { END_USER },
+    { BEGIN_USER }, { INSERT, 2, -1, "t", "t t", UNSET, UNSET, UNSET }, { END_USER },
+    { BEGIN_USER }, { INSERT, 3, -1, "h", "t th", UNSET, UNSET, UNSET }, { END_USER },
+    { BEGIN_USER }, { INSERT, 4, -1, "i", "t thi", UNSET, UNSET, UNSET }, { END_USER },
+    { BEGIN_USER }, { INSERT, 5, -1, "s", "t this", UNSET, UNSET, UNSET }, { END_USER },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test11 (void)
+{
+  /* Test backspace */
+  static const Command commands[] = {
+    { INSERT_SEQ, 0, -1, "insert some text", "insert some text", SET, UNSET, UNSET },
+    { BACKSPACE, 15, 16, "t", "insert some tex", SET, UNSET, UNSET },
+    { BACKSPACE, 14, 15, "x", "insert some te", SET, UNSET, UNSET },
+    { BACKSPACE, 13, 14, "e", "insert some t", SET, UNSET, UNSET },
+    { BACKSPACE, 12, 13, "t", "insert some ", SET, UNSET, UNSET },
+    { UNDO, -1, -1, NULL, "insert some text", SET, SET, UNSET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test12 (void)
+{
+  static const Command commands[] = {
+    { INSERT_SEQ, 0, -1, "this is a test\nmore", "this is a test\nmore", SET, UNSET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test\n", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "this", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "", UNSET, SET, UNSET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 0);
+}
+
+static void
+test13 (void)
+{
+  static const Command commands[] = {
+    { INSERT_SEQ, 0, -1, "this is a test\nmore", "this is a test\nmore", SET, UNSET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test\n", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a test", SET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a", UNSET, SET, UNSET },
+    { UNDO, -1, -1, NULL, "this is a", UNSET, SET, UNSET },
+    { SET_MAX_UNDO, 2, -1, NULL, "this is a", UNSET, SET, UNSET },
+    { REDO, -1, -1, NULL, "this is a test", SET, SET, UNSET },
+    { REDO, -1, -1, NULL, "this is a test\n", SET, UNSET, UNSET },
+    { REDO, -1, -1, NULL, "this is a test\n", SET, UNSET, UNSET },
+  };
+
+  run_test (commands, G_N_ELEMENTS (commands), 3);
+}
+
+int
+main (int   argc,
+      char *argv[])
+{
+  g_test_init (&argc, &argv, NULL);
+  g_test_add_func ("/Gtk/TextHistory/test1", test1);
+  g_test_add_func ("/Gtk/TextHistory/test2", test2);
+  g_test_add_func ("/Gtk/TextHistory/test3", test3);
+  g_test_add_func ("/Gtk/TextHistory/test4", test4);
+  g_test_add_func ("/Gtk/TextHistory/test5", test5);
+  g_test_add_func ("/Gtk/TextHistory/test6", test6);
+  g_test_add_func ("/Gtk/TextHistory/test7", test7);
+  g_test_add_func ("/Gtk/TextHistory/test8", test8);
+  g_test_add_func ("/Gtk/TextHistory/test9", test9);
+  g_test_add_func ("/Gtk/TextHistory/test10", test10);
+  g_test_add_func ("/Gtk/TextHistory/test11", test11);
+  g_test_add_func ("/Gtk/TextHistory/test12", test12);
+  g_test_add_func ("/Gtk/TextHistory/test13", test13);
+  return g_test_run ();
+}


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]