[gtksourceview/wip/chergert/snippets] snippet: implement basic snippet system
- From: Christian Hergert <chergert src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtksourceview/wip/chergert/snippets] snippet: implement basic snippet system
- Date: Tue, 21 Jan 2020 21:01:38 +0000 (UTC)
commit 8e2256a48c714d2dfd9bb65103378dcca3119dbd
Author: Christian Hergert <chergert redhat com>
Date: Fri Jan 17 16:12:00 2020 -0800
snippet: implement basic snippet system
This is a straightforward port of Builder's snippet system to
GtkSourceView. A number of new objects are added as part of this
commit to the GtkSourceView ABI.
- GtkSourceSnippet provides an object representing a snippet to be
inserted into a textview. Snippets are associated with a textview
rather than a buffer because of incremental state that is necessary
to interact with widgetry and event controllers. Additionally, it
doesn't make sense to have this attached to the buffer when the
view area could be different.
- GtkSourceSnippetChunk is a single chunk of a snippet. A snippet contains
zero or more chunks. A chunk can have a spec (which can be evaluated
using variables) or text set (such as after typing in the editor). Also,
a chunk can have a "focus-position" which allows the user to tab
through the chunks of the snippet.
- GtkSourceSnippetContext provides state which can be expanded as
part of the snippet. This is useful to expand variables set by the
application or filters to transform input text or other variables.
The style scheme has been adjusted to give us access to a focus position
tag so that they are highlighted to the user. Style schemes bundled with
GtkSourceView will want to implement this in a future commit.
Tabbing will expand the snippet based on the current word. However, some
applications may want to use a completion provider to show the user
more information about the snippet. A completion provider will be provided
in a forthcoming commit.
Applications can insert snippets using gtk_source_view_push_snippet().
docs/reference/meson.build | 2 +
gtksourceview/gtksource.h | 3 +
gtksourceview/gtksourcebuffer-private.h | 2 +
gtksourceview/gtksourcebuffer.c | 46 +
gtksourceview/gtksourcemarshalers.list | 1 +
gtksourceview/gtksourcesnippet-private.h | 75 ++
gtksourceview/gtksourcesnippet.c | 1326 +++++++++++++++++++++++
gtksourceview/gtksourcesnippet.h | 70 ++
gtksourceview/gtksourcesnippetchunk.c | 404 +++++++
gtksourceview/gtksourcesnippetchunk.h | 67 ++
gtksourceview/gtksourcesnippetcontext-private.h | 29 +
gtksourceview/gtksourcesnippetcontext.c | 911 ++++++++++++++++
gtksourceview/gtksourcesnippetcontext.h | 65 ++
gtksourceview/gtksourcestylescheme-private.h | 2 +
gtksourceview/gtksourcestylescheme.c | 9 +
gtksourceview/gtksourcetypes.h | 3 +
gtksourceview/gtksourceview.c | 371 ++++++-
gtksourceview/gtksourceview.h | 9 +
gtksourceview/meson.build | 6 +
19 files changed, 3388 insertions(+), 13 deletions(-)
---
diff --git a/docs/reference/meson.build b/docs/reference/meson.build
index 622a4de8..7fd35b46 100644
--- a/docs/reference/meson.build
+++ b/docs/reference/meson.build
@@ -35,6 +35,8 @@ reference_private_h = [
'gtksourcepixbufhelper-private.h',
'gtksourceregex-private.h',
'gtksourcesearchcontext-private.h',
+ 'gtksourcesnippet-private.h',
+ 'gtksourcesnippetcontext-private.h',
'gtksourcestyle-private.h',
'gtksourcestylescheme-private.h',
'gtksourcestyleschememanager-private.h',
diff --git a/gtksourceview/gtksource.h b/gtksourceview/gtksource.h
index 517c06ae..bea7c201 100644
--- a/gtksourceview/gtksource.h
+++ b/gtksourceview/gtksource.h
@@ -47,6 +47,9 @@
#include "gtksourceregion.h"
#include "gtksourcesearchcontext.h"
#include "gtksourcesearchsettings.h"
+#include "gtksourcesnippet.h"
+#include "gtksourcesnippetchunk.h"
+#include "gtksourcesnippetcontext.h"
#include "gtksourcespacedrawer.h"
#include "gtksourcestyle.h"
#include "gtksourcestylescheme.h"
diff --git a/gtksourceview/gtksourcebuffer-private.h b/gtksourceview/gtksourcebuffer-private.h
index 9d047ab8..4a0765f0 100644
--- a/gtksourceview/gtksourcebuffer-private.h
+++ b/gtksourceview/gtksourcebuffer-private.h
@@ -69,5 +69,7 @@ GTK_SOURCE_INTERNAL
gboolean _gtk_source_buffer_has_source_marks (GtkSourceBuffer *buffer);
GTK_SOURCE_INTERNAL
gboolean _gtk_source_buffer_has_spaces_tag (GtkSourceBuffer *buffer);
+GTK_SOURCE_INTERNAL
+GtkTextTag *_gtk_source_buffer_get_snippet_focus_tag (GtkSourceBuffer *buffer);
G_END_DECLS
diff --git a/gtksourceview/gtksourcebuffer.c b/gtksourceview/gtksourcebuffer.c
index 6bcd66ee..c025738e 100644
--- a/gtksourceview/gtksourcebuffer.c
+++ b/gtksourceview/gtksourcebuffer.c
@@ -172,6 +172,8 @@ typedef struct
GtkTextMark *tmp_insert_mark;
GtkTextMark *tmp_selection_bound_mark;
+ GtkTextTag *snippet_focus_tag;
+
GList *search_contexts;
GtkTextTag *invalid_char_tag;
@@ -256,10 +258,18 @@ gtk_source_buffer_tag_added_cb (GtkTextTagTable *table,
GtkTextTag *tag,
GtkSourceBuffer *buffer)
{
+ GtkSourceBufferPrivate *priv = gtk_source_buffer_get_instance_private (buffer);
+
if (GTK_SOURCE_IS_TAG (tag))
{
gtk_source_buffer_check_tag_for_spaces (buffer, GTK_SOURCE_TAG (tag));
}
+
+ if (priv->snippet_focus_tag != NULL)
+ {
+ gtk_text_tag_set_priority (priv->snippet_focus_tag,
+ gtk_text_tag_table_get_size (table) - 1);
+ }
}
static void
@@ -654,6 +664,42 @@ gtk_source_buffer_new_with_language (GtkSourceLanguage *language)
NULL);
}
+static void
+update_snippet_focus_style (GtkSourceBuffer *buffer)
+{
+ GtkSourceBufferPrivate *priv = gtk_source_buffer_get_instance_private (buffer);
+ GtkSourceStyle *style = NULL;
+
+ if (priv->snippet_focus_tag == NULL)
+ {
+ return;
+ }
+
+ if (priv->style_scheme != NULL)
+ {
+ style = _gtk_source_style_scheme_get_snippet_focus_style (priv->style_scheme);
+ }
+
+ gtk_source_style_apply (style, priv->snippet_focus_tag);
+}
+
+GtkTextTag *
+_gtk_source_buffer_get_snippet_focus_tag (GtkSourceBuffer *buffer)
+{
+ GtkSourceBufferPrivate *priv = gtk_source_buffer_get_instance_private (buffer);
+
+ if (priv->snippet_focus_tag == NULL)
+ {
+ priv->snippet_focus_tag =
+ gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer),
+ NULL,
+ NULL);
+ update_snippet_focus_style (buffer);
+ }
+
+ return priv->snippet_focus_tag;
+}
+
static void
update_bracket_match_style (GtkSourceBuffer *buffer)
{
diff --git a/gtksourceview/gtksourcemarshalers.list b/gtksourceview/gtksourcemarshalers.list
index 2236f2b8..98df9a87 100644
--- a/gtksourceview/gtksourcemarshalers.list
+++ b/gtksourceview/gtksourcemarshalers.list
@@ -10,4 +10,5 @@ VOID:BOXED,BOXED,UINT,FLAGS,INT
VOID:BOXED,ENUM
VOID:BOXED,INT
VOID:ENUM,INT
+VOID:OBJECT,BOXED
VOID:OBJECT,UINT
diff --git a/gtksourceview/gtksourcesnippet-private.h b/gtksourceview/gtksourcesnippet-private.h
new file mode 100644
index 00000000..19f3981e
--- /dev/null
+++ b/gtksourceview/gtksourcesnippet-private.h
@@ -0,0 +1,75 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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/>.
+ */
+
+ #pragma once
+
+ #include "gtksourcesnippet.h"
+
+ G_BEGIN_DECLS
+
+G_GNUC_INTERNAL
+void _gtk_source_snippet_replace_current_chunk_text (GtkSourceSnippet *self,
+ const gchar *new_text);
+G_GNUC_INTERNAL
+gchar *_gtk_source_snippet_get_edited_text (GtkSourceSnippet *self);
+G_GNUC_INTERNAL
+void _gtk_source_snippet_pause (GtkSourceSnippet *self);
+G_GNUC_INTERNAL
+void _gtk_source_snippet_unpause (GtkSourceSnippet *self);
+G_GNUC_INTERNAL
+gboolean _gtk_source_snippet_begin (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *iter);
+G_GNUC_INTERNAL
+void _gtk_source_snippet_finish (GtkSourceSnippet *self);
+G_GNUC_INTERNAL
+gboolean _gtk_source_snippet_move_next (GtkSourceSnippet *self);
+G_GNUC_INTERNAL
+gboolean _gtk_source_snippet_move_previous (GtkSourceSnippet *self);
+G_GNUC_INTERNAL
+void _gtk_source_snippet_before_insert_text (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gchar *text,
+ gint len);
+G_GNUC_INTERNAL
+void _gtk_source_snippet_after_insert_text (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gchar *text,
+ gint len);
+G_GNUC_INTERNAL
+void _gtk_source_snippet_before_delete_range (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *begin,
+ GtkTextIter *end);
+G_GNUC_INTERNAL
+void _gtk_source_snippet_after_delete_range (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *begin,
+ GtkTextIter *end);
+G_GNUC_INTERNAL
+gboolean _gtk_source_snippet_insert_set (GtkSourceSnippet *self,
+ GtkTextMark *mark);
+G_GNUC_INTERNAL
+GtkTextMark *_gtk_source_snippet_get_mark_begin (GtkSourceSnippet *self);
+G_GNUC_INTERNAL
+GtkTextMark *_gtk_source_snippet_get_mark_end (GtkSourceSnippet *self);
+
+G_END_DECLS
diff --git a/gtksourceview/gtksourcesnippet.c b/gtksourceview/gtksourcesnippet.c
new file mode 100644
index 00000000..14edd854
--- /dev/null
+++ b/gtksourceview/gtksourcesnippet.c
@@ -0,0 +1,1326 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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 <glib/gi18n.h>
+
+#include "gtksourcebuffer-private.h"
+#include "gtksourcesnippet-private.h"
+#include "gtksourcesnippetchunk.h"
+#include "gtksourcesnippetcontext.h"
+#include "gtksourcesnippetcontext-private.h"
+
+struct _GtkSourceSnippet
+{
+ GObject parent_instance;
+
+ GtkSourceSnippetContext *context;
+ GtkTextBuffer *buffer;
+ GPtrArray *chunks;
+ GArray *runs;
+
+ GtkTextMark *mark_begin;
+ GtkTextMark *mark_end;
+ gchar *trigger;
+ const gchar *language_id;
+ gchar *description;
+
+ gint focus_position;
+ gint max_focus_position;
+ gint current_chunk;
+
+ guint inserted : 1;
+};
+
+G_DEFINE_TYPE (GtkSourceSnippet, gtk_source_snippet, G_TYPE_OBJECT)
+
+enum {
+ PROP_0,
+ PROP_BUFFER,
+ PROP_DESCRIPTION,
+ PROP_LANGUAGE_ID,
+ PROP_MARK_BEGIN,
+ PROP_MARK_END,
+ PROP_POSITION,
+ PROP_TRIGGER,
+ N_PROPS
+};
+
+static GParamSpec *properties [N_PROPS];
+
+/**
+ * gtk_source_snippet_new:
+ * @trigger: (nullable): the trigger word
+ * @language_id: (nullable): the source language
+ *
+ * Creates a new #GtkSourceSnippet
+ *
+ * Returns: (transfer full): A new #GtkSourceSnippet
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippet *
+gtk_source_snippet_new (const gchar *trigger,
+ const gchar *language_id)
+{
+ g_return_val_if_fail (trigger != NULL, NULL);
+
+ return g_object_new (GTK_SOURCE_TYPE_SNIPPET,
+ "trigger", trigger,
+ "language-id", language_id,
+ NULL);
+}
+
+/**
+ * gtk_source_snippet_copy:
+ * @self: a #GtkSourceSnippet
+ *
+ * Does a deep copy of the snippet.
+ *
+ * Returns: (transfer full): A new #GtkSourceSnippet
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippet *
+gtk_source_snippet_copy (GtkSourceSnippet *self)
+{
+ GtkSourceSnippet *ret;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ ret = g_object_new (GTK_SOURCE_TYPE_SNIPPET,
+ "trigger", self->trigger,
+ "language-id", self->language_id,
+ "description", self->description,
+ NULL);
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *old_chunk;
+ GtkSourceSnippetChunk *new_chunk;
+
+ old_chunk = g_ptr_array_index (self->chunks, i);
+ new_chunk = gtk_source_snippet_chunk_copy (old_chunk);
+ gtk_source_snippet_add_chunk (ret, new_chunk);
+ g_object_unref (new_chunk);
+ }
+
+ return g_steal_pointer (&ret);
+}
+
+/**
+ * gtk_source_snippet_get_focus_position:
+ * @self: a #GtkSourceSnippet
+ *
+ * Gets the current focus for the snippet. This is changed
+ * as the user tabs through focus locations.
+ *
+ * Returns: The focus position, or -1 if unset.
+ *
+ * Since: 5.0
+ */
+gint
+gtk_source_snippet_get_focus_position (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), -1);
+
+ return self->focus_position;
+}
+
+/**
+ * gtk_source_snippet_get_n_chunks:
+ * @self: a #GtkSourceSnippet
+ *
+ * Gets the number of chunks in the snippet.
+ *
+ * Note that not all chunks are editable.
+ *
+ * Returns: The number of chunks.
+ *
+ * Since: 5.0
+ */
+guint
+gtk_source_snippet_get_n_chunks (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), 0);
+
+ return self->chunks->len;
+}
+
+/**
+ * gtk_source_snippet_get_nth_chunk:
+ * @self: a #GtkSourceSnippet
+ * @nth: the nth chunk to get
+ *
+ * Gets the chunk at @nth.
+ *
+ * Returns: (transfer none): an #GtkSourceSnippetChunk
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippetChunk *
+gtk_source_snippet_get_nth_chunk (GtkSourceSnippet *self,
+ guint nth)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), 0);
+
+ if (nth < self->chunks->len)
+ return g_ptr_array_index (self->chunks, nth);
+
+ return NULL;
+}
+
+/**
+ * gtk_source_snippet_get_trigger:
+ * @self: a #GtkSourceSnippet
+ *
+ * Gets the trigger for the source snippet. A trigger is
+ * a word that can be expanded into the full snippet when
+ * the user presses Tab.
+ *
+ * Returns: (nullable): A string or %NULL
+ *
+ * Since: 5.0
+ */
+const gchar *
+gtk_source_snippet_get_trigger (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ return self->trigger;
+}
+
+/**
+ * gtk_source_snippet_set_trigger:
+ * @self: a #GtkSourceSnippet
+ * @trigger: the trigger word
+ *
+ * Sets the trigger for the snippet.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_snippet_set_trigger (GtkSourceSnippet *self,
+ const gchar *trigger)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+ if (g_strcmp0 (trigger, self->trigger) != 0)
+ {
+ g_free (self->trigger);
+ self->trigger = g_strdup (trigger);
+ g_object_notify_by_pspec (G_OBJECT (self),
+ properties [PROP_TRIGGER]);
+ }
+}
+
+/**
+ * gtk_source_snippet_get_language_id:
+ * @self: a #GtkSourceSnippet
+ *
+ * Gets the language-id used for the source snippet.
+ *
+ * The language identifier should be one that matches a
+ * source language #GtkSourceLanguage:id property.
+ *
+ * Returns: the language identifier
+ *
+ * Since: 5.0
+ */
+const gchar *
+gtk_source_snippet_get_language_id (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ return self->language_id;
+}
+
+/**
+ * gtk_source_snippet_set_language_id:
+ * @self: a #GtkSourceSnippet
+ * @language_id: the language identifier for the snippet
+ *
+ * Sets the language identifier for the snippet.
+ *
+ * This should match the #GtkSourceLanguage:id identifier.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_snippet_set_language_id (GtkSourceSnippet *self,
+ const gchar *language_id)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+ language_id = g_intern_string (language_id);
+
+ if (language_id != self->language_id)
+ {
+ self->language_id = language_id;
+ g_object_notify_by_pspec (G_OBJECT (self),
+ properties [PROP_LANGUAGE_ID]);
+ }
+}
+
+/**
+ * gtk_source_snippet_get_description:
+ * @self: a #GtkSourceSnippet
+ *
+ * Gets the description for the snippet.
+ *
+ * Since: 5.0
+ */
+const gchar *
+gtk_source_snippet_get_description (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ return self->description;
+}
+
+/**
+ * gtk_source_snippet_set_description:
+ * @self: a #GtkSourceSnippet
+ * @description: the snippet description
+ *
+ * Sets the description for the snippet.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_snippet_set_description (GtkSourceSnippet *self,
+ const gchar *description)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+ if (g_strcmp0 (description, self->description) != 0)
+ {
+ g_free (self->description);
+ self->description = g_strdup (description);
+ g_object_notify_by_pspec (G_OBJECT (self),
+ properties [PROP_DESCRIPTION]);
+ }
+}
+
+static gint
+gtk_source_snippet_get_offset (GtkSourceSnippet *self,
+ GtkTextIter *iter)
+{
+ GtkTextIter begin;
+ gint ret;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), 0);
+ g_return_val_if_fail (iter, 0);
+
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &begin, self->mark_begin);
+ ret = gtk_text_iter_get_offset (iter) - gtk_text_iter_get_offset (&begin);
+ ret = MAX (0, ret);
+
+ return ret;
+}
+
+static gint
+gtk_source_snippet_get_index (GtkSourceSnippet *self,
+ GtkTextIter *iter)
+{
+ gint offset;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), 0);
+ g_return_val_if_fail (iter, 0);
+
+ offset = gtk_source_snippet_get_offset (self, iter);
+
+ for (guint i = 0; i < self->runs->len; i++)
+ {
+ gint run = g_array_index (self->runs, gint, i);
+
+ offset -= run;
+
+ if (offset <= 0)
+ {
+ /*
+ * NOTE:
+ *
+ * This is the central part of the hack by using offsets
+ * instead of textmarks (which gives us lots of gravity grief).
+ * We guess which snippet it is based on the current chunk.
+ */
+ if (self->current_chunk > -1 && (i + 1) == (guint)self->current_chunk)
+ return i + 1;
+ else
+ return i;
+ }
+ }
+
+ return (self->runs->len - 1);
+}
+
+static gboolean
+gtk_source_snippet_within_bounds (GtkSourceSnippet *self,
+ GtkTextIter *iter)
+{
+ GtkTextIter begin;
+ GtkTextIter end;
+ gboolean ret;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), FALSE);
+ g_return_val_if_fail (iter, FALSE);
+
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &begin, self->mark_begin);
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &end, self->mark_end);
+
+ ret = ((gtk_text_iter_compare (&begin, iter) <= 0) &&
+ (gtk_text_iter_compare (&end, iter) >= 0));
+
+ return ret;
+}
+
+gboolean
+_gtk_source_snippet_insert_set (GtkSourceSnippet *self,
+ GtkTextMark *mark)
+{
+ GtkTextIter iter;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), FALSE);
+ g_return_val_if_fail (GTK_IS_TEXT_MARK (mark), FALSE);
+
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &iter, mark);
+
+ if (!gtk_source_snippet_within_bounds (self, &iter))
+ {
+ return FALSE;
+ }
+
+ self->current_chunk = gtk_source_snippet_get_index (self, &iter);
+
+ return TRUE;
+}
+
+static void
+gtk_source_snippet_get_nth_chunk_range (GtkSourceSnippet *self,
+ gint nth,
+ GtkTextIter *begin,
+ GtkTextIter *end)
+{
+ gint run;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (nth >= 0);
+ g_return_if_fail (begin);
+ g_return_if_fail (end);
+
+ gtk_text_buffer_get_iter_at_mark (self->buffer, begin, self->mark_begin);
+
+ for (guint i = 0; i < nth; i++)
+ {
+ run = g_array_index (self->runs, gint, i);
+ gtk_text_iter_forward_chars (begin, run);
+ }
+
+ gtk_text_iter_assign (end, begin);
+ run = g_array_index (self->runs, gint, nth);
+ gtk_text_iter_forward_chars (end, run);
+}
+
+static void
+gtk_source_snippet_get_chunk_range (GtkSourceSnippet *self,
+ GtkSourceSnippetChunk *chunk,
+ GtkTextIter *begin,
+ GtkTextIter *end)
+{
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *item;
+
+ item = g_ptr_array_index (self->chunks, i);
+
+ if (item == chunk)
+ {
+ gtk_source_snippet_get_nth_chunk_range (self, i, begin, end);
+ return;
+ }
+ }
+
+ g_warn_if_reached ();
+}
+
+static void
+gtk_source_snippet_select_chunk (GtkSourceSnippet *self,
+ gint nth)
+{
+ GtkTextIter begin;
+ GtkTextIter end;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (nth >= 0);
+ g_return_if_fail ((guint)nth < self->runs->len);
+
+ gtk_source_snippet_get_nth_chunk_range (self, nth, &begin, &end);
+ gtk_text_iter_order (&begin, &end);
+
+ g_debug ("Selecting chunk %d with range %d:%d to %d:%d (offset %d+%d)",
+ nth,
+ gtk_text_iter_get_line (&begin) + 1,
+ gtk_text_iter_get_line_offset (&begin) + 1,
+ gtk_text_iter_get_line (&end) + 1,
+ gtk_text_iter_get_line_offset (&end) + 1,
+ gtk_text_iter_get_offset (&begin),
+ gtk_text_iter_get_offset (&end) - gtk_text_iter_get_offset (&begin));
+
+ gtk_text_buffer_select_range (self->buffer, &begin, &end);
+ self->current_chunk = nth;
+
+#ifndef G_DISABLE_ASSERT
+ {
+ GtkTextIter set_begin;
+ GtkTextIter set_end;
+
+ gtk_text_buffer_get_selection_bounds (self->buffer, &set_begin, &set_end);
+
+ g_assert (gtk_text_iter_equal (&set_begin, &begin));
+ g_assert (gtk_text_iter_equal (&set_end, &end));
+ }
+#endif
+}
+
+gboolean
+_gtk_source_snippet_move_next (GtkSourceSnippet *self)
+{
+ GtkTextIter iter;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), FALSE);
+
+ if (self->focus_position > self->max_focus_position)
+ {
+ return FALSE;
+ }
+
+ self->focus_position++;
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *chunk = g_ptr_array_index (self->chunks, i);
+
+ if (gtk_source_snippet_chunk_get_focus_position (chunk) == self->focus_position)
+ {
+ gtk_source_snippet_select_chunk (self, i);
+ return TRUE;
+ }
+ }
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *chunk = g_ptr_array_index (self->chunks, i);
+
+ if (gtk_source_snippet_chunk_get_focus_position (chunk) == 0)
+ {
+ gtk_source_snippet_select_chunk (self, i);
+ return FALSE;
+ }
+ }
+
+ g_debug ("No more tab stops, moving to end of snippet");
+
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &iter, self->mark_end);
+ gtk_text_buffer_select_range (self->buffer, &iter, &iter);
+ self->current_chunk = self->chunks->len - 1;
+
+ return FALSE;
+}
+
+gboolean
+_gtk_source_snippet_move_previous (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), FALSE);
+
+ if (self->focus_position == 1)
+ {
+ GtkTextIter iter;
+
+ /* Nothing to select before this position, just move
+ * the insertion mark to the beginning of the snippet.
+ */
+ gtk_text_buffer_get_iter_at_mark (self->buffer,
+ &iter,
+ self->mark_begin);
+ gtk_text_buffer_select_range (self->buffer, &iter, &iter);
+
+ return FALSE;
+ }
+
+ self->focus_position = MAX (1, self->focus_position - 1);
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *chunk = g_ptr_array_index (self->chunks, i);
+
+ if (gtk_source_snippet_chunk_get_focus_position (chunk) == self->focus_position)
+ {
+ gtk_source_snippet_select_chunk (self, i);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static void
+gtk_source_snippet_update_context (GtkSourceSnippet *self)
+{
+ GtkSourceSnippetContext *context;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+ if (self->chunks == NULL || self->chunks->len == 0)
+ {
+ return;
+ }
+
+ context = gtk_source_snippet_get_context (self);
+
+ _gtk_source_snippet_context_emit_changed (context);
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *chunk = g_ptr_array_index (self->chunks, i);
+ gint focus_position;
+
+ g_assert (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+
+ focus_position = gtk_source_snippet_chunk_get_focus_position (chunk);
+
+ if (focus_position > 0)
+ {
+ const gchar *text;
+
+ if ((text = gtk_source_snippet_chunk_get_text (chunk)))
+ {
+ gchar key[12];
+
+ g_snprintf (key, sizeof key, "%d", focus_position);
+ key[sizeof key - 1] = '\0';
+
+ gtk_source_snippet_context_set_variable (context, key, text);
+ }
+ }
+ }
+
+ _gtk_source_snippet_context_emit_changed (context);
+}
+
+static void
+gtk_source_snippet_clear_tags (GtkSourceSnippet *self)
+{
+ g_assert (GTK_SOURCE_IS_SNIPPET (self));
+
+ if (self->mark_begin != NULL && self->mark_end != NULL)
+ {
+ GtkTextBuffer *buffer;
+ GtkTextIter begin;
+ GtkTextIter end;
+ GtkTextTag *tag;
+
+ buffer = gtk_text_mark_get_buffer (self->mark_begin);
+
+ gtk_text_buffer_get_iter_at_mark (buffer, &begin, self->mark_begin);
+ gtk_text_buffer_get_iter_at_mark (buffer, &end, self->mark_end);
+
+ tag = _gtk_source_buffer_get_snippet_focus_tag (GTK_SOURCE_BUFFER (buffer));
+
+ gtk_text_buffer_remove_tag (buffer, tag, &begin, &end);
+ }
+}
+
+static void
+gtk_source_snippet_update_tags (GtkSourceSnippet *self)
+{
+ GtkTextBuffer *buffer;
+ GtkTextTag *tag;
+
+ g_assert (GTK_SOURCE_IS_SNIPPET (self));
+
+ gtk_source_snippet_clear_tags (self);
+
+ buffer = gtk_text_mark_get_buffer (self->mark_begin);
+ tag = _gtk_source_buffer_get_snippet_focus_tag (GTK_SOURCE_BUFFER (buffer));
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *chunk = g_ptr_array_index (self->chunks, i);
+ gint focus_position = gtk_source_snippet_chunk_get_focus_position (chunk);
+
+ if (focus_position >= 0)
+ {
+ GtkTextIter begin;
+ GtkTextIter end;
+
+ gtk_source_snippet_get_chunk_range (self, chunk, &begin, &end);
+ gtk_text_buffer_apply_tag (buffer, tag, &begin, &end);
+ }
+ }
+}
+
+gboolean
+_gtk_source_snippet_begin (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *iter)
+{
+ GtkSourceSnippetContext *context;
+ GtkTextMark *mark;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), FALSE);
+ g_return_val_if_fail (!self->buffer, FALSE);
+ g_return_val_if_fail (!self->mark_begin, FALSE);
+ g_return_val_if_fail (!self->mark_end, FALSE);
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
+ g_return_val_if_fail (iter, FALSE);
+
+ self->inserted = TRUE;
+
+ context = gtk_source_snippet_get_context (self);
+
+ gtk_source_snippet_update_context (self);
+ _gtk_source_snippet_context_emit_changed (context);
+ gtk_source_snippet_update_context (self);
+
+ self->buffer = g_object_ref (buffer);
+
+ mark = gtk_text_buffer_create_mark (buffer, NULL, iter, TRUE);
+ self->mark_begin = g_object_ref (mark);
+
+ gtk_text_buffer_begin_user_action (buffer);
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *chunk;
+ const gchar *text;
+
+ chunk = g_ptr_array_index (self->chunks, i);
+ text = gtk_source_snippet_chunk_get_text (chunk);
+
+ if (text != NULL)
+ {
+ gint len;
+
+ len = g_utf8_strlen (text, -1);
+ g_array_append_val (self->runs, len);
+ gtk_text_buffer_insert (buffer, iter, text, -1);
+ }
+ }
+
+ mark = gtk_text_buffer_create_mark (buffer, NULL, iter, FALSE);
+ self->mark_end = g_object_ref (mark);
+
+ gtk_text_buffer_end_user_action (buffer);
+
+ gtk_source_snippet_update_tags (self);
+
+ return _gtk_source_snippet_move_next (self);
+}
+
+void
+_gtk_source_snippet_finish (GtkSourceSnippet *self)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+ gtk_source_snippet_clear_tags (self);
+
+ g_clear_object (&self->mark_begin);
+ g_clear_object (&self->mark_end);
+ g_clear_object (&self->buffer);
+}
+
+void
+gtk_source_snippet_add_chunk (GtkSourceSnippet *self,
+ GtkSourceSnippetChunk *chunk)
+{
+ gint focus_position;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+ g_return_if_fail (!self->inserted);
+
+ g_ptr_array_add (self->chunks, g_object_ref (chunk));
+
+ gtk_source_snippet_chunk_set_context (chunk, self->context);
+
+ focus_position = gtk_source_snippet_chunk_get_focus_position (chunk);
+ self->max_focus_position = MAX (self->max_focus_position, focus_position);
+}
+
+static gchar *
+gtk_source_snippet_get_nth_text (GtkSourceSnippet *self,
+ gint nth)
+{
+ GtkTextIter iter;
+ GtkTextIter end;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+ g_return_val_if_fail (nth >= 0, NULL);
+
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &iter, self->mark_begin);
+
+ for (gint i = 0; i < nth; i++)
+ {
+ gtk_text_iter_forward_chars (&iter, g_array_index (self->runs, gint, i));
+ }
+
+ gtk_text_iter_assign (&end, &iter);
+ gtk_text_iter_forward_chars (&end, g_array_index (self->runs, gint, nth));
+
+ return gtk_text_buffer_get_text (self->buffer, &iter, &end, TRUE);
+}
+
+static void
+gtk_source_snippet_replace_chunk_text (GtkSourceSnippet *self,
+ gint nth,
+ const gchar *text)
+{
+ GtkTextIter begin;
+ GtkTextIter end;
+ gint diff = 0;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (nth >= 0);
+ g_return_if_fail (text);
+
+ /*
+ * This replaces the text for the snippet. We insert new text before
+ * we delete the old text to ensure things are more stable as we
+ * manipulate the runs. Avoiding zero-length runs, even temporarily
+ * can be helpful.
+ */
+
+ gtk_source_snippet_get_nth_chunk_range (self, nth, &begin, &end);
+
+ if (!gtk_text_iter_equal (&begin, &end))
+ {
+ gtk_text_iter_order (&begin, &end);
+ diff = gtk_text_iter_get_offset (&end) - gtk_text_iter_get_offset (&begin);
+ }
+
+ g_array_index (self->runs, gint, nth) += g_utf8_strlen (text, -1);
+ gtk_text_buffer_insert (self->buffer, &begin, text, -1);
+
+ /* At this point, begin should be updated to the end of where we inserted
+ * our new text. If `diff` is non-zero, then we need to remove those
+ * characters immediately after `begin`.
+ */
+ if (diff != 0)
+ {
+ end = begin;
+ gtk_text_iter_forward_chars (&end, diff);
+ g_array_index (self->runs, gint, nth) -= diff;
+ gtk_text_buffer_delete (self->buffer, &begin, &end);
+ }
+}
+
+static void
+gtk_source_snippet_rewrite_updated_chunks (GtkSourceSnippet *self)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ GtkSourceSnippetChunk *chunk = g_ptr_array_index (self->chunks, i);
+ const gchar *text;
+ gchar *real_text;
+
+ text = gtk_source_snippet_chunk_get_text (chunk);
+ real_text = gtk_source_snippet_get_nth_text (self, i);
+
+ if (g_strcmp0 (text, real_text) != 0)
+ {
+ gtk_source_snippet_replace_chunk_text (self, i, text);
+ }
+
+ g_free (real_text);
+ }
+}
+
+void
+_gtk_source_snippet_before_insert_text (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gchar *text,
+ gint len)
+{
+ gint utf8_len;
+ gint n;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (self->current_chunk >= 0);
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+ g_return_if_fail (iter);
+
+ n = gtk_source_snippet_get_index (self, iter);
+ utf8_len = g_utf8_strlen (text, len);
+ g_array_index (self->runs, gint, n) += utf8_len;
+
+#if 0
+ g_print ("I: ");
+ for (n = 0; n < self->runs->len; n++)
+ g_print ("%d ", g_array_index (self->runs, gint, n));
+ g_print ("\n");
+#endif
+}
+
+void
+_gtk_source_snippet_after_insert_text (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gchar *text,
+ gint len)
+{
+ GtkSourceSnippetChunk *chunk;
+ GtkTextMark *here;
+ gchar *new_text;
+ gint n;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (self->current_chunk >= 0);
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+ g_return_if_fail (iter);
+
+ n = gtk_source_snippet_get_index (self, iter);
+ chunk = g_ptr_array_index (self->chunks, n);
+ new_text = gtk_source_snippet_get_nth_text (self, n);
+ gtk_source_snippet_chunk_set_text (chunk, new_text);
+ gtk_source_snippet_chunk_set_text_set (chunk, TRUE);
+ g_free (new_text);
+
+ here = gtk_text_buffer_create_mark (buffer, NULL, iter, TRUE);
+
+ gtk_source_snippet_update_context (self);
+ gtk_source_snippet_update_context (self);
+ gtk_source_snippet_rewrite_updated_chunks (self);
+
+ gtk_text_buffer_get_iter_at_mark (buffer, iter, here);
+ gtk_text_buffer_delete_mark (buffer, here);
+
+ gtk_source_snippet_update_tags (self);
+}
+
+void
+_gtk_source_snippet_before_delete_range (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *begin,
+ GtkTextIter *end)
+{
+ gint *run;
+ gint len;
+ gint n;
+ gint lower_bound = -1;
+ gint upper_bound = -1;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+ g_return_if_fail (begin);
+ g_return_if_fail (end);
+
+ len = gtk_text_iter_get_offset (end) - gtk_text_iter_get_offset (begin);
+ n = gtk_source_snippet_get_index (self, begin);
+
+ if (n < 0)
+ {
+ return;
+ }
+
+ self->current_chunk = n;
+
+ while (len != 0 && (guint)n < self->runs->len)
+ {
+ if (lower_bound == -1 || n < lower_bound)
+ {
+ lower_bound = n;
+ }
+
+ if (n > upper_bound)
+ {
+ upper_bound = n;
+ }
+
+ run = &g_array_index (self->runs, gint, n);
+
+ if (len > *run)
+ {
+ len -= *run;
+ *run = 0;
+ n++;
+ continue;
+ }
+
+ *run -= len;
+
+ break;
+ }
+
+ if (lower_bound == -1 || upper_bound == -1)
+ {
+ return;
+ }
+
+ for (gint i = lower_bound; i <= upper_bound; i++)
+ {
+ GtkSourceSnippetChunk *chunk = g_ptr_array_index (self->chunks, i);
+ gchar *new_text;
+
+ new_text = gtk_source_snippet_get_nth_text (self, i);
+ gtk_source_snippet_chunk_set_text (chunk, new_text);
+ gtk_source_snippet_chunk_set_text_set (chunk, TRUE);
+ g_free (new_text);
+ }
+
+#if 0
+ g_print ("D: ");
+ for (n = 0; n < self->runs->len; n++)
+ g_print ("%d ", g_array_index (self->runs, gint, n));
+ g_print ("\n");
+#endif
+}
+
+void
+_gtk_source_snippet_after_delete_range (GtkSourceSnippet *self,
+ GtkTextBuffer *buffer,
+ GtkTextIter *begin,
+ GtkTextIter *end)
+{
+ GtkTextMark *here;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+ g_return_if_fail (begin);
+ g_return_if_fail (end);
+
+ here = gtk_text_buffer_create_mark (buffer, NULL, begin, TRUE);
+
+ gtk_source_snippet_update_context (self);
+ gtk_source_snippet_update_context (self);
+ gtk_source_snippet_rewrite_updated_chunks (self);
+
+ gtk_text_buffer_get_iter_at_mark (buffer, begin, here);
+ gtk_text_buffer_get_iter_at_mark (buffer, end, here);
+ gtk_text_buffer_delete_mark (buffer, here);
+
+ gtk_source_snippet_update_tags (self);
+}
+
+GtkTextMark *
+_gtk_source_snippet_get_mark_begin (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ return self->mark_begin;
+}
+
+GtkTextMark *
+_gtk_source_snippet_get_mark_end (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ return self->mark_end;
+}
+
+/**
+ * gtk_source_snippet_get_context:
+ * @self: an #GtkSourceSnippet
+ *
+ * Get's the context used for expanding the snippet.
+ *
+ * Returns: (nullable) (transfer none): an #GtkSourceSnippetContext
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippetContext *
+gtk_source_snippet_get_context (GtkSourceSnippet *self)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ if (self->context == NULL)
+ {
+ GtkSourceSnippetChunk *chunk;
+
+ self->context = gtk_source_snippet_context_new ();
+
+ for (guint i = 0; i < self->chunks->len; i++)
+ {
+ chunk = g_ptr_array_index (self->chunks, i);
+ gtk_source_snippet_chunk_set_context (chunk, self->context);
+ }
+ }
+
+ return self->context;
+}
+
+static void
+gtk_source_snippet_dispose (GObject *object)
+{
+ GtkSourceSnippet *self = (GtkSourceSnippet *)object;
+
+ if (self->mark_begin != NULL)
+ {
+ gtk_text_buffer_delete_mark (self->buffer, self->mark_begin);
+ g_clear_object (&self->mark_begin);
+ }
+
+ if (self->mark_end != NULL)
+ {
+ gtk_text_buffer_delete_mark (self->buffer, self->mark_end);
+ g_clear_object (&self->mark_end);
+ }
+
+ g_clear_pointer (&self->runs, g_array_unref);
+ g_clear_pointer (&self->chunks, g_ptr_array_unref);
+
+ g_clear_object (&self->buffer);
+ g_clear_object (&self->context);
+
+ G_OBJECT_CLASS (gtk_source_snippet_parent_class)->dispose (object);
+}
+
+static void
+gtk_source_snippet_finalize (GObject *object)
+{
+ GtkSourceSnippet *self = (GtkSourceSnippet *)object;
+
+ g_clear_pointer (&self->description, g_free);
+ g_clear_pointer (&self->trigger, g_free);
+ g_clear_object (&self->buffer);
+
+ G_OBJECT_CLASS (gtk_source_snippet_parent_class)->finalize (object);
+}
+
+static void
+gtk_source_snippet_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkSourceSnippet *self = GTK_SOURCE_SNIPPET (object);
+
+ switch (prop_id)
+ {
+ case PROP_BUFFER:
+ g_value_set_object (value, self->buffer);
+ break;
+
+ case PROP_MARK_BEGIN:
+ g_value_set_object (value, self->mark_begin);
+ break;
+
+ case PROP_MARK_END:
+ g_value_set_object (value, self->mark_end);
+ break;
+
+ case PROP_TRIGGER:
+ g_value_set_string (value, self->trigger);
+ break;
+
+ case PROP_LANGUAGE_ID:
+ g_value_set_string (value, self->language_id);
+ break;
+
+ case PROP_DESCRIPTION:
+ g_value_set_string (value, self->description);
+ break;
+
+ case PROP_POSITION:
+ g_value_set_uint (value, self->focus_position);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_source_snippet_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkSourceSnippet *self = GTK_SOURCE_SNIPPET (object);
+
+ switch (prop_id)
+ {
+ case PROP_TRIGGER:
+ gtk_source_snippet_set_trigger (self, g_value_get_string (value));
+ break;
+
+ case PROP_LANGUAGE_ID:
+ gtk_source_snippet_set_language_id (self, g_value_get_string (value));
+ break;
+
+ case PROP_DESCRIPTION:
+ gtk_source_snippet_set_description (self, g_value_get_string (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_source_snippet_class_init (GtkSourceSnippetClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->dispose = gtk_source_snippet_dispose;
+ object_class->finalize = gtk_source_snippet_finalize;
+ object_class->get_property = gtk_source_snippet_get_property;
+ object_class->set_property = gtk_source_snippet_set_property;
+
+ properties[PROP_BUFFER] =
+ g_param_spec_object ("buffer",
+ "Buffer",
+ "The GtkTextBuffer for the snippet",
+ GTK_TYPE_TEXT_BUFFER,
+ (G_PARAM_READABLE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_MARK_BEGIN] =
+ g_param_spec_object ("mark-begin",
+ "Mark Begin",
+ "The beginning text mark",
+ GTK_TYPE_TEXT_MARK,
+ (G_PARAM_READABLE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_MARK_END] =
+ g_param_spec_object ("mark-end",
+ "Mark End",
+ "The ending text mark",
+ GTK_TYPE_TEXT_MARK,
+ (G_PARAM_READABLE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_TRIGGER] =
+ g_param_spec_string ("trigger",
+ "Trigger",
+ "The trigger for the snippet",
+ NULL,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_LANGUAGE_ID] =
+ g_param_spec_string ("language-id",
+ "Language Id",
+ "The language-id for the snippet",
+ NULL,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_DESCRIPTION] =
+ g_param_spec_string ("description",
+ "Description",
+ "The description for the snippet",
+ NULL,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_POSITION] =
+ g_param_spec_int ("position",
+ "Position",
+ "The current position",
+ -1,
+ G_MAXINT,
+ -1,
+ (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+gtk_source_snippet_init (GtkSourceSnippet *self)
+{
+ self->max_focus_position = -1;
+ self->chunks = g_ptr_array_new_with_free_func (g_object_unref);
+ self->runs = g_array_new (FALSE, FALSE, sizeof (gint));
+}
+
+gchar *
+_gtk_source_snippet_get_edited_text (GtkSourceSnippet *self)
+{
+ GtkTextIter begin;
+ GtkTextIter end;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET (self), NULL);
+
+ if (self->mark_begin == NULL || self->mark_end == NULL)
+ {
+ return NULL;
+ }
+
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &begin, self->mark_begin);
+ gtk_text_buffer_get_iter_at_mark (self->buffer, &end, self->mark_end);
+
+ return gtk_text_iter_get_slice (&begin, &end);
+}
+
+void
+_gtk_source_snippet_replace_current_chunk_text (GtkSourceSnippet *self,
+ const gchar *new_text)
+{
+ GtkSourceSnippetChunk *chunk;
+ gint utf8_len;
+
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+ g_return_if_fail (self->chunks != NULL);
+
+ if (self->current_chunk < 0 || self->current_chunk >= self->chunks->len)
+ {
+ return;
+ }
+
+ chunk = g_ptr_array_index (self->chunks, self->current_chunk);
+
+ gtk_source_snippet_chunk_set_text (chunk, new_text);
+ gtk_source_snippet_chunk_set_text_set (chunk, TRUE);
+
+ g_assert (self->current_chunk >= 0);
+ g_assert (self->current_chunk < self->runs->len);
+
+ utf8_len = g_utf8_strlen (new_text, -1);
+ g_array_index (self->runs, gint, self->current_chunk) = utf8_len;
+}
+
+void
+_gtk_source_snippet_pause (GtkSourceSnippet *self)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+}
+
+void
+_gtk_source_snippet_unpause (GtkSourceSnippet *self)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (self));
+
+}
diff --git a/gtksourceview/gtksourcesnippet.h b/gtksourceview/gtksourcesnippet.h
new file mode 100644
index 00000000..85588023
--- /dev/null
+++ b/gtksourceview/gtksourcesnippet.h
@@ -0,0 +1,70 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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/>.
+ */
+
+#pragma once
+
+#if !defined (GTK_SOURCE_H_INSIDE) && !defined (GTK_SOURCE_COMPILATION)
+#error "Only <gtksourceview/gtksource.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+
+#include "gtksourcetypes.h"
+
+G_BEGIN_DECLS
+
+#define GTK_SOURCE_TYPE_SNIPPET (gtk_source_snippet_get_type())
+
+GTK_SOURCE_AVAILABLE_IN_ALL
+G_DECLARE_FINAL_TYPE (GtkSourceSnippet, gtk_source_snippet, GTK_SOURCE, SNIPPET, GObject)
+
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippet *gtk_source_snippet_new (const gchar *trigger,
+ const gchar *language_id);
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippet *gtk_source_snippet_copy (GtkSourceSnippet *self);
+GTK_SOURCE_AVAILABLE_IN_5_0
+const gchar *gtk_source_snippet_get_trigger (GtkSourceSnippet *self);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_set_trigger (GtkSourceSnippet *self,
+ const gchar *trigger);
+GTK_SOURCE_AVAILABLE_IN_5_0
+const gchar *gtk_source_snippet_get_language_id (GtkSourceSnippet *self);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_set_language_id (GtkSourceSnippet *self,
+ const gchar *language_id);
+GTK_SOURCE_AVAILABLE_IN_5_0
+const gchar *gtk_source_snippet_get_description (GtkSourceSnippet *self);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_set_description (GtkSourceSnippet *self,
+ const gchar *description);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_add_chunk (GtkSourceSnippet *self,
+ GtkSourceSnippetChunk *chunk);
+GTK_SOURCE_AVAILABLE_IN_5_0
+guint gtk_source_snippet_get_n_chunks (GtkSourceSnippet *self);
+GTK_SOURCE_AVAILABLE_IN_5_0
+gint gtk_source_snippet_get_focus_position (GtkSourceSnippet *self);
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippetChunk *gtk_source_snippet_get_nth_chunk (GtkSourceSnippet *self,
+ guint nth);
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippetContext *gtk_source_snippet_get_context (GtkSourceSnippet *self);
+
+G_END_DECLS
diff --git a/gtksourceview/gtksourcesnippetchunk.c b/gtksourceview/gtksourcesnippetchunk.c
new file mode 100644
index 00000000..738f7a69
--- /dev/null
+++ b/gtksourceview/gtksourcesnippetchunk.c
@@ -0,0 +1,404 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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 "gtksourcesnippetchunk.h"
+#include "gtksourcesnippetcontext.h"
+
+/**
+ * SECTION:snippetchunk
+ * @title: GtkSourceSnippetChunk
+ * @short_description: An chunk of text within the source snippet
+ *
+ * The #GtkSourceSnippetChunk represents a single chunk of text that
+ * may or may not be an edit point within the snippet. Chunks that are
+ * an edit point (also called a tab stop) have the
+ * #GtkSourceSnippetChunk:focus-position property set.
+ *
+ * Since: 5.0
+ */
+
+struct _GtkSourceSnippetChunk
+{
+ GObject parent_instance;
+
+ GtkSourceSnippetContext *context;
+ gchar *spec;
+ gchar *text;
+
+ gulong context_changed_handler;
+
+ gint focus_position;
+
+ guint text_set : 1;
+};
+
+G_DEFINE_TYPE (GtkSourceSnippetChunk, gtk_source_snippet_chunk, G_TYPE_OBJECT)
+
+enum {
+ PROP_0,
+ PROP_CONTEXT,
+ PROP_SPEC,
+ PROP_FOCUS_POSITION,
+ PROP_TEXT,
+ PROP_TEXT_SET,
+ N_PROPS
+};
+
+static GParamSpec *properties[N_PROPS];
+
+/**
+ * gtk_source_snippet_chunk_new:
+ *
+ * Create a new #GtkSourceSnippetChunk that can be added to
+ * a #GtkSourceSnippet.
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippetChunk *
+gtk_source_snippet_chunk_new (void)
+{
+ return g_object_new (GTK_SOURCE_TYPE_SNIPPET_CHUNK, NULL);
+}
+
+/**
+ * gtk_source_snippet_chunk_copy:
+ *
+ * Copies the source snippet.
+ *
+ * Returns: (transfer full): An #GtkSourceSnippetChunk.
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippetChunk *
+gtk_source_snippet_chunk_copy (GtkSourceSnippetChunk *chunk)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk), NULL);
+
+ return g_object_new (GTK_SOURCE_TYPE_SNIPPET_CHUNK,
+ "spec", chunk->spec,
+ "focus-position", chunk->focus_position,
+ NULL);
+}
+
+static void
+on_context_changed (GtkSourceSnippetContext *context,
+ GtkSourceSnippetChunk *chunk)
+{
+ gchar *text;
+
+ g_assert (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+ g_assert (GTK_SOURCE_IS_SNIPPET_CONTEXT (context));
+
+ if (!chunk->text_set)
+ {
+ text = gtk_source_snippet_context_expand (context, chunk->spec);
+ gtk_source_snippet_chunk_set_text (chunk, text);
+ g_free (text);
+ }
+}
+
+/**
+ * gtk_source_snippet_chunk_get_context:
+ *
+ * Gets the context for the snippet insertion.
+ *
+ * Returns: (transfer none): An #GtkSourceSnippetContext.
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippetContext *
+gtk_source_snippet_chunk_get_context (GtkSourceSnippetChunk *chunk)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk), NULL);
+
+ return chunk->context;
+}
+
+void
+gtk_source_snippet_chunk_set_context (GtkSourceSnippetChunk *chunk,
+ GtkSourceSnippetContext *context)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+ g_return_if_fail (!context || GTK_SOURCE_IS_SNIPPET_CONTEXT (context));
+
+ if (context != chunk->context)
+ {
+ g_clear_signal_handler (&chunk->context_changed_handler,
+ chunk->context);
+ g_clear_object (&chunk->context);
+
+ if (context != NULL)
+ {
+ chunk->context = g_object_ref (context);
+ chunk->context_changed_handler =
+ g_signal_connect_object (chunk->context,
+ "changed",
+ G_CALLBACK (on_context_changed),
+ chunk,
+ 0);
+ }
+
+ g_object_notify_by_pspec (G_OBJECT (chunk),
+ properties [PROP_CONTEXT]);
+ }
+}
+
+const gchar *
+gtk_source_snippet_chunk_get_spec (GtkSourceSnippetChunk *chunk)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk), NULL);
+
+ return chunk->spec;
+}
+
+void
+gtk_source_snippet_chunk_set_spec (GtkSourceSnippetChunk *chunk,
+ const gchar *spec)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+
+ if (g_strcmp0 (spec, chunk->spec) != 0)
+ {
+ g_free (chunk->spec);
+ chunk->spec = g_strdup (spec);
+ g_object_notify_by_pspec (G_OBJECT (chunk),
+ properties [PROP_SPEC]);
+ }
+}
+
+gint
+gtk_source_snippet_chunk_get_focus_position (GtkSourceSnippetChunk *chunk)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk), 0);
+
+ return chunk->focus_position;
+}
+
+void
+gtk_source_snippet_chunk_set_focus_position (GtkSourceSnippetChunk *chunk,
+ gint focus_position)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+
+ focus_position = MAX (focus_position, -1);
+
+ if (chunk->focus_position != focus_position)
+ {
+ chunk->focus_position = focus_position;
+ g_object_notify_by_pspec (G_OBJECT (chunk),
+ properties [PROP_FOCUS_POSITION]);
+ }
+}
+
+const gchar *
+gtk_source_snippet_chunk_get_text (GtkSourceSnippetChunk *chunk)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk), NULL);
+
+ return chunk->text ? chunk->text : "";
+}
+
+void
+gtk_source_snippet_chunk_set_text (GtkSourceSnippetChunk *chunk,
+ const gchar *text)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+
+ if (g_strcmp0 (chunk->text, text) != 0)
+ {
+ g_free (chunk->text);
+ chunk->text = g_strdup (text);
+ g_object_notify_by_pspec (G_OBJECT (chunk),
+ properties [PROP_TEXT]);
+ }
+}
+
+gboolean
+gtk_source_snippet_chunk_get_text_set (GtkSourceSnippetChunk *chunk)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk), FALSE);
+
+ return chunk->text_set;
+}
+
+void
+gtk_source_snippet_chunk_set_text_set (GtkSourceSnippetChunk *chunk,
+ gboolean text_set)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CHUNK (chunk));
+
+ text_set = !!text_set;
+
+ if (chunk->text_set != text_set)
+ {
+ chunk->text_set = text_set;
+ g_object_notify_by_pspec (G_OBJECT (chunk),
+ properties [PROP_TEXT_SET]);
+ }
+}
+
+static void
+gtk_source_snippet_chunk_finalize (GObject *object)
+{
+ GtkSourceSnippetChunk *chunk = (GtkSourceSnippetChunk *)object;
+
+ g_clear_pointer (&chunk->spec, g_free);
+ g_clear_pointer (&chunk->text, g_free);
+ g_clear_object (&chunk->context);
+
+ G_OBJECT_CLASS (gtk_source_snippet_chunk_parent_class)->finalize (object);
+}
+
+static void
+gtk_source_snippet_chunk_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkSourceSnippetChunk *chunk = GTK_SOURCE_SNIPPET_CHUNK (object);
+
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ g_value_set_object (value, gtk_source_snippet_chunk_get_context (chunk));
+ break;
+
+ case PROP_SPEC:
+ g_value_set_string (value, gtk_source_snippet_chunk_get_spec (chunk));
+ break;
+
+ case PROP_FOCUS_POSITION:
+ g_value_set_int (value, gtk_source_snippet_chunk_get_focus_position (chunk));
+ break;
+
+ case PROP_TEXT:
+ g_value_set_string (value, gtk_source_snippet_chunk_get_text (chunk));
+ break;
+
+ case PROP_TEXT_SET:
+ g_value_set_boolean (value, gtk_source_snippet_chunk_get_text_set (chunk));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_source_snippet_chunk_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkSourceSnippetChunk *chunk = GTK_SOURCE_SNIPPET_CHUNK (object);
+
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ gtk_source_snippet_chunk_set_context (chunk, g_value_get_object (value));
+ break;
+
+ case PROP_FOCUS_POSITION:
+ gtk_source_snippet_chunk_set_focus_position (chunk, g_value_get_int (value));
+ break;
+
+ case PROP_SPEC:
+ gtk_source_snippet_chunk_set_spec (chunk, g_value_get_string (value));
+ break;
+
+ case PROP_TEXT:
+ gtk_source_snippet_chunk_set_text (chunk, g_value_get_string (value));
+ break;
+
+ case PROP_TEXT_SET:
+ gtk_source_snippet_chunk_set_text_set (chunk, g_value_get_boolean (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gtk_source_snippet_chunk_class_init (GtkSourceSnippetChunkClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = gtk_source_snippet_chunk_finalize;
+ object_class->get_property = gtk_source_snippet_chunk_get_property;
+ object_class->set_property = gtk_source_snippet_chunk_set_property;
+
+ properties[PROP_CONTEXT] =
+ g_param_spec_object ("context",
+ "Context",
+ "The snippet context.",
+ GTK_SOURCE_TYPE_SNIPPET_CONTEXT,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_SPEC] =
+ g_param_spec_string ("spec",
+ "Spec",
+ "The specification to expand using the context.",
+ NULL,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_FOCUS_POSITION] =
+ g_param_spec_int ("focus-position",
+ "Focus Position",
+ "The focus position for the chunk.",
+ -1,
+ G_MAXINT,
+ -1,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_TEXT] =
+ g_param_spec_string ("text",
+ "Text",
+ "The text for the chunk.",
+ NULL,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ properties[PROP_TEXT_SET] =
+ g_param_spec_boolean ("text-set",
+ "If text property is set",
+ "If the text property has been manually set.",
+ FALSE,
+ (G_PARAM_READWRITE |
+ G_PARAM_EXPLICIT_NOTIFY |
+ G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+gtk_source_snippet_chunk_init (GtkSourceSnippetChunk *chunk)
+{
+ chunk->focus_position = -1;
+ chunk->spec = g_strdup ("");
+}
diff --git a/gtksourceview/gtksourcesnippetchunk.h b/gtksourceview/gtksourcesnippetchunk.h
new file mode 100644
index 00000000..460478e8
--- /dev/null
+++ b/gtksourceview/gtksourcesnippetchunk.h
@@ -0,0 +1,67 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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/>.
+ */
+
+#pragma once
+
+#if !defined (GTK_SOURCE_H_INSIDE) && !defined (GTK_SOURCE_COMPILATION)
+#error "Only <gtksourceview/gtksource.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+
+#include "gtksourcetypes.h"
+
+G_BEGIN_DECLS
+
+#define GTK_SOURCE_TYPE_SNIPPET_CHUNK (gtk_source_snippet_chunk_get_type())
+
+GTK_SOURCE_AVAILABLE_IN_5_0
+G_DECLARE_FINAL_TYPE (GtkSourceSnippetChunk, gtk_source_snippet_chunk, GTK_SOURCE, SNIPPET_CHUNK, GObject)
+
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippetChunk *gtk_source_snippet_chunk_new (void);
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippetChunk *gtk_source_snippet_chunk_copy (GtkSourceSnippetChunk *chunk);
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippetContext *gtk_source_snippet_chunk_get_context (GtkSourceSnippetChunk *chunk);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_chunk_set_context (GtkSourceSnippetChunk *chunk,
+ GtkSourceSnippetContext *context);
+GTK_SOURCE_AVAILABLE_IN_5_0
+const gchar *gtk_source_snippet_chunk_get_spec (GtkSourceSnippetChunk *chunk);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_chunk_set_spec (GtkSourceSnippetChunk *chunk,
+ const gchar *spec);
+GTK_SOURCE_AVAILABLE_IN_5_0
+gint gtk_source_snippet_chunk_get_focus_position (GtkSourceSnippetChunk *chunk);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_chunk_set_focus_position (GtkSourceSnippetChunk *chunk,
+ gint position);
+GTK_SOURCE_AVAILABLE_IN_5_0
+const gchar *gtk_source_snippet_chunk_get_text (GtkSourceSnippetChunk *chunk);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_chunk_set_text (GtkSourceSnippetChunk *chunk,
+ const gchar *text);
+GTK_SOURCE_AVAILABLE_IN_5_0
+gboolean gtk_source_snippet_chunk_get_text_set (GtkSourceSnippetChunk *chunk);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_chunk_set_text_set (GtkSourceSnippetChunk *chunk,
+ gboolean text_set);
+
+G_END_DECLS
diff --git a/gtksourceview/gtksourcesnippetcontext-private.h b/gtksourceview/gtksourcesnippetcontext-private.h
new file mode 100644
index 00000000..8fb734ca
--- /dev/null
+++ b/gtksourceview/gtksourcesnippetcontext-private.h
@@ -0,0 +1,29 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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/>.
+ */
+
+#pragma once
+
+#include "gtksourcesnippetcontext.h"
+
+G_BEGIN_DECLS
+
+G_GNUC_INTERNAL
+void _gtk_source_snippet_context_emit_changed (GtkSourceSnippetContext *context);
+
+G_END_DECLS
diff --git a/gtksourceview/gtksourcesnippetcontext.c b/gtksourceview/gtksourcesnippetcontext.c
new file mode 100644
index 00000000..dacd517a
--- /dev/null
+++ b/gtksourceview/gtksourcesnippetcontext.c
@@ -0,0 +1,911 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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 <errno.h>
+#include <glib/gi18n.h>
+#include <stdlib.h>
+
+#include "gtksourcesnippetcontext-private.h"
+
+/**
+ * SECTION:snippetcontext
+ * @title: GtkSourceSnippetContext
+ * @short_description: Context for expanding #GtkSourceSnippetChunk
+ *
+ * This class is currently used primary as a hashtable. However, the longer
+ * term goal is to have it hold onto a GjsContext as well as other languages
+ * so that #GtkSourceSnippetChunk can expand themselves by executing
+ * script within the context.
+ *
+ * The #GtkSourceSnippet will build the context and then expand each of the
+ * chunks during the insertion/edit phase.
+ *
+ * Since: 5.0
+ */
+
+struct _GtkSourceSnippetContext
+{
+ GObject parent_instance;
+
+ GHashTable *constants;
+ GHashTable *variables;
+ gchar *line_prefix;
+ gint tab_width;
+ guint use_spaces : 1;
+};
+
+struct _GtkSourceSnippetContextClass
+{
+ GObjectClass parent;
+};
+
+G_DEFINE_TYPE (GtkSourceSnippetContext, gtk_source_snippet_context, G_TYPE_OBJECT)
+
+enum {
+ CHANGED,
+ N_SIGNALS
+};
+
+typedef gchar *(*InputFilter) (const gchar *input);
+
+static GHashTable *filters;
+static guint signals[N_SIGNALS];
+
+/**
+ * gtk_source_snippet_context_new:
+ *
+ * Creates a new #GtkSourceSnippetContext.
+ *
+ * Generally, this isn't needed unless you are controlling the
+ * expansion of snippets manually.
+ *
+ * Returns: (transfer full): a #GtkSourceSnippetContext
+ *
+ * Since: 5.0
+ */
+GtkSourceSnippetContext *
+gtk_source_snippet_context_new (void)
+{
+ return g_object_new (GTK_SOURCE_TYPE_SNIPPET_CONTEXT, NULL);
+}
+
+/**
+ * gtk_source_snippet_context_clear_variables:
+ * @self: a #GtkSourceSnippetContext
+ *
+ * Removes all variables from the context.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_snippet_context_clear_variables (GtkSourceSnippetContext *self)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self));
+
+ g_hash_table_remove_all (self->variables);
+}
+
+/**
+ * gtk_source_snippet_context_set_variable:
+ * @self: a #GtkSourceSnippetContext
+ * @key: the variable name
+ * @value: the value for the variable
+ *
+ * Sets a variable within the context.
+ *
+ * This variable may be overridden by future updates to the
+ * context.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_snippet_context_set_variable (GtkSourceSnippetContext *self,
+ const gchar *key,
+ const gchar *value)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self));
+ g_return_if_fail (key);
+
+ g_hash_table_replace (self->variables, g_strdup (key), g_strdup (value));
+}
+
+/**
+ * gtk_source_snippet_context_set_constant:
+ * @self: a #GtkSourceSnippetContext
+ * @key: the constant name
+ * @value: the value of the constant
+ *
+ * Sets a constatnt within the context. This is similar to
+ * a variable set with gtk_source_snippet_context_set_variable()
+ * but is expected to not change during use of the snippet.
+ *
+ * Examples would be the date or users name.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_snippet_context_set_constant (GtkSourceSnippetContext *self,
+ const gchar *key,
+ const gchar *value)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self));
+ g_return_if_fail (key);
+
+ g_hash_table_replace (self->constants, g_strdup (key), g_strdup (value));
+}
+
+/**
+ * gtk_source_snippet_context_get_variable:
+ * @self: a #GtkSourceSnippetContext
+ * @key: the name of the variable
+ *
+ * Gets the current value for a variable named @key.
+ *
+ * Returns: (transfer none) (nullable): the value for the variable, or %NULL
+ *
+ * Since: 5.0
+ */
+const gchar *
+gtk_source_snippet_context_get_variable (GtkSourceSnippetContext *self,
+ const gchar *key)
+{
+ const gchar *ret;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self), NULL);
+
+ if (!(ret = g_hash_table_lookup (self->variables, key)))
+ ret = g_hash_table_lookup (self->constants, key);
+
+ return ret;
+}
+
+static gchar *
+filter_lower (const gchar *input)
+{
+ return input != NULL ? g_utf8_strdown (input, -1) : NULL;
+}
+
+static gchar *
+filter_upper (const gchar *input)
+{
+ return input != NULL ? g_utf8_strup (input, -1) : NULL;
+}
+
+static gchar *
+filter_capitalize (const gchar *input)
+{
+ gunichar c;
+ GString *str;
+
+ if (input == NULL)
+ return NULL;
+
+ if (*input == 0)
+ return g_strdup ("");
+
+ c = g_utf8_get_char (input);
+ if (g_unichar_isupper (c))
+ return g_strdup (input);
+
+ str = g_string_new (NULL);
+ input = g_utf8_next_char (input);
+ g_string_append_unichar (str, g_unichar_toupper (c));
+ if (*input)
+ g_string_append (str, input);
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+filter_uncapitalize (const gchar *input)
+{
+ gunichar c;
+ GString *str;
+
+ if (input == NULL)
+ return NULL;
+
+ c = g_utf8_get_char (input);
+ if (g_unichar_islower (c))
+ return g_strdup (input);
+
+ str = g_string_new (NULL);
+ input = g_utf8_next_char (input);
+ g_string_append_unichar (str, g_unichar_tolower (c));
+ g_string_append (str, input);
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+filter_html (const gchar *input)
+{
+ GString *str;
+
+ if (input == NULL)
+ return NULL;
+
+ str = g_string_new (NULL);
+
+ for (; *input; input = g_utf8_next_char (input))
+ {
+ gunichar c = g_utf8_get_char (input);
+
+ switch (c)
+ {
+ case '<':
+ g_string_append_len (str, "<", 4);
+ break;
+
+ case '>':
+ g_string_append_len (str, ">", 4);
+ break;
+
+ case '&':
+ g_string_append_len (str, "&", 5);
+ break;
+
+ default:
+ g_string_append_unichar (str, c);
+ break;
+ }
+ }
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+filter_camelize (const gchar *input)
+{
+ gboolean next_is_upper = TRUE;
+ gboolean skip = FALSE;
+ GString *str;
+
+ if (input == NULL)
+ return NULL;
+
+ if (!strchr (input, '_') && !strchr (input, ' ') && !strchr (input, '-'))
+ return filter_capitalize (input);
+
+ str = g_string_new (NULL);
+
+ for (; *input; input = g_utf8_next_char (input))
+ {
+ gunichar c = g_utf8_get_char (input);
+
+ switch (c)
+ {
+ case '_':
+ case '-':
+ case ' ':
+ next_is_upper = TRUE;
+ skip = TRUE;
+ break;
+
+ default:
+ break;
+ }
+
+ if (skip)
+ {
+ skip = FALSE;
+ continue;
+ }
+
+ if (next_is_upper)
+ {
+ c = g_unichar_toupper (c);
+ next_is_upper = FALSE;
+ }
+ else
+ {
+ c = g_unichar_tolower (c);
+ }
+
+ g_string_append_unichar (str, c);
+ }
+
+ if (g_str_has_suffix (str->str, "Private"))
+ g_string_truncate (str, str->len - strlen ("Private"));
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+filter_functify (const gchar *input)
+{
+ gunichar last = 0;
+ GString *str;
+
+ if (input == NULL)
+ return NULL;
+
+ str = g_string_new (NULL);
+
+ for (; *input; input = g_utf8_next_char (input))
+ {
+ gunichar c = g_utf8_get_char (input);
+ gunichar n = g_utf8_get_char (g_utf8_next_char (input));
+
+ if (last)
+ {
+ if ((g_unichar_islower (last) && g_unichar_isupper (c)) ||
+ (g_unichar_isupper (c) && g_unichar_islower (n)))
+ {
+ g_string_append_c (str, '_');
+ }
+ }
+
+ if ((c == ' ') || (c == '-'))
+ {
+ c = '_';
+ }
+
+ g_string_append_unichar (str, g_unichar_tolower (c));
+
+ last = c;
+ }
+
+ if (g_str_has_suffix (str->str, "_private") ||
+ g_str_has_suffix (str->str, "_PRIVATE"))
+ {
+ g_string_truncate (str, str->len - strlen ("_private"));
+ }
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+filter_namespace (const gchar *input)
+{
+ gunichar last = 0;
+ GString *str;
+ gboolean first_is_lower = FALSE;
+
+ if (input == NULL)
+ return NULL;
+
+ str = g_string_new (NULL);
+
+ for (; *input; input = g_utf8_next_char (input))
+ {
+ gunichar c = g_utf8_get_char (input);
+ gunichar n = g_utf8_get_char (g_utf8_next_char (input));
+
+ if (c == '_')
+ break;
+
+ if (last)
+ {
+ if ((g_unichar_islower (last) && g_unichar_isupper (c)) ||
+ (g_unichar_isupper (c) && g_unichar_islower (n)))
+ break;
+ }
+ else
+ {
+ first_is_lower = g_unichar_islower (c);
+ }
+
+ if ((c == ' ') || (c == '-'))
+ break;
+
+ g_string_append_unichar (str, c);
+
+ last = c;
+ }
+
+ if (first_is_lower)
+ {
+ gchar *ret;
+
+ ret = filter_capitalize (str->str);
+ g_string_free (str, TRUE);
+
+ return g_steal_pointer (&ret);
+ }
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+filter_class (const gchar *input)
+{
+ gchar *camel;
+ gchar *ns;
+ gchar *ret = NULL;
+
+ if (input == NULL)
+ return NULL;
+
+ camel = filter_camelize (input);
+ ns = filter_namespace (input);
+
+ if (g_str_has_prefix (camel, ns))
+ {
+ ret = g_strdup (camel + strlen (ns));
+ }
+ else
+ {
+ ret = camel;
+ camel = NULL;
+ }
+
+ g_free (camel);
+ g_free (ns);
+
+ return ret;
+}
+
+static gchar *
+filter_instance (const gchar *input)
+{
+ const gchar *tmp;
+ gchar *funct = NULL;
+ gchar *ret;
+
+ if (input == NULL)
+ return NULL;
+
+ if (!strchr (input, '_'))
+ {
+ funct = filter_functify (input);
+ input = funct;
+ }
+
+ if ((tmp = strrchr (input, '_')))
+ {
+ ret = g_strdup (tmp+1);
+ }
+ else
+ {
+ ret = g_strdup (input);
+ }
+
+ g_free (funct);
+
+ return g_steal_pointer (&ret);
+}
+
+static gchar *
+filter_space (const gchar *input)
+{
+ GString *str;
+
+ if (input == NULL)
+ return NULL;
+
+ str = g_string_new (NULL);
+ for (; *input; input = g_utf8_next_char (input))
+ g_string_append_c (str, ' ');
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+filter_descend_path (const gchar *input)
+{
+ const gchar *pos;
+
+ if (input == NULL)
+ return NULL;
+
+ while (*input == G_DIR_SEPARATOR)
+ {
+ input++;
+ }
+
+ if ((pos = strchr (input, G_DIR_SEPARATOR)))
+ {
+ return g_strdup (pos + 1);
+ }
+
+ return NULL;
+}
+
+static gchar *
+filter_stripsuffix (const gchar *input)
+{
+ const gchar *endpos;
+
+ if (input == NULL)
+ return NULL;
+
+ endpos = strrchr (input, '.');
+
+ if (endpos != NULL)
+ {
+ return g_strndup (input, (endpos - input));
+ }
+
+ return g_strdup (input);
+}
+
+static gchar *
+filter_slash_to_dots (const gchar *input)
+{
+ GString *str;
+
+ if (input == NULL)
+ return NULL;
+
+ str = g_string_new (NULL);
+
+ for (; *input; input = g_utf8_next_char (input))
+ {
+ gunichar ch = g_utf8_get_char (input);
+
+ if (ch == G_DIR_SEPARATOR)
+ {
+ g_string_append_c (str, '.');
+ }
+ else
+ {
+ g_string_append_unichar (str, ch);
+ }
+ }
+
+ return g_string_free (str, FALSE);
+}
+
+static gchar *
+apply_filter (gchar *input,
+ const gchar *filter)
+{
+ InputFilter filter_func;
+
+ if ((filter_func = g_hash_table_lookup (filters, filter)))
+ {
+ gchar *tmp = input;
+ input = filter_func (input);
+ g_free (tmp);
+ }
+
+ return input;
+}
+
+static gchar *
+apply_filters (GString *str,
+ const gchar *filters_list)
+{
+ gchar **filter_names;
+ gchar *input = g_string_free (str, FALSE);
+
+ filter_names = g_strsplit (filters_list, "|", 0);
+ for (guint i = 0; filter_names[i]; i++)
+ input = apply_filter (input, filter_names[i]);
+
+ g_strfreev (filter_names);
+
+ return input;
+}
+
+static gchar *
+scan_forward (const gchar *input,
+ const gchar **endpos,
+ gunichar needle)
+{
+ const gchar *begin = input;
+
+ for (; *input; input = g_utf8_next_char (input))
+ {
+ gunichar c = g_utf8_get_char (input);
+
+ if (c == needle)
+ {
+ *endpos = input;
+ return g_strndup (begin, (input - begin));
+ }
+ }
+
+ *endpos = NULL;
+
+ return NULL;
+}
+
+gchar *
+gtk_source_snippet_context_expand (GtkSourceSnippetContext *self,
+ const gchar *input)
+{
+ const gchar *expand;
+ gboolean is_dynamic;
+ GString *str;
+ gchar key[12];
+ glong n;
+ gint i;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self), NULL);
+ g_return_val_if_fail (input, NULL);
+
+ is_dynamic = (*input == '$');
+
+ str = g_string_new (NULL);
+
+ for (; *input; input = g_utf8_next_char (input))
+ {
+ gunichar c = g_utf8_get_char (input);
+
+ if (c == '\\')
+ {
+ input = g_utf8_next_char (input);
+ if (!*input)
+ break;
+ c = g_utf8_get_char (input);
+ }
+ else if (is_dynamic && c == '$')
+ {
+ input = g_utf8_next_char (input);
+
+ if (!*input)
+ break;
+
+ c = g_utf8_get_char (input);
+
+ if (g_unichar_isdigit (c))
+ {
+ errno = 0;
+ n = strtol (input, (gchar * *) &input, 10);
+ if (((n == LONG_MIN) || (n == LONG_MAX)) && errno == ERANGE)
+ break;
+ input--;
+ g_snprintf (key, sizeof key, "%ld", n);
+ key[sizeof key - 1] = '\0';
+ expand = gtk_source_snippet_context_get_variable (self, key);
+ if (expand)
+ g_string_append (str, expand);
+ continue;
+ }
+ else
+ {
+ if (strchr (input, '|'))
+ {
+ gchar *lkey;
+
+ lkey = g_strndup (input, strchr (input, '|') - input);
+ expand = gtk_source_snippet_context_get_variable (self, lkey);
+ g_free (lkey);
+
+ if (expand)
+ {
+ g_string_append (str, expand);
+ input = strchr (input, '|') - 1;
+ }
+ else
+ {
+ input += strlen (input) - 1;
+ }
+ }
+ else
+ {
+ expand = gtk_source_snippet_context_get_variable (self, input);
+
+ if (expand)
+ {
+ g_string_append (str, expand);
+ }
+ else
+ {
+ g_string_append_c (str, '$');
+ g_string_append (str, input);
+ }
+
+ input += strlen (input) - 1;
+ }
+
+ continue;
+ }
+ }
+ else if (is_dynamic && c == '|')
+ {
+ return apply_filters (str, input + 1);
+ }
+ else if (c == '`')
+ {
+ const gchar *endpos = NULL;
+ gchar *slice;
+
+ slice = scan_forward (input + 1, &endpos, '`');
+
+ if (slice)
+ {
+ gchar *expanded;
+
+ input = endpos;
+
+ expanded = gtk_source_snippet_context_expand (self, slice);
+
+ g_string_append (str, expanded);
+
+ g_free (expanded);
+ g_free (slice);
+
+ continue;
+ }
+ }
+ else if (c == '\t')
+ {
+ if (self->use_spaces)
+ {
+ for (i = 0; i < self->tab_width; i++)
+ g_string_append_c (str, ' ');
+ }
+ else
+ {
+ g_string_append_c (str, '\t');
+ }
+
+ continue;
+ }
+ else if (c == '\n')
+ {
+ g_string_append_c (str, '\n');
+
+ if (self->line_prefix)
+ {
+ g_string_append (str, self->line_prefix);
+ }
+
+ continue;
+ }
+
+ g_string_append_unichar (str, c);
+ }
+
+ return g_string_free (str, FALSE);
+}
+
+void
+gtk_source_snippet_context_set_tab_width (GtkSourceSnippetContext *self,
+ gint tab_width)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self));
+
+ if (tab_width != self->tab_width)
+ {
+ self->tab_width = tab_width;
+ }
+}
+
+void
+gtk_source_snippet_context_set_use_spaces (GtkSourceSnippetContext *self,
+ gboolean use_spaces)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self));
+
+ use_spaces = !!use_spaces;
+
+ if (self->use_spaces != use_spaces)
+ {
+ self->use_spaces = use_spaces;
+ }
+}
+
+void
+gtk_source_snippet_context_set_line_prefix (GtkSourceSnippetContext *self,
+ const gchar *line_prefix)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self));
+
+ if (g_strcmp0 (line_prefix, self->line_prefix) != 0)
+ {
+ g_free (self->line_prefix);
+ self->line_prefix = g_strdup (line_prefix);
+ }
+}
+
+void
+_gtk_source_snippet_context_emit_changed (GtkSourceSnippetContext *self)
+{
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET_CONTEXT (self));
+
+ g_signal_emit (self, signals [CHANGED], 0);
+}
+
+static void
+gtk_source_snippet_context_finalize (GObject *object)
+{
+ GtkSourceSnippetContext *self = (GtkSourceSnippetContext *)object;
+
+ g_clear_pointer (&self->constants, g_hash_table_unref);
+ g_clear_pointer (&self->variables, g_hash_table_unref);
+ g_clear_pointer (&self->line_prefix, g_free);
+
+ G_OBJECT_CLASS (gtk_source_snippet_context_parent_class)->finalize (object);
+}
+
+static void
+gtk_source_snippet_context_class_init (GtkSourceSnippetContextClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = gtk_source_snippet_context_finalize;
+
+ /**
+ * GtkSourceSnippetContext::changed:
+ *
+ * The "changed" signal is emitted when a change has been
+ * discovered in one of the chunks of the snippet which has
+ * caused a variable or other dynamic data within the context
+ * to have changed.
+ *
+ * Since: 5.0
+ */
+ signals[CHANGED] =
+ g_signal_new ("changed",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_FIRST,
+ 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE,
+ 0);
+
+ filters = g_hash_table_new (g_str_hash, g_str_equal);
+ g_hash_table_insert (filters, (gpointer) "lower", filter_lower);
+ g_hash_table_insert (filters, (gpointer) "upper", filter_upper);
+ g_hash_table_insert (filters, (gpointer) "capitalize", filter_capitalize);
+ g_hash_table_insert (filters, (gpointer) "decapitalize", filter_uncapitalize);
+ g_hash_table_insert (filters, (gpointer) "uncapitalize", filter_uncapitalize);
+ g_hash_table_insert (filters, (gpointer) "html", filter_html);
+ g_hash_table_insert (filters, (gpointer) "camelize", filter_camelize);
+ g_hash_table_insert (filters, (gpointer) "functify", filter_functify);
+ g_hash_table_insert (filters, (gpointer) "namespace", filter_namespace);
+ g_hash_table_insert (filters, (gpointer) "class", filter_class);
+ g_hash_table_insert (filters, (gpointer) "space", filter_space);
+ g_hash_table_insert (filters, (gpointer) "stripsuffix", filter_stripsuffix);
+ g_hash_table_insert (filters, (gpointer) "instance", filter_instance);
+ g_hash_table_insert (filters, (gpointer) "slash_to_dots", filter_slash_to_dots);
+ g_hash_table_insert (filters, (gpointer) "descend_path", filter_descend_path);
+}
+
+static void
+gtk_source_snippet_context_init (GtkSourceSnippetContext *self)
+{
+ GDateTime *dt;
+ gchar *str;
+
+ self->variables = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+ self->constants = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+
+#define ADD_CONSTANT(k, v) \
+ g_hash_table_insert (self->constants, g_strdup (k), g_strdup (v))
+
+ ADD_CONSTANT ("username", g_get_user_name ());
+ ADD_CONSTANT ("fullname", g_get_real_name ());
+ ADD_CONSTANT ("author", g_get_real_name ());
+
+ dt = g_date_time_new_now_local ();
+ str = g_date_time_format (dt, "%Y");
+ ADD_CONSTANT ("year", str);
+ g_free (str);
+ str = g_date_time_format (dt, "%b");
+ ADD_CONSTANT ("shortmonth", str);
+ g_free (str);
+ str = g_date_time_format (dt, "%d");
+ ADD_CONSTANT ("day", str);
+ g_free (str);
+ str = g_date_time_format (dt, "%a");
+ ADD_CONSTANT ("shortweekday", str);
+ g_free (str);
+ g_date_time_unref (dt);
+
+ ADD_CONSTANT ("email", "unknown@localhost");
+
+#undef ADD_CONSTANT
+}
diff --git a/gtksourceview/gtksourcesnippetcontext.h b/gtksourceview/gtksourcesnippetcontext.h
new file mode 100644
index 00000000..14e569d6
--- /dev/null
+++ b/gtksourceview/gtksourcesnippetcontext.h
@@ -0,0 +1,65 @@
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * GtkSourceView 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.1 of the License, or (at your option) any later version.
+ *
+ * GtkSourceView 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/>.
+ */
+
+#pragma once
+
+#if !defined (GTK_SOURCE_H_INSIDE) && !defined (GTK_SOURCE_COMPILATION)
+#error "Only <gtksourceview/gtksource.h> can be included directly."
+#endif
+
+#include <gtk/gtk.h>
+
+#include "gtksourcetypes.h"
+
+G_BEGIN_DECLS
+
+#define GTK_SOURCE_TYPE_SNIPPET_CONTEXT (gtk_source_snippet_context_get_type())
+
+GTK_SOURCE_AVAILABLE_IN_5_0
+G_DECLARE_FINAL_TYPE (GtkSourceSnippetContext, gtk_source_snippet_context, GTK_SOURCE, SNIPPET_CONTEXT,
GObject)
+
+GTK_SOURCE_AVAILABLE_IN_5_0
+GtkSourceSnippetContext *gtk_source_snippet_context_new (void);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_context_clear_variables (GtkSourceSnippetContext *self);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_context_set_variable (GtkSourceSnippetContext *self,
+ const gchar *key,
+ const gchar *value);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_context_set_constant (GtkSourceSnippetContext *self,
+ const gchar *key,
+ const gchar *value);
+GTK_SOURCE_AVAILABLE_IN_5_0
+const gchar *gtk_source_snippet_context_get_variable (GtkSourceSnippetContext *self,
+ const gchar *key);
+GTK_SOURCE_AVAILABLE_IN_5_0
+gchar *gtk_source_snippet_context_expand (GtkSourceSnippetContext *self,
+ const gchar *input);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_context_set_tab_width (GtkSourceSnippetContext *self,
+ gint tab_width);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_context_set_use_spaces (GtkSourceSnippetContext *self,
+ gboolean use_spaces);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_snippet_context_set_line_prefix (GtkSourceSnippetContext *self,
+ const gchar *line_prefix);
+
+G_END_DECLS
diff --git a/gtksourceview/gtksourcestylescheme-private.h b/gtksourceview/gtksourcestylescheme-private.h
index a7d6c641..5fd56f24 100644
--- a/gtksourceview/gtksourcestylescheme-private.h
+++ b/gtksourceview/gtksourcestylescheme-private.h
@@ -41,6 +41,8 @@ void _gtk_source_style_scheme_unapply (Gtk
G_GNUC_INTERNAL
GtkSourceStyle *_gtk_source_style_scheme_get_matching_brackets_style (GtkSourceStyleScheme *scheme);
G_GNUC_INTERNAL
+GtkSourceStyle *_gtk_source_style_scheme_get_snippet_focus_style (GtkSourceStyleScheme *scheme);
+G_GNUC_INTERNAL
GtkSourceStyle *_gtk_source_style_scheme_get_right_margin_style (GtkSourceStyleScheme *scheme);
G_GNUC_INTERNAL
GtkSourceStyle *_gtk_source_style_scheme_get_draw_spaces_style (GtkSourceStyleScheme *scheme);
diff --git a/gtksourceview/gtksourcestylescheme.c b/gtksourceview/gtksourcestylescheme.c
index 94a14c9e..0ee340da 100644
--- a/gtksourceview/gtksourcestylescheme.c
+++ b/gtksourceview/gtksourcestylescheme.c
@@ -62,6 +62,7 @@
#define STYLE_CURRENT_LINE_NUMBER "current-line-number"
#define STYLE_RIGHT_MARGIN "right-margin"
#define STYLE_DRAW_SPACES "draw-spaces"
+#define STYLE_SNIPPET_FOCUS "snippet-focus"
#define STYLE_BACKGROUND_PATTERN "background-pattern"
#define STYLE_SCHEME_VERSION "1.0"
@@ -618,6 +619,14 @@ _gtk_source_style_scheme_get_draw_spaces_style (GtkSourceStyleScheme *scheme)
return gtk_source_style_scheme_get_style (scheme, STYLE_DRAW_SPACES);
}
+GtkSourceStyle *
+_gtk_source_style_scheme_get_snippet_focus_style (GtkSourceStyleScheme *scheme)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_STYLE_SCHEME (scheme), NULL);
+
+ return gtk_source_style_scheme_get_style (scheme, STYLE_SNIPPET_FOCUS);
+}
+
static gboolean
get_color (GtkSourceStyle *style,
gboolean foreground,
diff --git a/gtksourceview/gtksourcetypes.h b/gtksourceview/gtksourcetypes.h
index 3ac09423..8cf43b47 100644
--- a/gtksourceview/gtksourcetypes.h
+++ b/gtksourceview/gtksourcetypes.h
@@ -59,6 +59,9 @@ typedef struct _GtkSourceMark GtkSourceMark;
typedef struct _GtkSourcePrintCompositor GtkSourcePrintCompositor;
typedef struct _GtkSourceSearchContext GtkSourceSearchContext;
typedef struct _GtkSourceSearchSettings GtkSourceSearchSettings;
+typedef struct _GtkSourceSnippet GtkSourceSnippet;
+typedef struct _GtkSourceSnippetChunk GtkSourceSnippetChunk;
+typedef struct _GtkSourceSnippetContext GtkSourceSnippetContext;
typedef struct _GtkSourceSpaceDrawer GtkSourceSpaceDrawer;
typedef struct _GtkSourceStyle GtkSourceStyle;
typedef struct _GtkSourceStyleSchemeChooserButton GtkSourceStyleSchemeChooserButton;
diff --git a/gtksourceview/gtksourceview.c b/gtksourceview/gtksourceview.c
index ddc82eb1..3c316fd7 100644
--- a/gtksourceview/gtksourceview.c
+++ b/gtksourceview/gtksourceview.c
@@ -31,25 +31,29 @@
#include <pango/pango-tabs.h>
#include <glib/gi18n-lib.h>
-#include "gtksourcebuffer.h"
+#include "gtksource-enumtypes.h"
+#include "gtksource-marshal.h"
+
#include "gtksourcebuffer-private.h"
+#include "gtksourcebuffer.h"
#include "gtksourcebufferinternal-private.h"
+#include "gtksourcecompletion-private.h"
#include "gtksourcecompletion.h"
-#include "gtksourcegutter.h"
+#include "gtksourcecompletionprovider.h"
#include "gtksourcegutter-private.h"
+#include "gtksourcegutter.h"
#include "gtksourcegutterrendererlines-private.h"
#include "gtksourcegutterrenderermarks-private.h"
-#include "gtksource-enumtypes.h"
+#include "gtksourceiter-private.h"
#include "gtksourcemark.h"
#include "gtksourcemarkattributes.h"
-#include "gtksource-marshal.h"
-#include "gtksourcestylescheme-private.h"
-#include "gtksourcecompletion-private.h"
-#include "gtksourcecompletionprovider.h"
-#include "gtksourceiter-private.h"
#include "gtksourcesearchcontext-private.h"
-#include "gtksourcespacedrawer.h"
+#include "gtksourcesnippet-private.h"
+#include "gtksourcesnippetchunk.h"
+#include "gtksourcesnippetcontext.h"
#include "gtksourcespacedrawer-private.h"
+#include "gtksourcespacedrawer.h"
+#include "gtksourcestylescheme-private.h"
/**
* SECTION:view
@@ -156,6 +160,8 @@ enum
MOVE_LINES,
MOVE_TO_MATCHING_BRACKET,
MOVE_WORDS,
+ PUSH_SNIPPET,
+ POP_SNIPPET,
SHOW_COMPLETION,
SMART_HOME_END,
N_SIGNALS
@@ -203,6 +209,8 @@ typedef struct
GtkSourceCompletion *completion;
+ GQueue snippets;
+
guint right_margin_pos;
gint cached_right_margin_pos;
guint tab_width;
@@ -311,6 +319,10 @@ static gboolean gtk_source_view_drag_drop (GtkDropTarget
int y,
GtkSourceView *view);
static void gtk_source_view_populate_extra_menu (GtkSourceView *view);
+static void gtk_source_view_real_push_snippet (GtkSourceView *view,
+ GtkSourceSnippet *snippet,
+ GtkTextIter *location);
+static void gtk_source_view_pop_snippet (GtkSourceView *view);
static void
gtk_source_view_constructed (GObject *object)
@@ -506,6 +518,7 @@ gtk_source_view_class_init (GtkSourceViewClass *klass)
klass->show_completion = gtk_source_view_show_completion_real;
klass->move_lines = gtk_source_view_move_lines;
klass->move_words = gtk_source_view_move_words;
+ klass->push_snippet = gtk_source_view_real_push_snippet;
/**
* GtkSourceView:completion:
@@ -819,6 +832,56 @@ gtk_source_view_class_init (GtkSourceViewClass *klass)
G_TYPE_FROM_CLASS (klass),
g_cclosure_marshal_VOID__INTv);
+ /**
+ * GtkSourceView::push-snippet:
+ * @view: a #GtkSourceView
+ * @snippet: a #GtkSourceSnippet
+ * @location: (inout): a #GtkTextIter
+ *
+ * The ::push-snippet signal is emitted to insert a new snippet into
+ * the view. If another snippet was active, it will be paused until all
+ * focus positions of @snippet have been exhausted.
+ *
+ * @location will be updated to point at the end of the snippet.
+ *
+ * Since: 5.0
+ */
+ signals[PUSH_SNIPPET] =
+ g_signal_new ("push-snippet",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkSourceViewClass, push_snippet),
+ NULL, NULL,
+ _gtk_source_marshal_VOID__OBJECT_BOXED,
+ G_TYPE_NONE,
+ 2,
+ GTK_SOURCE_TYPE_SNIPPET,
+ GTK_TYPE_TEXT_ITER);
+ g_signal_set_va_marshaller (signals[PUSH_SNIPPET],
+ G_TYPE_FROM_CLASS (klass),
+ _gtk_source_marshal_VOID__OBJECT_BOXEDv);
+
+ /**
+ * GtkSourceView::pop-snippet:
+ * @view: a #GtkSourceView
+ * @snippet: a #GtkSourceSnippet
+ *
+ * The ::pop-snippet signal is emitted when a snippet's focus positions
+ * have been exhausted.
+ *
+ * Since: 5.0
+ */
+ signals[POP_SNIPPET] =
+ g_signal_new ("pop-snippet",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkSourceViewClass, pop_snippet),
+ NULL, NULL,
+ NULL,
+ G_TYPE_NONE,
+ 1,
+ GTK_SOURCE_TYPE_SNIPPET);
+
/**
* GtkSourceView::smart-home-end:
* @view: the #GtkSourceView
@@ -3837,12 +3900,88 @@ do_ctrl_backspace (GtkSourceView *view)
return FALSE;
}
+static GtkSourceSnippet *
+lookup_snippet_by_trigger (GtkSourceView *view,
+ const gchar *word)
+{
+ GtkSourceSnippet *snippet;
+ GtkSourceSnippetChunk *chunk;
+
+ g_assert (GTK_SOURCE_IS_VIEW (view));
+ g_assert (word != NULL);
+
+ snippet = gtk_source_snippet_new (word, NULL);
+
+ for (guint i = 0; i < 3; i++)
+ {
+ chunk = gtk_source_snippet_chunk_new ();
+ gtk_source_snippet_chunk_set_spec (chunk, word);
+ gtk_source_snippet_chunk_set_focus_position (chunk, i+1);
+ gtk_source_snippet_add_chunk (snippet, chunk);
+ g_object_unref (chunk);
+ }
+
+ chunk = gtk_source_snippet_chunk_new ();
+ gtk_source_snippet_chunk_set_focus_position (chunk, 0);
+ gtk_source_snippet_add_chunk (snippet, chunk);
+ g_object_unref (chunk);
+
+ return snippet;
+}
+
+static gboolean
+gtk_source_view_try_expand_snippet (GtkSourceView *view,
+ GtkTextIter *iter)
+{
+ GtkSourceSnippet *snippet;
+ GtkTextIter begin;
+ gchar *word;
+
+ g_assert (GTK_SOURCE_IS_VIEW (view));
+ g_assert (iter != NULL);
+
+ if (gtk_text_iter_starts_line (iter) ||
+ !_gtk_source_iter_ends_full_word (iter))
+ {
+ return FALSE;
+ }
+
+ begin = *iter;
+
+ _gtk_source_iter_backward_full_word_start (&begin);
+
+ if (gtk_text_iter_compare (&begin, iter) >= 0)
+ {
+ return FALSE;
+ }
+
+ word = gtk_text_iter_get_slice (&begin, iter);
+
+ if (word == NULL || *word == 0)
+ {
+ return FALSE;
+ }
+
+ snippet = lookup_snippet_by_trigger (view, word);
+
+ g_free (word);
+
+ if (snippet != NULL)
+ {
+ gtk_source_view_push_snippet (view, snippet, iter);
+ g_object_unref (snippet);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
static gboolean
gtk_source_view_key_pressed (GtkSourceView *view,
- guint key,
- guint keycode,
- guint state,
- GtkEventControllerKey *controller)
+ guint key,
+ guint keycode,
+ guint state,
+ GtkEventControllerKey *controller)
{
GtkSourceViewPrivate *priv = gtk_source_view_get_instance_private (view);
GtkTextBuffer *buf;
@@ -3908,11 +4047,47 @@ gtk_source_view_key_pressed (GtkSourceView *view,
editable &&
gtk_text_view_get_accepts_tab (GTK_TEXT_VIEW (view)))
{
+ GtkSourceSnippet *snippet = g_queue_peek_head (&priv->snippets);
GtkTextIter s, e;
gboolean has_selection;
has_selection = gtk_text_buffer_get_selection_bounds (buf, &s, &e);
+ /* If we already have a snippet expanded, then we might need
+ * to move forward or backward between snippet positions.
+ */
+ if (snippet != NULL)
+ {
+ if (state == 0)
+ {
+ if (!_gtk_source_snippet_move_next (snippet))
+ {
+ gtk_source_view_pop_snippet (view);
+ }
+
+ return GDK_EVENT_STOP;
+ }
+ else if (state & GDK_SHIFT_MASK)
+ {
+ if (!_gtk_source_snippet_move_previous (snippet))
+ {
+ gtk_source_view_pop_snippet (view);
+ }
+
+ return GDK_EVENT_STOP;
+ }
+ }
+
+ /* tab: if there is no selection and the current word is a
+ * snippet trigger, then we should expand that snippet.
+ */
+ if (state == 0 &&
+ !has_selection &&
+ gtk_source_view_try_expand_snippet (view, &e))
+ {
+ return GDK_EVENT_STOP;
+ }
+
if (priv->indent_on_tab)
{
/* shift+tab: always unindent */
@@ -4931,3 +5106,173 @@ gtk_source_view_queue_draw (GtkSourceView *view)
_gtk_source_gutter_queue_draw (priv->right_gutter);
}
}
+
+static gchar *
+get_line_prefix (const GtkTextIter *iter)
+{
+ GtkTextIter begin;
+ GString *str;
+
+ g_assert (iter != NULL);
+
+ if (gtk_text_iter_starts_line (iter))
+ {
+ return NULL;
+ }
+
+ begin = *iter;
+ gtk_text_iter_set_line_offset (&begin, 0);
+
+ str = g_string_new (NULL);
+
+ do
+ {
+ gunichar c = gtk_text_iter_get_char (&begin);
+
+ switch (c)
+ {
+ case '\t':
+ case ' ':
+ g_string_append_unichar (str, c);
+ break;
+
+ default:
+ g_string_append_c (str, ' ');
+ break;
+ }
+ }
+ while (gtk_text_iter_forward_char (&begin) &&
+ (gtk_text_iter_compare (&begin, iter) < 0));
+
+ return g_string_free (str, FALSE);
+}
+
+static void
+gtk_source_view_real_push_snippet (GtkSourceView *view,
+ GtkSourceSnippet *snippet,
+ GtkTextIter *location)
+{
+ GtkSourceViewPrivate *priv = gtk_source_view_get_instance_private (view);
+ GtkTextBuffer *buffer;
+ gboolean more_to_focus;
+
+ g_assert (GTK_SOURCE_IS_VIEW (view));
+ g_assert (GTK_SOURCE_IS_SNIPPET (snippet));
+ g_assert (location != NULL);
+
+ buffer = gtk_text_iter_get_buffer (location);
+
+ g_queue_push_head (&priv->snippets, g_object_ref (snippet));
+
+ gtk_text_buffer_begin_user_action (buffer);
+ more_to_focus = _gtk_source_snippet_begin (snippet, buffer, location);
+ gtk_text_buffer_end_user_action (buffer);
+
+ gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (view),
+ gtk_text_buffer_get_insert (buffer));
+
+ if (!more_to_focus)
+ {
+ gtk_source_view_pop_snippet (view);
+ }
+}
+
+/**
+ * gtk_source_view_push_snippet:
+ * @view: a #GtkSourceView
+ * @snippet: a #GtkSourceSnippet
+ * @location: (nullable): a #GtkTextIter or %NULL for the cursor position
+ *
+ * Inserts a new snippet at @location
+ *
+ * If another snippet was already active, it will be paused and the new
+ * snippet will become active. Once the focus positions of @snippet have
+ * been exhausted, editing will return to the previous snippet.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_view_push_snippet (GtkSourceView *view,
+ GtkSourceSnippet *snippet,
+ GtkTextIter *location)
+{
+ GtkSourceViewPrivate *priv = gtk_source_view_get_instance_private (view);
+ GtkSourceSnippetContext *context;
+ GtkSourceSnippet *previous_snippet;
+ GtkTextBuffer *buffer;
+ GtkTextIter iter;
+ gboolean use_spaces;
+ gchar *prefix;
+ gint tab_width;
+
+ g_return_if_fail (GTK_SOURCE_IS_VIEW (view));
+ g_return_if_fail (GTK_SOURCE_IS_SNIPPET (snippet));
+
+ previous_snippet = g_queue_peek_head (&priv->snippets);
+
+ if (previous_snippet != NULL)
+ {
+ _gtk_source_snippet_pause (previous_snippet);
+ }
+
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+
+ if (location == NULL)
+ {
+ gtk_text_buffer_get_iter_at_mark (buffer,
+ &iter,
+ gtk_text_buffer_get_insert (buffer));
+ location = &iter;
+ }
+
+ g_return_if_fail (gtk_text_iter_get_buffer (location) == buffer);
+
+ context = gtk_source_snippet_get_context (snippet);
+
+ use_spaces = gtk_source_view_get_insert_spaces_instead_of_tabs (view);
+ gtk_source_snippet_context_set_use_spaces (context, use_spaces);
+
+ tab_width = gtk_source_view_get_tab_width (view);
+ gtk_source_snippet_context_set_tab_width (context, tab_width);
+
+ prefix = get_line_prefix (location);
+ gtk_source_snippet_context_set_line_prefix (context, prefix);
+ g_free (prefix);
+
+ g_signal_emit (view, signals [PUSH_SNIPPET], 0, snippet, location);
+}
+
+static void
+gtk_source_view_pop_snippet (GtkSourceView *view)
+{
+ GtkSourceViewPrivate *priv = gtk_source_view_get_instance_private (view);
+ GtkSourceSnippet *next_snippet;
+ GtkSourceSnippet *snippet;
+
+ g_return_if_fail (GTK_SOURCE_IS_VIEW (view));
+
+ snippet = g_queue_pop_head (&priv->snippets);
+
+ if (snippet == NULL)
+ {
+ return;
+ }
+
+ next_snippet = g_queue_peek_head (&priv->snippets);
+
+ if (next_snippet != NULL)
+ {
+ gchar *new_text;
+
+ new_text = _gtk_source_snippet_get_edited_text (snippet);
+ _gtk_source_snippet_replace_current_chunk_text (next_snippet, new_text);
+ _gtk_source_snippet_unpause (next_snippet);
+ _gtk_source_snippet_move_next (next_snippet);
+
+ g_free (new_text);
+ }
+
+ g_signal_emit (view, signals[POP_SNIPPET], 0, snippet);
+
+ g_object_unref (snippet);
+}
diff --git a/gtksourceview/gtksourceview.h b/gtksourceview/gtksourceview.h
index af1a7463..a7a719c2 100644
--- a/gtksourceview/gtksourceview.h
+++ b/gtksourceview/gtksourceview.h
@@ -96,6 +96,11 @@ struct _GtkSourceViewClass
gboolean down);
void (*move_words) (GtkSourceView *view,
gint step);
+ void (*push_snippet) (GtkSourceView *view,
+ GtkSourceSnippet *snippet,
+ GtkTextIter *location);
+ void (*pop_snippet) (GtkSourceView *view,
+ GtkSourceSnippet *snippet);
/*< private >*/
gpointer _reserved[20];
@@ -197,5 +202,9 @@ GTK_SOURCE_AVAILABLE_IN_3_16
GtkSourceBackgroundPatternType gtk_source_view_get_background_pattern (GtkSourceView
*view);
GTK_SOURCE_AVAILABLE_IN_3_24
GtkSourceSpaceDrawer *gtk_source_view_get_space_drawer (GtkSourceView
*view);
+GTK_SOURCE_AVAILABLE_IN_5_0
+void gtk_source_view_push_snippet (GtkSourceView
*view,
+ GtkSourceSnippet
*snippet,
+ GtkTextIter
*location);
G_END_DECLS
diff --git a/gtksourceview/meson.build b/gtksourceview/meson.build
index f28546a8..7aca6f1b 100644
--- a/gtksourceview/meson.build
+++ b/gtksourceview/meson.build
@@ -33,6 +33,9 @@ core_public_h = files([
'gtksourceregion.h',
'gtksourcesearchcontext.h',
'gtksourcesearchsettings.h',
+ 'gtksourcesnippet.h',
+ 'gtksourcesnippetchunk.h',
+ 'gtksourcesnippetcontext.h',
'gtksourcespacedrawer.h',
'gtksourcestyle.h',
'gtksourcestylescheme.h',
@@ -73,6 +76,9 @@ core_public_c = files([
'gtksourceregion.c',
'gtksourcesearchcontext.c',
'gtksourcesearchsettings.c',
+ 'gtksourcesnippet.c',
+ 'gtksourcesnippetchunk.c',
+ 'gtksourcesnippetcontext.c',
'gtksourcespacedrawer.c',
'gtksourcestyle.c',
'gtksourcestylescheme.c',
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
