[pango/line-breaker: 12/33] Add PangoLine
- From: Matthias Clasen <matthiasc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [pango/line-breaker: 12/33] Add PangoLine
- Date: Fri, 21 Jan 2022 05:20:50 +0000 (UTC)
commit fc4024ea1658233910e0bfe165cdef26d936a8b5
Author: Matthias Clasen <mclasen redhat com>
Date: Fri Jan 14 22:07:35 2022 -0500
Add PangoLine
This is an opaque, immutable object holding
a line of shaped text.
pango/meson.build | 2 +
pango/pango-line-private.h | 67 ++
pango/pango-line.c | 1449 ++++++++++++++++++++++++++++++++++++++++++++
pango/pango-line.h | 91 +++
pango/pango.h | 1 +
5 files changed, 1610 insertions(+)
---
diff --git a/pango/meson.build b/pango/meson.build
index 9f4c49be..15619a34 100644
--- a/pango/meson.build
+++ b/pango/meson.build
@@ -31,6 +31,7 @@ pango_sources = [
'serializer.c',
'json/gtkjsonparser.c',
'json/gtkjsonprinter.c',
+ 'pango-line.c',
]
pango_headers = [
@@ -52,6 +53,7 @@ pango_headers = [
'pango-gravity.h',
'pango-item.h',
'pango-language.h',
+ 'pango-line.h',
'pango-layout.h',
'pango-matrix.h',
'pango-markup.h',
diff --git a/pango/pango-line-private.h b/pango/pango-line-private.h
new file mode 100644
index 00000000..c32e9906
--- /dev/null
+++ b/pango/pango-line-private.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "pango-line.h"
+#include "pango-break.h"
+#include "pango-attributes.h"
+#include "pango-glyph-item.h"
+
+typedef struct _LineData LineData;
+struct _LineData {
+ char *text;
+ int length;
+ int n_chars;
+ PangoDirection direction;
+
+ PangoAttrList *attrs;
+ PangoLogAttr *log_attrs;
+};
+
+LineData * line_data_new (void);
+LineData * line_data_ref (LineData *data);
+void line_data_unref (LineData *data);
+void line_data_clear (LineData *data);
+
+struct _PangoLine
+{
+ GObject parent_instance;
+
+ PangoContext *context;
+ LineData *data;
+
+ int start_index;
+ int length;
+ int start_offset;
+ int n_chars;
+ GSList *runs;
+
+ guint wrapped : 1;
+ guint ellipsized : 1;
+ guint hyphenated : 1;
+ guint justified : 1;
+ guint starts_paragraph : 1;
+ guint ends_paragraph : 1;
+ guint has_extents : 1;
+
+ PangoDirection direction;
+
+ PangoRectangle ink_rect;
+ PangoRectangle logical_rect;
+};
+
+PangoLine * pango_line_new (PangoContext *context,
+ LineData *data);
+
+void pango_line_ellipsize (PangoLine *line,
+ PangoContext *context,
+ PangoEllipsizeMode ellipsize,
+ int goal_width);
+
+void pango_line_index_to_run (PangoLine *line,
+ int idx,
+ PangoGlyphItem **item);
+
+void pango_line_get_empty_extents (PangoLine *line,
+ PangoLeadingTrim trim,
+ PangoRectangle *logical_rect);
+
+void pango_line_check_invariants (PangoLine *line);
diff --git a/pango/pango-line.c b/pango/pango-line.c
new file mode 100644
index 00000000..967fb58a
--- /dev/null
+++ b/pango/pango-line.c
@@ -0,0 +1,1449 @@
+#include "config.h"
+
+#include "pango-line-private.h"
+
+#include "pango-tabs.h"
+#include "pango-impl-utils.h"
+#include "pango-attributes-private.h"
+#include "pango-item-private.h"
+
+#include <math.h>
+#include <hb-ot.h>
+
+/* {{{ LineData */
+
+void
+line_data_clear (LineData *data)
+{
+ g_free (data->text);
+ g_clear_pointer (&data->attrs, pango_attr_list_unref);
+ g_free (data->log_attrs);
+}
+
+LineData *
+line_data_new (void)
+{
+ return g_rc_box_new0 (LineData);
+}
+
+LineData *
+line_data_ref (LineData *data)
+{
+ return g_rc_box_acquire (data);
+}
+
+void
+line_data_unref (LineData *data)
+{
+ g_rc_box_release_full (data, (GDestroyNotify) line_data_clear);
+}
+
+/* }}} */
+/* {{{ PangoLine implementation */
+
+struct _PangoLineClass
+{
+ GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE (PangoLine, pango_line, G_TYPE_OBJECT)
+
+static void
+pango_line_init (PangoLine *line)
+{
+}
+
+static void
+pango_line_finalize (GObject *object)
+{
+ PangoLine *line = PANGO_LINE (object);
+
+ g_object_unref (line->context);
+
+ line_data_unref (line->data);
+ g_slist_free_full (line->runs, (GDestroyNotify)pango_glyph_item_free);
+
+ G_OBJECT_CLASS (pango_line_parent_class)->finalize (object);
+}
+
+static void
+pango_line_class_init (PangoLineClass *class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ object_class->finalize = pango_line_finalize;
+}
+
+/* }}} */
+/* {{{ Justification */
+
+static inline void
+distribute_letter_spacing (int letter_spacing,
+ int *space_left,
+ int *space_right)
+{
+ *space_left = letter_spacing / 2;
+
+ /* hinting */
+ if ((letter_spacing & (PANGO_SCALE - 1)) == 0)
+ *space_left = PANGO_UNITS_ROUND (*space_left);
+ *space_right = letter_spacing - *space_left;
+}
+
+static int
+pango_line_compute_width (PangoLine *line)
+{
+ int width = 0;
+
+ /* Compute the width of the line currently - inefficient, but easier
+ * than keeping the current width of the line up to date everywhere
+ */
+ for (GSList *l = line->runs; l; l = l->next)
+ {
+ PangoLayoutRun *run = l->data;
+ width += pango_glyph_string_get_width (run->glyphs);
+ }
+
+ return width;
+}
+
+static void
+justify_clusters (PangoLine *line,
+ int *remaining_width)
+{
+ int total_remaining_width, total_gaps = 0;
+ int added_so_far, gaps_so_far;
+ gboolean is_hinted;
+ GSList *run_iter;
+ enum {
+ MEASURE,
+ ADJUST
+ } mode;
+
+ total_remaining_width = *remaining_width;
+ if (total_remaining_width <= 0)
+ return;
+
+ /* hint to full pixel if total remaining width was so */
+ is_hinted = (total_remaining_width & (PANGO_SCALE - 1)) == 0;
+
+ for (mode = MEASURE; mode <= ADJUST; mode++)
+ {
+ gboolean leftedge = TRUE;
+ PangoGlyphString *rightmost_glyphs = NULL;
+ int rightmost_space = 0;
+ int residual = 0;
+
+ added_so_far = 0;
+ gaps_so_far = 0;
+
+ for (run_iter = line->runs; run_iter; run_iter = run_iter->next)
+ {
+ PangoLayoutRun *run = run_iter->data;
+ PangoGlyphString *glyphs = run->glyphs;
+ PangoGlyphItemIter cluster_iter;
+ gboolean have_cluster;
+ int dir;
+ int offset;
+
+ dir = run->item->analysis.level % 2 == 0 ? +1 : -1;
+ /* Note: we simply assert here, since our items are all internally
+ * created. If that ever changes, we need to add a fallback here.
+ */
+ g_assert (run->item->analysis.flags & PANGO_ANALYSIS_FLAG_HAS_CHAR_OFFSET);
+ offset = ((PangoItemPrivate *)run->item)->char_offset;
+ for (have_cluster = dir > 0 ?
+ pango_glyph_item_iter_init_start (&cluster_iter, run, line->data->text) :
+ pango_glyph_item_iter_init_end (&cluster_iter, run, line->data->text);
+ have_cluster;
+ have_cluster = dir > 0 ?
+ pango_glyph_item_iter_next_cluster (&cluster_iter) :
+ pango_glyph_item_iter_prev_cluster (&cluster_iter))
+ {
+ int i;
+ int width = 0;
+
+ /* don't expand in the middle of graphemes */
+ if (!line->data->log_attrs[offset + cluster_iter.start_char].is_cursor_position)
+ continue;
+
+ for (i = cluster_iter.start_glyph; i != cluster_iter.end_glyph; i += dir)
+ width += glyphs->glyphs[i].geometry.width;
+
+ /* also don't expand zero-width clusters. */
+ if (width == 0)
+ continue;
+
+ gaps_so_far++;
+
+ if (mode == ADJUST)
+ {
+ int leftmost, rightmost;
+ int adjustment, space_left, space_right;
+
+ adjustment = total_remaining_width / total_gaps + residual;
+ if (is_hinted)
+ {
+ int old_adjustment = adjustment;
+ adjustment = PANGO_UNITS_ROUND (adjustment);
+ residual = old_adjustment - adjustment;
+ }
+ /* distribute to before/after */
+ distribute_letter_spacing (adjustment, &space_left, &space_right);
+
+ if (cluster_iter.start_glyph < cluster_iter.end_glyph)
+ {
+ /* LTR */
+ leftmost = cluster_iter.start_glyph;
+ rightmost = cluster_iter.end_glyph - 1;
+ }
+ else
+ {
+ /* RTL */
+ leftmost = cluster_iter.end_glyph + 1;
+ rightmost = cluster_iter.start_glyph;
+ }
+ /* Don't add to left-side of left-most glyph of left-most non-zero run. */
+ if (leftedge)
+ leftedge = FALSE;
+ else
+ {
+ glyphs->glyphs[leftmost].geometry.width += space_left ;
+ glyphs->glyphs[leftmost].geometry.x_offset += space_left ;
+ added_so_far += space_left;
+ }
+ /* Don't add to right-side of right-most glyph of right-most non-zero run. */
+ {
+ /* Save so we can undo later. */
+ rightmost_glyphs = glyphs;
+ rightmost_space = space_right;
+
+ glyphs->glyphs[rightmost].geometry.width += space_right;
+ added_so_far += space_right;
+ }
+ }
+ }
+ }
+
+ if (mode == MEASURE)
+ {
+ total_gaps = gaps_so_far - 1;
+
+ if (total_gaps == 0)
+ {
+ /* a single cluster, can't really justify it */
+ return;
+ }
+ }
+ else /* mode == ADJUST */
+ {
+ if (rightmost_glyphs)
+ {
+ rightmost_glyphs->glyphs[rightmost_glyphs->num_glyphs - 1].geometry.width -= rightmost_space;
+ added_so_far -= rightmost_space;
+ }
+ }
+ }
+
+ *remaining_width -= added_so_far;
+}
+
+static void
+justify_words (PangoLine *line,
+ int *remaining_width)
+{
+ int total_remaining_width, total_space_width = 0;
+ int added_so_far, spaces_so_far;
+ gboolean is_hinted;
+ GSList *run_iter;
+ enum {
+ MEASURE,
+ ADJUST
+ } mode;
+
+ total_remaining_width = *remaining_width;
+ if (total_remaining_width <= 0)
+ return;
+
+ /* hint to full pixel if total remaining width was so */
+ is_hinted = (total_remaining_width & (PANGO_SCALE - 1)) == 0;
+
+ for (mode = MEASURE; mode <= ADJUST; mode++)
+ {
+ added_so_far = 0;
+ spaces_so_far = 0;
+
+ for (run_iter = line->runs; run_iter; run_iter = run_iter->next)
+ {
+ PangoLayoutRun *run = run_iter->data;
+ PangoGlyphString *glyphs = run->glyphs;
+ PangoGlyphItemIter cluster_iter;
+ gboolean have_cluster;
+ int offset;
+
+ /* Note: we simply assert here, since our items are all internally
+ * created. If that ever changes, we need to add a fallback here.
+ */
+ g_assert (run->item->analysis.flags & PANGO_ANALYSIS_FLAG_HAS_CHAR_OFFSET);
+ offset = ((PangoItemPrivate *)run->item)->char_offset;
+
+ for (have_cluster = pango_glyph_item_iter_init_start (&cluster_iter, run, line->data->text);
+ have_cluster;
+ have_cluster = pango_glyph_item_iter_next_cluster (&cluster_iter))
+ {
+ int i;
+ int dir;
+
+ if (!line->data->log_attrs[offset + cluster_iter.start_char].is_expandable_space)
+ continue;
+ dir = (cluster_iter.start_glyph < cluster_iter.end_glyph) ? 1 : -1;
+ for (i = cluster_iter.start_glyph; i != cluster_iter.end_glyph; i += dir)
+ {
+ int glyph_width = glyphs->glyphs[i].geometry.width;
+
+ if (glyph_width == 0)
+ continue;
+
+ spaces_so_far += glyph_width;
+
+ if (mode == ADJUST)
+ {
+ int adjustment;
+
+ adjustment = ((guint64) spaces_so_far * total_remaining_width) / total_space_width -
added_so_far;
+ if (is_hinted)
+ adjustment = PANGO_UNITS_ROUND (adjustment);
+
+ glyphs->glyphs[i].geometry.width += adjustment;
+ added_so_far += adjustment;
+ }
+ }
+ }
+ }
+
+ if (mode == MEASURE)
+ {
+ total_space_width = spaces_so_far;
+
+ if (total_space_width == 0)
+ {
+ justify_clusters (line, remaining_width);
+ return;
+ }
+ }
+ }
+
+ *remaining_width -= added_so_far;
+}
+
+/* }}} */
+/* {{{ Private API */
+
+void
+pango_line_check_invariants (PangoLine *line)
+{
+ /* Check that byte and char positions agree */
+ g_assert (g_utf8_strlen (line->data->text + line->start_index, line->length) == line->n_chars);
+ g_assert (g_utf8_offset_to_pointer (line->data->text + line->start_index, line->n_chars) ==
line->data->text + line->start_index + line->length);
+
+ /* Check that runs are sane */
+ if (line->runs)
+ {
+ int run_min, run_max;
+ int n_chars;
+
+ run_min = G_MAXINT;
+ run_max = 0;
+ n_chars = 0;
+ for (GSList *l = line->runs; l; l = l->next)
+ {
+ PangoGlyphItem *run = l->data;
+
+ run_min = MIN (run_min, run->item->offset);
+ run_max = MAX (run_max, run->item->offset + run->item->length);
+ n_chars += run->item->num_chars;
+ }
+
+ g_assert (run_min == line->start_index);
+ g_assert (run_max == line->start_index + line->length);
+ g_assert (n_chars == line->n_chars);
+ }
+}
+
+void
+pango_line_get_empty_extents (PangoLine *line,
+ PangoLeadingTrim trim,
+ PangoRectangle *logical_rect)
+{
+ PangoFontDescription *font_desc = NULL;
+ gboolean free_font_desc = FALSE;
+ double line_height_factor = 0.0;
+ int absolute_line_height = 0;
+ PangoFont *font;
+
+ font_desc = pango_context_get_font_description (line->context);
+
+ if (line->data->attrs)
+ {
+ PangoAttrIterator iter;
+ int start, end;
+
+ _pango_attr_list_get_iterator (line->data->attrs, &iter);
+
+ do
+ {
+ pango_attr_iterator_range (&iter, &start, &end);
+
+ if (start <= line->start_index && line->start_index < end)
+ {
+ PangoAttribute *attr;
+
+ if (!free_font_desc)
+ {
+ font_desc = pango_font_description_copy_static (font_desc);
+ free_font_desc = TRUE;
+ }
+
+ pango_attr_iterator_get_font (&iter, font_desc, NULL, NULL);
+
+ attr = pango_attr_iterator_get (&iter, PANGO_ATTR_LINE_HEIGHT);
+ if (attr)
+ line_height_factor = ((PangoAttrFloat *)attr)->value;
+
+ attr = pango_attr_iterator_get (&iter, PANGO_ATTR_ABSOLUTE_LINE_HEIGHT);
+ if (attr)
+ absolute_line_height = ((PangoAttrInt *)attr)->value;
+
+ break;
+ }
+ }
+ while (pango_attr_iterator_next (&iter));
+
+ _pango_attr_iterator_destroy (&iter);
+ }
+
+ memset (logical_rect, 0, sizeof (PangoRectangle));
+
+ font = pango_context_load_font (line->context, font_desc);
+ if (font)
+ {
+ PangoFontMetrics *metrics;
+
+ metrics = pango_font_get_metrics (font, pango_context_get_language (line->context));
+ if (metrics)
+ {
+ logical_rect->y = - pango_font_metrics_get_ascent (metrics);
+ logical_rect->height = - logical_rect->y + pango_font_metrics_get_descent (metrics);
+
+ if (trim != PANGO_LEADING_TRIM_BOTH)
+ {
+ int leading;
+
+ if (absolute_line_height != 0 || line_height_factor != 0.0)
+ {
+ int line_height;
+
+ line_height = MAX (absolute_line_height, ceilf (line_height_factor *
logical_rect->height));
+
+ leading = line_height - logical_rect->height;
+ }
+ else
+ {
+ leading = MAX (metrics->height - (metrics->ascent + metrics->descent), 0);
+ }
+
+ if ((trim & PANGO_LEADING_TRIM_START) == 0)
+ logical_rect->y -= leading / 2;
+ if (trim == PANGO_LEADING_TRIM_NONE)
+ logical_rect->height += leading;
+ else
+ logical_rect->height += (leading - leading / 2);
+ }
+
+ pango_font_metrics_unref (metrics);
+ }
+
+ g_object_unref (font);
+ }
+
+ if (free_font_desc)
+ pango_font_description_free (font_desc);
+}
+
+/*< private >
+ * pango_line_new:
+ * @context: the `PangoContext`
+ * @data: the `LineData`
+ *
+ * Creates a new `PangoLine`.
+ *
+ * The line shares the immutable `LineData` with other lines.
+ *
+ * The @context is needed for shape rendering.
+ *
+ * Returns: new `PangoLine`
+ */
+PangoLine *
+pango_line_new (PangoContext *context,
+ LineData *data)
+{
+ PangoLine *line;
+
+ line = g_object_new (PANGO_TYPE_LINE, NULL);
+
+ line->context = g_object_ref (context);
+ line->data = line_data_ref (data);
+
+ return line;
+}
+
+/*< private >
+ * pango_line_index_to_run:
+ * @line: a `PangoLine`
+ * @idx: a byte offset in the line
+ * @item: (out): return location for the run
+ *
+ * Finds the run in @line which contains @idx.
+ */
+void
+pango_line_index_to_run (PangoLine *line,
+ int idx,
+ PangoGlyphItem **item)
+{
+ *item = NULL;
+
+ for (GSList *l = line->runs; l; l = l->next)
+ {
+ PangoGlyphItem *run = l->data;
+
+ if (run->item->offset <= idx && idx < run->item->offset + run->item->length)
+ {
+ *item = run;
+ break;
+ }
+ }
+}
+
+/* }}} */
+/* {{{ Public API */
+/* {{{ Simple getters */
+
+/**
+ * pango_line_get_runs:
+ * @line: a `PangoLine`
+ *
+ * Gets the runs of the line.
+ *
+ * Note that the returned list and its contents
+ * are owned by Pango and must not be modified.
+ *
+ * Returns: (transfer none) (element-type PangoGlyphItem): a list of `PangoGlyphItem`
+ */
+GSList *
+pango_line_get_runs (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), NULL);
+
+ return line->runs;
+}
+
+/**
+ * pango_line_get_text:
+ * @line: a `PangoLine`
+ * @start_index: the byte index of the first byte of @line
+ * @length: the number of bytes in @line
+ *
+ * Gets the text that @line presents.
+ *
+ * The `PangoLine` represents the slice from @start_index
+ * to @start_index + @length of the returned string.
+ *
+ * The returned string is owned by @line and must not
+ * be modified.
+ *
+ * Returns: the text
+ */
+const char *
+pango_line_get_text (PangoLine *line,
+ int *start_index,
+ int *length)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), NULL);
+ g_return_val_if_fail (start_index != NULL, NULL);
+ g_return_val_if_fail (length != NULL, NULL);
+
+ *start_index = line->start_index;
+ *length = line->length;
+
+ return line->data->text;
+}
+
+/**
+ * pango_line_get_log_attrs:
+ * @line: a `PangoLine`
+ * @start_offset: the character offset of the first character of @line
+ * @n_attrs: the number of attributes that apply to @line
+ *
+ * Gets the `PangoLogAttr` array for the line.
+ *
+ * The `PangoLogAttrs` for @line are the slice from @start_offset
+ * to @start_offset+@n_attrs of the returned array. @n_attrs is
+ * be the number of characters plus one.
+ *
+ * The returned array is owned by @line and must not be modified.
+ *
+ * Returns: the `PangoLogAttr` array
+ */
+const PangoLogAttr *
+pango_line_get_log_attrs (PangoLine *line,
+ int *start_offset,
+ int *n_attrs)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), NULL);
+ g_return_val_if_fail (start_offset != NULL, NULL);
+ g_return_val_if_fail (n_attrs != NULL, NULL);
+
+ *start_offset = line->start_offset;
+ *n_attrs = line->n_chars + 1;
+
+ return line->data->log_attrs;
+}
+
+/**
+ * pango_line_wrapped:
+ * @line: a `PangoLine`
+ *
+ * Gets whether the line is wrapped.
+ *
+ * Returns: `TRUE` if @line has been wrapped
+ */
+gboolean
+pango_line_wrapped (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), FALSE);
+
+ return line->wrapped;
+}
+
+/**
+ * pango_line_ellipsized:
+ * @line: a `PangoLine`
+ *
+ * Gets whether the line is ellipsized.
+ *
+ * Returns: `TRUE` if @line has been ellipsized
+ */
+gboolean
+pango_line_ellipsized (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), FALSE);
+
+ return line->ellipsized;
+}
+
+/**
+ * pango_line_hyphenated:
+ * @line: a `PangoLine`
+ *
+ * Gets whether the line is hyphenated.
+ *
+ * Returns: `TRUE` if @line has been hyphenated
+ */
+gboolean
+pango_line_hyphenated (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), FALSE);
+
+ return line->hyphenated;
+}
+
+/**
+ * pango_line_justified:
+ * @line: a `PangoLine`
+ *
+ * Gets whether the line is justified.
+ *
+ * See [method Pango Line.justify].
+ *
+ * Returns: `TRUE` if @line has been justified
+ */
+gboolean
+pango_line_justified (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), FALSE);
+
+ return line->justified;
+}
+
+/**
+ * pango_line_starts_paragraph:
+ * @line: a `PangoLine`
+ *
+ * Gets whether the line is the first of a paragraph.
+ *
+ * Returns: `TRUE` if @line starts a paragraph
+ */
+gboolean
+pango_line_starts_paragraph (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), FALSE);
+
+ return line->starts_paragraph;
+}
+
+/**
+ * pango_line_ends_paragraph:
+ * @line: a `PangoLine`
+ *
+ * Gets whether the line is the last of a paragraph.
+ *
+ * Returns: `TRUE` if @line ends a paragraph
+ */
+gboolean
+pango_line_ends_paragraph (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), FALSE);
+
+ return line->ends_paragraph;
+}
+
+/**
+ * pango_line_get_direction:
+ * @line: a `PangoLine`
+ *
+ * Gets the text direction of the line.
+ *
+ * Returns: the direction of @line
+ */
+PangoDirection
+pango_line_get_direction (PangoLine *line)
+{
+ g_return_val_if_fail (PANGO_IS_LINE (line), PANGO_DIRECTION_LTR);
+
+ return line->direction;
+}
+
+/* }}} */
+/* {{{ Justification */
+
+/**
+ * pango_line_justify:
+ * @line: (transfer full): a `PangoLine`
+ * @width: the width to justify @line to
+ *
+ * Creates a new `PangoLine` that is justified
+ * copy of @line.
+ *
+ * The content of the returned line is justified
+ * to fill the given width, by modifying inter-word
+ * spaces (and possibly intra-word spaces too).
+ *
+ * Note that this function consumes @line.
+ *
+ * Returns: (transfer full): a new `PangoLine`
+ */
+PangoLine *
+pango_line_justify (PangoLine *line,
+ int width)
+{
+ int remaining_width;
+ PangoLine *copy;
+
+ remaining_width = width - pango_line_compute_width (line);
+ if (remaining_width <= 0)
+ return line;
+
+ copy = pango_line_new (line->context, line->data);
+ copy->start_index = line->start_index;
+ copy->length = line->length;
+ copy->start_offset = line->start_offset;
+ copy->n_chars = line->n_chars;
+ copy->wrapped = line->wrapped;
+ copy->ellipsized = line->ellipsized;
+ copy->hyphenated = line->hyphenated;
+ copy->justified = TRUE;
+ copy->starts_paragraph = line->starts_paragraph;
+ copy->ends_paragraph = line->ends_paragraph;
+ copy->has_extents = FALSE;
+ copy->direction = line->direction;
+
+ /* Avoid a copy if we have exclusive ownership of line */
+ if (G_OBJECT (line)->ref_count == 1)
+ {
+ copy->runs = line->runs;
+ line->runs = NULL;
+ }
+ else
+ copy->runs = g_slist_copy_deep (line->runs, (GCopyFunc) pango_glyph_item_copy, NULL);
+
+ justify_words (copy, &remaining_width);
+
+ g_object_unref (line);
+
+ return copy;
+}
+
+/* }}} */
+/* {{{ Extents */
+
+/**
+ * pango_line_get_extents:
+ * @line: a `PangoLine`
+ * @ink_rect: (out) (optional): rectangle that will be filled with ink extents
+ * @logical_rect: (out) (optional): rectangle that will be filled with the logical extents
+ *
+ * Gets the extents of the line.
+ *
+ * Note that the origin is at the left end of the baseline.
+ */
+void
+pango_line_get_extents (PangoLine *line,
+ PangoRectangle *ink_rect,
+ PangoRectangle *logical_rect)
+{
+ PangoRectangle ink = { 0, };
+ PangoRectangle logical = { 0, };
+ int x_pos;
+ GSList *l;
+ PangoLeadingTrim trim = PANGO_LEADING_TRIM_NONE;
+
+ if (line->starts_paragraph)
+ trim |= PANGO_LEADING_TRIM_START;
+ if (line->ends_paragraph)
+ trim |= PANGO_LEADING_TRIM_END;
+
+ if (line->has_extents)
+ goto cached;
+
+ x_pos = 0;
+
+ for (l = line->runs; l; l = l->next)
+ {
+ PangoLayoutRun *run = l->data;
+ PangoRectangle run_ink;
+ PangoRectangle run_logical;
+ int new_pos;
+
+ pango_glyph_item_get_extents (run, trim, &run_ink, &run_logical);
+
+ if (ink.width == 0 || ink.height == 0)
+ {
+ ink = run_ink;
+ ink.x += x_pos;
+ }
+ else if (run_ink.width != 0 && run_ink.height != 0)
+ {
+ new_pos = MIN (ink.x, x_pos + run_ink.x);
+ ink.width = MAX (ink.x + ink.width,
+ x_pos + run_ink.x + run_ink.width) - new_pos;
+ ink.x = new_pos;
+
+ new_pos = MIN (ink.y, run_ink.y);
+ ink.height = MAX (ink.y + ink.height,
+ run_ink.y + run_ink.height) - new_pos;
+ ink.y = new_pos;
+ }
+
+ if (l == line->runs)
+ {
+ logical = run_logical;
+ logical.x += x_pos;
+ }
+ else
+ {
+ new_pos = MIN (logical.x, x_pos + run_logical.x);
+ logical.width = MAX (logical.x + logical.width,
+ x_pos + run_logical.x + run_logical.width) - new_pos;
+ logical.x = new_pos;
+
+ new_pos = MIN (logical.y, run_logical.y);
+ logical.height = MAX (logical.y + logical.height,
+ run_logical.y + run_logical.height) - new_pos;
+ logical.y = new_pos;
+ }
+
+ x_pos += run_logical.width;
+ }
+
+ if (!line->runs)
+ pango_line_get_empty_extents (line, trim, &logical);
+
+ line->ink_rect = ink;
+ line->logical_rect = logical;
+ line->has_extents = TRUE;
+
+cached:
+ if (ink_rect)
+ *ink_rect = line->ink_rect;
+ if (logical_rect)
+ *logical_rect = line->logical_rect;
+}
+
+/* }}} */
+/* {{{ Editing API */
+
+/**
+ * pango_line_layout_index_to_pos:
+ * @line: a `PangoLine`
+ * @idx: byte index within @line
+ * @pos: (out): rectangle in which to store the position of the grapheme
+ *
+ * Converts from an index within a `PangoLine` to the
+ * position corresponding to the grapheme at that index.
+ *
+ * The return value is represented as rectangle. Note that `pos->x` is
+ * always the leading edge of the grapheme and `pos->x + pos->width` the
+ * trailing edge of the grapheme. If the directionality of the grapheme
+ * is right-to-left, then `pos->width` will be negative.
+ *
+ * Note that @idx is allowed to be @line->start_index + @line->length.
+ */
+void
+pango_line_index_to_pos (PangoLine *line,
+ int idx,
+ PangoRectangle *pos)
+{
+ PangoRectangle run_logical;
+ PangoRectangle line_logical;
+ PangoGlyphItem *run = NULL;
+ int x_pos;
+
+ pango_line_get_extents (line, NULL, &line_logical);
+
+ if (!line->runs)
+ {
+ *pos = line_logical;
+ return;
+ }
+
+ if (idx == line->start_index + line->length)
+ run = g_slist_last (line->runs)->data;
+ else
+ pango_line_index_to_run (line, idx, &run);
+
+ pango_glyph_item_get_extents (run, PANGO_LEADING_TRIM_BOTH, NULL, &run_logical);
+
+ pos->y = run_logical.y;
+ pos->height = run_logical.height;
+
+ /* FIXME: avoid iterating through the runs multiple times */
+
+ pango_line_index_to_x (line, idx, 0, &x_pos);
+ pos->x = line_logical.x + x_pos;
+
+ if (idx < line->start_index + line->length)
+ {
+ pango_line_index_to_x (line, idx, 1, &x_pos);
+ pos->width = (line_logical.x + x_pos) - pos->x;
+ }
+ else
+ pos->width = 0;
+}
+
+/**
+ * pango_line_index_to_x:
+ * @line: a `PangoLine`
+ * @idx: byte index within @line
+ * @trailing: an integer indicating the edge of the grapheme to retrieve
+ * the position of. If > 0, the trailing edge of the grapheme,
+ * if 0, the leading of the grapheme
+ * @x_pos: (out): location to store the x_offset (in Pango units)
+ *
+ * Converts an index within a `PangoLine` to a X position.
+ *
+ * Note that @idx is allowed to be @line->start_index + @line->length.
+ */
+void
+pango_line_index_to_x (PangoLine *line,
+ int index,
+ int trailing,
+ int *x_pos)
+{
+ GSList *run_list = line->runs;
+ int width = 0;
+
+ while (run_list)
+ {
+ PangoLayoutRun *run = run_list->data;
+
+ if (run->item->offset <= index && run->item->offset + run->item->length > index)
+ {
+ int offset = g_utf8_pointer_to_offset (line->data->text, line->data->text + index);
+ int attr_offset;
+
+ if (trailing)
+ {
+ while (index < line->start_index + line->length &&
+ offset + 1 < line->data->n_chars &&
+ !line->data->log_attrs[offset + 1].is_cursor_position)
+ {
+ offset++;
+ index = g_utf8_next_char (line->data->text + index) - line->data->text;
+ }
+ }
+ else
+ {
+ while (index > line->start_index &&
+ !line->data->log_attrs[offset].is_cursor_position)
+ {
+ offset--;
+ index = g_utf8_prev_char (line->data->text + index) - line->data->text;
+ }
+ }
+
+ /* Note: we simply assert here, since our items are all internally
+ * created. If that ever changes, we need to add a fallback here.
+ */
+ g_assert (run->item->analysis.flags & PANGO_ANALYSIS_FLAG_HAS_CHAR_OFFSET);
+ attr_offset = ((PangoItemPrivate *)run->item)->char_offset;
+ pango_glyph_string_index_to_x_full (run->glyphs,
+ line->data->text + run->item->offset,
+ run->item->length,
+ &run->item->analysis,
+ line->data->log_attrs + attr_offset,
+ index - run->item->offset, trailing, x_pos);
+ if (x_pos)
+ *x_pos += width;
+
+ return;
+ }
+
+ width += pango_glyph_string_get_width (run->glyphs);
+
+ run_list = run_list->next;
+ }
+
+ if (x_pos)
+ *x_pos = width;
+}
+
+/**
+ * pango_line_x_to_index:
+ * @line: a `PangoLine`
+ * @x: the X offset (in Pango units) from the left edge of the line
+ * @idx: (out): location to store calculated byte index for the grapheme
+ * in which the user clicked
+ * @trailing: (out): location to store an integer indicating where in the
+ * grapheme the user clicked. It will either be zero, or the number of
+ * characters in the grapheme. 0 represents the leading edge of the grapheme.
+ *
+ * Converts from x offset to the byte index of the corresponding character
+ * within the text of the line.
+ *
+ * If @x is outside the line, @idx and @trailing will point to the very
+ * first or very last position in the line. This determination is based on the
+ * resolved direction of the paragraph; for example, if the resolved direction
+ * is right-to-left, then an X position to the right of the line (after it)
+ * results in 0 being stored in @idx and @trailing. An X position to the
+ * left of the line results in @idx pointing to the (logical) last grapheme
+ * in the line and @trailing being set to the number of characters in that
+ * grapheme. The reverse is true for a left-to-right line.
+ *
+ * Return value: %FALSE if @x_pos was outside the line, %TRUE if inside
+ */
+gboolean
+pango_line_x_to_index (PangoLine *line,
+ int x_pos,
+ int *index,
+ int *trailing)
+{
+ GSList *tmp_list;
+ gint start_pos = 0;
+ gint first_index = 0; /* line->start_index */
+ gint first_offset;
+ gint last_index; /* start of last grapheme in line */
+ gint last_offset;
+ gint end_index; /* end iterator for line */
+ gint end_offset; /* end iterator for line */
+ gint last_trailing;
+ gboolean suppress_last_trailing;
+
+ /* Find the last index in the line */
+ first_index = line->start_index;
+
+ if (line->length == 0)
+ {
+ if (index)
+ *index = first_index;
+ if (trailing)
+ *trailing = 0;
+
+ return FALSE;
+ }
+
+ g_assert (line->length > 0);
+
+ first_offset = g_utf8_pointer_to_offset (line->data->text, line->data->text + line->start_index);
+
+ end_index = first_index + line->length;
+ end_offset = first_offset + g_utf8_pointer_to_offset (line->data->text + first_index, line->data->text +
end_index);
+
+ last_index = end_index;
+ last_offset = end_offset;
+ last_trailing = 0;
+ do
+ {
+ last_index = g_utf8_prev_char (line->data->text + last_index) - line->data->text;
+ last_offset--;
+ last_trailing++;
+ }
+ while (last_offset > first_offset && !line->data->log_attrs[last_offset].is_cursor_position);
+
+ /* This is a HACK. If a program only keeps track of cursor (etc)
+ * indices and not the trailing flag, then the trailing index of the
+ * last character on a wrapped line is identical to the leading
+ * index of the next line. So, we fake it and set the trailing flag
+ * to zero.
+ *
+ * That is, if the text is "now is the time", and is broken between
+ * 'now' and 'is'
+ *
+ * Then when the cursor is actually at:
+ *
+ * n|o|w| |i|s|
+ * ^
+ * we lie and say it is at:
+ *
+ * n|o|w| |i|s|
+ * ^
+ *
+ * So the cursor won't appear on the next line before 'the'.
+ *
+ * Actually, any program keeping cursor
+ * positions with wrapped lines should distinguish leading and
+ * trailing cursors.
+ */
+ if (line->wrapped)
+ suppress_last_trailing = TRUE;
+ else
+ suppress_last_trailing = FALSE;
+
+ if (x_pos < 0)
+ {
+ /* pick the leftmost char */
+ if (index)
+ *index = (line->direction == PANGO_DIRECTION_LTR) ? first_index : last_index;
+ /* and its leftmost edge */
+ if (trailing)
+ *trailing = (line->direction == PANGO_DIRECTION_LTR || suppress_last_trailing) ? 0 : last_trailing;
+
+ return FALSE;
+ }
+
+ tmp_list = line->runs;
+ while (tmp_list)
+ {
+ PangoLayoutRun *run = tmp_list->data;
+ int logical_width;
+
+ logical_width = pango_glyph_string_get_width (run->glyphs);
+
+ if (x_pos >= start_pos && x_pos < start_pos + logical_width)
+ {
+ int offset;
+ gboolean char_trailing;
+ int grapheme_start_index;
+ int grapheme_start_offset;
+ int grapheme_end_offset;
+ int pos;
+ int char_index;
+
+ pango_glyph_string_x_to_index (run->glyphs,
+ line->data->text + run->item->offset, run->item->length,
+ &run->item->analysis,
+ x_pos - start_pos,
+ &pos, &char_trailing);
+
+ char_index = run->item->offset + pos;
+
+ /* Convert from characters to graphemes */
+
+ offset = g_utf8_pointer_to_offset (line->data->text, line->data->text + char_index);
+
+ grapheme_start_offset = offset;
+ grapheme_start_index = char_index;
+ while (grapheme_start_offset > first_offset &&
+ !line->data->log_attrs[grapheme_start_offset].is_cursor_position)
+ {
+ grapheme_start_index = g_utf8_prev_char (line->data->text + grapheme_start_index) -
line->data->text;
+ grapheme_start_offset--;
+ }
+
+ grapheme_end_offset = offset;
+ do
+ {
+ grapheme_end_offset++;
+ }
+
+ while (grapheme_end_offset < end_offset &&
+ !line->data->log_attrs[grapheme_end_offset].is_cursor_position);
+
+ if (index)
+ *index = grapheme_start_index;
+ if (trailing)
+ {
+ if ((grapheme_end_offset == end_offset && suppress_last_trailing) ||
+ offset + char_trailing <= (grapheme_start_offset + grapheme_end_offset) / 2)
+ *trailing = 0;
+ else
+ *trailing = grapheme_end_offset - grapheme_start_offset;
+ }
+
+ return TRUE;
+ }
+
+ start_pos += logical_width;
+ tmp_list = tmp_list->next;
+ }
+
+ /* pick the rightmost char */
+ if (index)
+ *index = (line->direction == PANGO_DIRECTION_LTR) ? last_index : first_index;
+
+ /* and its rightmost edge */
+ if (trailing)
+ *trailing = (line->direction == PANGO_DIRECTION_LTR && !suppress_last_trailing) ? last_trailing : 0;
+
+ return FALSE;
+}
+
+/* }}} */
+/* {{{ Cursor positioning */
+
+/**
+ * pango_line_get_cursor_pos:
+ * @line: a `PangoLine`
+ * @idx: the byte index of the cursor
+ * @strong_pos: (out) (optional): location to store the strong cursor position
+ * @weak_pos: (out) (optional): location to store the weak cursor position
+ *
+ * Given an index within @line, determines the positions that of the
+ * strong and weak cursors if the insertion point is at that index.
+ *
+ * Note that @idx is allowed to be @line->start_index + @line->length.
+ *
+ * The position of each cursor is stored as a zero-width rectangle
+ * with the height of the run extents.
+ *
+ * <picture>
+ * <source srcset="cursor-positions-dark.png" media="(prefers-color-scheme: dark)">
+ * <img alt="Cursor positions" src="cursor-positions-light.png">
+ * </picture>
+ *
+ * The strong cursor location is the location where characters of the
+ * directionality equal to the base direction of the layout are inserted.
+ * The weak cursor location is the location where characters of the
+ * directionality opposite to the base direction of the layout are inserted.
+ *
+ * The following example shows text with both a strong and a weak cursor.
+ *
+ * <picture>
+ * <source srcset="split-cursor-dark.png" media="(prefers-color-scheme: dark)">
+ * <img alt="Strong and weak cursors" src="split-cursor-light.png">
+ * </picture>
+ *
+ * The strong cursor has a little arrow pointing to the right, the weak
+ * cursor to the left. Typing a 'c' in this situation will insert the
+ * character after the 'b', and typing another Hebrew character, like 'ג',
+ * will insert it at the end.
+ */
+void
+pango_line_get_cursor_pos (PangoLine *line,
+ int idx,
+ PangoRectangle *strong_pos,
+ PangoRectangle *weak_pos)
+{
+ PangoRectangle line_rect = { 666, };
+ PangoRectangle run_rect = { 666, };
+ PangoDirection dir1, dir2;
+ int level1, level2;
+ PangoGlyphItem *run = NULL;
+ int x1_trailing;
+ int x2;
+
+ if (idx >= line->start_index + line->length)
+ {
+ if (line->runs)
+ run = g_slist_last (line->runs)->data;
+ }
+ else
+ pango_line_index_to_run (line, idx, &run);
+
+ pango_line_get_extents (line, NULL, &line_rect);
+ if (run)
+ pango_glyph_item_get_extents (run, PANGO_LEADING_TRIM_BOTH, NULL, &run_rect);
+ else
+ {
+ run_rect = line_rect;
+ x1_trailing = x2 = line_rect.width;
+ goto done;
+ }
+
+ /* Examine the trailing edge of the character before the cursor */
+ if (idx == line->start_index)
+ {
+ dir1 = line->direction;
+ level1 = dir1 == PANGO_DIRECTION_LTR ? 0 : 1;
+ if (line->direction == PANGO_DIRECTION_LTR)
+ x1_trailing = 0;
+ else
+ x1_trailing = line_rect.width;
+ }
+ else
+ {
+ int prev_index = g_utf8_prev_char (line->data->text + idx) - line->data->text;
+
+ if (prev_index >= line->start_index + line->length)
+ {
+ dir1 = line->direction;
+ level1 = dir1 == PANGO_DIRECTION_LTR ? 0 : 1;
+ x1_trailing = line_rect.width;
+ }
+ else
+ {
+ PangoGlyphItem *prev_run;
+
+ pango_line_index_to_run (line, prev_index, &prev_run);
+ level1 = prev_run->item->analysis.level;
+ dir1 = level1 % 2 ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR;
+ pango_line_index_to_x (line, prev_index, TRUE, &x1_trailing);
+ }
+ }
+
+ /* Examine the leading edge of the character after the cursor */
+ if (idx >= line->start_index + line->length)
+ {
+ dir2 = line->direction;
+ level2 = dir2 == PANGO_DIRECTION_LTR ? 0 : 1;
+ if (line->direction == PANGO_DIRECTION_LTR)
+ x2 = line_rect.width;
+ else
+ x2 = 0;
+ }
+ else
+ {
+ pango_line_index_to_x (line, idx, FALSE, &x2);
+ level2 = run->item->analysis.level;
+ dir2 = level2 % 2 ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR;
+ }
+
+done:
+ if (strong_pos)
+ {
+ strong_pos->x = line_rect.x;
+
+ if (dir1 == line->direction &&
+ (dir2 != dir1 || level1 < level2))
+ strong_pos->x += x1_trailing;
+ else
+ strong_pos->x += x2;
+
+ strong_pos->y = run_rect.y;
+ strong_pos->width = 0;
+ strong_pos->height = run_rect.height;
+ }
+
+ if (weak_pos)
+ {
+ weak_pos->x = line_rect.x;
+
+ if (dir1 == line->direction &&
+ (dir2 != dir1 || level1 < level2))
+ weak_pos->x += x2;
+ else
+ weak_pos->x += x1_trailing;
+
+ weak_pos->y = run_rect.y;
+ weak_pos->width = 0;
+ weak_pos->height = run_rect.height;
+ }
+}
+
+/**
+ * pango_line_get_caret_pos:
+ * @line: a `PangoLine`
+ * @idx: the byte index of the cursor
+ * @strong_pos: (out) (optional): location to store the strong cursor position
+ * @weak_pos: (out) (optional): location to store the weak cursor position
+ *
+ * Given an index within @line, determines the positions of the
+ * strong and weak cursors if the insertion point is at that index.
+ *
+ * Note that @idx is allowed to be @line->start_index + @line->length.
+ *
+ * This is a variant of [method Pango Line.get_cursor_pos] that applies
+ * font metric information about caret slope and offset to the positions
+ * it returns.
+ *
+ * <picture>
+ * <source srcset="caret-metrics-dark.png" media="(prefers-color-scheme: dark)">
+ * <img alt="Caret metrics" src="caret-metrics-light.png">
+ * </picture>
+ */
+void
+pango_line_get_caret_pos (PangoLine *line,
+ int idx,
+ PangoRectangle *strong_pos,
+ PangoRectangle *weak_pos)
+{
+ PangoGlyphItem *run = NULL;
+ hb_font_t *hb_font;
+ hb_position_t caret_offset, caret_run, caret_rise, descender;
+
+ pango_line_get_cursor_pos (line, idx, strong_pos, weak_pos);
+
+ if (idx >= line->start_index + line->length)
+ {
+ if (line->runs)
+ run = g_slist_last (line->runs)->data;
+ }
+ else
+ pango_line_index_to_run (line, idx, &run);
+
+ if (!run)
+ return;
+
+ hb_font = pango_font_get_hb_font (run->item->analysis.font);
+
+ if (hb_ot_metrics_get_position (hb_font, HB_OT_METRICS_TAG_HORIZONTAL_CARET_RISE, &caret_rise) &&
+ hb_ot_metrics_get_position (hb_font, HB_OT_METRICS_TAG_HORIZONTAL_CARET_RUN, &caret_run) &&
+ hb_ot_metrics_get_position (hb_font, HB_OT_METRICS_TAG_HORIZONTAL_CARET_OFFSET, &caret_offset) &&
+ hb_ot_metrics_get_position (hb_font, HB_OT_METRICS_TAG_HORIZONTAL_DESCENDER, &descender))
+ {
+ double slope_inv;
+ int x_scale, y_scale;
+
+ if (strong_pos)
+ strong_pos->x += caret_offset;
+
+ if (weak_pos)
+ weak_pos->x += caret_offset;
+
+ if (caret_rise == 0)
+ return;
+
+ hb_font_get_scale (hb_font, &x_scale, &y_scale);
+ slope_inv = (caret_run * y_scale) / (double) (caret_rise * x_scale);
+
+ if (strong_pos)
+ {
+ strong_pos->x += descender * slope_inv;
+ strong_pos->width = strong_pos->height * slope_inv;
+ if (slope_inv < 0)
+ strong_pos->x -= strong_pos->width;
+ }
+
+ if (weak_pos)
+ {
+ weak_pos->x += descender * slope_inv;
+ weak_pos->width = weak_pos->height * slope_inv;
+ if (slope_inv < 0)
+ weak_pos->x -= weak_pos->width;
+ }
+ }
+}
+
+/* }}} */
+/* }}} */
+
+/* vim:set foldmethod=marker expandtab: */
diff --git a/pango/pango-line.h b/pango/pango-line.h
new file mode 100644
index 00000000..b41ae4db
--- /dev/null
+++ b/pango/pango-line.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <glib-object.h>
+
+#include <pango/pango-types.h>
+#include <pango/pango-layout.h>
+
+G_BEGIN_DECLS
+
+#define PANGO_TYPE_LINE pango_line_get_type ()
+
+PANGO_AVAILABLE_IN_ALL
+G_DECLARE_FINAL_TYPE (PangoLine, pango_line, PANGO, LINE, GObject);
+
+PANGO_AVAILABLE_IN_ALL
+PangoLine * pango_line_justify (PangoLine *line,
+ int width);
+
+PANGO_AVAILABLE_IN_ALL
+GSList * pango_line_get_runs (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+const char * pango_line_get_text (PangoLine *line,
+ int *start_index,
+ int *length);
+
+PANGO_AVAILABLE_IN_ALL
+const PangoLogAttr * pango_line_get_log_attrs (PangoLine *line,
+ int *start_offset,
+ int *n_attrs);
+
+PANGO_AVAILABLE_IN_ALL
+gboolean pango_line_wrapped (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+gboolean pango_line_ellipsized (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+gboolean pango_line_hyphenated (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+gboolean pango_line_justified (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+gboolean pango_line_starts_paragraph (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+gboolean pango_line_ends_paragraph (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+PangoDirection pango_line_get_direction (PangoLine *line);
+
+PANGO_AVAILABLE_IN_ALL
+void pango_line_get_extents (PangoLine *line,
+ PangoRectangle *ink_rect,
+ PangoRectangle *logical_rect);
+
+PANGO_AVAILABLE_IN_ALL
+void pango_line_get_logical_extents (PangoLine *line,
+ PangoRectangle *ext);
+
+PANGO_AVAILABLE_IN_ALL
+void pango_line_index_to_pos (PangoLine *line,
+ int idx,
+ PangoRectangle *pos);
+
+PANGO_AVAILABLE_IN_ALL
+void pango_line_index_to_x (PangoLine *line,
+ int idx,
+ int trailing,
+ int *x_pos);
+
+PANGO_AVAILABLE_IN_ALL
+gboolean pango_line_x_to_index (PangoLine *line,
+ int x,
+ int *idx,
+ int *trailing);
+
+PANGO_AVAILABLE_IN_ALL
+void pango_line_get_cursor_pos (PangoLine *line,
+ int idx,
+ PangoRectangle *strong_pos,
+ PangoRectangle *weak_pos);
+
+PANGO_AVAILABLE_IN_ALL
+void pango_line_get_caret_pos (PangoLine *line,
+ int idx,
+ PangoRectangle *strong_pos,
+ PangoRectangle *weak_pos);
+
+G_END_DECLS
diff --git a/pango/pango.h b/pango/pango.h
index eca66265..c2aa5669 100644
--- a/pango/pango.h
+++ b/pango/pango.h
@@ -42,6 +42,7 @@
#include <pango/pango-item.h>
#include <pango/pango-language.h>
#include <pango/pango-layout.h>
+#include <pango/pango-line.h>
#include <pango/pango-matrix.h>
#include <pango/pango-markup.h>
#include <pango/pango-renderer.h>
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
