[gtksourceview/wip/chergert/gsv-gtk4: 74/125] gutter: add GtkSourceGutterLines
- From: Christian Hergert <chergert src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtksourceview/wip/chergert/gsv-gtk4: 74/125] gutter: add GtkSourceGutterLines
- Date: Wed, 15 Jan 2020 23:52:35 +0000 (UTC)
commit 3ad74d9dc0e6ce23a7ecea6137e97504630373d2
Author: Christian Hergert <chergert redhat com>
Date: Wed Jan 15 13:47:45 2020 -0800
gutter: add GtkSourceGutterLines
This new object provides an abstraction over tracking line information
while working with gutters. In particular, it can help avoid many costly
iterations over the text B-Tree.
docs/reference/meson.build | 1 +
gtksourceview/gtksource.h | 1 +
gtksourceview/gtksourcegutterlines.c | 657 +++++++++++++++++++++++++++++++++++
gtksourceview/gtksourcegutterlines.h | 96 +++++
gtksourceview/meson.build | 2 +
gtksourceview/quarkset-inline.h | 185 ++++++++++
6 files changed, 942 insertions(+)
---
diff --git a/docs/reference/meson.build b/docs/reference/meson.build
index 53bd38fa..ba0e45c5 100644
--- a/docs/reference/meson.build
+++ b/docs/reference/meson.build
@@ -41,6 +41,7 @@ reference_private_h = [
'gtksourcetypes-private.h',
'gtksourceundomanagerdefault.h',
'gtksourceutils-private.h',
+ 'quarkset-inline.h',
]
reference_content_files = files([
diff --git a/gtksourceview/gtksource.h b/gtksourceview/gtksource.h
index 2f795750..517c06ae 100644
--- a/gtksourceview/gtksource.h
+++ b/gtksourceview/gtksource.h
@@ -39,6 +39,7 @@
#include "gtksourceinit.h"
#include "gtksourcelanguage.h"
#include "gtksourcelanguagemanager.h"
+#include "gtksourcegutterlines.h"
#include "gtksourcemap.h"
#include "gtksourcemark.h"
#include "gtksourcemarkattributes.h"
diff --git a/gtksourceview/gtksourcegutterlines.c b/gtksourceview/gtksourcegutterlines.c
new file mode 100644
index 00000000..718bae2c
--- /dev/null
+++ b/gtksourceview/gtksourcegutterlines.c
@@ -0,0 +1,657 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- /
+ *
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2019 - 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 "gtksourcegutterlines.h"
+#include "gtksourcegutterlines-private.h"
+
+#include "quarkset-inline.h"
+
+/**
+ * SECTION:gutterlines
+ * @title: GtkSourceGutterLines
+ * @short_description: Collected information about visible lines
+ *
+ * The #GtkSourceGutterLines object is used to collect information about
+ * visible lines.
+ *
+ * Use this from your #GtkSourceGutterRenderer::query-data to collect the
+ * necessary information on visible lines. Doing so reduces the number of
+ * passes through the text btree allowing GtkSourceView to reach more
+ * frames-per-second while performing kinetic scrolling.
+ *
+ * Since: 5.0
+ */
+
+struct _GtkSourceGutterLines
+{
+ GObject parent_instance;
+ GtkTextView *view;
+ GArray *lines;
+ GdkRectangle visible_rect;
+ guint first;
+ guint last;
+ guint cursor_line;
+};
+
+typedef struct
+{
+ QuarkSet classes;
+ gint y;
+ gint height;
+ gint first_height;
+ gint last_height;
+} LineInfo;
+
+G_DEFINE_TYPE (GtkSourceGutterLines, gtk_source_gutter_lines, G_TYPE_OBJECT)
+
+static GQuark q_cursor_line;
+static GQuark q_prelit;
+static GQuark q_selected;
+
+static void
+gtk_source_gutter_lines_finalize (GObject *object)
+{
+ GtkSourceGutterLines *lines = (GtkSourceGutterLines *)object;
+
+ g_clear_pointer (&lines->lines, g_array_unref);
+ g_clear_object (&lines->view);
+
+ G_OBJECT_CLASS (gtk_source_gutter_lines_parent_class)->finalize (object);
+}
+
+static void
+gtk_source_gutter_lines_class_init (GtkSourceGutterLinesClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = gtk_source_gutter_lines_finalize;
+
+ q_cursor_line = g_quark_from_static_string ("cursor-line");
+ q_prelit = g_quark_from_static_string ("prelit");
+ q_selected = g_quark_from_static_string ("selected");
+}
+
+static void
+gtk_source_gutter_lines_init (GtkSourceGutterLines *self)
+{
+ self->cursor_line = -1;
+}
+
+static void
+clear_line_info (gpointer data)
+{
+ LineInfo *info = data;
+
+ info->y = 0;
+ info->height = 0;
+ quark_set_clear (&info->classes);
+}
+
+GtkSourceGutterLines *
+_gtk_source_gutter_lines_new (GtkTextView *text_view,
+ const GtkTextIter *begin,
+ const GtkTextIter *end,
+ gboolean needs_wrap_first,
+ gboolean needs_wrap_last)
+{
+ GtkSourceGutterLines *lines;
+ GtkTextBuffer *buffer;
+ GtkTextMark *mark;
+ GtkTextIter iter;
+ gboolean single_line;
+ guint cursor_line;
+ guint i;
+
+ g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
+ g_return_val_if_fail (begin != NULL, NULL);
+ g_return_val_if_fail (end != NULL, NULL);
+ g_return_val_if_fail (begin != end, NULL);
+
+ buffer = gtk_text_view_get_buffer (text_view);
+
+ g_return_val_if_fail (gtk_text_iter_get_buffer (begin) == buffer, NULL);
+ g_return_val_if_fail (gtk_text_iter_get_buffer (end) == buffer, NULL);
+
+ if (gtk_text_iter_compare (begin, end) > 0)
+ {
+ const GtkTextIter *tmp = begin;
+ begin = end;
+ end = tmp;
+ }
+
+ g_return_val_if_fail (begin != end, NULL);
+
+ lines = g_object_new (GTK_SOURCE_TYPE_GUTTER_LINES, NULL);
+ lines->view = g_object_ref (text_view);
+ lines->first = gtk_text_iter_get_line (begin);
+ lines->last = gtk_text_iter_get_line (end);
+ lines->lines = g_array_sized_new (FALSE,
+ FALSE,
+ sizeof (LineInfo),
+ lines->last - lines->first + 1);
+ g_array_set_clear_func (lines->lines, clear_line_info);
+ gtk_text_view_get_visible_rect (text_view, &lines->visible_rect);
+
+ /* No need to calculate special wrapping if wrap mode is none */
+ if (gtk_text_view_get_wrap_mode (text_view) == GTK_WRAP_NONE)
+ {
+ needs_wrap_first = FALSE;
+ needs_wrap_last = FALSE;
+ }
+
+ single_line = !needs_wrap_first && !needs_wrap_last;
+
+ /* Get the line number containing the cursor to compare while
+ * building the lines to add the "cursor-line" quark.
+ */
+ mark = gtk_text_buffer_get_insert (buffer);
+ gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
+ cursor_line = gtk_text_iter_get_line (&iter);
+
+ lines->cursor_line = cursor_line;
+
+ iter = *begin;
+
+ if (!gtk_text_iter_starts_line (&iter))
+ {
+ gtk_text_iter_set_line_offset (&iter, 0);
+ }
+
+ for (i = lines->first; i <= lines->last; i++)
+ {
+ LineInfo info = {0};
+
+ if G_LIKELY (single_line)
+ {
+ GdkRectangle rect;
+
+ gtk_text_view_get_iter_location (text_view, &iter, &rect);
+
+ info.y = rect.y;
+ info.height = rect.height;
+ info.first_height = rect.height;
+ info.last_height = rect.height;
+ }
+ else
+ {
+ gtk_text_view_get_line_yrange (text_view,
+ &iter,
+ &info.y,
+ &info.height);
+
+ if (gtk_text_iter_starts_line (&iter) &&
+ gtk_text_iter_ends_line (&iter))
+ {
+ info.first_height = info.height;
+ info.last_height = info.height;
+ }
+ else
+ {
+ GdkRectangle rect;
+
+ if (needs_wrap_first)
+ {
+
+ gtk_text_view_get_iter_location (text_view,
+ &iter,
+ &rect);
+ info.first_height = rect.height;
+ }
+ else
+ {
+ info.first_height = info.height;
+ }
+
+ if (needs_wrap_last)
+ {
+ gtk_text_iter_forward_to_line_end (&iter);
+ gtk_text_view_get_iter_location (text_view,
+ &iter,
+ &rect);
+ info.last_height = rect.height;
+ }
+ else
+ {
+ info.last_height = info.height;
+ }
+ }
+ }
+
+ if G_UNLIKELY (i == cursor_line)
+ {
+ quark_set_add (&info.classes, q_cursor_line);
+ }
+
+ g_array_append_val (lines->lines, info);
+
+ if G_UNLIKELY (!gtk_text_iter_forward_line (&iter) &&
+ !gtk_text_iter_is_end (&iter))
+ {
+ break;
+ }
+ }
+
+ g_return_val_if_fail (lines->lines->len > 0, NULL);
+ g_return_val_if_fail ((lines->last - lines->first) >= (lines->lines->len - 1), NULL);
+
+ return g_steal_pointer (&lines);
+}
+
+/**
+ * gtk_source_gutter_lines_add_qclass:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ * @qname: a class name as a #GQuark
+ *
+ * Adds the class denoted by @qname to @line.
+ *
+ * You may check if a line has @qname by calling
+ * gtk_source_gutter_lines_has_qclass().
+ *
+ * You can remove @qname by calling
+ * gtk_source_gutter_lines_remove_qclass().
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_gutter_lines_add_qclass (GtkSourceGutterLines *lines,
+ guint line,
+ GQuark qname)
+{
+ LineInfo *info;
+
+ g_return_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines));
+ g_return_if_fail (qname != 0);
+ g_return_if_fail (line >= lines->first);
+ g_return_if_fail (line <= lines->last);
+ g_return_if_fail (line - lines->first < lines->lines->len);
+
+ info = &g_array_index (lines->lines, LineInfo, line - lines->first);
+ quark_set_add (&info->classes, qname);
+}
+
+/**
+ * gtk_source_gutter_lines_add_class:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ * @name: a class name
+ *
+ * Adds the class @name to @line.
+ *
+ * @name will be converted to a #GQuark as part of this process. A
+ * faster version of this function is available via
+ * gtk_source_gutter_lines_add_qclass() for situations where the #GQuark is
+ * known ahead of time.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_gutter_lines_add_class (GtkSourceGutterLines *lines,
+ guint line,
+ const gchar *name)
+{
+ g_return_if_fail (name != NULL);
+
+ gtk_source_gutter_lines_add_qclass (lines,
+ line,
+ g_quark_from_string (name));
+}
+
+/**
+ * gtk_source_gutter_lines_remove_class:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ * @name: a class name
+ *
+ * Removes the class matching @name from @line.
+ *
+ * A faster version of this function is available via
+ * gtk_source_gutter_lines_remove_qclass() for situations where the
+ * #GQuark is known ahead of time.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_gutter_lines_remove_class (GtkSourceGutterLines *lines,
+ guint line,
+ const gchar *name)
+{
+ GQuark qname;
+
+ g_return_if_fail (name != NULL);
+
+ qname = g_quark_try_string (name);
+
+ if (qname != 0)
+ {
+ gtk_source_gutter_lines_remove_qclass (lines, line, qname);
+ }
+}
+
+/**
+ * gtk_source_gutter_lines_remove_qclass:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ * @qname: a #GQuark to remove from @line
+ *
+ * Reverses a call to gtk_source_gutter_lines_add_qclass() by removing
+ * the #GQuark matching @qname.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_gutter_lines_remove_qclass (GtkSourceGutterLines *lines,
+ guint line,
+ GQuark qname)
+{
+ LineInfo *info;
+
+ g_return_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines));
+ g_return_if_fail (qname != 0);
+ g_return_if_fail (line >= lines->first);
+ g_return_if_fail (line <= lines->last);
+ g_return_if_fail (line - lines->first < lines->lines->len);
+
+ info = &g_array_index (lines->lines, LineInfo, line - lines->first);
+ quark_set_remove (&info->classes, qname);
+}
+
+/**
+ * gtk_source_gutter_lines_has_class:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ * @name: a class name that may be convered to a #GQuark
+ *
+ * Checks to see if gtk_source_gutter_lines_add_class() was called with
+ * the @name for @line.
+ *
+ * A faster version of this function is provided via
+ * gtk_source_gutter_lines_has_qclass() for situations where the quark
+ * is known ahead of time.
+ *
+ * Returns: %TRUE if @line contains @name
+ *
+ * Since: 5.0
+ */
+gboolean
+gtk_source_gutter_lines_has_class (GtkSourceGutterLines *lines,
+ guint line,
+ const gchar *name)
+{
+ GQuark qname;
+
+ g_return_val_if_fail (name != NULL, FALSE);
+
+ qname = g_quark_try_string (name);
+
+ if (qname == 0)
+ {
+ return FALSE;
+ }
+
+ return gtk_source_gutter_lines_has_qclass (lines, line, qname);
+}
+
+/**
+ * gtk_source_gutter_lines_has_qclass:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ * @qname: a #GQuark containing the class name
+ *
+ * Checks to see if gtk_source_gutter_lines_add_qclass() was called with
+ * the quark denoted by @qname for @line.
+ *
+ * Returns: %TRUE if @line contains @qname
+ *
+ * Since: 5.0
+ */
+gboolean
+gtk_source_gutter_lines_has_qclass (GtkSourceGutterLines *lines,
+ guint line,
+ GQuark qname)
+{
+ LineInfo *info;
+
+ g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines), FALSE);
+ g_return_val_if_fail (qname != 0, FALSE);
+ g_return_val_if_fail (line >= lines->first, FALSE);
+ g_return_val_if_fail (line <= lines->last, FALSE);
+ g_return_val_if_fail (line - lines->first < lines->lines->len, FALSE);
+
+ info = &g_array_index (lines->lines, LineInfo, line - lines->first);
+
+ return quark_set_contains (&info->classes, qname);
+}
+
+/**
+ * gtk_source_gutter_lines_is_cursor:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ *
+ * Checks to see if @line contains the insertion cursor.
+ *
+ * Returns: %TRUE if the insertion cursor is on @line
+ *
+ * Since: 5.0
+ */
+gboolean
+gtk_source_gutter_lines_is_cursor (GtkSourceGutterLines *lines,
+ guint line)
+{
+ return gtk_source_gutter_lines_has_qclass (lines, line, q_cursor_line);
+}
+
+/**
+ * gtk_source_gutter_lines_is_prelit:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ *
+ * Checks to see if @line is marked as prelit. Generally, this means
+ * the mouse pointer is over the line within the gutter.
+ *
+ * Returns: %TRUE if the line is prelit
+ *
+ * Since: 5.0
+ */
+gboolean
+gtk_source_gutter_lines_is_prelit (GtkSourceGutterLines *lines,
+ guint line)
+{
+ return gtk_source_gutter_lines_has_qclass (lines, line, q_prelit);
+}
+
+/**
+ * gtk_source_gutter_lines_is_selected:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ *
+ * Checks to see if the view had a selection and if that selection overlaps
+ * @line in some way.
+ *
+ * Returns: %TRUE if the line contains a selection
+ *
+ * Since: 5.0
+ */
+gboolean
+gtk_source_gutter_lines_is_selected (GtkSourceGutterLines *lines,
+ guint line)
+{
+ return gtk_source_gutter_lines_has_qclass (lines, line, q_selected);
+}
+
+/**
+ * gtk_source_gutter_lines_get_first:
+ * @lines: a #GtkSourceGutterLines
+ *
+ * Gets the line number (starting from 0) for the first line that is
+ * user visible.
+ *
+ * Returns: a line number starting from 0
+ *
+ * Since: 5.0
+ */
+guint
+gtk_source_gutter_lines_get_first (GtkSourceGutterLines *lines)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines), 0);
+
+ return lines->first;
+}
+
+/**
+ * gtk_source_gutter_lines_get_last:
+ * @lines: a #GtkSourceGutterLines
+ *
+ * Gets the line number (starting from 0) for the last line that is
+ * user visible.
+ *
+ * Returns: a line number starting from 0
+ *
+ * Since: 5.0
+ */
+guint
+gtk_source_gutter_lines_get_last (GtkSourceGutterLines *lines)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines), 0);
+
+ return lines->last;
+}
+
+/**
+ * gtk_source_gutter_lines_get_iter_at_line:
+ * @lines: a #GtkSourceGutterLines
+ * @iter: (out): a location for a #GtkTextIter
+ * @line: the line number
+ *
+ * Gets a #GtkTextIter for the current buffer at @line
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_gutter_lines_get_iter_at_line (GtkSourceGutterLines *lines,
+ GtkTextIter *iter,
+ guint line)
+{
+ GtkTextBuffer *buffer;
+
+ g_return_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines));
+ g_return_if_fail (iter != NULL);
+
+ buffer = gtk_text_view_get_buffer (lines->view);
+ gtk_text_buffer_get_iter_at_line (buffer, iter, line);
+}
+
+/**
+ * gtk_source_gutter_lines_get_view:
+ * @lines: a #GtkSourceGutterLines
+ *
+ * Gets the #GtkTextView that the #GtkSourceGutterLines represents.
+ *
+ * Returns: (transfer none) (not nullable): a #GtkTextView
+ *
+ * Since: 5.0
+ */
+GtkTextView *
+gtk_source_gutter_lines_get_view (GtkSourceGutterLines *lines)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines), NULL);
+
+ return lines->view;
+}
+
+/**
+ * gtk_source_gutter_lines_get_buffer:
+ * @lines: a #GtkSourceGutterLines
+ *
+ * Gets the #GtkTextBuffer that the #GtkSourceGutterLines represents.
+ *
+ * Returns: (transfer none) (not nullable): a #GtkTextBuffer
+ *
+ * Since: 5.0
+ */
+GtkTextBuffer *
+gtk_source_gutter_lines_get_buffer (GtkSourceGutterLines *lines)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines), NULL);
+
+ return gtk_text_view_get_buffer (lines->view);
+}
+
+/**
+ * gtk_source_gutter_lines_get_line_yrange:
+ * @lines: a #GtkSourceGutterLines
+ * @line: a line number starting from zero
+ * @mode: a #GtkSourceGutterRendererAlignmentMode
+ * @y: (out): a location for the Y position in widget coordinates
+ * @height: (out): the line height based on @mode
+ *
+ * Gets the Y range for a line based on @mode.
+ *
+ * The value for @y is relative to the renderers widget coordinates.
+ *
+ * Since: 5.0
+ */
+void
+gtk_source_gutter_lines_get_line_yrange (GtkSourceGutterLines *lines,
+ guint line,
+ GtkSourceGutterRendererAlignmentMode mode,
+ gint *y,
+ gint *height)
+{
+ LineInfo *info;
+
+ g_return_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines));
+ g_return_if_fail (line >= lines->first);
+ g_return_if_fail (line <= lines->last);
+
+ info = &g_array_index (lines->lines, LineInfo, line - lines->first);
+
+ if (mode == GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL)
+ {
+ *y = info->y;
+ *height = info->height;
+ }
+ else if (mode == GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST)
+ {
+ *y = info->y;
+ *height = info->first_height;
+ }
+ else if (mode == GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST)
+ {
+ *y = info->y + info->height - info->last_height;
+ *height = info->last_height;
+ }
+ else
+ {
+ g_return_if_reached ();
+ }
+
+ *y -= lines->visible_rect.y;
+}
+
+guint
+_gtk_source_gutter_lines_get_cursor_line (GtkSourceGutterLines *lines)
+{
+ g_return_val_if_fail (GTK_SOURCE_IS_GUTTER_LINES (lines), 0);
+
+ return lines->cursor_line;
+}
diff --git a/gtksourceview/gtksourcegutterlines.h b/gtksourceview/gtksourcegutterlines.h
new file mode 100644
index 00000000..173f27c1
--- /dev/null
+++ b/gtksourceview/gtksourcegutterlines.h
@@ -0,0 +1,96 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- /
+ *
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2019 - 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"
+#include "gtksourcegutterrenderer.h"
+
+G_BEGIN_DECLS
+
+#define GTK_SOURCE_TYPE_GUTTER_LINES (gtk_source_gutter_lines_get_type())
+
+GTK_SOURCE_AVAILABLE_IN_ALL
+G_DECLARE_FINAL_TYPE (GtkSourceGutterLines, gtk_source_gutter_lines, GTK_SOURCE, GUTTER_LINES, GObject)
+
+GTK_SOURCE_AVAILABLE_IN_ALL
+guint gtk_source_gutter_lines_get_first (GtkSourceGutterLines *lines);
+GTK_SOURCE_AVAILABLE_IN_ALL
+guint gtk_source_gutter_lines_get_last (GtkSourceGutterLines *lines);
+GTK_SOURCE_AVAILABLE_IN_ALL
+void gtk_source_gutter_lines_get_iter_at_line (GtkSourceGutterLines *lines,
+ GtkTextIter *iter,
+ guint line);
+GTK_SOURCE_AVAILABLE_IN_ALL
+GtkTextView *gtk_source_gutter_lines_get_view (GtkSourceGutterLines *lines);
+GTK_SOURCE_AVAILABLE_IN_ALL
+GtkTextBuffer *gtk_source_gutter_lines_get_buffer (GtkSourceGutterLines *lines);
+GTK_SOURCE_AVAILABLE_IN_ALL
+void gtk_source_gutter_lines_get_yrange (GtkSourceGutterLines *lines,
+ guint line,
+ guint *line_y,
+ guint *line_height);
+GTK_SOURCE_AVAILABLE_IN_ALL
+void gtk_source_gutter_lines_add_qclass (GtkSourceGutterLines *lines,
+ guint line,
+ GQuark qname);
+GTK_SOURCE_AVAILABLE_IN_ALL
+void gtk_source_gutter_lines_add_class (GtkSourceGutterLines *lines,
+ guint line,
+ const gchar *name);
+GTK_SOURCE_AVAILABLE_IN_ALL
+void gtk_source_gutter_lines_remove_class (GtkSourceGutterLines *lines,
+ guint line,
+ const gchar *name);
+GTK_SOURCE_AVAILABLE_IN_ALL
+void gtk_source_gutter_lines_remove_qclass (GtkSourceGutterLines *lines,
+ guint line,
+ GQuark qname);
+GTK_SOURCE_AVAILABLE_IN_ALL
+gboolean gtk_source_gutter_lines_has_class (GtkSourceGutterLines *lines,
+ guint line,
+ const gchar *name);
+GTK_SOURCE_AVAILABLE_IN_ALL
+gboolean gtk_source_gutter_lines_has_qclass (GtkSourceGutterLines *lines,
+ guint line,
+ GQuark qname);
+GTK_SOURCE_AVAILABLE_IN_ALL
+gboolean gtk_source_gutter_lines_is_cursor (GtkSourceGutterLines *lines,
+ guint line);
+GTK_SOURCE_AVAILABLE_IN_ALL
+gboolean gtk_source_gutter_lines_is_prelit (GtkSourceGutterLines *lines,
+ guint line);
+GTK_SOURCE_AVAILABLE_IN_ALL
+gboolean gtk_source_gutter_lines_is_selected (GtkSourceGutterLines *lines,
+ guint line);
+GTK_SOURCE_AVAILABLE_IN_ALL
+void gtk_source_gutter_lines_get_line_yrange (GtkSourceGutterLines *lines,
+ guint line,
+ GtkSourceGutterRendererAlignmentMode mode,
+ gint *y,
+ gint *height);
+
+G_END_DECLS
diff --git a/gtksourceview/meson.build b/gtksourceview/meson.build
index 3a27dde6..2b5e7567 100644
--- a/gtksourceview/meson.build
+++ b/gtksourceview/meson.build
@@ -25,6 +25,7 @@ core_public_h = files([
'gtksourceinit.h',
'gtksourcelanguage.h',
'gtksourcelanguagemanager.h',
+ 'gtksourcegutterlines.h',
'gtksourcemap.h',
'gtksourcemark.h',
'gtksourcemarkattributes.h',
@@ -64,6 +65,7 @@ core_public_c = files([
'gtksourceinit.c',
'gtksourcelanguage.c',
'gtksourcelanguagemanager.c',
+ 'gtksourcegutterlines.c',
'gtksourcemap.c',
'gtksourcemark.c',
'gtksourcemarkattributes.c',
diff --git a/gtksourceview/quarkset-inline.h b/gtksourceview/quarkset-inline.h
new file mode 100644
index 00000000..c744c0a2
--- /dev/null
+++ b/gtksourceview/quarkset-inline.h
@@ -0,0 +1,185 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- */
+/*
+ * This file is part of GtkSourceView
+ *
+ * Copyright 2019 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 <glib.h>
+
+G_BEGIN_DECLS
+
+typedef struct _QuarkSet
+{
+ gint32 len;
+ union {
+ GQuark embed[2];
+ GQuark *alloc;
+ } u;
+} QuarkSet;
+
+static inline gboolean
+quark_set_is_embed (QuarkSet *set)
+{
+ return set->len >= 0;
+}
+
+static inline void
+quark_set_clear (QuarkSet *set)
+{
+ if (set->len < 0)
+ {
+ g_free (set->u.alloc);
+ }
+
+ set->len = 0;
+ set->u.alloc = NULL;
+}
+
+static inline gboolean
+quark_set_contains (QuarkSet *set,
+ GQuark quark)
+{
+ GQuark *quarks;
+ guint i;
+ guint len;
+
+ if (set->len == 0)
+ {
+ return FALSE;
+ }
+
+ if (quark_set_is_embed (set))
+ {
+ quarks = set->u.embed;
+ len = set->len;
+ }
+ else
+ {
+ quarks = set->u.alloc;
+ len = ABS (set->len);
+ }
+
+ for (i = 0; i < len; i++)
+ {
+ if (quarks[i] == quark)
+ {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static inline void
+quark_set_add (QuarkSet *set,
+ GQuark quark)
+{
+ if (quark_set_contains (set, quark))
+ {
+ return;
+ }
+
+ if G_LIKELY (set->len == 0 || set->len == 1)
+ {
+ G_STATIC_ASSERT (G_N_ELEMENTS (set->u.embed) == 2);
+
+ set->u.embed[set->len++] = quark;
+ }
+ else if (set->len == G_N_ELEMENTS (set->u.embed))
+ {
+ GQuark *alloc = g_new (GQuark, set->len + 1);
+ guint i;
+
+ for (i = 0; i < set->len; i++)
+ {
+ alloc[i] = set->u.embed[i];
+ }
+
+ alloc[set->len] = quark;
+ set->len = -(set->len + 1);
+ set->u.alloc = alloc;
+ }
+ else if (set->len < 0)
+ {
+ guint len = ABS (set->len);
+
+ set->u.alloc = g_realloc_n (set->u.alloc, len + 1, sizeof (GQuark));
+ set->u.alloc[len] = quark;
+ set->len--; /* = -(len + 1) */
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+}
+
+static inline void
+quark_set_remove (QuarkSet *set,
+ GQuark quark)
+{
+ if (set->len == 0)
+ {
+ return;
+ }
+ else if (set->len == -1 && set->u.alloc[0] == quark)
+ {
+ quark_set_clear (set);
+ return;
+ }
+ else if (set->len > 0)
+ {
+ G_STATIC_ASSERT (G_N_ELEMENTS (set->u.embed) == 2);
+
+ if (set->u.embed[0] == quark)
+ {
+ set->u.embed[0] = set->u.embed[1];
+ set->len--;
+ }
+ else if (set->u.embed[1] == quark)
+ {
+ set->len--;
+ }
+ }
+ else if (set->len < 0)
+ {
+ guint len = ABS (set->len);
+ guint i;
+
+ for (i = 0; i < len; i++)
+ {
+ if (set->u.alloc[i] == quark)
+ {
+ if (i + 1 < len)
+ {
+ set->u.alloc[i] = set->u.alloc[len - 1];
+ }
+
+ set->len++; /* = -(len - 1) */
+
+ break;
+ }
+ }
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+}
+
+G_END_DECLS
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
