From b6a8080b2fc8b8a5b16dd7d260fd87e39edcb28c Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 19 May 2022 06:44:23 +0200
Subject: [PATCH 01/15] Add GtkInscription

A label alternative that renders itself into a given rectangle.

The main use case is cells in column view.

Related: #3334
---
 gtk/gtk.h            |   1 +
 gtk/gtkinscription.c | 908 +++++++++++++++++++++++++++++++++++++++++++
 gtk/gtkinscription.h |  79 ++++
 gtk/meson.build      |   2 +
 4 files changed, 990 insertions(+)
 create mode 100644 gtk/gtkinscription.c
 create mode 100644 gtk/gtkinscription.h

diff --git a/gtk/gtk.h b/gtk/gtk.h
index 0d4521e4ac..bac384a2e0 100644
--- a/gtk/gtk.h
+++ b/gtk/gtk.h
@@ -155,6 +155,7 @@
 #include <gtk/gtkimcontextsimple.h>
 #include <gtk/gtkimmulticontext.h>
 #include <gtk/gtkinfobar.h>
+#include <gtk/gtkinscription.h>
 #include <gtk/gtklabel.h>
 #include <gtk/gtklayoutmanager.h>
 #include <gtk/gtklayoutchild.h>
diff --git a/gtk/gtkinscription.c b/gtk/gtkinscription.c
new file mode 100644
index 0000000000..ca18a200a3
--- /dev/null
+++ b/gtk/gtkinscription.c
@@ -0,0 +1,908 @@
+/*
+ * Copyright © 2022 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gtkinscription.h"
+
+#include "gtkcssstylechangeprivate.h"
+#include "gtksnapshot.h"
+#include "gtkwidgetprivate.h"
+
+/**
+ * GtkInscription:
+ *
+ * `GtkInscription` is a widget to show text in a predefined area.
+ *
+ * You likely want to use `GtkLabel` instead as this widget is intended only for
+ * a small subset of use cases. The main use case is usage inside lists
+ * such as `GtkColumnView`.
+ *
+ * While a `GtkLabel` sizes itself according to the text that is displayed,
+ * `GtkInscription` is given a size and inscribes the given text into that space
+ * as good as it can.
+ *
+ * As it is a common occurrence that text doesn't fit, users of this widget should
+ * plan for that case.
+ */
+
+/* 3 chars are enough to display ellipsizing "..." */
+#define DEFAULT_MIN_CHARS 3
+/* This means we request no natural size and fall back to min size */
+#define DEFAULT_NAT_CHARS 0
+/* 1 line is what people want in 90% of cases */
+#define DEFAULT_MIN_LINES 1
+/* This means we request no natural size and fall back to min size */
+#define DEFAULT_NAT_LINES 0
+/* Unlike GtkLabel, we default to not centering text */
+#define DEFAULT_XALIGN 0.f
+/* But just like GtkLabel, we center vertically */
+#define DEFAULT_YALIGN 0.5f
+
+struct _GtkInscription
+{
+  GtkWidget parent_instance;
+
+  char *text;
+  guint min_chars;
+  guint nat_chars;
+  guint min_lines;
+  guint nat_lines;
+  float xalign;
+  float yalign;
+
+  PangoLayout *layout;
+};
+
+enum
+{
+  PROP_0,
+  PROP_MIN_CHARS,
+  PROP_MIN_LINES,
+  PROP_NAT_CHARS,
+  PROP_NAT_LINES,
+  PROP_TEXT,
+  PROP_XALIGN,
+  PROP_YALIGN,
+
+  N_PROPS
+};
+
+G_DEFINE_TYPE (GtkInscription, gtk_inscription, GTK_TYPE_WIDGET)
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gtk_inscription_dispose (GObject *object)
+{
+  GtkInscription *self = GTK_INSCRIPTION (object);
+
+  g_clear_pointer (&self->text, g_free);
+
+  G_OBJECT_CLASS (gtk_inscription_parent_class)->dispose (object);
+}
+
+static void
+gtk_inscription_finalize (GObject *object)
+{
+  GtkInscription *self = GTK_INSCRIPTION (object);
+
+  g_clear_object (&self->layout);
+
+  G_OBJECT_CLASS (gtk_inscription_parent_class)->finalize (object);
+}
+
+static void
+gtk_inscription_get_property (GObject    *object,
+                              guint       property_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  GtkInscription *self = GTK_INSCRIPTION (object);
+
+  switch (property_id)
+    {
+    case PROP_MIN_CHARS:
+      g_value_set_uint (value, self->min_chars);
+      break;
+
+    case PROP_MIN_LINES:
+      g_value_set_uint (value, self->min_lines);
+      break;
+
+    case PROP_NAT_CHARS:
+      g_value_set_uint (value, self->nat_chars);
+      break;
+
+    case PROP_NAT_LINES:
+      g_value_set_uint (value, self->nat_lines);
+      break;
+
+    case PROP_TEXT:
+      g_value_set_string (value, self->text);
+      break;
+
+    case PROP_XALIGN:
+      g_value_set_float (value, self->xalign);
+      break;
+
+    case PROP_YALIGN:
+      g_value_set_float (value, self->yalign);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_inscription_set_property (GObject      *object,
+                              guint         property_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+{
+  GtkInscription *self = GTK_INSCRIPTION (object);
+
+  switch (property_id)
+    {
+    case PROP_MIN_CHARS:
+      gtk_inscription_set_min_chars (self, g_value_get_uint (value));
+      break;
+
+    case PROP_MIN_LINES:
+      gtk_inscription_set_min_lines (self, g_value_get_uint (value));
+      break;
+
+    case PROP_NAT_CHARS:
+      gtk_inscription_set_nat_chars (self, g_value_get_uint (value));
+      break;
+
+    case PROP_NAT_LINES:
+      gtk_inscription_set_nat_lines (self, g_value_get_uint (value));
+      break;
+
+    case PROP_TEXT:
+      gtk_inscription_set_text (self, g_value_get_string (value));
+      break;
+
+    case PROP_XALIGN:
+      gtk_inscription_set_xalign (self, g_value_get_float (value));
+      break;
+
+    case PROP_YALIGN:
+      gtk_inscription_set_yalign (self, g_value_get_float (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_inscription_css_changed (GtkWidget         *widget,
+                             GtkCssStyleChange *change)
+{
+  GtkInscription *self = GTK_INSCRIPTION (widget);
+
+  GTK_WIDGET_CLASS (gtk_inscription_parent_class)->css_changed (widget, change);
+
+  if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT_ATTRS))
+    {
+      PangoAttrList *new_attrs;
+
+      new_attrs = gtk_css_style_get_pango_attributes (gtk_css_style_change_get_new_style (change));
+      pango_layout_set_attributes (self->layout, new_attrs);
+      pango_attr_list_unref (new_attrs);
+
+      gtk_widget_queue_draw (widget);
+    }
+}
+
+static PangoFontMetrics *
+gtk_inscription_get_font_metrics (GtkInscription *self)
+{
+  PangoContext *context;
+
+  context = gtk_widget_get_pango_context (GTK_WIDGET (self));
+
+  return pango_context_get_metrics (context, NULL, NULL);
+}
+
+static int
+get_char_pixels (GtkInscription *self)
+{
+  int char_width, digit_width;
+  PangoFontMetrics *metrics;
+
+  metrics = gtk_inscription_get_font_metrics (self);
+  char_width = pango_font_metrics_get_approximate_char_width (metrics);
+  digit_width = pango_font_metrics_get_approximate_digit_width (metrics);
+  pango_font_metrics_unref (metrics);
+
+  return MAX (char_width, digit_width);
+}
+
+static void
+gtk_inscription_measure_width (GtkInscription *self,
+                               int            *minimum,
+                               int            *natural)
+{
+  int char_pixels = get_char_pixels (self);
+
+  if (self->min_chars == 0 && self->nat_chars == 0)
+    return;
+
+  *minimum = self->min_chars * char_pixels;
+  *natural = MAX (self->min_chars, self->nat_chars) * char_pixels;
+}
+
+static int
+get_line_pixels (GtkInscription *self,
+                 int            *baseline)
+{
+  PangoFontMetrics *metrics;
+  int ascent, descent;
+
+  metrics = gtk_inscription_get_font_metrics (self);
+
+  ascent = pango_font_metrics_get_ascent (metrics);
+  descent = pango_font_metrics_get_descent (metrics);
+
+  if (baseline)
+    *baseline = ascent;
+
+  return ascent + descent;
+}
+
+static void
+gtk_inscription_measure_height (GtkInscription *self,
+                                int            *minimum,
+                                int            *natural,
+                                int            *minimum_baseline,
+                                int            *natural_baseline)
+{
+  int line_pixels, baseline;
+
+  if (self->min_lines == 0 && self->nat_lines == 0)
+    return;
+
+  line_pixels = get_line_pixels (self, &baseline);
+
+  *minimum = self->min_lines * line_pixels;
+  *natural = MAX (self->min_lines, self->nat_lines) * line_pixels;
+
+  if (minimum_baseline)
+    *minimum_baseline = self->min_lines ? baseline : 0;
+  if (natural_baseline)
+    *natural_baseline = (self->min_lines || self->nat_lines) ? baseline : 0;
+}
+
+static void
+gtk_inscription_measure (GtkWidget      *widget,
+                         GtkOrientation  orientation,
+                         int             for_size,
+                         int            *minimum,
+                         int            *natural,
+                         int            *minimum_baseline,
+                         int            *natural_baseline)
+{
+  GtkInscription *self = GTK_INSCRIPTION (widget);
+
+  /* We split this into 2 functions explicitly, so nobody gets the idea
+   * of adding height-for-width to this.
+   * This is meant to be fast, so that is a big no-no.
+   */
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    gtk_inscription_measure_width (self, minimum, natural);
+  else
+    gtk_inscription_measure_height (self, minimum, natural, minimum_baseline, natural_baseline);
+
+  *minimum = PANGO_PIXELS_CEIL (*minimum);
+  *natural = PANGO_PIXELS_CEIL (*natural);
+  if (*minimum_baseline > 0)
+    *minimum_baseline = PANGO_PIXELS_CEIL (*minimum_baseline);
+  if (*natural_baseline > 0)
+    *natural_baseline = PANGO_PIXELS_CEIL (*natural_baseline);
+}
+
+static void
+gtk_inscription_get_layout_location (GtkInscription *self,
+                                     int            *x_out,
+                                     int            *y_out)
+{
+  GtkWidget *widget = GTK_WIDGET (self);
+  const int widget_width = gtk_widget_get_width (widget);
+  const int widget_height = gtk_widget_get_height (widget);
+  PangoRectangle logical;
+  float xalign;
+  int baseline;
+  int x, y;
+
+  g_assert (x_out);
+  g_assert (y_out);
+
+  xalign = self->xalign;
+  if (_gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR)
+    xalign = 1.0 - xalign;
+
+  pango_layout_get_pixel_extents (self->layout, NULL, &logical);
+  x = floor ((xalign * (widget_width - logical.width)) - logical.x);
+
+  baseline = gtk_widget_get_allocated_baseline (widget);
+  if (baseline != -1)
+    {
+      int layout_baseline = pango_layout_get_baseline (self->layout) / PANGO_SCALE;
+      /* yalign is 0 because we can't support yalign while baseline aligning */
+      y = baseline - layout_baseline;
+    }
+  else
+    {
+      y = floor ((widget_height - logical.height) * self->yalign);
+    }
+
+  *x_out = x;
+  *y_out = y;
+}
+
+static void
+gtk_inscription_allocate (GtkWidget *widget,
+                          int        width,
+                          int        height,
+                          int        baseline)
+{
+  GtkInscription *self = GTK_INSCRIPTION (widget);
+
+  pango_layout_set_width (self->layout, width * PANGO_SCALE);
+}
+
+static void
+gtk_inscription_snapshot (GtkWidget   *widget,
+                          GtkSnapshot *snapshot)
+{
+  GtkInscription *self = GTK_INSCRIPTION (widget);
+  GtkStyleContext *context;
+  int lx, ly;
+
+  if (!self->text || (*self->text == '\0'))
+    return;
+
+  context = _gtk_widget_get_style_context (widget);
+
+  gtk_snapshot_push_clip (snapshot, &GRAPHENE_RECT_INIT(0, 0, gtk_widget_get_width (widget), gtk_widget_get_height (widget)));
+  gtk_inscription_get_layout_location (self, &lx, &ly);
+  gtk_snapshot_render_layout (snapshot, context, lx, ly, self->layout);
+  gtk_snapshot_pop (snapshot);
+}
+
+static void
+gtk_inscription_class_init (GtkInscriptionClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  gobject_class->dispose = gtk_inscription_dispose;
+  gobject_class->finalize = gtk_inscription_finalize;
+  gobject_class->get_property = gtk_inscription_get_property;
+  gobject_class->set_property = gtk_inscription_set_property;
+
+  widget_class->css_changed = gtk_inscription_css_changed;
+  widget_class->measure = gtk_inscription_measure;
+  widget_class->size_allocate = gtk_inscription_allocate;
+  widget_class->snapshot = gtk_inscription_snapshot;
+
+  /**
+   * GtkInscription:min-chars: (attributes org.gtk.Property.get=gtk_inscription_get_min_chars org.gtk.Property.set=gtk_inscription_set_min_chars)
+   *
+   * The number of characters that should fit into the inscription at minimum.
+   *
+   * This influences the requested width, not the width actually given to the widget,
+   * which might turn out to be larger.
+   *
+   * Note that this is an approximate character width, so some characters might be
+   * wider and some might be thinner, so do not expect the number of characters to
+   * exactly match.
+   *
+   * If you set this property to 0, the inscription will not request any width at all
+   * and its width will be determined entirely by its surroundings.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_MIN_CHARS] =
+      g_param_spec_uint ("min-chars", NULL, NULL,
+                         0, G_MAXUINT,
+                         DEFAULT_MIN_CHARS,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtkInscription:min-lines: (attributes org.gtk.Property.get=gtk_inscription_get_min_lines org.gtk.Property.set=gtk_inscription_set_min_lines)
+   *
+   * The number of lines that should fit into the inscription at minimum.
+   *
+   * This influences the requested height, not the height actually given to the widget,
+   * which might turn out to be larger.
+   *
+   * Note that this is an approximate line height, so if the text uses things like fancy
+   * Unicode or attribute that influence the height, the text might not fit.
+   *
+   * If you set this property to 0, the inscription will not request any height at all
+   * and its height will be determined entirely by its surroundings.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_MIN_LINES] =
+      g_param_spec_uint ("min-lines", NULL, NULL,
+                         0, G_MAXUINT,
+                         DEFAULT_MIN_LINES,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtkInscription:nat-chars: (attributes org.gtk.Property.get=gtk_inscription_get_nat_chars org.gtk.Property.set=gtk_inscription_set_nat_chars)
+   *
+   * The number of characters that should ideally fit into the inscription.
+   *
+   * This influences the requested width, not the width actually given to the widget.
+   * The widget might turn out larger as well as smaller.
+   *
+   * If this property is set to a value smaller than [property@Gtk.Inscription:min-chars],
+   * that value will be used. In particular, for the default value of 0, this will always
+   * be the case.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_NAT_CHARS] =
+      g_param_spec_uint ("nat-chars", NULL, NULL,
+                         0, G_MAXUINT,
+                         DEFAULT_NAT_CHARS,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtkInscription:nat-lines: (attributes org.gtk.Property.get=gtk_inscription_get_nat_lines org.gtk.Property.set=gtk_inscription_set_nat_lines)
+   *
+   * The number of lines that should ideally fit into the inscription.
+   *
+   * This influences the requested height, not the height actually given to the widget.
+   * The widget might turn out larger as well as smaller.
+   *
+   * If this property is set to a value smaller than [property@Gtk.Inscription:min-lines],
+   * that value will be used. In particular, for the default value of 0, this will always
+   * be the case.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_NAT_LINES] =
+      g_param_spec_uint ("nat-lines", NULL, NULL,
+                         0, G_MAXUINT,
+                         DEFAULT_NAT_LINES,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtkInscription:text: (attributes org.gtk.Property.get=gtk_inscription_get_text org.gtk.Property.set=gtk_inscription_set_text)
+   *
+   * The displayed text.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_TEXT] =
+    g_param_spec_string ("text", NULL, NULL,
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtkInscription:xalign: (attributes org.gtk.Property.get=gtk_inscription_get_xalign org.gtk.Property.set=gtk_inscription_set_xalign)
+   *
+   * The horizontal alignment of the text inside the allocated size.
+   *
+   * Compare this to [property@Gtk.Widget:halign], which determines how the
+   * inscription's size allocation is positioned in the available space.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_XALIGN] =
+      g_param_spec_float ("xalign", NULL, NULL,
+                          0.0, 1.0,
+                          DEFAULT_XALIGN,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GtkInscription:yalign: (attributes org.gtk.Property.get=gtk_inscription_get_yalign org.gtk.Property.set=gtk_inscription_set_yalign)
+   *
+   * The vertical alignment of the text inside the allocated size.
+   *
+   * Compare this to [property@Gtk.Widget:valign], which determines how the
+   * inscription's size allocation is positioned in the available space.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_YALIGN] =
+      g_param_spec_float ("yalign", NULL, NULL,
+                          0.0, 1.0,
+                          DEFAULT_YALIGN,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gtk_inscription_init (GtkInscription *self)
+{
+  self->min_chars = DEFAULT_MIN_CHARS;
+  self->nat_chars = DEFAULT_NAT_CHARS;
+  self->min_lines = DEFAULT_MIN_LINES;
+  self->nat_lines = DEFAULT_NAT_LINES;
+  self->xalign = DEFAULT_XALIGN;
+  self->yalign = DEFAULT_YALIGN;
+
+  self->layout = gtk_widget_create_pango_layout (GTK_WIDGET (self), NULL);
+}
+
+/**
+ * gtk_inscription_new:
+ * @text: (nullable): The text to display.
+ *
+ * Creates a new `GtkInscription` with the given text.
+ *
+ * Returns: a new `GtkInscription`
+ *
+ * Since: 4.8
+ */
+GtkWidget *
+gtk_inscription_new (const char *text)
+{
+  return g_object_new (GTK_TYPE_INSCRIPTION,
+                       "text", text,
+                       NULL);
+}
+
+/**
+ * gtk_inscription_set_text: (attributes org.gtk.Method.set_property=text)
+ * @self: a `GtkInscription`
+ * @text: (nullable): The text to display
+ *
+ * Sets the text to be displayed.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_text (GtkInscription *self,
+                          const char  *text)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (g_strcmp0 (self->text, text) == 0)
+    return;
+
+  g_free (self->text);
+  self->text = g_strdup (text);
+
+  pango_layout_set_text (self->layout,
+                         self->text ? self->text : "",
+                         -1);
+
+  /* This here not being a gtk_widget_queue_resize() is why this widget exists */
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TEXT]);
+}
+
+/**
+ * gtk_inscription_get_text: (attributes org.gtk.Method.get_property=text)
+ * @self: a `GtkInscription`
+ *
+ * Gets the text that is displayed.
+ *
+ * Returns: (nullable) (transfer none): The displayed text
+ *
+ * Since: 4.8
+ */
+const char *
+gtk_inscription_get_text (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), NULL);
+
+  return self->text;
+}
+
+/**
+ * gtk_inscription_set_min_chars: (attributes org.gtk.Method.set_property=min-chars)
+ * @self: a `GtkInscription`
+ * @min_chars: the minimum number of characters that should fit, approximately
+ *
+ * Sets the `min-chars` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:min-chars] property.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_min_chars (GtkInscription *self,
+                               guint           min_chars)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (self->min_chars == min_chars)
+    return;
+
+  self->min_chars = min_chars;
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MIN_CHARS]);
+}
+
+/**
+ * gtk_inscription_get_min_chars: (attributes org.gtk.Method.get_property=min-chars)
+ * @self: a `GtkInscription`
+ *
+ * Gets the `min-chars` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:min-chars] property.
+ *
+ * Returns: the min-chars property
+ *
+ * Since: 4.8
+ */
+guint
+gtk_inscription_get_min_chars (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), DEFAULT_MIN_CHARS);
+
+  return self->min_chars;
+}
+
+/**
+ * gtk_inscription_set_nat_chars: (attributes org.gtk.Method.set_property=nat-chars)
+ * @self: a `GtkInscription`
+ * @nat_chars: the number of characters that should ideally fit, approximately
+ *
+ * Sets the `nat-chars` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:nat-chars] property.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_nat_chars (GtkInscription *self,
+                               guint           nat_chars)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (self->nat_chars == nat_chars)
+    return;
+
+  self->nat_chars = nat_chars;
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_NAT_CHARS]);
+}
+
+/**
+ * gtk_inscription_get_nat_chars: (attributes org.gtk.Method.get_property=nat-chars)
+ * @self: a `GtkInscription`
+ *
+ * Gets the `nat-chars` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:nat-chars] property.
+ *
+ * Returns: the nat-chars property
+ *
+ * Since: 4.8
+ */
+guint
+gtk_inscription_get_nat_chars (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), DEFAULT_NAT_CHARS);
+
+  return self->nat_chars;
+}
+
+/**
+ * gtk_inscription_set_min_lines: (attributes org.gtk.Method.set_property=min-lines)
+ * @self: a `GtkInscription`
+ * @min_lines: the minimum number of lines that should fit, approximately
+ *
+ * Sets the `min-lines` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:min-lines] property.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_min_lines (GtkInscription *self,
+                               guint           min_lines)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (self->min_lines == min_lines)
+    return;
+
+  self->min_lines = min_lines;
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MIN_LINES]);
+}
+
+/**
+ * gtk_inscription_get_min_lines: (attributes org.gtk.Method.get_property=min-lines)
+ * @self: a `GtkInscription`
+ *
+ * Gets the `min-lines` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:min-lines] property.
+ *
+ * Returns: the min-lines property
+ *
+ * Since: 4.8
+ */
+guint
+gtk_inscription_get_min_lines (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), DEFAULT_MIN_LINES);
+
+  return self->min_lines;
+}
+
+/**
+ * gtk_inscription_set_nat_lines: (attributes org.gtk.Method.set_property=nat-lines)
+ * @self: a `GtkInscription`
+ * @nat_lines: the number of lines that should ideally fit
+ *
+ * Sets the `nat-lines` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:nat-lines] property.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_nat_lines (GtkInscription *self,
+                               guint           nat_lines)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (self->nat_lines == nat_lines)
+    return;
+
+  self->nat_lines = nat_lines;
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_NAT_LINES]);
+}
+
+/**
+ * gtk_inscription_get_nat_lines: (attributes org.gtk.Method.get_property=nat-lines)
+ * @self: a `GtkInscription`
+ *
+ * Gets the `nat-lines` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:nat-lines] property.
+ *
+ * Returns: the nat-lines property
+ *
+ * Since: 4.8
+ */
+guint
+gtk_inscription_get_nat_lines (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), DEFAULT_NAT_LINES);
+
+  return self->nat_lines;
+}
+
+/**
+ * gtk_inscription_set_xalign: (attributes org.gtk.Method.set_property=xalign)
+ * @self: a `GtkInscription`
+ * @xalign: the new xalign value, between 0 and 1
+ *
+ * Sets the `xalign` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:xalign] property.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_xalign (GtkInscription *self,
+                            float           xalign)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  xalign = CLAMP (xalign, 0.0, 1.0);
+
+  if (self->xalign == xalign)
+    return;
+
+  self->xalign = xalign;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_XALIGN]);
+}
+
+/**
+ * gtk_inscription_get_xalign: (attributes org.gtk.Method.get_property=xalign)
+ * @self: a `GtkInscription`
+ *
+ * Gets the `xalign` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:xalign] property.
+ *
+ * Returns: the xalign property
+ *
+ * Since: 4.8
+ */
+float
+gtk_inscription_get_xalign (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), DEFAULT_XALIGN);
+
+  return self->xalign;
+}
+
+/**
+ * gtk_inscription_set_yalign: (attributes org.gtk.Method.set_property=yalign)
+ * @self: a `GtkInscription`
+ * @yalign: the new yalign value, between 0 and 1
+ *
+ * Sets the `yalign` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:yalign] property.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_yalign (GtkInscription *self,
+                            float           yalign)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  yalign = CLAMP (yalign, 0.0, 1.0);
+
+  if (self->yalign == yalign)
+    return;
+
+  self->yalign = yalign;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_YALIGN]);
+}
+
+/**
+ * gtk_inscription_get_yalign: (attributes org.gtk.Method.get_property=yalign)
+ * @self: a `GtkInscription`
+ *
+ * Gets the `yalign` of the inscription.
+ *
+ * See the [property@Gtk.Inscription:yalign] property.
+ *
+ * Returns: the yalign property
+ *
+ * Since: 4.8
+ */
+float
+gtk_inscription_get_yalign (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), DEFAULT_YALIGN);
+
+  return self->yalign;
+}
+
diff --git a/gtk/gtkinscription.h b/gtk/gtkinscription.h
new file mode 100644
index 0000000000..83e7eeb81e
--- /dev/null
+++ b/gtk/gtkinscription.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright © 2022 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#ifndef __GTK_INSCRIPTION_H__
+#define __GTK_INSCRIPTION_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtkwidget.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_INSCRIPTION         (gtk_inscription_get_type ())
+
+GDK_AVAILABLE_IN_4_8
+G_DECLARE_FINAL_TYPE (GtkInscription, gtk_inscription, GTK, INSCRIPTION, GtkWidget)
+
+GDK_AVAILABLE_IN_4_8
+GtkWidget *             gtk_inscription_new                     (const char             *text);
+
+GDK_AVAILABLE_IN_4_8
+const char *            gtk_inscription_get_text                (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_text                (GtkInscription         *self,
+                                                                 const char             *text);
+
+GDK_AVAILABLE_IN_4_8
+guint                   gtk_inscription_get_min_chars           (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_min_chars           (GtkInscription         *self,
+                                                                 guint                   min_chars);
+GDK_AVAILABLE_IN_4_8
+guint                   gtk_inscription_get_nat_chars           (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_nat_chars           (GtkInscription         *self,
+                                                                 guint                   nat_chars);
+GDK_AVAILABLE_IN_4_8
+guint                   gtk_inscription_get_min_lines           (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_min_lines           (GtkInscription         *self,
+                                                                 guint                   min_lines);
+GDK_AVAILABLE_IN_4_8
+guint                   gtk_inscription_get_nat_lines           (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_nat_lines           (GtkInscription         *self,
+                                                                 guint                   nat_lines);
+
+GDK_AVAILABLE_IN_4_8
+float                   gtk_inscription_get_xalign              (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_xalign              (GtkInscription         *self,
+                                                                 float                   xalign);
+GDK_AVAILABLE_IN_4_8
+float                   gtk_inscription_get_yalign              (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_yalign              (GtkInscription         *self,
+                                                                 float                   yalign);
+
+G_END_DECLS
+
+#endif  /* __GTK_INSCRIPTION_H__ */
diff --git a/gtk/meson.build b/gtk/meson.build
index 322badc1ad..2e404f2ac4 100644
--- a/gtk/meson.build
+++ b/gtk/meson.build
@@ -283,6 +283,7 @@ gtk_public_sources = files([
   'gtkimmodule.c',
   'gtkimmulticontext.c',
   'gtkinfobar.c',
+  'gtkinscription.c',
   'gtklabel.c',
   'gtklayoutchild.c',
   'gtklayoutmanager.c',
@@ -570,6 +571,7 @@ gtk_public_headers = files([
   'gtkimmodule.h',
   'gtkimmulticontext.h',
   'gtkinfobar.h',
+  'gtkinscription.h',
   'gtklabel.h',
   'gtklayoutchild.h',
   'gtklayoutmanager.h',

From b56b5ed81bb80f4443756362a6ff78863530ee9d Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 19 May 2022 06:45:05 +0200
Subject: [PATCH 02/15] gtk-demo: Use GtkInscription in the main list

---
 demos/gtk-demo/main-listitem.ui | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/demos/gtk-demo/main-listitem.ui b/demos/gtk-demo/main-listitem.ui
index a8d9c47430..aab22e3e20 100644
--- a/demos/gtk-demo/main-listitem.ui
+++ b/demos/gtk-demo/main-listitem.ui
@@ -7,9 +7,9 @@
           <lookup name="item">GtkListItem</lookup>
         </binding>
         <property name="child">
-          <object class="GtkLabel">
-            <property name="halign">start</property>
-            <binding name="label">
+          <object class="GtkInscription">
+            <property name="hexpand">1</property>
+            <binding name="text">
               <lookup name="title" type="GtkDemo">
                 <lookup name="item">expander</lookup>
               </lookup>

From 61bc38cd6188ce978b08cd6846ff32af9d78713e Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Tue, 7 Jun 2022 06:09:37 +0200
Subject: [PATCH 03/15] gtk-demo: Use GtkInscription in the wordlist demo

---
 demos/gtk-demo/listview_words.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/demos/gtk-demo/listview_words.c b/demos/gtk-demo/listview_words.c
index bee23dd562..bc4c9b8f66 100644
--- a/demos/gtk-demo/listview_words.c
+++ b/demos/gtk-demo/listview_words.c
@@ -17,10 +17,9 @@ const char *factory_text =
 "<interface>\n"
 "  <template class='GtkListItem'>\n"
 "    <property name='child'>\n"
-"      <object class='GtkLabel'>\n"
-"        <property name='ellipsize'>end</property>\n"
+"      <object class='GtkInscription'>\n"
 "        <property name='xalign'>0</property>\n"
-"        <binding name='label'>\n"
+"        <binding name='text'>\n"
 "          <lookup name='string' type='GtkStringObject'>\n"
 "            <lookup name='item'>GtkListItem</lookup>\n"
 "          </lookup>\n"

From c796b30136f75110a393c027b4856367ba67cfa8 Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Tue, 7 Jun 2022 06:21:14 +0200
Subject: [PATCH 04/15] testcolumnview: Use GtkInscription

This test is suddenly MASSIVELY faster.

I wonder why.
Could it be because inscription does exactly what it was made for?
---
 tests/testcolumnview.c | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/tests/testcolumnview.c b/tests/testcolumnview.c
index 79b1740cb8..4f5a365f85 100644
--- a/tests/testcolumnview.c
+++ b/tests/testcolumnview.c
@@ -200,7 +200,7 @@ row_data_bind (RowData        *data,
 
   row_data_update_info (data, info);
 
-  gtk_label_set_label (GTK_LABEL (data->name), g_file_info_get_display_name (info));
+  gtk_inscription_set_text (GTK_LABEL (data->name), g_file_info_get_display_name (info));
 
   g_object_unref (info);
 }
@@ -237,10 +237,10 @@ setup_widget (GtkListItem *list_item,
   box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
   gtk_container_add (GTK_CONTAINER (list_item), box);
 
-  child = gtk_label_new (NULL);
-  gtk_label_set_width_chars (GTK_LABEL (child), 5);
-  gtk_label_set_xalign (GTK_LABEL (child), 1.0);
-  g_object_bind_property (list_item, "position", child, "label", G_BINDING_SYNC_CREATE);
+  child = gtk_inscription_new (NULL);
+  gtk_inscription_set_min_chars (GTK_LABEL (child), 5);
+  gtk_inscription_set_xalign (GTK_LABEL (child), 1.0);
+  g_object_bind_property (list_item, "position", child, "text", G_BINDING_SYNC_CREATE);
   gtk_container_add (GTK_CONTAINER (box), child);
 
   data->expander = gtk_tree_expander_new ();
@@ -252,9 +252,8 @@ setup_widget (GtkListItem *list_item,
   data->icon = gtk_image_new ();
   gtk_container_add (GTK_CONTAINER (box), data->icon);
 
-  data->name = gtk_label_new (NULL);
-  gtk_label_set_max_width_chars (GTK_LABEL (data->name), 25);
-  gtk_label_set_ellipsize (GTK_LABEL (data->name), PANGO_ELLIPSIZE_END);
+  data->name = gtk_inscription_new (NULL);
+  gtk_inscription_set_nat_chars (GTK_LABEL (data->name), 25);
   gtk_container_add (GTK_CONTAINER (box), data->name);
 }
 #endif
@@ -441,10 +440,8 @@ const char *ui_file =
 "              </object>\n"
 "            </child>\n"
 "            <child>\n"
-"              <object class='GtkLabel'>\n"
-"                <property name='halign'>start</property>\n"
-"                <property name='label'>start</property>\n"
-"                <binding name='label'>\n"
+"              <object class='GtkInscription'>\n"
+"                <binding name='text'>\n"
 "                  <closure type='gchararray' function='get_string'>\n"
 "                    <lookup name='item'>expander</lookup>\n"
 "                    <constant type='gchararray'>standard::display-name</constant>"
@@ -480,9 +477,8 @@ const char *ui_file =
 "<interface>\n" \
 "  <template class='GtkListItem'>\n" \
 "    <property name='child'>\n" \
-"      <object class='GtkLabel'>\n" \
-"        <property name='halign'>start</property>\n" \
-"        <binding name='label'>\n" \
+"      <object class='GtkInscription'>\n" \
+"        <binding name='text'>\n" \
 "          <closure type='gchararray' function='get_string'>\n" \
 "            <lookup name='item' type='GtkTreeListRow'><lookup name='item'>GtkListItem</lookup></lookup>\n" \
 "            <constant type='gchararray'>" attr "</constant>" \
@@ -623,6 +619,7 @@ const char *factory_ui =
 "  <template class='GtkListItem'>\n"
 "    <property name='child'>\n"
 "      <object class='GtkLabel'>\n"
+"        <property name='xalign'>0</property>\n"
 "        <binding name='label'>\n"
 "          <lookup name='title' type='GtkColumnViewColumn'>\n"
 "            <lookup name='item'>GtkListItem</lookup>\n"

From 6ac7f0562b5a4f67dcae6ac6f2f625a5dc98ebdd Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Tue, 7 Jun 2022 17:23:32 +0200
Subject: [PATCH 05/15] inspector: Use inscriptions in the object tree

---
 gtk/inspector/object-tree.c | 74 ++++++++++++++++++-------------------
 1 file changed, 35 insertions(+), 39 deletions(-)

diff --git a/gtk/inspector/object-tree.c b/gtk/inspector/object-tree.c
index e49c494c5c..9e88e19f62 100644
--- a/gtk/inspector/object-tree.c
+++ b/gtk/inspector/object-tree.c
@@ -41,6 +41,7 @@
 #include "gtkflattenlistmodel.h"
 #include "gtkbuiltiniconprivate.h"
 #include "gtkiconview.h"
+#include "gtkinscription.h"
 #include "gtklabel.h"
 #include "gtklistitem.h"
 #include "gtkpopover.h"
@@ -975,24 +976,23 @@ static void
 setup_type_cb (GtkSignalListItemFactory *factory,
                GtkListItem              *list_item)
 {
-  GtkWidget *expander, *label;
+  GtkWidget *expander, *inscription;
 
   /* expander */
   expander = gtk_tree_expander_new ();
   gtk_list_item_set_child (list_item, expander);
 
   /* label */
-  label = gtk_label_new (NULL);
-  gtk_label_set_width_chars (GTK_LABEL (label), 30);
-  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
-  gtk_tree_expander_set_child (GTK_TREE_EXPANDER (expander), label);
+  inscription = gtk_inscription_new (NULL);
+  gtk_inscription_set_nat_chars (GTK_INSCRIPTION (inscription), 30);
+  gtk_tree_expander_set_child (GTK_TREE_EXPANDER (expander), inscription);
 }
 
 static void
 bind_type_cb (GtkSignalListItemFactory *factory,
               GtkListItem              *list_item)
 {
-  GtkWidget *expander, *label;
+  GtkWidget *expander, *inscription;
   GtkTreeListRow *list_row;
   gpointer item;
 
@@ -1001,17 +1001,17 @@ bind_type_cb (GtkSignalListItemFactory *factory,
   gtk_tree_expander_set_list_row (GTK_TREE_EXPANDER (expander), list_row);
   item = gtk_tree_list_row_get_item (list_row);
   expander = gtk_list_item_get_child (list_item);
-  label = gtk_tree_expander_get_child (GTK_TREE_EXPANDER (expander));
+  inscription = gtk_tree_expander_get_child (GTK_TREE_EXPANDER (expander));
 
-  gtk_label_set_label (GTK_LABEL (label), G_OBJECT_TYPE_NAME (item));
+  gtk_inscription_set_text (GTK_INSCRIPTION (inscription), G_OBJECT_TYPE_NAME (item));
 
   if (GTK_IS_WIDGET (item))
     {
-      g_signal_connect (item, "map", G_CALLBACK (widget_mapped), label);
-      g_signal_connect (item, "unmap", G_CALLBACK (widget_unmapped), label);
+      g_signal_connect (item, "map", G_CALLBACK (widget_mapped), inscription);
+      g_signal_connect (item, "unmap", G_CALLBACK (widget_unmapped), inscription);
       if (!gtk_widget_get_mapped (item))
-        widget_unmapped (item, label);
-      g_object_set_data (G_OBJECT (label), "binding", g_object_ref (item));
+        widget_unmapped (item, inscription);
+      g_object_set_data (G_OBJECT (inscription), "binding", g_object_ref (item));
     }
 
   g_object_unref (item);
@@ -1040,26 +1040,24 @@ static void
 setup_name_cb (GtkSignalListItemFactory *factory,
                GtkListItem              *list_item)
 {
-  GtkWidget *label;
+  GtkWidget *inscription;
 
-  label = gtk_label_new (NULL);
-  gtk_label_set_width_chars (GTK_LABEL (label), 15);
-  gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
-  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
-  gtk_list_item_set_child (list_item, label);
+  inscription = gtk_inscription_new (NULL);
+  gtk_inscription_set_nat_chars (GTK_INSCRIPTION (inscription), 15);
+  gtk_list_item_set_child (list_item, inscription);
 }
 
 static void
 bind_name_cb (GtkSignalListItemFactory *factory,
               GtkListItem              *list_item)
 {
-  GtkWidget *label;
+  GtkWidget *inscription;
   gpointer item;
 
   item = gtk_tree_list_row_get_item (gtk_list_item_get_item (list_item));
-  label = gtk_list_item_get_child (list_item);
+  inscription = gtk_list_item_get_child (list_item);
 
-  gtk_label_set_label (GTK_LABEL (label), gtk_inspector_get_object_name (item));
+  gtk_inscription_set_text (GTK_INSCRIPTION (inscription), gtk_inspector_get_object_name (item));
 
   g_object_unref (item);
 }
@@ -1068,54 +1066,52 @@ static void
 setup_label_cb (GtkSignalListItemFactory *factory,
                 GtkListItem              *list_item)
 {
-  GtkWidget *label;
+  GtkWidget *inscription;
 
-  label = gtk_label_new (NULL);
-  gtk_label_set_width_chars (GTK_LABEL (label), 25);
-  gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
-  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
-  gtk_list_item_set_child (list_item, label);
+  inscription = gtk_inscription_new (NULL);
+  gtk_inscription_set_nat_chars (GTK_INSCRIPTION (inscription), 25);
+  gtk_list_item_set_child (list_item, inscription);
 }
 
 static void
 bind_label_cb (GtkSignalListItemFactory *factory,
                GtkListItem              *list_item)
 {
-  GtkWidget *label;
+  GtkWidget *inscription;
   gpointer item;
   GBinding *binding = NULL;
 
   item = gtk_tree_list_row_get_item (gtk_list_item_get_item (list_item));
-  label = gtk_list_item_get_child (list_item);
+  inscription = gtk_list_item_get_child (list_item);
 
   if (GTK_IS_LABEL (item))
-    binding = g_object_bind_property (item, "label", label, "label", G_BINDING_SYNC_CREATE);
+    binding = g_object_bind_property (item, "label", inscription, "text", G_BINDING_SYNC_CREATE);
   else if (GTK_IS_BUTTON (item))
-    binding = g_object_bind_property (item, "label", label, "label", G_BINDING_SYNC_CREATE);
+    binding = g_object_bind_property (item, "label", inscription, "text", G_BINDING_SYNC_CREATE);
   else if (GTK_IS_WINDOW (item))
-    binding = g_object_bind_property (item, "title", label, "label", G_BINDING_SYNC_CREATE);
+    binding = g_object_bind_property (item, "title", inscription, "text", G_BINDING_SYNC_CREATE);
   else if (GTK_IS_TREE_VIEW_COLUMN (item))
-    binding = g_object_bind_property (item, "title", label, "label", G_BINDING_SYNC_CREATE);
+    binding = g_object_bind_property (item, "title", inscription, "text", G_BINDING_SYNC_CREATE);
   else if (GTK_IS_EDITABLE (item))
-    binding = g_object_bind_property (item, "text", label, "label", G_BINDING_SYNC_CREATE);
+    binding = g_object_bind_property (item, "text", inscription, "text", G_BINDING_SYNC_CREATE);
   else
-    gtk_label_set_label (GTK_LABEL (label), NULL);
+    gtk_inscription_set_text (GTK_INSCRIPTION (inscription), NULL);
 
   g_object_unref (item);
 
   if (binding)
-    g_object_set_data (G_OBJECT (label), "binding", binding);
+    g_object_set_data (G_OBJECT (inscription), "binding", binding);
 }
 
 static void
 unbind_label_cb (GtkSignalListItemFactory *factory,
                  GtkListItem              *list_item)
 {
-  GtkWidget *label;
+  GtkWidget *inscription;
   GBinding *binding;
 
-  label = gtk_list_item_get_child (list_item);
-  binding = g_object_steal_data (G_OBJECT (label), "binding");
+  inscription = gtk_list_item_get_child (list_item);
+  binding = g_object_steal_data (G_OBJECT (inscription), "binding");
   if (binding)
     g_binding_unbind (binding);
 }

From abdbef1b5ebb5407123906985026a8e8503362ab Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Tue, 7 Jun 2022 17:30:14 +0200
Subject: [PATCH 06/15] inspector: Add inscription support

Allow searching for inscription text and show it in the label column.
---
 gtk/inspector/object-tree.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/gtk/inspector/object-tree.c b/gtk/inspector/object-tree.c
index 9e88e19f62..34a7406683 100644
--- a/gtk/inspector/object-tree.c
+++ b/gtk/inspector/object-tree.c
@@ -836,6 +836,8 @@ match_object (GObject    *object,
 
   if (GTK_IS_LABEL (object))
     return match_string (gtk_label_get_label (GTK_LABEL (object)), text);
+  if (GTK_IS_INSCRIPTION (object))
+    return match_string (gtk_inscription_get_text (GTK_INSCRIPTION (object)), text);
   else if (GTK_IS_BUTTON (object))
     return match_string (gtk_button_get_label (GTK_BUTTON (object)), text);
   else if (GTK_IS_WINDOW (object))
@@ -1086,6 +1088,8 @@ bind_label_cb (GtkSignalListItemFactory *factory,
 
   if (GTK_IS_LABEL (item))
     binding = g_object_bind_property (item, "label", inscription, "text", G_BINDING_SYNC_CREATE);
+  if (GTK_IS_INSCRIPTION (item))
+    binding = g_object_bind_property (item, "text", inscription, "text", G_BINDING_SYNC_CREATE);
   else if (GTK_IS_BUTTON (item))
     binding = g_object_bind_property (item, "label", inscription, "text", G_BINDING_SYNC_CREATE);
   else if (GTK_IS_WINDOW (item))

From b8199bcc1f28239b6050a8951493172e026965b8 Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 9 Jun 2022 02:42:10 +0200
Subject: [PATCH 07/15] gtkpango: Add G_GNUC_WARN_UNUSED_RESULT

Guess who just spent 10 minutes in gdb and doesn't want to do that
again.
---
 gtk/gtkpango.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gtk/gtkpango.h b/gtk/gtkpango.h
index a7eae932c3..55cab30b3c 100644
--- a/gtk/gtkpango.h
+++ b/gtk/gtkpango.h
@@ -31,7 +31,7 @@
 G_BEGIN_DECLS
 
 PangoAttrList *_gtk_pango_attr_list_merge (PangoAttrList *into,
-                                           PangoAttrList *from);
+                                           PangoAttrList *from) G_GNUC_WARN_UNUSED_RESULT;
 
 gboolean gtk_buildable_attribute_tag_start (GtkBuildable       *buildable,
                                             GtkBuilder         *builder,

From 3f4c88aad1a9060015c809b3a2cdb78545feabba Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 9 Jun 2022 00:59:05 +0200
Subject: [PATCH 08/15] inscription: Add ::attributes property

---
 gtk/gtkinscription.c | 102 ++++++++++++++++++++++++++++++++++++++++---
 gtk/gtkinscription.h |   5 +++
 2 files changed, 101 insertions(+), 6 deletions(-)

diff --git a/gtk/gtkinscription.c b/gtk/gtkinscription.c
index ca18a200a3..e3559e01b1 100644
--- a/gtk/gtkinscription.c
+++ b/gtk/gtkinscription.c
@@ -21,7 +21,9 @@
 
 #include "gtkinscription.h"
 
+#include "gtkcssnodeprivate.h"
 #include "gtkcssstylechangeprivate.h"
+#include "gtkpango.h"
 #include "gtksnapshot.h"
 #include "gtkwidgetprivate.h"
 
@@ -66,6 +68,7 @@ struct _GtkInscription
   guint nat_lines;
   float xalign;
   float yalign;
+  PangoAttrList *attrs;
 
   PangoLayout *layout;
 };
@@ -73,6 +76,7 @@ struct _GtkInscription
 enum
 {
   PROP_0,
+  PROP_ATTRIBUTES,
   PROP_MIN_CHARS,
   PROP_MIN_LINES,
   PROP_NAT_CHARS,
@@ -118,6 +122,10 @@ gtk_inscription_get_property (GObject    *object,
 
   switch (property_id)
     {
+    case PROP_ATTRIBUTES:
+      g_value_set_boxed (value, self->attrs);
+      break;
+
     case PROP_MIN_CHARS:
       g_value_set_uint (value, self->min_chars);
       break;
@@ -162,6 +170,10 @@ gtk_inscription_set_property (GObject      *object,
 
   switch (property_id)
     {
+    case PROP_ATTRIBUTES:
+      gtk_inscription_set_attributes (self, g_value_get_boxed (value));
+      break;
+
     case PROP_MIN_CHARS:
       gtk_inscription_set_min_chars (self, g_value_get_uint (value));
       break;
@@ -196,6 +208,23 @@ gtk_inscription_set_property (GObject      *object,
     }
 }
 
+static void
+gtk_inscription_update_layout_attributes (GtkInscription *self,
+                                          PangoAttrList  *css_attrs)
+{
+  PangoAttrList *new_attrs;
+
+  if (css_attrs == NULL)
+    css_attrs = gtk_css_style_get_pango_attributes (gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (self))));
+
+  new_attrs = css_attrs;
+
+  new_attrs = _gtk_pango_attr_list_merge (new_attrs, self->attrs);
+
+  pango_layout_set_attributes (self->layout, new_attrs);
+  pango_attr_list_unref (new_attrs);
+}
+
 static void
 gtk_inscription_css_changed (GtkWidget         *widget,
                              GtkCssStyleChange *change)
@@ -206,12 +235,9 @@ gtk_inscription_css_changed (GtkWidget         *widget,
 
   if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT_ATTRS))
     {
-      PangoAttrList *new_attrs;
-
-      new_attrs = gtk_css_style_get_pango_attributes (gtk_css_style_change_get_new_style (change));
-      pango_layout_set_attributes (self->layout, new_attrs);
-      pango_attr_list_unref (new_attrs);
-
+      gtk_inscription_update_layout_attributes (self,
+          gtk_css_style_get_pango_attributes (gtk_css_style_change_get_new_style (change)));
+      
       gtk_widget_queue_draw (widget);
     }
 }
@@ -408,6 +434,18 @@ gtk_inscription_class_init (GtkInscriptionClass *klass)
   widget_class->size_allocate = gtk_inscription_allocate;
   widget_class->snapshot = gtk_inscription_snapshot;
 
+  /**
+   * GtkInscription:attributes: (attributes org.gtk.Property.get=gtk_inscription_get_attributes org.gtk.Property.set=gtk_inscription_set_attributes)
+   *
+   * A list of style attributes to apply to the text of the inscription.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_ATTRIBUTES] =
+      g_param_spec_boxed ("attributes", NULL, NULL,
+                          PANGO_TYPE_ATTR_LIST,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
   /**
    * GtkInscription:min-chars: (attributes org.gtk.Property.get=gtk_inscription_get_min_chars org.gtk.Property.set=gtk_inscription_set_min_chars)
    *
@@ -906,3 +944,55 @@ gtk_inscription_get_yalign (GtkInscription *self)
   return self->yalign;
 }
 
+/**
+ * gtk_inscription_set_attributes: (attributes org.gtk.Method.set_property=attributes)
+ * @self: a `GtkInscription`
+ * @attrs: (nullable): a [struct@Pango.AttrList]
+ *
+ * Apply attributes to the inscription text.
+ *
+ * These attributes will not be evaluated for sizing the inscription.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_attributes (GtkInscription *self,
+                                PangoAttrList  *attrs)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (self->attrs == attrs)
+    return;
+
+  if (attrs)
+    pango_attr_list_ref (attrs);
+
+  if (self->attrs)
+    pango_attr_list_unref (self->attrs);
+  self->attrs = attrs;
+
+  gtk_inscription_update_layout_attributes (self, NULL);
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ATTRIBUTES]);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+/**
+ * gtk_inscription_get_attributes: (attributes org.gtk.Method.get_property=attributes)
+ * @self: a `GtkInscription`
+ *
+ * Gets the inscription's attribute list.
+ *
+ * Returns: (nullable) (transfer none): the attribute list
+ *
+ * Since: 4.8
+ */
+PangoAttrList *
+gtk_inscription_get_attributes (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), NULL);
+
+  return self->attrs;
+}
+
diff --git a/gtk/gtkinscription.h b/gtk/gtkinscription.h
index 83e7eeb81e..f1f73dcc98 100644
--- a/gtk/gtkinscription.h
+++ b/gtk/gtkinscription.h
@@ -41,6 +41,11 @@ const char *            gtk_inscription_get_text                (GtkInscription
 GDK_AVAILABLE_IN_4_8
 void                    gtk_inscription_set_text                (GtkInscription         *self,
                                                                  const char             *text);
+GDK_AVAILABLE_IN_4_8
+PangoAttrList *         gtk_inscription_get_attributes          (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_attributes          (GtkInscription         *self,
+                                                                 PangoAttrList          *attrs);
 
 GDK_AVAILABLE_IN_4_8
 guint                   gtk_inscription_get_min_chars           (GtkInscription         *self);

From 01fcfc5c2adc9a0fa4c2266b08647b7ddb492048 Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 9 Jun 2022 02:43:13 +0200
Subject: [PATCH 09/15] inscription: Add ::markup

Utility property that sets both the ::text and ::attributes properties,
mainly intended for use in ui files to ease translation support and bindings.
---
 gtk/gtkinscription.c | 66 ++++++++++++++++++++++++++++++++++++++++++++
 gtk/gtkinscription.h |  3 ++
 2 files changed, 69 insertions(+)

diff --git a/gtk/gtkinscription.c b/gtk/gtkinscription.c
index e3559e01b1..b8be525e5d 100644
--- a/gtk/gtkinscription.c
+++ b/gtk/gtkinscription.c
@@ -77,6 +77,7 @@ enum
 {
   PROP_0,
   PROP_ATTRIBUTES,
+  PROP_MARKUP,
   PROP_MIN_CHARS,
   PROP_MIN_LINES,
   PROP_NAT_CHARS,
@@ -174,6 +175,10 @@ gtk_inscription_set_property (GObject      *object,
       gtk_inscription_set_attributes (self, g_value_get_boxed (value));
       break;
 
+    case PROP_MARKUP:
+      gtk_inscription_set_markup (self, g_value_get_string (value));
+      break;
+
     case PROP_MIN_CHARS:
       gtk_inscription_set_min_chars (self, g_value_get_uint (value));
       break;
@@ -446,6 +451,24 @@ gtk_inscription_class_init (GtkInscriptionClass *klass)
                           PANGO_TYPE_ATTR_LIST,
                           G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
+  /**
+   * GtkInscription:markup: (attributes org.gtk.Property.set=gtk_inscription_set_markup)
+   *
+   * Utility property that sets both the [property@Gtk.Inscription:text] and
+   * [property@Gtk.Inscription:attributes] properties, mainly intended for use in
+   * GtkBuilder ui files to ease translation support and bindings.
+   *
+   * This function uses [func@Pango.parse_markup] to parse the markup into text and
+   * attributes. The markup must be valid. If you cannot ensure that, consider using
+   * [func@Pango.parse_markup] and setting the two properties yourself.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_MARKUP] =
+    g_param_spec_string ("markup", NULL, NULL,
+                         NULL,
+                         G_PARAM_WRITABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
   /**
    * GtkInscription:min-chars: (attributes org.gtk.Property.get=gtk_inscription_get_min_chars org.gtk.Property.set=gtk_inscription_set_min_chars)
    *
@@ -996,3 +1019,46 @@ gtk_inscription_get_attributes (GtkInscription *self)
   return self->attrs;
 }
 
+/**
+ * gtk_inscription_set_markup: (attributes org.gtk.Method.set_property=markup)
+ * @self: a `GtkInscription`
+ * @markup: (nullable): The markup to display
+ *
+ * Utility function to set the text and attributes to be displayed.
+ *
+ * See the [property@Gtk.Inscription:markup] property.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_markup (GtkInscription *self,
+                            const char     *markup)
+{
+  PangoAttrList *attrs;
+  char *text;
+  GError *error = NULL;
+
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (markup == NULL)
+    {
+      text = NULL;
+      attrs = NULL;
+    }
+  else if (!pango_parse_markup (markup, -1,
+                           0,
+                           &attrs, &text,
+                           NULL,
+                           &error))
+    {
+      g_warning ("Failed to set text '%s' from markup due to error parsing markup: %s",
+                 markup, error->message);
+      return;
+    }
+
+  gtk_inscription_set_text (self, text);
+  gtk_inscription_set_attributes (self, attrs);
+
+  g_clear_pointer (&text, g_free);
+  g_clear_pointer (&attrs, pango_attr_list_unref);
+}
diff --git a/gtk/gtkinscription.h b/gtk/gtkinscription.h
index f1f73dcc98..856ecd39e7 100644
--- a/gtk/gtkinscription.h
+++ b/gtk/gtkinscription.h
@@ -46,6 +46,9 @@ PangoAttrList *         gtk_inscription_get_attributes          (GtkInscription
 GDK_AVAILABLE_IN_4_8
 void                    gtk_inscription_set_attributes          (GtkInscription         *self,
                                                                  PangoAttrList          *attrs);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_markup              (GtkInscription         *self,
+                                                                 const char             *markup);
 
 GDK_AVAILABLE_IN_4_8
 guint                   gtk_inscription_get_min_chars           (GtkInscription         *self);

From 9973a7173ff6d814b23550bf1288ae7fb1e65ec2 Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 9 Jun 2022 02:45:59 +0200
Subject: [PATCH 10/15] reftests: Add test for inscription markup parsing

Compare with label markup parsing as the reference.
---
 testsuite/reftests/inscription-markup.ref.ui | 29 ++++++++++++++++++++
 testsuite/reftests/inscription-markup.ui     | 27 ++++++++++++++++++
 testsuite/reftests/meson.build               |  2 ++
 3 files changed, 58 insertions(+)
 create mode 100644 testsuite/reftests/inscription-markup.ref.ui
 create mode 100644 testsuite/reftests/inscription-markup.ui

diff --git a/testsuite/reftests/inscription-markup.ref.ui b/testsuite/reftests/inscription-markup.ref.ui
new file mode 100644
index 0000000000..cf0e3474c1
--- /dev/null
+++ b/testsuite/reftests/inscription-markup.ref.ui
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow">
+    <property name="decorated">0</property>
+    <property name="default-width">800</property>
+    <property name="default-height">600</property>
+    <child>
+      <object class="GtkLabel">
+        <property name="use-markup">1</property>
+        <property name="wrap">1</property>
+        <property name="label" translatable="yes">Text sizes: &lt;span size="xx-small"&gt;tiny &lt;/span&gt;&lt;span size="x-small"&gt;very small &lt;/span&gt;&lt;span size="small"&gt;small &lt;/span&gt;&lt;span size="medium"&gt;normal &lt;/span&gt;&lt;span size="large"&gt;large &lt;/span&gt;&lt;span size="x-large"&gt;very large &lt;/span&gt;&lt;span size="xx-large"&gt;huge&lt;/span&gt;
+Text styles: &lt;span style="normal"&gt;Normal&lt;/span&gt; &lt;span style="italic"&gt;Italic&lt;/span&gt; &lt;span style="oblique"&gt;Olique&lt;/span&gt;
+Text weights: &lt;span weight="thin"&gt;thin&lt;/span&gt; &lt;span weight="light"&gt;light&lt;/span&gt; &lt;span weight="normal"&gt;normal&lt;/span&gt; &lt;span weight="bold"&gt;bold&lt;/span&gt; &lt;span weight="ultraheavy"&gt;ultraheavy&lt;/span&gt;
+Text &lt;span color="gray"&gt;c&lt;span color="green"&gt;o&lt;/span&gt;l&lt;span color="tomato"&gt;o&lt;/span&gt;rs&lt;/span&gt; and &lt;span background="pink"&gt;backgrounds&lt;/span&gt;
+Colorful &lt;span underline="low" underline-color="blue"&gt;&lt;span underline="double" underline-color="red"&gt;under&lt;/span&gt;lines&lt;/span&gt; and &lt;span background="pink"&gt;&lt;span underline="error"&gt;mo&lt;/span&gt;&lt;span underline="error" underline-color="green"&gt;re&lt;/span&gt;&lt;/span&gt;
+Colorful &lt;span strikethrough="true" strikethrough-color="magenta"&gt;strikethroughs&lt;/span&gt; and &lt;span overline="single" overline_color="green"&gt;overlines&lt;/span&gt;
+Superscripts and subscripts: 𝜀&lt;span rise="-6000" size="x-small" font_desc="italic"&gt;0&lt;/span&gt; = 𝜔&lt;span rise="8000" size="smaller"&gt;𝜔&lt;span rise="14000" size="smaller"&gt;𝜔&lt;span rise="20000"&gt;.&lt;span rise="23000"&gt;.&lt;span rise="26000"&gt;.&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;
+&lt;span letter_spacing="3000"&gt;Letterspacing&lt;/span&gt;
+OpenType font features: &lt;span font_desc="sans regular" font_features="dlig=0"&gt;feast&lt;/span&gt; versus &lt;span font_desc="sans regular" font_features="dlig=1"&gt;feast&lt;/span&gt;
+Shortcuts: &lt;tt&gt;Monospace&lt;/tt&gt; – &lt;b&gt;Bold&lt;/b&gt; – &lt;i&gt;Italic&lt;/i&gt; – &lt;big&gt;Big&lt;/big&gt; – &lt;small&gt;Small&lt;/small&gt; – &lt;u&gt;Underlined&lt;/u&gt; – &lt;s&gt;Strikethrough&lt;/s&gt; – Super&lt;sup&gt;script&lt;/sup&gt; – Sub&lt;sub&gt;script&lt;/sub&gt;
+hy­phen­ation al­go­rithm is a &lt;span allow_breaks="false" style="italic"&gt;set of rules&lt;/span&gt;, espe­ci­ally one co­di­fied for im­ple­men­tation in a com­pu­ter pro­gram, that de­ci­des at which points a word can be bro­ken over two lines with a hy­phen. For ex­am­ple, a hy­phen­ation al­go­rithm might de­cide that im­peach­ment can be broken as impeach‧ment or im‧peachment but not impe‧achment.
+&lt;span insert_hyphens="false"&gt;one/two three/four five/six seven/eight nine/ten&lt;/span&gt;
+&lt;span line_height='1.33'&gt;Line height: This is an example of widely spaced text. It was achieved by setting the line-height factor to 1.33. You can set the line-height factor to any value between 0 and 10.
+Note that the line height affects the spacing between paragraphs as well as between the wrapped lines inside a paragraph.&lt;/span&gt;
+Transforms: &lt;span text_transform='uppercase'&gt;straße&lt;/span&gt; &lt;span text_transform='capitalize'&gt;up, up and away&lt;/span&gt;</property>
+      </object>
+    </child>
+  </object>
+</interface>
diff --git a/testsuite/reftests/inscription-markup.ui b/testsuite/reftests/inscription-markup.ui
new file mode 100644
index 0000000000..7ca256b068
--- /dev/null
+++ b/testsuite/reftests/inscription-markup.ui
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow">
+    <property name="decorated">0</property>
+    <property name="default-width">800</property>
+    <property name="default-height">600</property>
+    <child>
+      <object class="GtkInscription">
+        <property name="markup" translatable="yes">Text sizes: &lt;span size="xx-small"&gt;tiny &lt;/span&gt;&lt;span size="x-small"&gt;very small &lt;/span&gt;&lt;span size="small"&gt;small &lt;/span&gt;&lt;span size="medium"&gt;normal &lt;/span&gt;&lt;span size="large"&gt;large &lt;/span&gt;&lt;span size="x-large"&gt;very large &lt;/span&gt;&lt;span size="xx-large"&gt;huge&lt;/span&gt;
+Text styles: &lt;span style="normal"&gt;Normal&lt;/span&gt; &lt;span style="italic"&gt;Italic&lt;/span&gt; &lt;span style="oblique"&gt;Olique&lt;/span&gt;
+Text weights: &lt;span weight="thin"&gt;thin&lt;/span&gt; &lt;span weight="light"&gt;light&lt;/span&gt; &lt;span weight="normal"&gt;normal&lt;/span&gt; &lt;span weight="bold"&gt;bold&lt;/span&gt; &lt;span weight="ultraheavy"&gt;ultraheavy&lt;/span&gt;
+Text &lt;span color="gray"&gt;c&lt;span color="green"&gt;o&lt;/span&gt;l&lt;span color="tomato"&gt;o&lt;/span&gt;rs&lt;/span&gt; and &lt;span background="pink"&gt;backgrounds&lt;/span&gt;
+Colorful &lt;span underline="low" underline-color="blue"&gt;&lt;span underline="double" underline-color="red"&gt;under&lt;/span&gt;lines&lt;/span&gt; and &lt;span background="pink"&gt;&lt;span underline="error"&gt;mo&lt;/span&gt;&lt;span underline="error" underline-color="green"&gt;re&lt;/span&gt;&lt;/span&gt;
+Colorful &lt;span strikethrough="true" strikethrough-color="magenta"&gt;strikethroughs&lt;/span&gt; and &lt;span overline="single" overline_color="green"&gt;overlines&lt;/span&gt;
+Superscripts and subscripts: 𝜀&lt;span rise="-6000" size="x-small" font_desc="italic"&gt;0&lt;/span&gt; = 𝜔&lt;span rise="8000" size="smaller"&gt;𝜔&lt;span rise="14000" size="smaller"&gt;𝜔&lt;span rise="20000"&gt;.&lt;span rise="23000"&gt;.&lt;span rise="26000"&gt;.&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;
+&lt;span letter_spacing="3000"&gt;Letterspacing&lt;/span&gt;
+OpenType font features: &lt;span font_desc="sans regular" font_features="dlig=0"&gt;feast&lt;/span&gt; versus &lt;span font_desc="sans regular" font_features="dlig=1"&gt;feast&lt;/span&gt;
+Shortcuts: &lt;tt&gt;Monospace&lt;/tt&gt; – &lt;b&gt;Bold&lt;/b&gt; – &lt;i&gt;Italic&lt;/i&gt; – &lt;big&gt;Big&lt;/big&gt; – &lt;small&gt;Small&lt;/small&gt; – &lt;u&gt;Underlined&lt;/u&gt; – &lt;s&gt;Strikethrough&lt;/s&gt; – Super&lt;sup&gt;script&lt;/sup&gt; – Sub&lt;sub&gt;script&lt;/sub&gt;
+hy­phen­ation al­go­rithm is a &lt;span allow_breaks="false" style="italic"&gt;set of rules&lt;/span&gt;, espe­ci­ally one co­di­fied for im­ple­men­tation in a com­pu­ter pro­gram, that de­ci­des at which points a word can be bro­ken over two lines with a hy­phen. For ex­am­ple, a hy­phen­ation al­go­rithm might de­cide that im­peach­ment can be broken as impeach‧ment or im‧peachment but not impe‧achment.
+&lt;span insert_hyphens="false"&gt;one/two three/four five/six seven/eight nine/ten&lt;/span&gt;
+&lt;span line_height='1.33'&gt;Line height: This is an example of widely spaced text. It was achieved by setting the line-height factor to 1.33. You can set the line-height factor to any value between 0 and 10.
+Note that the line height affects the spacing between paragraphs as well as between the wrapped lines inside a paragraph.&lt;/span&gt;
+Transforms: &lt;span text_transform='uppercase'&gt;straße&lt;/span&gt; &lt;span text_transform='capitalize'&gt;up, up and away&lt;/span&gt;</property>
+      </object>
+    </child>
+  </object>
+</interface>
diff --git a/testsuite/reftests/meson.build b/testsuite/reftests/meson.build
index 301f8bd0c5..3001d0e127 100644
--- a/testsuite/reftests/meson.build
+++ b/testsuite/reftests/meson.build
@@ -367,6 +367,8 @@ testdata = [
   'image-load-from-file.css',
   'image-load-from-file.ref.ui',
   'image-load-from-file.ui',
+  'inscription-markup.ref.ui',
+  'inscription-markup.ui',
   'label-attribute-preference.css',
   'label-attribute-preference.ref.ui',
   'label-attribute-preference.ui',

From 1517c1813cf7e8e2784288d8aa174a912e713807 Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 9 Jun 2022 05:17:40 +0200
Subject: [PATCH 11/15] inscription: Add ::text-overflow

Can't name it ::overflow, because that's taken by GtkWidget already
---
 gtk/gtkinscription.c | 117 +++++++++++++++++++++++++++++++++++++++++++
 gtk/gtkinscription.h |  22 ++++++++
 2 files changed, 139 insertions(+)

diff --git a/gtk/gtkinscription.c b/gtk/gtkinscription.c
index b8be525e5d..522d943933 100644
--- a/gtk/gtkinscription.c
+++ b/gtk/gtkinscription.c
@@ -25,6 +25,7 @@
 #include "gtkcssstylechangeprivate.h"
 #include "gtkpango.h"
 #include "gtksnapshot.h"
+#include "gtktypebuiltins.h"
 #include "gtkwidgetprivate.h"
 
 /**
@@ -69,6 +70,7 @@ struct _GtkInscription
   float xalign;
   float yalign;
   PangoAttrList *attrs;
+  GtkInscriptionOverflow overflow;
 
   PangoLayout *layout;
 };
@@ -83,6 +85,7 @@ enum
   PROP_NAT_CHARS,
   PROP_NAT_LINES,
   PROP_TEXT,
+  PROP_TEXT_OVERFLOW,
   PROP_XALIGN,
   PROP_YALIGN,
 
@@ -147,6 +150,10 @@ gtk_inscription_get_property (GObject    *object,
       g_value_set_string (value, self->text);
       break;
 
+    case PROP_TEXT_OVERFLOW:
+      g_value_set_enum (value, self->overflow);
+      break;
+
     case PROP_XALIGN:
       g_value_set_float (value, self->xalign);
       break;
@@ -199,6 +206,10 @@ gtk_inscription_set_property (GObject      *object,
       gtk_inscription_set_text (self, g_value_get_string (value));
       break;
 
+    case PROP_TEXT_OVERFLOW:
+      gtk_inscription_set_text_overflow (self, g_value_get_enum (value));
+      break;
+
     case PROP_XALIGN:
       gtk_inscription_set_xalign (self, g_value_get_float (value));
       break;
@@ -402,6 +413,36 @@ gtk_inscription_allocate (GtkWidget *widget,
   GtkInscription *self = GTK_INSCRIPTION (widget);
 
   pango_layout_set_width (self->layout, width * PANGO_SCALE);
+
+  switch (self->overflow)
+    {
+    case GTK_INSCRIPTION_OVERFLOW_CLIP:
+      pango_layout_set_height (self->layout, -1);
+      /* figure out if we're single line (clip horizontally)
+       * or multiline (clip vertically):
+       * If we can't fit 2 rows, we're single line.
+       */
+      {
+        PangoLayoutIter *iter = pango_layout_get_iter (self->layout);
+        if (pango_layout_iter_next_line (iter))
+          {
+            PangoRectangle rect;
+            pango_layout_iter_get_line_extents (iter, NULL, &rect);
+            if (rect.y + rect.height > height * PANGO_SCALE)
+              pango_layout_set_width (self->layout, -1);
+          }
+      }
+      break;
+
+    case GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START:
+    case GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE:
+    case GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END:
+      pango_layout_set_height (self->layout, height * PANGO_SCALE);
+      break;
+    default:
+      g_assert_not_reached();
+      break;
+    }
 }
 
 static void
@@ -566,6 +607,19 @@ gtk_inscription_class_init (GtkInscriptionClass *klass)
                          NULL,
                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
+  /**
+   * GtkInscription:text-overflow: (attributes org.gtk.Property.get=gtk_inscription_get_text_overflow org.gtk.Property.set=gtk_inscription_set_text_overflow)
+   *
+   * The overflow method to use for the text.
+   *
+   * Since: 4.8
+   */
+  properties[PROP_TEXT_OVERFLOW] =
+    g_param_spec_enum ("text-overflow", NULL, NULL,
+                       GTK_TYPE_INSCRIPTION_OVERFLOW,
+                       GTK_INSCRIPTION_OVERFLOW_CLIP,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
   /**
    * GtkInscription:xalign: (attributes org.gtk.Property.get=gtk_inscription_get_xalign org.gtk.Property.set=gtk_inscription_set_xalign)
    *
@@ -612,6 +666,7 @@ gtk_inscription_init (GtkInscription *self)
   self->yalign = DEFAULT_YALIGN;
 
   self->layout = gtk_widget_create_pango_layout (GTK_WIDGET (self), NULL);
+  pango_layout_set_wrap (self->layout, PANGO_WRAP_WORD_CHAR);
 }
 
 /**
@@ -1019,6 +1074,68 @@ gtk_inscription_get_attributes (GtkInscription *self)
   return self->attrs;
 }
 
+/**
+ * gtk_inscription_set_text_overflow: (attributes org.gtk.Method.set_property=text-overflow)
+ * @self: a `GtkInscription`
+ * @overflow: the overflow method to use
+ *
+ * Sets what to do when the text doesn't fit.
+ *
+ * Since: 4.8
+ */
+void
+gtk_inscription_set_text_overflow (GtkInscription         *self,
+                                   GtkInscriptionOverflow  overflow)
+{
+  g_return_if_fail (GTK_IS_INSCRIPTION (self));
+
+  if (self->overflow == overflow)
+    return;
+
+  self->overflow = overflow;
+
+  switch (self->overflow)
+    {
+    case GTK_INSCRIPTION_OVERFLOW_CLIP:
+      pango_layout_set_ellipsize (self->layout, PANGO_ELLIPSIZE_NONE);
+      break;
+    case GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START:
+      pango_layout_set_ellipsize (self->layout, PANGO_ELLIPSIZE_START);
+      break;
+    case GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE:
+      pango_layout_set_ellipsize (self->layout, PANGO_ELLIPSIZE_MIDDLE);
+      break;
+    case GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END:
+      pango_layout_set_ellipsize (self->layout, PANGO_ELLIPSIZE_END);
+      break;
+    default:
+      g_assert_not_reached();
+      break;
+    }
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TEXT_OVERFLOW]);
+}
+
+/**
+ * gtk_inscription_get_text_overflow: (attributes org.gtk.Method.get_property=text-overflow)
+ * @self: a `GtkInscription`
+ *
+ * Gets the inscription's overflow method.
+ *
+ * Returns: the overflow method
+ *
+ * Since: 4.8
+ */
+GtkInscriptionOverflow
+gtk_inscription_get_text_overflow (GtkInscription *self)
+{
+  g_return_val_if_fail (GTK_IS_INSCRIPTION (self), GTK_INSCRIPTION_OVERFLOW_CLIP);
+
+  return self->overflow;
+}
+
 /**
  * gtk_inscription_set_markup: (attributes org.gtk.Method.set_property=markup)
  * @self: a `GtkInscription`
diff --git a/gtk/gtkinscription.h b/gtk/gtkinscription.h
index 856ecd39e7..af53a7917d 100644
--- a/gtk/gtkinscription.h
+++ b/gtk/gtkinscription.h
@@ -30,6 +30,23 @@ G_BEGIN_DECLS
 
 #define GTK_TYPE_INSCRIPTION         (gtk_inscription_get_type ())
 
+/**
+ * GtkInscriptionOverflow:
+ * @GTK_INSCRIPTION_OVERFLOW_CLIP: Clip the remaining text
+ * @GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START: Omit characters at the start of the text
+ * @GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE: Omit characters at the middle of the text
+ * @GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END: Omit characters at the end of the text
+ *
+ * The different methods to handle text in #GtkInscription when it doesn't
+ * fit the available space.
+ */
+typedef enum {
+  GTK_INSCRIPTION_OVERFLOW_CLIP,
+  GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START,
+  GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE,
+  GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END
+} GtkInscriptionOverflow;
+
 GDK_AVAILABLE_IN_4_8
 G_DECLARE_FINAL_TYPE (GtkInscription, gtk_inscription, GTK, INSCRIPTION, GtkWidget)
 
@@ -49,6 +66,11 @@ void                    gtk_inscription_set_attributes          (GtkInscription
 GDK_AVAILABLE_IN_4_8
 void                    gtk_inscription_set_markup              (GtkInscription         *self,
                                                                  const char             *markup);
+GDK_AVAILABLE_IN_4_8
+GtkInscriptionOverflow  gtk_inscription_get_text_overflow       (GtkInscription         *self);
+GDK_AVAILABLE_IN_4_8
+void                    gtk_inscription_set_text_overflow       (GtkInscription         *self,
+                                                                 GtkInscriptionOverflow  overflow);
 
 GDK_AVAILABLE_IN_4_8
 guint                   gtk_inscription_get_min_chars           (GtkInscription         *self);

From e437a9c348b795445e1dadc801497c1075c3738e Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 9 Jun 2022 07:14:30 +0200
Subject: [PATCH 12/15] inscription: Add a11y support for text interface

This is entirely untested.
---
 gtk/a11y/gtkatspitext.c     | 271 ++++++++++++++++++++++++++++++++++++
 gtk/gtkinscription.c        |  11 +-
 gtk/gtkinscriptionprivate.h |  33 +++++
 3 files changed, 314 insertions(+), 1 deletion(-)
 create mode 100644 gtk/gtkinscriptionprivate.h

diff --git a/gtk/a11y/gtkatspitext.c b/gtk/a11y/gtkatspitext.c
index e4a6140298..e7bd9275be 100644
--- a/gtk/a11y/gtkatspitext.c
+++ b/gtk/a11y/gtkatspitext.c
@@ -32,6 +32,7 @@
 #include "gtkatcontextprivate.h"
 #include "gtkdebug.h"
 #include "gtkeditable.h"
+#include "gtkinscriptionprivate.h"
 #include "gtklabelprivate.h"
 #include "gtkentryprivate.h"
 #include "gtksearchentryprivate.h"
@@ -406,6 +407,274 @@ static const GDBusInterfaceVTable label_vtable = {
   NULL,
 };
 
+/* }}} */
+/* {{{ GtkInscription */
+
+static void
+inscription_handle_method (GDBusConnection       *connection,
+                           const gchar           *sender,
+                           const gchar           *object_path,
+                           const gchar           *interface_name,
+                           const gchar           *method_name,
+                           GVariant              *parameters,
+                           GDBusMethodInvocation *invocation,
+                           gpointer               user_data)
+{
+  GtkATContext *self = user_data;
+  GtkAccessible *accessible = gtk_at_context_get_accessible (self);
+  GtkWidget *widget = GTK_WIDGET (accessible);
+
+  if (g_strcmp0 (method_name, "GetCaretOffset") == 0)
+    {
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(i)", 0));
+    }
+  else if (g_strcmp0 (method_name, "SetCaretOffset") == 0)
+    {
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(b)", FALSE));
+    }
+  else if (g_strcmp0 (method_name, "GetText") == 0)
+    {
+      int start, end;
+      const char *text;
+      int len;
+      char *string;
+
+      g_variant_get (parameters, "(ii)", &start, &end);
+
+      text = gtk_inscription_get_text (GTK_INSCRIPTION (widget));
+      len = g_utf8_strlen (text, -1);
+
+      start = CLAMP (start, 0, len);
+      end = CLAMP (end, 0, len);
+
+      if (end <= start)
+        string = g_strdup ("");
+      else
+        {
+          const char *p, *q;
+          p = g_utf8_offset_to_pointer (text, start);
+          q = g_utf8_offset_to_pointer (text, end);
+          string = g_strndup (p, q - p);
+        }
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", string));
+      g_free (string);
+    }
+  else if (g_strcmp0 (method_name, "GetTextBeforeOffset") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      int offset;
+      AtspiTextBoundaryType boundary_type;
+      char *string;
+      int start, end;
+
+      g_variant_get (parameters, "(iu)", &offset, &boundary_type);
+
+      string = gtk_pango_get_text_before (layout, offset, boundary_type, &start, &end);
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(sii)", string, start, end));
+      g_free (string);
+    }
+  else if (g_strcmp0 (method_name, "GetTextAtOffset") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      int offset;
+      AtspiTextBoundaryType boundary_type;
+      char *string;
+      int start, end;
+
+      g_variant_get (parameters, "(iu)", &offset, &boundary_type);
+
+      string = gtk_pango_get_text_at (layout, offset, boundary_type, &start, &end);
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(sii)", string, start, end));
+      g_free (string);
+    }
+  else if (g_strcmp0 (method_name, "GetTextAfterOffset") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      int offset;
+      AtspiTextBoundaryType boundary_type;
+      char *string;
+      int start, end;
+
+      g_variant_get (parameters, "(iu)", &offset, &boundary_type);
+
+      string = gtk_pango_get_text_after (layout, offset, boundary_type, &start, &end);
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(sii)", string, start, end));
+      g_free (string);
+    }
+  else if (g_strcmp0 (method_name, "GetCharacterAtOffset") == 0)
+    {
+      int offset;
+      const char *text;
+      gunichar ch = 0;
+
+      g_variant_get (parameters, "(i)", &offset);
+
+      text = gtk_inscription_get_text (GTK_INSCRIPTION (widget));
+
+      if (0 <= offset && offset < g_utf8_strlen (text, -1))
+        ch = g_utf8_get_char (g_utf8_offset_to_pointer (text, offset));
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(i)", ch));
+    }
+  else if (g_strcmp0 (method_name, "GetStringAtOffset") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      int offset;
+      AtspiTextGranularity granularity;
+      char *string;
+      int start, end;
+
+      g_variant_get (parameters, "(iu)", &offset, &granularity);
+
+      string = gtk_pango_get_string_at (layout, offset, granularity, &start, &end);
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(sii)", string, start, end));
+      g_free (string);
+    }
+  else if (g_strcmp0 (method_name, "GetAttributes") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("a{ss}"));
+      int offset;
+      int start, end;
+
+      g_variant_get (parameters, "(i)", &offset);
+
+      gtk_pango_get_run_attributes (layout, &builder, offset, &start, &end);
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(a{ss}ii)", &builder, start, end));
+    }
+  else if (g_strcmp0 (method_name, "GetAttributeValue") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("a{ss}"));
+      int offset;
+      const char *name;
+      int start, end;
+      GVariant *attrs;
+      const char *val;
+
+      g_variant_get (parameters, "(i&s)", &offset, &name);
+
+      gtk_pango_get_run_attributes (layout, &builder, offset, &start, &end);
+
+      attrs = g_variant_builder_end (&builder);
+      if (!g_variant_lookup (attrs, name, "&s", &val))
+        val = "";
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", val));
+      g_variant_unref (attrs);
+    }
+  else if (g_strcmp0 (method_name, "GetAttributeRun") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("a{ss}"));
+      int offset;
+      gboolean include_defaults;
+      int start, end;
+
+      g_variant_get (parameters, "(ib)", &offset, &include_defaults);
+
+      if (include_defaults)
+        gtk_pango_get_default_attributes (layout, &builder);
+
+      gtk_pango_get_run_attributes (layout, &builder, offset, &start, &end);
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(a{ss}ii)", &builder, start, end));
+    }
+  else if (g_strcmp0 (method_name, "GetDefaultAttributes") == 0 ||
+           g_strcmp0 (method_name, "GetDefaultAttributeSet") == 0)
+    {
+      PangoLayout *layout = gtk_inscription_get_layout (GTK_INSCRIPTION (widget));;
+      GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("a{ss}"));
+
+      gtk_pango_get_default_attributes (layout, &builder);
+
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(a{ss})", &builder));
+    }
+  else if (g_strcmp0 (method_name, "GetNSelections") == 0)
+    {
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(i)", 0));
+    }
+  else if (g_strcmp0 (method_name, "GetSelection") == 0)
+    {
+      g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No selections available");
+    }
+  else if (g_strcmp0 (method_name, "AddSelection") == 0)
+    {
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(b)", FALSE));
+    }
+  else if (g_strcmp0 (method_name, "RemoveSelection") == 0)
+    {
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(b)", FALSE));
+    }
+  else if (g_strcmp0 (method_name, "SetSelection") == 0)
+    {
+      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(b)", FALSE));
+    }
+  else if (g_strcmp0 (method_name, "GetCharacterExtents") == 0)
+    {
+      g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "");
+    }
+  else if (g_strcmp0 (method_name, "GetRangeExtents") == 0)
+    {
+      g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "");
+    }
+  else if (g_strcmp0 (method_name, "GetBoundedRanges") == 0)
+    {
+      g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "");
+    }
+  else if (g_strcmp0 (method_name, "ScrollSubstringTo") == 0)
+    {
+      g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "");
+    }
+  else if (g_strcmp0 (method_name, "ScrollSubstringToPoint") == 0)
+    {
+      g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "");
+    }
+}
+
+static GVariant *
+inscription_get_property (GDBusConnection  *connection,
+                          const gchar      *sender,
+                          const gchar      *object_path,
+                          const gchar      *interface_name,
+                          const gchar      *property_name,
+                          GError          **error,
+                          gpointer          user_data)
+{
+  GtkATContext *self = user_data;
+  GtkAccessible *accessible = gtk_at_context_get_accessible (self);
+  GtkWidget *widget = GTK_WIDGET (accessible);
+
+  if (g_strcmp0 (property_name, "CharacterCount") == 0)
+    {
+      const char *text;
+      int len;
+
+      text = gtk_inscription_get_text (GTK_INSCRIPTION (widget));
+      len = g_utf8_strlen (text, -1);
+
+      return g_variant_new_int32 (len);
+    }
+  else if (g_strcmp0 (property_name, "CaretOffset") == 0)
+    {
+      return g_variant_new_int32 (0);
+    }
+
+  return NULL;
+}
+
+static const GDBusInterfaceVTable inscription_vtable = {
+  inscription_handle_method,
+  inscription_get_property,
+  NULL,
+};
+
 /* }}} */
 /* {{{ GtkEditable */
 
@@ -1301,6 +1570,8 @@ gtk_atspi_get_text_vtable (GtkAccessible *accessible)
 {
   if (GTK_IS_LABEL (accessible))
     return &label_vtable;
+  else if (GTK_IS_INSCRIPTION (accessible))
+    return &inscription_vtable;
   else if (GTK_IS_EDITABLE (accessible) &&
            GTK_IS_TEXT (gtk_editable_get_delegate (GTK_EDITABLE (accessible))))
     return &editable_vtable;
diff --git a/gtk/gtkinscription.c b/gtk/gtkinscription.c
index 522d943933..ffe7ffd09c 100644
--- a/gtk/gtkinscription.c
+++ b/gtk/gtkinscription.c
@@ -19,7 +19,7 @@
 
 #include "config.h"
 
-#include "gtkinscription.h"
+#include "gtkinscriptionprivate.h"
 
 #include "gtkcssnodeprivate.h"
 #include "gtkcssstylechangeprivate.h"
@@ -653,6 +653,8 @@ gtk_inscription_class_init (GtkInscriptionClass *klass)
                           G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
 
   g_object_class_install_properties (gobject_class, N_PROPS, properties);
+
+  gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_LABEL);
 }
 
 static void
@@ -669,6 +671,13 @@ gtk_inscription_init (GtkInscription *self)
   pango_layout_set_wrap (self->layout, PANGO_WRAP_WORD_CHAR);
 }
 
+/* for a11y */
+PangoLayout *
+gtk_inscription_get_layout (GtkInscription *self)
+{
+  return self->layout;
+}
+
 /**
  * gtk_inscription_new:
  * @text: (nullable): The text to display.
diff --git a/gtk/gtkinscriptionprivate.h b/gtk/gtkinscriptionprivate.h
new file mode 100644
index 0000000000..97de354e27
--- /dev/null
+++ b/gtk/gtkinscriptionprivate.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright © 2022 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#ifndef __GTK_INSCRIPTION_PRIVATE_H__
+#define __GTK_INSCRIPTION_PRIVATE_H__
+
+
+#include <gtk/gtkinscription.h>
+
+
+G_BEGIN_DECLS
+
+PangoLayout *           gtk_inscription_get_layout              (GtkInscription *self);
+
+G_END_DECLS
+
+#endif /* __GTK_INSCRIPTION_PRIVATE_H__ */

From 7c034cc28371d58f76627065304b55458bbf3316 Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Thu, 9 Jun 2022 07:16:13 +0200
Subject: [PATCH 13/15] inscription: Set css name

We use "label" just like GtkLabel as the two widgets differ in the way
they are measured, but they should be styled the same.

If it turns out we change our opinion on this for specific cases, we
can add style classes later.
---
 gtk/gtkinscription.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/gtk/gtkinscription.c b/gtk/gtkinscription.c
index ffe7ffd09c..e043e3a0e4 100644
--- a/gtk/gtkinscription.c
+++ b/gtk/gtkinscription.c
@@ -654,6 +654,7 @@ gtk_inscription_class_init (GtkInscriptionClass *klass)
 
   g_object_class_install_properties (gobject_class, N_PROPS, properties);
 
+  gtk_widget_class_set_css_name (widget_class, "label");
   gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_LABEL);
 }
 

From bf5edc6b7c9164b86f3d889f68eb966003fc4bbc Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Fri, 10 Jun 2022 01:09:49 +0200
Subject: [PATCH 14/15] reftests: Add test for the overflow methods

Reference is using labels again
---
 gtk/gtkinscription.c                          |  8 ++--
 .../reftests/inscription-overflow.ref.ui      | 41 +++++++++++++++++++
 testsuite/reftests/inscription-overflow.ui    | 35 ++++++++++++++++
 testsuite/reftests/meson.build                |  2 +
 4 files changed, 82 insertions(+), 4 deletions(-)
 create mode 100644 testsuite/reftests/inscription-overflow.ref.ui
 create mode 100644 testsuite/reftests/inscription-overflow.ui

diff --git a/gtk/gtkinscription.c b/gtk/gtkinscription.c
index e043e3a0e4..155f334ad8 100644
--- a/gtk/gtkinscription.c
+++ b/gtk/gtkinscription.c
@@ -367,8 +367,8 @@ gtk_inscription_measure (GtkWidget      *widget,
 
 static void
 gtk_inscription_get_layout_location (GtkInscription *self,
-                                     int            *x_out,
-                                     int            *y_out)
+                                     float          *x_out,
+                                     float          *y_out)
 {
   GtkWidget *widget = GTK_WIDGET (self);
   const int widget_width = gtk_widget_get_width (widget);
@@ -376,7 +376,7 @@ gtk_inscription_get_layout_location (GtkInscription *self,
   PangoRectangle logical;
   float xalign;
   int baseline;
-  int x, y;
+  float x, y;
 
   g_assert (x_out);
   g_assert (y_out);
@@ -451,7 +451,7 @@ gtk_inscription_snapshot (GtkWidget   *widget,
 {
   GtkInscription *self = GTK_INSCRIPTION (widget);
   GtkStyleContext *context;
-  int lx, ly;
+  float lx, ly;
 
   if (!self->text || (*self->text == '\0'))
     return;
diff --git a/testsuite/reftests/inscription-overflow.ref.ui b/testsuite/reftests/inscription-overflow.ref.ui
new file mode 100644
index 0000000000..e9b131b1d5
--- /dev/null
+++ b/testsuite/reftests/inscription-overflow.ref.ui
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow">
+    <property name="default-width">200</property>
+    <child>
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkOverlay">
+            <child>
+              <object class="GtkLabel" />
+            </child>
+            <child type="overlay">
+              <object class="GtkLabel">
+                <property name="label" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+            <property name="ellipsize">start</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+            <property name="ellipsize">middle</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+            <property name="ellipsize">end</property>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>
diff --git a/testsuite/reftests/inscription-overflow.ui b/testsuite/reftests/inscription-overflow.ui
new file mode 100644
index 0000000000..4884893ee8
--- /dev/null
+++ b/testsuite/reftests/inscription-overflow.ui
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow">
+    <property name="default-width">200</property>
+    <child>
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkInscription">
+            <property name="text" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+            <property name="text-overflow">clip</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkInscription">
+            <property name="text" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+            <property name="text-overflow">ellipsize-start</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkInscription">
+            <property name="text" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+            <property name="text-overflow">ellipsize-middle</property>
+          </object>
+        </child>
+        <child>
+          <object class="GtkInscription">
+            <property name="text" translatable="yes">Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.</property>
+            <property name="text-overflow">ellipsize-end</property>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>
diff --git a/testsuite/reftests/meson.build b/testsuite/reftests/meson.build
index 3001d0e127..7c03cb7062 100644
--- a/testsuite/reftests/meson.build
+++ b/testsuite/reftests/meson.build
@@ -369,6 +369,8 @@ testdata = [
   'image-load-from-file.ui',
   'inscription-markup.ref.ui',
   'inscription-markup.ui',
+  'inscription-overflow.ref.ui',
+  'inscription-overflow.ui',
   'label-attribute-preference.css',
   'label-attribute-preference.ref.ui',
   'label-attribute-preference.ui',

From 303bc3bb1bd8a78da82cfed864e851fdede3429b Mon Sep 17 00:00:00 2001
From: Benjamin Otte <otte@redhat.com>
Date: Fri, 10 Jun 2022 04:02:30 +0200
Subject: [PATCH 15/15] inspector: Use inscriptions for the rendernodes list

---
 gtk/inspector/recorder.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/gtk/inspector/recorder.c b/gtk/inspector/recorder.c
index 43409cb81f..05078eb71b 100644
--- a/gtk/inspector/recorder.c
+++ b/gtk/inspector/recorder.c
@@ -24,7 +24,7 @@
 #include <gtk/gtkdragsource.h>
 #include <gtk/gtkeventcontroller.h>
 #include <gtk/gtkfilechooserdialog.h>
-#include <gtk/gtksignallistitemfactory.h>
+#include <gtk/gtkinscription.h>
 #include <gtk/gtklabel.h>
 #include <gtk/gtklistbox.h>
 #include <gtk/gtklistitem.h>
@@ -33,6 +33,7 @@
 #include <gtk/gtkmessagedialog.h>
 #include <gtk/gtkpicture.h>
 #include <gtk/gtkpopover.h>
+#include <gtk/gtksignallistitemfactory.h>
 #include <gtk/gtksingleselection.h>
 #include <gtk/gtktogglebutton.h>
 #include <gtk/gtktreeexpander.h>
@@ -401,7 +402,8 @@ setup_widget_for_render_node (GtkSignalListItemFactory *factory,
   gtk_box_append (GTK_BOX (box), child);
 
   /* name */
-  child = gtk_label_new (NULL);
+  child = gtk_inscription_new (NULL);
+  gtk_widget_set_hexpand (child, TRUE);
   gtk_box_append (GTK_BOX (box), child);
 }
 
@@ -431,7 +433,7 @@ bind_widget_for_render_node (GtkSignalListItemFactory *factory,
   /* name */
   name = node_name (node);
   child = gtk_widget_get_last_child (box);
-  gtk_label_set_label (GTK_LABEL (child), name);
+  gtk_inscription_set_text (GTK_INSCRIPTION (child), name);
   g_free (name);
 
   g_object_unref (paintable);