openkylin
/
gtksourceview3
mirror of https://gitee.com/openkylin/gtksourceview3.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
gtksourceview3/gtksourceview/gtksourcebuffer.c

3320 lines
89 KiB
C
Raw Permalink Normal View History

Import Upstream version 3.24.11
2022-05-14 03:31:02 +08:00
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- */
/* gtksourcebuffer.c
* This file is part of GtkSourceView
*
* Copyright (C) 1999-2002 - Mikael Hermansson <tyan@linux.se>,
* Chris Phelps <chicane@reninet.com> and
* Jeroen Zwartepoorte <jeroen@xs4all.nl>
* Copyright (C) 2003 - Paolo Maggi <paolo.maggi@polito.it> and
* Gustavo Giráldez <gustavo.giraldez@gmx.net>
*
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "gtksourcebuffer.h"
#include "gtksourcebuffer-private.h"
#include <string.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include "gtksourcelanguage.h"
#include "gtksourcelanguage-private.h"
#include "gtksourceundomanager.h"
#include "gtksourceundomanagerdefault.h"
#include "gtksourcestyle.h"
#include "gtksourcestylescheme.h"
#include "gtksourcestyleschememanager.h"
#include "gtksourcemark.h"
#include "gtksourcemarkssequence.h"
#include "gtksourcesearchcontext.h"
#include "gtksourcetag.h"
#include "gtksourceview-i18n.h"
#include "gtksourceview-enumtypes.h"
/**
* SECTION:buffer
* @Short_description: Stores the text for display in a GtkSourceView
* @Title: GtkSourceBuffer
* @See_also: #GtkTextBuffer, #GtkSourceView
*
* A #GtkSourceBuffer object is the model for #GtkSourceView widgets.
* It extends the #GtkTextBuffer class by adding features useful to display
* and edit source code such as syntax highlighting and bracket matching. It
* also implements support for the undo/redo.
*
* To create a #GtkSourceBuffer use gtk_source_buffer_new() or
* gtk_source_buffer_new_with_language(). The second form is just a convenience
* function which allows you to initially set a #GtkSourceLanguage. You can also
* directly create a #GtkSourceView and get its #GtkSourceBuffer with
* gtk_text_view_get_buffer().
*
* The highlighting is enabled by default, but you can disable it with
* gtk_source_buffer_set_highlight_syntax().
*
* # Undo/Redo
*
* A custom #GtkSourceUndoManager can be implemented and set with
* gtk_source_buffer_set_undo_manager(). However the default implementation
* should be suitable for most uses, so you can use the API provided by
* #GtkSourceBuffer instead of using #GtkSourceUndoManager. By default, actions
* that can be undone or redone are defined as groups of operations between a
* call to gtk_text_buffer_begin_user_action() and
* gtk_text_buffer_end_user_action(). In general, this happens whenever the user
* presses any key which modifies the buffer. But the default undo manager will
* try to merge similar consecutive actions into one undo/redo level. The
* merging is done word by word, so after writing a new sentence (character by
* character), each undo will remove the previous word.
*
* The default undo manager remembers the "modified" state of the buffer, and
* restores it when an action is undone or redone. It can be useful in a text
* editor to know whether the file is saved. See gtk_text_buffer_get_modified()
* and gtk_text_buffer_set_modified().
*
* The default undo manager also restores the selected text (or cursor
* position), if the selection was related to the action. For example if the
* user selects some text and deletes it, an undo will restore the selection. On
* the other hand, if some text is selected but a deletion occurs elsewhere (the
* deletion was done programmatically), an undo will not restore the selection,
* it will only moves the cursor (the cursor is moved so that the user sees the
* undo's effect). Warning: the selection restoring behavior might change in the
* future.
*
* # Context Classes # {#context-classes}
*
* It is possible to retrieve some information from the syntax highlighting
* engine. The default context classes that are applied to regions of a
* #GtkSourceBuffer:
* - <emphasis>comment</emphasis>: the region delimits a comment;
* - <emphasis>no-spell-check</emphasis>: the region should not be spell checked;
* - <emphasis>path</emphasis>: the region delimits a path to a file;
* - <emphasis>string</emphasis>: the region delimits a string.
*
* Custom language definition files can create their own context classes,
* since the functions like gtk_source_buffer_iter_has_context_class() take
* a string parameter as the context class.
*
* #GtkSourceBuffer provides an API to access the context classes:
* gtk_source_buffer_iter_has_context_class(),
* gtk_source_buffer_get_context_classes_at_iter(),
* gtk_source_buffer_iter_forward_to_context_class_toggle() and
* gtk_source_buffer_iter_backward_to_context_class_toggle().
*
* And the #GtkSourceBuffer::highlight-updated signal permits to be notified
* when a context class region changes.
*
* Each context class has also an associated #GtkTextTag with the name
* <emphasis>gtksourceview:context-classes:&lt;name&gt;</emphasis>. For example to
* retrieve the #GtkTextTag for the string context class, one can write:
* |[
* GtkTextTagTable *tag_table;
* GtkTextTag *tag;
*
* tag_table = gtk_text_buffer_get_tag_table (buffer);
* tag = gtk_text_tag_table_lookup (tag_table, "gtksourceview:context-classes:string");
* ]|
*
* The tag must be used for read-only purposes.
*
* Accessing a context class via the associated #GtkTextTag is less
* convenient than the #GtkSourceBuffer API, because:
* - The tag doesn't always exist, you need to listen to the
* #GtkTextTagTable::tag-added and #GtkTextTagTable::tag-removed signals.
* - Instead of the #GtkSourceBuffer::highlight-updated signal, you can listen
* to the #GtkTextBuffer::apply-tag and #GtkTextBuffer::remove-tag signals.
*
* A possible use-case for accessing a context class via the associated
* #GtkTextTag is to read the region but without adding a hard dependency on the
* GtkSourceView library (for example for a spell-checking library that wants to
* read the no-spell-check region).
*/
/*
#define ENABLE_DEBUG
#define ENABLE_PROFILE
*/
#undef ENABLE_DEBUG
#undef ENABLE_PROFILE
#ifdef ENABLE_DEBUG
#define DEBUG(x) (x)
#else
#define DEBUG(x)
#endif
#ifdef ENABLE_PROFILE
#define PROFILE(x) (x)
#else
#define PROFILE(x)
#endif
#define UPDATE_BRACKET_DELAY 50
#define BRACKET_MATCHING_CHARS_LIMIT 10000
#define CONTEXT_CLASSES_PREFIX "gtksourceview:context-classes:"
enum
{
HIGHLIGHT_UPDATED,
SOURCE_MARK_UPDATED,
UNDO,
REDO,
BRACKET_MATCHED,
N_SIGNALS
};
enum
{
PROP_0,
PROP_CAN_UNDO,
PROP_CAN_REDO,
PROP_HIGHLIGHT_SYNTAX,
PROP_HIGHLIGHT_MATCHING_BRACKETS,
PROP_MAX_UNDO_LEVELS,
PROP_LANGUAGE,
PROP_STYLE_SCHEME,
PROP_UNDO_MANAGER,
PROP_IMPLICIT_TRAILING_NEWLINE,
N_PROPERTIES
};
struct _GtkSourceBufferPrivate
{
GtkTextTag *bracket_match_tag;
GtkSourceBracketMatchType bracket_match_state;
guint bracket_highlighting_timeout_id;
/* Hash table: category -> MarksSequence */
GHashTable *source_marks;
GtkSourceMarksSequence *all_source_marks;
GtkSourceStyleScheme *style_scheme;
GtkSourceLanguage *language;
GtkSourceEngine *highlight_engine;
GtkSourceUndoManager *undo_manager;
gint max_undo_levels;
GtkTextMark *tmp_insert_mark;
GtkTextMark *tmp_selection_bound_mark;
GList *search_contexts;
GtkTextTag *invalid_char_tag;
guint highlight_syntax : 1;
guint highlight_brackets : 1;
guint implicit_trailing_newline : 1;
};
static guint buffer_signals[N_SIGNALS];
static GParamSpec *buffer_properties[N_PROPERTIES];
G_DEFINE_TYPE_WITH_PRIVATE (GtkSourceBuffer, gtk_source_buffer, GTK_TYPE_TEXT_BUFFER)
/* Prototypes */
static void gtk_source_buffer_dispose (GObject *object);
static void gtk_source_buffer_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_source_buffer_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_source_buffer_can_undo_handler (GtkSourceUndoManager *manager,
GtkSourceBuffer *buffer);
static void gtk_source_buffer_can_redo_handler (GtkSourceUndoManager *manager,
GtkSourceBuffer *buffer);
static void gtk_source_buffer_real_insert_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
gint len);
static void gtk_source_buffer_real_insert_pixbuf (GtkTextBuffer *buffer,
GtkTextIter *pos,
GdkPixbuf *pixbuf);
static void gtk_source_buffer_real_insert_child_anchor
(GtkTextBuffer *buffer,
GtkTextIter *pos,
GtkTextChildAnchor *anchor);
static void gtk_source_buffer_real_delete_range (GtkTextBuffer *buffer,
GtkTextIter *iter,
GtkTextIter *end);
static void gtk_source_buffer_real_mark_set (GtkTextBuffer *buffer,
const GtkTextIter *location,
GtkTextMark *mark);
static void gtk_source_buffer_real_mark_deleted (GtkTextBuffer *buffer,
GtkTextMark *mark);
static void gtk_source_buffer_real_undo (GtkSourceBuffer *buffer);
static void gtk_source_buffer_real_redo (GtkSourceBuffer *buffer);
static void gtk_source_buffer_real_highlight_updated
(GtkSourceBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end);
static void
gtk_source_buffer_constructed (GObject *object)
{
GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (object);
if (buffer->priv->undo_manager == NULL)
{
/* This will install the default undo manager */
gtk_source_buffer_set_undo_manager (buffer, NULL);
}
G_OBJECT_CLASS (gtk_source_buffer_parent_class)->constructed (object);
}
static void
gtk_source_buffer_class_init (GtkSourceBufferClass *klass)
{
GObjectClass *object_class;
GtkTextBufferClass *text_buffer_class;
object_class = G_OBJECT_CLASS (klass);
text_buffer_class = GTK_TEXT_BUFFER_CLASS (klass);
object_class->constructed = gtk_source_buffer_constructed;
object_class->dispose = gtk_source_buffer_dispose;
object_class->get_property = gtk_source_buffer_get_property;
object_class->set_property = gtk_source_buffer_set_property;
text_buffer_class->delete_range = gtk_source_buffer_real_delete_range;
text_buffer_class->insert_text = gtk_source_buffer_real_insert_text;
text_buffer_class->insert_pixbuf = gtk_source_buffer_real_insert_pixbuf;
text_buffer_class->insert_child_anchor = gtk_source_buffer_real_insert_child_anchor;
text_buffer_class->mark_set = gtk_source_buffer_real_mark_set;
text_buffer_class->mark_deleted = gtk_source_buffer_real_mark_deleted;
klass->undo = gtk_source_buffer_real_undo;
klass->redo = gtk_source_buffer_real_redo;
/**
* GtkSourceBuffer:highlight-syntax:
*
* Whether to highlight syntax in the buffer.
*/
buffer_properties[PROP_HIGHLIGHT_SYNTAX] =
g_param_spec_boolean ("highlight-syntax",
"Highlight Syntax",
"Whether to highlight syntax in the buffer",
TRUE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* GtkSourceBuffer:highlight-matching-brackets:
*
* Whether to highlight matching brackets in the buffer.
*/
buffer_properties[PROP_HIGHLIGHT_MATCHING_BRACKETS] =
g_param_spec_boolean ("highlight-matching-brackets",
"Highlight Matching Brackets",
"Whether to highlight matching brackets",
TRUE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* GtkSourceBuffer:max-undo-levels:
*
* Number of undo levels for the buffer. -1 means no limit. This property
* will only affect the default undo manager.
*/
buffer_properties[PROP_MAX_UNDO_LEVELS] =
g_param_spec_int ("max-undo-levels",
"Maximum Undo Levels",
"Number of undo levels for the buffer",
-1,
G_MAXINT,
-1,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
buffer_properties[PROP_LANGUAGE] =
g_param_spec_object ("language",
"Language",
"Language object to get highlighting patterns from",
GTK_SOURCE_TYPE_LANGUAGE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
buffer_properties[PROP_CAN_UNDO] =
g_param_spec_boolean ("can-undo",
"Can undo",
"Whether Undo operation is possible",
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS);
buffer_properties[PROP_CAN_REDO] =
g_param_spec_boolean ("can-redo",
"Can redo",
"Whether Redo operation is possible",
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS);
/**
* GtkSourceBuffer:style-scheme:
*
* Style scheme. It contains styles for syntax highlighting, optionally
* foreground, background, cursor color, current line color, and matching
* brackets style.
*/
buffer_properties[PROP_STYLE_SCHEME] =
g_param_spec_object ("style-scheme",
"Style scheme",
"Style scheme",
GTK_SOURCE_TYPE_STYLE_SCHEME,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
buffer_properties[PROP_UNDO_MANAGER] =
g_param_spec_object ("undo-manager",
"Undo manager",
"The buffer undo manager",
GTK_SOURCE_TYPE_UNDO_MANAGER,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS);
/**
* GtkSourceBuffer:implicit-trailing-newline:
*
* Whether the buffer has an implicit trailing newline. See
* gtk_source_buffer_set_implicit_trailing_newline().
*
* Since: 3.14
*/
buffer_properties[PROP_IMPLICIT_TRAILING_NEWLINE] =
g_param_spec_boolean ("implicit-trailing-newline",
"Implicit trailing newline",
"",
TRUE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, N_PROPERTIES, buffer_properties);
/**
* GtkSourceBuffer::highlight-updated:
* @buffer: the buffer that received the signal
* @start: the start of the updated region
* @end: the end of the updated region
*
* The ::highlight-updated signal is emitted when the syntax
* highlighting and [context classes][context-classes] are updated in a
* certain region of the @buffer.
*/
buffer_signals[HIGHLIGHT_UPDATED] =
g_signal_new_class_handler ("highlight-updated",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_CALLBACK (gtk_source_buffer_real_highlight_updated),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
* GtkSourceBuffer::source-mark-updated:
* @buffer: the buffer that received the signal
* @mark: the #GtkSourceMark
*
* The ::source-mark-updated signal is emitted each time
* a mark is added to, moved or removed from the @buffer.
*/
buffer_signals[SOURCE_MARK_UPDATED] =
g_signal_new ("source-mark-updated",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
1, GTK_TYPE_TEXT_MARK);
/**
* GtkSourceBuffer::undo:
* @buffer: the buffer that received the signal
*
* The ::undo signal is emitted to undo the last user action which
* modified the buffer.
*/
buffer_signals[UNDO] =
g_signal_new ("undo",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSourceBufferClass, undo),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* GtkSourceBuffer::redo:
* @buffer: the buffer that received the signal
*
* The ::redo signal is emitted to redo the last undo operation.
*/
buffer_signals[REDO] =
g_signal_new ("redo",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSourceBufferClass, redo),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* GtkSourceBuffer::bracket-matched:
* @buffer: a #GtkSourceBuffer.
* @iter: (nullable): if found, the location of the matching bracket.
* @state: state of bracket matching.
*
* @iter is set to a valid iterator pointing to the matching bracket
* if @state is %GTK_SOURCE_BRACKET_MATCH_FOUND. Otherwise @iter is
* meaningless.
*
* The signal is emitted only when the @state changes, typically when
* the cursor moves.
*
* A use-case for this signal is to show messages in a #GtkStatusbar.
*
* Since: 2.12
*/
buffer_signals[BRACKET_MATCHED] =
g_signal_new ("bracket-matched",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSourceBufferClass, bracket_matched),
NULL, NULL, NULL,
G_TYPE_NONE, 2,
GTK_TYPE_TEXT_ITER,
GTK_SOURCE_TYPE_BRACKET_MATCH_TYPE);
}
static void
set_undo_manager (GtkSourceBuffer *buffer,
GtkSourceUndoManager *manager)
{
if (manager == buffer->priv->undo_manager)
{
return;
}
if (buffer->priv->undo_manager != NULL)
{
g_signal_handlers_disconnect_by_func (buffer->priv->undo_manager,
G_CALLBACK (gtk_source_buffer_can_undo_handler),
buffer);
g_signal_handlers_disconnect_by_func (buffer->priv->undo_manager,
G_CALLBACK (gtk_source_buffer_can_redo_handler),
buffer);
g_object_unref (buffer->priv->undo_manager);
buffer->priv->undo_manager = NULL;
}
if (manager != NULL)
{
buffer->priv->undo_manager = g_object_ref (manager);
g_signal_connect (buffer->priv->undo_manager,
"can-undo-changed",
G_CALLBACK (gtk_source_buffer_can_undo_handler),
buffer);
g_signal_connect (buffer->priv->undo_manager,
"can-redo-changed",
G_CALLBACK (gtk_source_buffer_can_redo_handler),
buffer);
/* Notify possible changes in the can-undo/redo state */
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_CAN_UNDO]);
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_CAN_REDO]);
}
}
static void
search_context_weak_notify_cb (GtkSourceBuffer *buffer,
GObject *search_context)
{
buffer->priv->search_contexts = g_list_remove (buffer->priv->search_contexts,
search_context);
}
static void
gtk_source_buffer_init (GtkSourceBuffer *buffer)
{
GtkSourceBufferPrivate *priv = gtk_source_buffer_get_instance_private (buffer);
buffer->priv = priv;
priv->highlight_syntax = TRUE;
priv->highlight_brackets = TRUE;
priv->bracket_match_state = GTK_SOURCE_BRACKET_MATCH_NONE;
priv->max_undo_levels = -1;
priv->source_marks = g_hash_table_new_full (g_str_hash,
g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)g_object_unref);
priv->all_source_marks = _gtk_source_marks_sequence_new (GTK_TEXT_BUFFER (buffer));
priv->style_scheme = _gtk_source_style_scheme_get_default ();
if (priv->style_scheme != NULL)
{
g_object_ref (priv->style_scheme);
}
}
static void
gtk_source_buffer_dispose (GObject *object)
{
GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (object);
GList *l;
if (buffer->priv->bracket_highlighting_timeout_id != 0)
{
g_source_remove (buffer->priv->bracket_highlighting_timeout_id);
buffer->priv->bracket_highlighting_timeout_id = 0;
}
if (buffer->priv->undo_manager != NULL)
{
set_undo_manager (buffer, NULL);
}
if (buffer->priv->highlight_engine != NULL)
{
_gtk_source_engine_attach_buffer (buffer->priv->highlight_engine, NULL);
}
g_clear_object (&buffer->priv->highlight_engine);
g_clear_object (&buffer->priv->language);
g_clear_object (&buffer->priv->style_scheme);
for (l = buffer->priv->search_contexts; l != NULL; l = l->next)
{
GtkSourceSearchContext *search_context = l->data;
g_object_weak_unref (G_OBJECT (search_context),
(GWeakNotify)search_context_weak_notify_cb,
buffer);
}
g_list_free (buffer->priv->search_contexts);
buffer->priv->search_contexts = NULL;
g_clear_object (&buffer->priv->all_source_marks);
if (buffer->priv->source_marks != NULL)
{
g_hash_table_unref (buffer->priv->source_marks);
buffer->priv->source_marks = NULL;
}
G_OBJECT_CLASS (gtk_source_buffer_parent_class)->dispose (object);
}
static void
gtk_source_buffer_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkSourceBuffer *buffer;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (object));
buffer = GTK_SOURCE_BUFFER (object);
switch (prop_id)
{
case PROP_HIGHLIGHT_SYNTAX:
gtk_source_buffer_set_highlight_syntax (buffer, g_value_get_boolean (value));
break;
case PROP_HIGHLIGHT_MATCHING_BRACKETS:
gtk_source_buffer_set_highlight_matching_brackets (buffer, g_value_get_boolean (value));
break;
case PROP_MAX_UNDO_LEVELS:
gtk_source_buffer_set_max_undo_levels (buffer, g_value_get_int (value));
break;
case PROP_LANGUAGE:
gtk_source_buffer_set_language (buffer, g_value_get_object (value));
break;
case PROP_STYLE_SCHEME:
gtk_source_buffer_set_style_scheme (buffer, g_value_get_object (value));
break;
case PROP_UNDO_MANAGER:
gtk_source_buffer_set_undo_manager (buffer, g_value_get_object (value));
break;
case PROP_IMPLICIT_TRAILING_NEWLINE:
gtk_source_buffer_set_implicit_trailing_newline (buffer, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_source_buffer_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkSourceBuffer *buffer;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (object));
buffer = GTK_SOURCE_BUFFER (object);
switch (prop_id)
{
case PROP_HIGHLIGHT_SYNTAX:
g_value_set_boolean (value, buffer->priv->highlight_syntax);
break;
case PROP_HIGHLIGHT_MATCHING_BRACKETS:
g_value_set_boolean (value, buffer->priv->highlight_brackets);
break;
case PROP_MAX_UNDO_LEVELS:
g_value_set_int (value, buffer->priv->max_undo_levels);
break;
case PROP_LANGUAGE:
g_value_set_object (value, buffer->priv->language);
break;
case PROP_STYLE_SCHEME:
g_value_set_object (value, buffer->priv->style_scheme);
break;
case PROP_CAN_UNDO:
g_value_set_boolean (value, gtk_source_buffer_can_undo (buffer));
break;
case PROP_CAN_REDO:
g_value_set_boolean (value, gtk_source_buffer_can_redo (buffer));
break;
case PROP_UNDO_MANAGER:
g_value_set_object (value, buffer->priv->undo_manager);
break;
case PROP_IMPLICIT_TRAILING_NEWLINE:
g_value_set_boolean (value, buffer->priv->implicit_trailing_newline);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* gtk_source_buffer_new:
* @table: (nullable): a #GtkTextTagTable, or %NULL to create a new one.
*
* Creates a new source buffer.
*
* Returns: a new source buffer.
*/
GtkSourceBuffer *
gtk_source_buffer_new (GtkTextTagTable *table)
{
return g_object_new (GTK_SOURCE_TYPE_BUFFER,
"tag-table", table,
NULL);
}
/**
* gtk_source_buffer_new_with_language:
* @language: a #GtkSourceLanguage.
*
* Creates a new source buffer using the highlighting patterns in
* @language. This is equivalent to creating a new source buffer with
* a new tag table and then calling gtk_source_buffer_set_language().
*
* Returns: a new source buffer which will highlight text
* according to the highlighting patterns in @language.
*/
GtkSourceBuffer *
gtk_source_buffer_new_with_language (GtkSourceLanguage *language)
{
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE (language), NULL);
return g_object_new (GTK_SOURCE_TYPE_BUFFER,
"tag-table", NULL,
"language", language,
NULL);
}
static void
gtk_source_buffer_can_undo_handler (GtkSourceUndoManager *manager,
GtkSourceBuffer *buffer)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_CAN_UNDO]);
}
static void
gtk_source_buffer_can_redo_handler (GtkSourceUndoManager *manager,
GtkSourceBuffer *buffer)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_CAN_REDO]);
}
static void
update_bracket_match_style (GtkSourceBuffer *buffer)
{
GtkSourceStyle *style = NULL;
if (buffer->priv->bracket_match_tag == NULL)
{
return;
}
if (buffer->priv->style_scheme != NULL)
{
style = _gtk_source_style_scheme_get_matching_brackets_style (buffer->priv->style_scheme);
}
gtk_source_style_apply (style, buffer->priv->bracket_match_tag);
}
static GtkTextTag *
get_bracket_match_tag (GtkSourceBuffer *buffer)
{
if (buffer->priv->bracket_match_tag == NULL)
{
buffer->priv->bracket_match_tag =
gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer),
NULL,
NULL);
update_bracket_match_style (buffer);
}
return buffer->priv->bracket_match_tag;
}
/* This is private, just used by the print compositor to not print bracket
* matches. Note that unlike get_bracket_match_tag() it returns NULL
* if the tag is not set.
*/
GtkTextTag *
_gtk_source_buffer_get_bracket_match_tag (GtkSourceBuffer *buffer)
{
return buffer->priv->bracket_match_tag;
}
static gunichar
bracket_pair (gunichar base_char,
gint *direction)
{
gint dir;
gunichar pair;
switch (base_char)
{
case '{':
dir = 1;
pair = '}';
break;
case '(':
dir = 1;
pair = ')';
break;
case '[':
dir = 1;
pair = ']';
break;
case '<':
dir = 1;
pair = '>';
break;
case '}':
dir = -1;
pair = '{';
break;
case ')':
dir = -1;
pair = '(';
break;
case ']':
dir = -1;
pair = '[';
break;
case '>':
dir = -1;
pair = '<';
break;
default:
dir = 0;
pair = 0;
break;
}
if (direction != NULL)
{
*direction = dir;
}
return pair;
}
/*
* This function works similar to gtk_text_buffer_remove_tag() except that
* instead of taking the optimization to make removing tags fast in terms
* of wall clock time, it tries to avoiding to much time of the screen
* by minimizing the damage regions. This results in fewer full-redraws
* when updating the text marks. To see the difference, compare this to
* gtk_text_buffer_remove_tag() and enable the "show pixel cache" feature
* the GTK+ inspector.
*/
static void
remove_tag_with_minimal_damage (GtkTextBuffer *buffer,
GtkTextTag *tag,
const GtkTextIter *begin,
const GtkTextIter *end)
{
GtkTextIter tag_begin = *begin;
GtkTextIter tag_end;
if (!gtk_text_iter_starts_tag (&tag_begin, tag))
{
if (!gtk_text_iter_forward_to_tag_toggle (&tag_begin, tag))
{
return;
}
}
while (gtk_text_iter_starts_tag (&tag_begin, tag) &&
gtk_text_iter_compare (&tag_begin, end) < 0)
{
gint count = 1;
tag_end = tag_begin;
/*
* We might have found the start of another tag embedded
* inside this tag. So keep scanning forward until we have
* reached the right number of end tags.
*/
while (gtk_text_iter_forward_to_tag_toggle (&tag_end, tag))
{
if (gtk_text_iter_starts_tag (&tag_end, tag))
{
count++;
}
else if (gtk_text_iter_ends_tag (&tag_end, tag))
{
if (--count == 0)
{
break;
}
}
}
if (gtk_text_iter_ends_tag (&tag_end, tag))
{
gtk_text_buffer_remove_tag (buffer, tag, &tag_begin, &tag_end);
tag_begin = tag_end;
/*
* Move to the next start tag. It's possible to have an overlapped
* end tag, which would be non-ideal, but possible.
*/
if (!gtk_text_iter_starts_tag (&tag_begin, tag))
{
while (gtk_text_iter_forward_to_tag_toggle (&tag_begin, tag))
{
if (gtk_text_iter_starts_tag (&tag_begin, tag))
{
break;
}
}
}
}
}
}
static void
update_bracket_highlighting (GtkSourceBuffer *source_buffer)
{
GtkTextBuffer *buffer;
GtkTextIter insert_iter;
GtkTextIter bracket;
GtkTextIter bracket_match;
GtkSourceBracketMatchType previous_state;
buffer = GTK_TEXT_BUFFER (source_buffer);
if (source_buffer->priv->bracket_match_tag != NULL)
{
GtkTextIter start;
GtkTextIter end;
gtk_text_buffer_get_bounds (buffer, &start, &end);
remove_tag_with_minimal_damage (GTK_TEXT_BUFFER (source_buffer),
source_buffer->priv->bracket_match_tag,
&start,
&end);
}
if (!source_buffer->priv->highlight_brackets)
{
if (source_buffer->priv->bracket_match_tag != NULL)
{
GtkTextTagTable *table;
table = gtk_text_buffer_get_tag_table (buffer);
gtk_text_tag_table_remove (table, source_buffer->priv->bracket_match_tag);
source_buffer->priv->bracket_match_tag = NULL;
}
return;
}
gtk_text_buffer_get_iter_at_mark (buffer,
&insert_iter,
gtk_text_buffer_get_insert (buffer));
previous_state = source_buffer->priv->bracket_match_state;
source_buffer->priv->bracket_match_state =
_gtk_source_buffer_find_bracket_match (source_buffer,
&insert_iter,
&bracket,
&bracket_match);
if (source_buffer->priv->bracket_match_state == GTK_SOURCE_BRACKET_MATCH_FOUND)
{
GtkTextIter next_iter;
g_signal_emit (source_buffer,
buffer_signals[BRACKET_MATCHED],
0,
&bracket_match,
GTK_SOURCE_BRACKET_MATCH_FOUND);
next_iter = bracket_match;
gtk_text_iter_forward_char (&next_iter);
gtk_text_buffer_apply_tag (buffer,
get_bracket_match_tag (source_buffer),
&bracket_match,
&next_iter);
next_iter = bracket;
gtk_text_iter_forward_char (&next_iter);
gtk_text_buffer_apply_tag (buffer,
get_bracket_match_tag (source_buffer),
&bracket,
&next_iter);
return;
}
/* Don't emit the signal at all if chars at previous and current
* positions are nonbrackets.
*/
if (previous_state != GTK_SOURCE_BRACKET_MATCH_NONE ||
source_buffer->priv->bracket_match_state != GTK_SOURCE_BRACKET_MATCH_NONE)
{
g_signal_emit (source_buffer,
buffer_signals[BRACKET_MATCHED],
0,
NULL,
source_buffer->priv->bracket_match_state);
}
}
static gboolean
bracket_highlighting_timeout_cb (gpointer user_data)
{
GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (user_data);
update_bracket_highlighting (buffer);
buffer->priv->bracket_highlighting_timeout_id = 0;
return G_SOURCE_REMOVE;
}
static void
queue_bracket_highlighting_update (GtkSourceBuffer *buffer)
{
if (buffer->priv->bracket_highlighting_timeout_id != 0)
{
g_source_remove (buffer->priv->bracket_highlighting_timeout_id);
}
/* Queue an update to the bracket location instead of doing it
* immediately. We are likely going to be servicing a draw deadline
* immediately, so blocking to find the match and invalidating
* visible regions causes animations to stutter. Instead, give
* ourself just a little bit of a delay to catch up.
*
* The value for this delay was found experimentally, as 25msec
* resulted in continuing to see frame stutter, but 50 was not
* distinguishable from having matching-brackets disabled.
* The animation in gtkscrolledwindow is 200, but that creates
* an undesireable delay before the match is shown to the user.
* 50msec errors on the side of "immediate", but without the
* frame stutter.
*
* If we had access to a GdkFrameClock, we might consider using
* ::update() or ::after-paint() to synchronize this.
*/
buffer->priv->bracket_highlighting_timeout_id =
gdk_threads_add_timeout_full (G_PRIORITY_LOW,
UPDATE_BRACKET_DELAY,
bracket_highlighting_timeout_cb,
buffer,
NULL);
}
/* Although this function is not really useful
* (queue_bracket_highlighting_update() could be called directly), the name
* cursor_moved() is more meaningful.
*/
static void
cursor_moved (GtkSourceBuffer *buffer)
{
queue_bracket_highlighting_update (buffer);
}
static void
gtk_source_buffer_real_highlight_updated (GtkSourceBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end)
{
queue_bracket_highlighting_update (buffer);
}
static void
gtk_source_buffer_content_inserted (GtkTextBuffer *buffer,
gint start_offset,
gint end_offset)
{
GtkSourceBuffer *source_buffer = GTK_SOURCE_BUFFER (buffer);
cursor_moved (source_buffer);
if (source_buffer->priv->highlight_engine != NULL)
{
_gtk_source_engine_text_inserted (source_buffer->priv->highlight_engine,
start_offset,
end_offset);
}
}
static void
gtk_source_buffer_real_insert_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
gint len)
{
gint start_offset;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (text != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
start_offset = gtk_text_iter_get_offset (iter);
/* iter is invalidated when
* insertion occurs (because the buffer contents change), but the
* default signal handler revalidates it to point to the end of the
* inserted text.
*/
GTK_TEXT_BUFFER_CLASS (gtk_source_buffer_parent_class)->insert_text (buffer, iter, text, len);
gtk_source_buffer_content_inserted (buffer,
start_offset,
gtk_text_iter_get_offset (iter));
}
/* insert_pixbuf and insert_child_anchor do nothing except notifying
* the highlighting engine about the change, because engine's idea
* of buffer char count must be correct at all times.
*/
static void
gtk_source_buffer_real_insert_pixbuf (GtkTextBuffer *buffer,
GtkTextIter *iter,
GdkPixbuf *pixbuf)
{
gint start_offset;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
start_offset = gtk_text_iter_get_offset (iter);
/* iter is invalidated when
* insertion occurs (because the buffer contents change), but the
* default signal handler revalidates it to point to the end of the
* inserted text.
*/
GTK_TEXT_BUFFER_CLASS (gtk_source_buffer_parent_class)->insert_pixbuf (buffer, iter, pixbuf);
gtk_source_buffer_content_inserted (buffer,
start_offset,
gtk_text_iter_get_offset (iter));
}
static void
gtk_source_buffer_real_insert_child_anchor (GtkTextBuffer *buffer,
GtkTextIter *iter,
GtkTextChildAnchor *anchor)
{
gint start_offset;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
start_offset = gtk_text_iter_get_offset (iter);
/* iter is invalidated when insertion occurs (because the buffer
* contents change), but the default signal handler revalidates it to
* point to the end of the inserted text.
*/
GTK_TEXT_BUFFER_CLASS (gtk_source_buffer_parent_class)->insert_child_anchor (buffer, iter, anchor);
gtk_source_buffer_content_inserted (buffer,
start_offset,
gtk_text_iter_get_offset (iter));
}
static void
gtk_source_buffer_real_delete_range (GtkTextBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end)
{
gint offset, length;
GtkSourceBuffer *source_buffer = GTK_SOURCE_BUFFER (buffer);
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (start) == buffer);
g_return_if_fail (gtk_text_iter_get_buffer (end) == buffer);
gtk_text_iter_order (start, end);
offset = gtk_text_iter_get_offset (start);
length = gtk_text_iter_get_offset (end) - offset;
GTK_TEXT_BUFFER_CLASS (gtk_source_buffer_parent_class)->delete_range (buffer, start, end);
cursor_moved (source_buffer);
/* emit text deleted for engines */
if (source_buffer->priv->highlight_engine != NULL)
{
_gtk_source_engine_text_deleted (source_buffer->priv->highlight_engine,
offset, length);
}
}
static gint
get_bracket_matching_context_class_mask (GtkSourceBuffer *buffer,
GtkTextIter *iter)
{
gint mask = 0;
guint i;
/* This describes a mask of relevant context classes for highlighting
* matching brackets.
*/
const gchar *cclass_mask_definitions[] = {
"comment",
"string",
};
for (i = 0; i < G_N_ELEMENTS (cclass_mask_definitions); ++i)
{
gboolean has_class;
has_class = gtk_source_buffer_iter_has_context_class (buffer,
iter,
cclass_mask_definitions[i]);
mask |= has_class << i;
}
return mask;
}
/* Note that we only look BRACKET_MATCHING_CHARS_LIMIT at most.
* @pos is moved to the bracket match, if found.
*/
static GtkSourceBracketMatchType
find_bracket_match_real (GtkSourceBuffer *buffer,
GtkTextIter *pos)
{
GtkTextIter iter;
gunichar base_char;
gunichar search_char;
gint direction;
gint bracket_count;
gint char_count;
gint cclass_mask;
gboolean found;
base_char = gtk_text_iter_get_char (pos);
search_char = bracket_pair (base_char, &direction);
if (direction == 0)
{
return GTK_SOURCE_BRACKET_MATCH_NONE;
}
cclass_mask = get_bracket_matching_context_class_mask (buffer, pos);
iter = *pos;
bracket_count = 0;
char_count = 0;
found = FALSE;
do
{
gunichar cur_char;
gint cur_mask;
gtk_text_iter_forward_chars (&iter, direction);
cur_char = gtk_text_iter_get_char (&iter);
char_count++;
cur_mask = get_bracket_matching_context_class_mask (buffer, &iter);
/* Check if we lost a class, which means we don't look any
* further.
*/
if ((cclass_mask & cur_mask) != cclass_mask)
{
found = FALSE;
break;
}
if (cclass_mask != cur_mask)
{
continue;
}
if (cur_char == search_char)
{
if (bracket_count == 0)
{
found = TRUE;
break;
}
bracket_count--;
}
else if (cur_char == base_char)
{
bracket_count++;
}
}
while (!gtk_text_iter_is_end (&iter) &&
!gtk_text_iter_is_start (&iter) &&
char_count < BRACKET_MATCHING_CHARS_LIMIT);
if (found)
{
*pos = iter;
return GTK_SOURCE_BRACKET_MATCH_FOUND;
}
if (char_count >= BRACKET_MATCHING_CHARS_LIMIT)
{
return GTK_SOURCE_BRACKET_MATCH_OUT_OF_RANGE;
}
return GTK_SOURCE_BRACKET_MATCH_NOT_FOUND;
}
/* Note that we take into account both the character following @pos and the one
* preceding it. If there are brackets on both sides, the one following @pos
* takes precedence.
* @bracket and @bracket_match are valid only if GTK_SOURCE_BRACKET_MATCH_FOUND
* is returned. @bracket is set either to @pos or @pos-1.
*/
GtkSourceBracketMatchType
_gtk_source_buffer_find_bracket_match (GtkSourceBuffer *buffer,
const GtkTextIter *pos,
GtkTextIter *bracket,
GtkTextIter *bracket_match)
{
GtkSourceBracketMatchType result_right;
GtkSourceBracketMatchType result_left;
GtkTextIter prev;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), GTK_SOURCE_BRACKET_MATCH_NONE);
g_return_val_if_fail (pos != NULL, GTK_SOURCE_BRACKET_MATCH_NONE);
g_return_val_if_fail (bracket_match != NULL, GTK_SOURCE_BRACKET_MATCH_NONE);
*bracket_match = *pos;
result_right = find_bracket_match_real (buffer, bracket_match);
if (result_right == GTK_SOURCE_BRACKET_MATCH_FOUND)
{
if (bracket != NULL)
{
*bracket = *pos;
}
return GTK_SOURCE_BRACKET_MATCH_FOUND;
}
prev = *pos;
if (!gtk_text_iter_starts_line (&prev) &&
gtk_text_iter_backward_cursor_position (&prev))
{
*bracket_match = prev;
result_left = find_bracket_match_real (buffer, bracket_match);
}
else
{
result_left = GTK_SOURCE_BRACKET_MATCH_NONE;
}
if (result_left == GTK_SOURCE_BRACKET_MATCH_FOUND)
{
if (bracket != NULL)
{
*bracket = prev;
}
return GTK_SOURCE_BRACKET_MATCH_FOUND;
}
/* If there is a bracket, the expected return value is for the bracket,
* not the other character.
*/
if (result_right == GTK_SOURCE_BRACKET_MATCH_NONE)
{
return result_left;
}
if (result_left == GTK_SOURCE_BRACKET_MATCH_NONE)
{
return result_right;
}
/* There are brackets on both sides, and none was successful. The one on
* the right takes precedence.
*/
return result_right;
}
/**
* gtk_source_buffer_can_undo:
* @buffer: a #GtkSourceBuffer.
*
* Determines whether a source buffer can undo the last action.
*
* Returns: %TRUE if it's possible to undo the last action.
*/
gboolean
gtk_source_buffer_can_undo (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
return gtk_source_undo_manager_can_undo (buffer->priv->undo_manager);
}
/**
* gtk_source_buffer_can_redo:
* @buffer: a #GtkSourceBuffer.
*
* Determines whether a source buffer can redo the last action
* (i.e. if the last operation was an undo).
*
* Returns: %TRUE if a redo is possible.
*/
gboolean
gtk_source_buffer_can_redo (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
return gtk_source_undo_manager_can_redo (buffer->priv->undo_manager);
}
/**
* gtk_source_buffer_undo:
* @buffer: a #GtkSourceBuffer.
*
* Undoes the last user action which modified the buffer. Use
* gtk_source_buffer_can_undo() to check whether a call to this
* function will have any effect.
*
* This function emits the #GtkSourceBuffer::undo signal.
*/
void
gtk_source_buffer_undo (GtkSourceBuffer *buffer)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_signal_emit (buffer, buffer_signals[UNDO], 0);
}
/**
* gtk_source_buffer_redo:
* @buffer: a #GtkSourceBuffer.
*
* Redoes the last undo operation. Use gtk_source_buffer_can_redo()
* to check whether a call to this function will have any effect.
*
* This function emits the #GtkSourceBuffer::redo signal.
*/
void
gtk_source_buffer_redo (GtkSourceBuffer *buffer)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_signal_emit (buffer, buffer_signals[REDO], 0);
}
/**
* gtk_source_buffer_get_max_undo_levels:
* @buffer: a #GtkSourceBuffer.
*
* Determines the number of undo levels the buffer will track for buffer edits.
*
* Returns: the maximum number of possible undo levels or -1 if no limit is set.
*/
gint
gtk_source_buffer_get_max_undo_levels (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), 0);
return buffer->priv->max_undo_levels;
}
/**
* gtk_source_buffer_set_max_undo_levels:
* @buffer: a #GtkSourceBuffer.
* @max_undo_levels: the desired maximum number of undo levels.
*
* Sets the number of undo levels for user actions the buffer will
* track. If the number of user actions exceeds the limit set by this
* function, older actions will be discarded.
*
* If @max_undo_levels is -1, the undo/redo is unlimited.
*
* If @max_undo_levels is 0, the undo/redo is disabled.
*/
void
gtk_source_buffer_set_max_undo_levels (GtkSourceBuffer *buffer,
gint max_undo_levels)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
if (buffer->priv->max_undo_levels == max_undo_levels)
{
return;
}
buffer->priv->max_undo_levels = max_undo_levels;
if (GTK_SOURCE_IS_UNDO_MANAGER_DEFAULT (buffer->priv->undo_manager))
{
gtk_source_undo_manager_default_set_max_undo_levels (GTK_SOURCE_UNDO_MANAGER_DEFAULT (buffer->priv->undo_manager),
max_undo_levels);
}
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_MAX_UNDO_LEVELS]);
}
gboolean
_gtk_source_buffer_is_undo_redo_enabled (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
if (buffer->priv->undo_manager == NULL)
{
return FALSE;
}
/* A custom UndoManager is not forced to follow max_undo_levels. */
if (!GTK_SOURCE_IS_UNDO_MANAGER_DEFAULT (buffer->priv->undo_manager))
{
return TRUE;
}
return buffer->priv->max_undo_levels != 0;
}
/**
* gtk_source_buffer_begin_not_undoable_action:
* @buffer: a #GtkSourceBuffer.
*
* Marks the beginning of a not undoable action on the buffer,
* disabling the undo manager. Typically you would call this function
* before initially setting the contents of the buffer (e.g. when
* loading a file in a text editor).
*
* You may nest gtk_source_buffer_begin_not_undoable_action() /
* gtk_source_buffer_end_not_undoable_action() blocks.
*/
void
gtk_source_buffer_begin_not_undoable_action (GtkSourceBuffer *buffer)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
gtk_source_undo_manager_begin_not_undoable_action (buffer->priv->undo_manager);
}
/**
* gtk_source_buffer_end_not_undoable_action:
* @buffer: a #GtkSourceBuffer.
*
* Marks the end of a not undoable action on the buffer. When the
* last not undoable block is closed through the call to this
* function, the list of undo actions is cleared and the undo manager
* is re-enabled.
*/
void
gtk_source_buffer_end_not_undoable_action (GtkSourceBuffer *buffer)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
gtk_source_undo_manager_end_not_undoable_action (buffer->priv->undo_manager);
}
/**
* gtk_source_buffer_get_highlight_matching_brackets:
* @buffer: a #GtkSourceBuffer.
*
* Determines whether bracket match highlighting is activated for the
* source buffer.
*
* Returns: %TRUE if the source buffer will highlight matching
* brackets.
*/
gboolean
gtk_source_buffer_get_highlight_matching_brackets (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
return buffer->priv->highlight_brackets;
}
/**
* gtk_source_buffer_set_highlight_matching_brackets:
* @buffer: a #GtkSourceBuffer.
* @highlight: %TRUE if you want matching brackets highlighted.
*
* Controls the bracket match highlighting function in the buffer. If
* activated, when you position your cursor over a bracket character
* (a parenthesis, a square bracket, etc.) the matching opening or
* closing bracket character will be highlighted.
*/
void
gtk_source_buffer_set_highlight_matching_brackets (GtkSourceBuffer *buffer,
gboolean highlight)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
highlight = highlight != FALSE;
if (highlight != buffer->priv->highlight_brackets)
{
buffer->priv->highlight_brackets = highlight;
update_bracket_highlighting (buffer);
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_HIGHLIGHT_MATCHING_BRACKETS]);
}
}
/**
* gtk_source_buffer_get_highlight_syntax:
* @buffer: a #GtkSourceBuffer.
*
* Determines whether syntax highlighting is activated in the source
* buffer.
*
* Returns: %TRUE if syntax highlighting is enabled, %FALSE otherwise.
*/
gboolean
gtk_source_buffer_get_highlight_syntax (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
return buffer->priv->highlight_syntax;
}
/**
* gtk_source_buffer_set_highlight_syntax:
* @buffer: a #GtkSourceBuffer.
* @highlight: %TRUE to enable syntax highlighting, %FALSE to disable it.
*
* Controls whether syntax is highlighted in the buffer.
*
* If @highlight is %TRUE, the text will be highlighted according to the syntax
* patterns specified in the #GtkSourceLanguage set with
* gtk_source_buffer_set_language().
*
* If @highlight is %FALSE, syntax highlighting is disabled and all the
* #GtkTextTag objects that have been added by the syntax highlighting engine
* are removed from the buffer.
*/
void
gtk_source_buffer_set_highlight_syntax (GtkSourceBuffer *buffer,
gboolean highlight)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
highlight = highlight != FALSE;
if (buffer->priv->highlight_syntax != highlight)
{
buffer->priv->highlight_syntax = highlight;
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_HIGHLIGHT_SYNTAX]);
}
}
/**
* gtk_source_buffer_set_language:
* @buffer: a #GtkSourceBuffer.
* @language: (nullable): a #GtkSourceLanguage to set, or %NULL.
*
* Associates a #GtkSourceLanguage with the buffer.
*
* Note that a #GtkSourceLanguage affects not only the syntax highlighting, but
* also the [context classes][context-classes]. If you want to disable just the
* syntax highlighting, see gtk_source_buffer_set_highlight_syntax().
*
* The buffer holds a reference to @language.
*/
void
gtk_source_buffer_set_language (GtkSourceBuffer *buffer,
GtkSourceLanguage *language)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (GTK_SOURCE_IS_LANGUAGE (language) || language == NULL);
if (!g_set_object (&buffer->priv->language, language))
{
return;
}
if (buffer->priv->highlight_engine != NULL)
{
/* disconnect the old engine */
_gtk_source_engine_attach_buffer (buffer->priv->highlight_engine, NULL);
g_object_unref (buffer->priv->highlight_engine);
buffer->priv->highlight_engine = NULL;
}
if (language != NULL)
{
/* get a new engine */
buffer->priv->highlight_engine = _gtk_source_language_create_engine (language);
if (buffer->priv->highlight_engine != NULL)
{
_gtk_source_engine_attach_buffer (buffer->priv->highlight_engine,
GTK_TEXT_BUFFER (buffer));
if (buffer->priv->style_scheme != NULL)
{
_gtk_source_engine_set_style_scheme (buffer->priv->highlight_engine,
buffer->priv->style_scheme);
}
}
}
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_LANGUAGE]);
}
/**
* gtk_source_buffer_get_language:
* @buffer: a #GtkSourceBuffer.
*
* Returns the #GtkSourceLanguage associated with the buffer,
* see gtk_source_buffer_set_language(). The returned object should not be
* unreferenced by the user.
*
* Returns: (nullable) (transfer none): the #GtkSourceLanguage associated
* with the buffer, or %NULL.
*/
GtkSourceLanguage *
gtk_source_buffer_get_language (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
return buffer->priv->language;
}
/*
* _gtk_source_buffer_update_syntax_highlight:
* @buffer: a #GtkSourceBuffer.
* @start: start of the area to highlight.
* @end: end of the area to highlight.
* @synchronous: whether the area should be highlighted synchronously.
*
* Asks the buffer to analyze and highlight given area.
*/
void
_gtk_source_buffer_update_syntax_highlight (GtkSourceBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end,
gboolean synchronous)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
if (buffer->priv->highlight_engine != NULL)
{
_gtk_source_engine_update_highlight (buffer->priv->highlight_engine,
start,
end,
synchronous);
}
}
void
_gtk_source_buffer_update_search_highlight (GtkSourceBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end,
gboolean synchronous)
{
GList *l;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
for (l = buffer->priv->search_contexts; l != NULL; l = l->next)
{
GtkSourceSearchContext *search_context = l->data;
_gtk_source_search_context_update_highlight (search_context,
start,
end,
synchronous);
}
}
/**
* gtk_source_buffer_ensure_highlight:
* @buffer: a #GtkSourceBuffer.
* @start: start of the area to highlight.
* @end: end of the area to highlight.
*
* Forces buffer to analyze and highlight the given area synchronously.
*
* <note>
* <para>
* This is a potentially slow operation and should be used only
* when you need to make sure that some text not currently
* visible is highlighted, for instance before printing.
* </para>
* </note>
**/
void
gtk_source_buffer_ensure_highlight (GtkSourceBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end)
{
_gtk_source_buffer_update_syntax_highlight (buffer, start, end, TRUE);
_gtk_source_buffer_update_search_highlight (buffer, start, end, TRUE);
}
/**
* gtk_source_buffer_set_style_scheme:
* @buffer: a #GtkSourceBuffer.
* @scheme: (nullable): a #GtkSourceStyleScheme or %NULL.
*
* Sets a #GtkSourceStyleScheme to be used by the buffer and the view.
*
* Note that a #GtkSourceStyleScheme affects not only the syntax highlighting,
* but also other #GtkSourceView features such as highlighting the current line,
* matching brackets, the line numbers, etc.
*
* Instead of setting a %NULL @scheme, it is better to disable syntax
* highlighting with gtk_source_buffer_set_highlight_syntax(), and setting the
* #GtkSourceStyleScheme with the "classic" or "tango" ID, because those two
* style schemes follow more closely the GTK+ theme (for example for the
* background color).
*
* The buffer holds a reference to @scheme.
*/
void
gtk_source_buffer_set_style_scheme (GtkSourceBuffer *buffer,
GtkSourceStyleScheme *scheme)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (GTK_SOURCE_IS_STYLE_SCHEME (scheme) || scheme == NULL);
if (g_set_object (&buffer->priv->style_scheme, scheme))
{
update_bracket_match_style (buffer);
if (buffer->priv->highlight_engine != NULL)
{
_gtk_source_engine_set_style_scheme (buffer->priv->highlight_engine, scheme);
}
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_STYLE_SCHEME]);
}
}
/**
* gtk_source_buffer_get_style_scheme:
* @buffer: a #GtkSourceBuffer.
*
* Returns the #GtkSourceStyleScheme associated with the buffer,
* see gtk_source_buffer_set_style_scheme().
* The returned object should not be unreferenced by the user.
*
* Returns: (nullable) (transfer none): the #GtkSourceStyleScheme
* associated with the buffer, or %NULL.
*/
GtkSourceStyleScheme *
gtk_source_buffer_get_style_scheme (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
return buffer->priv->style_scheme;
}
static void
add_source_mark (GtkSourceBuffer *buffer,
GtkSourceMark *mark)
{
const gchar *category;
GtkSourceMarksSequence *seq;
_gtk_source_marks_sequence_add (buffer->priv->all_source_marks,
GTK_TEXT_MARK (mark));
category = gtk_source_mark_get_category (mark);
seq = g_hash_table_lookup (buffer->priv->source_marks, category);
if (seq == NULL)
{
seq = _gtk_source_marks_sequence_new (GTK_TEXT_BUFFER (buffer));
g_hash_table_insert (buffer->priv->source_marks,
g_strdup (category),
seq);
}
_gtk_source_marks_sequence_add (seq, GTK_TEXT_MARK (mark));
}
static void
gtk_source_buffer_real_mark_set (GtkTextBuffer *buffer,
const GtkTextIter *location,
GtkTextMark *mark)
{
if (GTK_SOURCE_IS_MARK (mark))
{
add_source_mark (GTK_SOURCE_BUFFER (buffer),
GTK_SOURCE_MARK (mark));
g_signal_emit (buffer, buffer_signals[SOURCE_MARK_UPDATED], 0, mark);
}
else if (mark == gtk_text_buffer_get_insert (buffer))
{
cursor_moved (GTK_SOURCE_BUFFER (buffer));
}
GTK_TEXT_BUFFER_CLASS (gtk_source_buffer_parent_class)->mark_set (buffer, location, mark);
}
static void
gtk_source_buffer_real_mark_deleted (GtkTextBuffer *buffer,
GtkTextMark *mark)
{
if (GTK_SOURCE_IS_MARK (mark))
{
GtkSourceBuffer *source_buffer = GTK_SOURCE_BUFFER (buffer);
const gchar *category;
GtkSourceMarksSequence *seq;
category = gtk_source_mark_get_category (GTK_SOURCE_MARK (mark));
seq = g_hash_table_lookup (source_buffer->priv->source_marks, category);
if (_gtk_source_marks_sequence_is_empty (seq))
{
g_hash_table_remove (source_buffer->priv->source_marks, category);
}
g_signal_emit (buffer, buffer_signals[SOURCE_MARK_UPDATED], 0, mark);
}
if (GTK_TEXT_BUFFER_CLASS (gtk_source_buffer_parent_class)->mark_deleted != NULL)
{
GTK_TEXT_BUFFER_CLASS (gtk_source_buffer_parent_class)->mark_deleted (buffer, mark);
}
}
static void
gtk_source_buffer_real_undo (GtkSourceBuffer *buffer)
{
g_return_if_fail (gtk_source_undo_manager_can_undo (buffer->priv->undo_manager));
gtk_source_undo_manager_undo (buffer->priv->undo_manager);
}
static void
gtk_source_buffer_real_redo (GtkSourceBuffer *buffer)
{
g_return_if_fail (gtk_source_undo_manager_can_redo (buffer->priv->undo_manager));
gtk_source_undo_manager_redo (buffer->priv->undo_manager);
}
/**
* gtk_source_buffer_create_source_mark:
* @buffer: a #GtkSourceBuffer.
* @name: (nullable): the name of the mark, or %NULL.
* @category: a string defining the mark category.
* @where: location to place the mark.
*
* Creates a source mark in the @buffer of category @category. A source mark is
* a #GtkTextMark but organised into categories. Depending on the category
* a pixbuf can be specified that will be displayed along the line of the mark.
*
* Like a #GtkTextMark, a #GtkSourceMark can be anonymous if the
* passed @name is %NULL. Also, the buffer owns the marks so you
* shouldn't unreference it.
*
* Marks always have left gravity and are moved to the beginning of
* the line when the user deletes the line they were in.
*
* Typical uses for a source mark are bookmarks, breakpoints, current
* executing instruction indication in a source file, etc..
*
* Returns: (transfer none): a new #GtkSourceMark, owned by the buffer.
*
* Since: 2.2
*/
GtkSourceMark *
gtk_source_buffer_create_source_mark (GtkSourceBuffer *buffer,
const gchar *name,
const gchar *category,
const GtkTextIter *where)
{
GtkSourceMark *mark;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
g_return_val_if_fail (category != NULL, NULL);
g_return_val_if_fail (where != NULL, NULL);
mark = gtk_source_mark_new (name, category);
gtk_text_buffer_add_mark (GTK_TEXT_BUFFER (buffer),
GTK_TEXT_MARK (mark),
where);
/* We want to return a borrowed reference and the mark is already
* owned by @buffer due to gtk_text_buffer_add_mark(). Therefore
* it is safe to unref immediately.
*/
g_object_unref (mark);
return mark;
}
static GtkSourceMarksSequence *
get_marks_sequence (GtkSourceBuffer *buffer,
const gchar *category)
{
return category == NULL ?
buffer->priv->all_source_marks :
g_hash_table_lookup (buffer->priv->source_marks, category);
}
GtkSourceMark *
_gtk_source_buffer_source_mark_next (GtkSourceBuffer *buffer,
GtkSourceMark *mark,
const gchar *category)
{
GtkSourceMarksSequence *seq;
GtkTextMark *next_mark;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
seq = get_marks_sequence (buffer, category);
if (seq == NULL)
{
return NULL;
}
next_mark = _gtk_source_marks_sequence_next (seq, GTK_TEXT_MARK (mark));
return next_mark == NULL ? NULL : GTK_SOURCE_MARK (next_mark);
}
GtkSourceMark *
_gtk_source_buffer_source_mark_prev (GtkSourceBuffer *buffer,
GtkSourceMark *mark,
const gchar *category)
{
GtkSourceMarksSequence *seq;
GtkTextMark *prev_mark;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
seq = get_marks_sequence (buffer, category);
if (seq == NULL)
{
return NULL;
}
prev_mark = _gtk_source_marks_sequence_prev (seq, GTK_TEXT_MARK (mark));
return prev_mark == NULL ? NULL : GTK_SOURCE_MARK (prev_mark);
}
/**
* gtk_source_buffer_forward_iter_to_source_mark:
* @buffer: a #GtkSourceBuffer.
* @iter: an iterator.
* @category: (nullable): category to search for, or %NULL
*
* Moves @iter to the position of the next #GtkSourceMark of the given
* @category. Returns %TRUE if @iter was moved. If @category is NULL, the
* next source mark can be of any category.
*
* Returns: whether @iter was moved.
*
* Since: 2.2
*/
gboolean
gtk_source_buffer_forward_iter_to_source_mark (GtkSourceBuffer *buffer,
GtkTextIter *iter,
const gchar *category)
{
GtkSourceMarksSequence *seq;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
seq = get_marks_sequence (buffer, category);
if (seq == NULL)
{
return FALSE;
}
return _gtk_source_marks_sequence_forward_iter (seq, iter);
}
/**
* gtk_source_buffer_backward_iter_to_source_mark:
* @buffer: a #GtkSourceBuffer.
* @iter: an iterator.
* @category: (nullable): category to search for, or %NULL
*
* Moves @iter to the position of the previous #GtkSourceMark of the given
* category. Returns %TRUE if @iter was moved. If @category is NULL, the
* previous source mark can be of any category.
*
* Returns: whether @iter was moved.
*
* Since: 2.2
*/
gboolean
gtk_source_buffer_backward_iter_to_source_mark (GtkSourceBuffer *buffer,
GtkTextIter *iter,
const gchar *category)
{
GtkSourceMarksSequence *seq;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
seq = get_marks_sequence (buffer, category);
if (seq == NULL)
{
return FALSE;
}
return _gtk_source_marks_sequence_backward_iter (seq, iter);
}
/**
* gtk_source_buffer_get_source_marks_at_iter:
* @buffer: a #GtkSourceBuffer.
* @iter: an iterator.
* @category: (nullable): category to search for, or %NULL
*
* Returns the list of marks of the given category at @iter. If @category
* is %NULL it returns all marks at @iter.
*
* Returns: (element-type GtkSource.Mark) (transfer container):
* a newly allocated #GSList.
*
* Since: 2.2
*/
GSList *
gtk_source_buffer_get_source_marks_at_iter (GtkSourceBuffer *buffer,
GtkTextIter *iter,
const gchar *category)
{
GtkSourceMarksSequence *seq;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
g_return_val_if_fail (iter != NULL, NULL);
seq = get_marks_sequence (buffer, category);
if (seq == NULL)
{
return NULL;
}
return _gtk_source_marks_sequence_get_marks_at_iter (seq, iter);
}
/**
* gtk_source_buffer_get_source_marks_at_line:
* @buffer: a #GtkSourceBuffer.
* @line: a line number.
* @category: (nullable): category to search for, or %NULL
*
* Returns the list of marks of the given category at @line.
* If @category is %NULL, all marks at @line are returned.
*
* Returns: (element-type GtkSource.Mark) (transfer container):
* a newly allocated #GSList.
*
* Since: 2.2
*/
GSList *
gtk_source_buffer_get_source_marks_at_line (GtkSourceBuffer *buffer,
gint line,
const gchar *category)
{
GtkSourceMarksSequence *seq;
GtkTextIter start;
GtkTextIter end;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
seq = get_marks_sequence (buffer, category);
if (seq == NULL)
{
return NULL;
}
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (buffer),
&start,
line);
end = start;
if (!gtk_text_iter_ends_line (&end))
{
gtk_text_iter_forward_to_line_end (&end);
}
return _gtk_source_marks_sequence_get_marks_in_range (seq, &start, &end);
}
/**
* gtk_source_buffer_remove_source_marks:
* @buffer: a #GtkSourceBuffer.
* @start: a #GtkTextIter.
* @end: a #GtkTextIter.
* @category: (nullable): category to search for, or %NULL.
*
* Remove all marks of @category between @start and @end from the buffer.
* If @category is NULL, all marks in the range will be removed.
*
* Since: 2.2
*/
void
gtk_source_buffer_remove_source_marks (GtkSourceBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end,
const gchar *category)
{
GtkSourceMarksSequence *seq;
GSList *list;
GSList *l;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
seq = get_marks_sequence (buffer, category);
if (seq == NULL)
{
return;
}
list = _gtk_source_marks_sequence_get_marks_in_range (seq, start, end);
for (l = list; l != NULL; l = l->next)
{
gtk_text_buffer_delete_mark (GTK_TEXT_BUFFER (buffer), l->data);
}
g_slist_free (list);
}
static GtkTextTag *
get_context_class_tag (GtkSourceBuffer *buffer,
const gchar *context_class)
{
gchar *tag_name;
GtkTextTagTable *tag_table;
GtkTextTag *tag;
tag_name = g_strdup_printf (CONTEXT_CLASSES_PREFIX "%s", context_class);
tag_table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (buffer));
tag = gtk_text_tag_table_lookup (tag_table, tag_name);
g_free (tag_name);
return tag;
}
/**
* gtk_source_buffer_iter_has_context_class:
* @buffer: a #GtkSourceBuffer.
* @iter: a #GtkTextIter.
* @context_class: class to search for.
*
* Check if the class @context_class is set on @iter.
*
* See the #GtkSourceBuffer description for the list of default context classes.
*
* Returns: whether @iter has the context class.
* Since: 2.10
*/
gboolean
gtk_source_buffer_iter_has_context_class (GtkSourceBuffer *buffer,
const GtkTextIter *iter,
const gchar *context_class)
{
GtkTextTag *tag;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (context_class != NULL, FALSE);
tag = get_context_class_tag (buffer, context_class);
if (tag != NULL)
{
return gtk_text_iter_has_tag (iter, tag);
}
return FALSE;
}
/**
* gtk_source_buffer_get_context_classes_at_iter:
* @buffer: a #GtkSourceBuffer.
* @iter: a #GtkTextIter.
*
* Get all defined context classes at @iter.
*
* See the #GtkSourceBuffer description for the list of default context classes.
*
* Returns: (array zero-terminated=1) (transfer full): a new %NULL
* terminated array of context class names.
* Use g_strfreev() to free the array if it is no longer needed.
*
* Since: 2.10
*/
gchar **
gtk_source_buffer_get_context_classes_at_iter (GtkSourceBuffer *buffer,
const GtkTextIter *iter)
{
const gsize prefix_len = strlen (CONTEXT_CLASSES_PREFIX);
GSList *tags;
GSList *l;
GPtrArray *ret;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
g_return_val_if_fail (iter != NULL, NULL);
tags = gtk_text_iter_get_tags (iter);
ret = g_ptr_array_new ();
for (l = tags; l != NULL; l = l->next)
{
GtkTextTag *tag = l->data;
gchar *tag_name;
g_object_get (tag, "name", &tag_name, NULL);
if (tag_name != NULL &&
g_str_has_prefix (tag_name, CONTEXT_CLASSES_PREFIX))
{
gchar *context_class_name = g_strdup (tag_name + prefix_len);
g_ptr_array_add (ret, context_class_name);
}
g_free (tag_name);
}
g_slist_free (tags);
g_ptr_array_add (ret, NULL);
return (gchar **) g_ptr_array_free (ret, FALSE);
}
/**
* gtk_source_buffer_iter_forward_to_context_class_toggle:
* @buffer: a #GtkSourceBuffer.
* @iter: a #GtkTextIter.
* @context_class: the context class.
*
* Moves forward to the next toggle (on or off) of the context class. If no
* matching context class toggles are found, returns %FALSE, otherwise %TRUE.
* Does not return toggles located at @iter, only toggles after @iter. Sets
* @iter to the location of the toggle, or to the end of the buffer if no
* toggle is found.
*
* See the #GtkSourceBuffer description for the list of default context classes.
*
* Returns: whether we found a context class toggle after @iter
*
* Since: 2.10
*/
gboolean
gtk_source_buffer_iter_forward_to_context_class_toggle (GtkSourceBuffer *buffer,
GtkTextIter *iter,
const gchar *context_class)
{
GtkTextTag *tag;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (context_class != NULL, FALSE);
tag = get_context_class_tag (buffer, context_class);
if (tag != NULL)
{
return gtk_text_iter_forward_to_tag_toggle (iter, tag);
}
return FALSE;
}
/**
* gtk_source_buffer_iter_backward_to_context_class_toggle:
* @buffer: a #GtkSourceBuffer.
* @iter: a #GtkTextIter.
* @context_class: the context class.
*
* Moves backward to the next toggle (on or off) of the context class. If no
* matching context class toggles are found, returns %FALSE, otherwise %TRUE.
* Does not return toggles located at @iter, only toggles after @iter. Sets
* @iter to the location of the toggle, or to the end of the buffer if no
* toggle is found.
*
* See the #GtkSourceBuffer description for the list of default context classes.
*
* Returns: whether we found a context class toggle before @iter
*
* Since: 2.10
*/
gboolean
gtk_source_buffer_iter_backward_to_context_class_toggle (GtkSourceBuffer *buffer,
GtkTextIter *iter,
const gchar *context_class)
{
GtkTextTag *tag;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (context_class != NULL, FALSE);
tag = get_context_class_tag (buffer, context_class);
if (tag != NULL)
{
return gtk_text_iter_backward_to_tag_toggle (iter, tag);
}
return FALSE;
}
/*
* GtkTextView wastes a lot of time tracking the clipboard content if
* we do insert/delete operations while there is a selection.
* These two utilities store the current selection with marks before
* doing an edit operation and restore it at the end.
*/
void
_gtk_source_buffer_save_and_clear_selection (GtkSourceBuffer *buffer)
{
GtkTextBuffer *buf;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
buf = GTK_TEXT_BUFFER (buffer);
/* Note we cannot use buffer_get_selection_bounds since it
* orders the iters while we want to know the position of
* each mark.
*/
if (gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (buffer)))
{
GtkTextIter insert_iter;
GtkTextIter selection_bound_iter;
g_assert (buffer->priv->tmp_insert_mark == NULL);
g_assert (buffer->priv->tmp_selection_bound_mark == NULL);
gtk_text_buffer_get_iter_at_mark (buf, &insert_iter, gtk_text_buffer_get_insert (buf));
gtk_text_buffer_get_iter_at_mark (buf, &selection_bound_iter, gtk_text_buffer_get_selection_bound (buf));
buffer->priv->tmp_insert_mark = gtk_text_buffer_create_mark (buf, NULL, &insert_iter, FALSE);
buffer->priv->tmp_selection_bound_mark = gtk_text_buffer_create_mark (buf, NULL, &selection_bound_iter, FALSE);
gtk_text_buffer_place_cursor (buf, &insert_iter);
}
}
void
_gtk_source_buffer_restore_selection (GtkSourceBuffer *buffer)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
if (buffer->priv->tmp_insert_mark != NULL &&
buffer->priv->tmp_selection_bound_mark != NULL)
{
GtkTextBuffer *buf;
GtkTextIter insert_iter;
GtkTextIter selection_bound_iter;
buf = GTK_TEXT_BUFFER (buffer);
gtk_text_buffer_get_iter_at_mark (buf, &insert_iter, buffer->priv->tmp_insert_mark);
gtk_text_buffer_get_iter_at_mark (buf, &selection_bound_iter, buffer->priv->tmp_selection_bound_mark);
gtk_text_buffer_select_range (buf, &insert_iter, &selection_bound_iter);
gtk_text_buffer_delete_mark (buf, buffer->priv->tmp_insert_mark);
gtk_text_buffer_delete_mark (buf, buffer->priv->tmp_selection_bound_mark);
buffer->priv->tmp_insert_mark = NULL;
buffer->priv->tmp_selection_bound_mark = NULL;
}
}
static gchar *
do_lower_case (GtkTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end)
{
gchar *text;
gchar *new_text;
text = gtk_text_buffer_get_text (buffer, start, end, TRUE);
new_text = g_utf8_strdown (text, -1);
g_free (text);
return new_text;
}
static gchar *
do_upper_case (GtkTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end)
{
gchar *text;
gchar *new_text;
text = gtk_text_buffer_get_text (buffer, start, end, TRUE);
new_text = g_utf8_strup (text, -1);
g_free (text);
return new_text;
}
static gchar *
do_toggle_case (GtkTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end)
{
GString *str;
GtkTextIter iter_start;
str = g_string_new (NULL);
iter_start = *start;
while (!gtk_text_iter_is_end (&iter_start))
{
GtkTextIter iter_end;
gchar *text;
gchar *text_down;
gchar *text_up;
iter_end = iter_start;
gtk_text_iter_forward_cursor_position (&iter_end);
if (gtk_text_iter_compare (end, &iter_end) < 0)
{
break;
}
text = gtk_text_buffer_get_text (buffer, &iter_start, &iter_end, TRUE);
text_down = g_utf8_strdown (text, -1);
text_up = g_utf8_strup (text, -1);
if (g_strcmp0 (text, text_down) == 0)
{
g_string_append (str, text_up);
}
else if (g_strcmp0 (text, text_up) == 0)
{
g_string_append (str, text_down);
}
else
{
g_string_append (str, text);
}
g_free (text);
g_free (text_down);
g_free (text_up);
iter_start = iter_end;
}
return g_string_free (str, FALSE);
}
static gchar *
do_title_case (GtkTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end)
{
GString *str;
GtkTextIter iter_start;
str = g_string_new (NULL);
iter_start = *start;
while (!gtk_text_iter_is_end (&iter_start))
{
GtkTextIter iter_end;
gchar *text;
iter_end = iter_start;
gtk_text_iter_forward_cursor_position (&iter_end);
if (gtk_text_iter_compare (end, &iter_end) < 0)
{
break;
}
text = gtk_text_buffer_get_text (buffer, &iter_start, &iter_end, TRUE);
if (gtk_text_iter_starts_word (&iter_start))
{
gchar *text_normalized;
text_normalized = g_utf8_normalize (text, -1, G_NORMALIZE_DEFAULT);
if (g_utf8_strlen (text_normalized, -1) == 1)
{
gunichar c;
gunichar new_c;
c = gtk_text_iter_get_char (&iter_start);
new_c = g_unichar_totitle (c);
g_string_append_unichar (str, new_c);
}
else
{
gchar *text_up;
text_up = g_utf8_strup (text, -1);
g_string_append (str, text_up);
g_free (text_up);
}
g_free (text_normalized);
}
else
{
gchar *text_down;
text_down = g_utf8_strdown (text, -1);
g_string_append (str, text_down);
g_free (text_down);
}
g_free (text);
iter_start = iter_end;
}
return g_string_free (str, FALSE);
}
/**
* gtk_source_buffer_change_case:
* @buffer: a #GtkSourceBuffer.
* @case_type: how to change the case.
* @start: a #GtkTextIter.
* @end: a #GtkTextIter.
*
* Changes the case of the text between the specified iterators.
*
* Since: 3.12
*/
void
gtk_source_buffer_change_case (GtkSourceBuffer *buffer,
GtkSourceChangeCaseType case_type,
GtkTextIter *start,
GtkTextIter *end)
{
GtkTextBuffer *text_buffer;
gchar *new_text;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
gtk_text_iter_order (start, end);
text_buffer = GTK_TEXT_BUFFER (buffer);
switch (case_type)
{
case GTK_SOURCE_CHANGE_CASE_LOWER:
new_text = do_lower_case (text_buffer, start, end);
break;
case GTK_SOURCE_CHANGE_CASE_UPPER:
new_text = do_upper_case (text_buffer, start, end);
break;
case GTK_SOURCE_CHANGE_CASE_TOGGLE:
new_text = do_toggle_case (text_buffer, start, end);
break;
case GTK_SOURCE_CHANGE_CASE_TITLE:
new_text = do_title_case (text_buffer, start, end);
break;
default:
g_return_if_reached ();
}
gtk_text_buffer_begin_user_action (text_buffer);
gtk_text_buffer_delete (text_buffer, start, end);
gtk_text_buffer_insert (text_buffer, start, new_text, -1);
gtk_text_buffer_end_user_action (text_buffer);
g_free (new_text);
}
/* Move to the end of the line excluding trailing spaces. */
static void
move_to_line_text_end(GtkTextIter *iter)
{
gint line;
line = gtk_text_iter_get_line (iter);
if (!gtk_text_iter_ends_line (iter))
{
gtk_text_iter_forward_to_line_end (iter);
}
while (gtk_text_iter_backward_char (iter) &&
(gtk_text_iter_get_line (iter) == line))
{
gunichar ch;
ch = gtk_text_iter_get_char (iter);
if (!g_unichar_isspace (ch))
{
break;
}
}
gtk_text_iter_forward_char (iter);
}
/**
* gtk_source_buffer_join_lines:
* @buffer: a #GtkSourceBuffer.
* @start: a #GtkTextIter.
* @end: a #GtkTextIter.
*
* Joins the lines of text between the specified iterators.
*
* Since: 3.16
*/
void
gtk_source_buffer_join_lines (GtkSourceBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end)
{
GtkTextBuffer *text_buffer;
GtkTextMark *end_mark;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
gtk_text_iter_order (start, end);
text_buffer = GTK_TEXT_BUFFER (buffer);
end_mark = gtk_text_buffer_create_mark (text_buffer, NULL, end, FALSE);
_gtk_source_buffer_save_and_clear_selection (buffer);
gtk_text_buffer_begin_user_action (text_buffer);
move_to_line_text_end (start);
if (!gtk_text_iter_ends_line (end))
{
gtk_text_iter_forward_to_line_end (end);
}
while (gtk_text_iter_compare (start, end) < 0)
{
GtkTextIter iter;
gunichar ch;
iter = *start;
do
{
ch = gtk_text_iter_get_char (&iter);
if (!g_unichar_isspace (ch))
{
break;
}
} while (gtk_text_iter_forward_char (&iter) &&
gtk_text_iter_compare (&iter, end) < 0);
if (!gtk_text_iter_is_end (&iter))
{
gtk_text_buffer_delete (text_buffer, start, &iter);
if (!gtk_text_iter_ends_line (start))
{
gtk_text_buffer_insert (text_buffer, start, " ", 1);
}
}
move_to_line_text_end (start);
gtk_text_buffer_get_iter_at_mark (text_buffer, end, end_mark);
}
gtk_text_buffer_end_user_action (text_buffer);
_gtk_source_buffer_restore_selection (buffer);
gtk_text_buffer_delete_mark (text_buffer, end_mark);
}
static gchar *
get_line_slice (GtkTextBuffer *buf,
gint line)
{
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_line (buf, &start, line);
end = start;
if (!gtk_text_iter_ends_line (&start))
{
gtk_text_iter_forward_to_line_end (&end);
}
return gtk_text_buffer_get_slice (buf, &start, &end, TRUE);
}
typedef struct {
gchar *line; /* the original text to re-insert */
gchar *key; /* the key to use for the comparison */
} SortLine;
static gint
compare_line (gconstpointer aptr,
gconstpointer bptr)
{
const SortLine *a = aptr;
const SortLine *b = bptr;
return g_strcmp0 (a->key, b->key);
}
static gint
compare_line_reversed (gconstpointer aptr,
gconstpointer bptr)
{
const SortLine *a = aptr;
const SortLine *b = bptr;
return g_strcmp0 (b->key, a->key);
}
/**
* gtk_source_buffer_sort_lines:
* @buffer: a #GtkSourceBuffer.
* @start: a #GtkTextIter.
* @end: a #GtkTextIter.
* @flags: #GtkSourceSortFlags specifying how the sort should behave
* @column: sort considering the text starting at the given column
*
* Sort the lines of text between the specified iterators.
*
* Since: 3.18
*/
void
gtk_source_buffer_sort_lines (GtkSourceBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end,
GtkSourceSortFlags flags,
gint column)
{
GtkTextBuffer *text_buffer;
gint start_line;
gint end_line;
gint num_lines;
SortLine *lines;
gchar *last_line = NULL;
gint i;
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
text_buffer = GTK_TEXT_BUFFER (buffer);
gtk_text_iter_order (start, end);
start_line = gtk_text_iter_get_line (start);
end_line = gtk_text_iter_get_line (end);
/* Required for gtk_text_buffer_delete() */
if (!gtk_text_iter_starts_line (start))
{
gtk_text_iter_set_line_offset (start, 0);
}
/* if we are at line start our last line is the previus one.
* Otherwise the last line is the current one but we try to
* move the iter after the line terminator */
if (gtk_text_iter_starts_line (end))
{
end_line = MAX (start_line, end_line - 1);
}
else
{
gtk_text_iter_forward_line (end);
}
if (start_line == end_line)
{
return;
}
num_lines = end_line - start_line + 1;
lines = g_new0 (SortLine, num_lines);
for (i = 0; i < num_lines; i++)
{
gchar *line;
gboolean free_line = FALSE;
glong length;
lines[i].line = get_line_slice (text_buffer, start_line + i);
if ((flags & GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE) != 0)
{
line = lines[i].line;
}
else
{
line = g_utf8_casefold (lines[i].line, -1);
free_line = TRUE;
}
length = g_utf8_strlen (line, -1);
if (length < column)
{
lines[i].key = NULL;
}
else if (column > 0)
{
gchar *substring;
substring = g_utf8_offset_to_pointer (line, column);
lines[i].key = g_utf8_collate_key (substring, -1);
}
else
{
lines[i].key = g_utf8_collate_key (line, -1);
}
if (free_line)
{
g_free (line);
}
}
if ((flags & GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER) != 0)
{
qsort (lines, num_lines, sizeof (SortLine), compare_line_reversed);
}
else
{
qsort (lines, num_lines, sizeof (SortLine), compare_line);
}
_gtk_source_buffer_save_and_clear_selection (buffer);
gtk_text_buffer_begin_user_action (text_buffer);
gtk_text_buffer_delete (text_buffer, start, end);
for (i = 0; i < num_lines; i++)
{
if ((flags & GTK_SOURCE_SORT_FLAGS_REMOVE_DUPLICATES) != 0 &&
g_strcmp0 (last_line, lines[i].line) == 0)
{
continue;
}
gtk_text_buffer_insert (text_buffer, start, lines[i].line, -1);
gtk_text_buffer_insert (text_buffer, start, "\n", -1);
last_line = lines[i].line;
}
gtk_text_buffer_end_user_action (text_buffer);
_gtk_source_buffer_restore_selection (buffer);
for (i = 0; i < num_lines; i++)
{
g_free (lines[i].line);
g_free (lines[i].key);
}
g_free (lines);
}
/**
* gtk_source_buffer_set_undo_manager:
* @buffer: a #GtkSourceBuffer.
* @manager: (nullable): A #GtkSourceUndoManager or %NULL.
*
* Set the buffer undo manager. If @manager is %NULL the default undo manager
* will be set.
*/
void
gtk_source_buffer_set_undo_manager (GtkSourceBuffer *buffer,
GtkSourceUndoManager *manager)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (manager == NULL || GTK_SOURCE_IS_UNDO_MANAGER (manager));
if (manager == NULL)
{
manager = g_object_new (GTK_SOURCE_TYPE_UNDO_MANAGER_DEFAULT,
"buffer", buffer,
"max-undo-levels", buffer->priv->max_undo_levels,
NULL);
}
else
{
g_object_ref (manager);
}
set_undo_manager (buffer, manager);
g_object_unref (manager);
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_UNDO_MANAGER]);
}
/**
* gtk_source_buffer_get_undo_manager:
* @buffer: a #GtkSourceBuffer.
*
* Returns the #GtkSourceUndoManager associated with the buffer,
* see gtk_source_buffer_set_undo_manager(). The returned object should not be
* unreferenced by the user.
*
* Returns: (nullable) (transfer none): the #GtkSourceUndoManager associated
* with the buffer, or %NULL.
*/
GtkSourceUndoManager *
gtk_source_buffer_get_undo_manager (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
return buffer->priv->undo_manager;
}
void
_gtk_source_buffer_add_search_context (GtkSourceBuffer *buffer,
GtkSourceSearchContext *search_context)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
g_return_if_fail (GTK_SOURCE_IS_SEARCH_CONTEXT (search_context));
g_return_if_fail (gtk_source_search_context_get_buffer (search_context) == buffer);
if (g_list_find (buffer->priv->search_contexts, search_context) != NULL)
{
return;
}
buffer->priv->search_contexts = g_list_prepend (buffer->priv->search_contexts,
search_context);
g_object_weak_ref (G_OBJECT (search_context),
(GWeakNotify)search_context_weak_notify_cb,
buffer);
}
static void
sync_invalid_char_tag (GtkSourceBuffer *buffer,
GParamSpec *pspec,
gpointer data)
{
GtkSourceStyle *style = NULL;
if (buffer->priv->style_scheme != NULL)
{
style = gtk_source_style_scheme_get_style (buffer->priv->style_scheme, "def:error");
}
gtk_source_style_apply (style, buffer->priv->invalid_char_tag);
}
static void
text_tag_set_highest_priority (GtkTextTag *tag,
GtkTextBuffer *buffer)
{
GtkTextTagTable *table;
gint n;
table = gtk_text_buffer_get_tag_table (buffer);
n = gtk_text_tag_table_get_size (table);
gtk_text_tag_set_priority (tag, n - 1);
}
void
_gtk_source_buffer_set_as_invalid_character (GtkSourceBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end)
{
if (buffer->priv->invalid_char_tag == NULL)
{
buffer->priv->invalid_char_tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer),
"invalid-char-style",
NULL);
sync_invalid_char_tag (buffer, NULL, NULL);
g_signal_connect (buffer,
"notify::style-scheme",
G_CALLBACK (sync_invalid_char_tag),
NULL);
}
/* Make sure the 'error' tag has the priority over
* syntax highlighting tags.
*/
text_tag_set_highest_priority (buffer->priv->invalid_char_tag,
GTK_TEXT_BUFFER (buffer));
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer),
buffer->priv->invalid_char_tag,
start,
end);
}
gboolean
_gtk_source_buffer_has_invalid_chars (GtkSourceBuffer *buffer)
{
GtkTextIter start;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), FALSE);
if (buffer->priv->invalid_char_tag == NULL)
{
return FALSE;
}
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &start);
if (gtk_text_iter_starts_tag (&start, buffer->priv->invalid_char_tag) ||
gtk_text_iter_forward_to_tag_toggle (&start, buffer->priv->invalid_char_tag))
{
return TRUE;
}
return FALSE;
}
/**
* gtk_source_buffer_set_implicit_trailing_newline:
* @buffer: a #GtkSourceBuffer.
* @implicit_trailing_newline: the new value.
*
* Sets whether the @buffer has an implicit trailing newline.
*
* If an explicit trailing newline is present in a #GtkTextBuffer, #GtkTextView
* shows it as an empty line. This is generally not what the user expects.
*
* If @implicit_trailing_newline is %TRUE (the default value):
* - when a #GtkSourceFileLoader loads the content of a file into the @buffer,
* the trailing newline (if present in the file) is not inserted into the
* @buffer.
* - when a #GtkSourceFileSaver saves the content of the @buffer into a file, a
* trailing newline is added to the file.
*
* On the other hand, if @implicit_trailing_newline is %FALSE, the file's
* content is not modified when loaded into the @buffer, and the @buffer's
* content is not modified when saved into a file.
*
* Since: 3.14
*/
void
gtk_source_buffer_set_implicit_trailing_newline (GtkSourceBuffer *buffer,
gboolean implicit_trailing_newline)
{
g_return_if_fail (GTK_SOURCE_IS_BUFFER (buffer));
implicit_trailing_newline = implicit_trailing_newline != FALSE;
if (buffer->priv->implicit_trailing_newline != implicit_trailing_newline)
{
buffer->priv->implicit_trailing_newline = implicit_trailing_newline;
g_object_notify_by_pspec (G_OBJECT (buffer), buffer_properties[PROP_IMPLICIT_TRAILING_NEWLINE]);
}
}
/**
* gtk_source_buffer_get_implicit_trailing_newline:
* @buffer: a #GtkSourceBuffer.
*
* Returns: whether the @buffer has an implicit trailing newline.
* Since: 3.14
*/
gboolean
gtk_source_buffer_get_implicit_trailing_newline (GtkSourceBuffer *buffer)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), TRUE);
return buffer->priv->implicit_trailing_newline;
}
/**
* gtk_source_buffer_create_source_tag:
* @buffer: a #GtkSourceBuffer
* @tag_name: (nullable): name of the new tag, or %NULL
* @first_property_name: (nullable): name of first property to set, or %NULL
* @...: %NULL-terminated list of property names and values
*
* In short, this is the same function as gtk_text_buffer_create_tag(), but
* instead of creating a #GtkTextTag, this function creates a #GtkSourceTag.
*
* This function creates a #GtkSourceTag and adds it to the tag table for
* @buffer. Equivalent to calling gtk_text_tag_new() and then adding the tag to
* the buffer’s tag table. The returned tag is owned by the buffer’s tag table,
* so the ref count will be equal to one.
*
* If @tag_name is %NULL, the tag is anonymous.
*
* If @tag_name is non-%NULL, a tag called @tag_name must not already
* exist in the tag table for this buffer.
*
* The @first_property_name argument and subsequent arguments are a list
* of properties to set on the tag, as with g_object_set().
*
* Returns: (transfer none): a new #GtkSourceTag.
* Since: 3.20
*/
GtkTextTag *
gtk_source_buffer_create_source_tag (GtkSourceBuffer *buffer,
const gchar *tag_name,
const gchar *first_property_name,
...)
{
GtkTextTag *tag;
GtkTextTagTable *table;
va_list list;
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER (buffer), NULL);
tag = gtk_source_tag_new (tag_name);
table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (buffer));
if (!gtk_text_tag_table_add (table, tag))
{
g_object_unref (tag);
return NULL;
}
if (first_property_name != NULL)
{
va_start (list, first_property_name);
g_object_set_valist (G_OBJECT (tag), first_property_name, list);
va_end (list);
}
g_object_unref (tag);
return tag;
}