Add search support

Add a filter to GtkListBase, and move the selection
to the first matching item whenever the filter changes.
This is meant to be used with single selection and
a string filter that is hooked up to a search entry.

.gitlab-ci.yml

@@ -184,7 +184,7 @@ static-scan:
   allow_failure: true
 
 reference:
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora-docs:v19
   stage: docs
   variables:
     EXTRA_MESON_FLAGS: "--buildtype=release"

.gitlab-ci/fedora-base.Dockerfile

@@ -0,0 +1,88 @@
+FROM fedora:31
+
+RUN dnf -y install \
+    adwaita-icon-theme \
+    atk-devel \
+    at-spi2-atk-devel \
+    avahi-gobject-devel \
+    cairo-devel \
+    cairo-gobject-devel \
+    ccache \
+    clang \
+    clang-analyzer \
+    colord-devel \
+    cups-devel \
+    dbus-daemon \
+    dbus-x11 \
+    dejavu-sans-mono-fonts \
+    desktop-file-utils \
+    diffutils \
+    elfutils-libelf-devel \
+    fribidi-devel \
+    gcc \
+    gcc-c++ \
+    gdk-pixbuf2-devel \
+    gdk-pixbuf2-modules \
+    gettext \
+    git \
+    glib2-devel \
+    glib2-static \
+    glibc-devel \
+    glibc-headers \
+    gobject-introspection-devel \
+    graphene-devel \
+    gstreamer1-devel \
+    gstreamer1-plugins-good \
+    gstreamer1-plugins-bad-free-devel \
+    gstreamer1-plugins-base-devel \
+    gtk-doc \
+    hicolor-icon-theme \
+    iso-codes \
+    itstool \
+    json-glib-devel \
+    lcov \
+    libattr-devel \
+    libepoxy-devel \
+    libffi-devel \
+    libmount-devel \
+    librsvg2 \
+    libselinux-devel \
+    libXcomposite-devel \
+    libXcursor-devel \
+    libXcursor-devel \
+    libXdamage-devel \
+    libXfixes-devel \
+    libXi-devel \
+    libXinerama-devel \
+    libxkbcommon-devel \
+    libXrandr-devel \
+    libXrender-devel \
+    libXtst-devel \
+    libxslt \
+    mesa-dri-drivers \
+    mesa-libEGL-devel \
+    mesa-libwayland-egl-devel \
+    ninja-build \
+    pango-devel \
+    pcre-devel \
+    pcre-static \
+    python3 \
+    python3-jinja2 \
+    python3-pip \
+    python3-pygments \
+    python3-wheel \
+    redhat-rpm-config \
+    sassc \
+    sysprof-devel \
+    systemtap-sdt-devel \
+    vulkan-devel \
+    wayland-devel \
+    wayland-protocols-devel \
+    weston \
+    weston-libs \
+    which \
+    xorg-x11-server-Xvfb \
+ && dnf clean all
+
+RUN pip3 install meson==0.53.1
+

.gitlab-ci/fedora-docs.Dockerfile

@@ -0,0 +1,12 @@
+FROM registry.gitlab.gnome.org/gnome/gtk/fedora-base:v19
+
+RUN dnf -y install pandoc
+
+ARG HOST_USER_ID=5555
+ENV HOST_USER_ID ${HOST_USER_ID}
+RUN useradd -u $HOST_USER_ID -ms /bin/bash user
+
+USER user
+WORKDIR /home/user
+
+ENV LANG C.UTF-8

.gitlab-ci/fedora.Dockerfile

@@ -1,90 +1,4 @@
-FROM fedora:31
-
-RUN dnf -y install \
-    adwaita-icon-theme \
-    atk-devel \
-    at-spi2-atk-devel \
-    avahi-gobject-devel \
-    cairo-devel \
-    cairo-gobject-devel \
-    ccache \
-    clang \
-    clang-analyzer \
-    colord-devel \
-    cups-devel \
-    dbus-daemon \
-    dbus-x11 \
-    dejavu-sans-mono-fonts \
-    desktop-file-utils \
-    diffutils \
-    elfutils-libelf-devel \
-    fribidi-devel \
-    gcc \
-    gcc-c++ \
-    gdk-pixbuf2-devel \
-    gdk-pixbuf2-modules \
-    gettext \
-    git \
-    glib2-devel \
-    glib2-static \
-    glibc-devel \
-    glibc-headers \
-    gobject-introspection-devel \
-    graphene-devel \
-    gstreamer1-devel \
-    gstreamer1-plugins-good \
-    gstreamer1-plugins-bad-free-devel \
-    gstreamer1-plugins-base-devel \
-    gtk-doc \
-    hicolor-icon-theme \
-    iso-codes \
-    itstool \
-    json-glib-devel \
-    lcov \
-    libattr-devel \
-    libepoxy-devel \
-    libffi-devel \
-    libmount-devel \
-    librsvg2 \
-    libselinux-devel \
-    libXcomposite-devel \
-    libXcursor-devel \
-    libXcursor-devel \
-    libXdamage-devel \
-    libXfixes-devel \
-    libXi-devel \
-    libXinerama-devel \
-    libxkbcommon-devel \
-    libXrandr-devel \
-    libXrender-devel \
-    libXtst-devel \
-    libxslt \
-    mesa-dri-drivers \
-    mesa-libEGL-devel \
-    mesa-libwayland-egl-devel \
-    ninja-build \
-    pango-devel \
-    pcre-devel \
-    pcre-static \
-    python3 \
-    python3-jinja2 \
-    python3-pip \
-    python3-pygments \
-    python3-wheel \
-    redhat-rpm-config \
-    sassc \
-    sysprof-devel \
-    systemtap-sdt-devel \
-    vulkan-devel \
-    wayland-devel \
-    wayland-protocols-devel \
-    weston \
-    weston-libs \
-    which \
-    xorg-x11-server-Xvfb \
- && dnf clean all
-
-RUN pip3 install meson==0.53.1
+FROM registry.gitlab.gnome.org/gnome/gtk/fedora-base:v19
 
 ARG HOST_USER_ID=5555
 ENV HOST_USER_ID ${HOST_USER_ID}

.gitlab-ci/run-tests.sh

@@ -25,7 +25,7 @@ case "${backend}" in
   wayland)
     export XDG_RUNTIME_DIR="$(mktemp -p $(pwd) -d xdg-runtime-XXXXXX)"
 
-    weston --backend=headless-backend.so --socket=wayland-5 &
+    weston --backend=headless-backend.so --socket=wayland-5 --idle-time=0 &
     compositor=$!
     export WAYLAND_DISPLAY=wayland-5
 

.gitlab-ci/test-msys2.sh

@@ -34,8 +34,8 @@ pacman --noconfirm -S --needed \
     mingw-w64-$MSYS2_ARCH-shared-mime-info
 
 # https://gitlab.gnome.org/GNOME/gtk/issues/2243
-wget "https://gitlab.gnome.org/creiter/gitlab-ci-win32-runner-v2/raw/master/pango/mingw-w64-$MSYS2_ARCH-pango-1.44.7-1-any.pkg.tar.xz"
-pacman --noconfirm -U "mingw-w64-$MSYS2_ARCH-pango-1.44.7-1-any.pkg.tar.xz"
+wget "https://gitlab.gnome.org/creiter/gitlab-ci-win32-runner-v2/raw/master/pango/mingw-w64-$MSYS2_ARCH-pango-git-1.44.7.90.ge48ae523-1-any.pkg.tar.zst"
+pacman --noconfirm -U "mingw-w64-$MSYS2_ARCH-pango-git-1.44.7.90.ge48ae523-1-any.pkg.tar.zst"
 
 # https://github.com/msys2/MINGW-packages/pull/6465
 pacman --noconfirm -S --needed mingw-w64-$MSYS2_ARCH-brotli

config.h.meson

@@ -35,6 +35,10 @@
    */
 #mesondefine HAVE_DECL_ISNAN
 
+/* Define to 1 if you have the declaration of `isnanf', and to 0 if you don't.
+   */
+#mesondefine HAVE_DECL_ISNANF
+
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #mesondefine HAVE_DLFCN_H
 
@@ -292,3 +296,6 @@
 #mesondefine HAVE_PANGOFT
 
 #mesondefine ISO_CODES_PREFIX
+
+/* Define if tracker3 is available */
+#mesondefine HAVE_TRACKER3

demos/constraint-editor/constraint-editor-window.c

@@ -487,8 +487,6 @@ constraint_editor_window_class_init (ConstraintEditorWindowClass *class)
   GObjectClass *object_class = G_OBJECT_CLASS (class);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 
-  g_type_ensure (CONSTRAINT_VIEW_TYPE);
-
   object_class->finalize = constraint_editor_window_finalize;
 
   gtk_widget_class_set_template_from_resource (widget_class,

demos/constraint-editor/constraint-view.c

@@ -169,6 +169,7 @@ constraint_view_init (ConstraintView *self)
   GListModel *guides;
   GListModel *children;
   GListModel *constraints;
+  GtkFilter *filter;
 
   manager = gtk_constraint_layout_new ();
   gtk_widget_set_layout_manager (GTK_WIDGET (self), manager);
@@ -176,8 +177,12 @@ constraint_view_init (ConstraintView *self)
   all_children = gtk_widget_observe_children (GTK_WIDGET (self));
   all_constraints = gtk_constraint_layout_observe_constraints (GTK_CONSTRAINT_LAYOUT (manager));
   guides = gtk_constraint_layout_observe_guides (GTK_CONSTRAINT_LAYOUT (manager));
-  constraints = (GListModel *)gtk_filter_list_model_new (all_constraints, omit_internal, NULL, NULL);
-  children = (GListModel *)gtk_filter_list_model_new (all_children, omit_internal, NULL, NULL);
+  filter = gtk_custom_filter_new (omit_internal, NULL, NULL);
+  constraints = (GListModel *)gtk_filter_list_model_new (all_constraints, filter);
+  g_object_unref (filter);
+  filter = gtk_custom_filter_new (omit_internal, NULL, NULL);
+  children = (GListModel *)gtk_filter_list_model_new (all_children, filter);
+  g_object_unref (filter);
 
   list = g_list_store_new (G_TYPE_LIST_MODEL);
   g_list_store_append (list, children);

demos/constraint-editor/constraint-view.h

@@ -23,6 +23,7 @@
 
 #define CONSTRAINT_VIEW_TYPE (constraint_view_get_type ())
 
+G_MODULE_EXPORT
 G_DECLARE_FINAL_TYPE (ConstraintView, constraint_view, CONSTRAINT, VIEW, GtkWidget)
 
 ConstraintView * constraint_view_new (void);

demos/constraint-editor/guide-editor.c

@@ -184,58 +184,6 @@ max_input (GtkSpinButton *spin_button,
   return FALSE;
 }
 
-static gboolean
-min_output (GtkSpinButton *spin_button)
-{
-  GtkAdjustment *adjustment;
-  double value;
-  GtkWidget *box, *text;
-
-  adjustment = gtk_spin_button_get_adjustment (spin_button);
-  value = gtk_adjustment_get_value (adjustment);
-
-  box = gtk_widget_get_first_child (GTK_WIDGET (spin_button));
-  text = gtk_widget_get_first_child (box);
-
-  if (value == 0.0)
-    {
-      gtk_editable_set_text (GTK_EDITABLE (spin_button), "");
-      gtk_text_set_placeholder_text (GTK_TEXT (text), "unset");
-      return TRUE;
-    }
-  else
-    {
-      gtk_text_set_placeholder_text (GTK_TEXT (text), "");
-      return FALSE;
-    }
-}
-
-static gboolean
-max_output (GtkSpinButton *spin_button)
-{
-  GtkAdjustment *adjustment;
-  double value;
-  GtkWidget *box, *text;
-
-  adjustment = gtk_spin_button_get_adjustment (spin_button);
-  value = gtk_adjustment_get_value (adjustment);
-
-  box = gtk_widget_get_first_child (GTK_WIDGET (spin_button));
-  text = gtk_widget_get_first_child (box);
-
-  if (value == (double)G_MAXINT)
-    {
-      gtk_editable_set_text (GTK_EDITABLE (spin_button), "");
-      gtk_text_set_placeholder_text (GTK_TEXT (text), "unset");
-      return TRUE;
-    }
-  else
-    {
-      gtk_text_set_placeholder_text (GTK_TEXT (text), "");
-      return FALSE;
-    }
-}
-
 static void
 guide_editor_constructed (GObject *object)
 {
@@ -244,16 +192,12 @@ guide_editor_constructed (GObject *object)
   guide_strength_combo (editor->strength);
 
   g_signal_connect (editor->min_width, "input", G_CALLBACK (min_input), NULL);
-  g_signal_connect (editor->min_width, "output", G_CALLBACK (min_output), NULL);
 
   g_signal_connect (editor->min_height, "input", G_CALLBACK (min_input), NULL);
-  g_signal_connect (editor->min_height, "output", G_CALLBACK (min_output), NULL);
 
   g_signal_connect (editor->max_width, "input", G_CALLBACK (max_input), NULL);
-  g_signal_connect (editor->max_width, "output", G_CALLBACK (max_output), NULL);
 
   g_signal_connect (editor->max_height, "input", G_CALLBACK (max_input), NULL);
-  g_signal_connect (editor->max_height, "output", G_CALLBACK (max_output), NULL);
 
   if (editor->guide)
     {

demos/gtk-demo/application.c

@@ -328,19 +328,14 @@ static void
 startup (GApplication *app)
 {
   GtkBuilder *builder;
-  GMenuModel *appmenu;
-  GMenuModel *menubar;
 
   G_APPLICATION_CLASS (demo_application_parent_class)->startup (app);
 
   builder = gtk_builder_new ();
   gtk_builder_add_from_resource (builder, "/application_demo/menus.ui", NULL);
 
-  appmenu = (GMenuModel *)gtk_builder_get_object (builder, "appmenu");
-  menubar = (GMenuModel *)gtk_builder_get_object (builder, "menubar");
-
-  gtk_application_set_app_menu (GTK_APPLICATION (app), appmenu);
-  gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
+  gtk_application_set_menubar (GTK_APPLICATION (app),
+                               G_MENU_MODEL (gtk_builder_get_object (builder, "menubar")));
 
   g_object_unref (builder);
 }
@@ -353,6 +348,7 @@ create_window (GApplication *app,
 
   window = (DemoApplicationWindow *)g_object_new (demo_application_window_get_type (),
                                                   "application", app,
+                                                  "show-menubar", TRUE,
                                                   NULL);
   if (content)
     gtk_text_buffer_set_text (window->buffer, content, -1);

demos/gtk-demo/appmenu.ui

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<interface>
-  <menu id="appmenu">
-    <section>
-      <item>
-        <attribute name="label" translatable="yes">About</attribute>
-        <attribute name="action">app.about</attribute>
-      </item>
-    </section>
-    <section>
-      <item>
-        <attribute name="label" translatable="yes">_Quit</attribute>
-        <attribute name="action">app.quit</attribute>
-        <attribute name="accel">&lt;Control&gt;q</attribute>
-      </item>
-    </section>
-  </menu>
-</interface>

demos/gtk-demo/award.c

@@ -0,0 +1,247 @@
+/*
+ * Copyright © 2018 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 "award.h"
+
+struct _GtkAward
+{
+  GObject parent;
+
+  char *explanation;
+  char *name;
+  char *title;
+  GDateTime *granted; /* or NULL if not granted */
+};
+
+enum {
+  PROP_0,
+  PROP_EXPLANATION,
+  PROP_NAME,
+  PROP_TITLE,
+  PROP_GRANTED,
+
+  N_PROPS,
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+G_DEFINE_TYPE (GtkAward, gtk_award, G_TYPE_OBJECT)
+
+static void
+gtk_award_set_property (GObject      *object,
+                        guint         prop_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+
+{
+  GtkAward *self = GTK_AWARD (object);
+
+  switch (prop_id)
+    {
+    case PROP_EXPLANATION:
+      self->explanation = g_value_dup_string (value);
+      break;
+
+    case PROP_NAME:
+      self->name = g_value_dup_string (value);
+      break;
+
+    case PROP_TITLE:
+      self->title = g_value_dup_string (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_award_get_property (GObject    *object,
+                        guint       prop_id,
+                        GValue     *value,
+                        GParamSpec *pspec)
+{
+  GtkAward *self = GTK_AWARD (object);
+
+  switch (prop_id)
+    {
+    case PROP_EXPLANATION:
+      g_value_set_string (value, self->explanation);
+      break;
+
+    case PROP_NAME:
+      g_value_set_string (value, self->name);
+      break;
+
+    case PROP_TITLE:
+      g_value_set_string (value, self->title);
+      break;
+
+    case PROP_GRANTED:
+      g_value_set_boxed (value, self->granted);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_award_dispose (GObject *object)
+{
+  GtkAward *self = GTK_AWARD (object);
+
+  g_clear_pointer (&self->name, g_free);
+  g_clear_pointer (&self->title, g_free);
+  g_clear_pointer (&self->granted, g_date_time_unref);
+
+  G_OBJECT_CLASS (gtk_award_parent_class)->dispose (object);
+}
+
+static void
+gtk_award_class_init (GtkAwardClass *class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+  gobject_class->set_property = gtk_award_set_property;
+  gobject_class->get_property = gtk_award_get_property;
+  gobject_class->dispose = gtk_award_dispose;
+
+  properties[PROP_EXPLANATION] =
+    g_param_spec_string ("explanation",
+                         "Explanation",
+                         "How to get the title",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_NAME] =
+    g_param_spec_string ("name",
+                         "Name",
+                         "internal name of the award",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_TITLE] =
+    g_param_spec_string ("title",
+                         "Title",
+                         "user-visible title",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_GRANTED] =
+    g_param_spec_boxed ("granted",
+                        "Granted",
+                        "Timestamp the award was granted or NULL if not granted yet",
+                        G_TYPE_DATE_TIME,
+                        G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gtk_award_init (GtkAward *self)
+{
+}
+
+GListModel *
+gtk_award_get_list (void)
+{
+  static GListModel *list = NULL;
+
+  if (list == NULL)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (GTK_TYPE_AWARD);
+      builder = gtk_builder_new_from_resource ("/awards.ui");
+      list = G_LIST_MODEL (gtk_builder_get_object (builder, "list"));
+      g_object_ref (list);
+      g_object_unref (builder);
+    }
+
+  return g_object_ref (list);
+}
+
+const char *
+gtk_award_get_name (GtkAward *award)
+{
+  return award->name;
+}
+
+const char *
+gtk_award_get_title (GtkAward *award)
+{
+  return award->title;
+}
+
+GDateTime *
+gtk_award_get_granted (GtkAward *award)
+{
+  return award->granted;
+}
+
+GtkAward *
+award_find (const char *name)
+{
+  GListModel *list;
+  GtkAward *self;
+  guint i;
+
+  list = gtk_award_get_list ();
+  g_object_unref (list);
+
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      self = g_list_model_get_item (list, i);
+      g_object_unref (self);
+
+      if (g_ascii_strcasecmp (name, self->name) == 0)
+        return self;
+    }
+
+  return NULL;
+}
+
+void
+award (const char *name)
+{
+  GtkAward *self;
+  GNotification *notification;
+
+  self = award_find (name);
+  if (self == NULL)
+    {
+      g_warning ("Did not find award \"%s\"", name);
+      return;
+    }
+
+  if (self->granted)
+    return;
+
+  self->granted = g_date_time_new_now_utc ();
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_GRANTED]);
+
+  notification = g_notification_new ("You won an award!");
+  g_notification_set_body (notification, self->title);
+  g_application_send_notification (g_application_get_default (), NULL, notification);
+  g_object_unref (notification);
+}
+

demos/gtk-demo/award.h

@@ -0,0 +1,18 @@
+#ifndef __AWARD_H__
+#define __AWARD_H__
+
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_AWARD (gtk_award_get_type ())
+
+G_DECLARE_FINAL_TYPE (GtkAward, gtk_award, GTK, AWARD, GObject)
+
+GListModel *    gtk_award_get_list                      (void);
+
+const char *    gtk_award_get_name                      (GtkAward               *award);
+const char *    gtk_award_get_title                     (GtkAward               *award);
+GDateTime *     gtk_award_get_granted                   (GtkAward               *award);
+
+void            award                                   (const char             *name);
+
+#endif /* __AWARD_H__ */

demos/gtk-demo/awardlistitem.ui

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface domain="gtk40">
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkLabel">
+        <property name="label" bind-source="GtkListItem" bind-property="position"></property>
+        <property name="margin">6</property>
+      </object>
+    </property>
+  </template>
+</interface>

demos/gtk-demo/awards.ui

@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GListStore" id="list">
+    <property name="item-type">GtkAward</property>
+    <child>
+      <object class="GtkAward">
+        <property name="name">demo-inspector</property>
+        <!-- Transformers -->
+        <property name="title" translatable="yes">You got a high-rise double-pump carburetor.</property>
+        <property name="explanation" translatable="yes">Launch the inspector</property>
+      </object>
+    </child>
+    <child>
+      <object class="GtkAward">
+        <property name="name">demo-start</property>
+        <!-- The Matrix -->
+        <property name="title" translatable="yes">After this, there is no turning back.</property>
+        <property name="explanation" translatable="yes">Start gtk-demo</property>
+      </object>
+    </child>
+
+    <child>
+      <object class="GtkAward">
+        <property name="name">listbox-reshare</property>
+        <!-- Mean Girls -->
+        <property name="title" translatable="yes">Trying to make fetch happen</property>
+        <property name="explanation" translatable="yes">Reshare a tweet</property>
+      </object>
+    </child>
+    <child>
+      <object class="GtkAward">
+        <property name="name">listbox-100th-row</property>
+        <!-- Aladdin -->
+        <property name="title" translatable="yes">The ever impressive, long contained, often imitated, but never duplicated Genie of the lamp.</property>
+        <property name="explanation" translatable="yes">Select a 100th row in a list</property>
+      </object>
+    </child>
+
+    <child>
+      <object class="GtkAward">
+        <property name="name">password-best</property>
+        <!-- Spaceballs -->
+        <property name="title" translatable="yes">I've got the same combination on my luggage!</property>
+        <property name="explanation" translatable="yes">Use "12345" as the password</property>
+      </object>
+    </child>
+    <child>
+      <object class="GtkAward">
+        <property name="name">password-correct</property>
+        <!-- Stanley Parable -->
+        <property name="title" translatable="yes">Night Shark 1-1-5</property>
+        <property name="explanation" translatable="yes">Correctly enter a password</property>
+      </object>
+    </child>
+
+    <child>
+      <object class="GtkAward">
+        <property name="name">puzzle-give-up</property>
+        <!-- Pretty Woman -->
+        <property name="title" translatable="yes">Big Mistake. Big. Huge!</property>
+        <property name="explanation" translatable="yes">Close the puzzle without finishing it</property>
+      </object>
+    </child>
+    <child>
+      <object class="GtkAward">
+        <property name="name">puzzle-solve</property>
+        <!-- The Incredibles -->
+        <property name="title" translatable="yes">That was totally wicked!</property>
+        <property name="explanation" translatable="yes">Solve a puzzle</property>
+      </object>
+    </child>
+    <child>
+      <object class="GtkAward">
+        <property name="name">puzzle-solve-animated</property>
+        <!-- The Phantom Menace -->
+        <property name="title" translatable="yes">A surprise to be sure but a welcome one.</property>
+        <property name="explanation" translatable="yes">Solve an animated puzzle</property>
+      </object>
+    </child>
+    <child>
+      <object class="GtkAward">
+        <property name="name">puzzle-solve-large</property>
+        <!-- Portal -->
+        <property name="title" translatable="yes">Science isn't about WHY. It's about WHY NOT?!</property>
+        <property name="explanation" translatable="yes">Solve a puzzle with at least 20 pieces</property>
+      </object>
+    </child>
+  </object>
+</interface>

demos/gtk-demo/awardview.c

@@ -0,0 +1,48 @@
+/* Awards
+ *
+ * This demo demonstrates how to use lists to show the awards you have collected
+ * while exploring this demo.
+ *
+ */
+
+#include <gtk/gtk.h>
+
+/* Include the header for accessing the awards */
+#include "award.h"
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_awardview (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkWidget *sw, *listview;
+      GListModel *list;
+
+      window = gtk_window_new ();
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Awards");
+      gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_window_set_child (GTK_WINDOW (window), sw);
+
+      listview = gtk_list_view_new_with_factory (
+          gtk_builder_list_item_factory_new_from_resource (NULL, "/awardview/awardlistitem.ui"));
+      list = gtk_award_get_list ();
+      gtk_list_view_set_model (GTK_LIST_VIEW (listview), list);
+      g_object_unref (list);
+      gtk_list_view_set_show_separators (GTK_LIST_VIEW (listview), TRUE);
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), listview);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/builder.c

@@ -83,7 +83,7 @@ do_builder (GtkWidget *do_widget)
                                        window);
       gtk_widget_insert_action_group (window, "win", actions);
 
-      g_object_set_data_full (G_OBJECT(window), "builder", builder, g_object_unref);
+      g_object_unref (builder);
     }
 
   if (!gtk_widget_get_visible (window))

demos/gtk-demo/css_basics.c

@@ -97,7 +97,7 @@ do_css_basics (GtkWidget *do_widget)
       container = gtk_scrolled_window_new (NULL, NULL);
       gtk_window_set_child (GTK_WINDOW (window), container);
       child = gtk_text_view_new_with_buffer (text);
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (container), child);
       g_signal_connect (text, "changed",
                         G_CALLBACK (css_text_changed), provider);
 

demos/gtk-demo/css_blendmodes.c

@@ -134,6 +134,8 @@ do_css_blendmodes (GtkWidget *do_widget)
                                                   GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
 
       setup_listbox (builder, provider);
+
+      g_object_unref (builder);
     }
 
   if (!gtk_widget_get_visible (window))

demos/gtk-demo/css_multiplebgs.c

@@ -85,7 +85,7 @@ do_css_multiplebgs (GtkWidget *do_widget)
 
   if (!window)
     {
-      GtkWidget *paned, *container, *child;
+      GtkWidget *paned, *overlay, *child, *sw;
       GtkStyleProvider *provider;
       GtkTextBuffer *text;
       GBytes *bytes;
@@ -96,25 +96,25 @@ do_css_multiplebgs (GtkWidget *do_widget)
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
       g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
-      container = gtk_overlay_new ();
-      gtk_window_set_child (GTK_WINDOW (window), container);
+      overlay = gtk_overlay_new ();
+      gtk_window_set_child (GTK_WINDOW (window), overlay);
 
       child = gtk_drawing_area_new ();
       gtk_widget_set_name (child, "canvas");
       gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (child),
                                       drawing_area_draw,
                                       NULL, NULL);
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_overlay_set_child (GTK_OVERLAY (overlay), child);
 
       child = gtk_button_new ();
-      gtk_overlay_add_overlay (GTK_OVERLAY (container), child);
+      gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
       gtk_widget_set_name (child, "bricks-button");
       gtk_widget_set_halign (child, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (child, GTK_ALIGN_CENTER);
       gtk_widget_set_size_request (child, 250, 84);
 
       paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
-      gtk_overlay_add_overlay (GTK_OVERLAY (container), paned);
+      gtk_overlay_add_overlay (GTK_OVERLAY (overlay), paned);
 
       /* Need a filler so we get a handle */
       child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
@@ -132,10 +132,10 @@ do_css_multiplebgs (GtkWidget *do_widget)
 
       provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
 
-      container = gtk_scrolled_window_new (NULL, NULL);
-      gtk_paned_set_end_child (GTK_PANED (paned), container);
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_paned_set_end_child (GTK_PANED (paned), sw);
       child = gtk_text_view_new_with_buffer (text);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (container), child);
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), child);
       g_signal_connect (text,
                         "changed",
                         G_CALLBACK (css_text_changed),

demos/gtk-demo/cursors.c

@@ -29,7 +29,7 @@ do_cursors (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       g_signal_connect (window, "destroy",
                         G_CALLBACK (on_destroy), NULL);
-      g_object_set_data_full (G_OBJECT (window), "builder", builder, g_object_unref);
+      g_object_unref (builder);
     }
 
   if (!gtk_widget_get_visible (window))

demos/gtk-demo/demo.gresource.xml

@@ -1,14 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <gresources>
+  <gresource prefix="/">
+    <file>awards.ui</file>
+  </gresource>
   <gresource prefix="/ui">
     <file preprocess="xml-stripblanks">main.ui</file>
-    <file preprocess="xml-stripblanks">appmenu.ui</file>
+    <file preprocess="xml-stripblanks">main-listitem.ui</file>
   </gresource>
   <gresource prefix="/application_demo">
     <file>application.c</file>
     <file>application.ui</file>
     <file>menus.ui</file>
   </gresource>
+  <gresource prefix="/awardview">
+    <file>awardlistitem.ui</file>
+  </gresource>
   <gresource prefix="/builder">
     <file>demo.ui</file>
   </gresource>
@@ -119,6 +125,22 @@
     <file>gnome-fs-directory.png</file>
     <file>gnome-fs-regular.png</file>
   </gresource>
+  <gresource prefix="/listview_filebrowser">
+    <file>listview_filebrowser.ui</file>
+  </gresource>
+  <gresource prefix="/listview_minesweeper">
+    <file>listview_minesweeper.ui</file>
+    <file>listview_minesweeper_cell.ui</file>
+  </gresource>
+  <gresource prefix="/listview_settings">
+    <file>listview_settings.ui</file>
+  </gresource>
+  <gresource prefix="/listview_weather">
+    <file compressed="true">listview_weather.txt</file>
+  </gresource>
+  <gresource prefix="/listview_colors">
+    <file compressed="true">color.names.txt</file>
+  </gresource>
   <gresource prefix="/shortcuts">
     <file>shortcuts.ui</file>
     <file>shortcuts-builder.ui</file>
@@ -155,6 +177,7 @@
   </gresource>
   <gresource prefix="/sources">
     <file>application_demo.c</file>
+    <file>awardview.c</file>
     <file>assistant.c</file>
     <file>builder.c</file>
     <file>clipboard.c</file>
@@ -195,6 +218,13 @@
     <file>infobar.c</file>
     <file>links.c</file>
     <file>listbox.c</file>
+    <file>listview_applauncher.c</file>
+    <file>listview_colors.c</file>
+    <file>listview_clocks.c</file>
+    <file>listview_filebrowser.c</file>
+    <file>listview_minesweeper.c</file>
+    <file>listview_settings.c</file>
+    <file>listview_weather.c</file>
     <file>list_store.c</file>
     <file>markup.c</file>
     <file>modelbutton.c</file>

demos/gtk-demo/dnd.c

@@ -7,6 +7,292 @@
 
 #include <gtk/gtk.h>
 
+G_DECLARE_FINAL_TYPE (CanvasItem, canvas_item, CANVAS, ITEM, GtkWidget)
+
+struct _CanvasItem {
+  GtkWidget parent;
+
+  GtkWidget *fixed;
+  GtkWidget *label;
+
+  double r;
+  double angle;
+  double delta;
+
+  GtkWidget *editor;
+};
+
+struct _CanvasItemClass {
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (CanvasItem, canvas_item, GTK_TYPE_WIDGET)
+
+static int n_items = 0;
+
+static void
+set_color (CanvasItem *item,
+           GdkRGBA    *color)
+{
+  char *css;
+  char *str;
+  GtkStyleContext *context;
+  GtkCssProvider *provider;
+
+  str = gdk_rgba_to_string (color);
+  css = g_strdup_printf ("* { background: %s; padding: 10px; margin: 1px; }", str);
+
+  context = gtk_widget_get_style_context (item->label);
+  provider = g_object_get_data (G_OBJECT (context), "style-provider");
+  if (provider)
+    gtk_style_context_remove_provider (context, GTK_STYLE_PROVIDER (provider));
+
+  provider = gtk_css_provider_new ();
+  gtk_css_provider_load_from_data (provider, css, -1);
+  gtk_style_context_add_provider (gtk_widget_get_style_context (item->label), GTK_STYLE_PROVIDER (provider), 800);
+  g_object_set_data_full (G_OBJECT (context), "style-provider", provider, g_object_unref);
+
+  g_free (str);
+  g_free (css);
+}
+
+static gboolean
+item_drag_drop (GtkDropTarget *dest,
+                const GValue  *value,
+                double         x,
+                double         y)
+{
+  GtkWidget *label = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (dest));
+  CanvasItem *item = CANVAS_ITEM (gtk_widget_get_parent (gtk_widget_get_parent (label)));
+
+  set_color (item, g_value_get_boxed (value));
+
+  return TRUE;
+}
+
+static void
+apply_transform (CanvasItem *item)
+{
+  GskTransform *transform;
+  double x, y;
+
+  x = gtk_widget_get_allocated_width (item->label) / 2.0;
+  y = gtk_widget_get_allocated_height (item->label) / 2.0;
+  item->r = sqrt (x*x + y*y);
+
+  transform = gsk_transform_translate (
+                 gsk_transform_rotate (
+                   gsk_transform_translate (NULL,
+                                            &(graphene_point_t) { item->r, item->r }),
+                   item->angle + item->delta),
+                 &(graphene_point_t) { - x, - y });
+
+  gtk_fixed_set_child_transform (GTK_FIXED (item->fixed), item->label, transform);
+  gsk_transform_unref (transform);
+}
+
+static void
+angle_changed (GtkGestureRotate *gesture,
+               double            angle,
+               double            delta)
+{
+  CanvasItem *item = CANVAS_ITEM (gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)));
+
+  item->delta = angle / M_PI * 180.0;
+
+  apply_transform (item);
+}
+
+static void
+rotate_done (GtkGesture *gesture)
+{
+  CanvasItem *item = CANVAS_ITEM (gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)));
+
+  item->angle = item->angle + item->delta;
+  item->delta = 0;
+}
+
+static void
+click_done (GtkGesture *gesture)
+{
+  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
+  GtkWidget *canvas = gtk_widget_get_parent (item);
+  GtkWidget *last_child;
+
+  last_child = gtk_widget_get_last_child (canvas);
+  if (item != last_child)
+    gtk_widget_insert_after (item, canvas, last_child);
+}
+
+static void
+canvas_item_init (CanvasItem *item)
+{
+  char *text;
+  char *id;
+  GdkRGBA rgba;
+  GtkDropTarget *dest;
+  GtkGesture *gesture;
+
+  n_items++;
+
+  text = g_strdup_printf ("Item %d", n_items);
+  item->label = gtk_label_new (text);
+  g_free (text);
+
+  item->fixed = gtk_fixed_new ();
+  gtk_widget_set_parent (item->fixed, GTK_WIDGET (item));
+  gtk_fixed_put (GTK_FIXED (item->fixed), item->label, 0, 0);
+
+  gtk_widget_add_css_class (item->label, "frame");
+
+  id = g_strdup_printf ("item%d", n_items);
+  gtk_widget_set_name (item->label, id);
+  g_free (id);
+
+  gdk_rgba_parse (&rgba, "yellow");
+  set_color (item, &rgba);
+
+  item->angle = 0;
+
+  dest = gtk_drop_target_new (GDK_TYPE_RGBA, GDK_ACTION_COPY);
+  g_signal_connect (dest, "drop", G_CALLBACK (item_drag_drop), NULL);
+  gtk_widget_add_controller (GTK_WIDGET (item->label), GTK_EVENT_CONTROLLER (dest));
+
+  gesture = gtk_gesture_rotate_new ();
+  g_signal_connect (gesture, "angle-changed", G_CALLBACK (angle_changed), NULL);
+  g_signal_connect (gesture, "end", G_CALLBACK (rotate_done), NULL);
+  gtk_widget_add_controller (GTK_WIDGET (item), GTK_EVENT_CONTROLLER (gesture));
+
+  gesture = gtk_gesture_click_new ();
+  g_signal_connect (gesture, "released", G_CALLBACK (click_done), NULL);
+  gtk_widget_add_controller (GTK_WIDGET (item), GTK_EVENT_CONTROLLER (gesture));
+}
+
+static void
+canvas_item_dispose (GObject *object)
+{
+  CanvasItem *item = CANVAS_ITEM (object);
+
+  g_clear_pointer (&item->fixed, gtk_widget_unparent);
+  g_clear_pointer (&item->editor, gtk_widget_unparent);
+
+  G_OBJECT_CLASS (canvas_item_parent_class)->dispose (object);
+}
+
+static void
+canvas_item_map (GtkWidget *widget)
+{
+  CanvasItem *item = CANVAS_ITEM (widget);
+
+  GTK_WIDGET_CLASS (canvas_item_parent_class)->map (widget);
+
+  apply_transform (item);
+}
+
+static void
+canvas_item_class_init (CanvasItemClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = canvas_item_dispose;
+
+  widget_class->map = canvas_item_map;
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+  gtk_widget_class_set_css_name (widget_class, "item");
+}
+
+static GtkWidget *
+canvas_item_new (void)
+{
+  CanvasItem *item = g_object_new (canvas_item_get_type (), NULL);
+
+  return GTK_WIDGET (item);
+}
+
+static GdkPaintable *
+canvas_item_get_drag_icon (CanvasItem *item)
+{
+  return gtk_widget_paintable_new (item->fixed);
+}
+
+static gboolean
+canvas_item_is_editing (CanvasItem *item)
+{
+  return item->editor != NULL;
+}
+
+static void
+scale_changed (GtkRange   *range,
+               CanvasItem *item)
+{
+  item->angle = gtk_range_get_value (range);
+  apply_transform (item);
+}
+
+static void
+text_changed (GtkEditable *editable,
+              GParamSpec  *pspec,
+              CanvasItem  *item)
+{
+  gtk_label_set_text (GTK_LABEL (item->label), gtk_editable_get_text (editable));
+  apply_transform (item);
+}
+
+static void
+canvas_item_stop_editing (CanvasItem *item)
+{
+  GtkWidget *scale;
+
+  if (!item->editor)
+    return;
+
+  scale = gtk_widget_get_last_child (item->editor);
+  g_signal_handlers_disconnect_by_func (scale, scale_changed, item);
+
+  gtk_fixed_remove (GTK_FIXED (gtk_widget_get_parent (item->editor)), item->editor);
+  item->editor = NULL;
+}
+
+static void
+canvas_item_start_editing (CanvasItem *item)
+{
+  GtkWidget *canvas = gtk_widget_get_parent (GTK_WIDGET (item));
+  GtkWidget *entry;
+  GtkWidget *scale;
+  double x, y;
+
+  if (item->editor)
+    return;
+
+  item->editor = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+
+  entry = gtk_entry_new ();
+
+  gtk_editable_set_text (GTK_EDITABLE (entry),
+                         gtk_label_get_text (GTK_LABEL (item->label)));
+
+  gtk_editable_set_width_chars (GTK_EDITABLE (entry), 12);
+  g_signal_connect (entry, "notify::text", G_CALLBACK (text_changed), item);
+  g_signal_connect_swapped (entry, "activate", G_CALLBACK (canvas_item_stop_editing), item);
+
+  gtk_box_append (GTK_BOX (item->editor), entry);
+
+  scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 360, 1);
+  gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
+  gtk_range_set_value (GTK_RANGE (scale), fmod (item->angle, 360));
+
+  g_signal_connect (scale, "value-changed", G_CALLBACK (scale_changed), item);
+
+  gtk_box_append (GTK_BOX (item->editor), scale);
+
+  gtk_widget_translate_coordinates (GTK_WIDGET (item), canvas, 0, 0, &x, &y);
+  gtk_fixed_put (GTK_FIXED (canvas), item->editor, x, y + 2 * item->r);
+  gtk_widget_grab_focus (entry);
+
+}
+
 static GdkContentProvider *
 prepare (GtkDragSource *source,
          double         x,
@@ -18,7 +304,8 @@ prepare (GtkDragSource *source,
   canvas = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
   item = gtk_widget_pick (canvas, x, y, GTK_PICK_DEFAULT);
 
-  if (!GTK_IS_LABEL (item))
+  item = gtk_widget_get_ancestor (item, canvas_item_get_type ());
+  if (!item)
     return NULL;
 
   g_object_set_data (G_OBJECT (canvas), "dragged-item", item);
@@ -31,12 +318,17 @@ drag_begin (GtkDragSource *source,
             GdkDrag       *drag)
 {
   GtkWidget *canvas;
-  GtkWidget *item;
+  CanvasItem *item;
+  GdkPaintable *paintable;
 
   canvas = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
-  item = g_object_get_data (G_OBJECT (canvas), "dragged-item");
+  item = CANVAS_ITEM (g_object_get_data (G_OBJECT (canvas), "dragged-item"));
 
-  gtk_widget_set_opacity (item, 0.5);
+  paintable = canvas_item_get_drag_icon (item);
+  gtk_drag_source_set_icon (source, paintable, item->r, item->r);
+  g_object_unref (paintable);
+
+  gtk_widget_set_opacity (GTK_WIDGET (item), 0.3);
 }
 
 static void
@@ -61,110 +353,56 @@ drag_cancel (GtkDragSource       *source,
   return FALSE;
 }
 
-typedef struct {
-  double x, y;
-  double angle;
-  double delta;
-} TransformData;
-
-static void
-apply_transform (GtkWidget *item)
-{
-  GtkWidget *canvas = gtk_widget_get_parent (item);
-  TransformData *data;
-  GskTransform *transform;
-
-  data = g_object_get_data (G_OBJECT (item), "transform-data");
-  transform = gsk_transform_rotate (gsk_transform_translate (NULL, &(graphene_point_t){data->x, data->y}),
-                                    data->angle + data->delta);
-  gtk_fixed_set_child_transform (GTK_FIXED (canvas), item, transform);
-  gsk_transform_unref (transform);
-}
-
 static gboolean
 drag_drop (GtkDropTarget *target,
            const GValue  *value,
            double         x,
            double         y)
 {
-  GtkWidget *item;
-  TransformData *transform_data;
+  CanvasItem *item;
   GtkWidget *canvas;
   GtkWidget *last_child;
 
   item = g_value_get_object (value);
-  transform_data = g_object_get_data (G_OBJECT (item), "transform-data");
 
-  transform_data->x = x;
-  transform_data->y = y;
-
-  canvas = gtk_widget_get_parent (item);
+  canvas = gtk_widget_get_parent (GTK_WIDGET (item));
   last_child = gtk_widget_get_last_child (canvas);
-  if (item != last_child)
-    gtk_widget_insert_after (item, canvas, last_child);
+  if (GTK_WIDGET (item) != last_child)
+    gtk_widget_insert_after (GTK_WIDGET (item), canvas, last_child);
 
-  apply_transform (item);
+  gtk_fixed_move (GTK_FIXED (canvas), GTK_WIDGET (item), x - item->r, y - item->r);
 
   return TRUE;
 }
 
-static double pos_x, pos_y;
-
-static GtkWidget * canvas_item_new (double x, double y);
-
 static void
 new_item_cb (GtkWidget *button, gpointer data)
 {
   GtkWidget *canvas = data;
+  GtkWidget *popover;
   GtkWidget *item;
+  GdkRectangle rect;
 
-  item = canvas_item_new (pos_x, pos_y);
-  gtk_fixed_put (GTK_FIXED (canvas), item, 0, 0);
-  apply_transform (item);
+  popover = gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER);
+  gtk_popover_get_pointing_to (GTK_POPOVER (popover), &rect);
+
+  item = canvas_item_new ();
+  gtk_fixed_put (GTK_FIXED (canvas), item, rect.x, rect.y);
+  apply_transform (CANVAS_ITEM (item));
 
   gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
 }
 
-static void
-edit_label_done (GtkWidget *entry, gpointer data)
-{
-  GtkWidget *canvas = gtk_widget_get_parent (entry);
-  GtkWidget *label;
-  int x, y;
-
-  gtk_fixed_get_child_position (GTK_FIXED (canvas), entry, &x, &y);
-
-  label = GTK_WIDGET (g_object_get_data (G_OBJECT (entry), "label"));
-  gtk_label_set_text (GTK_LABEL (label), gtk_editable_get_text (GTK_EDITABLE (entry)));
-  gtk_widget_show (label);
-
-  gtk_fixed_remove (GTK_FIXED (canvas), entry);
-}
-
 static void
 edit_cb (GtkWidget *button, GtkWidget *child)
 {
-  GtkWidget *canvas = gtk_widget_get_parent (child);
-  int x, y;
-
-  gtk_fixed_get_child_position (GTK_FIXED (canvas), child, &x, &y);
-
-  if (GTK_IS_LABEL (child))
-    {
-      GtkWidget *entry = gtk_entry_new ();
-
-      g_object_set_data (G_OBJECT (entry), "label", child);
-
-      gtk_editable_set_text (GTK_EDITABLE (entry), gtk_label_get_text (GTK_LABEL (child)));
-      gtk_editable_set_width_chars (GTK_EDITABLE (entry), 12);
-      g_signal_connect (entry, "activate", G_CALLBACK (edit_label_done), NULL);
-      gtk_fixed_put (GTK_FIXED (canvas), entry, x, y);
-      gtk_widget_grab_focus (entry);
-      gtk_widget_hide (child);
-    }
+  CanvasItem *item = CANVAS_ITEM (child);
 
   if (button)
     gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
+
+  if (!canvas_item_is_editing (item))
+    canvas_item_start_editing (item);
 }
 
 static void
@@ -189,6 +427,7 @@ pressed_cb (GtkGesture *gesture,
 
   widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
   child = gtk_widget_pick (widget, x, y, GTK_PICK_DEFAULT);
+  child = gtk_widget_get_ancestor (child, canvas_item_get_type ());
 
   if (gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)) == GDK_BUTTON_SECONDARY)
     {
@@ -196,9 +435,6 @@ pressed_cb (GtkGesture *gesture,
       GtkWidget *box;
       GtkWidget *item;
 
-      pos_x = x;
-      pos_y = y;
-
       menu = gtk_popover_new ();
       gtk_widget_set_parent (menu, widget);
       gtk_popover_set_has_arrow (GTK_POPOVER (menu), FALSE);
@@ -242,14 +478,20 @@ released_cb (GtkGesture *gesture,
 {
   GtkWidget *widget;
   GtkWidget *child;
+  CanvasItem *item;
 
   widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
   child = gtk_widget_pick (widget, x, y, 0);
+  item = (CanvasItem *)gtk_widget_get_ancestor (child, canvas_item_get_type ());
+  if (!item)
+    return;
 
   if (gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)) == GDK_BUTTON_PRIMARY)
     {
-      if (child != NULL && child != widget)
-        edit_cb (NULL, child);
+      if (canvas_item_is_editing (item))
+        canvas_item_stop_editing (item);
+      else
+        canvas_item_start_editing (item);
     }
 }
 
@@ -287,131 +529,6 @@ canvas_new (void)
   return canvas;
 }
 
-static void
-set_color (GtkWidget *item,
-           GdkRGBA   *color)
-{
-  char *css;
-  char *str;
-  GtkStyleContext *context;
-  GtkCssProvider *provider;
-
-  str = gdk_rgba_to_string (color);
-  css = g_strdup_printf ("* { background: %s; padding: 10px; }", str);
-
-  context = gtk_widget_get_style_context (item);
-  provider = g_object_get_data (G_OBJECT (context), "style-provider");
-  if (provider)
-    gtk_style_context_remove_provider (context, GTK_STYLE_PROVIDER (provider));
-
-  provider = gtk_css_provider_new ();
-  gtk_css_provider_load_from_data (provider, css, -1);
-  gtk_style_context_add_provider (gtk_widget_get_style_context (item), GTK_STYLE_PROVIDER (provider), 800);
-  g_object_set_data_full (G_OBJECT (context), "style-provider", provider, g_object_unref);
-
-  g_free (str);
-  g_free (css);
-}
-
-static gboolean
-item_drag_drop (GtkDropTarget *dest,
-                const GValue  *value,
-                double         x,
-                double         y)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (dest));
-
-  set_color (item, g_value_get_boxed (value));
-
-  return TRUE;
-}
-
-static void
-angle_changed (GtkGestureRotate *gesture,
-               double            angle,
-               double            delta)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  TransformData *data = g_object_get_data (G_OBJECT (item), "transform-data");
-
-  data->delta = angle / M_PI * 180.0;
-
-  apply_transform (item);
-}
-
-static void
-rotate_done (GtkGesture *gesture)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  TransformData *data = g_object_get_data (G_OBJECT (item), "transform-data");
-
-  data->angle = data->angle + data->delta;
-  data->delta = 0;
-}
-
-static void
-click_done (GtkGesture *gesture)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  GtkWidget *canvas = gtk_widget_get_parent (item);
-  GtkWidget *last_child;
-
-  last_child = gtk_widget_get_last_child (canvas);
-  if (item != last_child)
-    gtk_widget_insert_after (item, canvas, last_child);
-}
-
-static int n_items = 0;
-
-static GtkWidget *
-canvas_item_new (double x,
-                 double y)
-{
-  GtkWidget *widget;
-  char *label;
-  char *id;
-  TransformData *transform_data;
-  GdkRGBA rgba;
-  GtkDropTarget *dest;
-  GtkGesture *gesture;
-
-  n_items++;
-
-  label = g_strdup_printf ("Item %d", n_items);
-  id = g_strdup_printf ("item%d", n_items);
-
-  gdk_rgba_parse (&rgba, "yellow");
-
-  widget = gtk_label_new (label);
-  gtk_widget_add_css_class (widget, "frame");
-  gtk_widget_set_name (widget, id);
-
-  set_color (widget, &rgba);
-  transform_data = g_new0 (TransformData, 1);
-  transform_data->x = x;
-  transform_data->y = y;
-  transform_data->angle = 0.0;
-  g_object_set_data_full (G_OBJECT (widget), "transform-data", transform_data, g_free);
-
-  g_free (label);
-  g_free (id);
-
-  dest = gtk_drop_target_new (GDK_TYPE_RGBA, GDK_ACTION_COPY);
-  g_signal_connect (dest, "drop", G_CALLBACK (item_drag_drop), NULL);
-  gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (dest));
-
-  gesture = gtk_gesture_rotate_new ();
-  g_signal_connect (gesture, "angle-changed", G_CALLBACK (angle_changed), NULL);
-  g_signal_connect (gesture, "end", G_CALLBACK (rotate_done), NULL);
-  gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture));
-
-  gesture = gtk_gesture_click_new ();
-  g_signal_connect (gesture, "released", G_CALLBACK (click_done), NULL);
-  gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture));
-  
-  return widget;
-}
-
 static GtkWidget *window = NULL;
 
 GtkWidget *
@@ -458,9 +575,9 @@ do_dnd (GtkWidget *do_widget)
         {
           GtkWidget *item;
 
-          item = canvas_item_new (x, y);
-          gtk_fixed_put (GTK_FIXED (canvas), item, 0, 0);
-          apply_transform (item);
+          item = canvas_item_new ();
+          gtk_fixed_put (GTK_FIXED (canvas), item, x, y);
+          apply_transform (CANVAS_ITEM (item));
 
           x += 150;
           y += 100;

demos/gtk-demo/fishbowl.c

@@ -249,6 +249,14 @@ fishbowl_changes_toggled_cb (GtkToggleButton *button,
     gtk_button_set_icon_name (GTK_BUTTON (button), "changes-allow");
 }
 
+char *
+format_header_cb (GObject *object,
+                  guint    count,
+                  double   fps)
+{
+  return g_strdup_printf ("%u Icons, %.2f fps", count, fps);
+}
+
 GtkWidget *
 do_fishbowl (GtkWidget *do_widget)
 {

demos/gtk-demo/fishbowl.ui

@@ -28,22 +28,12 @@
         </child>
         <child type="end">
           <object class="GtkLabel">
-            <property name="label">fps</property>
-          </object>
-        </child>
-        <child type="end">
-          <object class="GtkLabel">
-            <property name="label" bind-source="bowl" bind-property="framerate-string"/>
-          </object>
-        </child>
-        <child type="end">
-          <object class="GtkLabel">
-            <property name="label">Icons, </property>
-          </object>
-        </child>
-        <child type="end">
-          <object class="GtkLabel">
-            <property name="label" bind-source="bowl" bind-property="count"/>
+            <binding name="label">
+              <closure type="gchararray" function="format_header_cb">
+                <lookup name="count">bowl</lookup>
+                <lookup name="framerate">bowl</lookup>
+              </closure>
+            </binding>
           </object>
         </child>
         <child type="end">

demos/gtk-demo/flowbox.c

@@ -4,6 +4,8 @@
  * as needed and support sorting and filtering.
  *
  * The children of a GtkFlowBox are regular widgets
+ *
+ * The dataset used here has 665 colors.
  */
 
 #include <gtk/gtk.h>

demos/gtk-demo/geninclude.py

@@ -13,17 +13,16 @@ in_files = sys.argv[2:]
 file_output = """
 typedef GtkWidget *(*GDoDemoFunc) (GtkWidget *do_widget);
 
-typedef struct _Demo Demo;
+typedef struct _DemoData DemoData;
 
-struct _Demo
+struct _DemoData
 {
   const char *name;
   const char *title;
   const char *filename;
   GDoDemoFunc func;
-  Demo *children;
+  DemoData *children;
 };
-
 """
 
 # Demo = namedtuple('Demo', ['name', 'title', 'file', 'func'])
@@ -67,7 +66,7 @@ for demo in demos:
 i = 0
 for parent in parents:
     id = parent_ids[i]
-    file_output += "\nDemo child" + str(id) + "[] = {\n"
+    file_output += "\nDemoData child" + str(id) + "[] = {\n"
     # iterate over all demos and check if the name starts with the given parent name
     for child in demos:
         if child[1].startswith(parent + "/"):
@@ -82,7 +81,7 @@ for parent in parents:
 # Sort demos by title
 demos = sorted(demos, key=lambda x: x[1])
 
-file_output += "\nDemo gtk_demos[] = {\n"
+file_output += "\nDemoData gtk_demos[] = {\n"
 for demo in demos:
     # Do not generate one of these for demos with a parent demo
     if "/" not in demo[1]:

demos/gtk-demo/gtkfishbowl.c

@@ -53,7 +53,6 @@ enum {
    PROP_BENCHMARK,
    PROP_COUNT,
    PROP_FRAMERATE,
-   PROP_FRAMERATE_STRING,
    PROP_UPDATE_DELAY,
    NUM_PROPERTIES
 };
@@ -289,14 +288,6 @@ gtk_fishbowl_get_property (GObject         *object,
       g_value_set_double (value, gtk_fishbowl_get_framerate (fishbowl));
       break;
 
-    case PROP_FRAMERATE_STRING:
-      {
-        char *s = g_strdup_printf ("%.2f", gtk_fishbowl_get_framerate (fishbowl));
-        g_value_set_string (value, s);
-        g_free (s);
-      }
-      break;
-
     case PROP_UPDATE_DELAY:
       g_value_set_int64 (value, gtk_fishbowl_get_update_delay (fishbowl));
       break;
@@ -350,13 +341,6 @@ gtk_fishbowl_class_init (GtkFishbowlClass *klass)
                            0,
                            G_PARAM_READABLE);
 
-  props[PROP_FRAMERATE_STRING] =
-      g_param_spec_string ("framerate-string",
-                           "Framerate as string",
-                           "Framerate as string, with 2 decimals",
-                           NULL,
-                           G_PARAM_READABLE);
-
   props[PROP_UPDATE_DELAY] =
       g_param_spec_int64 ("update-delay",
                           "Update delay",
@@ -508,7 +492,6 @@ gtk_fishbowl_do_update (GtkFishbowl *fishbowl)
   priv->framerate = ((int)(priv->framerate * 100))/100.0;
 
   g_object_notify_by_pspec (G_OBJECT (fishbowl), props[PROP_FRAMERATE]);
-  g_object_notify_by_pspec (G_OBJECT (fishbowl), props[PROP_FRAMERATE_STRING]);
 
   if (!priv->benchmark)
     return;

demos/gtk-demo/gtkgears.c

@@ -197,7 +197,7 @@ gtk_gears_class_init (GtkGearsClass *klass)
  * @param v the vertex to fill
  * @param x the x coordinate
  * @param y the y coordinate
- * @param z the z coortinate
+ * @param z the z coordinate
  * @param n pointer to the normal table
  *
  * @return the operation error code

demos/gtk-demo/iconscroll.c

@@ -12,7 +12,7 @@ static GtkWidget *window = NULL;
 static GtkWidget *scrolledwindow;
 static int selected;
 
-#define N_WIDGET_TYPES 4
+#define N_WIDGET_TYPES 6
 
 
 static int hincrement = 5;
@@ -64,6 +64,7 @@ populate_icons (void)
       gtk_grid_attach (GTK_GRID (grid), create_icon (), left, top, 1, 1);
 
   hincrement = 0;
+  vincrement = 5;
 
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
                                   GTK_POLICY_NEVER,
@@ -100,6 +101,7 @@ populate_text (gboolean hilight)
   gtk_text_view_set_buffer (GTK_TEXT_VIEW (textview), buffer);
 
   hincrement = 0;
+  vincrement = 5;
 
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
                                   GTK_POLICY_NEVER,
@@ -124,6 +126,7 @@ populate_image (void)
   gtk_picture_set_can_shrink (GTK_PICTURE (image), FALSE);
 
   hincrement = 5;
+  vincrement = 5;
 
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
                                   GTK_POLICY_AUTOMATIC,
@@ -131,6 +134,42 @@ populate_image (void)
   gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), image);
 }
 
+extern GtkWidget *create_weather_view (void);
+
+static void
+populate_list (void)
+{
+  GtkWidget *list;
+
+  list = create_weather_view ();
+
+  hincrement = 5;
+  vincrement = 0;
+
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), list);
+}
+
+extern GtkWidget *create_color_grid (void);
+
+static void
+populate_grid (void)
+{
+  GtkWidget *list;
+
+  list = create_color_grid ();
+
+  hincrement = 0;
+  vincrement = 5;
+
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), list);
+}
+
 static void
 set_widget_type (int type)
 {
@@ -164,6 +203,16 @@ set_widget_type (int type)
       populate_image ();
       break;
 
+    case 4:
+      gtk_window_set_title (GTK_WINDOW (window), "Scrolling a list");
+      populate_list ();
+      break;
+
+    case 5:
+      gtk_window_set_title (GTK_WINDOW (window), "Scrolling a grid");
+      populate_grid ();
+      break;
+
     default:
       g_assert_not_reached ();
     }

demos/gtk-demo/listbox.c

@@ -8,6 +8,7 @@
 #include <gtk/gtk.h>
 #include <stdlib.h>
 #include <string.h>
+#include "award.h"
 
 static GdkPixbuf *avatar_pixbuf_other;
 static GtkWidget *window = NULL;
@@ -234,9 +235,9 @@ reshare_clicked (GtkMessageRow *row,
 {
   GtkMessageRowPrivate *priv = row->priv;
 
+  award ("listbox-reshare");
   priv->message->n_reshares++;
   gtk_message_row_update (row);
-
 }
 
 static void
@@ -255,11 +256,14 @@ gtk_message_row_state_flags_changed (GtkWidget    *widget,
 {
   GtkMessageRowPrivate *priv = GTK_MESSAGE_ROW (widget)->priv;
   GtkStateFlags flags;
+  gboolean visible;
 
   flags = gtk_widget_get_state_flags (widget);
 
-  gtk_widget_set_visible (priv->extra_buttons_box,
-                          flags & (GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED));
+  visible = flags & (GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED) ? TRUE : FALSE;
+  gtk_widget_set_visible (priv->extra_buttons_box, visible);
+  if (visible && gtk_list_box_row_get_index (GTK_LIST_BOX_ROW (widget)) % 100 == 99)
+    award ("listbox-100th-row");
 
   GTK_WIDGET_CLASS (gtk_message_row_parent_class)->state_flags_changed (widget, previous_state_flags);
 }

demos/gtk-demo/listbox.ui

@@ -150,7 +150,7 @@
                   </object>
                 </child>
                 <child>
-                  <object class="GtkButton" id="favorite-buttton">
+                  <object class="GtkButton" id="favorite-button">
                     <property name="label" translatable="yes">Favorite</property>
                     <property name="receives-default">1</property>
                     <property name="has-frame">0</property>

demos/gtk-demo/listview_applauncher.c

@@ -0,0 +1,199 @@
+/* Lists/Application launcher
+ *
+ * This demo uses the GtkCoverFlow widget as a fancy application launcher.
+ *
+ * It is also a very small introduction to listviews.
+ */
+
+#include <gtk/gtk.h>
+
+/* This is the function that creates the #GListModel that we need.
+ * GTK list widgets need a #GListModel to display, as models support change
+ * notifications.
+ * Unfortunately various older APIs do not provide list models, so we create
+ * our own.
+ */
+static GListModel *
+create_application_list (void)
+{
+  GListStore *store;
+  GList *apps, *l;
+
+  /* We use a #GListStore here, which is a simple array-like list implementation
+   * for manual management.
+   * List models need to know what type of data they provide, so we need to
+   * provide the type here. As we want to do a list of applications, #GAppInfo
+   * is the object we provide.
+   */
+  store = g_list_store_new (G_TYPE_APP_INFO);
+
+  apps = g_app_info_get_all ();
+
+  for (l = apps; l; l = l->next)
+    {
+      g_list_store_append (store, l->data);
+    }
+
+  g_list_free_full (apps, g_object_unref);
+
+  return G_LIST_MODEL (store);
+}
+
+/* This is the function we use for setting up new listitems to display.
+ * We add just a #GtkImage here to display the application's icon as this is just
+ * a simple demo.
+ */
+static void
+setup_listitem_cb (GtkListItemFactory *factory,
+                   GtkListItem        *list_item)
+{
+  GtkWidget *image;
+
+  image = gtk_image_new ();
+  gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
+
+  gtk_list_item_set_child (list_item, image);
+}
+
+/* Here we need to prepare the listitem for displaying its item. We get the
+ * listitem already set up from the previous function, so we can reuse the
+ * #GtkImage widget we set up above.
+ * We get the item - which we know is a #GAppInfo because it comes out of
+ * the model we set up above, grab its icon and display it.
+ */
+static void
+bind_listitem_cb (GtkListItemFactory *factory,
+                  GtkListItem        *list_item)
+{
+  GtkWidget *image;
+  GAppInfo *app_info;
+
+  image = gtk_list_item_get_child (list_item);
+  app_info = gtk_list_item_get_item (list_item);
+
+  gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
+}
+
+/* In more complex code, we would also need functions to unbind and teardown
+ * the listitem, but this is simple code, so the default implementations are
+ * enough. If we had connected signals, this step would have been necessary.
+ *
+ * The #GtkSignalListItemFactory documentation contains more information about
+ * this step.
+ */
+
+/* This function is called whenever an item in the list is activated. This is
+ * the simple way to allow reacting to the Enter key or double-clicking on a
+ * listitem.
+ * Of course, it is possible to use far more complex interactions by turning
+ * off activation and adding buttons or other widgets in the setup function
+ * above, but this is a simple demo, so we'll use the simple way.
+ */
+static void
+activate_cb (GtkCoverFlow *coverflow,
+             guint         position,
+             gpointer      unused)
+{
+  GAppInfo *app_info;
+  GdkAppLaunchContext *context;
+  GError *error = NULL;
+
+  app_info = g_list_model_get_item (gtk_cover_flow_get_model (coverflow), position);
+
+  /* Prepare the context for launching the application and launch it. This
+   * code is explained in detail in the documentation for #GdkAppLaunchContext
+   * and #GAppInfo.
+   */
+  context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (coverflow)));
+  if (!g_app_info_launch (app_info,
+                          NULL, 
+                          G_APP_LAUNCH_CONTEXT (context),
+                          &error))
+    {
+      GtkWidget *dialog;
+
+      /* And because error handling is important, even a simple demo has it:
+       * We display an error dialog that something went wrong.
+       */
+      dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (coverflow))),
+                                       GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
+                                       GTK_MESSAGE_ERROR,
+                                       GTK_BUTTONS_CLOSE,
+                                       "Could not launch %s", g_app_info_get_display_name (app_info));
+      gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s", error->message);
+      g_clear_error (&error);
+      gtk_widget_show (dialog);
+    }
+
+  g_object_unref (context);
+  g_object_unref (app_info);
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_listview_applauncher (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkWidget *coverflow, *sw;;
+      GListModel *model;
+      GtkListItemFactory *factory;
+
+      /* Create a window and set a few defaults */
+      window = gtk_window_new ();
+      gtk_window_set_default_size (GTK_WINDOW (window), 640, 320);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Application Launcher");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+    
+      /* The #GtkListitemFactory is what is used to create #GtkListItems
+       * to display the data from the model. So it is absolutely necessary
+       * to create one.
+       * We will use a #GtkSignalListItemFactory because it is the simplest
+       * one to use. Different ones are available for different use cases.
+       * The most powerful one is #GtkBuilderListItemFactory which uses
+       * #GtkBuilder .ui files, so it requires little code.
+       */
+      factory = gtk_signal_list_item_factory_new ();
+      g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
+      g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
+
+      /* Create the list widget here: We use a coverflow widget because it's
+       * the coolest one. We could just as well use other list widgets such
+       * as a #GtkListView or a #GtkGridView and the code would look very
+       * similar.
+       */
+      coverflow = gtk_cover_flow_new_with_factory (factory);
+      /* We connect the activate signal here. It's the function we defined
+       * above for launching the selected application.
+       */
+      g_signal_connect (coverflow, "activate", G_CALLBACK (activate_cb), NULL);
+
+      /* And of course we need to set the data model. Here we call the function
+       * we wrote above that gives us the list of applications. Then we set
+       * it on the coverflow list widget.
+       * The coverflow will now take items from the model and use the factory
+       * to create as many listitems as it needs to show itself to the user.
+       */
+      model = create_application_list ();
+      gtk_cover_flow_set_model (GTK_COVER_FLOW (coverflow), model);
+      g_object_unref (model);
+
+      /* List widgets should always be contained in a #GtkScrolledWindow,
+       * because otherwise they might get too large or they might not
+       * be scrollable.
+       */
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_window_set_child (GTK_WINDOW (window), sw);
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), coverflow);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/listview_clocks.c

@@ -0,0 +1,489 @@
+/* Lists/Clocks
+ *
+ * This demo displays the time in different timezones.
+ *
+ * The goal is to show how to set up expressions that track changes
+ * in objects and make them update widgets.
+ *
+ * For that, we create a GtkClock object that updates its time every
+ * second and then use various ways to display that time.
+ *
+ * Typically, this will be done using GtkBuilder .ui files with the
+ * help of the <binding> tag, but this demo shows the code that runs
+ * behind that.
+ */
+
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_CLOCK (gtk_clock_get_type ())
+G_DECLARE_FINAL_TYPE (GtkClock, gtk_clock, GTK, CLOCK, GObject)
+
+/* This is our object. It's just a timezone */
+typedef struct _GtkClock GtkClock;
+struct _GtkClock
+{
+  GObject parent_instance;
+
+  /* We allow this to be NULL for the local timezone */
+  GTimeZone *timezone;
+  /* Name of the location we're displaying time for */
+  char *location;
+};
+
+enum {
+  PROP_0,
+  PROP_LOCATION,
+  PROP_TIME,
+  PROP_TIMEZONE,
+
+  N_PROPS
+};
+
+/* This function returns the current time in the clock's timezone.
+ * Note that this returns a new object every time, so we need to
+ * remember to unref it after use. */
+static GDateTime *
+gtk_clock_get_time (GtkClock *clock)
+{
+  if (clock->timezone)
+    return g_date_time_new_now (clock->timezone);
+  else
+    return g_date_time_new_now_local ();
+}
+
+/* Here, we implement the functionality required by the GdkPaintable interface.
+ * This way we have a trivial way to display an analog clock.
+ * It also allows demonstrating how to directly use objects in the listview
+ * later by making this object do something interesting. */
+static void
+gtk_clock_snapshot (GdkPaintable *paintable,
+                    GdkSnapshot  *snapshot,
+                    double        width,
+                    double        height)
+{
+  GtkClock *self = GTK_CLOCK (paintable);
+  GDateTime *time;
+  GskRoundedRect outline;
+
+#define BLACK ((GdkRGBA) { 0, 0, 0, 1 })
+
+  /* save/restore() is necessary so we can undo the transforms we start
+   * out with. */
+  gtk_snapshot_save (snapshot);
+
+  /* First, we move the (0, 0) point to the center of the area so
+   * we can draw everything relative to it. */
+  gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (width / 2, height / 2));
+  /* Next we scale it, so that we can pretend that the clock is
+   * 100px in size. That way, we don't need to do any complicated
+   * math later.
+   * We use MIN() here so that we use the smaller dimension for sizing.
+   * That way we don't overdraw but keep the aspect ratio. */
+  gtk_snapshot_scale (snapshot, MIN (width, height) / 100.0, MIN (width, height) / 100.0);
+  /* Now we have a circle with diameter 100px (and radius 50px) that
+   * has its (0, 0) point at the center.
+   * Let's draw a simple clock into it. */
+
+  time = gtk_clock_get_time (self);
+
+  /* First, draw a circle. This is a neat little trick to draw a circle
+   * without requiring Cairo. */
+  gsk_rounded_rect_init_from_rect (&outline, &GRAPHENE_RECT_INIT(-50, -50, 100, 100), 50);
+  gtk_snapshot_append_border (snapshot,
+                              &outline,
+                              (float[4]) { 4, 4, 4, 4 },
+                              (GdkRGBA [4]) { BLACK, BLACK, BLACK, BLACK });
+
+  /* Next, draw the hour hand.
+   * We do this using tranforms again: Instead of computing where the angle points
+   * to, we just rotate everything and then draw the hand as if if was :00.
+   * We don't even need to care about am/pm here because rotations just work. */
+  gtk_snapshot_save (snapshot);
+  gtk_snapshot_rotate (snapshot, 30 * g_date_time_get_hour (time) + 0.5 * g_date_time_get_minute (time));
+  gsk_rounded_rect_init_from_rect (&outline, &GRAPHENE_RECT_INIT(-2, -23, 4, 25), 2);
+  gtk_snapshot_push_rounded_clip (snapshot, &outline);
+  gtk_snapshot_append_color (snapshot, &BLACK, &outline.bounds);
+  gtk_snapshot_pop (snapshot);
+  gtk_snapshot_restore (snapshot);
+
+  /* And the same as above for the minute hand. Just make this one longer
+   * so people can tell the hands apart. */
+  gtk_snapshot_save (snapshot);
+  gtk_snapshot_rotate (snapshot, 6 * g_date_time_get_minute (time));
+  gsk_rounded_rect_init_from_rect (&outline, &GRAPHENE_RECT_INIT(-2, -43, 4, 45), 2);
+  gtk_snapshot_push_rounded_clip (snapshot, &outline);
+  gtk_snapshot_append_color (snapshot, &BLACK, &outline.bounds);
+  gtk_snapshot_pop (snapshot);
+  gtk_snapshot_restore (snapshot);
+
+  /* and finally, the second indicator. */
+  gtk_snapshot_save (snapshot);
+  gtk_snapshot_rotate (snapshot, 6 * g_date_time_get_second (time));
+  gsk_rounded_rect_init_from_rect (&outline, &GRAPHENE_RECT_INIT(-2, -43, 4, 10), 2);
+  gtk_snapshot_push_rounded_clip (snapshot, &outline);
+  gtk_snapshot_append_color (snapshot, &BLACK, &outline.bounds);
+  gtk_snapshot_pop (snapshot);
+  gtk_snapshot_restore (snapshot);
+
+  /* And finally, don't forget to restore the initial save() that we did for
+   * the initial transformations. */
+  gtk_snapshot_restore (snapshot);
+
+  g_date_time_unref (time);
+}
+
+/* Our desired size is 100px. That sounds okay for an analog clock */
+static int
+gtk_clock_get_intrinsic_width (GdkPaintable *paintable)
+{
+  return 100;
+}
+
+static int
+gtk_clock_get_intrinsic_height (GdkPaintable *paintable)
+{
+  return 100;
+}
+
+/* Initialize the paintable interface. This way we turn our clock objects
+ * into objects that can be drawn.
+ * There are more functions to this interface to define desired size,
+ * but this is enough.
+ */
+static void
+gtk_clock_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->snapshot = gtk_clock_snapshot;
+  iface->get_intrinsic_width = gtk_clock_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_clock_get_intrinsic_height;
+}
+
+/* Finally, we define the type. The important part is adding the paintable
+ * interface, so GTK knows that this object can indeed be drawm.
+ */
+G_DEFINE_TYPE_WITH_CODE (GtkClock, gtk_clock, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                                gtk_clock_paintable_init))
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gtk_clock_get_property (GObject    *object,
+                        guint       property_id,
+                        GValue     *value,
+                        GParamSpec *pspec)
+{
+  GtkClock *self = GTK_CLOCK (object);
+
+  switch (property_id)
+    {
+    case PROP_LOCATION:
+      g_value_set_string (value, self->location);
+      break;
+
+    case PROP_TIME:
+      g_value_take_boxed (value, gtk_clock_get_time (self));
+      break;
+
+    case PROP_TIMEZONE:
+      g_value_set_boxed (value, self->timezone);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_clock_set_property (GObject      *object,
+                        guint         property_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+{
+  GtkClock *self = GTK_CLOCK (object);
+
+  switch (property_id)
+    {
+    case PROP_LOCATION:
+      self->location = g_value_dup_string (value);
+      break;
+
+    case PROP_TIMEZONE:
+      self->timezone = g_value_dup_boxed (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+/* This is the list of all the ticking clocks */
+static GSList *ticking_clocks = NULL;
+/* This is the id of the timeout source that is updating all ticking clocks */
+static guint ticking_clock_id = 0;
+
+/* Every second, this function is called to tell everybody that the
+ * clocks are ticking.
+ */
+static gboolean
+gtk_clock_tick (gpointer unused)
+{
+  GSList *l;
+
+  for (l = ticking_clocks; l; l = l->next)
+    {
+      GtkClock *clock = l->data;
+
+      /* We will now return a different value for the time porperty,
+       * so notify about that.
+       */
+      g_object_notify_by_pspec (G_OBJECT (clock), properties[PROP_TIME]);
+      /* We will also draw the hands of the clock differently.
+       * So notify about that, too.
+       */
+      gdk_paintable_invalidate_contents (GDK_PAINTABLE (clock));
+    }
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+gtk_clock_stop_ticking (GtkClock *self)
+{
+  ticking_clocks = g_slist_remove (ticking_clocks, self);
+
+  /* If no clock is remaining, stop running the tick updates */
+  if (ticking_clocks == NULL && ticking_clock_id != 0)
+    g_clear_handle_id (&ticking_clock_id, g_source_remove);
+}
+
+static void
+gtk_clock_start_ticking (GtkClock *self)
+{
+  /* if no clock is ticking yet, start */
+  if (ticking_clock_id == 0)
+    ticking_clock_id = g_timeout_add_seconds (1, gtk_clock_tick, NULL);
+
+  ticking_clocks = g_slist_prepend (ticking_clocks, self);
+}
+
+static void
+gtk_clock_finalize (GObject *object)
+{
+  GtkClock *self = GTK_CLOCK (object);
+
+  gtk_clock_stop_ticking (self);
+
+  g_free (self->location);
+  g_clear_pointer (&self->timezone, g_time_zone_unref);
+
+  G_OBJECT_CLASS (gtk_clock_parent_class)->finalize (object);
+}
+
+static void
+gtk_clock_class_init (GtkClockClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = gtk_clock_get_property;
+  gobject_class->set_property = gtk_clock_set_property;
+  gobject_class->finalize = gtk_clock_finalize;
+
+  properties[PROP_LOCATION] =
+    g_param_spec_string ("location", NULL, NULL, NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  properties[PROP_TIME] =
+    g_param_spec_boxed ("time", NULL, NULL, G_TYPE_DATE_TIME, G_PARAM_READABLE);
+  properties[PROP_TIMEZONE] =
+    g_param_spec_boxed ("timezone", NULL, NULL, G_TYPE_TIME_ZONE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gtk_clock_init (GtkClock *self)
+{
+  gtk_clock_start_ticking (self);
+}
+
+static GtkClock *
+gtk_clock_new (const char *location,
+               GTimeZone  *timezone)
+{
+  GtkClock *result;
+
+  result = g_object_new (GTK_TYPE_CLOCK,
+                         "location", location,
+                         "timezone", timezone,
+                         NULL);
+
+  g_clear_pointer (&timezone, g_time_zone_unref);
+
+  return result;
+}
+
+static GListModel *
+create_clocks_model (void)
+{
+  GListStore *result;
+  GtkClock *clock;
+
+  result = g_list_store_new (GTK_TYPE_CLOCK);
+
+  /* local time */
+  clock = gtk_clock_new ("local", NULL);
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  /* UTC time */
+  clock = gtk_clock_new ("UTC", g_time_zone_new_utc ());
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  /* A bunch of timezones with GTK hackers */
+  clock = gtk_clock_new ("San Francisco", g_time_zone_new ("America/Los_Angeles"));
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  clock = gtk_clock_new ("Boston", g_time_zone_new ("America/New_York"));
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  clock = gtk_clock_new ("London", g_time_zone_new ("Europe/London"));
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  clock = gtk_clock_new ("Berlin", g_time_zone_new ("Europe/Berlin"));
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  clock = gtk_clock_new ("Moscow", g_time_zone_new ("Europe/Moscow"));
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  clock = gtk_clock_new ("New Delhi", g_time_zone_new ("Asia/Kolkata"));
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+  clock = gtk_clock_new ("Shanghai", g_time_zone_new ("Asia/Shanghai"));
+  g_list_store_append (result, clock);
+  g_object_unref (clock);
+
+  return G_LIST_MODEL (result);
+}
+
+static char *
+convert_time_to_string (GObject   *image,
+                        GDateTime *time,
+                        gpointer   unused)
+{
+  return g_date_time_format (time, "%x\n%X");
+}
+
+/* And this function is the crux for this whole demo.
+ * It shows how to use expressions to set up bindings.
+ */
+static void
+setup_listitem_cb (GtkListItemFactory *factory,
+                   GtkListItem        *list_item)
+{
+  GtkWidget *box, *picture, *location_label, *time_label;
+  GtkExpression *clock_expression, *expression;
+
+  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_list_item_set_child (list_item, box);
+
+  /* First, we create an expression that gets us the clock from the listitem:
+   * 1. Create an expression that gets the list item.
+   * 2. Use that expression's "item" property to get the clock
+   */
+  expression = gtk_constant_expression_new (GTK_TYPE_LIST_ITEM, list_item);
+  clock_expression = gtk_property_expression_new (GTK_TYPE_LIST_ITEM, expression, "item");
+
+  /* Bind the clock's location to a label.
+   * This is easy: We just get the "location" property of the clock.
+   */
+  expression = gtk_property_expression_new (GTK_TYPE_CLOCK,
+                                            gtk_expression_ref (clock_expression),
+                                            "location");
+  /* Now create the label and bind the expression to it. */
+  location_label = gtk_label_new (NULL);
+  gtk_expression_bind (expression, location_label, "label", location_label);
+  gtk_box_append (GTK_BOX (box), location_label);
+
+
+  /* Here we bind the item itself to a GdkPicture.
+   * This is simply done by using the clock expression itself.
+   */
+  expression = gtk_expression_ref (clock_expression);
+  /* Now create the widget and bind the expression to it. */
+  picture = gtk_picture_new ();
+  gtk_expression_bind (expression, picture, "paintable", picture);
+  gtk_box_append (GTK_BOX (box), picture);
+
+
+  /* And finally, everything comes together.
+   * We create a label for displaying the time as text.
+   * For that, we need to transform the "GDateTime" of the
+   * time property into a string so that the label can display it.
+   */
+  expression = gtk_property_expression_new (GTK_TYPE_CLOCK,
+                                            gtk_expression_ref (clock_expression),
+                                            "time");
+  expression = gtk_cclosure_expression_new (G_TYPE_STRING,
+                                            NULL,
+                                            1, (GtkExpression *[1]) { expression },
+                                            G_CALLBACK (convert_time_to_string),
+                                            NULL, NULL);
+  /* Now create the label and bind the expression to it. */
+  time_label = gtk_label_new (NULL);
+  gtk_expression_bind (expression, time_label, "label", time_label);
+  gtk_box_append (GTK_BOX (box), time_label);
+
+  gtk_expression_unref (clock_expression);
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_listview_clocks (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkWidget *gridview, *sw;
+      GtkListItemFactory *factory;
+      GListModel *model;
+      GtkNoSelection *selection;
+
+      /* This is the normal window setup code every demo does */
+      window = gtk_window_new ();
+      gtk_window_set_title (GTK_WINDOW (window), "Clocks");
+      gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+
+      /* List widgets go into a scrolled window. Always. */
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_window_set_child (GTK_WINDOW (window), sw);
+
+      /* Create the factory that creates the listitems. Because we
+       * used bindings above during setup, we only need to connect
+       * to the setup signal.
+       * The bindings take care of the bind step.
+       */
+      factory = gtk_signal_list_item_factory_new ();
+      g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
+
+      gridview = gtk_grid_view_new_with_factory (factory);
+      gtk_scrollable_set_hscroll_policy (GTK_SCROLLABLE (gridview), GTK_SCROLL_NATURAL);
+      gtk_scrollable_set_vscroll_policy (GTK_SCROLLABLE (gridview), GTK_SCROLL_NATURAL);
+
+      model = create_clocks_model ();
+      selection = gtk_no_selection_new (model);
+      gtk_grid_view_set_model (GTK_GRID_VIEW (gridview), G_LIST_MODEL (selection));
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), gridview);
+      g_object_unref (selection);
+      g_object_unref (model);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/listview_colors.c

@@ -0,0 +1,593 @@
+/* Lists/Colors
+ *
+ * This demo displays a list of named colors.
+ *
+ * It is using a GtkGridView, and shows how to display
+ * and sort the data in various ways. The controls for
+ * this are implemented using GtkDropDown.
+ *
+ * The dataset used here has 9283 items.
+ */
+
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_COLOR (gtk_color_get_type ())
+G_DECLARE_FINAL_TYPE (GtkColor, gtk_color, GTK, COLOR, GObject)
+
+/* This is our object. It's just a color */
+typedef struct _GtkColor GtkColor;
+struct _GtkColor
+{
+  GObject parent_instance;
+
+  char *name;
+  GdkRGBA *color;
+  int h, s, v;
+};
+
+enum {
+  PROP_0,
+  PROP_NAME,
+  PROP_COLOR,
+  PROP_RED,
+  PROP_GREEN,
+  PROP_BLUE,
+  PROP_HUE,
+  PROP_SATURATION,
+  PROP_VALUE,
+
+  N_PROPS
+};
+
+static void
+gtk_color_snapshot (GdkPaintable *paintable,
+                    GdkSnapshot  *snapshot,
+                    double        width,
+                    double        height)
+{
+  GtkColor *self = GTK_COLOR (paintable);
+
+  gtk_snapshot_append_color (snapshot, self->color, &GRAPHENE_RECT_INIT (0, 0, width, height));
+}
+
+static int
+gtk_color_get_intrinsic_width (GdkPaintable *paintable)
+{
+  return 32;
+}
+
+static int
+gtk_color_get_intrinsic_height (GdkPaintable *paintable)
+{
+  return 32;
+}
+
+static void
+gtk_color_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->snapshot = gtk_color_snapshot;
+  iface->get_intrinsic_width = gtk_color_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_color_get_intrinsic_height;
+}
+
+/*
+ * Finally, we define the type. The important part is adding the paintable
+ * interface, so GTK knows that this object can indeed be drawm.
+ */
+G_DEFINE_TYPE_WITH_CODE (GtkColor, gtk_color, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                                gtk_color_paintable_init))
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gtk_color_get_property (GObject    *object,
+                        guint       property_id,
+                        GValue     *value,
+                        GParamSpec *pspec)
+{
+  GtkColor *self = GTK_COLOR (object);
+
+  switch (property_id)
+    {
+    case PROP_NAME:
+      g_value_set_string (value, self->name);
+      break;
+
+    case PROP_COLOR:
+      g_value_set_boxed (value, self->color);
+      break;
+
+    case PROP_RED:
+      g_value_set_float (value, self->color->red);
+      break;
+
+    case PROP_GREEN:
+      g_value_set_float (value, self->color->green);
+      break;
+
+    case PROP_BLUE:
+      g_value_set_float (value, self->color->blue);
+      break;
+
+    case PROP_HUE:
+      g_value_set_int (value, self->h);
+      break;
+
+    case PROP_SATURATION:
+      g_value_set_int (value, self->s);
+      break;
+
+    case PROP_VALUE:
+      g_value_set_int (value, self->v);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_color_set_property (GObject      *object,
+                        guint         property_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+{
+  GtkColor *self = GTK_COLOR (object);
+
+  switch (property_id)
+    {
+    case PROP_NAME:
+      self->name = g_value_dup_string (value);
+      break;
+
+    case PROP_COLOR:
+      self->color = g_value_dup_boxed (value);
+      break;
+
+    case PROP_HUE:
+      self->h = g_value_get_int (value);
+      break;
+
+    case PROP_SATURATION:
+      self->s = g_value_get_int (value);
+      break;
+
+    case PROP_VALUE:
+      self->v = g_value_get_int (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_color_finalize (GObject *object)
+{
+  GtkColor *self = GTK_COLOR (object);
+
+  g_free (self->name);
+  g_clear_pointer (&self->color, gdk_rgba_free);
+
+  G_OBJECT_CLASS (gtk_color_parent_class)->finalize (object);
+}
+
+static void
+gtk_color_class_init (GtkColorClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = gtk_color_get_property;
+  gobject_class->set_property = gtk_color_set_property;
+  gobject_class->finalize = gtk_color_finalize;
+
+  properties[PROP_NAME] =
+    g_param_spec_string ("name", NULL, NULL, NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  properties[PROP_COLOR] =
+    g_param_spec_boxed ("color", NULL, NULL, GDK_TYPE_RGBA, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  properties[PROP_RED] =
+    g_param_spec_float ("red", NULL, NULL, 0, 1, 0, G_PARAM_READABLE);
+  properties[PROP_GREEN] =
+    g_param_spec_float ("green", NULL, NULL, 0, 1, 0, G_PARAM_READABLE);
+  properties[PROP_BLUE] =
+    g_param_spec_float ("blue", NULL, NULL, 0, 1, 0, G_PARAM_READABLE);
+  properties[PROP_HUE] =
+    g_param_spec_int ("hue", NULL, NULL, 0, 360, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  properties[PROP_SATURATION] =
+    g_param_spec_int ("saturation", NULL, NULL, 0, 100, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  properties[PROP_VALUE] =
+    g_param_spec_int ("value", NULL, NULL, 0, 100, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gtk_color_init (GtkColor *self)
+{
+}
+
+static GtkColor *
+gtk_color_new (const char *name,
+               float r, float g, float b,
+               int h, int s, int v)
+{
+  GtkColor *result;
+  GdkRGBA color = { r, g, b, 1.0 };
+
+  result = g_object_new (GTK_TYPE_COLOR,
+                         "name", name,
+                         "color", &color,
+                         "hue", h,
+                         "saturation", s,
+                         "value", v,
+                         NULL);
+
+  return result;
+}
+
+static GListModel *
+create_colors_model (void)
+{
+  GListStore *result;
+  GtkColor *color;
+  GBytes *data;
+  char **lines;
+  guint i;
+
+  result = g_list_store_new (GTK_TYPE_COLOR);
+  data = g_resources_lookup_data ("/listview_colors/color.names.txt", 0, NULL);
+  lines = g_strsplit (g_bytes_get_data (data, NULL), "\n", 0);
+
+  for (i = 0; lines[i]; i++)
+    {
+      const char *name;
+      char **fields;
+      int red, green, blue;
+      int h, s, v;
+
+      if (lines[i][0] == '#' || lines[i][0] == '\0')
+        continue;
+
+      fields = g_strsplit (lines[i], " ", 0);
+      name = fields[1];
+      red = atoi (fields[3]);
+      green = atoi (fields[4]);
+      blue = atoi (fields[5]);
+      h = atoi (fields[9]);
+      s = atoi (fields[10]);
+      v = atoi (fields[11]);
+ 
+      color = gtk_color_new (name, red / 255., green / 255., blue / 255., h, s, v);
+      g_list_store_append (result, color);
+      g_object_unref (color);
+
+      g_strfreev (fields);
+    }
+  g_strfreev (lines);
+
+  g_bytes_unref (data);
+
+  return G_LIST_MODEL (result);
+}
+
+static char *
+get_rgb_markup (gpointer this,
+                GtkColor *color)
+{
+  if (!color)
+    return NULL;
+
+  return g_strdup_printf ("<b>R:</b> %d <b>G:</b> %d <b>B:</b> %d",
+                          (int)(color->color->red * 255), 
+                          (int)(color->color->green * 255),
+                          (int)(color->color->blue * 255));
+}
+
+static char *
+get_hsv_markup (gpointer this,
+                GtkColor *color)
+{
+  if (!color)
+    return NULL;
+
+  return g_strdup_printf ("<b>H:</b> %d <b>S:</b> %d <b>V:</b> %d",
+                          color->h, 
+                          color->s,
+                          color->v);
+}
+
+static void
+setup_simple_listitem_cb (GtkListItemFactory *factory,
+                          GtkListItem        *list_item)
+{
+  GtkWidget *picture;
+  GtkExpression *color_expression, *expression;
+
+  expression = gtk_constant_expression_new (GTK_TYPE_LIST_ITEM, list_item);
+  color_expression = gtk_property_expression_new (GTK_TYPE_LIST_ITEM, expression, "item");
+
+  picture = gtk_picture_new ();
+  gtk_widget_set_size_request (picture, 32, 32);
+  gtk_expression_bind (color_expression, picture, "paintable", NULL);
+
+  gtk_list_item_set_child (list_item, picture);
+}
+
+static void
+setup_listitem_cb (GtkListItemFactory *factory,
+                   GtkListItem        *list_item)
+{
+  GtkWidget *box, *picture, *name_label, *rgb_label, *hsv_label;;
+  GtkExpression *color_expression, *expression;
+  GtkExpression *params[1];
+
+  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_list_item_set_child (list_item, box);
+
+  expression = gtk_constant_expression_new (GTK_TYPE_LIST_ITEM, list_item);
+  color_expression = gtk_property_expression_new (GTK_TYPE_LIST_ITEM, expression, "item");
+
+  expression = gtk_property_expression_new (GTK_TYPE_COLOR,
+                                            gtk_expression_ref (color_expression),
+                                            "name");
+  name_label = gtk_label_new (NULL);
+  gtk_expression_bind (expression, name_label, "label", NULL);
+  gtk_box_append (GTK_BOX (box), name_label);
+
+  expression = gtk_expression_ref (color_expression);
+  picture = gtk_picture_new ();
+  gtk_expression_bind (expression, picture, "paintable", NULL);
+  gtk_box_append (GTK_BOX (box), picture);
+
+  params[0] = gtk_expression_ref (color_expression);
+  expression = gtk_cclosure_expression_new (G_TYPE_STRING,
+                                            NULL,
+                                            1, params,
+                                            (GCallback)get_rgb_markup,
+                                            NULL, NULL);
+
+  rgb_label = gtk_label_new (NULL);
+  gtk_label_set_use_markup (GTK_LABEL (rgb_label), TRUE);
+  gtk_expression_bind (expression, rgb_label, "label", NULL);
+  gtk_box_append (GTK_BOX (box), rgb_label);
+
+  params[0] = gtk_expression_ref (color_expression);
+  expression = gtk_cclosure_expression_new (G_TYPE_STRING,
+                                            NULL,
+                                            1, params,
+                                            (GCallback)get_hsv_markup,
+                                            NULL, NULL);
+
+  hsv_label = gtk_label_new (NULL);
+  gtk_label_set_use_markup (GTK_LABEL (hsv_label), TRUE);
+  gtk_expression_bind (expression, hsv_label, "label", NULL);
+  gtk_box_append (GTK_BOX (box), hsv_label);
+
+  gtk_expression_unref (color_expression);
+}
+
+static void
+set_title (gpointer    item,
+           const char *title)
+{
+  g_object_set_data (G_OBJECT (item), "title", (gpointer)title);
+}
+
+static char *
+get_title (gpointer item)
+{
+  return g_strdup ((char *)g_object_get_data (G_OBJECT (item), "title"));
+}
+
+static gboolean
+set_item (GBinding *binding,
+          const GValue *from,
+          GValue *to,
+          gpointer data)
+{
+  GObject *source = g_binding_get_source (binding);
+  GListModel *model;
+  guint selected;
+  gpointer item;
+
+  selected = g_value_get_uint (from);
+
+  model = gtk_drop_down_get_model (GTK_DROP_DOWN (source));
+  item = g_list_model_get_item (model, selected);
+
+  g_value_set_object (to, item);
+
+  g_clear_object (&item);
+
+  return TRUE;
+}
+
+GtkWidget *
+create_color_grid (void)
+{
+  GtkWidget *gridview;
+  GtkListItemFactory *factory;
+  GListModel *model, *selection;
+
+  gridview = gtk_grid_view_new ();
+  gtk_scrollable_set_hscroll_policy (GTK_SCROLLABLE (gridview), GTK_SCROLL_NATURAL);
+  gtk_scrollable_set_vscroll_policy (GTK_SCROLLABLE (gridview), GTK_SCROLL_NATURAL);
+
+  factory = gtk_signal_list_item_factory_new ();
+  g_signal_connect (factory, "setup", G_CALLBACK (setup_simple_listitem_cb), NULL);
+  gtk_grid_view_set_factory (GTK_GRID_VIEW (gridview), factory);
+  g_object_unref (factory);
+ 
+  gtk_grid_view_set_max_columns (GTK_GRID_VIEW (gridview), 24);
+  gtk_grid_view_set_enable_rubberband (GTK_GRID_VIEW (gridview), TRUE);
+
+  model = G_LIST_MODEL (gtk_sort_list_model_new (create_colors_model (), NULL));
+  selection = G_LIST_MODEL (gtk_multi_selection_new (model));
+  gtk_grid_view_set_model (GTK_GRID_VIEW (gridview), selection);
+  g_object_unref (selection);
+  g_object_unref (model);
+
+  return gridview;
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_listview_colors (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkWidget *header, *gridview, *sw, *box, *dropdown;
+      GtkListItemFactory *factory;
+      GListStore *factories;
+      GListModel *model;
+
+      GtkSorter *sorter;
+      GtkSorter *multi_sorter;
+      GListStore *sorters;
+      GtkExpression *expression;
+
+      window = gtk_window_new ();
+      gtk_window_set_title (GTK_WINDOW (window), "Colors");
+      header = gtk_header_bar_new ();
+      gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE);
+      gtk_window_set_titlebar (GTK_WINDOW (window), header);
+
+      gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer*)&window);
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_window_set_child (GTK_WINDOW (window), sw);
+
+      gridview = create_color_grid ();
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), gridview);
+      model = gtk_grid_view_get_model (GTK_GRID_VIEW (gridview));
+      g_object_get (model, "model", &model, NULL);
+
+      sorters = g_list_store_new (GTK_TYPE_SORTER);
+
+      sorter = gtk_string_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "name"));
+      set_title (sorter, "Name");
+      g_list_store_append (sorters, sorter);
+      g_object_unref (sorter);
+
+      multi_sorter = gtk_multi_sorter_new ();
+
+      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "red"));
+      gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
+      set_title (sorter, "Red");
+      g_list_store_append (sorters, sorter);
+      gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
+
+      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "green"));
+      gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
+      set_title (sorter, "Green");
+      g_list_store_append (sorters, sorter);
+      gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
+
+      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "blue"));
+      gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
+      set_title (sorter, "Blue");
+      g_list_store_append (sorters, sorter);
+      gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
+
+      set_title (multi_sorter, "RGB");
+      g_list_store_append (sorters, multi_sorter);
+      g_object_unref (multi_sorter);
+
+      multi_sorter = gtk_multi_sorter_new ();
+
+      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "hue"));
+      gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
+      set_title (sorter, "Hue");
+      g_list_store_append (sorters, sorter);
+      gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
+
+      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "saturation"));
+      gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
+      set_title (sorter, "Saturation");
+      g_list_store_append (sorters, sorter);
+      gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
+
+      sorter = gtk_numeric_sorter_new (gtk_property_expression_new (GTK_TYPE_COLOR, NULL, "value"));
+      gtk_numeric_sorter_set_sort_order (GTK_NUMERIC_SORTER (sorter), GTK_SORT_DESCENDING);
+      set_title (sorter, "Value");
+      g_list_store_append (sorters, sorter);
+      gtk_multi_sorter_append (GTK_MULTI_SORTER (multi_sorter), sorter);
+
+      set_title (multi_sorter, "HSV");
+      g_list_store_append (sorters, multi_sorter);
+      g_object_unref (multi_sorter);
+
+      dropdown = gtk_drop_down_new ();
+      box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
+      gtk_box_append (GTK_BOX (box), gtk_label_new ("Sort by:"));
+      gtk_box_append (GTK_BOX (box), dropdown);
+      gtk_header_bar_pack_end (GTK_HEADER_BAR (header), box);
+
+      expression = gtk_cclosure_expression_new (G_TYPE_STRING,
+                                                NULL,
+                                                0, NULL,
+                                                (GCallback)get_title,
+                                                NULL, NULL);
+      gtk_drop_down_set_expression (GTK_DROP_DOWN (dropdown), expression);
+      gtk_expression_unref (expression);
+
+      gtk_drop_down_set_model (GTK_DROP_DOWN (dropdown), G_LIST_MODEL (sorters));
+      g_object_unref (sorters);
+
+      g_object_bind_property_full (dropdown, "selected",
+                                   model, "sorter",
+                                   G_BINDING_SYNC_CREATE,
+                                   set_item, NULL,
+                                   NULL, NULL);
+
+      factories = g_list_store_new (GTK_TYPE_LIST_ITEM_FACTORY);
+
+      factory = gtk_signal_list_item_factory_new ();
+      g_signal_connect (factory, "setup", G_CALLBACK (setup_simple_listitem_cb), NULL);
+      set_title (factory, "Colors");
+      g_list_store_append (factories, factory);
+
+      factory = gtk_signal_list_item_factory_new ();
+      g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
+      set_title (factory, "Everything");
+      g_list_store_append (factories, factory);
+
+      dropdown = gtk_drop_down_new ();
+      box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
+      gtk_box_append (GTK_BOX (box), gtk_label_new ("Show:"));
+      gtk_box_append (GTK_BOX (box), dropdown);
+      gtk_header_bar_pack_end (GTK_HEADER_BAR (header), box);
+
+      expression = gtk_cclosure_expression_new (G_TYPE_STRING,
+                                                NULL,
+                                                0, NULL,
+                                                (GCallback)get_title,
+                                                NULL, NULL);
+      gtk_drop_down_set_expression (GTK_DROP_DOWN (dropdown), expression);
+      gtk_expression_unref (expression);
+
+      gtk_drop_down_set_model (GTK_DROP_DOWN (dropdown), G_LIST_MODEL (factories));
+      g_object_unref (factories);
+
+      g_object_bind_property_full (dropdown, "selected",
+                                   gridview, "factory",
+                                   G_BINDING_SYNC_CREATE,
+                                   set_item, NULL,
+                                   NULL, NULL);
+      g_object_unref (model);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/listview_filebrowser.c

@@ -0,0 +1,255 @@
+/* Lists/File browser
+ *
+ * This demo shows off the different layouts that are quickly achievable
+ * with GtkListview and GtkGridView by implementing a file browser with
+ * different views.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+
+/* Create a simple object that holds the data for the different views */
+typedef struct _FileBrowserView FileBrowserView;
+struct _FileBrowserView
+{
+  GObject parent_instance;
+
+  GtkListItemFactory *factory;
+  char *icon_name;
+  GtkOrientation orientation;
+};
+
+enum {
+  PROP_0,
+  PROP_FACTORY,
+  PROP_ICON_NAME,
+  PROP_ORIENTATION,
+
+  N_PROPS
+};
+
+#define FILE_BROWSER_TYPE_VIEW (file_browser_view_get_type ())
+G_DECLARE_FINAL_TYPE (FileBrowserView, file_browser_view, FILE_BROWSER, VIEW, GObject);
+
+G_DEFINE_TYPE (FileBrowserView, file_browser_view, G_TYPE_OBJECT);
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+file_browser_view_get_property (GObject    *object,
+                                guint       property_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  FileBrowserView *self = FILE_BROWSER_VIEW (object);
+
+  switch (property_id)
+    {
+    case PROP_FACTORY:
+      g_value_set_object (value, self->factory);
+      break;
+
+    case PROP_ICON_NAME:
+      g_value_set_string (value, self->icon_name);
+      break;
+
+    case PROP_ORIENTATION:
+      g_value_set_enum (value, self->orientation);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+file_browser_view_set_property (GObject      *object,
+                                guint         prop_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  FileBrowserView *self = FILE_BROWSER_VIEW (object);
+
+  switch (prop_id)
+    {
+    case PROP_FACTORY:
+      g_set_object (&self->factory, g_value_get_object (value));
+      break;
+
+    case PROP_ICON_NAME:
+      g_free (self->icon_name);
+      self->icon_name = g_value_dup_string (value);
+      break;
+
+    case PROP_ORIENTATION:
+      self->orientation = g_value_get_enum (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+file_browser_view_finalize (GObject *object)
+{
+  FileBrowserView *self = FILE_BROWSER_VIEW (object);
+
+  g_object_unref (self->factory);
+  g_free (self->icon_name);
+
+  G_OBJECT_CLASS (file_browser_view_parent_class)->dispose (object);
+}
+
+static void
+file_browser_view_class_init (FileBrowserViewClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = file_browser_view_get_property;
+  gobject_class->set_property = file_browser_view_set_property;
+  gobject_class->finalize = file_browser_view_finalize;
+
+  properties[PROP_FACTORY] =
+    g_param_spec_object ("factory",
+                         "factory",
+                         "factory to use in the main view",
+                         GTK_TYPE_LIST_ITEM_FACTORY,
+                         G_PARAM_READWRITE);
+  properties[PROP_ICON_NAME] =
+    g_param_spec_string ("icon-name",
+                         "icon name",
+                         "icon to display for selecting this view",
+                         NULL,
+                         G_PARAM_READWRITE);
+  properties[PROP_ORIENTATION] =
+    g_param_spec_enum ("orientation",
+                       "orientation",
+                       "orientation of the view",
+                       GTK_TYPE_ORIENTATION,
+                       GTK_ORIENTATION_VERTICAL,
+                       G_PARAM_READWRITE);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void file_browser_view_init (FileBrowserView *self)
+{
+}
+
+char *
+filebrowser_get_display_name (GObject *object,
+                              GFileInfo *info)
+{
+  if (!info)
+    return NULL;
+
+  return g_strdup (g_file_info_get_attribute_string (info, "standard::display-name"));
+}
+
+char *
+filebrowser_get_content_type (GObject *object,
+                              GFileInfo *info)
+{
+  if (!info)
+    return NULL;
+
+  return g_strdup (g_file_info_get_attribute_string (info, "standard::content-type"));
+}
+
+char *
+filebrowser_get_size (GObject *object,
+                      GFileInfo *info)
+{
+  if (!info)
+    return NULL;
+
+  return g_format_size (g_file_info_get_attribute_uint64 (info, "standard::size"));
+}
+
+GIcon *
+filebrowser_get_icon (GObject *object,
+                      GFileInfo *info)
+{
+  GIcon *icon;
+
+  if (info)
+    icon = G_ICON (g_file_info_get_attribute_object (info, "standard::icon"));
+  else
+    icon = NULL;
+
+  if (icon)
+    g_object_ref (icon);
+
+  return icon;
+}
+
+void
+filebrowser_up_clicked_cb (GtkButton        *button,
+                           GtkDirectoryList *list)
+{
+  GFile *file;
+
+  file = g_file_get_parent (gtk_directory_list_get_file (list));
+  if (file == NULL)
+    return;
+
+  gtk_directory_list_set_file (list, file);
+}
+
+void
+filebrowser_view_activated_cb (GtkGridView      *view,
+                               guint             pos,
+                               GtkDirectoryList *list)
+{
+  GFileInfo *info;
+
+  info = g_list_model_get_item (gtk_grid_view_get_model (view), pos);
+  if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
+    gtk_directory_list_set_file (list, G_FILE (g_file_info_get_attribute_object (info, "standard::file")));
+
+  g_object_unref (info);
+}
+
+GtkWidget *
+do_listview_filebrowser (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkWidget *view;
+      GtkBuilder *builder;
+      GtkDirectoryList *dirlist;
+      GFile *file;
+      char *cwd;
+
+      builder = gtk_builder_new_from_resource ("/listview_filebrowser/listview_filebrowser.ui");
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+
+      /* Create the model and fill it with the contents of the current directory */
+      cwd = g_get_current_dir ();
+      file = g_file_new_for_path (cwd);
+      g_free (cwd);
+      dirlist = GTK_DIRECTORY_LIST (gtk_builder_get_object (builder, "dirlist"));
+      gtk_directory_list_set_file (dirlist, file);
+      g_object_unref (file);
+
+      /* grab focus in the view */
+      view = GTK_WIDGET (gtk_builder_get_object (builder, "view"));
+      gtk_widget_grab_focus (view);
+
+      g_object_unref (builder);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/listview_filebrowser.ui

@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GListStore" id="viewlist">
+    <property name="item-type">FileBrowserView</property>
+    <child>
+      <object class="FileBrowserView">
+        <property name="factory">
+          <object class="GtkBuilderListItemFactory">
+            <property name="bytes"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkBox">
+        <child>
+          <object class="GtkImage">
+            <binding name="gicon">
+              <closure type="GIcon" function="filebrowser_get_icon">
+                <lookup name="item">GtkListItem</lookup>
+              </closure>
+            </binding>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="halign">start</property>
+            <binding name="label">
+              <closure type="gchararray" function="filebrowser_get_display_name">
+                <lookup name="item">GtkListItem</lookup>
+              </closure>
+            </binding>
+          </object>
+        </child>
+      </object>
+    </property>
+  </template>
+</interface>
+            ]]></property>
+          </object>
+        </property>
+        <property name="icon-name">view-list-symbolic</property>
+        <property name="orientation">horizontal</property>
+      </object>
+    </child>
+    <child>
+      <object class="FileBrowserView">
+        <property name="icon-name">view-grid-symbolic</property>
+        <property name="factory">
+          <object class="GtkBuilderListItemFactory">
+            <property name="bytes"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkImage">
+            <property name="icon-size">large</property>
+            <binding name="gicon">
+              <closure type="GIcon" function="filebrowser_get_icon">
+                <lookup name="item">GtkListItem</lookup>
+              </closure>
+            </binding>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="wrap">1</property>
+            <property name="wrap-mode">word-char</property>
+            <property name="lines">2</property>
+            <property name="ellipsize">end</property>
+            <property name="width-chars">10</property>
+            <property name="max-width-chars">30</property>
+            <binding name="label">
+              <closure type="gchararray" function="filebrowser_get_display_name">
+                <lookup name="item">GtkListItem</lookup>
+              </closure>
+            </binding>
+          </object>
+        </child>
+      </object>
+    </property>
+  </template>
+</interface>
+            ]]></property>
+          </object>
+        </property>
+        <property name="orientation">vertical</property>
+      </object>
+    </child>
+    <child>
+      <object class="FileBrowserView">
+        <property name="icon-name">view-paged-symbolic</property>
+        <property name="factory">
+          <object class="GtkBuilderListItemFactory">
+            <property name="bytes"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkBox">
+        <child>
+          <object class="GtkImage">
+            <property name="icon-size">large</property>
+            <binding name="gicon">
+              <closure type="GIcon" function="filebrowser_get_icon">
+                <lookup name="item">GtkListItem</lookup>
+              </closure>
+            </binding>
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="halign">start</property>
+                <binding name="label">
+                  <closure type="gchararray" function="filebrowser_get_display_name">
+                    <lookup name="item">GtkListItem</lookup>
+                  </closure>
+                </binding>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="halign">start</property>
+                <binding name="label">
+                  <closure type="gchararray" function="filebrowser_get_size">
+                    <lookup name="item">GtkListItem</lookup>
+                  </closure>
+                </binding>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="halign">start</property>
+                <binding name="label">
+                  <closure type="gchararray" function="filebrowser_get_content_type">
+                    <lookup name="item">GtkListItem</lookup>
+                  </closure>
+                </binding>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </property>
+  </template>
+</interface>
+            ]]></property>
+          </object>
+        </property>
+        <property name="orientation">horizontal</property>
+      </object>
+    </child>
+  </object>
+  <object class="GtkDirectoryList" id="dirlist">
+    <property name="attributes">standard::name,standard::display-name,standard::icon,standard::size,standard::content-type</property>
+  </object>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">File browser</property>
+    <property name="default-width">600</property>
+    <property name="default-height">400</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar" id="">
+        <property name="show-title-buttons">1</property>
+        <child>
+          <object class="GtkButton">
+            <property name="icon-name">go-up</property>
+            <signal name="clicked" handler="filebrowser_up_clicked_cb" object="dirlist" swapped="no"/>
+          </object>
+        </child>
+        <child type="end">
+          <object class="GtkListView">
+            <property name="valign">center</property>
+            <property name="orientation">horizontal</property>
+            <style>
+              <class name="linked"/>
+            </style>
+            <property name="model">
+              <object class="GtkSingleSelection" id="selected-view">
+                <property name="model">viewlist</property>
+              </object>
+            </property>
+            <property name="factory">
+              <object class="GtkBuilderListItemFactory">
+                <property name="bytes"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkImage">
+        <binding name="icon-name">
+          <lookup type="FileBrowserView" name="icon-name">
+            <lookup name="item">GtkListItem</lookup>
+          </lookup>
+        </binding>
+      </object>
+    </property>
+  </template>
+</interface>
+                ]]></property>
+              </object>
+            </property>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkScrolledWindow">
+        <property name="can-focus">1</property>
+        <child>
+          <object class="GtkGridView" id="view">
+            <property name="model">dirlist</property>
+            <property name="max-columns">15</property>
+            <binding name="factory">
+              <lookup name="factory" type="FileBrowserView">
+                <lookup name="selected-item">selected-view</lookup>
+              </lookup>
+            </binding>
+            <binding name="orientation">
+              <lookup name="orientation" type="FileBrowserView">
+                <lookup name="selected-item">selected-view</lookup>
+              </lookup>
+            </binding>
+            <signal name="activate" handler="filebrowser_view_activated_cb" object="dirlist" swapped="no"/>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

demos/gtk-demo/listview_minesweeper.c

@@ -0,0 +1,472 @@
+/* Lists/Minesweeper
+ *
+ * This demo shows how to develop a user interface for small game using a
+ * gridview.
+ *
+ * It demonstrates how to use the activate signal and single-press behavior
+ * to implement rather different interaction behavior to a typical list.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+/*** The cell object ***/
+
+/* Create an object that holds the data for a cell in the game */
+typedef struct _SweeperCell SweeperCell;
+struct _SweeperCell
+{
+  GObject parent_instance;
+
+  gboolean is_mine;
+  gboolean is_visible;
+  guint neighbor_mines;
+};
+
+enum {
+  CELL_PROP_0,
+  CELL_PROP_LABEL,
+
+  N_CELL_PROPS
+};
+
+#define SWEEPER_TYPE_CELL (sweeper_cell_get_type ())
+G_DECLARE_FINAL_TYPE (SweeperCell, sweeper_cell, SWEEPER, CELL, GObject);
+
+G_DEFINE_TYPE (SweeperCell, sweeper_cell, G_TYPE_OBJECT);
+static GParamSpec *cell_properties[N_CELL_PROPS] = { NULL, };
+
+static const char *
+sweeper_cell_get_label (SweeperCell *self)
+{
+  static const char *minecount_labels[10] = { "", "1", "2", "3", "4", "5", "6", "7", "8", "9" };
+
+  if (!self->is_visible)
+    return "?";
+  
+  if (self->is_mine)
+    return "💣";
+
+  return minecount_labels[self->neighbor_mines];
+}
+
+static void
+sweeper_cell_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  SweeperCell *self = SWEEPER_CELL (object);
+
+  switch (property_id)
+    {
+    case CELL_PROP_LABEL:
+      g_value_set_string (value, sweeper_cell_get_label (self));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+sweeper_cell_class_init (SweeperCellClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = sweeper_cell_get_property;
+
+  cell_properties[CELL_PROP_LABEL] =
+    g_param_spec_string ("label",
+                         "label",
+                         "label to display for this row",
+                         NULL,
+                         G_PARAM_READABLE);
+
+  g_object_class_install_properties (gobject_class, N_CELL_PROPS, cell_properties);
+}
+
+static void
+sweeper_cell_init (SweeperCell *self)
+{
+}
+
+static void
+sweeper_cell_reveal (SweeperCell *self)
+{
+  if (self->is_visible)
+    return;
+
+  self->is_visible = TRUE;
+
+  g_object_notify_by_pspec (G_OBJECT (self), cell_properties[CELL_PROP_LABEL]);
+}
+
+static SweeperCell *
+sweeper_cell_new (void)
+{
+  return g_object_new (SWEEPER_TYPE_CELL, NULL);
+}
+
+/*** The board object ***/
+
+/* Create an object that holds the data for the game */
+typedef struct _SweeperGame SweeperGame;
+struct _SweeperGame
+{
+  GObject parent_instance;
+
+  GPtrArray *cells;
+  guint width;
+  guint height;
+  gboolean playing;
+  gboolean win;
+};
+
+enum {
+  GAME_PROP_0,
+  GAME_PROP_HEIGHT,
+  GAME_PROP_PLAYING,
+  GAME_PROP_WIDTH,
+  GAME_PROP_WIN,
+
+  N_GAME_PROPS
+};
+
+#define SWEEPER_TYPE_GAME (sweeper_game_get_type ())
+G_DECLARE_FINAL_TYPE (SweeperGame, sweeper_game, SWEEPER, GAME, GObject);
+
+static GType
+sweeper_game_list_model_get_item_type (GListModel *model)
+{
+  return SWEEPER_TYPE_GAME;
+}
+
+static guint
+sweeper_game_list_model_get_n_items (GListModel *model)
+{
+  SweeperGame *self = SWEEPER_GAME (model);
+
+  return self->width * self->height;
+}
+
+static gpointer
+sweeper_game_list_model_get_item (GListModel *model,
+                                  guint       position)
+{
+  SweeperGame *self = SWEEPER_GAME (model);
+
+  return g_object_ref (g_ptr_array_index (self->cells, position));
+}
+
+static void
+sweeper_game_list_model_init (GListModelInterface *iface)
+{
+  iface->get_item_type = sweeper_game_list_model_get_item_type;
+  iface->get_n_items = sweeper_game_list_model_get_n_items;
+  iface->get_item = sweeper_game_list_model_get_item;
+}
+
+G_DEFINE_TYPE_WITH_CODE (SweeperGame, sweeper_game, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (G_TYPE_LIST_MODEL, sweeper_game_list_model_init))
+
+static GParamSpec *game_properties[N_GAME_PROPS] = { NULL, };
+
+static void
+sweeper_game_dispose (GObject *object)
+{
+  SweeperGame *self = SWEEPER_GAME (object);
+
+  g_clear_pointer (&self->cells, g_ptr_array_unref);
+
+  G_OBJECT_CLASS (sweeper_game_parent_class)->dispose (object);
+}
+
+static void
+sweeper_game_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  SweeperGame *self = SWEEPER_GAME (object);
+
+  switch (property_id)
+    {
+    case GAME_PROP_HEIGHT:
+      g_value_set_uint (value, self->height);
+      break;
+
+    case GAME_PROP_PLAYING:
+      g_value_set_boolean (value, self->playing);
+      break;
+
+    case GAME_PROP_WIDTH:
+      g_value_set_uint (value, self->width);
+      break;
+
+    case GAME_PROP_WIN:
+      g_value_set_boolean (value, self->win);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+sweeper_game_class_init (SweeperGameClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->dispose = sweeper_game_dispose;
+  gobject_class->get_property = sweeper_game_get_property;
+
+  game_properties[GAME_PROP_HEIGHT] =
+    g_param_spec_uint ("height",
+                       "height",
+                       "height of the game grid",
+                       1, G_MAXUINT, 8,
+                       G_PARAM_READABLE);
+
+  game_properties[GAME_PROP_PLAYING] =
+    g_param_spec_boolean ("playing",
+                          "playing",
+                          "if the game is still going on",
+                          FALSE,
+                          G_PARAM_READABLE);
+
+  game_properties[GAME_PROP_WIDTH] =
+    g_param_spec_uint ("width",
+                       "width",
+                       "width of the game grid",
+                       1, G_MAXUINT, 8,
+                       G_PARAM_READABLE);
+
+  game_properties[GAME_PROP_WIN] =
+    g_param_spec_boolean ("win",
+                          "win",
+                          "if the game was won",
+                          FALSE,
+                          G_PARAM_READABLE);
+
+  g_object_class_install_properties (gobject_class, N_GAME_PROPS, game_properties);
+}
+
+static void
+sweeper_game_reset_board (SweeperGame *self,
+                          guint        width,
+                          guint        height)
+{
+  guint i;
+
+  g_ptr_array_set_size (self->cells, 0);
+
+  for (i = 0; i < width * height; i++)
+    {
+      g_ptr_array_add (self->cells, sweeper_cell_new ());
+    }
+
+  if (self->width != width)
+    {
+      self->width = width;
+      g_object_notify_by_pspec (G_OBJECT (self), game_properties[GAME_PROP_WIDTH]);
+    }
+  if (self->height != height)
+    {
+      self->height = height;
+      g_object_notify_by_pspec (G_OBJECT (self), game_properties[GAME_PROP_HEIGHT]);
+    }
+  if (!self->playing)
+    {
+      self->playing = TRUE;
+      g_object_notify_by_pspec (G_OBJECT (self), game_properties[GAME_PROP_PLAYING]);
+    }
+  if (self->win)
+    {
+      self->win = FALSE;
+      g_object_notify_by_pspec (G_OBJECT (self), game_properties[GAME_PROP_WIN]);
+    }
+}
+
+static void
+sweeper_game_place_mines (SweeperGame *self,
+                          guint        n_mines)
+{
+  guint i;
+
+  for (i = 0; i < n_mines; i++)
+    {
+      SweeperCell *cell;
+
+      do {
+        cell = g_ptr_array_index (self->cells, g_random_int_range (0, self->cells->len));
+      } while (cell->is_mine);
+
+      cell->is_mine = TRUE;
+    }
+}
+
+static SweeperCell *
+get_cell (SweeperGame *self,
+          guint        x,
+          guint        y)
+{
+  return g_ptr_array_index (self->cells, y * self->width + x);
+}
+
+static void
+sweeper_game_count_neighbor_mines (SweeperGame *self,
+                                   guint        width,
+                                   guint        height)
+{
+  guint x, y, x2, y2;
+
+  for (y = 0; y < height; y++)
+    {
+      for (x = 0; x < width; x++)
+        {
+          SweeperCell *cell = get_cell (self, x, y);
+
+          for (y2 = MAX (1, y) - 1; y2 < MIN (height, y + 2); y2++)
+            {
+              for (x2 = MAX (1, x) - 1; x2 < MIN (width, x + 2); x2++)
+                {
+                  SweeperCell *other = get_cell (self, x2, y2);
+
+                  if (other->is_mine)
+                    cell->neighbor_mines++;
+                }
+            }
+        }
+    }
+}
+
+static void
+sweeper_game_new_game (SweeperGame *self,
+                       guint        width,
+                       guint        height,
+                       guint        n_mines)
+{
+  guint n_items_before;
+
+  g_return_if_fail (n_mines <= width * height);
+
+  n_items_before = self->width * self->height;
+
+  g_object_freeze_notify (G_OBJECT (self));
+
+  sweeper_game_reset_board (self, width, height);
+  sweeper_game_place_mines (self, n_mines);
+  sweeper_game_count_neighbor_mines (self, width, height);
+
+  g_list_model_items_changed (G_LIST_MODEL (self), 0, n_items_before, width * height);
+
+  g_object_thaw_notify (G_OBJECT (self));
+}
+
+static void
+sweeper_game_init (SweeperGame *self)
+{
+  self->cells = g_ptr_array_new_with_free_func (g_object_unref);
+
+  sweeper_game_new_game (self, 8, 8, 10);
+}
+
+static void
+sweeper_game_end (SweeperGame *self,
+                  gboolean     win)
+{
+  if (self->playing)
+    {
+      self->playing = FALSE;
+      g_object_notify_by_pspec (G_OBJECT (self), game_properties[GAME_PROP_PLAYING]);
+    }
+  if (self->win != win)
+    {
+      self->win = win;
+      g_object_notify_by_pspec (G_OBJECT (self), game_properties[GAME_PROP_WIN]);
+    }
+}
+
+static void
+sweeper_game_check_finished (SweeperGame *self)
+{
+  guint i;
+
+  if (!self->playing)
+    return;
+
+  for (i = 0; i < self->cells->len; i++)
+    {
+      SweeperCell *cell = g_ptr_array_index (self->cells, i);
+
+      /* There's still a non-revealed cell that isn't a mine */
+      if (!cell->is_visible && !cell->is_mine)
+        return;
+    }
+
+  sweeper_game_end (self, TRUE);
+}
+
+static void
+sweeper_game_reveal_cell (SweeperGame *self,
+                          guint        position)
+{
+  SweeperCell *cell;
+
+  if (!self->playing)
+    return;
+
+  cell = g_ptr_array_index (self->cells, position);
+  sweeper_cell_reveal (cell);
+
+  if (cell->is_mine)
+    sweeper_game_end (self, FALSE);
+
+  sweeper_game_check_finished (self);
+}
+
+void
+minesweeper_cell_clicked_cb (GtkGridView *gridview,
+                             guint        pos,
+                             SweeperGame *game)
+{
+  sweeper_game_reveal_cell (game, pos);
+}
+
+void
+minesweeper_new_game_cb (GtkButton   *button,
+                         SweeperGame *game)
+{
+  sweeper_game_new_game (game, 8, 8, 10);
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_listview_minesweeper (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (SWEEPER_TYPE_GAME);
+
+      builder = gtk_builder_new_from_resource ("/listview_minesweeper/listview_minesweeper.ui");
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+
+      g_object_unref (builder);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/listview_minesweeper.ui

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="SweeperGame" id="game">
+  </object>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">Minesweeper</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar" id="">
+        <property name="show-title-buttons">1</property>
+        <child>
+          <object class="GtkButton">
+            <property name="label">New Game</property>
+            <signal name="clicked" handler="minesweeper_new_game_cb" object="game" swapped="no"/>
+          </object>
+        </child>
+        <child type="title">
+          <object class="GtkImage">
+            <property name="icon-name">trophy-gold</property>
+            <binding name="visible">
+              <lookup name="win">game</lookup>
+            </binding>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkGridView" id="view">
+        <property name="model">
+          <object class="GtkNoSelection">
+            <property name="model">game</property>
+          </object>
+        </property>
+        <property name="single-click-activate">1</property>
+        <binding name="max-columns">
+          <lookup name="width">game</lookup>
+        </binding>
+        <binding name="min-columns">
+          <lookup name="width">game</lookup>
+        </binding>
+        <property name="factory">
+          <object class="GtkBuilderListItemFactory">
+            <property name="resource">/listview_minesweeper/listview_minesweeper_cell.ui</property>
+          </object>
+        </property>
+        <signal name="activate" handler="minesweeper_cell_clicked_cb" object="game" swapped="no"/>
+      </object>
+    </child>
+  </object>
+</interface>

demos/gtk-demo/listview_minesweeper_cell.ui

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkLabel">
+        <property name="halign">center</property>
+        <property name="valign">center</property>
+        <binding name="label">
+          <lookup name="label" type="SweeperCell">
+            <lookup name="item">GtkListItem</lookup>
+          </lookup>
+        </binding>
+      </object>
+    </property>
+  </template>
+</interface>

demos/gtk-demo/listview_settings.c

@@ -0,0 +1,333 @@
+/* Lists/Settings
+ *
+ * This demo shows a settings viewer for GSettings.
+ *
+ * It demonstrates how to implement support for trees with GtkListView.
+ * It also shows how to set up sorting and filtering for columns in a
+ * GtkColumnView.
+ */
+
+#include <gtk/gtk.h>
+
+/* Create an object that wraps GSettingsSchemaKey because that's a boxed type */
+typedef struct _SettingsKey SettingsKey;
+struct _SettingsKey
+{
+  GObject parent_instance;
+
+  GSettings *settings;
+  GSettingsSchemaKey *key;
+};
+
+enum {
+  PROP_0,
+  PROP_NAME,
+  PROP_SUMMARY,
+  PROP_DESCRIPTION,
+  PROP_VALUE,
+
+  N_PROPS
+};
+
+#define SETTINGS_TYPE_KEY (settings_key_get_type ())
+G_DECLARE_FINAL_TYPE (SettingsKey, settings_key, SETTINGS, KEY, GObject);
+
+G_DEFINE_TYPE (SettingsKey, settings_key, G_TYPE_OBJECT);
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+settings_key_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  SettingsKey *self = SETTINGS_KEY (object);
+
+  switch (property_id)
+    {
+    case PROP_DESCRIPTION:
+      g_value_set_string (value, g_settings_schema_key_get_description (self->key));
+      break;
+
+    case PROP_NAME:
+      g_value_set_string (value, g_settings_schema_key_get_name (self->key));
+      break;
+
+    case PROP_SUMMARY:
+      g_value_set_string (value, g_settings_schema_key_get_summary (self->key));
+      break;
+
+    case PROP_VALUE:
+      {
+        GVariant *variant = g_settings_get_value (self->settings, g_settings_schema_key_get_name (self->key));
+        g_value_take_string (value, g_variant_print (variant, FALSE));
+        g_variant_unref (variant);
+      }
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+settings_key_finalize (GObject *object)
+{
+  SettingsKey *self = SETTINGS_KEY (object);
+
+  g_object_unref (self->settings);
+  g_settings_schema_key_unref (self->key);
+
+  G_OBJECT_CLASS (settings_key_parent_class)->finalize (object);
+}
+
+static void
+settings_key_class_init (SettingsKeyClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = settings_key_finalize;
+  gobject_class->get_property = settings_key_get_property;
+
+  properties[PROP_DESCRIPTION] =
+    g_param_spec_string ("description", NULL, NULL, NULL, G_PARAM_READABLE);
+  properties[PROP_NAME] =
+    g_param_spec_string ("name", NULL, NULL, NULL, G_PARAM_READABLE);
+  properties[PROP_SUMMARY] =
+    g_param_spec_string ("summary", NULL, NULL, NULL, G_PARAM_READABLE);
+  properties[PROP_VALUE] =
+    g_param_spec_string ("value", NULL, NULL, NULL, G_PARAM_READABLE);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+settings_key_init (SettingsKey *self)
+{
+}
+
+static SettingsKey *
+settings_key_new (GSettings          *settings,
+                  GSettingsSchemaKey *key)
+{
+  SettingsKey *result = g_object_new (SETTINGS_TYPE_KEY, NULL);
+
+  result->settings = g_object_ref (settings);
+  result->key = g_settings_schema_key_ref (key);
+
+  return result;
+}
+
+static int
+strvcmp (gconstpointer p1,
+         gconstpointer p2)
+{
+  const char * const *s1 = p1;
+  const char * const *s2 = p2;
+
+  return strcmp (*s1, *s2);
+}
+
+static GtkFilter *current_filter;
+
+static gboolean
+transform_settings_to_keys (GBinding     *binding,
+                            const GValue *from_value,
+                            GValue       *to_value,
+                            gpointer      data)
+{
+  GtkTreeListRow *treelistrow;
+  GSettings *settings;
+  GSettingsSchema *schema;
+  GListStore *store;
+  GtkSortListModel *sort_model;
+  GtkFilterListModel *filter_model;
+  GtkFilter *filter;
+  GtkExpression *expression;
+  char **keys;
+  guint i;
+
+  treelistrow = g_value_get_object (from_value);
+  if (treelistrow == NULL)
+    return TRUE;
+  settings = gtk_tree_list_row_get_item (treelistrow);
+  g_object_get (settings, "settings-schema", &schema, NULL);
+
+  store = g_list_store_new (SETTINGS_TYPE_KEY);
+
+  keys = g_settings_schema_list_keys (schema);
+
+  for (i = 0; keys[i] != NULL; i++)
+    {
+      GSettingsSchemaKey *almost_there = g_settings_schema_get_key (schema, keys[i]);
+      SettingsKey *finally = settings_key_new (settings, almost_there);
+      g_list_store_append (store, finally);
+      g_object_unref (finally);
+      g_settings_schema_key_unref (almost_there);
+    }
+
+  g_strfreev (keys);
+  g_settings_schema_unref (schema);
+  g_object_unref (settings);
+
+  sort_model = gtk_sort_list_model_new (G_LIST_MODEL (store),
+                                        gtk_column_view_get_sorter (GTK_COLUMN_VIEW (data)));
+  g_object_unref (store);
+
+  expression = gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name");
+  filter = gtk_string_filter_new ();
+  gtk_string_filter_set_expression (GTK_STRING_FILTER (filter), expression);
+  filter_model = gtk_filter_list_model_new (G_LIST_MODEL (sort_model), filter);
+  gtk_expression_unref (expression);
+  g_object_unref (sort_model);
+
+  g_set_object (&current_filter, filter);
+
+  g_object_unref (filter);
+
+  g_value_take_object (to_value, filter_model);
+
+  return TRUE;
+}
+
+static GListModel *
+create_settings_model (gpointer item,
+                       gpointer unused)
+{
+  GSettings *settings = item;
+  char **schemas;
+  GListStore *result;
+  guint i;
+
+  if (settings == NULL)
+    {
+      g_settings_schema_source_list_schemas (g_settings_schema_source_get_default (),
+                                             TRUE,
+                                             &schemas,
+                                             NULL);
+    }
+  else
+    {
+      schemas = g_settings_list_children (settings);
+    }
+
+  if (schemas == NULL || schemas[0] == NULL)
+    {
+      g_free (schemas);
+      return NULL;
+    }
+
+  qsort (schemas, g_strv_length (schemas), sizeof (char *), strvcmp);
+
+  result = g_list_store_new (G_TYPE_SETTINGS);
+  for (i = 0;  schemas[i] != NULL; i++)
+    {
+      GSettings *child;
+
+      if (settings == NULL)
+        child = g_settings_new (schemas[i]);
+      else
+        child = g_settings_get_child (settings, schemas[i]);
+
+      g_list_store_append (result, child);
+      g_object_unref (child);
+    }
+
+  g_strfreev (schemas);
+
+  return G_LIST_MODEL (result);
+}
+
+static void
+search_enabled (GtkSearchEntry *entry)
+{
+  gtk_editable_set_text (GTK_EDITABLE (entry), "");
+}
+
+static void
+search_changed (GtkSearchEntry *entry,
+                gpointer data)
+{
+  const char *text = gtk_editable_get_text (GTK_EDITABLE (entry));
+
+  if (current_filter)
+    gtk_string_filter_set_search (GTK_STRING_FILTER (current_filter), text);
+}
+
+static void
+stop_search (GtkSearchEntry *entry,
+             gpointer data)
+{
+  gtk_editable_set_text (GTK_EDITABLE (entry), "");
+
+  if (current_filter)
+    gtk_string_filter_set_search (GTK_STRING_FILTER (current_filter), "");
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_listview_settings (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkWidget *listview, *columnview;
+      GListModel *model;
+      GtkTreeListModel *treemodel;
+      GtkSingleSelection *selection;
+      GtkBuilderScope *scope;
+      GtkBuilder *builder;
+      GtkColumnViewColumn *name_column;
+      GtkSorter *sorter;
+
+      g_type_ensure (SETTINGS_TYPE_KEY);
+
+      scope = gtk_builder_cscope_new ();
+      gtk_builder_cscope_add_callback_symbol (GTK_BUILDER_CSCOPE (scope), "search_enabled", (GCallback)search_enabled);
+      gtk_builder_cscope_add_callback_symbol (GTK_BUILDER_CSCOPE (scope), "search_changed", (GCallback)search_changed);
+      gtk_builder_cscope_add_callback_symbol (GTK_BUILDER_CSCOPE (scope), "stop_search", (GCallback)stop_search);
+
+      builder = gtk_builder_new ();
+      gtk_builder_set_scope (builder, scope);
+      gtk_builder_add_from_resource (builder, "/listview_settings/listview_settings.ui", NULL);
+
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+
+      listview = GTK_WIDGET (gtk_builder_get_object (builder, "listview"));
+      columnview = GTK_WIDGET (gtk_builder_get_object (builder, "columnview"));
+      model = create_settings_model (NULL, NULL);
+      treemodel = gtk_tree_list_model_new (FALSE,
+                                           model,
+                                           TRUE,
+                                           create_settings_model,
+                                           NULL,
+                                           NULL);
+      selection = gtk_single_selection_new (G_LIST_MODEL (treemodel));
+      g_object_bind_property_full (selection, "selected-item",
+                                   columnview, "model",
+                                   G_BINDING_SYNC_CREATE,
+                                   transform_settings_to_keys,
+                                   NULL,
+                                   columnview, NULL);
+      gtk_list_view_set_model (GTK_LIST_VIEW (listview), G_LIST_MODEL (selection));
+      g_object_unref (selection);
+      g_object_unref (treemodel);
+      g_object_unref (model);
+
+      name_column = GTK_COLUMN_VIEW_COLUMN (gtk_builder_get_object (builder, "name_column"));
+      sorter = gtk_string_sorter_new (gtk_property_expression_new (SETTINGS_TYPE_KEY, NULL, "name"));
+      gtk_column_view_column_set_sorter (name_column, sorter);
+      g_object_unref (sorter);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/listview_settings.ui

@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">Settings</property>
+    <property name="default-width">640</property>
+    <property name="default-height">480</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <property name="show-title-buttons">1</property>
+        <child type="end">
+          <object class="GtkToggleButton" id="search_button">
+            <property name="icon-name">system-search-symbolic</property>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkPaned">
+        <property name="position">300</property>
+        <child>
+          <object class="GtkScrolledWindow">
+            <child>
+              <object class="GtkListView" id="listview">
+                <property name="factory">
+                  <object class="GtkBuilderListItemFactory">
+                    <property name="bytes"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkTreeExpander" id="expander">
+        <binding name="list-row">
+          <lookup name="item">GtkListItem</lookup>
+        </binding>
+        <property name="child">
+          <object class="GtkLabel">
+            <property name="xalign">0</property>
+            <binding name="label">
+              <lookup name="schema" type="GSettings">
+                <lookup name="item">expander</lookup>
+              </lookup>
+            </binding>
+          </object>
+        </property>
+      </object>
+    </property>
+  </template>
+</interface>
+                    ]]></property>
+                  </object>
+                </property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkSearchBar">
+                <property name="search-mode-enabled" bind-source="search_button" bind-property="active" bind-flags="bidirectional"/>
+                <signal name="notify::search-mode-enabled" handler="search_enabled" object="entry"/>
+                <child>
+                  <object class="GtkSearchEntry" id="entry">
+                    <signal name="search-changed" handler="search_changed"/>
+                    <signal name="stop-search" handler="stop_search"/>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow">
+                <property name="hexpand">1</property>
+                <property name="vexpand">1</property>
+                <child>
+                  <object class="GtkColumnView" id="columnview">
+                    <child>
+                      <object class="GtkColumnViewColumn" id="name_column">
+                        <property name="title">Name</property>
+                        <property name="factory">
+                          <object class="GtkBuilderListItemFactory">
+                            <property name="bytes"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkLabel">
+        <property name="xalign">0</property>
+        <binding name="label">
+          <lookup name="name" type="SettingsKey">
+            <lookup name="item">GtkListItem</lookup>
+          </lookup>
+        </binding>
+      </object>
+    </property>
+  </template>
+</interface>
+                        ]]></property>
+                          </object>
+                        </property>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkColumnViewColumn">
+                        <property name="title">Value</property>
+                        <property name="factory">
+                          <object class="GtkBuilderListItemFactory">
+                            <property name="bytes"><![CDATA[
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkLabel">
+        <property name="xalign">0</property>
+        <binding name="label">
+          <lookup name="value" type="SettingsKey">
+            <lookup name="item">GtkListItem</lookup>
+          </lookup>
+        </binding>
+      </object>
+    </property>
+  </template>
+</interface>
+                        ]]></property>
+                          </object>
+                        </property>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

demos/gtk-demo/listview_weather.c

@@ -0,0 +1,326 @@
+/* Lists/Weather
+ *
+ * This demo shows a few of the rarer features of GtkListView and
+ * how they can be used to display weather information.
+ *
+ * The hourly weather info uses a horizontal listview. This is easy
+ * to achieve because GtkListView implements the GtkOrientable interface.
+ * To make the items in the list stand out more, the listview uses
+ * separators.
+ *
+ * A GtkNoSelectionModel is used to make sure no item in the list can be
+ * selected. All other interactions with the items is still possible.
+ *
+ * The dataset used here has 70000 items.
+ */
+
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_WEATHER_INFO (gtk_weather_info_get_type ())
+
+G_DECLARE_FINAL_TYPE (GtkWeatherInfo, gtk_weather_info, GTK, WEATHER_INFO, GObject)
+
+typedef enum {
+  GTK_WEATHER_CLEAR,
+  GTK_WEATHER_FEW_CLOUDS,
+  GTK_WEATHER_FOG,
+  GTK_WEATHER_OVERCAST,
+  GTK_WEATHER_SCATTERED_SHOWERS,
+  GTK_WEATHER_SHOWERS,
+  GTK_WEATHER_SNOW,
+  GTK_WEATHER_STORM
+} GtkWeatherType;
+
+struct _GtkWeatherInfo
+{
+  GObject parent_instance;
+
+  gint64 timestamp;
+  int temperature;
+  GtkWeatherType weather_type;
+};
+
+struct _GtkWeatherInfoClass
+{
+  GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkWeatherInfo, gtk_weather_info, G_TYPE_OBJECT)
+
+static void
+gtk_weather_info_class_init (GtkWeatherInfoClass *klass)
+{
+}
+
+static void
+gtk_weather_info_init (GtkWeatherInfo *self)
+{
+}
+
+static GtkWeatherInfo *
+gtk_weather_info_new (GDateTime      *timestamp,
+                      GtkWeatherInfo *copy_from)
+{
+  GtkWeatherInfo *result;
+
+  result = g_object_new (GTK_TYPE_WEATHER_INFO, NULL);
+
+  result->timestamp = g_date_time_to_unix (timestamp);
+  if (copy_from)
+    {
+      result->temperature = copy_from->temperature;
+      result->weather_type = copy_from->weather_type;
+      g_object_unref (copy_from);
+    }
+
+  return result;
+}
+
+static GDateTime *
+parse_timestamp (const char *string,
+                 GTimeZone  *timezone)
+{
+  char *with_seconds;
+  GDateTime *result;
+
+  with_seconds = g_strconcat (string, ":00", NULL);
+  result = g_date_time_new_from_iso8601 (with_seconds, timezone);
+  g_free (with_seconds);
+
+  return result;
+}
+
+static GtkWeatherType
+parse_weather_type (const char     *clouds,
+                    const char     *precip,
+                    GtkWeatherType  fallback)
+{
+  if (strstr (precip, "SN"))
+    return GTK_WEATHER_SNOW;
+
+  if (strstr (precip, "TS"))
+    return GTK_WEATHER_STORM;
+
+  if (strstr (precip, "DZ"))
+    return GTK_WEATHER_SCATTERED_SHOWERS;
+
+  if (strstr (precip, "SH") || strstr (precip, "RA"))
+    return GTK_WEATHER_SHOWERS;
+
+  if (strstr (precip, "FG"))
+    return GTK_WEATHER_FOG;
+
+  if (g_str_equal (clouds, "M") ||
+      g_str_equal (clouds, ""))
+    return fallback;
+
+  if (strstr (clouds, "OVC") ||
+      strstr (clouds, "BKN"))
+    return GTK_WEATHER_OVERCAST;
+
+  if (strstr (clouds, "BKN") ||
+      strstr (clouds, "SCT"))
+    return GTK_WEATHER_FEW_CLOUDS;
+
+  if (strstr (clouds, "VV"))
+    return GTK_WEATHER_FOG;
+
+  return GTK_WEATHER_CLEAR;
+}
+
+static double
+parse_temperature (const char *s,
+                   double      fallback)
+{
+  char *endptr;
+  double d;
+
+  d = g_ascii_strtod (s, &endptr);
+  if (*endptr != '\0')
+    return fallback;
+
+  return d;
+}
+
+static GListModel *
+create_weather_model (void)
+{
+  GListStore *store;
+  GTimeZone *utc;
+  GDateTime *timestamp;
+  GtkWeatherInfo *info;
+  GBytes *data;
+  char **lines;
+  guint i;
+
+  store = g_list_store_new (GTK_TYPE_WEATHER_INFO);
+  data = g_resources_lookup_data ("/listview_weather/listview_weather.txt", 0, NULL);
+  lines = g_strsplit (g_bytes_get_data (data, NULL), "\n", 0);
+
+  utc = g_time_zone_new_utc ();
+  timestamp = g_date_time_new (utc, 2011, 1, 1, 0, 0, 0);
+  info = gtk_weather_info_new (timestamp, NULL);
+  g_list_store_append (store, info);
+
+  for (i = 0; lines[i] != NULL && *lines[i]; i++)
+    {
+      char **fields;
+      GDateTime *date;
+
+      fields = g_strsplit (lines[i], ",", 0);
+      date = parse_timestamp (fields[0], utc);
+      while (g_date_time_difference (date, timestamp) > 30 * G_TIME_SPAN_MINUTE)
+        {
+          GDateTime *new_timestamp = g_date_time_add_hours (timestamp, 1);
+          g_date_time_unref (timestamp);
+          timestamp = new_timestamp;
+          info = gtk_weather_info_new (timestamp, info);
+          g_list_store_append (store, info);
+        }
+
+      info->temperature = parse_temperature (fields[1], info->temperature);
+      info->weather_type = parse_weather_type (fields[2], fields[3], info->weather_type);
+      g_date_time_unref (date);
+      g_strfreev (fields);
+    }
+
+  g_strfreev (lines);
+  g_bytes_unref (data);
+  g_time_zone_unref (utc);
+
+  return G_LIST_MODEL (store);
+}
+
+static void
+setup_widget (GtkListItem *list_item,
+              gpointer     unused)
+{
+  GtkWidget *box, *child;
+
+  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_list_item_set_child (list_item, box);
+
+  child = gtk_label_new (NULL);
+  gtk_label_set_width_chars (GTK_LABEL (child), 5);
+  gtk_box_append (GTK_BOX (box), child);
+
+  child = gtk_image_new ();
+  gtk_image_set_icon_size (GTK_IMAGE (child), GTK_ICON_SIZE_LARGE);
+  gtk_box_append (GTK_BOX (box), child);
+
+  child = gtk_label_new (NULL);
+  gtk_widget_set_vexpand (child, TRUE);
+  gtk_widget_set_valign (child, GTK_ALIGN_END);
+  gtk_label_set_width_chars (GTK_LABEL (child), 4);
+  gtk_box_append (GTK_BOX (box), child);
+}
+
+static void
+bind_widget (GtkListItem *list_item,
+             gpointer     unused)
+{
+  GtkWidget *box, *child;
+  GtkWeatherInfo *info;
+  GDateTime *timestamp;
+  char *s;
+
+  box = gtk_list_item_get_child (list_item);
+  info = gtk_list_item_get_item (list_item);
+
+  child = gtk_widget_get_first_child (box);
+  timestamp = g_date_time_new_from_unix_utc (info->timestamp);
+  s = g_date_time_format (timestamp, "%R");
+  gtk_label_set_text (GTK_LABEL (child), s);
+  g_free (s);
+  g_date_time_unref (timestamp);
+
+  child = gtk_widget_get_next_sibling (child);
+  switch (info->weather_type)
+  {
+  case GTK_WEATHER_CLEAR:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-clear-symbolic");
+    break;
+  case GTK_WEATHER_FEW_CLOUDS:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-few-clouds-symbolic");
+    break;
+  case GTK_WEATHER_FOG:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-fog-symbolic");
+    break;
+  case GTK_WEATHER_OVERCAST:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-overcast-symbolic");
+    break;
+  case GTK_WEATHER_SCATTERED_SHOWERS:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-showers-scattered-symbolic");
+    break;
+  case GTK_WEATHER_SHOWERS:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-showers-symbolic");
+    break;
+  case GTK_WEATHER_SNOW:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-snow-symbolic");
+    break;
+  case GTK_WEATHER_STORM:
+    gtk_image_set_from_icon_name (GTK_IMAGE (child), "weather-storm-symbolic");
+    break;
+  default:
+    gtk_image_clear (GTK_IMAGE (child));
+    break;
+  }
+
+
+  child = gtk_widget_get_next_sibling (child);
+  s = g_strdup_printf ("%d°", info->temperature);
+  gtk_label_set_text (GTK_LABEL (child), s);
+  g_free (s);
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+create_weather_view (void)
+{
+  GtkWidget *listview;
+  GListModel *model, *selection;
+
+  listview = gtk_list_view_new_with_factory (
+  gtk_functions_list_item_factory_new (setup_widget,
+                                       bind_widget,
+                                       NULL, NULL));
+  gtk_orientable_set_orientation (GTK_ORIENTABLE (listview), GTK_ORIENTATION_HORIZONTAL);
+  gtk_list_view_set_show_separators (GTK_LIST_VIEW (listview), TRUE);
+  model = create_weather_model ();
+  selection = G_LIST_MODEL (gtk_no_selection_new (model));
+  gtk_list_view_set_model (GTK_LIST_VIEW (listview), selection);
+  g_object_unref (selection);
+  g_object_unref (model);
+
+  return listview;
+}
+
+GtkWidget *
+do_listview_weather (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkWidget *listview, *sw;;
+
+      window = gtk_window_new ();
+      gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
+      gtk_window_set_title (GTK_WINDOW (window), "Weather");
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Weather");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_window_set_child (GTK_WINDOW (window), sw);
+      listview = create_weather_view ();
+      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), listview);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/main-listitem.ui

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <property name="child">
+      <object class="GtkTreeExpander" id="expander">
+        <binding name="list-row">
+          <lookup name="item">GtkListItem</lookup>
+        </binding>
+        <property name="child">
+          <object class="GtkLabel">
+            <property name="halign">start</property>
+            <binding name="label">
+              <lookup name="title" type="GtkDemo">
+                <lookup name="item">expander</lookup>
+              </lookup>
+            </binding>
+          </object>
+        </property>
+      </object>
+    </property>
+  </template>
+</interface>

demos/gtk-demo/main.c

@@ -8,6 +8,7 @@
 #include <gtk/gtk.h>
 #include <glib/gstdio.h>
 
+#include "award.h"
 #include "demos.h"
 
 static GtkWidget *info_view;
@@ -16,18 +17,96 @@ static GtkWidget *source_view;
 static gchar *current_file = NULL;
 
 static GtkWidget *notebook;
-static GtkWidget *treeview;
+static GtkSingleSelection *selection;
 static GtkWidget *toplevel;
 
-enum {
-  NAME_COLUMN,
-  TITLE_COLUMN,
-  FILENAME_COLUMN,
-  FUNC_COLUMN,
-  STYLE_COLUMN,
-  NUM_COLUMNS
+typedef struct _GtkDemo GtkDemo;
+struct _GtkDemo
+{
+  GObject parent_instance;
+
+  const char *name;
+  const char *title;
+  const char *filename;
+  GDoDemoFunc func;
+  GListModel *children_model;
 };
 
+enum {
+  PROP_0,
+  PROP_FILENAME,
+  PROP_NAME,
+  PROP_TITLE,
+
+  N_PROPS
+};
+
+# define GTK_TYPE_DEMO (gtk_demo_get_type ())
+G_DECLARE_FINAL_TYPE (GtkDemo, gtk_demo, GTK, DEMO, GObject);
+
+G_DEFINE_TYPE (GtkDemo, gtk_demo, G_TYPE_OBJECT);
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gtk_demo_get_property (GObject    *object,
+                       guint       property_id,
+                       GValue     *value,
+                       GParamSpec *pspec)
+{
+  GtkDemo *self = GTK_DEMO (object);
+
+  switch (property_id)
+    {
+    case PROP_FILENAME:
+      g_value_set_string (value, self->filename);
+      break;
+
+    case PROP_NAME:
+      g_value_set_string (value, self->name);
+      break;
+
+    case PROP_TITLE:
+      g_value_set_string (value, self->title);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void gtk_demo_class_init (GtkDemoClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = gtk_demo_get_property;
+
+  properties[PROP_FILENAME] =
+    g_param_spec_string ("filename",
+                         "filename",
+                         "filename",
+                         NULL,
+                         G_PARAM_READABLE);
+  properties[PROP_NAME] =
+    g_param_spec_string ("name",
+                         "name",
+                         "name",
+                         NULL,
+                         G_PARAM_READABLE);
+  properties[PROP_TITLE] =
+    g_param_spec_string ("title",
+                         "title",
+                         "title",
+                         NULL,
+                         G_PARAM_READABLE);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void gtk_demo_init (GtkDemo *self)
+{
+}
+
 typedef struct _CallbackData CallbackData;
 struct _CallbackData
 {
@@ -35,6 +114,27 @@ struct _CallbackData
   GtkTreePath *path;
 };
 
+static gboolean
+gtk_demo_run (GtkDemo   *self,
+              GtkWidget *window)
+{
+  GtkWidget *result;
+
+  if (!self->func)
+    return FALSE;
+
+  result = self->func (window);
+  if (result == NULL)
+    return FALSE;
+
+  if (GTK_IS_WINDOW (result))
+    {
+      gtk_window_set_transient_for (GTK_WINDOW (result), GTK_WINDOW (window));
+      gtk_window_set_modal (GTK_WINDOW (result), TRUE);
+    }
+  return TRUE;
+}
+              
 static void
 activate_about (GSimpleAction *action,
                 GVariant      *parameter,
@@ -61,7 +161,7 @@ activate_about (GSimpleAction *action,
                           gtk_get_major_version (),
                           gtk_get_minor_version (),
                           gtk_get_micro_version ());
-  g_string_append_printf (s, "\nA link can apppear here: <http://www.gtk.org>");
+  g_string_append_printf (s, "\nA link can appear here: <http://www.gtk.org>");
 
   version = g_strdup_printf ("%s\nRunning against GTK %d.%d.%d",
                              PACKAGE_VERSION,
@@ -113,84 +213,18 @@ activate_inspector (GSimpleAction *action,
                     gpointer       user_data)
 {
   gtk_window_set_interactive_debugging (TRUE);
-}
-
-static void
-window_closed_cb (GtkWidget *window, gpointer data)
-{
-  CallbackData *cbdata = data;
-  GtkTreeIter iter;
-  PangoStyle style;
-
-  gtk_tree_model_get_iter (cbdata->model, &iter, cbdata->path);
-  gtk_tree_model_get (GTK_TREE_MODEL (cbdata->model), &iter,
-                      STYLE_COLUMN, &style,
-                      -1);
-  if (style == PANGO_STYLE_ITALIC)
-    gtk_tree_store_set (GTK_TREE_STORE (cbdata->model), &iter,
-                        STYLE_COLUMN, PANGO_STYLE_NORMAL,
-                        -1);
-
-  gtk_tree_path_free (cbdata->path);
-  g_free (cbdata);
-}
-
-static void
-run_example_for_row (GtkWidget    *window,
-                     GtkTreeModel *model,
-                     GtkTreeIter  *iter)
-{
-  PangoStyle style;
-  GDoDemoFunc func;
-  GtkWidget *demo;
-
-  gtk_tree_model_get (GTK_TREE_MODEL (model),
-                      iter,
-                      FUNC_COLUMN, &func,
-                      STYLE_COLUMN, &style,
-                      -1);
-
-  if (func)
-    {
-      gtk_tree_store_set (GTK_TREE_STORE (model),
-                          iter,
-                          STYLE_COLUMN, (style == PANGO_STYLE_ITALIC ? PANGO_STYLE_NORMAL : PANGO_STYLE_ITALIC),
-                          -1);
-      demo = (func) (window);
-
-      if (demo != NULL)
-        {
-          CallbackData *cbdata;
-
-          cbdata = g_new (CallbackData, 1);
-          cbdata->model = model;
-          cbdata->path = gtk_tree_model_get_path (model, iter);
-
-          if (GTK_IS_WINDOW (demo))
-            {
-              gtk_window_set_transient_for (GTK_WINDOW (demo), GTK_WINDOW (window));
-              gtk_window_set_modal (GTK_WINDOW (demo), TRUE);
-            }
-
-          g_signal_connect (demo, "destroy",
-                            G_CALLBACK (window_closed_cb), cbdata);
-        }
-    }
+  award ("demo-inspector");
 }
 
 static void
 activate_run (GSimpleAction *action,
               GVariant      *parameter,
-              gpointer       user_data)
+              gpointer       window)
 {
-  GtkWidget *window = user_data;
-  GtkTreeSelection *selection;
-  GtkTreeModel *model;
-  GtkTreeIter iter;
+  GtkTreeListRow *row = gtk_single_selection_get_selected_item (selection);
+  GtkDemo *demo = gtk_tree_list_row_get_item (row);
 
-  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
-  if (gtk_tree_selection_get_selected (selection, &model, &iter))
-    run_example_for_row (window, model, &iter);
+  gtk_demo_run (demo, window);
 }
 
 /* Stupid syntax highlighting.
@@ -895,124 +929,93 @@ load_file (const gchar *demoname,
 }
 
 static void
-selection_cb (GtkTreeSelection *selection,
-              GtkTreeModel     *model)
+activate_cb (GtkWidget *widget,
+             guint      position,
+             gpointer   window)
 {
-  GtkTreeIter iter;
-  char *name;
-  char *filename;
-  char *title;
+  GtkTreeListRow *row = g_list_model_get_item (gtk_list_view_get_model (GTK_LIST_VIEW (widget)), position);
+  GtkDemo *demo = gtk_tree_list_row_get_item (row);
 
-  if (! gtk_tree_selection_get_selected (selection, NULL, &iter))
-    return;
+  gtk_demo_run (demo, window);
 
-  gtk_tree_model_get (model, &iter,
-                      NAME_COLUMN, &name,
-                      TITLE_COLUMN, &title,
-                      FILENAME_COLUMN, &filename,
-                      -1);
-
-  if (filename)
-    load_file (name, filename);
-
-  gtk_window_set_title (GTK_WINDOW (toplevel), title);
-
-  g_free (name);
-  g_free (title);
-  g_free (filename);
+  g_object_unref (row);
 }
 
 static void
-populate_model (GtkTreeModel *model)
+selection_cb (GtkSingleSelection *sel,
+              GParamSpec         *pspec,
+              gpointer            user_data)
 {
-  Demo *d = gtk_demos;
+  GtkTreeListRow *row = gtk_single_selection_get_selected_item (sel);
+  GtkDemo *demo = gtk_tree_list_row_get_item (row);
 
-  /* this code only supports 1 level of children. If we
-   * want more we probably have to use a recursing function.
-   */
-  while (d->title)
+  if (demo->filename)
+    load_file (demo->name, demo->filename);
+
+  gtk_window_set_title (GTK_WINDOW (toplevel), demo->title);
+}
+
+static GListModel *
+create_demo_model (void)
+{
+  GListStore *store = g_list_store_new (GTK_TYPE_DEMO);
+  DemoData *demo = gtk_demos;
+
+  while (demo->title)
     {
-      Demo *children = d->children;
-      GtkTreeIter iter;
+      GtkDemo *d = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
+      DemoData *children = demo->children;
 
-      gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
+      d->name = demo->name;
+      d->title = demo->title;
+      d->filename = demo->filename;
+      d->func = demo->func;
 
-      gtk_tree_store_set (GTK_TREE_STORE (model),
-                          &iter,
-                          NAME_COLUMN, d->name,
-                          TITLE_COLUMN, d->title,
-                          FILENAME_COLUMN, d->filename,
-                          FUNC_COLUMN, d->func,
-                          STYLE_COLUMN, PANGO_STYLE_NORMAL,
-                          -1);
+      g_list_store_append (store, d);
 
-      d++;
-
-      if (!children)
-        continue;
-
-      while (children->title)
+      if (children)
         {
-          GtkTreeIter child_iter;
+          d->children_model = G_LIST_MODEL (g_list_store_new (GTK_TYPE_DEMO));
 
-          gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter);
+          while (children->title)
+            {
+              GtkDemo *child = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
 
-          gtk_tree_store_set (GTK_TREE_STORE (model),
-                              &child_iter,
-                              NAME_COLUMN, children->name,
-                              TITLE_COLUMN, children->title,
-                              FILENAME_COLUMN, children->filename,
-                              FUNC_COLUMN, children->func,
-                              STYLE_COLUMN, PANGO_STYLE_NORMAL,
-                              -1);
+              child->name = children->name;
+              child->title = children->title;
+              child->filename = children->filename;
+              child->func = children->func;
 
-          children++;
+              g_list_store_append (G_LIST_STORE (d->children_model), child);
+              children++;
+            }
         }
+
+      demo++;
     }
 
+  return G_LIST_MODEL (store);
 }
 
-static void
-startup (GApplication *app)
+static GListModel *
+get_child_model (gpointer item,
+                 gpointer user_data)
 {
-  GtkBuilder *builder;
-  GMenuModel *appmenu;
-  const char *ids[] = { "appmenu", NULL };
+  GtkDemo *demo = item;
 
-  builder = gtk_builder_new ();
-  gtk_builder_add_objects_from_resource (builder, "/ui/appmenu.ui", ids, NULL);
+  if (demo->children_model)
+    return g_object_ref (G_LIST_MODEL (demo->children_model));
 
-  appmenu = (GMenuModel *)gtk_builder_get_object (builder, "appmenu");
-
-  gtk_application_set_app_menu (GTK_APPLICATION (app), appmenu);
-
-  g_object_unref (builder);
-}
-
-static void
-row_activated_cb (GtkWidget         *tree_view,
-                  GtkTreePath       *path,
-                  GtkTreeViewColumn *column)
-{
-  GtkTreeIter iter;
-  GtkWidget *window;
-  GtkTreeModel *model;
-
-  window = GTK_WIDGET (gtk_widget_get_root (tree_view));
-  model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
-  gtk_tree_model_get_iter (model, &iter, path);
-
-  run_example_for_row (window, model, &iter);
+  return NULL;
 }
 
 static void
 activate (GApplication *app)
 {
   GtkBuilder *builder;
-  GtkWindow *window;
-  GtkWidget *widget;
-  GtkTreeModel *model;
-  GtkTreeIter iter;
+  GListModel *listmodel;
+  GtkTreeListModel *treemodel;
+  GtkWidget *window, *listview;
 
   static GActionEntry win_entries[] = {
     { "run", activate_run, NULL, NULL, NULL }
@@ -1020,33 +1023,35 @@ activate (GApplication *app)
 
   builder = gtk_builder_new_from_resource ("/ui/main.ui");
 
-  window = (GtkWindow *)gtk_builder_get_object (builder, "window");
-  gtk_application_add_window (GTK_APPLICATION (app), window);
+  window = (GtkWidget *)gtk_builder_get_object (builder, "window");
+  gtk_application_add_window (GTK_APPLICATION (app), GTK_WINDOW (window));
   g_action_map_add_action_entries (G_ACTION_MAP (window),
                                    win_entries, G_N_ELEMENTS (win_entries),
                                    window);
 
-  notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook");
+  notebook = GTK_WIDGET (gtk_builder_get_object (builder, "notebook"));
 
-  info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview");
-  source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview");
-  treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview");
-  model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
+  info_view = GTK_WIDGET (gtk_builder_get_object (builder, "info-textview"));
+  source_view = GTK_WIDGET (gtk_builder_get_object (builder, "source-textview"));
   toplevel = GTK_WIDGET (window);
+  listview = GTK_WIDGET (gtk_builder_get_object (builder, "listview"));
+  g_signal_connect (listview, "activate", G_CALLBACK (activate_cb), window);
 
   load_file (gtk_demos[0].name, gtk_demos[0].filename);
 
-  populate_model (model);
+  listmodel = create_demo_model ();
+  treemodel = gtk_tree_list_model_new (FALSE,
+                                       G_LIST_MODEL (listmodel),
+                                       FALSE,
+                                       get_child_model,
+                                       NULL,
+                                       NULL);
+  selection = gtk_single_selection_new (G_LIST_MODEL (treemodel));
+  g_signal_connect (selection, "notify::selected-item", G_CALLBACK (selection_cb), NULL);
+  gtk_list_view_set_model (GTK_LIST_VIEW (listview),
+                           G_LIST_MODEL (selection));
 
-  g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model);
-
-  widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection");
-  g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model);
-
-  gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter);
-  gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter);
-
-  gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview));
+  award ("demo-start");
 
   gtk_widget_show (GTK_WIDGET (window));
 
@@ -1063,7 +1068,7 @@ auto_quit (gpointer data)
 static void
 list_demos (void)
 {
-  Demo *d, *c;
+  DemoData *d, *c;
 
   d = gtk_demos;
 
@@ -1090,7 +1095,7 @@ command_line (GApplication            *app,
   const gchar *name = NULL;
   gboolean autoquit = FALSE;
   gboolean list = FALSE;
-  Demo *d, *c;
+  DemoData *d, *c;
   GDoDemoFunc func = 0;
   GtkWidget *window, *demo;
 
@@ -1219,7 +1224,6 @@ main (int argc, char **argv)
   g_application_add_main_option (G_APPLICATION (app), "list", 0, 0, G_OPTION_ARG_NONE, "List examples", NULL);
   g_application_add_main_option (G_APPLICATION (app), "autoquit", 0, 0, G_OPTION_ARG_NONE, "Quit after a delay", NULL);
 
-  g_signal_connect (app, "startup", G_CALLBACK (startup), NULL);
   g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
   g_signal_connect (app, "command-line", G_CALLBACK (command_line), NULL);
   g_signal_connect (app, "handle-local-options", G_CALLBACK (local_options), NULL);

demos/gtk-demo/main.ui

@@ -65,30 +65,12 @@
             <property name="hscrollbar-policy">never</property>
             <property name="min-content-width">150</property>
             <child>
-              <object class="GtkTreeView" id="treeview">
-                <property name="model">treestore</property>
-                <property name="headers-visible">0</property>
-                <child internal-child="selection">
-                  <object class="GtkTreeSelection" id="treeview-selection">
-                    <property name="mode">browse</property>
+              <object class="GtkListView" id="listview">
+                <property name="factory">
+                  <object class="GtkBuilderListItemFactory">
+                    <property name="resource">/ui/main-listitem.ui</property>
                   </object>
-                </child>
-                <child>
-                  <object class="GtkTreeViewColumn">
-                    <child>
-                      <object class="GtkCellRendererText"/>
-                      <attributes>
-                        <attribute name="style">4</attribute>
-                        <attribute name="text">1</attribute>
-                      </attributes>
-                    </child>
-                    <child>
-                      <object class="GtkCellRendererText">
-                        <property name="text">  </property>
-                      </object>
-                    </child>
-                  </object>
-                </child>
+                </property>
               </object>
             </child>
           </object>

demos/gtk-demo/menus.ui

@@ -1,38 +1,39 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
-  <menu id="appmenu">
-    <section>
-      <item>
-        <attribute name="label" translatable="yes">_New</attribute>
-        <attribute name="action">app.new</attribute>
-        <attribute name="accel">&lt;Control&gt;n</attribute>
-      </item>
-      <item>
-        <attribute name="label" translatable="yes">_Open</attribute>
-        <attribute name="action">app.open</attribute>
-      </item>
-      <item>
-        <attribute name="label" translatable="yes">_Save</attribute>
-        <attribute name="action">app.save</attribute>
-        <attribute name="accel">&lt;Control&gt;s</attribute>
-      </item>
-      <item>
-        <attribute name="label" translatable="yes">Save _As...</attribute>
-        <attribute name="action">app.save-as</attribute>
-        <attribute name="accel">&lt;Control&gt;s</attribute>
-      </item>
-    </section>
-    <section>
-      <item>
-        <attribute name="label" translatable="yes">_Quit</attribute>
-        <attribute name="action">app.quit</attribute>
-        <attribute name="accel">&lt;Control&gt;q</attribute>
-      </item>
-    </section>
-  </menu>
   <menu id="menubar">
     <submenu>
-      <attribute name="label" translatable="yes">_Preferences</attribute>
+      <attribute name="label" translatable="yes">_Application</attribute>
+      <section>
+        <item>
+          <attribute name="label" translatable="yes">_New</attribute>
+          <attribute name="action">app.new</attribute>
+          <attribute name="accel">&lt;Control&gt;n</attribute>
+        </item>
+        <item>
+          <attribute name="label" translatable="yes">_Open</attribute>
+          <attribute name="action">app.open</attribute>
+        </item>
+        <item>
+          <attribute name="label" translatable="yes">_Save</attribute>
+          <attribute name="action">app.save</attribute>
+          <attribute name="accel">&lt;Control&gt;s</attribute>
+        </item>
+        <item>
+          <attribute name="label" translatable="yes">Save _As...</attribute>
+          <attribute name="action">app.save-as</attribute>
+          <attribute name="accel">&lt;Control&gt;s</attribute>
+        </item>
+      </section>
+      <section>
+        <item>
+          <attribute name="label" translatable="yes">_Quit</attribute>
+          <attribute name="action">app.quit</attribute>
+          <attribute name="accel">&lt;Control&gt;q</attribute>
+        </item>
+      </section>
+    </submenu>
+    <submenu>
+      <attribute name="label" translatable="yes">_File</attribute>
       <section>
         <item>
           <attribute name="label" translatable="yes">_Prefer Dark Theme</attribute>

demos/gtk-demo/meson.build

@@ -3,6 +3,7 @@
 demos = files([
   'application_demo.c',
   'assistant.c',
+  'awardview.c',
   'builder.c',
   'clipboard.c',
   'combobox.c',
@@ -41,6 +42,13 @@ demos = files([
   'listbox.c',
   'flowbox.c',
   'list_store.c',
+  'listview_applauncher.c',
+  'listview_clocks.c',
+  'listview_colors.c',
+  'listview_filebrowser.c',
+  'listview_minesweeper.c',
+  'listview_settings.c',
+  'listview_weather.c',
   'markup.c',
   'modelbutton.c',
   'overlay.c',
@@ -84,6 +92,7 @@ demos = files([
 gtkdemo_deps = [ libgtk_dep, ]
 
 extra_demo_sources = files(['main.c',
+                            'award.c',
                             'gtkfishbowl.c',
                             'fontplane.c',
                             'gtkgears.c',
@@ -95,7 +104,7 @@ extra_demo_sources = files(['main.c',
 if harfbuzz_dep.found() and pangoft_dep.found()
   demos += files('font_features.c')
   extra_demo_sources += files(['script-names.c', 'language-names.c'])
-  gtkdemo_deps += [ harfbuzz_dep, ]
+  gtkdemo_deps += [ harfbuzz_dep, epoxy_dep ]
 endif
 
 if os_unix

demos/gtk-demo/paintable_mediastream.c

@@ -218,7 +218,7 @@ gtk_nuclear_media_stream_seek (GtkMediaStream *stream,
   gtk_media_stream_seek_success (stream);
 
   /* We also have to update our timestamp and tell the
-   * paintable interface abbout the seek
+   * paintable interface about the seek
    */
   gtk_media_stream_update (stream, nuclear->progress);
   gdk_paintable_invalidate_contents (GDK_PAINTABLE (nuclear));
@@ -263,7 +263,7 @@ gtk_nuclear_media_stream_init (GtkNuclearMediaStream *nuclear)
   /* This time, we don't have to add a timer here, because media
    * streams start paused.
    *
-   * However, media streams need to tell GTK once they are intialized,
+   * However, media streams need to tell GTK once they are initialized,
    * so we do that here.
    */
   gtk_media_stream_prepared (GTK_MEDIA_STREAM (nuclear),

demos/gtk-demo/password_entry.c

@@ -11,6 +11,8 @@
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 
+#include "award.h"
+
 static GtkWidget *entry;
 static GtkWidget *entry2;
 static GtkWidget *button;
@@ -25,6 +27,18 @@ update_button (GObject    *object,
 
   gtk_widget_set_sensitive (button,
                             text[0] != '\0' && g_str_equal (text, text2));
+
+  if (g_str_equal (text, text2) &&
+      g_ascii_strcasecmp (text, "12345") == 0)
+    award ("password-best");
+}
+
+static void
+button_pressed (GtkButton *widget,
+                GtkWidget *window)
+{
+  award ("password-correct");
+  gtk_window_destroy (GTK_WINDOW (window));
 }
 
 GtkWidget *
@@ -74,7 +88,7 @@ do_password_entry (GtkWidget *do_widget)
 
       button = gtk_button_new_with_mnemonic ("_Done");
       gtk_widget_add_css_class (button, "suggested-action");
-      g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
+      g_signal_connect (button, "clicked", G_CALLBACK (button_pressed), window);
       gtk_widget_set_sensitive (button, FALSE);
       gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);
 

demos/gtk-demo/revealer.c

@@ -25,13 +25,12 @@ static gboolean
 reveal_one (gpointer data)
 {
   GtkWidget *window = data;
-  GtkBuilder *builder;
   gchar *name;
   GtkRevealer *revealer;
 
-  builder = GTK_BUILDER (g_object_get_data (G_OBJECT (window), "builder"));
   name = g_strdup_printf ("revealer%d", count);
-  revealer = (GtkRevealer *)gtk_builder_get_object (builder, name);
+  revealer = GTK_REVEALER (g_object_get_data (G_OBJECT (window), name));
+  g_free (name);
 
   gtk_revealer_set_reveal_child (revealer, TRUE);
 
@@ -59,6 +58,7 @@ on_destroy (gpointer data)
       g_source_remove (timeout);
       timeout = 0;
     }
+
 }
 
 GtkWidget *
@@ -67,14 +67,23 @@ do_revealer (GtkWidget *do_widget)
   if (!window)
     {
       GtkBuilder *builder;
+      int i;
 
       builder = gtk_builder_new_from_resource ("/revealer/revealer.ui");
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      for (i = 0; i < 10; i++)
+        {
+          char *name = g_strdup_printf ("revealer%d", i);
+          GtkWidget *revealer = GTK_WIDGET (gtk_builder_get_object (builder, name));
+          g_object_set_data (G_OBJECT (window), name, revealer);
+          g_free (name);
+        }
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       g_signal_connect (window, "destroy",
                         G_CALLBACK (on_destroy), NULL);
-      g_object_set_data_full (G_OBJECT (window), "builder", builder, g_object_unref);
+
+      g_object_unref (builder);
     }
 
   if (!gtk_widget_get_visible (window))

demos/gtk-demo/sliding_puzzle.c

@@ -11,6 +11,9 @@
 #include "puzzlepiece.h"
 #include "paintable.h"
 
+/* Give out awards */
+#include "award.h"
+
 static GtkWidget *window = NULL;
 static GtkWidget *frame = NULL;
 static GtkWidget *choices = NULL;
@@ -156,6 +159,14 @@ check_solved (GtkWidget *grid)
   picture = gtk_grid_get_child_at (GTK_GRID (grid), pos_x, pos_y);
   gtk_picture_set_paintable (GTK_PICTURE (picture), piece);
 
+  /* Hand out a bunch of awards
+   */
+  award ("puzzle-solve");
+  if ((gdk_paintable_get_flags (piece) & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
+    award ("puzzle-solve-animated");
+  if (height * width > 20)
+    award ("puzzle-solve-large");
+
   return TRUE;
 }
 
@@ -387,9 +398,21 @@ add_choice (GtkWidget    *container,
   icon = gtk_image_new_from_paintable (paintable);
   gtk_image_set_icon_size (GTK_IMAGE (icon), GTK_ICON_SIZE_LARGE);
 
-  gtk_box_append (GTK_BOX (container), icon);
+  gtk_flow_box_insert (GTK_FLOW_BOX (container), icon, -1);
 }
 
+static void
+widget_destroyed (gpointer data,
+                  GObject *widget)
+{
+  if (data)
+    *(gpointer *) data = NULL;
+
+  if (!solved)
+    award ("puzzle-give-up");
+}
+
+
 GtkWidget *
 do_sliding_puzzle (GtkWidget *do_widget)
 {
@@ -460,7 +483,7 @@ do_sliding_puzzle (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "Sliding Puzzle");
       gtk_window_set_titlebar (GTK_WINDOW (window), header);
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_object_weak_ref (G_OBJECT (window), widget_destroyed, &window);
 
       frame = gtk_aspect_frame_new (0.5, 0.5, (float) gdk_paintable_get_intrinsic_aspect_ratio (puzzle), FALSE);
       gtk_window_set_child (GTK_WINDOW (window), frame);

demos/print-editor/print-editor.c

@@ -641,24 +641,25 @@ static GActionEntry app_entries[] = {
 
 static const gchar ui_info[] =
   "<interface>"
-  "  <menu id='appmenu'>"
-  "    <section>"
-  "      <item>"
-  "        <attribute name='label'>_About</attribute>"
-  "        <attribute name='action'>app.about</attribute>"
-  "        <attribute name='accel'>&lt;Primary&gt;a</attribute>"
-  "      </item>"
-  "    </section>"
-  "    <section>"
-  "      <item>"
-  "        <attribute name='label'>_Quit</attribute>"
-  "        <attribute name='action'>app.quit</attribute>"
-  "        <attribute name='accel'>&lt;Primary&gt;q</attribute>"
-  "      </item>"
-  "    </section>"
-  "  </menu>"
   "  <menu id='menubar'>"
   "    <submenu>"
+  "      <attribute name='label'>_Application</attribute>"
+  "      <section>"
+  "        <item>"
+  "          <attribute name='label'>_About</attribute>"
+  "          <attribute name='action'>app.about</attribute>"
+  "          <attribute name='accel'>&lt;Primary&gt;a</attribute>"
+  "        </item>"
+  "      </section>"
+  "      <section>"
+  "        <item>"
+  "          <attribute name='label'>_Quit</attribute>"
+  "          <attribute name='action'>app.quit</attribute>"
+  "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
+  "        </item>"
+  "      </section>"
+  "    </submenu>"
+  "    <submenu>"
   "      <attribute name='label'>_File</attribute>"
   "      <section>"
   "        <item>"
@@ -738,16 +739,13 @@ static void
 startup (GApplication *app)
 {
   GtkBuilder *builder;
-  GMenuModel *appmenu;
   GMenuModel *menubar;
 
   builder = gtk_builder_new ();
   gtk_builder_add_from_string (builder, ui_info, -1, NULL);
 
-  appmenu = (GMenuModel *)gtk_builder_get_object (builder, "appmenu");
   menubar = (GMenuModel *)gtk_builder_get_object (builder, "menubar");
 
-  gtk_application_set_app_menu (GTK_APPLICATION (app), appmenu);
   gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
 
   g_object_unref (builder);

demos/widget-factory/widget-factory.c

@@ -271,7 +271,7 @@ activate_about (GSimpleAction *action,
                           gtk_get_major_version (),
                           gtk_get_minor_version (),
                           gtk_get_micro_version ());
-  g_string_append_printf (s, "\nA link can apppear here: <http://www.gtk.org>");
+  g_string_append_printf (s, "\nA link can appear here: <http://www.gtk.org>");
 
   version = g_strdup_printf ("%s\nRunning against GTK %d.%d.%d",
                              PACKAGE_VERSION,

demos/widget-factory/widget-factory.ui

@@ -2169,7 +2169,7 @@ microphone-sensitivity-medium-symbolic</property>
                             </child>
                             <child>
                               <object class="GtkButton" id="selection_dialog_button">
-                                <property name="label" translatable="yes">_Select</property>
+                                <property name="label" translatable="yes">S_elect</property>
                                 <property name="use-underline">1</property>
                               </object>
                             </child>

docs/CODEOWNERS

@@ -30,9 +30,9 @@ gtk/gtkeventcontroller* @carlosg
 gtk/gtkgesture*.[ch]    @carlosg
 
 # GtkFileChooser
-gtk/gtkfilechooser*     @federico
-gtk/gtkfilesystem*      @federico
-gtk/gtkfilefilter*      @federico
+gtk/gtkfilechooser*     @federico @ebassi
+gtk/gtkfilesystem*      @federico @ebassi
+gtk/gtkfilefilter*      @federico @ebassi
 
 # GtkFontChooser
 gtk/gtkfontchooser*     @matthiasc
@@ -66,3 +66,7 @@ gtk/themes              @lapoc @jimmac
 
 # Inspector
 gtk/inspector           @otte @matthiasc
+
+# Layout managers
+gtk/gtklayout*          @ebassi
+gtk/gtkconstraint*      @ebassi

docs/CODING-STYLE.md

@@ -3,7 +3,7 @@ GTK Coding Style
 
 This document is intended to be a short description of the preferred
 coding style to be used for the GTK source code. It was strongly
-inspired by Clutter's CODING_STYLE.
+inspired by Clutter's `CODING_STYLE`.
 
 Coding style is a matter of consistency, readability and maintainance;
 coding style is also completely arbitrary and a matter of taste. This
@@ -16,22 +16,24 @@ will be clearly identified. Please, don't submit code to GTK that
 looks like any of these.
 
 Part of the rationales for these coding style rules are available either
-in the kernel CodingStyle document or in Cairo's CODING_STYLE one.
+in the kernel CodingStyle document or in Cairo's `CODING_STYLE` one.
 
 When in doubt, check the surrounding code and try to imitate it.
 
-+ Line width
+### Line width
 
 The maximum line width for source files is 80 characters, whenever possible.
 Longer lines are usually an indication that you either need a function
 or a pre-processor macro.
 
-+ Indentation
+### Indentation
 
 Each new level is indented 2 or more spaces than the previous level:
 
+```c
   if (condition)
     single_statement ();
+```
 
 This can only be achieved using space characters. It may not be achieved
 using tab characters alone, or using a combination of spaces and tabs.
@@ -44,39 +46,46 @@ Even if two spaces for each indentation level allows deeper nesting than
 8 spaces, GTK favours self-documenting function names that can take
 quite some space. For this reason you should avoid deeply nested code.
 
-+ Tab characters
+### Tab characters
 
 The tab character must always be expanded to spaces. If a literal
 tab must be used inside the source, the tab must always be interpreted
 according to its traditional meaning:
 
+```
 	Advance to the next column which is a multiple of 8.
         [ these two lines should be aligned ]
+```
 
-+ Braces
+### Braces
 
 Curly braces should not be used for single statement blocks:
 
+```c
   if (condition)
     single_statement ();
   else
     another_single_statement (arg1);
+```
 
 In case of multiple statements, curly braces should be put on another
 indentation level:
 
+```c
   if (condition)
     {
       statement_1 ();
       statement_2 ();
       statement_3 ();
     }
+```
 
 The "no block for single statements" rule has only four exceptions:
 
-  ①  if the single statement covers multiple lines, e.g. for functions with
+  1. if the single statement covers multiple lines, e.g. for functions with
      many arguments, and it is followed by else or else if:
 
+```c
   /* valid */
   if (condition)
     {
@@ -87,9 +96,11 @@ The "no block for single statements" rule has only four exceptions:
     }
   else
     another_single_statement (arg1, arg2);
+```
 
-  ②  if the condition is composed of many lines:
+  2. if the condition is composed of many lines:
 
+```c
   /* valid */
   if (condition1 ||
       (condition2 && condition3) ||
@@ -98,10 +109,12 @@ The "no block for single statements" rule has only four exceptions:
     {
       a_single_statement ();
     }
+```
 
-  ③  Nested if's, in which case the block should be placed on the
+  3. Nested if's, in which case the block should be placed on the
      outermost if:
 
+```c
   /* valid */
   if (condition)
     {
@@ -117,10 +130,12 @@ The "no block for single statements" rule has only four exceptions:
       single_statement ();
     else if (yet_another_condition)
       another_single_statement ();
+```
 
-  ④  If either side of an if-else statement has braces, both sides
+  4.  If either side of an if-else statement has braces, both sides
      should, to match up indentation:
 
+```c
   /* valid */
   if (condition)
     {
@@ -140,10 +155,12 @@ The "no block for single statements" rule has only four exceptions:
     }
   else
     baz ();
+```
 
 In general, new blocks should be placed on a new indentation level,
 like:
 
+```c
   int retval = 0;
 
   statement_1 ();
@@ -157,10 +174,12 @@ like:
 
     retval = res ? -1 : 1;
   }
+```
 
 While curly braces for function definitions should rest on a new line
 they should not add an indentation level:
 
+```c
   /* valid */
   static void
   my_function (int argument)
@@ -180,18 +199,23 @@ they should not add an indentation level:
     {
       do_my_things ();
     }
+```
 
 Curly braces must not be placed on the same line as a condition:
 
+```c
   /* invalid */
   if (condition) {
     statement_1 ();
     statement_2 ();
   }
-+ Conditions
+```
+
+### Conditions
 
 Do not check boolean values for equality:
 
+```c
   /* invalid */
   if (condition == TRUE)
     do_foo ();
@@ -199,9 +223,11 @@ Do not check boolean values for equality:
   /* valid */
   if (another_condition)
     do_bar ();
+```
 
 Even if C handles NULL equality like a boolean, be explicit:
 
+```c
   /* valid */
   if (some_pointer == NULL)
     do_blah ();
@@ -209,10 +235,12 @@ Even if C handles NULL equality like a boolean, be explicit:
   /* invalid */
   if (some_other_pointer)
     do_blurp ();
+```
 
 In case of conditions split over multiple lines, the logical operators should
 always go at the end of the line:
 
+```c
   /* invalid */
   if (condition1
       || condition2
@@ -228,37 +256,45 @@ always go at the end of the line:
     {
       do_blah ();
     }
+```
 
-+ Functions
+### Functions
 
 Functions should be declared by placing the returned value on a separate
 line from the function name:
 
+```c
   void
   my_function (void)
   {
   }
+```
 
 The arguments list must be broken into a new line for each argument,
 with the argument names right aligned, taking into account pointers:
 
+```c
   void
   my_function (some_type_t     type,
                another_type_t *a_pointer,
                final_type_t    another_type)
   {
   }
+```
 
 The alignment also holds when invoking a function without breaking the
 80 characters limit:
 
+```c
   align_function_arguments (first_argument,
                             second_argument,
                             third_argument);
+```
 
 To respect the 80 characters limit do not break the function name from
 the arguments:
 
+```c
   /* invalid */
   a_very_long_function_name_with_long_parameters
     (argument_the_first, argument_the_second);
@@ -267,11 +303,13 @@ the arguments:
   first_a = argument_the_first;
   second_a = argument_the_second;
   a_very_long_function_name_with_long_parameters (first_a, second_a);
+```
 
-+ Whitespace
+### Whitespace
 
 Always put a space before a parenthesis but never after:
 
+```c
   /* valid */
   if (condition)
     do_my_things ();
@@ -288,11 +326,13 @@ Always put a space before a parenthesis but never after:
   /* invalid */
   if ( condition )
     do_my_things ( );
+```
 
-A switch() should open a block on a new indentation level, and each case
+A `switch()` should open a block on a new indentation level, and each case
 should start on the same indentation level as the curly braces, with the
 case block on a new indentation level:
 
+```c
   /* valid */
   switch (condition)
     {
@@ -330,10 +370,12 @@ case block on a new indentation level:
       do_bar ();
       break;
     }
+```
 
 It is preferable, though not mandatory, to separate the various cases with
 a newline:
 
+```c
   switch (condition)
     {
     case FOO:
@@ -347,13 +389,15 @@ a newline:
     default:
       do_default ();
     }
+```
 
-The 'break' statement for the default: case is not mandatory.
+The `break` statement for the `default:` case is not mandatory.
 
 If a case block needs to declare new variables, the same rules as the
 inner blocks (see above) apply; the break statement should be placed
 outside of the inner block:
 
+```c
   switch (condition)
     {
     case FOO:
@@ -366,10 +410,12 @@ outside of the inner block:
 
     ...
     }
+```
 
 When declaring a structure type use newlines to separate logical sections
 of the structure:
 
+```c
   struct _GtkWrapBoxPrivate
   {
     GtkOrientation        orientation;
@@ -386,13 +432,15 @@ of the structure:
 
     GList                *children;
   };
-
+```
 
 Do not eliminate whitespace and newlines just because something would
 fit on 80 characters:
 
+```c
   /* invalid */
   if (condition) foo (); else bar ();
+```
 
 Do eliminate trailing whitespace on any line, preferably as a separate
 patch or commit. Never use empty lines at the beginning or at the end of
@@ -402,45 +450,56 @@ Do enable the default git pre-commit hook that detect trailing
 whitespace for you and help you to avoid corrupting GTK's tree with
 it. Do that as follows:
 
+```
   chmod a+x .git/hooks/pre-commit
+```
 
 You might also find the git-stripspace utility helpful which acts as a
 filter to remove trailing whitespace as well as initial, final, and
 duplicate blank lines.
 
-+ Headers
+### Headers
 
 Headers are special, for GTK, in that they don't have to obey the
 80 characters limit. The only major rule for headers is that the function
 definitions should be vertically aligned in three columns:
 
+```c
   return value          function_name           (type   argument,
                                                  type   argument,
                                                  type   argument);
+```
 
 The maximum width of each column is given by the longest element in the
 column:
 
+```c
   void         gtk_type_set_property (GtkType      *type,
                                       const gchar  *value,
                                       GError      **error);
   const gchar *gtk_type_get_property (GtkType      *type);
+```
 
 It is also possible to align the columns to the next tab:
 
+```c
   void          gtk_type_set_prop           (GtkType *type,
                                              gfloat   value);
   gfloat        gtk_type_get_prop           (GtkType *type);
   gint          gtk_type_update_foobar      (GtkType *type);
+```
 
 Public headers should never be included directly:
 
+```c
   #if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
   #error "Only <gtk/gtk.h> can be included directly."
   #endif
+```
 
 Private headers should include the public header first, if one exists:
 
+```c
   #ifndef __GTK_FOO_PRIVATE_H__
   #define __GTK_FOO_PRIVATE_H__
 
@@ -449,22 +508,28 @@ Private headers should include the public header first, if one exists:
   ...
 
   #endif /* __GTK_FOO_PRIVATE_H__ */
+```
 
 All headers should have inclusion guards:
 
+```c
   #ifndef __GTK_FOO_H__
   #define __GTK_FOO_H__
 
   ...
 
   #endif /* __GTK_FOO_H__ */
+```
 
-You can also use the "once" pragma instead of the classic pre-processor guard:
+You can also use the `once` pragma instead of the classic pre-processor guard:
 
+```c
   #pragma once
+```
 
 Additionally, public headers should use C++ guards around their declarations:
 
+```c
   G_BEGIN_DECLS
 
   GDK_AVAILABLE_IN_ALL
@@ -476,8 +541,9 @@ Additionally, public headers should use C++ guards around their declarations:
   ...
 
   G_END_DECLS
+```
 
-+ Includes
+### Includes
 
 GTK source files must never include the global gtk.h header; instead, it
 should include the individual headers that are needed.
@@ -486,15 +552,18 @@ Every source file must include config.h first, followed by the header matching
 the source file, either the public installed header, or the private header, if
 it exists.
 
+```c
   #include "config.h"
 
   #include "gtkfoo.h"
+```
 
 Source files should then include project headers, in alphabetical order,
 starting from headers in the current directory; then headers in
 sub-directories; and, finally, in paths relative to the top-level
 directory:
 
+```c
   #include "config.h"
 
   #include "gtkfooprivate.h"
@@ -505,9 +574,11 @@ directory:
   #include "a11y/gtkwidgetaccessible.h"
 
   #include "gdk/gdkwindowprivate.h"
+```
 
 Finally, source files should include the system headers last:
 
+```c
   #include "config.h"
 
   #include "gtkbarprivate.h"
@@ -521,47 +592,56 @@ Finally, source files should include the system headers last:
 
   #include <graphene.h>
   #include <string.h>
+```
 
 Cyclic dependencies should be avoided if at all possible; for instance, you
 could use additional headers to break cycles.
 
-+ GObject
+### GObject
 
 GObject classes definition and implementation require some additional
 coding style notices.
 
 Typedef declarations should be placed at the beginning of the file:
 
+```c
   typedef struct _GtkFoo          GtkFoo;
   typedef struct _GtkFooClass     GtkFooClass;
+```
 
 This includes enumeration types:
 
+```c
   typedef enum
   {
     GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
     GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH
   } GtkSizeRequestMode;
+```
 
 And callback types:
 
+```c
   typedef void (* GtkCallback) (GtkWidget *widget,
                                 gpointer   user_data);
+```
 
 Instance structures should only contain the parent type:
 
+```c
   struct _GtkFoo
   {
     GtkWidget parent_instance;
   };
+```
 
-You should use the G_DECLARE_DERIVABLE_TYPE() and G_DECLARE_FINAL_TYPE()
+You should use the `G_DECLARE_DERIVABLE_TYPE()` and `G_DECLARE_FINAL_TYPE()`
 macros in newly written headers.
 
-Inside your source file, always use the G_DEFINE_TYPE(),
-G_DEFINE_TYPE_WITH_PRIVATE(), and G_DEFINE_TYPE_WITH_CODE() macros, or their
-abstract variants G_DEFINE_ABSTRACT_TYPE(),
-G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(), and G_DEFINE_ABSTRACT_TYPE_WITH_CODE();
+Inside your source file, always use the `G_DEFINE_TYPE()`,
+`G_DEFINE_TYPE_WITH_PRIVATE()`, and `G_DEFINE_TYPE_WITH_CODE()` macros, or their
+`abstract variants G_DEFINE_ABSTRACT_TYPE()`,
+`G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE()`, and `G_DEFINE_ABSTRACT_TYPE_WITH_CODE()`;
 also, use the similar macros for defining interfaces, quarks, and boxed types.
 
 All the properties should be stored inside the private data structure, which
@@ -572,34 +652,39 @@ installed.
 The private data structure should only be accessed internally either using the
 pointer inside the instance structure, for legacy code, or the generated
 instance private data getter function for your type. You should never use the
-G_TYPE_INSTANCE_GET_PRIVATE() macro or the g_type_instance_get_private()
+`G_TYPE_INSTANCE_GET_PRIVATE()` macro or the `g_type_instance_get_private()`
 function.
 
 Interface types should always have the dummy typedef for cast purposes:
 
+```c
         typedef struct _GtkFoo                  GtkFoo;
+```
 
 The interface structure should have "Interface" postfixed to the dummy typedef:
 
+```c
         typedef struct _GtkFooInterface         GtkFooInterface;
+```
 
 Interfaces must have the following macros:
 
-        - Macro:                                - Expands to:
-        • GTK_TYPE_<iface_name>             <iface_name>_get_type
-        • GTK_<iface_name>                  G_TYPE_CHECK_INSTANCE_CAST
-        • GTK_IS_<iface_name>               G_TYPE_CHECK_INSTANCE_TYPE
-        • GTK_<iface_name>_GET_IFACE        G_TYPE_INSTANCE_GET_INTERFACE
+| Macro                        | Expands to                      |
+|------------------------------|---------------------------------|
+| `GTK_TYPE_<iface_name>`      | `<iface_name>_get_type`         |
+| `GTK_<iface_name>`           | `G_TYPE_CHECK_INSTANCE_CAST`    |
+| `GTK_IS_<iface_name>`        | `G_TYPE_CHECK_INSTANCE_TYPE`    |
+| `GTK_<iface_name>_GET_IFACE` | `G_TYPE_INSTANCE_GET_INTERFACE` |
 
-+ Memory allocation
+### Memory allocation
 
-When dynamically allocating data on the heap either use g_new() or,
-if allocating multiple small data structures, g_slice_new().
+When dynamically allocating data on the heap either use `g_new()` or,
+if allocating multiple small data structures, `g_slice_new()`.
 
 Public structure types should always be returned after being zero-ed,
-either explicitly for each member, or by using g_new0() or g_slice_new0().
+either explicitly for each member, or by using `g_new0()` or `g_slice_new0()`.
 
-+ Macros
+### Macros
 
 Try to avoid private macros unless strictly necessary. Remember to #undef
 them at the end of a block or a series of functions needing them.
@@ -608,9 +693,9 @@ Inline functions are usually preferable to private macros.
 
 Public macros should not be used unless they evaluate to a constant.
 
-+ Symbol visibility
+### Symbol visibility
 
-Any symbol that is not explicitly annotated using a GDK_AVAILABLE_IN_*
+Any symbol that is not explicitly annotated using a `GDK_AVAILABLE_IN_*`
 macro is considered internal, and not exported in the shared library.
 
 Never export variables as public API, since this is cumbersome on some
@@ -622,11 +707,12 @@ should be declared in a private header file.
 Non-exported functions that are only needed in one source file
 should be declared static.
 
-+ Documentation
+### Documentation
 
 All public APIs must have gtk-doc comments. For functions, these should
 be placed in the source file, directly above the function.
 
+```c
   /* valid */
   /**
    * gtk_get_flow:
@@ -645,6 +731,7 @@ be placed in the source file, directly above the function.
     ...
 
   }
+```
 
 Doc comments for macros, function types, class structs, etc should be
 placed next to the definitions, typically in headers.
@@ -652,6 +739,7 @@ placed next to the definitions, typically in headers.
 Section introductions should be placed in the source file they describe,
 after the license header:
 
+```c
   /* valid */
   /**
    * SECTION:gtksizerequest
@@ -662,15 +750,19 @@ after the license header:
    * width-for-height) geometry management system.
    * ...
    */
+```
 
 To properly document a new function, macro, function type or struct,
-it needs to be listed in the gtk3-sections.txt file.
+it needs to be listed in the `sections.txt` file.
 
 To properly document a new class, it needs to be given its own section
-in gtk3-sections.txt, needs to be included in gtk-docs.sgml, and the
-get_type function needs to listed in gtk3.types.
+in the sections.txt, needs to be included in the `docs.xml` file, and the
+`get_type` function needs to listed in the `.types` file.
 
-+ Old code
+For more information on the documentation style and contribution guidelines,
+please [follow the corresponding contribution guide](./reference/README.md).
+
+### Old code
 
 New code that is being added to GTK should adhere to the style
 explained above. Existing GTK code does largely follow these

docs/RELEASE-HOWTO.md

@@ -118,9 +118,3 @@ $ ssh matthiasc@master.gnome.org ftpadmin install gtk-4.2.0.tar.xz
     create a new message in the same form, replacing version numbers,
     commentary at the top about "what this release is about" and the
     summary of changes.
-
-  17. Send it to gnome-announce-list, gtk-list, gtk-app-devel-list and
-    gtk-devel-list. Set reply-to to desktop-devel-list.
-
-  18. Add a link to the release announcement to www.gtk.org which lives
-    in the gtk-web git module.

docs/reference/README.md

@@ -0,0 +1,211 @@
+# How to contribute to GTK's documentation
+
+The GTK documentation is divided in two major components:
+
+ - the API reference, which is generated from special comments in the GTK
+   source code
+ - static pages that provide an overview of specific sections of the API
+
+In both cases, the contents are parsed, converted into DocBook format, and
+cross-linked in order to match types, functions, signals, and properties.
+From the DocBook output, we generate HTML, which can be used to read the
+documentation both offline and online.
+
+In both cases, contributing to the GTK documentation requires modifying
+files tracked in the source control repository, and follows the same steps
+as any other code contribution as outlined in the GTK [contribution
+guide][contributing]. Please, refer to that document for any further
+question on the mechanics of contributing to GTK.
+
+GTK uses [gtk-doc][gtkdoc] to generate its documentation. Please, visit the
+gtk-doc website to read the project's documentation.
+
+[contributing]: ../../CONTRIBUTING.md
+[gtkdoc]: https://wiki.gnome.org/DocumentationProject/GtkDoc
+
+## Contributing to the API reference
+
+Whenever you need to add or modify the documentation of a type or a
+function, you will need to edit a `gtk-doc` comment stanza, typically right
+above the type or function declaration. For instance:
+
+```c
+/**
+ * gtk_foo_set_bar:
+ * @self: a #GtkFoo
+ * @bar: a #GtkBar
+ *
+ * Sets the given #GtkBar instance on a #GtkFoo widget.
+ */
+void
+gtk_foo_set_bar (GtkFoo *self,
+		 GtkBar *bar)
+{
+  ...
+```
+
+Or, for types:
+
+```c
+/**
+ * GtkFoo:
+ *
+ * A foo widget instance.
+ *
+ * The contents of this structure are private and should never
+ * be accessed directly.
+ */
+struct _GtkFoo
+{
+  GtkWidget parent_instance;
+};
+```
+
+Each public function and type in the GTK API reference must be listed in the
+`sections.txt` file for the specific namespace to which it belongs: GDK,
+GSK, or GTK. For instance, if you add a function named `gtk_foo_set_bar()`,
+you will need to:
+
+ 1. open `docs/reference/gtk/gtk4-sections.txt`
+ 1. find the section that lists the symbols of the `GtkFoo` type
+ 1. add `gtk_foo_set_bar` to the list
+
+New classes require:
+
+ 1. a new section in the `sections.txt` file
+ 1. the `get_type` function added to the `.types` file
+ 1. an `xinclude` element in the `docs.xml` file
+
+The GTK documentation also contains a number of 'freestanding' chapters
+for which the source is in .md files in docs/reference/gtk.
+
+## Style guide
+
+Like the [coding style][coding], these rules try to formalize the existing
+documentation style; in general, you should only ever modify existing code
+that does not match the rules if you're already changing that code for
+unrelated reasons.
+
+[coding]: ../CODING-STYLE.md
+
+### Syntax
+
+The input syntax for GTK documentation is markdown, in a flavor that is
+similar to what you see on gitlab or github. The markdown support for
+fragments that are extracted from sources is more limited than for
+freestanding chapters. As an exception, man pages for tools are currently
+maintained in docbook, since the conversion from markdown to docbook is
+losing too much of the expected formatting.
+
+In addition to typical markdown formatting such as \*emphasis\* or \_italics\_,
+gtk-doc supports a few abbreviations for cross-references and formatting:
+
+`#ClassName`
+ : Creates a link to the docs for a class
+
+`function()`
+ : Creates a link to the docs for a function
+
+`%constant`
+ : Generates suitable markup for enum values or constants
+
+### Sections
+
+ - The "section" of each type must contain a name, to be referenced in the
+   `sections.txt` file; a title; and a short description. For instance:
+
+```c
+/**
+ * SECTION:gtkshortcut
+ * @Title: GtkShortcut
+ * @Short_desc: A key shortcut
+ *
+ * ...
+```
+
+   For classes, the title should be the name of the class. While it's
+   possible to add section titles directly to the `sections.txt` file, this
+   is considered deprecated, and should not be done for newly written code.
+ - For classes, the long description should contain an overview of the type;
+   what it does; typical use cases; and idiomatic examples of its use.
+ - For widget classes, the long description of a section should also contain:
+   - special XML elements and attributes parsed by the class, in case of a
+     custom GtkBuildable implementation
+   - the CSS element name to be used by selectors
+   - the CSS selector hierarchy for children, in case of a composite widget
+
+### Functions
+
+ - The argument names must match in the declaration, definition, and
+   documentation stanza.
+ - The description should refer to the function as the subject, e.g.:
+
+```
+Adds a shortcut to the shortcuts controller.
+```
+
+   Or:
+
+```
+Checks whether the widget is set to be visible or not.
+```
+
+### Methods
+
+ - Methods are special functions whose first argument is always the instance
+   of a certain class. The instance argument for newly written code should be
+   called `self`.
+ - If a method is a setter or a getter for an object property, link the
+   property in the methods's description.
+ - If a method changes one or more properties as side effect, link those
+   properties in the method's description
+ - If a method is a signal emitter, link the signal in the method's
+   description.
+
+### Signals
+
+ - While GObject can introspect argument and return types for signals,
+   you should *always* document them with an explicit gtk-doc stanza.
+ - The syntax for signal stanzas is similar to functions:
+
+```c
+/**
+ * GtkFoo::signal-name:
+ * @arg1: ...
+ * @arg2: ...
+ *
+ * ...
+```
+
+### Properties
+
+ - While GObject properties contain text that can be extracted
+   programmatically in order to build their documentation, you should
+   *always* document them with an explicit gtk-doc stanza. The text
+   associated to the property is short and meant to be used when
+   programmatically building user interfaces, and not for documentation
+   purposes.
+ - Always note if setting a property has side effects, like causing another
+   property to change state.
+ - The syntax for property documentation is:
+
+```c
+/**
+ * GtkFoo:property-name:
+ *
+ * ...
+```
+
+### Actions
+
+ - Actions are new in GTK 4, and gtk-doc had to learn a new syntax
+   to document them:
+
+```
+/**c
+ * GtkFoo|action-name:
+ * @arg1: ...
+ * @arg2: ...
+ *
+ * ...
+```

docs/reference/gdk/gdk4-sections.txt

@@ -79,10 +79,6 @@ gdk_display_sync
 gdk_display_flush
 gdk_display_close
 gdk_display_is_closed
-gdk_display_get_event
-gdk_display_peek_event
-gdk_display_put_event
-gdk_display_has_pending
 gdk_display_is_rgba
 gdk_display_is_composited
 gdk_display_get_default_group
@@ -99,9 +95,13 @@ gdk_display_get_setting
 gdk_display_get_startup_notification_id
 gdk_display_setup_window_visual
 
+<SUBSECTION>
+gdk_display_put_event
+
 <SUBSECTION>
 gdk_display_map_keyval
 gdk_display_map_keycode
+gdk_display_translate_key
 
 <SUBSECTION Standard>
 GDK_DISPLAY
@@ -174,7 +174,6 @@ gdk_rgba_get_type
 GdkSurface
 GdkGravity
 GdkSurfaceEdge
-GdkSurfaceTypeHint
 GdkSurfaceState
 gdk_surface_new_toplevel
 gdk_surface_new_popup
@@ -470,7 +469,6 @@ gdk_seat_capabilities_get_type
 <FILE>events</FILE>
 GdkEvent
 GdkEventType
-GdkEventMask
 GdkKeyMatch
 GdkTouchpadGesturePhase
 GdkScrollDirection

docs/reference/gtk/actions.md

@@ -0,0 +1,222 @@
+# Overview of actions in GTK {#actions-overview}
+
+This chapter describes in detail how GTK uses actions to connect
+activatable UI elements to callbacks. GTK inherits the underlying
+architecture of GAction and GMe:u for describing abstract actions
+and menus from the GIO library.
+
+## Basics about actions
+
+A GAction is essentially a way to tell the toolkit about a piece of
+functionality in your program, and to give it a name.
+
+Actions are purely functional. They do not contain any presentational
+information.
+
+An action has four pieces of information associated with it:
+
+- a name as an identifier (usually all-lowercase, untranslated
+  English string)
+- an enabled flag indicating if the action can be activated or not
+  (like the "sensitive" property on widgets)
+- an optional state value, for stateful actions (like a boolean for
+  toggles)
+- an optional parameter type, used when activating the action
+
+An action supports two operations. You can activate it, which requires
+passing a parameter of the correct type And you can request to change
+the actions state (for stateful actions) to a new state value of the
+correct type.
+
+Here are some rules about an action:
+
+- the name is immutable (in the sense that it will never change) and
+  it is never %NULL
+- the enabled flag can change
+- the parameter type is immutable
+- the parameter type is optional: it can be %NULL
+- if the parameter type is %NULL then action activation must be done
+  without a parameter (ie: a %NULL GVariant pointer)
+- if the parameter type is non-%NULL then the parameter must have this
+  type
+- the state can change, but it cannot change type
+- if the action was stateful when it was created, it will always have a
+  state and it will always have exactly the same type (such as boolean
+  or string)
+- if the action was stateless when it was created, it can never have a
+  state
+- you can only request state changes on stateful actions and it is only
+  possible to request that the state change to a value of the same type
+  as the existing state
+
+An action does not have any sort of presentational information such as
+a label, an icon or a way of creating a widget from it.
+
+## Action state and parameters
+
+Most actions in your application will be stateless actions with no
+parameters. These typically appear as menu items with no special
+decoration. An example is "quit".
+
+Stateful actions are used to represent an action which has a
+closely-associated state of some kind. A good example is a "fullscreen"
+action. For this case, you would expect to see a checkmark next to the
+menu item when the fullscreen option is active. This is usually called
+a toggle action, and it has a boolean state. By convention, toggle actions
+have no parameter type for activation: activating the action always toggles
+the state.
+
+Another common case is to have an action representing a enumeration of
+possible values of a given type (typically string). This is often called
+a radio action and is usually represented in the user interface with radio
+buttons or radio menu items, or sometimes a combobox. A good example is
+"text-justify" with possible values "left", "center", and "right". By
+convention, these types of actions have a parameter type equal to their
+state type, and activating them with a particular parameter value is
+equivalent to changing their state to that value.
+
+This approach to handling radio buttons is different than many other
+action systems such as GtkAction. With GAction, there is only one action
+for "text-justify" and "left", "center" and "right" are possible states on
+that action. There are not three separate "justify-left", "justify-center"
+and "justify-right" actions.
+
+The final common type of action is a stateless action with a parameter.
+This is typically used for actions like "open-bookmark" where the parameter
+to the action would be the identifier of the bookmark to open.
+
+Because some types of actions cannot be invoked without a parameter, it is
+often important to specify a parameter when referring to the action from
+a place where it will be invoked (such as from a radio button that sets
+the state to a particular value or from a menu item that opens a specific
+bookmark). In these contexts, the value used for the action parameter is
+typically called the target of the action.
+
+Even though toggle actions have a state, they do not have a parameter.
+Therefore, a target value is not needed when referring to them — they
+will always be toggled on activation.
+
+Most APIs that allow using a GAction (such as GMenuModel and GtkActionable)
+allow use of detailed action names. This is a convenient way of specifying
+an action name and an action target with a single string.
+
+In the case that the action target is a string with no unusual characters
+(ie: only alpha-numeric, plus '-' and '.') then you can use a detailed
+action name of the form "justify::left" to specify the justify action with
+a target of left.
+
+In the case that the action target is not a string, or contains unusual
+characters, you can use the more general format "action-name(5)", where the
+"5" here is any valid text-format GVariant (ie: a string that can be parsed
+by g_variant_parse()). Another example is "open-bookmark('http://gnome.org/')".
+
+You can convert between detailed action names and split-out action names
+and target values using g_action_parse_detailed_name() and
+g_action_print_detailed_name() but usually you will not need to. Most APIs
+will provide both ways of specifying actions with targets.
+
+## Action scopes
+
+Actions are always scoped to a particular object on which they operate.
+
+In GTK, actions are typically scoped to either an application or a window,
+but any widget can have actions associated with it.
+
+Actions scoped to windows should be the actions that specifically impact
+that window. These are actions like "fullscreen" and "close", or in the
+case that a window contains a document, "save" and "print".
+
+Actions that impact the application as a whole rather than one specific
+window are scoped to the application. These are actions like "about" and
+"preferences".
+
+If a particular action is scoped to a window then it is scoped to a
+specific window. Another way of saying this: if your application has a
+"fullscreen" action that applies to windows and it has three windows,
+then it will have three fullscreen actions: one for each window.
+
+Having a separate action per-window allows for each window to have a
+separate state for each instance of the action as well as being able to
+control the enabled state of the action on a per-window basis.
+
+Actions are added to their relevant scope (application, window or widget)
+either using the GActionMap interface, or by using
+gtk_widget_insert_action_group(). Actions that will be the same for all
+instances of a widget class can be added globally using
+gtk_widget_class_install_action().
+
+## Action groups and action maps
+
+Actions rarely occurs in isolation. It is common to have groups
+of related actions, which are represented by instances of the
+GActionGroup interface.
+
+Action maps are a variant of action groups that allow to change
+the name of the action as it is looked up. In GTK, the convention
+is to add a prefix to the action name to indicate the scope of
+the actions, such as "app." for the actions with application scope
+or "win." for those with window scope.
+
+When referring to actions on a GActionMap only the name of the
+action itself is used (ie: "quit", not "app.quit"). The
+"app.quit" form is only used when referring to actions from
+places like a GMenu or GtkActionable widget where the scope
+of the action is not already known.
+
+GtkApplication and GtkApplicationWindow implement the GActionMap
+interface, so you can just add actions directly to them. For
+other widgets, use gtk_widget_insert_action_group() to add
+actions to it.
+
+If you want to insert several actions at the same time, it is
+typically faster and easier to use GActionEntry.
+
+## Connecting actions to widgets
+
+Any widget that implements the GtkActionable interface can
+be connected to an action just by setting the ::action-name
+property. If the action has a parameter, you will also need
+to set the ::action-target property.
+Widgets that implement GtkActionable include GtkSwitch, GtkButton,
+and their respective subclasses.
+
+Another way of obtaining widgets that are connected to actions
+is to create a menu using a GMenu menu model. GMenu provides an
+abstract way to describe typical menus: nested groups of items
+where each item can have a label, and icon, and an action.
+
+Typical uses of GMenu inside GTK are to set up an application
+menu or menubar with gtk_application_set_app_menu() or
+gtk_application_set_menubar(). Another, maybe more common use
+is to create a popover for a menubutton, using
+gtk_menu_button_set_menu_model().
+
+Unlike traditional menus, those created from menu models don't
+have keyboard accelerators associated with menu items. Instead,
+GtkApplication offers the gtk_application_set_accels_for_action()
+API to associate keyboard shortcuts with actions.
+
+## Activation
+
+When a widget with a connected action is activated, GTK finds
+the action to activate by walking up the widget hierarchy,
+looking for a matching action, ending up at the GtkApplication.
+
+## Built-in Actions
+
+GTK uses actions for its own purposes in a number places. These
+built-in actions can sometimes be activated by applications, and
+you should avoid naming conflicts with them when creating your
+own actions.
+
+default.activate
+ :  Activates the default widget in a context (typically a GtkWindow,
+    GtkDialog or GtkPopover)
+clipboard.cut, clipboard.copy, clipboard.paste
+ :  Clipboard operations on entries, text view and labels, typically
+    used in the context menu
+selection.delete, selection.select-all
+ : Selection operations on entries, text view and labels
+color.select, color.customize:
+ : Operate on colors in a #GtkColorChooserWidget. These actions are
+   unusual in that they have the non-trivial parameter type (dddd):

docs/reference/gtk/actions.xml

@@ -1,394 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="chap-actions">
-<refmeta>
-<refentrytitle>The GTK Action Model</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>The GTK Action Model</refname>
-<refpurpose>
-    How actions are used in GTK
-</refpurpose>
-</refnamediv>
-
-
-  <refsect1 id="actions-overview">
-    <title>Overview of actions in GTK</title>
-
-  <para>
-   This chapter describes in detail how GTK uses actions to connect
-   activatable UI elements to callbacks. GTK inherits the underlying
-   architecture of GAction and GMenu for describing abstract actions
-   and menus from the GIO library.
-  </para>
-
-  <refsect2>
-    <title>Basics about actions</title>
-
-    <para>
-     A GAction is essentially a way to tell the toolkit about a
-     piece of functionality in your program, and to give it a name.
-   </para>
-
-   <para>
-     Actions are purely functional. They do not contain any
-     presentational information.
-   </para>
-
-   <para>
-     An action has four pieces of information associated with it:
-     <itemizedlist>
-       <listitem><para>
-         a name as an identifier (usually all-lowercase, untranslated
-         English string)
-       </para></listitem>
-       <listitem><para>
-         an enabled flag indicating if the action can be activated or
-         not (like the "sensitive" property on widgets)
-       </para></listitem>
-       <listitem><para>
-         an optional state value, for stateful actions (like a boolean
-         for toggles)
-       </para></listitem>
-       <listitem><para>
-         an optional parameter type, used when activating the action
-       </para></listitem>
-     </itemizedlist>
-   </para>
-
-   <para>
-     An action supports two operations. You can activate it, which
-     requires passing a parameter of the correct type
-     And you can request to change the actions state (for stateful
-     actions) to a new state value of the correct type.
-   </para>
-
-   <para>
-     Here are some rules about an action:
-     <itemizedlist>
-       <listitem><para>
-         the name is immutable (in the sense that it will never
-         change) and it is never %NULL
-       </para></listitem>
-       <listitem><para>
-         the enabled flag can change
-       </para></listitem>
-       <listitem><para>
-         the parameter type is immutable
-       </para></listitem>
-       <listitem><para>
-         the parameter type is optional: it can be %NULL
-       </para></listitem>
-       <listitem><para>
-         if the parameter type is %NULL then action activation must
-         be done without a parameter (ie: a %NULL GVariant pointer)
-       </para></listitem>
-       <listitem><para>
-         if the parameter type is non-%NULL then the parameter must
-         have this type
-       </para></listitem>
-       <listitem><para>
-         the state can change, but it cannot change type
-       </para></listitem>
-       <listitem><para>
-         if the action was stateful when it was created, it will
-         always have a state and it will always have exactly the same
-         type (such as boolean or string)
-       </para></listitem>
-       <listitem><para>
-         if the action was stateless when it was created, it can never
-         have a state
-       </para></listitem>
-       <listitem><para>
-         you can only request state changes on stateful actions and it
-         is only possible to request that the state change to a value
-         of the same type as the existing state
-       </para></listitem>
-     </itemizedlist>
-   </para>
-
-   <para>
-     An action does not have any sort of presentational information
-     such as a label, an icon or a way of creating a widget from it.
-   </para>
-
-   </refsect2>
-
-   <refsect2>
-     <title>Action state and parameters</title>
-
-     <para>
-       Most actions in your application will be stateless actions with
-       no parameters. These typically appear as menu items with no
-       special decoration. An example is "quit".
-     </para>
-
-     <para>
-       Stateful actions are used to represent an action which has a
-       closely-associated state of some kind. A good example is a
-       "fullscreen" action. For this case, you'd expect to see a
-       checkmark next to the menu item when the fullscreen option
-       is active. This is usually called a toggle action, and it has
-       a boolean state. By convention, toggle actions have no parameter
-       type for activation: activating the action always toggles the
-       state.
-     </para>
-
-     <para>
-       Another common case is to have an action representing a
-       enumeration of possible values of a given type (typically
-       string). This is often called a radio action and is usually
-       represented in the user interface with radio buttons or radio
-       menu items, or sometimes a combobox. A good example is
-       "text-justify" with possible values "left", "center", and
-       "right". By convention, these types of actions have a parameter
-       type equal to their state type, and activating them with a
-       particular parameter value is equivalent to changing their
-       state to that value.
-     </para>
-
-     <para>
-       This approach to handling radio buttons is different than many
-       other action systems such as GtkAction. With GAction, there is
-       only one action for "text-justify" and "left", "center" and
-       "right" are possible states on that action. There are not three
-       separate "justify-left", "justify-center" and "justify-right"
-       actions.
-     </para>
-
-     <para>
-       The final common type of action is a stateless action with a
-       parameter. This is typically used for actions like
-       "open-bookmark" where the parameter to the action would be
-       the identifier of the bookmark to open.
-     </para>
-
-     <para>
-       Because some types of actions cannot be invoked without a
-       parameter, it is often important to specify a parameter when
-       referring to the action from a place where it will be invoked
-       (such as from a radio button that sets the state to a particular
-       value or from a menu item that opens a specific bookmark). In
-       these contexts, the value used for the action parameter is
-       typically called the target of the action.
-     </para>
-
-     <para>
-       Even though toggle actions have a state, they do not have a
-       parameter. Therefore, a target value is not needed when
-       referring to them — they will always be toggled on activation.
-     </para>
-
-     <para>
-       Most APIs that allow using a GAction (such as GMenuModel and
-       GtkActionable) allow use of detailed action names. This is a
-       convenient way of specifying an action name and an action target
-       with a single string.
-     </para>
-
-     <para>
-       In the case that the action target is a string with no unusual
-       characters (ie: only alpha-numeric, plus '-' and '.') then you
-       can use a detailed action name of the form "justify::left" to
-       specify the justify action with a target of left.
-     </para>
-
-     <para>
-       In the case that the action target is not a string, or contains
-       unusual characters, you can use the more general format
-       "action-name(5)", where the "5" here is any valid text-format
-       GVariant (ie: a string that can be parsed by g_variant_parse()).
-       Another example is "open-bookmark('http://gnome.org/')".
-     </para>
-
-     <para>
-       You can convert between detailed action names and split-out
-       action names and target values using g_action_parse_detailed_name()
-       and g_action_print_detailed_name() but usually you will
-       not need to. Most APIs will provide both ways of specifying
-       actions with targets.
-     </para>
-
-   </refsect2>
-
-   <refsect2>
-     <title>Action scopes</title>
-
-     <para>
-       Actions are always scoped to a particular object on which they
-       operate.
-     </para>
-
-     <para>
-       In GTK, actions are typically scoped to either an application
-       or a window, but any widget can have actions associated with it.
-     </para>
-
-     <para>
-       Actions scoped to windows should be the actions that
-       specifically impact that window. These are actions like
-       "fullscreen" and "close", or in the case that a window contains
-       a document, "save" and "print".
-     </para>
-
-     <para>
-       Actions that impact the application as a whole rather than one
-       specific window are scoped to the application. These are actions
-       like "about" and "preferences".
-     </para>
-
-     <para>
-       If a particular action is scoped to a window then it is scoped
-       to a specific window. Another way of saying this: if your
-       application has a "fullscreen" action that applies to windows
-       and it has three windows, then it will have three fullscreen
-       actions: one for each window.
-     </para>
-
-     <para>
-       Having a separate action per-window allows for each window to
-       have a separate state for each instance of the action as well
-       as being able to control the enabled state of the action on a
-       per-window basis.
-     </para>
-
-     <para>
-       Actions are added to their relevant scope (application,
-       window or widget) either using the GActionMap interface,
-       or by using gtk_widget_insert_action_group(). Actions that
-       will be the same for all instances of a widget class can
-       be added globally using gtk_widget_class_install_action().
-     </para>
-
-  </refsect2>
-
-  <refsect2>
-    <title>Action groups and action maps</title>
-
-    <para>
-      Actions rarely occurs in isolation. It is common to have groups
-      of related actions, which are represented by instances of the
-      GActionGroup interface.
-    </para>
-
-    <para>
-      Action maps are a variant of action groups that allow to change
-      the name of the action as it is looked up. In GTK, the convention
-      is to add a prefix to the action name to indicate the scope of
-      the actions, such as "app." for the actions with application scope
-      or "win." for those with window scope.
-    </para>
-
-    <para>
-      When referring to actions on a GActionMap only the name of the
-      action itself is used (ie: "quit", not "app.quit"). The
-      "app.quit" form is only used when referring to actions from
-      places like a GMenu or GtkActionable widget where the scope
-      of the action is not already known.
-    </para>
-
-    <para>
-      GtkApplication and GtkApplicationWindow implement the GActionMap
-      interface, so you can just add actions directly to them. For
-      other widgets, use gtk_widget_insert_action_group() to add
-      actions to it.
-    </para>
-
-    <para>
-      If you want to insert several actions at the same time, it is
-      typically faster and easier to use GActionEntry.
-    </para>
-
-  </refsect2>
-
-  <refsect2>
-    <title>Connecting actions to widgets</title>
-
-    <para>
-      Any widget that implements the GtkActionable interface can
-      be connected to an action just by setting the ::action-name
-      property. If the action has a parameter, you will also need
-      to set the ::action-target property.
-      Widgets that implement GtkActionable include GtkSwitch, GtkButton,
-      and their respective subclasses.
-    </para>
-
-    <para>
-      Another way of obtaining widgets that are connected to actions
-      is to create a menu using a GMenu menu model. GMenu provides an
-      abstract way to describe typical menus: nested groups of items
-      where each item can have a label, and icon, and an action.
-    </para>
-
-    <para>
-      Typical uses of GMenu inside GTK are to set up an application
-      menu or menubar with gtk_application_set_app_menu() or
-      gtk_application_set_menubar(). Another, maybe more common use
-      is to create a popover for a menubutton, using
-      gtk_menu_button_set_menu_model().
-    </para>
-
-    <para>
-      Unlike traditional menus, those created from menu models don't
-      have keyboard accelerators associated with menu items. Instead,
-      GtkApplication offers the gtk_application_set_accels_for_action()
-      API to associate keyboard shortcuts with actions.
-    </para>
-  </refsect2>
-
-  <refsect2>
-    <title>Activation</title>
-
-    <para>
-      When a widget with a connected action is activated, GTK finds
-      the action to activate by walking up the widget hierarchy,
-      looking for a matching action, ending up at the GtkApplication.
-    </para>
-  </refsect2>
-
-  <refsect2>
-    <title>Built-in Actions</title>
-
-    <para>
-      GTK uses actions for its own purposes in a number places. These
-      built-in actions can sometimes be activated by applications, and
-      you should avoid naming conflicts with them when creating your
-      own actions.
-      <variablelist>
-        <varlistentry>
-          <term>default.activate</term>
-          <listitem><para>Activates the default widget in a context
-             (typically a GtkWindow, GtkDialog or GtkPopover)
-          </para></listitem>
-        </varlistentry>
-        <varlistentry>
-          <term>clipboard.cut, clipboard.copy, clipboard.paste</term>
-          <listitem><para>Clipboard operations on entries, text view
-            and labels, typically used in the context menu
-          </para></listitem>
-        </varlistentry>
-        <varlistentry>
-          <term>selection.delete, selection.select-all</term>
-          <listitem><para>Selection operations on entries, text view
-            and labels
-          </para></listitem>
-        </varlistentry>
-        <varlistentry>
-          <term>color.select, color.customize</term>
-          <listitem><para>Operations on colors in GtkColorChooserWidget.
-            These actions are unusual in that they have the non-trivial
-            parameter type (dddd).
-          </para></listitem>
-        </varlistentry>
-      </variablelist>
-    </para>
-
-  </refsect2>
-
-  </refsect1>
-</refentry>

docs/reference/gtk/broadway.md

@@ -0,0 +1,36 @@
+# Using GTK with Broadway {#gtk-broadway}
+
+The GDK Broadway backend provides support for displaying GTK
+applications in a web browser, using HTML5 and web sockets. To run
+your application in this way, select the Broadway backend by setting
+`GDK_BACKEND=broadway`. Then you can make your application appear in
+a web browser by pointing it at `http://127.0.0.1:8080`. Note that
+you need to enable web sockets in your web browser.
+
+You can choose a different port from the default 8080 by setting
+the `BROADWAY_DISPLAY` environment variable to the port that you
+want to use.
+
+It is also possible to use multiple GTK applications in the same
+web browser window, by using the Broadway server, `broadwayd`, that
+ships with GTK. To use broadwayd, start it like this:
+
+```
+broadwayd :5
+```
+
+Then point your web browser at `http://127.0.0.1:8085`.
+Start your applications like this:
+
+```
+GDK_BACKEND=broadway BROADWAY_DISPLAY=:5 gtk4-demo
+```
+
+## Broadway-specific environment variables {#broadway-envar}
+
+### BROADWAY_DISPLAY
+
+Specifies the Broadway display number. The default display is 0.
+The display number determines the port to use when connecting
+to a Broadway application via the following formula:
+`port = 8080 + display`

docs/reference/gtk/broadway.xml

@@ -1,71 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-broadway">
-<refmeta>
-<refentrytitle>Using GTK with Broadway</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>Using GTK with Broadway</refname>
-<refpurpose>
-HTML-specific aspects of using GTK
-</refpurpose>
-</refnamediv>
-
-<refsect1>
-<title>Using GTK with Broadway</title>
-
-<para>
-The GDK Broadway backend provides support for displaying GTK
-applications in a web browser, using HTML5 and web sockets. To run
-your application in this way, select the Broadway backend by setting
-<literal>GDK_BACKEND=broadway</literal>. Then you can make
-your application appear in a web browser by pointing it at
-<literal>http://127.0.0.1:8080</literal>. Note that you need
-to enable web sockets in your web browser.
-</para>
-
-<para>
-You can choose a different port from the default 8080 by setting
-the <envar>BROADWAY_DISPLAY</envar> environment variable to the
-port that you want to use.
-</para>
-
-<para>
-It is also possible to use multiple GTK applications in the same
-web browser window, by using the Broadway server,
-<command>broadwayd</command>, that ships with GTK.
-To use broadwayd, start it like this:
-<programlisting>
-broadwayd :5
-</programlisting>
-Then point your web browser at <literal>http://127.0.0.1:8085</literal>.
-Start your applications like this:
-<programlisting>
-GDK_BACKEND=broadway BROADWAY_DISPLAY=:5 gtk4-demo
-</programlisting>
-</para>
-
-<refsect2 id="broadway-envar">
-<title>Broadway-specific environment variables</title>
-
-</refsect2>
-  <formalpara>
-    <title><envar>BROADWAY_DISPLAY</envar></title>
-
-    <para>
-      Specifies the Broadway display number. The default display is 0.
-      The display number determines the port to use when connecting
-      to a Broadway application via the following formula:
-      <programlisting>
-        <replaceable>port</replaceable> = 8080 + <replaceable>display</replaceable>
-      </programlisting>
-    </para>
-  </formalpara>
-</refsect1>
-
-</refentry>

docs/reference/gtk/building.md

@@ -0,0 +1,270 @@
+# Compiling the GTK Libraries {#gtk-building}
+
+## Building GTK
+
+Before we get into the details of how to compile GTK, we should
+mention that in many cases, binary packages of GTK prebuilt for
+your operating system will be available, either from your
+operating system vendor or from independent sources. If such a
+set of packages is available, installing it will get you
+programming with GTK much faster than building it yourself. In
+fact, you may well already have GTK installed on your system already.
+
+In order to build GTK, you will need *meson* installed on your
+system. On Linux, and other UNIX-like operating systems, you will
+also need *ninja*. This guide does not cover how to install these
+two requirements, but you can refer to the
+[Meson website](http://mesonbuild.com) for more information. The
+[Ninja](https://ninja-build.org) build tool is also usable on
+various operating systems, so we will refer to it in the examples.
+
+If you are building GTK from a source distribution or from a Git
+clone, you will need to use *meson* to configure the project. The
+most commonly useful argument is the `--prefix` one, which determines
+where the files will go once installed. To install GTK under a prefix
+like `/opt/gtk` you would run Meson as:
+
+```
+meson setup --prefix /opt/gtk builddir
+```
+
+Meson will create the `builddir` directory and place all the build
+artefacts there.
+
+You can get a list of all available options for the build by
+running `meson configure`.
+
+After Meson successfully configured the build directory, you then
+can run the build, using Ninja:
+
+```
+cd builddir
+ninja
+ninja install
+```
+
+If you don't have permission to write to the directory you are
+installing in, you may have to change to root temporarily before
+running `ninja install`.
+
+Several environment variables are useful to pass to set before
+running *meson*. `CPPFLAGS` contains options to pass to the C
+compiler, and is used to tell the compiler where to look for
+include files. The `LDFLAGS` variable is used in a similar fashion
+for the linker. Finally the `PKG_CONFIG_PATH` environment variable
+contains a search path that `pkg-config` (see below) uses when
+looking for files describing how to compile programs using different
+libraries. If you were installing GTK and it's dependencies into
+`/opt/gtk`, you might want to set these variables as:
+
+```
+CPPFLAGS="-I/opt/gtk/include"
+LDFLAGS="-L/opt/gtk/lib"
+PKG_CONFIG_PATH="/opt/gtk/lib/pkgconfig"
+export CPPFLAGS LDFLAGS PKG_CONFIG_PATH
+```
+
+You may also need to set the `LD_LIBRARY_PATH` environment variable
+so the systems dynamic linker can find the newly installed libraries,
+and the `PATH` environment program so that utility binaries installed
+by the various libraries will be found.
+
+```
+LD_LIBRARY_PATH="/opt/gtk/lib"
+PATH="/opt/gtk/bin:$PATH"
+export LD_LIBRARY_PATH PATH
+```
+
+## Build types {#build-types}
+
+Meson has different build types, exposed by the `buildtype`
+configuration option. GTK enables and disables functionality
+depending on the build type used when calling *meson* to
+configure the build.
+
+### Debug builds
+
+GTK will enable debugging code paths in both the `debug` and
+`debugoptimized` build types. Builds with `buildtype` set to
+`debug` will additionally enable consistency checks on the
+internal state of the toolkit.
+
+It is recommended to use the `debug` or `debugoptimized` build
+types when developing GTK itself. Additionally, `debug` builds of
+GTK are recommended for profiling and debugging GTK applications,
+as they include additional validation of the internal state.
+
+The `debugoptimized` build type is the default for GTK if no build
+type is specified when calling *meson*.
+
+### Release builds
+
+The `release` build type will disable debugging code paths and
+additional run time safeties, like checked casts for object
+instances.
+
+The `plain` build type provided by Meson should only be used when
+packaging GTK, and it's expected that packagers will provide their
+own compiler flags when building GTK. See the previous section for
+the list of environment variables to be used to define compiler and
+linker flags.
+
+## Dependencies {#dependencies}
+
+Before you can compile the GTK widget toolkit, you need to have
+various other tools and libraries installed on your
+system. Dependencies of GTK have their own build systems, so
+you will need to refer to their own installation instructions.
+
+A particular important tool used by GTK to find its dependencies
+is `pkg-config`.
+
+[pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/)
+is a tool for tracking the compilation flags needed for libraries
+that are used by the GTK libraries. (For each library, a small `.pc`
+text file is installed in a standard location that contains the
+compilation flags needed for that library along with version number
+information.)
+
+Some of the libraries that GTK depends on are maintained by the
+GTK team: GLib, GdkPixbuf, Pango, ATK and GObject Introspection.
+Other libraries are maintained separately.
+
+- The GLib library provides core non-graphical functionality
+  such as high level data types, Unicode manipulation, and
+  an object and type system to C programs. It is available
+  from [here](https://download.gnome.org/sources/glib/).
+- The [GdkPixbuf](https://git.gnome.org/browse/gdk-pixbuf/)
+  library provides facilities for loading images in a variety of
+  file formats. It is available [here](ttps://download.gnome.org/sources/gdk-pixbuf/).
+- [Pango](http://www.pango.org) is a library for internationalized
+  text handling. It is available [here](https://download.gnome.org/sources/pango/).
+- ATK is the Accessibility Toolkit. It provides a set of generic
+  interfaces allowing accessibility technologies such as
+  screen readers to interact with a graphical user interface.
+  It is available [here](https://download.gnome.org/sources/atk/).
+- [GObject Introspection](https://wiki.gnome.org/Projects/GObjectIntrospection)
+  is a framework for making introspection data available to language
+  bindings. It is available [here](https://download.gnome.org/sources/gobject-introspection/).
+- The [GNU libiconv](https://www.gnu.org/software/libiconv/) library
+  is needed to build GLib if your system doesn't have the iconv()
+  function for doing conversion between character encodings. Most
+  modern systems should have iconv().
+- The libintl library from the [GNU gettext](https://www.gnu.org/software/gettext/)
+  package is needed if your system doesn't have the gettext()
+  functionality for handling message translation databases.
+- The libraries from the X window system are needed to build
+  Pango and GTK. You should already have these installed on
+  your system, but it's possible that you'll need to install
+  the development environment for these libraries that your
+  operating system vendor provides.
+- The [fontconfig](https://www.freedesktop.org/wiki/Software/fontconfig/)
+  library provides Pango with a standard way of locating
+  fonts and matching them against font names.
+- [Cairo](https://www.cairographics.org) is a graphics library that
+  supports vector graphics and image compositing. Both Pango and GTK
+  use Cairo for drawing.
+- [libepoxy](https://github.com/anholt/libepoxy) is a library that
+  abstracts the differences between different OpenGL libraries. GTK
+  uses it for cross-platform GL support and for its own drawing.
+- [Graphene](http://ebassi.github.io/graphene/) is a library that
+  provides vector and matrix types for 2D and 3D transformations.
+  GTK uses it internally for drawing.
+- The [Wayland](https://wayland.freedesktop.org) libraries are needed
+  to build GTK with the Wayland backend.
+- The [shared-mime-info](https://www.freedesktop.org/wiki/Software/shared-mime-info)
+  package is not a hard dependency of GTK, but it contains definitions
+  for mime types that are used by GIO and, indirectly, by GTK.
+  gdk-pixbuf will use GIO for mime type detection if possible.
+  For this to work, shared-mime-info needs to be installed and
+  `XDG_DATA_DIRS` set accordingly at configure time. Otherwise,
+  gdk-pixbuf falls back to its built-in mime type detection.
+
+## Building and testing GTK {#building}
+
+First make sure that you have the necessary external
+dependencies installed: `pkg-config`, Meson, Ninja,
+the JPEG, PNG, and TIFF libraries, FreeType, and, if necessary,
+libiconv and libintl. To get detailed information about building
+these packages, see the documentation provided with the
+individual packages. On any average Linux system, it's quite likely
+you'll have all of these installed already, or they will be easily
+accessible through your operating system package repositories.
+
+Then build and install the GTK libraries in the order:
+GLib, Cairo, Pango, ATK, then GTK. For each library, follow the
+instructions they provide, and make sure to share common settings
+between them and the GTK build; if you are using a separate prefix
+for GTK, for instance, you will need to use the same prefix for
+all its dependencies you build. If you're lucky, this will all go
+smoothly, and you'll be ready to [start compiling your own GTK
+applications](#gtk-compiling). You can test your GTK installation
+by running the `gtk4-demo` program that GTK installs.
+
+If one of the projects you're configuring or building fails, look
+closely at the error messages printed; these will often provide useful
+information as to what went wrong. Every build system has its own
+log that can help you understand the issue you're encountering. If
+all else fails, you can ask for help on the
+[GTK forums](#gtk-resources).
+
+## Extra Configuration Options {#extra-configuration-options}
+
+In addition to the normal options provided by Meson,
+GTK defines various arguments that modify what should
+be built. All of these options are passed to `meson`
+as `-Doption=value`. Most of the time, the value can
+be `true` or `false`. To see a summary of all supported
+options and their allowed values, run
+```
+meson configure builddir
+```
+
+### `xinerama`
+
+By default GTK will try to link against the Xinerama libraries
+if they are found. This option can be used to explicitly control
+whether Xinerama should be used.
+
+### `gtk_doc` and `man-pages`
+
+The *gtk-doc* package is used to generate the reference documentation
+included with GTK. By default support for *gtk-doc* is disabled
+because it requires various extra dependencies to be installed.
+If you have *gtk-doc* and *pandoc* installed and are modifying GTK,
+you may want to enable *gtk-doc* support by passing in `-Dgtk_doc=true`.
+
+Additionally, some tools provided by GTK have their own
+manual pages generated using a similar set of dependencies;
+if you have *xsltproc* then you can generate manual pages by
+passing `-Dman-pages=true` when configuring the build.
+
+### `print-backends`
+
+By default, GTK will try to build various print backends
+if their dependencies are found. This option can be used
+to explicitly control which print backends should be built.
+
+### `x11-backend`, `win32-backend`, `broadway-backend`, `wayland-backend` and `quartz-backend`
+
+Enable specific backends for GDK.  If none of these options
+are given, the Wayland backend will be enabled by default,
+if the platform is Linux; the X11 backend will also be enabled
+by default, unless the platform is Windows, in which case the
+default is win32, or the platform is macOS, in which case the
+default is quartz. If any backend is explicitly enabled or disabled,
+no other platform will be enabled automatically.
+
+### `introspection`
+
+Allows to disable building introspection support. This is option
+is mainly useful for shortening turnaround times on developer
+systems. Installed builds of GTK should always have introspection
+support.
+
+### `build-tests`, `install-tests`, `demos`
+
+By default, GTK will build quite a few tests and demos.
+While these are useful on a developer system, they are not
+needed when GTK is built e.g. for a flatpak runtime. These
+options allow to disable building tests and demos.

docs/reference/gtk/building.xml

@@ -1,518 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-building">
-<refmeta>
-<refentrytitle>Compiling the GTK libraries</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>Compiling the GTK Libraries</refname>
-<refpurpose>
-How to compile GTK itself
-</refpurpose>
-</refnamediv>
-  <refsect1 id="overview">
-    <title>Building GTK</title>
-    <para>
-      Before we get into the details of how to compile GTK, we should
-      mention that in many cases, binary packages of GTK prebuilt for
-      your operating system will be available, either from your
-      operating system vendor or from independent sources. If such a
-      set of packages is available, installing it will get you
-      programming with GTK much faster than building it yourself. In
-      fact, you may well already have GTK installed on your system
-      already.
-    </para>
-    <para>
-      In order to build GTK, you will need <application>meson</application>
-      installed on your system. On Linux, and other UNIX-like operating
-      systems, you will also need <application>ninja</application>. This
-      guide does not cover how to install these two requirements, but you
-      can refer to the <ulink url="http://mesonbuild.com">Meson website</ulink>
-      for more information. The <ulink url="https://ninja-build.org">Ninja</ulink>
-      build tool is also usable on various operating systems, so we will
-      refer to it in the examples.
-    </para>
-    <para>
-      If you are building GTK from a source distribution or from a Git
-      clone, you will need to use <application>meson</application> to
-      configure the project. The most commonly useful argument is the
-      <systemitem>--prefix</systemitem> one, which determines where the
-      files will go once installed. To install GTK under a prefix
-      like <filename>/opt/gtk</filename> you would run Meson as:
-    </para>
-    <informalexample>
-      <programlisting>
-        meson --prefix /opt/gtk builddir
-      </programlisting>
-    </informalexample>
-    <para>
-      Meson will create the <filename>builddir</filename> directory and
-      place all the build artefacts there.
-    </para>
-    <para>
-      You can get a list of all available options for the build by
-      running <application>meson configure</application>.
-    </para>
-    <para>
-      After Meson successfully configured the build directory, you then
-      can run the build, using Ninja:
-    </para>
-    <informalexample>
-      <programlisting>
-        cd builddir
-        ninja
-        ninja install
-      </programlisting>
-    </informalexample>
-    <para>
-      If you don't have permission to write to the directory you are
-      installing in, you may have to change to root temporarily before
-      running <literal>ninja install</literal>.
-    </para>
-    <para>
-      Several environment variables are useful to pass to set before
-      running <application>meson</application>. <envar>CPPFLAGS</envar>
-      contains options to pass to the C compiler, and is used to tell
-      the compiler where to look for include files. The <envar>LDFLAGS</envar>
-      variable is used in a similar fashion for the linker. Finally the
-      <envar>PKG_CONFIG_PATH</envar> environment variable contains
-      a search path that <command>pkg-config</command> (see below)
-      uses when looking for files describing how to compile
-      programs using different libraries. If you were installing GTK
-      and it's dependencies into <filename>/opt/gtk</filename>, you
-      might want to set these variables as:
-    </para>
-    <programlisting>
-      CPPFLAGS="-I/opt/gtk/include"
-      LDFLAGS="-L/opt/gtk/lib"
-      PKG_CONFIG_PATH="/opt/gtk/lib/pkgconfig"
-      export CPPFLAGS LDFLAGS PKG_CONFIG_PATH
-    </programlisting>
-    <para>
-      You may also need to set the <envar>LD_LIBRARY_PATH</envar>
-      environment variable so the systems dynamic linker can find
-      the newly installed libraries, and the <envar>PATH</envar>
-      environment program so that utility binaries installed by
-      the various libraries will be found.
-    </para>
-    <programlisting>
-      LD_LIBRARY_PATH="/opt/gtk/lib"
-      PATH="/opt/gtk/bin:$PATH"
-      export LD_LIBRARY_PATH PATH
-    </programlisting>
-  </refsect1>
-
-  <refsect1 id="build-types">
-    <title>Build types</title>
-
-    <para>Meson has different build types, exposed by the <literal>buildtype</literal>
-    configuration option. GTK enables and disables functionality depending on
-    the build type used when calling <application>meson</application> to
-    configure the build.</para>
-
-    <formalpara>
-      <title><systemitem>debug</systemitem> and <systemitem>debugoptimized</systemitem></title>
-
-      <para>
-        GTK will enable debugging code paths in both the
-        <literal>debug</literal> and <literal>debugoptimized</literal>
-        build types. Builds with <literal>buildtype</literal> set
-        to <literal>debug</literal> will additionally enable
-        consistency checks on the internal state of the toolkit.
-      </para>
-
-      <para>
-        It is recommended to use the <literal>debug</literal> or
-        <literal>debugoptimized</literal> build types when developing
-        GTK itself. Additionally, <literal>debug</literal> builds of
-        GTK are recommended for profiling and debugging GTK applications,
-        as they include additional validation of the internal state.
-      </para>
-
-      <para>
-        The <literal>debugoptimized</literal> build type is the
-        default for GTK if no build type is specified when calling
-        <application>meson</application>
-      </para>
-    </formalpara>
-
-    <formalpara>
-      <title><systemitem>release</systemitem></title>
-
-      <para>
-        The <literal>release</literal> build type will disable
-        debugging code paths and additional run time safeties, like
-        checked casts for object instances.
-      </para>
-    </formalpara>
-
-    <para>
-      The <literal>plain</literal> build type provided by Meson
-      should only be used when packaging GTK, and it's expected
-      that packagers will provide their own compiler flags when
-      building GTK. See the previous section for the list of
-      environment variables to be used to define compiler and
-      linker flags.
-    </para>
-  </refsect1>
-
-  <refsect1 id="dependencies">
-    <title>Dependencies</title>
-    <para>
-      Before you can compile the GTK widget toolkit, you need to have
-      various other tools and libraries installed on your
-      system. Dependencies of GTK have their own build systems, so
-      you will need to refer to their own installation instructions.
-    </para>
-    <para>
-      A particular important tool used by GTK to find its dependencies
-      is <application>pkg-config</application>.
-    </para>
-    <para>
-      <ulink url="https://www.freedesktop.org/wiki/Software/pkg-config/">pkg-config</ulink>
-      is a tool for tracking the compilation flags needed for
-      libraries that are used by the GTK libraries. (For each
-      library, a small <literal>.pc</literal> text file is installed
-      in a standard location that contains the compilation flags
-      needed for that library along with version number information.)
-    </para>
-    <para>
-      Some of the libraries that GTK depends on are maintained by
-      by the GTK team: GLib, GdkPixbuf, Pango, ATK and GObject Introspection.
-      Other libraries are maintained separately.
-    </para>
-    <itemizedlist>
-      <listitem>
-        <para>
-          The GLib library provides core non-graphical functionality
-          such as high level data types, Unicode manipulation, and
-          an object and type system to C programs. It is available
-          from  <ulink url="https://download.gnome.org/sources/glib/">here</ulink>.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          The <ulink url="https://git.gnome.org/browse/gdk-pixbuf/">GdkPixbuf library</ulink>
-          provides facilities for loading images in a variety of file formats.
-          It is available <ulink url="https://download.gnome.org/sources/gdk-pixbuf/">here</ulink>.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          <ulink url="http://www.pango.org">Pango</ulink> is a library
-          for internationalized text handling. It is available
-          <ulink url="https://download.gnome.org/sources/pango/">here</ulink>.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          ATK is the Accessibility Toolkit. It provides a set of generic
-          interfaces allowing accessibility technologies such as
-          screen readers to interact with a graphical user interface.
-          It is available
-          <ulink url="https://download.gnome.org/sources/atk/">here</ulink>.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          <ulink url="https://wiki.gnome.org/Projects/GObjectIntrospection">Gobject Introspection</ulink>
-          is a framework for making introspection data available to
-          language bindings. It is available
-          <ulink url="https://download.gnome.org/sources/gobject-introspection/">here</ulink>.
-        </para>
-      </listitem>
-    </itemizedlist>
-    <itemizedlist>
-      <title>External dependencies</title>
-      <listitem>
-        <para>
-          The <ulink url="https://www.gnu.org/software/libiconv/">GNU
-          libiconv library</ulink> is needed to build GLib if your
-          system doesn't have the <function>iconv()</function>
-          function for doing conversion between character
-          encodings. Most modern systems should have
-          <function>iconv()</function>.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          The libintl library from the <ulink
-          url="https://www.gnu.org/software/gettext/">GNU gettext
-          package</ulink> is needed if your system doesn't have the
-          <function>gettext()</function> functionality for handling
-          message translation databases.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          The libraries from the X window system are needed to build
-          Pango and GTK. You should already have these installed on
-          your system, but it's possible that you'll need to install
-          the development environment for these libraries that your
-          operating system vendor provides.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          The <ulink url="https://www.freedesktop.org/wiki/Software/fontconfig/">fontconfig</ulink>
-          library provides Pango with a standard way of locating
-          fonts and matching them against font names.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          <ulink url="https://www.cairographics.org">Cairo</ulink>
-          is a graphics library that supports vector graphics and image
-          compositing. Both Pango and GTK use Cairo for drawing.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          <ulink url="https://github.com/anholt/libepoxy">libepoxy</ulink>
-          is a library that abstracts the differences between different
-          OpenGL libraries. GTK uses it for cross-platform GL support
-          and for its own drawing.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          <ulink url="https://github.com/anholt/libepoxy">Graphene</ulink>
-          is a library that provides vector and matrix types for 2D and
-          3D transformations. GTK uses it internally for drawing.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          The <ulink url="https://wayland.freedesktop.org">Wayland</ulink> libraries
-          are needed to build GTK with the Wayland backend.
-        </para>
-      </listitem>
-      <listitem>
-        <para>
-          The <ulink url="https://www.freedesktop.org/wiki/Software/shared-mime-info">shared-mime-info</ulink>
-          package is not a hard dependency of GTK, but it contains definitions
-          for mime types that are used by GIO and, indirectly, by GTK.
-          gdk-pixbuf will use GIO for mime type detection if possible. For this
-          to work, shared-mime-info needs to be installed and
-          <envar>XDG_DATA_DIRS</envar> set accordingly at configure time.
-          Otherwise, gdk-pixbuf falls back to its built-in mime type detection.
-        </para>
-      </listitem>
-    </itemizedlist>
-  </refsect1>
-  <refsect1 id="building">
-    <title>Building and testing GTK</title>
-    <para>
-      First make sure that you have the necessary external
-      dependencies installed: <command>pkg-config</command>, Meson, Ninja,
-      the JPEG, PNG, and TIFF libraries, FreeType, and, if necessary,
-      libiconv and libintl. To get detailed information about building
-      these packages, see the documentation provided with the
-      individual packages. On any average Linux system, it's quite likely
-      you'll have all of these installed already, or they will be easily
-      accessible through your operating system package repositories.
-    </para>
-    <para>
-      Then build and install the GTK libraries in the order:
-      GLib, Cairo, Pango, ATK, then GTK. For each library, follow the
-      instructions they provide, and make sure to share common settings
-      between them and the GTK build; if you are using a separate prefix
-      for GTK, for instance, you will need to use the same prefix for all
-      its dependencies you build. If you're lucky, this will all go smoothly,
-      and you'll be ready to <link linkend="gtk-compiling">start compiling
-      your own GTK applications</link>. You can test your GTK installation
-      by running the <command>gtk4-demo</command> program that
-      GTK installs.
-    </para>
-    <para>
-      If one of the projects you're configuring or building fails, look
-      closely at the error messages printed; these will often provide useful
-      information as to what went wrong. Every build system has its own
-      log that can help you understand the issue you're encountering. If all
-      else fails, you can ask for help on the gtk-list mailing list.
-      See <xref linkend="gtk-resources"/> for more information.
-    </para>
-  </refsect1>
-
-  <refsect1 id="extra-configuration-options">
-    <title>Extra Configuration Options</title>
-
-    <para>
-      In addition to the normal options provided by Meson, GTK defines
-      various arguments that modify what should be built.
-
-      <cmdsynopsis>
-        <command>meson</command>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dx11-backend=true</arg>
-          <arg choice="plain">-Dx11-backend=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dwayland-backend=true</arg>
-          <arg choice="plain">-Dwayland-backend=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dbroadway-backend=true</arg>
-          <arg choice="plain">-Dbroadway-backend=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dwin32-backend=true</arg>
-          <arg choice="plain">-Dwin32-backend=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dquartz-backend=true</arg>
-          <arg choice="plain">-Dquartz-backend=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dmedia=gstreamer</arg>
-          <arg choice="plain">-Dmedia=ffmpeg</arg>
-          <arg choice="plain">-Dmedia=all</arg>
-          <arg choice="plain">-Dmedia=none</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dvulkan=yes</arg>
-          <arg choice="plain">-Dvulkan=no</arg>
-          <arg choice="plain">-Dvulkan=auto</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dxinerama=yes</arg>
-          <arg choice="plain">-Dxinerama=no</arg>
-          <arg choice="plain">-Dxinerama=auto</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dcloudproviders=true</arg>
-          <arg choice="plain">-Dcloudproviders=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dprint-backends=all</arg>
-          <arg choice="plain">-Dprint-backends=none</arg>
-          <arg choice="plain">-Dprint-backends=cups,lpr,...</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dcolord=yes</arg>
-          <arg choice="plain">-Dcolord=no</arg>
-          <arg choice="plain">-Dcolord=auto</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dgtk_doc=true</arg>
-          <arg choice="plain">-Dgtk_doc=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dman-pages=true</arg>
-          <arg choice="plain">-Dman-pages=false</arg>
-        </group>
-        <sbr/>
-        <group>
-          <arg choice="plain">-Dintrospection=true</arg>
-          <arg choice="plain">-Dintrospection=false</arg>
-        </group>
-      </cmdsynopsis>
-    </para>
-
-    <formalpara>
-      <title><systemitem>xinerama</systemitem></title>
-
-      <para>
-        By default GTK will try to link against the Xinerama libraries
-        if they are found. This options can be used to explicitly control
-        whether Xinerama should be used.
-      </para>
-    </formalpara>
-
-    <formalpara>
-      <title><systemitem>gtk_doc</systemitem> and
-        <systemitem>man-pages</systemitem></title>
-
-      <para>
-        The <application>gtk-doc</application> package is
-        used to generate the reference documentation included
-        with GTK. By default support for <application>gtk-doc</application>
-        is disabled because it requires various extra dependencies
-        to be installed. If you have
-        <application>gtk-doc</application> installed and
-        are modifying GTK, you may want to enable
-        <application>gtk-doc</application> support by passing
-        in <systemitem>gtk_doc</systemitem>.
-      </para>
-      <para>
-        Additionally, some tools provided by GTK have their own
-        manual pages generated using a similar set of dependencies;
-        if you have <application>xsltproc</application> then you
-        can generate manual pages by passing <systemitem>man-pages</systemitem>
-        when configuring the build.
-      </para>
-    </formalpara>
-
-    <formalpara>
-      <title><systemitem>print-backends</systemitem></title>
-
-      <para>
-        By default, GTK will try to build various print backends if
-        their dependencies are found. This option can be used to
-        explicitly control which print backends should be built.
-      </para>
-    </formalpara>
-
-    <formalpara>
-      <title><systemitem>x11-backend</systemitem>,
-        <systemitem>win32-backend</systemitem>,
-        <systemitem>quartz-backend</systemitem>,
-        <systemitem>broadway-backend</systemitem> and
-        <systemitem>wayland-backend</systemitem></title>
-
-      <para>
-        Enable specific backends for GDK.  If none of these options
-        are given, the Wayland backend will be enabled by default,
-        if the platform is Linux; the X11 backend will also be enabled
-        by default, unless the platform is Windows, in which case the
-        default is win32, or the platform is macOS, in which case the
-        default is quartz. If any backend is explicitly enabled or disabled,
-        no other platform will be enabled automatically.
-      </para>
-    </formalpara>
-
-    <formalpara>
-      <title><systemitem>introspection</systemitem></title>
-
-      <para>
-        Allows to disable building introspection support. This is option
-        is mainly useful for shortening turnaround times on developer
-        systems. Installed builds of GTK should always have introspection
-        support.
-      </para>
-    </formalpara>
-
-    <formalpara>
-      <title><systemitem>build-tests</systemitem>,
-             <systemitem>install-tests</systemitem>,
-             <systemitem>demos</systemitem></title>
-
-      <para>
-        By default, GTK will build quite a few tests and demos.
-        While these are useful on a developer system, they are not
-        needed when GTK is built e.g. for a flatpak runtime. These
-        options allow to disable building tests and demos.
-      </para>
-    </formalpara>
-
-  </refsect1>
-
-</refentry>

docs/reference/gtk/compiling.md

@@ -1,94 +1,55 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-compiling">
-<refmeta>
-<refentrytitle>Compiling GTK Applications</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
+# Compiling GTK Applications on UNIX {#gtk-compiling}
 
-<refnamediv>
-<refname>Compiling GTK Applications</refname>
-<refpurpose>
-How to compile your GTK application
-</refpurpose>
-</refnamediv>
-
-<refsect1>
-<title>Compiling GTK Applications on UNIX</title>
-
-<para>
 To compile a GTK application, you need to tell the compiler where to
 find the GTK header files and libraries. This is done with the
-<literal>pkg-config</literal> utility.
-</para>
-<para>
-The following interactive shell session demonstrates how
-<literal>pkg-config</literal> is used (the actual output on
-your system may be different):
-<programlisting>
+`pkg-config` utility.
+
+The following interactive shell session demonstrates how `pkg-config`
+is used (the actual output on your system may be different):
+
+```
 $ pkg-config --cflags gtk4
  -pthread -I/usr/include/gtk-4.0 -I/usr/lib64/gtk-4.0/include -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pango-1.0 -I/usr/include/glib-2.0 -I/usr/lib64/glib-2.0/include -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng12
 $ pkg-config --libs gtk4
  -pthread -lgtk-4 -lgdk-4 -latk-1.0 -lgio-2.0 -lpangoft2-1.0 -lgdk_pixbuf-2.0 -lpangocairo-1.0 -lcairo -lpango-1.0 -lfreetype -lfontconfig -lgobject-2.0 -lgmodule-2.0 -lgthread-2.0 -lrt -lglib-2.0
-</programlisting>
-</para>
-<para>
+```
 The simplest way to compile a program is to use the "backticks"
 feature of the shell. If you enclose a command in backticks
-(<emphasis>not single quotes</emphasis>), then its output will be
-substituted into the command line before execution. So to compile
-a GTK Hello, World, you would type the following:
-<programlisting>
+(*not single quotes*), then its output will be substituted into the
+command line before execution. So to compile a GTK Hello, World, you
+would type the following:
+```
 $ cc `pkg-config --cflags gtk4` hello.c -o hello `pkg-config --libs gtk4`
-</programlisting>
-</para>
-
-<para>
+```
 Deprecated GTK functions are annotated to make the compiler
 emit warnings when they are used (e.g. with gcc, you need to use
 the -Wdeprecated-declarations option). If these warnings are
 problematic, they can be turned off by defining the preprocessor
 symbol %GDK_DISABLE_DEPRECATION_WARNINGS by using the commandline
-option <literal>-DGDK_DISABLE_DEPRECATION_WARNINGS</literal>
-</para>
+option `-DGDK_DISABLE_DEPRECATION_WARNINGS`.
 
-<para>
 GTK deprecation annotations are versioned; by defining the
 macros %GDK_VERSION_MIN_REQUIRED and %GDK_VERSION_MAX_ALLOWED,
 you can specify the range of GTK versions whose API you want
 to use. APIs that were deprecated before or introduced after
 this range will trigger compiler warnings.
-</para>
 
-<para>
 Here is how you would compile hello.c if you want to allow it
 to use symbols that were not deprecated in 4.2:
-<programlisting>
+```
 $ cc `pkg-config --cflags gtk4` -DGDK_VERSION_MIN_REQIRED=GDK_VERSION_4_2 hello.c -o hello `pkg-config --libs gtk4`
-</programlisting>
-</para>
+```
 
-<para>
 And here is how you would compile hello.c if you don't want
 it to use any symbols that were introduced after 4.2:
-<programlisting>
+```
 $ cc `pkg-config --cflags gtk4` -DGDK_VERSION_MAX_ALLOWED=GDK_VERSION_4_2 hello.c -o hello `pkg-config --libs gtk4`
-</programlisting>
-</para>
-
-<para>
+```
 The older deprecation mechanism of hiding deprecated interfaces
 entirely from the compiler by using the preprocessor symbol
 GTK_DISABLE_DEPRECATED is still used for deprecated macros,
 enumeration values, etc. To detect uses of these in your code,
-use the commandline option <literal>-DGTK_DISABLE_DEPRECATED</literal>.
+use the commandline option `-DGTK_DISABLE_DEPRECATED`.
 There are similar symbols GDK_DISABLE_DEPRECATED,
-GDK_PIXBUF_DISABLE_DEPRECATED and G_DISABLE_DEPRECATED for GDK, GdkPixbuf and
-GLib.
-</para>
-
-</refsect1>
-</refentry>
+GDK_PIXBUF_DISABLE_DEPRECATED and G_DISABLE_DEPRECATED for GDK,
+GdkPixbuf and GLib.

docs/reference/gtk/css-overview.md

@@ -0,0 +1,79 @@
+# CSS in GTK {#css}
+
+This chapter describes how GTK uses CSS for styling and layout. 
+It is not meant to be an explanation of CSS from first principles,
+but focuses on listing supported CSS features and differences
+between Web CSS and GTK.
+
+There is plenty of introductory documentation available that
+can be used to learn about CSS in general. In the tables below
+we include links to the official specs that can be used to look
+up the definition of individual selectors and properties.
+
+## CSS nodes
+
+GTK applies the style information found in style sheets by matching
+the selectors against a tree of nodes. Each node in the tree has a
+name, a state and possibly style classes. The children of each node
+are linearly ordered.
+
+Every widget has one or more of these CSS nodes, and determines their
+name, state, style classes and how they are layed out as children and
+siblings in the overall node tree. The documentation for each widget
+explains what CSS nodes it has.
+
+### The CSS nodes of a GtkScale
+
+```
+scale[.fine-tune]
+├── marks.top
+│   ├── mark
+┊   ┊
+│   ╰── mark
+├── trough
+│   ├── slider
+│   ├── [highlight]
+│   ╰── [fill]
+╰── marks.bottom
+    ├── mark
+    ┊
+    ╰── mark
+```
+
+## Selectors
+
+Selectors work very similar to the way they do on the web.
+
+All widgets have one or more CSS nodes with element names and style
+classes. When style classes are used in selectors, they have to be prefixed
+with a period. Widget names can be used in selectors like IDs. When used
+in a selector, widget names must be prefixed with a # character.
+
+### GTK CSS Selectors
+
+| Pattern | Reference | Notes |
+|:--------|:----------|:------|
+| *       | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#universal-selector) | |
+| E       | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#type-selectors) | |
+| E.class | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#class-html) | |
+| E#id    | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#id-selectors) | |
+| E:nth-child(n) | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#structural-pseudos) | |
+| E:nth-last-child(n) | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#structural-pseudos) | |
+| E:first-child | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#structural-pseudos) | |
+| E:last-child | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#structural-pseudos) | |
+| E:only-child | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#structural-pseudos) | |
+| E:link, E:visited | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#link) | Corresponds to GTK_STATE_FLAG_LINK and GTK_STATE_FLAGS_VISITED |
+| E:active, E:hover, E:focus | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#useraction-pseudos) | Correspond to GTK_STATE_FLAG_ACTIVE, GTK_STATE_FLAG_PRELIGHT, GTK_STATE_FLAGS_FOCUSED |
+| E:focus-within | [CSS Selector Level 4](https://drafts.csswg.org/selectors/#focus-within-pseudo) | Set on all ancestors of the focus widget, unlike CSS |
+| E:focus-visible | [CSS Selector Level 4](https://drafts.csswg.org/selectors/#focus-within-pseudo) | Set on focus widget and all ancestors, unlike CSS |
+| E:disabled | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#UIstates) | Corresponds to GTK_STATE_FLAG_INSENSITIVE |
+| E:disabled | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#UIstates) | Corresponds to GTK_STATE_FLAG_CHECKED |
+| E:indeterminate | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#indeterminate) | Corresponds to GTK_STATE_FLAG_INCONSISTENT |
+| E:backdrop, E:selected | | Corresponds to GTK_STATE_FLAG_BACKDROP, GTK_STATE_FLAG_SELECTED |
+| E:not(selector) | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#negation) | |
+| E:dir(ltr), E:dir(rtl) | [CSS Selector Level 4](https://drafts.csswg.org/selectors/#the-dir-pseudo) | |
+| E:drop(active) | [CSS Selector Level 4](https://drafts.csswg.org/selectors/#drag-pseudos) | |
+| E F | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#descendent-combinators) | |
+| E > F | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#child-combinators) | |
+| E ~ F | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#general-sibling-combinators) | |
+| E + F | [CSS Selector Level 3](https://www.w3.org/TR/css3-selectors/#adjacent-sibling-combinators) | |

docs/reference/gtk/css-properties.md

@@ -0,0 +1,238 @@
+# GTK CSS Properties
+
+GTK supports CSS properties and shorthands as far as they can be applied
+in the context of widgets, and adds its own properties only when needed.
+All GTK-specific properties have a -gtk prefix.
+
+## Basic types
+
+All properties support the following keywords: inherit, initial, unset,
+with the same meaning as defined in the
+[CSS Cascading and Inheritance](https://www.w3.org/TR/css3-cascade/#defaulting-keywords)
+spec.
+
+The following units are supported for basic datatypes:
+
+Length
+ : px, pt, em, ex, rem, pc, in, cm, mm, calc()
+Percentage
+ : %, calc()
+Angle
+ : deg | grad | turn, calc()
+Time
+ : s | ms, calc()
+
+Length values with the em or ex units are resolved using the font
+size value, unless they occur in setting the font-size itself, in
+which case they are resolved using the inherited font size value.
+
+The rem unit is resolved using the initial font size value, which is
+not quite the same as the CSS definition of rem.
+
+The calc() notation adds considerable expressive power. There are limits
+on what types can be combined in such an expression (e.g. it does not make
+sense to add a number and a time). For the full details, see the
+[CSS3 VAlues and Units](https://www.w3.org/TR/css3-values/#calc-notation)
+spec.
+
+A common pattern among shorthand properties (called 'four sides') is one
+where one to four values can be specified, to determine a value for each
+side of an area. In this case, the specified values are interpreted as
+follows:
+
+4 values:
+ : top right bottom left
+3 values:
+ : top horizontal bottom
+2 values:
+ : vertical horizontal
+1 value:
+ : all
+
+## Colors
+
+GTK extends the CSS syntax with several additional ways to specify colors.
+
+The first is a reference to a color defined via a @define-color rule in CSS.
+The syntax for @define-color rules is as follows:
+
+```
+@define-color Name Color
+```
+
+To refer to the color defined by a @define-color rule, prefix the name with @.
+
+GTK also supports color expressions, which allow colors to be transformed to
+new ones. Color expressions can be nested, providing a rich language to
+define colors. Color expressions resemble functions, taking 1 or more colors
+and in some cases a number as arguments.
+
+`lighter(Color)`
+ : produces a brigher variant of Color
+`darker(Color)`
+ : produces a darker variant of Color
+`shade(Color, Number)`
+ : changes the lightness of Color. The number ranges from 0 for black to 2 for white.
+`alpha(Color, Number)`
+ : replaces the alpha value of color with number (between 0 and 1)
+`mix(Color1, Color2, Number)`
+ : interpolates between the two colors
+
+## Images
+
+GTK extends the CSS syntax for images and also uses it for specifying icons.
+To load a themed icon, use
+
+```
+-gtk-icontheme(Name)
+```
+
+The specified icon name is used to look up a themed icon, while taking into
+account the values of the -gtk-icon-palette property. This kind of image is
+mainly used as value of the -gtk-icon-source property. 
+
+Symbolic icons from the icon theme are recolored according to the
+-gtk-icon-palette property, which defines a list of named colors.
+The recognized names for colors in symbolic icons are error, warning
+and success. The default palette maps these three names to symbolic
+colors with the names @error_color, @warning_color and @success_color
+respectively. The syntax for defining a custom palette is a comma-separated
+list of name-color pairs, e.g.
+
+```
+success blue, warning #fc3, error magenta
+```
+
+Recoloring is sometimes needed for images that are not part of an icon theme,
+and the
+
+```
+-gtk-recolor(uri, palette)
+```
+
+syntax makes this available. -gtk-recolor requires a url as first argument.
+The remaining arguments specify the color palette to use. If the palette is
+not explicitly specified, the current value of the -gtk-icon-palette property
+is used. 
+
+GTK supports scaled rendering on hi-resolution displays. This works best if
+images can specify normal and hi-resolution variants. From CSS, this can be
+done with
+
+```
+-gtk-scaled(Image1, Image2)
+```
+
+## GTK CSS Properties
+
+| Property   | Reference | Notes |
+|:-----------|:----------|:------|
+|color       | [CSS Color Level 3](https://www.w3.org/TR/css3-color/#foreground) | |
+|opacity     | [CSS Color Level 3](https://www.w3.org/TR/css3-color/#opacity) | |
+|filter      | [CSS Filter Effect Level 1](https://drafts.fxtf.org/filters/#FilterProperty) | |
+|font-family | [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-family-prop) | defaults to gtk-font-name setting |
+|font-size   | [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-size-prop) | defaults to gtk-font-name setting |
+|font-style  | [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-style-prop) | |
+|font-variant| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#descdef-font-variant) | only CSS2 values supported |
+|font-weight | [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-weight-prop) | |
+|font-stretch| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-stretch-prop) | |
+|font-kerning| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-kerning-prop) | |
+|font-variant-ligatures| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-variant-ligatures-prop) | |
+|font-variant-position| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-variant-position-prop) | |
+|font-variant-caps| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-variant-position-prop) | |
+|font-variant-numeric| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-variant-numeric-prop) | |
+|font-variant-alternates| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-variant-alternates-prop) | |
+|font-variant-east-asian| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-variant-east-asian-prop) | |
+|font-feature-settings| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-feature-settings-prop) | |
+|font-variation-settings| [CSS Fonts Level 4](https://www.w3.org/TR/css-fonts-4/#font-variation-settings-def) | |
+|-gtk-dpi|[Number](https://www.w3.org/TR/css3-values/#number-value) | defaults to screen resolution |
+|font| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-prop) | CSS allows line-height, etc |
+|font-variant| [CSS Fonts Level 3](https://www.w3.org/TR/css3-fonts/#font-variant-prop) | |
+|caret-color|[CSS Basic User Interface Level 3](https://www.w3.org/TR/css3-ui/#caret-color) | CSS allows an auto value |
+|-gtk-secondary-caret-color|[Color](https://www.w3.org/TR/css-color-3/#valuea-def-color) | used for the secondary caret in bidirectional text |
+|letter-spacing| [CSS Text Level 3](https://www.w3.org/TR/css3-text/#letter-spacing) | |
+|text-decoration-line| [CSS Text Decoration Level 3](https://www.w3.org/TR/css-text-decor-3/#text-decoration-line-property) | CSS allows overline |
+|text-decoration-color| [CSS Text Decoration Level 3](https://www.w3.org/TR/css-text-decor-3/#text-decoration-color-property) | |
+|text-decoration-style| [CSS Text Decoration Level 3](https://www.w3.org/TR/css-text-decor-3/#text-decoration-style-property) | CSS allows dashed and dotted |
+|text-shadow| [CSS Text Decoration Level 3](https://www.w3.org/TR/css-text-decor-3/#text-shadow-property) | |
+|text-decoration| [CSS Text Decoration Level 3](https://www.w3.org/TR/css-text-decor-3/#text-decoration-property) | |
+|-gtk-icon-source| [Image](https://www.w3.org/TR/css-backgrounds-3/#typedef-image), `builtin` or `none` | used for builtin icons in buttons and expanders |
+|-gtk-icon-size| [Length](https://www.w3.org/TR/css3-values/#length-value) | size used for builtin icons in buttons and expanders |
+|-gtk-icon-style| `requested`, `regular` or `symbolic` | preferred style for application-loaded icons |
+|-gtk-icon-transform| [Transform list](https://drafts.csswg.org/css-transforms-1/#typedef-transform-list) or `none` | applied to builtin and application-loaded icons |
+|-gtk-icon-palette| Color palette, as explained above | used to recolor symbolic icons |
+|-gtk-icon-shadow| [Shadow](https://www.w3.org/TR/css-backgrounds-3/#typedef-shadow) or `none` | applied to builtin and application-loaded icons |
+|-gtk-icon-filter| [Filter value list](https://www.w3.org/TR/filter-effects-1/#typedef-filter-value-list) or `none` | applied to builtin and application-loaded icons |
+|transform| [CSS Transforms Level 2](https://drafts.csswg.org/css-transforms-2/) | |
+|min-width| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#min-width) | CSS allows percentages |
+|min-height| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#min-height) | CSS allows percentages |
+|margin-top| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#margin-top) | CSS allows percentages or auto |
+|margin-right| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#margin-right) | CSS allows percentages or auto |
+|margin-bottom| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#margin-bottom) | CSS allows percentages or auto |
+|margin-left| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#margin-left) | CSS allows percentages or auto |
+|padding-top| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#padding-top) | CSS allows percentages |
+|padding-right| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#padding-right) | CSS allows percentages |
+|padding-bottom| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#padding-bottom) | CSS allows percentages |
+|padding-left| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#padding-left) | CSS allows percentages |
+|margin| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#margin) | a 'four sides' property |
+|padding| [CSS Box Model Level 3](https://www.w3.org/TR/css3-box/#padding) | a 'four sides' property |
+|border-top-width| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-width) | CSS allows other values |
+|border-right-width| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-width) | CSS allows other values |
+|border-bottom-width| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-width) | CSS allows other values |
+|border-left-width| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-width) | CSS allows other values |
+|border-top-style| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-style) | |
+|border-right-style| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-style) | |
+|border-bottom-style| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-style) | |
+|border-left-style| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-style) | |
+|border-top-right-radius| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-radius) | |
+|border-bottom-right-radius| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-radius) | |
+|border-bottom-left-radius| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-radius) | |
+|border-top-left-radius| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-radius) | |
+|border-top-color| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-color) | |
+|border-right-color| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-color) | |
+|border-bottom-color| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-color) | |
+|border-left-color| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-color) | |
+|border-image-source| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-image-source) | |
+|border-image-repeat| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-image-repeat) | |
+|border-image-slice| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-image-slice) | a 'four sides' property |
+|border-image-width| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-image-width) | a 'four sides' property |
+|border-width| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-width) | a 'four sides' property |
+|border-style| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#the-border-style) | a 'four sides' property |
+|border-color| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border-color) | a 'four sides' property |
+|border-top| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border-top) | |
+|border-right| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border-right) | |
+|border-bottom| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border-bottom) | |
+|border-left| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border-left) | |
+|border| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border) | |
+|border-radius| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border-radius) | |
+|border-image| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#border-image) | |
+|outline-style| [CSS Basic User Interface Level 3](https://www.w3.org/TR/css3-ui/#outline-style) | initial value is none, auto is not supported |
+|outline-width| [CSS Basic User Interface Level 3](https://www.w3.org/TR/css3-ui/#outline-width) | |
+|outline-color| [CSS Basic User Interface Level 3](https://www.w3.org/TR/css3-ui/#outline-color) | initial value is currentColor, invert is not supported |
+|outline-offset| [CSS Basic User Interface Level 3](https://www.w3.org/TR/css3-ui/#outline-offset) | |
+|outline| [CSS Basic User Interface Level 3](https://www.w3.org/TR/css3-ui/#propdef-outline) | |
+|background-color| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background-color) | |
+|background-clip| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background-clip) | |
+|background-origin| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background-origin) | |
+|background-size| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background-size) | |
+|background-position| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background-position) | |
+|background-repeat| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background-repeat) | |
+|background-image| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background-image) | not supported: urls without quotes, colors in crossfades |
+|box-shadow| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#box-shadow) | |
+|background-blend-mode| [CSS Compositing and Blending Level 1](https://www.w3.org/TR/compositing-1/#propdef-background-blend-mode) | only affects multiple backgrounds |
+|background| [CSS Backgrounds and Borders Level 3](https://www.w3.org/TR/css3-background/#background) | |
+|transition-property| [CSS Transitions](https://www.w3.org/TR/css3-transitions/#transition-property) | |
+|transition-duration| [CSS Transitions](https://www.w3.org/TR/css3-transitions/#transition-duration) | |
+|transition-timing-function| [CSS Transitions](https://www.w3.org/TR/css3-transitions/#transition-timing-function) | |
+|transition-delay| [CSS Transitions](https://www.w3.org/TR/css3-transitions/#transition-delay) | |
+|transition| [CSS Transitions](https://www.w3.org/TR/css3-transitions/#transition) | |
+|animation-name| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-name) | |
+|animation-duration| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-duration) | |
+|animation-timing-function| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-timing-function) | |
+|animation-iteration-count| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-iteration-count) | |
+|animation-direction| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-direction) | |
+|animation-play-state| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-play-state) | |
+|animation-delay| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-delay) | |
+|animation-fill-mode| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation-fill-mode) | |
+|animation| [CSS Animations Level 1](https://www.w3.org/TR/css3-animations/#animation) | |
+|border-spacing| [CSS Table Level 3](https://www.w3.org/TR/css-tables-3/#border-spacing-property) | respected by GtkBox and GtkGrid |

docs/reference/gtk/drawing-model.md

@@ -0,0 +1,157 @@
+# Overview of the drawing model {#drawing-overview}
+
+This chapter describes the GTK drawing model in detail.  If you
+are interested in the procedure which GTK follows to draw its
+widgets and windows, you should read this chapter; this will be
+useful to know if you decide to implement your own widgets.  This
+chapter will also clarify the reasons behind the ways certain
+things are done in GTK.
+
+## Windows and events {#drawing-windows}
+
+Applications that use a windowing system generally create
+rectangular regions in the screen called _surfaces_ (GTK is
+following the Wayland terminology, other windowing systems
+such as X11 may call these _windows_). Traditional windowing
+systems do not automatically save the graphical content of
+surfaces, and instead ask applications to provide new content
+whenever it is needed. For example, if a window that is stacked
+below other windows gets raised to the top, then the application
+has to repaint it, so the previously obscured area can be shown.
+When the windowing system asks an application to redraw a window,
+it sends a _frame event_ (_expose event_ in X11 terminology)
+for that window.
+
+Each GTK toplevel window or dialog is associated with a
+windowing system surface. Child widgets such as buttons or
+entries don't have their own surface; they use the surface
+of their toplevel.
+
+Generally, the drawing cycle begins when GTK receives
+a frame event from the underlying windowing system:  if the
+user drags a window over another one, the windowing system will
+tell the underlying surface that it needs to repaint itself.  The
+drawing cycle can also be initiated when a widget itself decides
+that it needs to update its display.  For example, when the user
+types a character in an entry widget, the entry asks GTK to queue
+a redraw operation for itself.
+
+The windowing system generates frame events for surfaces. The GDK
+interface to the windowing system translates such events into
+emissions of the ::render signal on the affected surfaces. The GTK
+toplevel window connects to that signal, and reacts appropriately.
+
+The following sections describe how GTK decides which widgets
+need to be repainted in response to such events, and how widgets
+work internally in terms of the resources they use from the
+windowing system.
+
+## The frame clock {#frameclock}
+
+All GTK applications are mainloop-driven, which means that most
+of the time the app is idle inside a loop that just waits for
+something to happen and then calls out to the right place when
+it does. On top of this GTK has a frame clock that gives a
+“pulse” to the application. This clock beats at a steady rate,
+which is tied to the framerate of the output (this is synced to
+the monitor via the window manager/compositor). A typical
+refresh rate is 60 frames per second, so a new “pulse” happens
+roughly every 16 milliseconds.
+
+The clock has several phases:
+
+- Events
+- Update
+- Layout
+- Paint
+
+ The phases happens in this order and we will always run each
+ phase through before going back to the start.
+
+The Events phase is a stretch of time between each redraw where
+GTK processes input events from the user and other events
+(like e.g. network I/O). Some events, like mouse motion are
+compressed so that only a single mouse motion event per clock
+cycle needs to be handled.
+
+Once the Events phase is over, external events are paused and
+the redraw loop is run. First is the Update phase, where all
+animations are run to calculate the new state based on the
+estimated time the next frame will be visible (available via
+the frame clock). This often involves geometry changes which
+drive the next phase, Layout. If there are any changes in
+widget size requirements the new layout is calculated for the
+widget hierarchy (i.e. sizes and positions for all widgets are
+determined). Then comes the Paint phase, where we redraw the
+regions of the window that need redrawing.
+
+If nothing requires the Update/Layout/Paint phases we will
+stay in the Events phase forever, as we don’t want to redraw
+if nothing changes. Each phase can request further processing
+in the following phases (e.g. the Update phase will cause there
+to be layout work, and layout changes cause repaints).
+
+There are multiple ways to drive the clock, at the lowest level you
+can request a particular phase with gdk_frame_clock_request_phase()
+which will schedule a clock beat as needed so that it eventually
+reaches the requested phase. However, in practice most things
+happen at higher levels:
+
+- If you are doing an animation, you can use
+  gtk_widget_add_tick_callback() which will cause a regular
+  beating of the clock with a callback in the Update phase
+  until you stop the tick.
+- If some state changes that causes the size of your widget to
+  change you call gtk_widget_queue_resize() which will request
+  a Layout phase and mark your widget as needing relayout.
+- If some state changes so you need to redraw some area of
+  your widget you use the normal gtk_widget_queue_draw()
+  set of functions. These will request a Paint phase and
+  mark the region as needing redraw.
+
+There are also a lot of implicit triggers of these from the
+CSS layer (which does animations, resizes and repaints as needed).
+
+## The scene graph {#scene-graph}
+
+The first step in “drawing” a window is that GTK creates
+_render nodes_ for all the widgets in the window. The render
+nodes are combined into a tree that you can think of as a
+_scene graph_ describing your window contents.
+
+Render nodes belong to the GSK layer, and there are various kinds
+of them, for the various kinds of drawing primitives you are likely
+to need when translating widget content and CSS styling. Typical
+examples are text nodes, gradient nodes, texture nodes or clip nodes.
+
+In the past, all drawing in GTK happened via cairo. It is still possible
+to use cairo for drawing your custom widget contents, by using a cairo
+render node.
+
+A GSK _renderer_ takes these render nodes, transforms them into
+rendering commands for the drawing API it targets, and arranges
+for the resulting drawing to be associated with the right surface.
+GSK has renderers for OpenGL, Vulkan and cairo.
+
+## Hierarchical drawing {#hierarchical-drawing}
+
+During the Paint phase GTK receives a single #GdkSurface::render
+signal on the toplevel surface. The signal handler will create a
+snapshot object (which is a helper for creating a scene graph) and
+call the #GtkWidget::snapshot() vfunc, which will propagate down
+the widget hierarchy. This lets each widget snapshot its content
+at the right place and time, correctly handling things like partial
+transparencies and overlapping widgets.
+
+During the snapshotting of each widget, GTK automatically handles
+the CSS rendering according to the CSS box model. It snapshots first
+the background, then the border, then the widget content itself, and
+finally the outline.
+
+To avoid excessive work when generating scene graphs, GTK caches render
+nodes. Each widget keeps a reference to its render node (which in turn,
+will refer to the render nodes of children, and grandchildren, and so
+on), and will reuse that node during the Paint phase. Invalidating a
+widget (by calling gtk_widget_queue_draw()) discards the cached render
+node, forcing the widget to regenerate it the next time it needs to
+produce a snapshot.

docs/reference/gtk/drawing-model.xml

@@ -1,232 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="chap-drawing-model">
-<refmeta>
-<refentrytitle>The GTK Drawing Model</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>The GTK Drawing Model</refname>
-<refpurpose>
-    How widgets draw
-</refpurpose>
-</refnamediv>
-
-
-  <refsect1 id="drawing-overview">
-    <title>Overview of the drawing model</title>
-
-    <para>
-      This chapter describes the GTK drawing model in detail.  If you
-      are interested in the procedure which GTK follows to draw its
-      widgets and windows, you should read this chapter; this will be
-      useful to know if you decide to implement your own widgets.  This
-      chapter will also clarify the reasons behind the ways certain
-      things are done in GTK.
-    </para>
-
-    <refsect2 id="drawing model windows">
-
-      <title>Windows and events</title>
-
-      <para>
-        Applications that use a windowing system generally create
-        rectangular regions in the screen called <firstterm>surfaces</firstterm>
-        (GTK is following the Wayland terminology, other windowing systems
-        such as X11 may call these <firstterm>windows</firstterm>).
-        Traditional windowing systems do not automatically save the
-        graphical content of surfaces, and instead ask applications to
-        provide new content whenever it is needed.
-        For example, if a window that is stacked below other
-        windows gets raised to the top, then the application has to
-        repaint it, so the previously obscured area can be shown.
-        When the windowing system asks an application to redraw
-        a window, it sends a <firstterm>frame event</firstterm>
-        (<firstterm>expose event</firstterm> in X11 terminology)
-        for that window.
-      </para>
-      
-      <para>
-        Each GTK toplevel window or dialog is associated with a
-        windowing system surface. Child widgets such as buttons or
-        entries don't have their own surface; they use the surface
-        of their toplevel.
-      </para>
-
-      <para>
-        Generally, the drawing cycle begins when GTK receives
-        a frame event from the underlying windowing system:  if the
-        user drags a window over another one, the windowing system will
-        tell the underlying surface that it needs to repaint itself.  The
-        drawing cycle can also be initiated when a widget itself decides
-        that it needs to update its display.  For example, when the user
-        types a character in an entry widget, the entry asks GTK to queue
-        a redraw operation for itself.
-      </para>
-
-      <para>
-        The windowing system generates frame events for surfaces. The GDK
-        interface to the windowing system translates such events into
-        emissions of the ::render signal on the affected surfaces.
-        The GTK toplevel window connects to that signal, and reacts appropriately.
-      </para>
-
-      <para>
-        The following sections describe how GTK decides which widgets
-        need to be repainted in response to such events, and how widgets
-        work internally in terms of the resources they use from the
-        windowing system.
-      </para>
-    </refsect2>
-
-    <refsect2 id="frameclock">
-      <title>The frame clock</title>
-
-      <para>
-        All GTK applications are mainloop-driven, which means that most
-        of the time the app is idle inside a loop that just waits for
-        something to happen and then calls out to the right place when
-        it does. On top of this GTK has a frame clock that gives a
-        “pulse” to the application. This clock beats at a steady rate,
-        which is tied to the framerate of the output (this is synced to
-        the monitor via the window manager/compositor). A typical
-        refresh rate is 60 frames per second, so a new “pulse” happens
-        roughly every 16 milliseconds.
-      </para>
-
-      <para>
-        The clock has several phases:
-        <itemizedlist>
-          <listitem><para>Events</para></listitem>
-          <listitem><para>Update</para></listitem>
-          <listitem><para>Layout</para></listitem>
-          <listitem><para>Paint</para></listitem>
-        </itemizedlist>
-        The phases happens in this order and we will always run each
-        phase through before going back to the start.
-      </para>
-
-      <para>
-        The Events phase is a stretch of time between each redraw where
-        GTK processes input events from the user and other events
-        (like e.g. network I/O). Some events, like mouse motion are
-        compressed so that only a single mouse motion event per clock 
-        cycle needs to be handled.
-      </para>
-
-      <para>
-        Once the Events phase is over, external events are paused and
-        the redraw loop is run. First is the Update phase, where all
-        animations are run to calculate the new state based on the
-        estimated time the next frame will be visible (available via
-        the frame clock). This often involves geometry changes which
-        drive the next phase, Layout. If there are any changes in
-        widget size requirements the new layout is calculated for the
-        widget hierarchy (i.e. sizes and positions for all widgets are
-        determined). Then comes the Paint phase, where we redraw the
-        regions of the window that need redrawing.
-      </para>
-
-      <para>
-        If nothing requires the Update/Layout/Paint phases we will
-        stay in the Events phase forever, as we don’t want to redraw
-        if nothing changes. Each phase can request further processing
-        in the following phases (e.g. the Update phase will cause there
-        to be layout work, and layout changes cause repaints).
-      </para>
-
-      <para>
-        There are multiple ways to drive the clock, at the lowest level
-        you can request a particular phase with
-        gdk_frame_clock_request_phase() which will schedule a clock beat
-        as needed so that it eventually reaches the requested phase.
-        However, in practice most things happen at higher levels:
-        <itemizedlist>
-          <listitem><para>
-            If you are doing an animation, you can use
-            gtk_widget_add_tick_callback() which will cause a regular
-            beating of the clock with a callback in the Update phase
-            until you stop the tick.
-          </para></listitem>
-          <listitem><para>
-            If some state changes that causes the size of your widget
-            to change you call gtk_widget_queue_resize() which will
-            request a Layout phase and mark your widget as needing
-            relayout.
-          </para></listitem>
-          <listitem><para>
-            If some state changes so you need to redraw some area of
-            your widget you use the normal gtk_widget_queue_draw()
-            set of functions. These will request a Paint phase and
-            mark the region as needing redraw.
-          </para></listitem>
-        </itemizedlist>
-        There are also a lot of implicit triggers of these from the
-        CSS layer (which does animations, resizes and repaints as needed).
-      </para>
-    </refsect2>
-
-    <refsect2 id="scene-graph">
-      <title>The scene graph</title>
-
-      <para>
-        The first step in “drawing” a window is that GTK creates
-        <firstterm>render nodes</firstterm> for all the widgets
-        in the window. The render nodes are combined into a tree
-        that you can think of as a <firstterm>scene graph</firstterm>
-        describing your window contents.
-      </para>
-      <para>
-        Render nodes belong to the GSK layer, and there are various kinds
-        of them, for the various kinds of drawing primitives you are likely
-        to need when translating widget content and CSS styling. Typical
-        examples are text nodes, gradient nodes, texture nodes or clip nodes.
-      <para>
-      <para>
-        In the past, all drawing in GTK happened via cairo. It is still possible
-        to use cairo for drawing your custom widget contents, by using a cairo
-        render node.
-      </para>
-      </para>
-        A GSK <firstterm>renderer</firstterm> takes these render nodes, transforms
-        them into rendering commands for the drawing API it targets, and arranges
-        for the resulting drawing to be associated with the right surface. GSK has
-        renderers for OpenGL, Vulkan and cairo.
-      </para>
-    </refsect2>
-
-    <refsect2 id="hierarchical-drawing">
-      <title>Hierarchical drawing</title>
-
-      <para>
-        During the Paint phase GTK receives a single #GdkSurface::render signal on
-        the toplevel surface. The signal handler will create a snapshot object
-        (which is a helper for creating a scene graph) and call the
-        #GtkWidget::snapshot() vfunc, which will propagate down the widget hierarchy.
-        This lets each widget snapshot its content at the right place and time,
-        correctly handling things like partial transparencies and overlapping widgets.
-      </para>
-
-      <para>
-        During the snapshotting of each widget, GTK automatically handles the CSS
-        rendering according to the CSS box model. It snapshots first the background,
-        then the border, then the widget content itself, and finally the outline.
-      </para>
-
-      <para>
-        To avoid excessive work when generating scene graphs, GTK caches render nodes.
-        Each widget keeps a reference to its render node (which in turn, will refer to
-        the render nodes of children, and grandchildren, and so on), and will reuse
-        that node during the Paint phase. Invalidating a widget (by calling
-        gtk_widget_queue_draw()) discards the cached render node, forcing the widget
-        to regenerate it the next time it needs to produce a snapshot.
-      </para>
-    </refsect2>
-
-  </refsect1>
-
-</refentry>

docs/reference/gtk/glossary.xml

@@ -1,366 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE glossary PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<glossary id="glossary">
-  <title>Glossary</title>
-
-  <glossentry id="allocation">
-    <glossterm>allocation</glossterm>
-    <glossdef>
-      <para>
-	The final size of a <glossterm
-	linkend="widget">widget</glossterm> within its <glossterm
-	linkend="parent">parent</glossterm>.  For example, a widget
-	may request a minimum size of 20&times;20 pixels, but its
-	parent may decide to allocate 50&times;20 pixels for it
-	instead.
-      </para>
-      <glossseealso>
-	<glossterm linkend="requisition">requisition</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="bin">
-    <glossterm>bin</glossterm>
-    <glossdef>
-      <para>
-	A <glossterm linkend="container">container</glossterm> that
-	can hold at most one child widget.  The base class for bins is
-	#GtkBin.
-      </para>
-      <glossseealso>
-	<glossterm linkend="container">container</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="child">
-    <glossterm>child</glossterm>
-    <glossdef>
-      <para>
-	A <glossterm linkend="container">container's</glossterm> child
-	is a <glossterm linkend="widget">widget</glossterm> contained
-	inside it.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="column">
-    <glossterm>column</glossterm>
-    <glossdef>
-      <para>
-	GTK contains several widgets which display data in columns,
-        e.g. the #GtkTreeView. 
-        These <glossterm linkend="view-column">view columns</glossterm> in 
-        the tree view are represented by #GtkTreeViewColumn
-        objects inside GTK. They should not be confused with 
-        <glossterm linkend="model-column">model columns</glossterm> which
-        are used to organize the data in tree models.
-      </para>
-      <glossseealso>model-view widget</glossseealso>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="container">
-    <glossterm>container</glossterm>
-    <glossdef>
-      <para>
-	A <glossterm linkend="widget">widget</glossterm> that contains
-	other widgets; in that case, the container is the
-	<emphasis>parent</emphasis> of the <emphasis>child</emphasis>
-	widgets.  Some containers don't draw anything on their own,
-	but rather just organize their children's <glossterm
-	linkend="geometry">geometry</glossterm>; for example, #GtkVBox lays out 
-        its children vertically without painting anything on its own.  Other
-	containers include decorative elements; for example, #GtkFrame contains 
-        the frame's child and a label in addition to the shaded frame it draws.  
-        The base class for containers is #GtkContainer.
-      </para>
-      <glossseealso>
-	<glossterm linkend="container">widget</glossterm>
-	<glossterm linkend="container">geometry</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="display">
-    <glossterm>display</glossterm>
-    <glossdef>
-      <para>
-        GDK inherited the concept of display from the X window system,
-        which considers a display to be the combination
-        of a keyboard, a pointing device and one or more 
-        <glossterm linkend="screen">screens</glossterm>. 
-        Applications open a display to show windows and interact with the user.
-        In GDK, a display is represented by a #GdkDisplay.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="ellipsization">
-    <glossdef>
-      <para>
-        Ellipsization is the process of replacing some part
-        of a text by an ellipsis (usually "...") to make the
-        text fit in a smaller space. Pango can ellipsize text
-        at the beginning, at the end or in the middle.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="event">
-    <glossterm>event</glossterm>
-    <glossdef>
-      <para>
-        Events are the way in which GDK informs GTK about external events
-        like pointer motion, button clicks, key presses, etc. 
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="geometry">
-    <glossterm>geometry</glossterm>
-    <glossdef>
-      <para>
-	A <glossterm linkend="widget">widget's</glossterm> position
-	and size.  Within its parent, this is called the widget's
-	<glossterm linkend="allocation">allocation</glossterm>.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="mapping">
-    <glossterm>mapping</glossterm>
-    <glossdef>
-      <para>
-	This is the step in a <glossterm
-	linkend="widget">widget's</glossterm> life cycle where it
-	actually shows the GdkSurfaces it created when it was
-	<glossterm linkend="realization">realized</glossterm>.  When a
-	widget is mapped, it must turn on its
-	%GTK_MAPPED <link linkend="GtkWidgetFlags">flag</link>.
-      </para>
-
-      <para>
-	Note that due to the asynchronous nature of the X window
-	system, a widget's window may not appear on the screen
-	immediatly after one calls gdk_surface_show():
-	you must wait for the corresponding map <glossterm
-	linkend="event">event</glossterm> to be received.  You can do
-	this with the <link
-	linkend="GtkWidget-map-event"><methodname>GtkWidget::map-event</methodname>
-	signal</link>.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="model-column">
-    <glossterm>model column</glossterm>
-    <glossdef>
-      <para>
-        A column in a tree model, holding data of a certain type. 
-        The types which can be stored in the columns of a model 
-        have to be specified when the model is constructed, see 
-        e.g. gtk_list_store_new().
-      </para>
-      <glossseealso>
-	<glossterm linkend="view-column">view column</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="model-view">
-    <glossterm>model-view widget</glossterm>
-    <glossdef>
-      <para>
-        These widgets follow the well-known model-view pattern, which separates
-        the data (the model) to be displayed from the component which does the 
-        actual visualization (the view). Examples of this pattern in GTK are 
-        the #GtkTreeView/#GtkTreeModel and #GtkTextView/#GtkTextBuffer
-      </para>
-      <para>
-        One important advantage of this pattern is that it is possible to 
-        display the same model in multiple views; another one that the 
-        separation of the model allows a great deal of flexibility, as 
-        demonstrated by e.g. #GtkTreeModelSort or #GtkTreeModelFilter.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="no-window">
-    <glossterm>no-window widget</glossterm>
-    <glossdef>
-      <para>
-	A widget that does not have a GdkSurface of its own on which to
-	draw its contents, but rather shares its <glossterm
-	linkend="parent">parent's</glossterm>.  This can be tested with
-	the gtk_widget_get_has_surface() function.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="parent">
-    <glossterm>parent</glossterm>
-    <glossdef>
-      <para>
-	A <glossterm linkend="widget">widget's</glossterm> parent is
-	the <glossterm linkend="container">container</glossterm>
-	inside which it resides.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="realization">
-    <glossterm>realization</glossterm>
-    <glossdef>
-      <para>
-	This is the step in a <glossterm
-	linkend="widget">widget's</glossterm> life cycle where it
-	creates its own GdkSurface, or otherwise associates itself with
-	its <glossterm linkend="parent">parent's</glossterm>
-	GdkSurface.  If the widget has its own window, then it must
-	also attach a <glossterm linkend="style">style</glossterm> to
-	it.  A widget becomes unrealized by destroying its associated
-	GdkSurface.  When a widget is realized, it must turn on its
-	%GTK_REALIZED <link linkend="GtkWidgetFlags">flag</link>.
-      </para>
-
-      <para>
-	Widgets that don't own the GdkSurface on which they draw are
-	called <glossterm linkend="no-window">no-window widgets</glossterm>.  
-        This can be tested with the gtk_widget_get_has_surface() function.  Normally,
-        these widgets draw on their parent's GdkSurface.
-      </para>
-
-      <para>
-	Note that when a #GtkWidget creates a window in its #GtkWidget::realize
-	handler, it does not actually show the window.  That is, the
-	window's structure is just created in memory.  The widget
-	actually shows the window when it gets <glossterm
-	linkend="mapping">mapped</glossterm>.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="requisition">
-    <glossterm>requisition</glossterm>
-    <glossdef>
-      <para>
-	The size requisition of a <glossterm
-	linkend="widget">widget</glossterm> is the minimum amount of
-	space it requests from its <glossterm
-	linkend="parent">parent</glossterm>.  Once the parent computes
-	the widget's final size, it gives it its <glossterm
-	linkend="allocation">size allocation</glossterm>.
-      </para>
-      <glossseealso>
-	<glossterm linkend="allocation">allocation</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="screen">
-    <glossterm>screen</glossterm>
-    <glossdef>
-      <para>
-	GDK inherited the concept of screen from the X window system, 
-        which considers a screen to be a rectangular area, on which 
-        applications may place their windows. Screens under X may have 
-        quite dissimilar <glossterm linkend="visual">visuals</glossterm>.
-        Each screen can stretch across multiple physical monitors.
-      </para>
-      <para>
-        In GDK, screens are represented by #GdkScreen objects.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="style">
-    <glossterm>style</glossterm>
-    <glossdef>
-      <para>
-        A style encapsulates what GTK needs to know in order to draw
-        a widget. Styles can be modified with 
-        <link linkend="gtk3-Resource-Files">resource files</link>.
-      </para>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="toplevel">
-    <glossterm>toplevel</glossterm>
-    <glossdef>
-      <para>
-	A <glossterm linkend="widget">widget</glossterm> that does not
-	require a <glossterm linkend="parent">parent</glossterm> container.  
-        The only toplevel widgets in GTK are #GtkWindow and widgets derived from it.
-      </para>
-      <glossseealso>
-	<glossterm linkend="container">container</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
-
-  <glossentry id="unmap">
-    <glossterm>unmap</glossterm>
-    <glosssee><glossterm linkend="mapping">mapping</glossterm></glosssee>
-  </glossentry>
-
-  <glossentry id="unrealize">
-    <glossterm>unrealize</glossterm>
-    <glosssee><glossterm linkend="realization">realization</glossterm></glosssee>
-  </glossentry>
-
-  <glossentry id="view-column">
-    <glossterm>view column</glossterm>
-    <glossdef>
-      <para>
-        A displayed column in a tree view, represented by a
-        #GtkTreeViewColumn object.
-      </para>
-      <glossseealso>
-	<glossterm linkend="model-column">model column</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
- 
-  <glossentry id="visual">
-    <glossterm>visual</glossterm>
-    <glossdef>
-      <para>
-        A visual describes how color information is stored in pixels.
-        A <glossterm linkend="screen">screen</glossterm> may support
-        multiple visuals. On modern hardware, the most common visuals
-        are truecolor visuals, which store a fixed number of bits 
-        (typically 8) for the red, green and blue components of a color.
-      </para>
-      <para>
-        On ancient hardware, one may still meet indexed visuals, which 
-        store color information as an index into a color map, or even
-        monochrome visuals. 
-      </para>
-    </glossdef>
-  </glossentry>
- 
-  <glossentry id="widget">
-    <glossterm>widget</glossterm>
-    <glossdef>
-      <para>
-	A control in a graphical user interface.  Widgets can draw
-	themselves and process events from the mouse and keyboard.
-	Widget types include buttons, menus, text entry lines, and
-	lists.  Widgets can be arranged into <glossterm
-	linkend="container">containers</glossterm>, and these take
-	care of assigning the <glossterm
-	linkend="geometry">geometry</glossterm> of the widgets:  every
-	widget thus has a parent except those widgets which are
-	<glossterm linkend="toplevel">toplevels</glossterm>.  The base
-	class for widgets is #GtkWidget.
-      </para>
-      <glossseealso>
-	<glossterm linkend="container">container</glossterm>
-      </glossseealso>
-    </glossdef>
-  </glossentry>
-</glossary>

docs/reference/gtk/gtk-markdown-to-docbook

@@ -0,0 +1,192 @@
+#!/usr/bin/python3
+#
+# Call pandoc to convert markdown to docbook, then expand gtk-doc
+# abbreviations (|[ ]|, function(), #object, %constant, etc)
+
+import sys
+import re
+import tempfile
+import os.path
+import subprocess
+
+# The following code is taken from gtk-doc
+
+def ExpandAbbreviations(symbol, text):
+    # Convert '@param()'
+    text = re.sub(r'(\A|[^\\])\@(\w+((\.|->)\w+)*)\s*\(\)', r'\1<parameter>\2()</parameter>', text)
+
+    # Convert 'function()' or 'macro()'.
+    # if there is abc_*_def() we don't want to make a link to _def()
+    # FIXME: also handle abc(def(....)) : but that would need to be done recursively :/
+    def f1(m):
+        return m.group(1) + MakeXRef(m.group(2), tagify(m.group(2) + "()", "function"))
+    text = re.sub(r'([^\*.\w])(\w+)\s*\(\)', f1, text)
+    # handle #Object.func()
+    text = re.sub(r'(\A|[^\\])#([\w\-:\.]+[\w]+)\s*\(\)', f1, text)
+
+    # Convert '@param', but not '\@param'.
+    text = re.sub(r'(\A|[^\\])\@(\w+((\.|->)\w+)*)', r'\1<parameter>\2</parameter>', text)
+    text = re.sub(r'/\\\@', r'\@', text)
+
+    # Convert '%constant', but not '\%constant'.
+    # Also allow negative numbers, e.g. %-1.
+    def f2(m):
+        return m.group(1) + MakeXRef(m.group(2), tagify(m.group(2), "literal"))
+
+    text = re.sub(r'(\A|[^\\])\%(-?\w+)', f2, text)
+    text = re.sub(r'\\\%', r'\%', text)
+
+    # Convert '#symbol', but not '\#symbol'.
+
+    # Only convert #foo after a space to avoid interfering with
+    # fragment identifiers in urls
+    def f3(m):
+        return m.group(1) + MakeHashXRef(m.group(2), "type")
+
+    text = re.sub(r'(\A|[ ])#([\w\-:\.]+[\w]+)', f3, text)
+    text = re.sub(r'\\#', '#', text)
+
+    return text
+
+# Standard C preprocessor directives, which we ignore for '#' abbreviations.
+PreProcessorDirectives = {
+    'assert', 'define', 'elif', 'else', 'endif', 'error', 'if', 'ifdef', 'ifndef',
+    'include', 'line', 'pragma', 'unassert', 'undef', 'warning'
+}
+
+def MakeHashXRef(symbol, tag):
+    text = symbol
+
+    # Check for things like '#include', '#define', and skip them.
+    if symbol in PreProcessorDirectives:
+        return "#%s" % symbol
+
+    # Get rid of special suffixes ('-struct','-enum').
+    text = re.sub(r'-struct$', '', text)
+    text = re.sub(r'-enum$', '', text)
+
+    # If the symbol is in the form "Object::signal", then change the symbol to
+    # "Object-signal" and use "signal" as the text.
+    if '::' in symbol:
+        o, s = symbol.split('::', 1)
+        symbol = '%s-%s' % (o, s)
+        text = u'“' + s + u'”'
+
+    # If the symbol is in the form "Object:property", then change the symbol to
+    # "Object--property" and use "property" as the text.
+    if ':' in symbol:
+        o, p = symbol.split(':', 1)
+        symbol = '%s--%s' % (o, p)
+        text = u'“' + p + u'”'
+
+    if tag != '':
+        text = tagify(text, tag)
+
+    return MakeXRef(symbol, text)
+
+def MakeXRef(symbol, text=None):
+    """This returns a cross-reference link to the given symbol.
+
+    Though it doesn't try to do this for a few standard C types that it knows
+    won't be in the documentation.
+
+    Args:
+        symbol (str): the symbol to try to create a XRef to.
+        text (str): text to put inside the XRef, defaults to symbol
+
+    Returns:
+        str: a docbook link
+    """
+    symbol = symbol.strip()
+    if not text:
+        text = symbol
+
+        # Get rid of special suffixes ('-struct','-enum').
+        text = re.sub(r'-struct$', '', text)
+        text = re.sub(r'-enum$', '', text)
+
+    if ' ' in symbol:
+        return text
+
+    symbol_id = CreateValidSGMLID(symbol)
+    return "<link linkend=\"%s\">%s</link>" % (symbol_id, text)
+
+def CreateValidSGMLID(xml_id):
+    """Creates a valid SGML 'id' from the given string.
+
+    According to http://www.w3.org/TR/html4/types.html#type-id "ID and NAME
+    tokens must begin with a letter ([A-Za-z]) and may be followed by any number
+    of letters, digits ([0-9]), hyphens ("-"), underscores ("_"), colons (":"),
+    and periods (".")."
+
+    When creating SGML IDS, we append ":CAPS" to all all-caps identifiers to
+    prevent name clashes (SGML ids are case-insensitive). (It basically never is
+    the case that mixed-case identifiers would collide.)
+
+    Args:
+      id (str): The text to be converted into a valid SGML id.
+
+    Returns:
+      str: The converted id.
+    """
+
+    # Special case, '_' would end up as '' so we use 'gettext-macro' instead.
+    if xml_id == '_':
+        return "gettext-macro"
+
+    xml_id = re.sub(r'[,;]', '', xml_id)
+    xml_id = re.sub(r'[_ ]', '-', xml_id)
+    xml_id = re.sub(r'^-+', '', xml_id)
+    xml_id = xml_id.replace('::', '-')
+    xml_id = xml_id.replace(':', '--')
+
+    # Append ":CAPS" to all all-caps identifiers
+    # FIXME: there are some inconsistencies here, we have index files containing e.g. TRUE--CAPS
+    if xml_id.isupper() and not xml_id.endswith('-CAPS'):
+        xml_id += ':CAPS'
+
+    return xml_id
+
+def tagify(text, elem):
+    # Adds a tag around some text.
+    # e.g tagify("Text", "literal") => "<literal>Text</literal>".
+    return '<' + elem + '>' + text + '</' + elem + '>'
+
+# End of gtk-doc excerpts
+
+MarkdownExtensions = {
+  '-auto_identifiers', # we use explicit identifiers where needed
+  '+header_attributes', # for explicit identifiers
+  '+blank_before_header', # helps with gtk-doc #Object abbreviations
+  '+compact_definition_lists', # to replace <variablelist>
+  '+pipe_tables',
+  '+backtick_code_blocks', # to replace |[ ]|
+  '+fenced_code_attributes', # to add language annotations
+  '-raw_html', # to escape literal tags like <child> in input
+  '+startnum', # to have interrupted lists in the q&a part
+}
+
+def ConvertToDocbook(infile, outfile):
+    basename = os.path.basename(infile)
+    if basename.startswith('section'):
+        division='section'
+    else:
+        division='chapter'
+    input_format = "markdown" + "".join(MarkdownExtensions)
+    output_format = "docbook"
+    subprocess.check_call(["pandoc", infile, "-o", outfile,
+                           "--from=" + input_format,
+                           "--to=" + output_format,
+                           "--top-level-division=" + division])
+
+def ExpandGtkDocAbbreviations(infile, outfile):
+    contents = open(infile, 'r', encoding='utf-8').read()
+    with open(outfile, 'w', encoding='utf-8') as out:
+        out.write(ExpandAbbreviations("file", contents))
+
+
+if __name__ == '__main__':
+    tmp = tempfile.mktemp()
+    ConvertToDocbook(sys.argv[1], tmp)
+    ExpandGtkDocAbbreviations(tmp, sys.argv[2])
+    os.remove(tmp)

docs/reference/gtk/gtk4-docs.xml

@@ -6,7 +6,7 @@
 <!ENTITY pi "&#960;">
 <!ENTITY solidus "&#8260;">
 ]>
-<book id="index" xmlns:xi="http://www.w3.org/2003/XInclude">
+<book xmlns="http://docbook.org/ns/docbook" id="index" xmlns:xi="http://www.w3.org/2003/XInclude">
   <bookinfo>
     <title>GTK 4 Reference Manual</title>
     <releaseinfo>
@@ -21,16 +21,16 @@
   <part id="gtk">
     <title>Introduction</title>
     <xi:include href="overview.xml"/>
-    <xi:include href="xml/getting_started.xml"/>
+    <xi:include href="getting_started.xml"/>
     <xi:include href="resources.xml" />
-    <xi:include href="xml/question_index.xml" />
+    <xi:include href="question_index.xml" />
   </part>
 
   <part id="concepts">
     <title>GTK Concepts</title>
-    <xi:include href="xml/drawing-model.xml" />
-    <xi:include href="xml/input-handling.xml" />
-    <xi:include href="xml/actions.xml" />
+    <xi:include href="drawing-model.xml" />
+    <xi:include href="input-handling.xml" />
+    <xi:include href="actions.xml" />
   </part>
 
   <part id="gtkobjects">
@@ -48,19 +48,52 @@
 
     <chapter id="Lists">
       <title>GListModel support</title>
+      <xi:include href="xml/gtkexpression.xml" />
       <xi:include href="xml/gtkfilterlistmodel.xml" />
+      <section>
+        <xi:include href="xml/gtkfilter.xml" />
+        <xi:include href="xml/gtkcustomfilter.xml" />
+        <xi:include href="xml/gtkstringfilter.xml" />
+        <xi:include href="xml/gtkmultifilter.xml" />
+      </section>
       <xi:include href="xml/gtkflattenlistmodel.xml" />
       <xi:include href="xml/gtkmaplistmodel.xml" />
       <xi:include href="xml/gtkslicelistmodel.xml" />
       <xi:include href="xml/gtksortlistmodel.xml" />
+      <section>
+        <xi:include href="xml/gtksorter.xml" />
+        <xi:include href="xml/gtkcustomsorter.xml" />
+        <xi:include href="xml/gtkstringsorter.xml" />
+        <xi:include href="xml/gtknumericsorter.xml" />
+        <xi:include href="xml/gtkmultisorter.xml" />
+      </section>
       <xi:include href="xml/gtkselectionmodel.xml" />
       <xi:include href="xml/gtknoselection.xml" />
       <xi:include href="xml/gtksingleselection.xml" />
+      <xi:include href="xml/gtkdirectorylist.xml" />
+    </chapter>
+
+    <chapter id="ListContainers">
+      <title>List-based Widgets</title>
+      <xi:include href="section-list-widget.xml"/>
+      <xi:include href="xml/gtklistitem.xml" />
+      <xi:include href="xml/gtklistitemfactory.xml" />
+      <section>
+        <xi:include href="xml/gtksignallistitemfactory.xml" />
+        <xi:include href="xml/gtkbuilderlistitemfactory.xml" />
+      </section>
+      <xi:include href="xml/gtklistview.xml" />
+      <xi:include href="xml/gtkgridview.xml" />
+      <xi:include href="xml/gtkcolumnview.xml" />
+      <xi:include href="xml/gtkcolumnviewcolumn.xml" />
+      <xi:include href="xml/gtkdropdown.xml" />
     </chapter>
 
     <chapter id="Trees">
       <xi:include href="xml/gtktreelistrow.xml" />
       <xi:include href="xml/gtktreelistmodel.xml" />
+      <xi:include href="xml/gtktreelistrowsorter.xml" />
+      <xi:include href="xml/gtktreeexpander.xml" />
     </chapter>
 
     <chapter id="Application">
@@ -120,6 +153,7 @@
       <xi:include href="xml/gtkcenterlayout.xml" />
       <xi:include href="xml/gtkfixedlayout.xml" />
       <xi:include href="xml/gtkgridlayout.xml" />
+      <xi:include href="xml/gtkoverlaylayout.xml" />
       <xi:include href="xml/gtkcustomlayout.xml" />
       <xi:include href="xml/gtkconstraintlayout.xml" />
       <xi:include href="xml/gtkconstraint.xml" />
@@ -178,7 +212,7 @@
 
     <chapter id="TextWidgetObjects">
       <title>Multiline Text Editor</title>
-      <xi:include href="xml/text_widget.xml" />
+      <xi:include href="section-text-widget.xml" />
       <xi:include href="xml/gtktextiter.xml" />
       <xi:include href="xml/gtktextmark.xml" />
       <xi:include href="xml/gtktextbuffer.xml" />
@@ -189,7 +223,7 @@
 
     <chapter id="TreeWidgetObjects">
       <title>Tree, List and Icon Grid Widgets</title>
-      <xi:include href="xml/tree_widget.xml" />
+      <xi:include href="section-tree-widget.xml" />
       <xi:include href="xml/gtktreemodel.xml" />
       <xi:include href="xml/gtktreeselection.xml" />
       <xi:include href="xml/gtktreeviewcolumn.xml" />
@@ -225,6 +259,7 @@
       <xi:include href="xml/gtkpopover.xml" />
       <xi:include href="xml/gtkpopovermenu.xml" />
       <xi:include href="xml/gtkpopovermenubar.xml" />
+      <xi:include href="xml/gtkdropdown.xml" />
     </chapter>
 
     <chapter id="SelectorWidgets">
@@ -378,6 +413,7 @@
   <part id="theming">
     <title>Theming in GTK</title>
     <xi:include href="css-overview.xml" />
+    <xi:include href="css-properties.xml" />
     <xi:include href="xml/gtkstylecontext.xml" />
     <xi:include href="xml/gtkcssprovider.xml" />
     <xi:include href="xml/gtkstyleprovider.xml" />
@@ -397,8 +433,8 @@
       </para>
     </partintro>
 
-    <xi:include href="xml/migrating-2to4.xml" />
-    <xi:include href="xml/migrating-3to4.xml" />
+    <xi:include href="migrating-2to4.xml" />
+    <xi:include href="migrating-3to4.xml" />
   </part>
 
   <part>
@@ -418,7 +454,7 @@
   <part id="platform-support">
     <title>GTK Platform Support</title>
     <xi:include href="building.xml" />
-    <xi:include href="xml/compiling.xml" />
+    <xi:include href="compiling.xml" />
     <xi:include href="running.xml" />
     <xi:include href="x11.xml" />
     <xi:include href="windows.xml" />
@@ -427,8 +463,6 @@
     <xi:include href="wayland.xml" />
   </part>
 
-  <xi:include href="glossary.xml" />
-
   <index id="api-index-full">
     <title>Index of all symbols</title>
     <xi:include href="xml/api-index-full.xml"><xi:fallback /></xi:include>

docs/reference/gtk/gtk4-sections.txt

@@ -392,6 +392,199 @@ gtk_single_selection_set_can_unselect
 gtk_single_selection_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtklistitem</FILE>
+<TITLE>GtkListItem</TITLE>
+GtkListItem
+gtk_list_item_get_item
+gtk_list_item_get_position
+gtk_list_item_get_child
+gtk_list_item_set_child
+gtk_list_item_get_selected
+gtk_list_item_get_selectable
+gtk_list_item_set_selectable
+<SUBSECTION Standard>
+GTK_LIST_ITEM
+GTK_LIST_ITEM_CLASS
+GTK_LIST_ITEM_GET_CLASS
+GTK_IS_LIST_ITEM
+GTK_IS_LIST_ITEM_CLASS
+GTK_TYPE_LIST_ITEM
+<SUBSECTION Private>
+gtk_list_item_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtklistitemfactory</FILE>
+<TITLE>GtkListItemFactory</TITLE>
+GtkListItemFactory
+<SUBSECTION Standard>
+GTK_LIST_ITEM_FACTORY
+GTK_LIST_ITEM_FACTORY_CLASS
+GTK_LIST_ITEM_FACTORY_GET_CLASS
+GTK_IS_LIST_ITEM_FACTORY
+GTK_IS_LIST_ITEM_FACTORY_CLASS
+GTK_TYPE_LIST_ITEM_FACTORY
+<SUBSECTION Private>
+gtk_list_item_factory_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkbuilderlistitemfactory</FILE>
+<TITLE>GtkBuilderListItemFactory</TITLE>
+GtkBuilderListItemFactory
+gtk_builder_list_item_factory_new_from_bytes
+gtk_builder_list_item_factory_new_from_resource
+gtk_builder_list_item_factory_get_bytes
+gtk_builder_list_item_factory_get_resource
+gtk_builder_list_item_factory_get_scope
+<SUBSECTION Standard>
+GTK_BUILDER_LIST_ITEM_FACTORY
+GTK_BUILDER_LIST_ITEM_FACTORY_CLASS
+GTK_BUILDER_LIST_ITEM_FACTORY_GET_CLASS
+GTK_IS_BUILDER_LIST_ITEM_FACTORY
+GTK_IS_BUILDER_LIST_ITEM_FACTORY_CLASS
+GTK_TYPE_BUILDER_LIST_ITEM_FACTORY
+<SUBSECTION Private>
+gtk_builder_list_item_factory_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtksignallistitemfactory</FILE>
+<TITLE>GtkSignalListItemFactory</TITLE>
+GtkSignalListItemFactory
+gtk_signal_list_item_factory_new
+<SUBSECTION Standard>
+GTK_SIGNAL_LIST_ITEM_FACTORY
+GTK_SIGNAL_LIST_ITEM_FACTORY_CLASS
+GTK_SIGNAL_LIST_ITEM_FACTORY_GET_CLASS
+GTK_IS_SIGNAL_LIST_ITEM_FACTORY
+GTK_IS_SIGNAL_LIST_ITEM_FACTORY_CLASS
+GTK_TYPE_SIGNAL_LIST_ITEM_FACTORY
+<SUBSECTION Private>
+gtk_signal_list_item_factory_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtklistview</FILE>
+<TITLE>GtkListView</TITLE>
+GtkListView
+gtk_list_view_new
+gtk_list_view_new_with_factory
+gtk_list_view_set_factory
+gtk_list_view_get_factory
+gtk_list_view_set_model
+gtk_list_view_get_model
+gtk_list_view_set_show_separators
+gtk_list_view_get_show_separators
+gtk_list_view_set_single_click_activate
+gtk_list_view_get_single_click_activate
+gtk_list_view_set_enable_rubberband
+gtk_list_view_get_enable_rubberband
+gtk_list_view_set_search_filter
+gtk_list_view_get_search_filter
+gtk_list_view_next_match
+<SUBSECTION Standard>
+GTK_LIST_VIEW
+GTK_LIST_VIEW_CLASS
+GTK_LIST_VIEW_GET_CLASS
+GTK_IS_LIST_VIEW
+GTK_IS_LIST_VIEW_CLASS
+GTK_TYPE_LIST_VIEW
+<SUBSECTION Private>
+gtk_list_view_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkcolumnview</FILE>
+<TITLE>GtkColumnView</TITLE>
+GtkColumnView
+gtk_column_view_new
+gtk_column_view_append_column
+gtk_column_view_insert_column
+gtk_column_view_remove_column
+gtk_column_view_get_columns
+gtk_column_view_get_model
+gtk_column_view_set_model
+gtk_column_view_get_sorter
+gtk_column_view_get_show_separators
+gtk_column_view_set_show_separators
+gtk_column_view_sort_by_column
+gtk_column_view_set_single_click_activate
+gtk_column_view_get_single_click_activate
+gtk_column_view_set_enable_rubberband
+gtk_column_view_get_enable_rubberband
+gtk_column_view_set_search_filter
+gtk_column_view_get_search_filter
+gtk_column_view_next_match
+<SUBSECTION Standard>
+GTK_COLUMN_VIEW
+GTK_COLUMN_VIEW_CLASS
+GTK_COLUMN_VIEW_GET_CLASS
+GTK_IS_COLUMN_VIEW
+GTK_IS_COLUMN_VIEW_CLASS
+GTK_TYPE_COLUMN_VIEW
+<SUBSECTION Private>
+gtk_column_view_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkcolumnviewcolumn</FILE>
+<TITLE>GtkColumnViewColumn</TITLE>
+GtkColumnViewColumn
+gtk_column_view_column_new
+gtk_column_view_column_new_with_factory
+gtk_column_view_column_get_column_view
+gtk_column_view_column_set_factory
+gtk_column_view_column_get_factory
+gtk_column_view_column_set_title
+gtk_column_view_column_get_title
+gtk_column_view_column_set_sorter
+gtk_column_view_column_get_sorter
+gtk_column_view_column_set_visible
+gtk_column_view_column_get_visible
+gtk_column_view_column_set_fixed_width
+gtk_column_view_column_get_fixed_width
+<SUBSECTION Standard>
+GTK_COLUMN_VIEW_COLUMN
+GTK_COLUMN_VIEW_COLUMN_CLASS
+GTK_COLUMN_VIEW_COLUMN_GET_CLASS
+GTK_IS_COLUMN_VIEW_COLUMN
+GTK_IS_COLUMN_VIEW_COLUMN_CLASS
+GTK_TYPE_COLUMN_VIEW_COLUMN
+<SUBSECTION Private>
+gtk_column_view_column_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkgridview</FILE>
+<TITLE>GtkGridView</TITLE>
+GtkGridView
+gtk_grid_view_new
+gtk_grid_view_set_model
+gtk_grid_view_get_model
+gtk_grid_view_set_max_columns
+gtk_grid_view_get_max_columns
+gtk_grid_view_set_min_columns
+gtk_grid_view_get_min_columns
+gtk_grid_view_set_single_click_activate
+gtk_grid_view_get_single_click_activate
+gtk_grid_view_set_enable_rubberband
+gtk_grid_view_get_enable_rubberband
+gtk_grid_view_set_search_filter
+gtk_grid_view_get_search_filter
+gtk_grid_view_next_match
+<SUBSECTION Standard>
+GTK_GRID_VIEW
+GTK_GRID_VIEW_CLASS
+GTK_GRID_VIEW_GET_CLASS
+GTK_IS_GRID_VIEW
+GTK_IS_GRID_VIEW_CLASS
+GTK_TYPE_GRID_VIEW
+<SUBSECTION Private>
+gtk_grid_view_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtkbuildable</FILE>
 GtkBuildable
@@ -1160,6 +1353,92 @@ GTK_TYPE_FILE_FILTER
 gtk_file_filter_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtkdirectorylist</FILE>
+<TITLE>GtkDirectoryList</TITLE>
+GtkDirectoryList
+gtk_directory_list_new
+gtk_directory_list_get_attributes
+gtk_directory_list_set_attributes
+gtk_directory_list_get_file
+gtk_directory_list_set_file
+gtk_directory_list_get_io_priority
+gtk_directory_list_set_io_priority
+gtk_directory_list_is_loading
+gtk_directory_list_get_error
+<SUBSECTION Standard>
+GTK_DIRECTORY_LIST
+GTK_IS_DIRECTORY_LIST
+GTK_TYPE_DIRECTORY_LIST
+GTK_DIRECTORY_LIST_CLASS
+GTK_IS_DIRECTORY_LIST_CLASS
+GTK_DIRECTORY_LIST_GET_CLASS
+<SUBSECTION Private>
+gtk_directory_list_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkfilter</FILE>
+<TITLE>GtkFilter</TITLE>
+GtkFilter
+gtk_filter_match
+gtk_filter_get_strictness
+<SUBSECTION>
+GtkFilterChange
+gtk_filter_changed
+<SUBSECTION>
+gtk_custom_filter_new
+<SUBSECTION Standard>
+GTK_FILTER
+GTK_IS_FILTER
+GTK_TYPE_FILTER
+GTK_FILTER_CLASS
+GTK_IS_FILTER_CLASS
+GTK_FILTER_GET_CLASS
+<SUBSECTION Private>
+gtk_filter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkcustomfilter</FILE>
+<TITLE>GtkCustomFilter</TITLE>
+GtkCustomFilter
+GtkCustomFilterFunc
+gtk_custom_filter_new
+<SUBSECTION Standard>
+GTK_CUSTOM_FILTER
+GTK_IS_CUSTOM_FILTER
+GTK_TYPE_CUSTOM_FILTER
+GTK_CUSTOM_FILTER_CLASS
+GTK_IS_CUSTOM_FILTER_CLASS
+GTK_CUSTOM_FILTER_GET_CLASS
+<SUBSECTION Private>
+gtk_custom_filter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkmultifilter</FILE>
+<TITLE>GtkMultiFilter</TITLE>
+GtkMultiFilter
+gtk_multi_filter_append
+gtk_multi_filter_remove
+<SUBSECTION>
+GtkAnyFilter
+gtk_any_filter_new
+<SUBSECTION>
+GtkEveryFilter
+gtk_every_filter_new
+<SUBSECTION Standard>
+GTK_CUSTOM_FILTER
+GTK_IS_CUSTOM_FILTER
+GTK_TYPE_CUSTOM_FILTER
+GTK_CUSTOM_FILTER_CLASS
+GTK_IS_CUSTOM_FILTER_CLASS
+GTK_CUSTOM_FILTER_GET_CLASS
+<SUBSECTION Private>
+gtk_custom_filter_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtkfilterlistmodel</FILE>
 <TITLE>GtkFilterListModel</TITLE>
@@ -1169,9 +1448,8 @@ gtk_filter_list_model_new
 gtk_filter_list_model_new_for_type
 gtk_filter_list_model_set_model
 gtk_filter_list_model_get_model
-gtk_filter_list_model_set_filter_func
-gtk_filter_list_model_has_filter
-gtk_filter_list_model_refilter
+gtk_filter_list_model_set_filter
+gtk_filter_list_model_get_filter
 <SUBSECTION Standard>
 GTK_FILTER_LIST_MODEL
 GTK_IS_FILTER_LIST_MODEL
@@ -1486,6 +1764,7 @@ GtkIMContext
 GtkIMContextClass
 gtk_im_context_get_preedit_string
 gtk_im_context_filter_keypress
+gtk_im_context_filter_key
 gtk_im_context_focus_in
 gtk_im_context_focus_out
 gtk_im_context_reset
@@ -2335,17 +2614,123 @@ GTK_SLICE_LIST_MODEL_GET_CLASS
 gtk_slice_list_model_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtksorter</FILE>
+<TITLE>GtkSorter</TITLE>
+GtkSorter
+GtkSorterOrder
+GtkSorterChange
+gtk_sorter_compare
+gtk_sorter_get_order
+gtk_sorter_changed
+<SUBSECTION Standard>
+GTK_SORTER
+GTK_IS_SORTER
+GTK_TYPE_SORTER
+GTK_SORTER_CLASS
+GTK_IS_SORTER_CLASS
+GTK_SORTER_GET_CLASS
+<SUBSECTION Private>
+gtk_sorter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkstringsorter</FILE>
+<TITLE>GtkStringSorter</TITLE>
+GtkStringSorter
+gtk_string_sorter_new
+gtk_string_sorter_get_expression
+gtk_string_sorter_set_expression
+gtk_string_sorter_get_ignore_case
+gtk_string_sorter_set_ignore_case
+<SUBSECTION Standard>
+GTK_STRING_SORTER
+GTK_IS_STRING_SORTER
+GTK_TYPE_STRING_SORTER
+GTK_IS_STRING_SORTER_CLASS
+GTK_STRING_SORTER_GET_CLASS
+<SUBSECTION Private>
+gtk_string_sorter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtknumericsorter</FILE>
+<TITLE>GtkNumericSorter</TITLE>
+GtkNumericSorter
+gtk_numeric_sorter_new
+gtk_numeric_sorter_get_expression
+gtk_numeric_sorter_set_expression
+gtk_numeric_sorter_get_sort_order
+gtk_numeric_sorter_set_sort_order
+<SUBSECTION Standard>
+GTK_NUMERIC_SORTER
+GTK_IS_NUMERIC_SORTER
+GTK_TYPE_NUMERIC_SORTER
+GTK_IS_NUMERIC_SORTER_CLASS
+GTK_NUMERIC_SORTER_GET_CLASS
+<SUBSECTION Private>
+gtk_numeric_sorter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkcustomsorter</FILE>
+<TITLE>GtkCustomSorter</TITLE>
+GtkCustomSorter
+gtk_custom_sorter_new
+<SUBSECTION Standard>
+GTK_CUSTOM_SORTER
+GTK_IS_CUSTOM_SORTER
+GTK_TYPE_CUSTOM_SORTER
+GTK_IS_CUSTOM_SORTER_CLASS
+GTK_CUSTOM_SORTER_GET_CLASS
+<SUBSECTION Private>
+gtk_custom_sorter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkmultisorter</FILE>
+<TITLE>GtkMultiSorter</TITLE>
+GtkMultiSorter
+gtk_multi_sorter_new
+gtk_multi_sorter_append
+gtk_multi_sorter_remove
+<SUBSECTION Standard>
+GTK_MULTI_SORTER
+GTK_IS_MULTI_SORTER
+GTK_TYPE_MULTI_SORTER
+GTK_IS_MULTI_SORTER_CLASS
+GTK_MULTI_SORTER_GET_CLASS
+<SUBSECTION Private>
+gtk_multi_sorter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtktreelistrowsorter</FILE>
+<TITLE>GtkTreeListRowSorter</TITLE>
+GtkTreeListRowSorter
+gtk_tree_list_row_sorter_new
+gtk_tree_list_row_sorter_get_sorter
+gtk_tree_list_row_sorter_set_sorter
+<SUBSECTION Standard>
+GTK_TREE_LIST_ROW_SORTER
+GTK_IS_TREE_LIST_ROW_SORTER
+GTK_TYPE_TREE_LIST_ROW_SORTER
+GTK_IS_TREE_LIST_ROW_SORTER_CLASS
+GTK_TREE_LIST_ROW_SORTER_GET_CLASS
+<SUBSECTION Private>
+gtk_tree_list_row_sorter_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtksortlistmodel</FILE>
 <TITLE>GtkSortListModel</TITLE>
 GtkSortListModel
 gtk_sort_list_model_new
 gtk_sort_list_model_new_for_type
-gtk_sort_list_model_set_sort_func
-gtk_sort_list_model_has_sort
+gtk_sort_list_model_set_sorter
+gtk_sort_list_model_get_sorter
 gtk_sort_list_model_set_model
 gtk_sort_list_model_get_model
-gtk_sort_list_model_resort
 <SUBSECTION Standard>
 GTK_SORT_LIST_MODEL
 GTK_IS_SORT_LIST_MODEL
@@ -2931,6 +3316,26 @@ GTK_TREE_LIST_MODEL_GET_CLASS
 gtk_tree_list_row_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtktreeexpander</FILE>
+<TITLE>GtkTreeExpander</TITLE>
+gtk_tree_expander_new
+gtk_tree_expander_get_child
+gtk_tree_expander_set_child
+gtk_tree_expander_get_item
+gtk_tree_expander_get_list_row
+gtk_tree_expander_set_list_row
+<SUBSECTION Standard>
+GTK_TREE_EXPANDER
+GTK_IS_TREE_EXPANDER
+GTK_TYPE_TREE_EXPANDER
+GTK_TREE_EXPANDER_CLASS
+GTK_IS_TREE_EXPANDER_CLASS
+GTK_TREE_EXPANDER_GET_CLASS
+<SUBSECTION Private>
+gtk_tree_expander_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtktreemodel</FILE>
 <TITLE>GtkTreeModel</TITLE>
@@ -4010,6 +4415,7 @@ gtk_widget_get_allocation
 gtk_widget_get_allocated_baseline
 gtk_widget_get_width
 gtk_widget_get_height
+gtk_widget_get_size
 gtk_widget_compute_bounds
 gtk_widget_compute_transform
 gtk_widget_compute_point
@@ -4551,6 +4957,8 @@ GtkDeleteType
 GtkDirectionType
 GtkJustification
 GtkMovementStep
+GtkOrdering
+gtk_ordering_from_cmpfunc
 GtkOrientation
 GtkPackType
 GtkPositionType
@@ -5180,9 +5588,6 @@ gtk_application_inhibit
 gtk_application_uninhibit
 
 <SUBSECTION>
-gtk_application_prefers_app_menu
-gtk_application_get_app_menu
-gtk_application_set_app_menu
 gtk_application_get_menubar
 gtk_application_set_menubar
 gtk_application_get_menu_by_id
@@ -6986,3 +7391,99 @@ GTK_EMOJI_CHOOSER_GET_CLASS
 <SUBSECTION Private>
 gtk_emoji_chooser_get_type
 </SECTION>
+
+<SECTION>
+<FILE>gtkoverlaylayout</FILE>
+GtkOverlayLayout
+
+gtk_overlay_layout_new
+
+<SUBSECTION>
+GtkOverlayLayoutChild
+
+gtk_overlay_layout_child_set_measure
+gtk_overlay_layout_child_get_measure
+gtk_overlay_layout_child_set_clip_overlay
+gtk_overlay_layout_child_get_clip_overlay
+
+<SUBSECTION Private>
+GTK_TYPE_OVERLAY_LAYOUT
+gtk_overlay_layout_get_type
+GTK_TYPE_OVERLAY_LAYOUT_CHLD
+gtk_overlay_layout_child_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkexpression</FILE>
+GtkExpression
+GtkExpressionWatch
+GtkExpressionNotify
+gtk_expression_ref
+gtk_expression_unref
+gtk_expression_get_value_type
+gtk_expression_is_static
+gtk_expression_evaluate
+gtk_expression_watch
+gtk_expression_bind
+gtk_expression_watch_ref
+gtk_expression_watch_unref
+gtk_expression_watch_evaluate
+gtk_expression_watch_unwatch
+
+<SUBSECTION>
+gtk_property_expression_new
+gtk_property_expression_new_for_pspec
+gtk_constant_expression_new
+gtk_constant_expression_new_for_value
+gtk_object_expression_new
+gtk_closure_expression_new
+gtk_cclosure_expression_new
+
+<SUBSECTION Standard>
+GTK_IS_EXPRESSION
+GTK_TYPE_EXPRESSION
+<SUBSECTION Private>
+gtk_expression_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkstringfilter</FILE>
+GtkStringFilter
+GtkStringFilterMatchMode
+gtk_string_filter_new
+gtk_string_filter_get_search
+gtk_string_filter_set_search
+gtk_string_filter_get_expression
+gtk_string_filter_set_expression
+gtk_string_filter_get_ignore_case
+gtk_string_filter_set_ignore_case
+gtk_string_filter_get_match_mode
+gtk_string_filter_set_match_mode
+
+<SUBSECTION Private>
+gtk_string_filter_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkdropdown</FILE>
+<TITLE>GtkDropDown</TITLE>
+GtkDropDown
+gtk_drop_down_new
+gtk_drop_down_set_from_strings
+gtk_drop_down_set_model
+gtk_drop_down_get_model
+gtk_drop_down_set_selected
+gtk_drop_down_get_selected
+gtk_drop_down_set_factory
+gtk_drop_down_get_factory
+gtk_drop_down_set_list_factory
+gtk_drop_down_get_list_factory
+gtk_drop_down_set_expression
+gtk_drop_down_get_expression
+gtk_drop_down_set_enable_search
+gtk_drop_down_get_enable_search
+<SUBSECTION Standard>
+GTK_TYPE_DROP_DOWN
+<SUBSECTION Private>
+gtk_drop_down_get_type
+</SECTION>

docs/reference/gtk/gtk4.types.in

@@ -7,6 +7,7 @@ gtk_accessible_get_type
 gtk_actionable_get_type
 gtk_action_bar_get_type
 gtk_adjustment_get_type
+gtk_any_filter_get_type
 gtk_app_chooser_get_type
 gtk_app_chooser_button_get_type
 gtk_app_chooser_dialog_get_type
@@ -19,10 +20,11 @@ gtk_assistant_page_get_type
 gtk_bin_layout_get_type
 gtk_box_get_type
 gtk_box_layout_get_type
+gtk_buildable_get_type
 gtk_builder_cscope_get_type
 gtk_builder_get_type
+gtk_builder_list_item_factory_get_type
 gtk_builder_scope_get_type
-gtk_buildable_get_type
 gtk_button_get_type
 gtk_calendar_get_type
 gtk_cell_area_get_type
@@ -46,6 +48,8 @@ gtk_color_button_get_type
 gtk_color_chooser_get_type
 gtk_color_chooser_dialog_get_type
 gtk_color_chooser_widget_get_type
+gtk_column_view_get_type
+gtk_column_view_column_get_type
 gtk_combo_box_get_type
 gtk_combo_box_text_get_type
 gtk_constraint_get_type
@@ -53,12 +57,16 @@ gtk_constraint_guide_get_type
 gtk_constraint_layout_get_type
 gtk_constraint_target_get_type
 gtk_css_provider_get_type
+gtk_custom_filter_get_type
+gtk_custom_sorter_get_type
 gtk_dialog_get_type
+gtk_directory_list_get_type
 gtk_drag_icon_get_type
 gtk_drag_source_get_type
 gtk_drawing_area_get_type
 gtk_drop_target_get_type
 gtk_drop_target_async_get_type
+gtk_drop_down_get_type
 gtk_editable_get_type
 gtk_emoji_chooser_get_type
 gtk_entry_buffer_get_type
@@ -70,12 +78,14 @@ gtk_event_controller_focus_get_type
 gtk_event_controller_legacy_get_type
 gtk_event_controller_motion_get_type
 gtk_event_controller_scroll_get_type
+gtk_every_filter_get_type
 gtk_expander_get_type
 gtk_file_chooser_button_get_type
 gtk_file_chooser_dialog_get_type
 gtk_file_chooser_get_type
 gtk_file_chooser_widget_get_type
 gtk_file_filter_get_type
+gtk_filter_get_type
 gtk_filter_list_model_get_type
 gtk_fixed_get_type
 gtk_fixed_layout_get_type
@@ -101,6 +111,7 @@ gtk_gl_area_get_type
 gtk_grid_get_type
 gtk_grid_layout_child_get_type
 gtk_grid_layout_get_type
+gtk_grid_view_get_type
 gtk_header_bar_get_type
 gtk_icon_theme_get_type
 gtk_icon_view_get_type
@@ -113,9 +124,12 @@ gtk_label_get_type
 gtk_layout_child_get_type
 gtk_layout_manager_get_type
 gtk_link_button_get_type
+gtk_list_item_get_type
+gtk_list_item_factory_get_type
 gtk_list_store_get_type
 gtk_list_box_get_type
 gtk_list_box_row_get_type
+gtk_list_view_get_type
 gtk_lock_button_get_type
 gtk_map_list_model_get_type
 gtk_media_controls_get_type
@@ -124,13 +138,18 @@ gtk_media_stream_get_type
 gtk_menu_button_get_type
 gtk_message_dialog_get_type
 gtk_mount_operation_get_type
+gtk_multi_filter_get_type
+gtk_multi_sorter_get_type
 gtk_native_get_type
 gtk_native_dialog_get_type
 gtk_no_selection_get_type
 gtk_notebook_get_type
 gtk_notebook_page_get_type
+gtk_numeric_sorter_get_type
 gtk_orientable_get_type
 gtk_overlay_get_type
+gtk_overlay_layout_get_type
+gtk_overlay_layout_child_get_type
 gtk_pad_controller_get_type
 gtk_page_setup_get_type
 @DISABLE_ON_W32@gtk_page_setup_unix_dialog_get_type
@@ -172,11 +191,13 @@ gtk_shortcuts_window_get_type
 gtk_shortcuts_section_get_type
 gtk_shortcuts_group_get_type
 gtk_shortcuts_shortcut_get_type
+gtk_signal_list_item_factory_get_type
 gtk_single_selection_get_type
 gtk_size_group_get_type
 gtk_slice_list_model_get_type
 gtk_snapshot_get_type
 gtk_sort_list_model_get_type
+gtk_sorter_get_type
 gtk_spin_button_get_type
 gtk_spinner_get_type
 gtk_stack_get_type
@@ -184,6 +205,8 @@ gtk_stack_page_get_type
 gtk_stack_sidebar_get_type
 gtk_stack_switcher_get_type
 gtk_statusbar_get_type
+gtk_string_filter_get_type
+gtk_string_sorter_get_type
 gtk_switch_get_type
 gtk_level_bar_get_type
 gtk_style_context_get_type
@@ -201,6 +224,7 @@ gtk_tree_drag_dest_get_type
 gtk_tree_drag_source_get_type
 gtk_tree_list_model_get_type
 gtk_tree_list_row_get_type
+gtk_tree_list_row_sorter_get_type
 gtk_tree_model_filter_get_type
 gtk_tree_model_get_type
 gtk_tree_model_sort_get_type

docs/reference/gtk/input-handling.md

@@ -0,0 +1,206 @@
+# Overview of GTK input and event handling {#input-overview}
+
+This chapter describes in detail how GTK handles input. If you are interested
+in what happens to translate a key press or mouse motion of the users into a
+change of a GTK widget, you should read this chapter. This knowledge will also
+be useful if you decide to implement your own widgets.
+
+Devices and events
+
+The most basic input devices that every computer user has interacted with are
+keyboards and mice; beyond these, GTK supports touchpads, touchscreens and
+more exotic input devices such as graphics tablets. Inside GTK, every such
+input device is represented by a #GdkDevice object.
+
+To simplify dealing with the variability between these input devices, GTK
+has a concept of master and slave devices. The concrete physical devices that
+have many different characteristics (mice may have 2 or 3 or 8 buttons,
+keyboards have different layouts and may or may not have a separate number
+block, etc) are represented as slave devices. Each slave device is
+associated with a virtual master device. Master devices always come in
+pointer/keyboard pairs - you can think of such a pair as a 'seat'.
+
+GTK widgets generally deal with the master devices, and thus can be used
+with any pointing device or keyboard.
+
+When a user interacts with an input device (e.g. moves a mouse or presses
+a key on the keyboard), GTK receives events from the windowing system.
+These are typically directed at a specific surface - for pointer events,
+the surface under the pointer (grabs complicate this), for keyboard events,
+the surface with the keyboard focus.
+
+GDK translates these raw windowing system events into #GdkEvents.
+Typical input events are button clicks, pointer motion, key presses
+or touch events. These are all represented as #GdkEvents, but you can
+differentiate between different events by looking at their type, using
+gdk_event_get_event_type().
+
+Some events, such as touch events or button press-release pairs,
+are connected in to each other in an “event sequence” that
+univocally identifies events that are related to the same
+interaction.
+
+When GTK creates a GdkSurface, it connects to the #GdkSurface::event
+signal on it, which receives all of these input events. Surfaces have
+have signals and properties, e.g. to deal with window management
+related events.
+
+## Event propagation {#event-propagation}
+
+The function which initially receives input events on the GTK
+side is responsible for a number of tasks.
+
+1. Find the widget which got the event.
+2. Generate crossing (i.e. enter and leave) events when the focus or
+   hover location change from one widget to another.
+3. Send the event to widgets.
+
+An event is propagated down and up the widget hierarchy in three phases
+(see #GtkPropagationPhase) towards a target widget.
+
+![Event propagation phases](capture-bubble.png)
+
+For key events, the top-level window gets a first shot at activating
+mnemonics and accelerators. If that does not consume the events,
+the target widget for event propagation is window's current focus
+widget (see gtk_window_get_focus()).
+
+For pointer events, the target widget is determined by picking
+the widget at the events coordinates (see gtk_window_pick()).
+
+In the first phase (the “capture” phase) the event is delivered to
+each widget from the top-most (the top-level #GtkWindow or grab widget)
+down to the target #GtkWidget.
+[Event controllers](event-controllers-and-gestures) that are attached
+with %GTK_PHASE_CAPTURE get a chance to react to the event.
+
+After the “capture” phase, the widget that was intended to be the
+destination of the event will run event controllers attached to
+it with %GTK_PHASE_TARGET. This is known as the “target” phase,
+and only happens on that widget.
+
+In the last phase (the “bubble” phase), the event is delivered
+to each widget from the target to the top-most, and event
+controllers attached with %GTK_PHASE_BUBBLE are run.
+
+Events are not delivered to a widget which is insensitive or unmapped.
+
+Any time during the propagation phase, a controller may indicate
+that a received event was consumed and propagation should
+therefore be stopped. If gestures are used, this may happen
+when the gesture claims the event touch sequence (or the
+pointer events) for its own. See the “gesture states” section
+below to learn more about gestures and sequences.
+
+## Keyboard input
+
+Every #GtkWindow maintains a single focus location (in
+the #GtkWindow:focus-widget property). The focus widget is the
+target widget for key events sent to the window. Only widgets which
+have #GtkWidget:can-focus set to %TRUE can become the focus. Typically
+these are input controls such as entries or text fields, but e.g.
+buttons can take the focus too.
+
+Input widgets can be given the focus by clicking on them, but focus
+can also be moved around with certain key events (this is known as
+“keyboard navigation”). GTK reserves the Tab key to move the focus
+to the next location, and Shift-Tab to move it back to the previous
+one. In addition many containers allow “directional navigation” with
+the arrow keys.
+
+Many widgets can be “activated” to trigger and action. E.g., you can
+activate a button or switch by clicking on them, but you can also
+activate them with the keyboard, by using the Enter or Space keys.
+
+Apart from keyboard navigation, activation and directly typing into
+entries or text views, GTK widgets can use key events for activating
+“shortcuts”. Shortcuts generally act as a quick way to move the focus
+around or to activate a widget that does not currently have the focus.
+
+GTK has traditionally supported different kinds of shortcuts:
+
+Accelerators
+ : Accelerators are any other shortcuts that can be activated regardless
+   of where the focus is, and typically trigger global actions, such as
+   Ctrl-Q to quit an application.
+Mnmemonics
+ : Mnemonics are usually triggered using Alt as a modifier for a letter.
+   They are used in places where a label is associated with a control,
+   and are indicated by underlining the letter in the label. As a special
+   case, inside menus (i.e. inside #GtkPopoverMenu), mnemonics can be
+   trigered without the modifier.
+Key bindings
+ : Key bindings are specific to individual widgets, such as Ctrl-C or
+   Ctrl-V in an entry copy to or paste from the clipboard. They are only
+   triggered when the widget has focus.
+   
+GTK handles accelerators and mnemonics in a global scope, during the
+capture phase, and key bindings locally, during the target phase.
+
+Under the hood, all shortcuts are represented as instances of #GtkShortcut,
+and they are managed by #GtkShortcutController.
+
+## Event controllers and gestures {#event-controllers-and-gestures}
+
+Event controllers are standalone objects that can perform
+specific actions upon received #GdkEvents. These are tied
+to a #GtkWidget, and can be told of the event propagation
+phase at which they will manage the events.
+
+Gestures are a set of specific controllers that are prepared
+to handle pointer and/or touch events, each gesture
+implementation attempts to recognize specific actions out the
+received events, notifying of the state/progress accordingly to
+let the widget react to those. On multi-touch gestures, every
+interacting touch sequence will be tracked independently.
+
+Since gestures are “simple” units, it is not uncommon to tie
+several together to perform higher level actions, grouped
+gestures handle the same event sequences simultaneously, and
+those sequences share a same state across all grouped
+gestures. Some examples of grouping may be:
+
+- A “drag” and a “swipe” gestures may want grouping.
+  The former will report events as the dragging happens,
+  the latter will tell the swipe X/Y velocities only after
+  recognition has finished.
+- Grouping a “drag” gesture with a “pan” gesture will only
+  effectively allow dragging in the panning orientation, as
+  both gestures share state.
+- If “press” and “long press” are wanted simultaneously,
+  those would need grouping.
+
+Shortcuts are handled by #GtkShortcutController, which is
+a complex event handler that can either activate shortcuts
+itself, or propagate them to another controller, depending
+on its #GtkShortcutController:scope.
+
+## Gesture states
+
+Gestures have a notion of “state” for each individual touch
+sequence. When events from a touch sequence are first received,
+the touch sequence will have “none” state, this means the touch
+sequence is being handled by the gesture to possibly trigger
+actions, but the event propagation will not be stopped.
+
+When the gesture enters recognition, or at a later point in time,
+the widget may choose to claim the touch sequences (individually
+or as a group), hence stopping event propagation after the event
+is run through every gesture in that widget and propagation phase.
+Anytime this happens, the touch sequences are cancelled downwards
+the propagation chain, to let these know that no further events
+will be sent.
+
+Alternatively, or at a later point in time, the widget may choose
+to deny the touch sequences, thus letting those go through again
+in event propagation. When this happens in the capture phase, and
+if there are no other claiming gestures in the widget,
+a %GDK_TOUCH_BEGIN/%GDK_BUTTON_PRESS event will be emulated and
+propagated downwards, in order to preserve consistency.
+
+Grouped gestures always share the same state for a given touch
+sequence, so setting the state on one does transfer the state to
+the others. They also are mutually exclusive, within a widget
+where may be only one gesture group claiming a given sequence.
+If another gesture group claims later that same sequence, the
+first group will deny the sequence:

docs/reference/gtk/input-handling.xml

@@ -1,332 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="chap-input-handling">
-<refmeta>
-<refentrytitle>The GTK Input Model</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>The GTK Input Model</refname>
-<refpurpose>
-    input and event handling in detail
-</refpurpose>
-</refnamediv>
-
-
-  <refsect1 id="input-overview">
-    <title>Overview of GTK input and event handling</title>
-
-  <para>
-   This chapter describes in detail how GTK handles input. If you are interested
-   in what happens to translate a key press or mouse motion of the users into a
-   change of a GTK widget, you should read this chapter. This knowledge will also
-   be useful if you decide to implement your own widgets.
-  </para>
-
-  <refsect2>
-    <title>Devices and events</title>
-
-    <!-- input devices: master/slave, keyboard/pointer/touch -->
-    <para>
-     The most basic input devices that every computer user has interacted with are
-     keyboards and mice; beyond these, GTK supports touchpads, touchscreens and
-     more exotic input devices such as graphics tablets. Inside GTK, every such
-     input device is represented by a #GdkDevice object.
-    </para>
-
-    <para>
-     To simplify dealing with the variability between these input devices, GTK
-     has a concept of master and slave devices. The concrete physical devices that
-     have many different characteristics (mice may have 2 or 3 or 8 buttons,
-     keyboards have different layouts and may or may not have a separate number
-     block, etc) are represented as slave devices. Each slave device is
-     associated with a virtual master device. Master devices always come in
-     pointer/keyboard pairs - you can think of such a pair as a 'seat'.
-    </para>
-    <para>
-     GTK widgets generally deal with the master devices, and thus can be used
-     with any pointing device or keyboard.
-    </para>
-
-    <para>
-     When a user interacts with an input device (e.g. moves a mouse or presses
-     a key on the keyboard), GTK receives events from the windowing system.
-     These are typically directed at a specific surface - for pointer events,
-     the surface under the pointer (grabs complicate this), for keyboard events,
-     the surface with the keyboard focus.
-    </para>
-    <para>
-     GDK translates these raw windowing system events into #GdkEvents.
-     Typical input events are button clicks, pointer motion, key presses
-     or touch events. These are all represented as #GdkEvents, but you can
-     differentiate between different events by looking at their type, using
-     gdk_event_get_event_type().
-    </para>
-    <para>
-      Some events, such as touch events or button press-release pairs,
-      are connected in to each other in an “event sequence” that
-      univocally identifies events that are related to the same
-      interaction.
-    </para>
-    <para>
-      When GTK creates a GdkSurface, it connects to the #GdkSurface::event
-      signal on it, which receives all of these input events. Surfaces have
-      have signals and properties, e.g. to deal with window management
-      related events.
-    </para>
-  </refsect2>
-
-  <refsect2 id="event-propagation">
-    <title>Event propagation</title>
-
-    <para>
-      The function which initially receives input events on the GTK
-      side is responsible for a number of tasks.
-    </para>
-    <orderedlist>
-      <listitem><para>
-        Find the widget which got the event.
-      </para></listitem>
-      <listitem><para>
-        Generate crossing (i.e. enter and leave) events when the focus or hover
-        location change from one widget to another.
-      </para></listitem>
-      <listitem><para>
-        The event is sent to widgets.
-      </para></listitem>
-    </orderedlist>
-
-    <para>
-      An event is propagated down and up the widget hierarchy in three phases
-      (see #GtkPropagationPhase) towards a target widget.
-    </para>
-
-    <informalfigure>
-      <mediaobject>
-        <imageobject>
-          <imagedata fileref="capture-bubble.png" format="PNG"/>
-        </imageobject>
-      </mediaobject>
-    </informalfigure>
-
-    <para>
-      For key events, the top-level window gets a first shot at activating
-      mnemonics and accelerators. If that does not consume the events,
-      the target widget for event propagation is window's current focus
-      widget (see gtk_window_get_focus()).
-    </para>
-
-    <para>
-      For pointer events, the target widget is determined by picking
-      the widget at the events coordinates (see gtk_window_pick()).
-    </para>
-
-    <para>In the first phase (the “capture” phase) the event is
-      delivered to each widget from the top-most (the top-level
-      #GtkWindow or grab widget) down to the target #GtkWidget.
-      <link linkend="event-controllers-and-gestures">Event
-      controllers</link> that are attached with %GTK_PHASE_CAPTURE
-      get a chance to react to the event.
-    </para>
-
-    <para>
-      After the “capture” phase, the widget that was intended to be the
-      destination of the event will run event controllers attached to
-      it with %GTK_PHASE_TARGET. This is known as the “target” phase,
-      and only happens on that widget.
-    </para>
-
-    <para>
-      In the last phase (the “bubble” phase), the event is delivered
-      to each widget from the target to the top-most, and event
-      controllers attached with %GTK_PHASE_BUBBLE are run.
-    </para>
-
-    <para>
-      Events are not delivered to a widget which is insensitive or
-      unmapped.
-    </para>
-
-    <para>
-      Any time during the propagation phase, a controller may indicate
-      that a received event was consumed and propagation should
-      therefore be stopped. If gestures are used, this may happen
-      when the gesture claims the event touch sequence (or the
-      pointer events) for its own. See the “gesture states” section
-      below to learn more about gestures and sequences.
-    </para>
-  </refsect2>
-
-  <refsect2>
-    <title>Keyboard input</title>
-
-    <para>
-      Every #GtkWindow maintains a single focus location (in the
-      #GtkWindow:focus-widget property). The focus widget is the target
-      widget for key events sent to the window. Only widgets which have
-      #GtkWidget:can-focus set to %TRUE can become the focus. Typically
-      these are input controls such as entries or text fields, but e.g.
-      buttons can take the focus too.
-    </para>
-
-    <para>
-      Input widgets can be given the focus by clicking on them, but focus
-      can also be moved around with certain key events (this is known as
-      “keyboard navigation”). GTK reserves the Tab key to move the focus
-      to the next location, and Shift-Tab to move it back to the previous
-      one. In addition many containers allow “directional navigation” with
-      the arrow keys.
-    </para>
-
-    <para>
-      Many widgets can be “activated” to trigger and action. E.g., you can
-      activate a button or switch by clicking on them, but you can also
-      activate them with the keyboard, by using the Enter or Space keys.
-    </para>
-
-    <para>
-      Apart from keyboard navigation, activation and directly typing into
-      entries or text views, GTK widgets can use key events for activating
-      “shortcuts”. Shortcuts generally act as a quick way to move the focus
-      around or to activate a widget that does not currently have the focus.
-    </para>
-
-    <para>
-      GTK has traditionally supported different kinds of shortcuts:
-      <variablelist>
-        <varlistentry>
-          <term>Accelerators</term>
-          <listitem><para>
-            Accelerators are any other shortcuts that can be activated regardless
-            of where the focus is, and typically trigger global actions, such as
-            Ctrl-Q to quit an application.
-          </para></listitem>
-        </varlistentry>
-        <varlistentry>
-          <term>Mnmemonics</term>
-          <listitem><para>
-            Mnemonics are usually triggered using Alt as a modifier for a letter.
-            They are used in places where a label is associated with a control,
-            and are indicated by underlining the letter in the label. As a special
-            case, inside menus (i.e. inside #GtkPopoverMenu), mnemonics can be
-            trigered without the modifier.
-          </para></listitem>
-        </varlistentry>
-        <varlistentry>
-          <term>Key bindings</term>
-          <listitem><para>
-            Key bindings are specific to individual widgets, such as Ctrl-C or
-            Ctrl-V in an entry copy to or paste from the clipboard. They are only
-            triggered when the widget has focus.
-          </para></listitem>
-        </varlistentry>
-      </variablelist>
-    </para>
-    <para>
-      GTK traditionally handles accelerators and mnemonics in a global scope,
-      during the capture phase, and key bindings locally, during the target phase.
-    </para>
-    <para>
-      Under the hood, all shortcuts are represented as instances of #GtkShortcut,
-      and they are managed by #GtkShortcutController.
-    </para>
-  </refsect2>
-
-  <refsect2 id="event-controllers-and-gestures">
-    <title>Event controllers and gestures</title>
-
-    <para>
-      Event controllers are standalone objects that can perform
-      specific actions upon received #GdkEvents. These are tied
-      to a #GtkWidget, and can be told of the event propagation
-      phase at which they will manage the events.
-    </para>
-
-    <para>
-      Gestures are a set of specific controllers that are prepared
-      to handle pointer and/or touch events, each gesture
-      implementation attempts to recognize specific actions out the
-      received events, notifying of the state/progress accordingly to
-      let the widget react to those. On multi-touch gestures, every
-      interacting touch sequence will be tracked independently.
-    </para>
-
-    <para>
-      Since gestures are “simple” units, it is not uncommon to tie
-      several together to perform higher level actions, grouped
-      gestures handle the same event sequences simultaneously, and
-      those sequences share a same state across all grouped
-      gestures. Some examples of grouping may be:
-
-      <simplelist>
-	<member>
-	  A “drag” and a “swipe” gestures may want grouping.
-          The former will report events as the dragging happens,
-          the latter will tell the swipe X/Y velocities only after
-          recognition has finished.
-	</member>
-	<member>
-	  Grouping a “drag” gesture with a “pan” gesture will only
-          effectively allow dragging in the panning orientation, as
-          both gestures share state.
-	</member>
-	<member>
-	  If “press” and “long press” are wanted simultaneously,
-          those would need grouping.
-	</member>
-      </simplelist>
-    </para>
-
-    <para>
-      Shortcuts are handled by #GtkShortcutController, which is
-      a complex event handler that can either activate shortcuts
-      itself, or propagate them to another controller, depending
-      on its #GtkShortcutController:scope.
-    </para>
-  </refsect2>
-
-  <refsect2>
-    <title>Gesture states</title>
-    <para>
-      Gestures have a notion of “state” for each individual touch
-      sequence. When events from a touch sequence are first received,
-      the touch sequence will have “none” state, this means the touch
-      sequence is being handled by the gesture to possibly trigger
-      actions, but the event propagation will not be stopped.
-    </para>
-
-    <para>
-      When the gesture enters recognition, or at a later point in time,
-      the widget may choose to claim the touch sequences (individually
-      or as a group), hence stopping event propagation after the event
-      is run through every gesture in that widget and propagation phase.
-      Anytime this happens, the touch sequences are cancelled downwards
-      the propagation chain, to let these know that no further events
-      will be sent.
-    </para>
-
-    <para>
-      Alternatively, or at a later point in time, the widget may choose
-      to deny the touch sequences, thus letting those go through again
-      in event propagation. When this happens in the capture phase, and
-      if there are no other claiming gestures in the widget,
-      a %GDK_TOUCH_BEGIN/%GDK_BUTTON_PRESS event will be emulated and
-      propagated downwards, in order to preserve consistency.
-    </para>
-
-    <para>
-      Grouped gestures always share the same state for a given touch
-      sequence, so setting the state on one does transfer the state to
-      the others. They also are mutually exclusive, within a widget
-      there may be only one gesture group claiming a given sequence.
-      If another gesture group claims later that same sequence, the
-      first group will deny the sequence.
-    </para>
-  </refsect2>
-
-  </refsect1>
-</refentry>

docs/reference/gtk/lists-overview.md

@@ -0,0 +1,101 @@
+# List widgets
+
+GTK provides powerful widgets to display and edit lists of data. This document gives an overview over the concepts and how they work together to allow developers to implement lists.
+
+Lists are intended to be used whenever developers want to display lists of objects in roughly the same way.  
+
+Lists are perfectly fine to be used for very short list of only 2 or 3 elements, but generally scale fine to millions of items. Of course, the larger the list grows, the more care needs to be taken to choose the right data structures to keep things running well.
+
+Lists are meant to be used with changing data, both with the items itself changing as well as the list adding and removing items. Of course, they work just as well with static data.
+
+## Terminology
+
+These terms are used throughout the documentation when talking about lists and you should be aware of what they refer to. These are often generic terms that have a specific meaning in this context.
+
+**_Views_** or **_list widgets_** are the widgets that hold and manage the lists. Examples of thse widgets would be #GtkListView or #GtkGridView.
+
+Views display data from a **_model_**. A model is a #GListModel and models can be provided in 3 ways or combinations thereof:
+
+ * Many list models implementations already exist. There are models that provide specific data, like #GtkDirectoryList. And there are models like #GListStore that allow building lists manually.
+
+ * Wrapping list models exists like #GtkFilterListModel or #GtkSortListModel that modify or adapt or combine other models.
+
+ * Last but not least, developers are encouraged to create their own #GListModel implementations. The interface is kept deliberately small to make this easy.
+
+The same model can be used in multiple different views and wrapped with multiple different models at once.
+
+The elements in a model are called **_items_**. All items are #GObjects.
+
+Every item in a model has a **_position_** which is the unsigned integer that describes where in the model the item is located. This position can of course change as items are added or removed from the model.  
+
+It is important to be aware of the difference between items and positions because the mapping from position to item is not permanent, so developers should think about whether they want to track items or positions when working with models. Oftentimes some things are really hard to do one way but very easy the other way.
+
+The other important part of a view is a **_factory_**. Each factory is a #GtkListItemFactory implementation that takes care of mapping the items of the model to widgets that can be shown in the view.
+
+The way factories do this is by creating a **_listitem_** for each item that is currently in use. Listitems are always #GtkListItem objects. They are only ever created by GTK and provide information about what item they are meant to display.
+
+Different factory implementations use various different methods to allow developers to add the right widgets to listitems and to link those widgets with the item managed by the listitem. Finding a suitable factory implementation for the data displayed, the programming language and development environment is an important task that can simplify setting up the view tremendously.
+
+Views support selections via a **_selection model_**. A selection model is an implementation of the #GtkSelectionModel interface on top of the #GListModel interface that allows marking each item in a model as either selected or not selected. Just like regular models, this can be implemented either by implementing #GtkSelectionModel directly or by wrapping a model with one of the GTK models provided for this purposes, such as #GtkNoSelection or #GtkSingleSelection. The behavior of selection models - ie which items they allow selecting and what effect this has on other items - is completely up to the selection model. As such, single-selections, multi-selections or sharing selection state between different selection models and/or views is possible. The selection state of an item is exposed in the listitem via the GtkListItem:selected property.
+
+Views and listitems also support activation. Activation means that double clicking or pressing enter while inside a focused row will cause the view to emit and activation signal such as GtkListView::activate. This provides an easy way to set up lists, but can also be turned off on listitems if undesired.
+
+Both selections and activation are supported among other things via widget actions (FIXME: Link docs). This allows developers to add widgets to their lists that cause selections to change or to trigger activation via the #GtkActionable interface. For a list of all supported actions see the relevant documentation. (FIXME: where do we document actions and how to I link that?)
+
+## Behind the scenes
+
+While for short lists it is not a problem to instantiate widgets for every item in the model, once lists grow to thousands or millions of elements, this gets less feasible. Because of this, the views only create a limited amount of listitems and recycle them by binding them to new items. In general, views try to keep listitems available only for the items that can actually be seen on screen.
+
+While this behavior allows views to scale effortlessly to huge lists, it has a few implication on what can be done with views. For example, it is not possible to query a view for a listitem used for a certain position - there might not be one and even if there is, that listitem might soon be recycled for a new position.
+
+It is also important that developers save state they care about in the item and do not rely on the widgets they created as those widgets can be recycled for a new position at any time causing any state to be lost.
+
+Another important requirement for views is that they need to know which items are not visible so they can be recycled. Views achieve that by implementing the #GtkScrollable interface and expecting to be placed directly into a #GtkScrolledWindow.
+
+Of course, if you are only using models with few items, this is not important and you can treat views like any other widget. But if you use large lists and your performance suffers, you should be aware of this. Views also allow tuning the number of listitems they create such as with gtk_grid_view_set_max_columns(), and developers running into performance problems should definitely study the tradeoffs of those and experiment with them.
+
+## Displaying trees
+
+While #GtkTreeView provided builtin support for trees, the list widgets, and in particular #GListModel do not. This was a design choice because the common use case is displaying lists and not trees and it greatly simplifies the API interface provided.
+
+However, GTK provides functionality to make trees look and behave like lists for the people who still want to display lists. This is achieved by using the #GtkTreeListModel model to flatten a tree into a list. The #GtkTreeExpander widget can then be used inside a listitem to allow users to expand and collapse rows and provide a similar experience to #GtkTreeView.
+
+Developers should refer to those objects' API reference for more discussion on the topic.
+
+## comparison to GtkTreeView
+
+Developers familiar with #GtkTreeView may wonder how this way of doing lists compares to the way they know. This section will try to outline the similarities and differences between the two.  
+
+This new approach tries to provide roughly the same functionality as the old approach but often uses a very different approach to achieve these goals.
+
+The main difference and one of the primary reasons for this new development is that items can be displayed using regular widgets and #GtkCellRenderer is no longer necessary. This allows all benefits that widgets provide, such as complex layout and animating widgets and not only makes cell renderers obsolete, but also #GtkCellArea.
+
+The other big difference is the massive change to the data model. #GtkTreeModel was a rather complex interface for a tree data structure and #GListModel was deliberately designed to be a simple data structure for lists only. (See above (FIXME: link) for how to still do trees with this new model.) Another big change is that the new model allows for bulk changes via the #GListModel:items-changed signal while #GtkTreeModel only allows a single item to change at once.  The goal here is of course to encourage implementation of custom list models.
+
+Another consequence of the new model is that it is now easily possible to refer to the contents of a row in the model directly by keeping the item, while #GtkTreeRowReference was a very slow mechanism to achieve the same. And because the items are real objects, developers can make them emit change signals causing listitems and their children to update, which wasn't possible with #GtkTreeModel.
+
+The selection handling is also different. While selections used to be managed via custom code in each widget, selection state is now meant to be managed by the selection models. In particular this allows for complex use cases with specialized requirements (FIXME: Can I add a shoutout to @mitch here because I vividly remember a huge discussion about GtkTreeView's selection behavior and the Gimp).
+
+Finally here's a quick list of equivalent functionality to look for when transitioning code for easy lookup:
+
+| old                 | new                                 |
+| ------------------- | ----------------------------------- |
+| #GtkTreeModel       | #GListModel                         |
+| #GtkTreePath        | #guint position, #GtkTreeListRow    |
+| #GtkTreeIter        | #guint position                     |
+| GtkTreeRowReference | #GObject item                       |
+| #GtkListStore       | #GListStore                         |
+| #GtkTreeStore       | #GtkTreeListModel, #GtkTreeExpander |
+| #GtkTreeSelection   | #GtkSelectionModel                  |
+| #GtkTreeViewColumn  | #GtkColumnView                      |
+| #GtkTreeView        | #GtkListView, #GtkColumnView        |
+| #GtkCellView        |                                     |
+| #GtkComboBox        |                                     |
+| #GtkIconView        | #GtkGridView                        |
+| #GtkTreeSortable    |                                     |
+| #GtkTreeModelSort   | #GtkSortListModel                   |
+| #GtkTreeModelFilter | #GtkFilterListModel                 |
+| #GtkCellLayout      | #GtkListItemFactory                 |
+| #GtkCellArea        | #GtkWidget                          |
+| #GtkCellRenderer    | #GtkWidget                          |
+

docs/reference/gtk/meson.build

@@ -1,3 +1,5 @@
+fs = import('fs')
+
 private_headers = [
   'imm-extra.h',
   'gtkbitmaskprivateimpl.h',
@@ -22,6 +24,13 @@ private_headers = [
   'gtkcolorplaneprivate.h',
   'gtkcolorscaleprivate.h',
   'gtkcolorswatchprivate.h',
+  'gtkcolumnlistitemfactoryprivate.h',
+  'gtkcolumnviewcellprivate.h',
+  'gtkcolumnviewcolumnprivate.h',
+  'gtkcolumnviewlayoutprivate.h',
+  'gtkcolumnviewprivate.h',
+  'gtkcolumnviewsorterprivate.h',
+  'gtkcolumnviewtitleprivate.h',
   'gtkcomboboxprivate.h',
   'gtkconstraintexpressionprivate.h',
   'gtkconstraintguideprivate.h',
@@ -130,6 +139,11 @@ private_headers = [
   'gtkimmoduleprivate.h',
   'gtkkineticscrollingprivate.h',
   'gtklabelprivate.h',
+  'gtklistbaseprivate.h',
+  'gtklistitemprivate.h',
+  'gtklistitemfactoryprivate.h',
+  'gtklistitemmanagerprivate.h',
+  'gtklistitemwidgetprivate.h',
   'gtklockbuttonprivate.h',
   'gtkmagnifierprivate.h',
   'gtkmediafileprivate.h',
@@ -338,13 +352,6 @@ images = [
 ]
 
 content_files = [
-  'actions.xml',
-  'broadway.xml',
-  'building.xml',
-  'compiling.xml',
-  'css-overview.xml',
-  'drawing-model.xml',
-  'glossary.xml',
   'gtk4-broadwayd.xml',
   'gtk4-builder-tool.xml',
   'gtk4-demo-application.xml',
@@ -355,34 +362,32 @@ content_files = [
   'gtk4-query-settings.xml',
   'gtk4-update-icon-cache.xml',
   'gtk4-widget-factory.xml',
-  'input-handling.xml',
-  'migrating-2to4.xml',
-  'migrating-3to4.xml',
-  'osx.xml',
-  'other_software.xml',
   'overview.xml',
-  'question_index.xml',
-  'resources.xml',
-  'running.xml',
-  'text_widget.xml',
-  'tree_widget.xml',
   'visual_index.xml',
-  'wayland.xml',
-  'windows.xml',
-  'x11.xml',
 ]
 
-expand_content_files = [
-  'actions.xml',
-  'compiling.xml',
-  'drawing-model.xml',
-  'glossary.xml',
-  'input-handling.xml',
-  'migrating-2to4.xml',
-  'migrating-3to4.xml',
-  'question_index.xml',
-  'text_widget.xml',
-  'tree_widget.xml',
+expand_content_md_files = [
+  'broadway.md',
+  'osx.md',
+  'wayland.md',
+  'windows.md',
+  'x11.md',
+  'getting_started.md',
+  'resources.md',
+  'building.md',
+  'compiling.md',
+  'running.md',
+  'migrating-2to4.md',
+  'migrating-3to4.md',
+  'actions.md',
+  'input-handling.md',
+  'drawing-model.md',
+  'css-overview.md',
+  'css-properties.md',
+  'section-text-widget.md',
+  'section-tree-widget.md',
+  'section-list-widget.md',
+  'question_index.md',
 ]
 
 types_conf = configuration_data()
@@ -400,7 +405,17 @@ endif
 
 if get_option('gtk_doc')
   configure_file(input: 'version.xml.in', output: 'version.xml', configuration: version_conf)
-  configure_file(input: 'getting_started.xml.in', output: 'getting_started.xml', configuration: src_dir_conf)
+
+  # gtk-markdown-to-docbook uses pandoc
+  pandoc = find_program('pandoc', required: true)
+  expand_md = find_program('gtk-markdown-to-docbook')
+  expand_md_targets = []
+  foreach t : expand_content_md_files
+    expand_md_targets += custom_target(t,
+                                       input: [ t ],
+                                       output: [ fs.replace_suffix(t, '.xml') ],
+                                       command: [ expand_md, '@INPUT@', '@OUTPUT@'])
+  endforeach
 
   gnome.gtkdoc('gtk4',
                mode: 'none',
@@ -431,8 +446,7 @@ if get_option('gtk_doc')
                  '--extra-dir=../gdk',
                  '--extra-dir=../gsk',
                ],
-               content_files: content_files,
-               expand_content_files: expand_content_files,
+               content_files: content_files + expand_md_targets,
                html_assets: images,
                install: true)
 endif

docs/reference/gtk/migrating-2to4.md

@@ -0,0 +1,5 @@
+# Migrating from GTK 2.x to GTK 4 {#gtk-migrating-2-to-4}
+
+If your application is still using GTK 2, you should first convert it to GTK 3,
+by following the [migration guide](https://developer.gnome.org/gtk3/stable/gtk-migrating-2-to-3.html)
+in the GTK 3 documentation, and then follow [these instructions](#gtk-migrating-3-to-4).

docs/reference/gtk/migrating-2to4.xml

@@ -1,15 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-<!ENTITY % local.common.attrib "xmlns:xi  CDATA  #FIXED 'http://www.w3.org/2003/XInclude'">
-]>
-<chapter id="gtk-migrating-2-to-4">
-  <title>Migrating from GTK 2.x to GTK 4</title>
-
-  <para>
-    If your application is still using GTK 2, you should first convert it to
-    GTK 3, by following the <ulink url="https://developer.gnome.org/gtk3/stable/gtk-migrating-2-to-3.html">migration guide</ulink> in the GTK 3
-    documentation, and then follow <xref linkend="gtk-migrating-3-to-4"/>.
-  </para>
-
-</chapter>

docs/reference/gtk/migrating-3to4.md

@@ -0,0 +1,942 @@
+# Migrating from GTK 3.x to GTK 4 {#gtk-migrating-3-to-4}
+
+GTK 4 is a major new version of GTK that breaks both API and ABI
+compared to GTK 3.x. Thankfully, most of the changes are not hard
+to adapt to and there are a number of steps that you can take to
+prepare your GTK 3.x application for the switch to GTK 4. After
+that, there's a number of adjustments that you may have to do
+when you actually switch your application to build against GTK 4.
+
+## Preparation in GTK 3.x
+
+The steps outlined in the following sections assume that your
+application is working with GTK 3.24, which is the final stable
+release of GTK 3.x. It includes all the necessary APIs and tools
+to help you port your application to GTK 4. If you are using
+an older version of GTK 3.x, you should first get your application
+to build and work with the latest minor release in the 3.24 series.
+
+### Do not use deprecated symbols
+
+Over the years, a number of functions, and in some cases, entire
+widgets have been deprecated. These deprecations are clearly spelled
+out in the API reference, with hints about the recommended replacements.
+The API reference for GTK 3 also includes an
+[index](https://developer.gnome.org/gtk3/3.24/api-index-deprecated.html)
+of all deprecated symbols.
+
+To verify that your program does not use any deprecated symbols,
+you can use defines to remove deprecated symbols from the header files,
+as follows:
+```
+make CFLAGS+="-DGDK_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED"
+```
+
+Note that some parts of our API, such as enumeration values, are
+not well covered by the deprecation warnings. In most cases, using
+them will require you to also use deprecated functions, which will
+trigger warnings.
+
+### Enable diagnostic warnings
+
+Deprecations of properties and signals cannot be caught at compile
+time, as both properties and signals are installed and used after
+types have been instantiated. In order to catch deprecations and
+changes in the run time components, you should use the
+`G_ENABLE_DIAGNOSTIC` environment variable when running your
+application, e.g.:
+```
+G_ENABLE_DIAGNOSTIC=1 ./your-app
+```
+
+### Do not use widget style properties
+
+Style properties do not exist in GTK 4. You should stop using them in
+your custom CSS and in your code.
+
+### Review your window creation flags
+
+GTK 4 removes the `GDK_WA_CURSOR` flag. Instead, just use
+gdk_window_set_cursor() to set a cursor on the window after
+creating it. GTK 4 also removes the `GDK_WA_VISUAL` flag, and
+always uses an RGBA visual for windows. To prepare your code for
+this, use `gdk_window_set_visual (gdk_screen_get_rgba_visual ())`
+after creating your window. GTK 4 also removes the `GDK_WA_WMCLASS`
+flag. If you need this X11-specific functionality, use XSetClassHint()
+directly.
+
+### Stop using direct access to GdkEvent structs
+
+In GTK 4, event structs are opaque and immutable. Many fields already
+have accessors in GTK 3, and you should use those to reduce the amount
+of porting work you have to do at the time of the switch.
+
+### Stop using gdk_pointer_warp()
+
+Warping the pointer is disorienting and unfriendly to users.
+GTK 4 does not support it. In special circumstances (such as when
+implementing remote connection UIs) it can be necessary to
+warp the pointer; in this case, use platform APIs such as
+XWarpPointer() directly.
+
+### Stop using non-RGBA visuals
+
+GTK 4 always uses RGBA visuals for its windows; you should make
+sure that your code works with such visuals. At the same time,
+you should stop using GdkVisual APIs, since this object not longer
+exists in GTK 4. Most of its APIs are deprecated already and not
+useful when dealing with RGBA visuals.
+
+### Stop using GtkBox padding, fill and expand child properties
+
+GTK 4 removes these #GtkBox child properties, so you should stop using
+them. You can replace GtkBox:padding using the #GtkWidget:margin properties
+on your #GtkBox child widgets.
+
+The fill child property can be replaced by setting appropriate values
+for the #GtkWidget:halign and #GtkWidget:valign properties of the child
+widgets. If you previously set the fill child property to %TRUE, you can
+achieve the same effect by setting the halign or valign properties to
+%GTK_ALIGN_FILL, depending on the parent box -- halign for a horizontal
+box, valign for a vertical one.
+
+\#GtkBox also uses the expand child property. It can be replaced by setting
+#GtkWidget:hexpand or #GtkWidget:vexpand on the child widgets. To match the
+old behavior of the #GtkBox's expand child property, you need to set
+#GtkWidget:hexpand on the child widgets of a horizontal #GtkBox and
+#GtkWidget:vexpand on the child widgets of a vertical #GtkBox.
+
+Note that there's a subtle but important difference between #GtkBox's
+expand and fill child properties and the ones in #GtkWidget: setting
+#GtkWidget:hexpand or #GtkWidget:vexpand to %TRUE will propagate up
+the widget hierarchy, so a pixel-perfect port might require you to reset
+the expansion flags to %FALSE in a parent widget higher up the hierarchy.
+
+### Stop using the state argument of GtkStyleContext getters
+
+The getters in the GtkStyleContext API, such as
+gtk_style_context_get_property(), gtk_style_context_get(),
+or gtk_style_context_get_color() only accept the context's current
+state for their state argument. You should update all callers to pass
+the current state.
+
+### Stop using gdk_pixbuf_get_from_window() and gdk_cairo_set_source_surface()
+
+These functions are not supported in GTK 4. Instead, either use
+backend-specific APIs, or render your widgets using
+#GtkWidgetClass.snapshot() (once you are using GTK 4).
+
+Stop using GtkButton's image-related API
+
+The functions and properties related to automatically add a GtkImage
+to a GtkButton, and using a GtkSetting to control its visibility, are
+not supported in GTK 4. Instead, you can just pack a GtkImage inside
+a GtkButton, and control its visibility like you would for any other
+widget. If you only want to add a named icon to a GtkButton, you can
+use gtk_button_new_from_icon_name().
+
+### Stop using GtkWidget event signals
+
+Event controllers and #GtkGestures replace event signals in GTK 4.
+They have been backported to GTK 3.x so you can prepare for this change.
+
+### Set a proper application ID
+
+In GTK 4 we want the application's #GApplication 'application-id'
+(and therefore the D-Bus name), the desktop file basename and Wayland's
+xdg-shell app_id to match. In order to achieve this with GTK 3.x call
+g_set_prgname() with the same application ID you passed to #GtkApplication.
+Rename your desktop files to match the application ID if needed.
+
+The call to g_set_prgname() can be removed once you fully migrated to GTK 4.
+
+You should be aware that changing the application ID makes your
+application appear as a new, different app to application installers.
+You should consult the appstream documentation for best practices
+around renaming applications.
+
+### Stop using gtk_main() and related APIs
+
+GTK 4 removes the gtk_main_ family of APIs. The recommended replacement
+is GtkApplication, but you can also iterate the GLib mainloop directly,
+using GMainContext APIs. The replacement for gtk_events_pending() is
+g_main_context_pending(), the replacement for gtk_main_iteration() is
+g_main_context_iteration().
+
+### Reduce the use of gtk_widget_destroy()
+
+GTK 4 introduces a gtk_window_destroy() api. While that is not available
+in GTK 3, you can prepare for the switch by using gtk_widget_destroy()
+only on toplevel windows, and replace all other uses with
+gtk_container_remove() or g_object_unref().
+
+### Reduce the use of generic container APIs</title>
+
+GTK 4 removes gtk_container_add() and gtk_container_remove(). While there
+is not always a replacement for gtk_container_remove() in GTK 3, you can
+replace many uses of gtk_container_add() with equivalent container-specific
+APIs such as gtk_box_pack_start() or gtk_grid_attach(), and thereby reduce
+the amount of work you have to do at the time of the switch.
+
+## Changes that need to be done at the time of the switch
+
+This section outlines porting tasks that you need to tackle when
+you get to the point that you actually build your application against
+GTK 4. Making it possible to prepare for these in GTK 3 would
+have been either impossible or impractical.
+
+### Stop using GdkScreen
+
+The GdkScreen object has been removed in GTK 4. Most of its APIs already
+had replacements in GTK 3 and were deprecated, a few remaining replacements
+have been added to GdkDisplay.
+
+### Stop using the root window
+
+The root window is an X11-centric concept that is no longer exposed in the
+backend-neutral GDK API. If you need to interact with the X11 root window,
+you can use gdk_x11_display_get_xrootwindow() to get its XID.
+
+### Stop using GdkVisual
+
+This object is not useful with current GTK drawing APIs and has been removed
+without replacement.
+
+### Stop using GdkDeviceManager
+
+The GdkDeviceManager object has been removed in GTK 4. Most of its APIs already
+had replacements in GTK 3 and were deprecated in favor of GdkSeat.
+
+### Adapt to GdkWindow API changes
+
+GdkWindow has been renamed to GdkSurface.
+
+In GTK 4, the two roles of a standalone toplevel window and of a popup
+that is placed relative to a parent window have been separated out into
+two interfaces, #GdkToplevel and #GdkPopup. Surfaces implementing these
+interfaces are created with gdk_surface_new_toplevel() and
+gdk_surface_new_popup(), respectively, and they are presented on screen
+using gdk_toplevel_present() and gdk_popup_present(). The present()
+functions take parameters in the form of an auxiliary layout struct,
+#GdkPopupLayout or #GdkToplevelLayout. If your code is dealing directly
+with surfaces, you may have to change it to call the API in these
+interfaces, depending on whether the surface you are dealing with
+is a toplevel or a popup.
+
+As part of this reorganization, X11-only concepts such as sticky or
+keep-below have been removed. If you need to use them on your X11 windows,
+you will have to set the corresponding X11 properties (as specified in the
+EWMH) yourself. Subsurfaces are only supported with the Wayland backend,
+using gdk_wayland_surface_new_subsurface(). Native and foreign subwindows
+are no longer supported. These concepts were complicating the code and
+could not be supported across backends.
+
+gdk_window_reparent() is no longer available.
+
+A number of minor API cleanups have happened in GdkSurface
+as well. For example, gdk_surface_input_shape_combine_region()
+has been renamed to gdk_surface_set_input_region(), and
+gdk_surface_begin_resize_drag() has been renamed to
+gdk_toplevel_begin_resize().
+
+### The "iconified" window state has been renamed to "minimized"
+
+The %GDK_SURFACE_STATE_ICONIFIED value of the
+#GdkSurfaceState enumeration is now %GDK_SURFACE_STATE_MINIMIZED.
+
+The #GdkWindow functions <function>gdk_window_iconify()</function>
+and <function>gdk_window_deiconify()</function> have been renamed to
+gdk_toplevel_minimize() and gdk_toplevel_present(), respectively.
+
+The behavior of the minimization and unminimization operations have
+not been changed, and they still require support from the underlying
+windowing system.
+
+### Adapt to GdkEvent API changes
+
+Direct access to GdkEvent structs is no longer possible in GTK 4.
+GdkEvent is now a strictly read-only type, and you can no longer
+change any of its fields, or construct new events. All event fields
+have accessors that you will have to use.
+
+Event compression is always enabled in GTK 4. If you need to see
+the uncoalesced motion history, use gdk_motion_event_get_history()
+on the latest motion event.
+
+### Stop using grabs
+
+GTK 4 no longer provides the gdk_device_grab() or gdk_seat_grab()
+apis. If you need to dismiss a popup when the user clicks outside
+(the most common use for grabs), you can use the GdkPopup
+#GdkPopup:autohide property instead. GtkPopover also has a
+#GtkPopover:autohide property for this. If you need to prevent
+the user from interacting with a window while a dialog is open,
+use the #GtkWindow:modal property of the dialog.
+
+### Adapt to coordinate API changes
+
+A number of coordinate APIs in GTK 3 had _double variants: 
+gdk_device_get_position(), gdk_device_get_surface_at_position(),
+gdk_surface_get_device_position(). These have been changed to use
+doubles, and the _double variants have been removed. Update your
+code accordingly.
+
+Any APIs that deal with global (or root) coordinates have been
+removed in GTK 4, since not all backends support them. You should
+replace your use of such APIs with surface-relative equivalents.
+Examples of this are gdk_surface_get_origin(), gdk_surface_move()
+or gdk_event_get_root_coords().
+
+### Adapt to GdkKeymap API changes
+
+GdkKeymap no longer exists as an independent object.
+
+If you need access to keymap state, it is now exposed as properties
+on the #GdkDevice representing the keyboard: #GdkDevice:direction,
+#GdkDevice:has-bidi-layouts, #GdkDevice:caps-lock-state,
+#GdkDevice:num-lock-state, #GdkDevice:scroll-lock-state and
+#GdkDevice:modifier-state. To obtain the keyboard device, you can use
+`gdk_seat_get_keyboard (gdk_display_get_default_seat (display)`.
+
+If you need access to translated keys for event handling, #GdkEvent
+now includes all of the translated key state, including consumed
+modifiers, group and shift level, so there should be no need to
+manually call gdk_keymap_translate_keyboard_state() (which has
+been removed).
+
+If you need to do forward or backward mapping between key codes
+and key values, use gdk_display_map_keycode() and gdk_display_map_keyval(),
+which are the replacements for gdk_keymap_get_entries_for_keycode()
+and gdk_keymap_get_entries_for_keyval().
+
+### Adapt to changes in keyboard modifier handling
+
+GTK 3 has the idea that use of modifiers may differ between different
+platforms, and has a #GdkModifierIntent api to let platforms provide
+hint about how modifiers are expected to be used. It also promoted
+the use of <Primary> instead of <Control> to specify accelerators that
+adapt to platform conventions.
+
+In GTK 4, the meaning of modifiers has been fixed, and backends are
+expected to map the platform conventions to the existing modifiers.
+The expected use of modifiers in GTK 4 is:
+
+GDK_CONTROL_MASK
+ : Primary accelerators
+ GDK_ALT_MASK
+ :  Mnemonics
+GDK_SHIFT_MASK
+ : Extending selections
+GDK_CONTROL_MASK
+ : Modifying selections
+GDK_CONTROL_MASK|GDK_ALT_MASK
+ : Prevent text input
+
+Consequently, #GdkModifierIntent and related APIs have been removed,
+and <Control> is preferred over <Primary> in accelerators.
+
+A related change is that GTK 4 no longer supports the use of archaic
+X11 'real' modifiers with the names Mod1,..., Mod5, and %GDK_MOD1_MASK
+has been renamed to %GDK_ALT_MASK.
+
+### Stop using gtk_get_current_... APIs
+
+The function gtk_get_current_event() and its variants have been
+replaced by equivalent event controller APIs:
+gtk_event_controller_get_current_event(), etc.
+
+### Convert your ui files
+
+A number of the changes outlined below affect .ui files. The
+gtk4-builder-tool simplify command can perform many of the
+necessary changes automatically, when called with the --3to4
+option. You should always review the resulting changes.
+
+### Adapt to event controller API changes
+
+A few changes to the event controller and #GtkGesture APIs
+did not make it back to GTK 3, and have to be taken into account
+when moving to GTK 4. One is that the #GtkEventControllerMotion::enter
+and #GtkEventControllerMotion::leave signals have gained new arguments.
+Another is that #GtkGestureMultiPress has been renamed to #GtkGestureClick,
+and has lost its area property. A #GtkEventControllerFocus has been
+split off from #GtkEventcontrollerKey.
+
+### Focus handling changes
+
+The semantics of the #GtkWidget:can-focus property have changed.
+In GTK 3, this property only meant that the widget itself would not
+accept keyboard input, but its children still might (in the case of
+containers). In GTK 4, if :can-focus is %FALSE, the focus cannot enter
+the widget or any of its descendents, and the default value has changed
+from %FALSE to %TRUE. In addition, there is a #GtkWidget:focusable
+property, which controls whether an individual widget can receive
+the input focus.
+
+The feature to automatically keep the focus widget scrolled into view
+with gtk_container_set_focus_vadjustment() has been removed together with
+GtkContainer, and is provided by scrollable widgets instead. In the common
+case that the scrollable is a #GtkViewport, use #GtkViewport:scroll-to-focus.
+
+### Use the new apis for keyboard shortcuts
+
+The APIs for keyboard shortcuts and accelerators have changed in GTK 4.
+
+Instead of GtkAccelGroup, you now use a #GtkShortcutController with global
+scope, and instead of GtkBindingSet, you now use gtk_widget_class_add_shortcut(),
+gtk_widget_class_add_binding() and its variants. In both cases, you probably
+want to add actions that can be triggered by your shortcuts.
+
+There is no direct replacement for loading and saving accelerators with
+GtkAccelMap. But since #GtkShortcutController implements #GListModel and
+both #GtkShortcutTrigger and #GtkShortcutAction can be serialized to
+strings, it is relatively easy to implement saving and loading yourself. 
+
+### Stop using GtkEventBox
+
+GtkEventBox is no longer needed and has been removed.
+All widgets receive all events.
+
+### Stop using GtkButtonBox
+
+GtkButtonBox has been removed. Use a GtkBox instead.
+
+### Adapt to GtkBox API changes
+
+The GtkBox pack-start and -end methods have been replaced by gtk_box_prepend()
+and gtk_box_append(). You can also reorder box children as necessary.
+
+### Adapt to GtkHeaderBar and GtkActionBar API changes
+
+The gtk_header_bar_set_show_close_button() function has been renamed to
+the more accurate name gtk_header_bar_set_show_title_buttons(). The
+corresponding getter and the property itself have also been renamed.
+
+The gtk_header_bar_set_custom_title() function has been renamed to
+the more accurate name gtk_header_bar_set_title_widget(). The
+corresponding getter and the property itself have also been renamed.
+
+The gtk_header_bar_set_title() function has been removed along with its
+corresponding getter and the property. By default #GtkHeaderBar shows
+the title of the window, so if you were setting the title of the header
+bar, consider setting the window title instead. If you need to show a
+title that's different from the window title, use the
+#GtkHeaderBar:title-widget property to add a #GtkLabel as shown in the
+example in #GtkHeaderBar documentation.
+
+The gtk_header_bar_set_subtitle() function has been removed along with
+its corresponding getter and the property. The old "subtitle" behavior
+can be replicated by setting the #GtkHeaderBar:title-widget property to
+a #GtkBox with two labels inside, with the title label matching the
+example in #GtkHeaderBar documentation, and the subtitle label being
+similar, but with "subtitle" style class instead of "title".
+
+The gtk_header_bar_set_has_subtitle() function has been removed along
+with its corresponding getter and the property. Its behavior can be
+replicated by setting the #GtkHeaderBar:title-widget property to a
+#GtkStack with #GtkStack:vhomogeneous property set to %TRUE and two
+pages, each with a #GtkBox with title and subtitle as described above.
+
+The ::pack-type child properties of GtkHeaderBar and GtkActionBar have
+been removed. If you need to programmatically place children, use the
+pack_start() and pack_end() APIs. In ui files, use the type attribute
+on the child element.
+
+gtk4-builder-tool can help with this conversion, with the --3to4 option
+of the simplify command.
+
+### Adapt to GtkStack, GtkAssistant and GtkNotebook API changes
+
+The child properties of GtkStack, GtkAssistant and GtkNotebook have been
+converted into child meta objects.
+Instead of gtk_container_child_set (stack, child, …), you can now use
+g_object_set (gtk_stack_get_page (stack, child), …). In .ui files, the
+GtkStackPage objects must be created explicitly, and take the child widget
+as property. GtkNotebook and GtkAssistant are similar.
+
+gtk4-builder-tool can help with this conversion, with the --3to4 option
+of the simplify command.
+
+### Adapt to GtkBin removal
+
+The abstract base class GtkBin for single-child containers has been
+removed. The former subclasses are now derived directly from GtkWidget,
+and have a "child" property for their child widget. To add a child, use
+the setter for the "child" property (e.g. gtk_frame_set_child()) instead
+of gtk_container_add(). Adding a child in a ui file with <child> still works.
+
+The affected classes are:
+
+- GtkAspectFrame
+- GtkButton (and subclasses)
+- GtkComboBox
+- GtkFlowBoxChild
+- GtkFrame
+- GtkListBoxRow
+- GtkOverlay
+- GtkPopover
+- GtkRevealer
+- GtkScrolledWindow
+- GtkSearchBar
+- GtkViewport
+- GtkWindow (and subclasses)
+
+If you have custom widgets that were derived from GtkBin, you should
+port them to derive from GtkWidget. Notable vfuncs that you will have
+to implement include dispose() (to unparent your child), compute_expand()
+(if you want your container to propagate expand flags) and
+get_request_mode() (if you want your container to support height-for-width.
+
+You may also want to implement the GtkBuildable interface, to support
+adding children with <child> in ui files.
+
+### Adapt to GtkContainer removal
+
+The abstract base class GtkContainer for general containers has been
+removed. The former subclasses are now derived directly from GtkWidget,
+and have class-specific add() and remove() functions.
+The most noticable change is the use of gtk_box_append() or gtk_box_prepend()
+instead of gtk_container_add() for adding children to GtkBox, and the change
+to use container-specific remove functions, such as gtk_stack_remove() instead
+of gtk_container_remove(). Adding a child in a ui file with <child> still works.
+
+The affected classes are:
+
+- GtkActionBar
+- GtkBox (and subclasses)
+- GtkExpander
+- GtkFixed
+- GtkFlowBox
+- GtkGrid
+- GtkHeaderBar
+- GtkIconView
+- GtkInfoBar
+- GtkListBox
+- GtkNotebook
+- GtkPaned
+- GtkStack
+- GtkTextView
+- GtkTreeView
+
+Without GtkContainer, there are no longer facilities for defining and
+using child properties. If you have custom widgets using child properties,
+they will have to be converted either to layout properties provided
+by a layout manager (if they are layout-related), or handled in some
+other way. One possibility is to use child meta objects, as seen with
+GtkAssistantPage, GtkStackPage and the like.
+
+### Stop using GtkContainer::border-width
+
+GTK 4 has removed the #GtkContainer::border-width property (together
+with the rest of GtkContainer). Use other means to influence the spacing
+of your containers, such as the CSS margin and padding properties on child
+widgets.
+
+### Adapt to gtk_widget_destroy() removal
+
+The function gtk_widget_destroy() has been removed. To explicitly destroy
+a toplevel window, use gtk_window_destroy(). To destroy a widget that is
+part of a hierarchy, remove it from its parent using a container-specific
+remove api, such as gtk_box_remove() or gtk_stack_remove(). To destroy
+a freestanding non-toplevel widget, use g_object_unref() to drop your
+reference.
+
+### Adapt to coordinate API changes
+
+A number of APIs that are accepting or returning coordinates have
+been changed from ints to doubles: gtk_widget_translate_coordinates(),
+gtk_fixed_put(), gtk_fixed_move(). This change is mostly transparent,
+except for cases where out parameters are involved: you need to
+pass double* now, instead of int*.
+
+### Adapt to GtkStyleContext API changes
+
+The getters in the GtkStyleContext API, such as
+gtk_style_context_get_property(), gtk_style_context_get(),
+or gtk_style_context_get_color() have lost their state argument,
+and always use the context's current state. Update all callers
+to omit the state argument.
+
+The most commonly used GtkStyleContext API, gtk_style_context_add_class(),
+has been moved to GtkWidget as gtk_widget_add_css_class(), as have the
+corresponding gtk_style_context_remove_class() and
+gtk_style_context_has_class() APIs.
+
+### Adapt to GtkCssProvider API changes
+
+In GTK 4, the various #GtkCssProvider load functions have lost their
+#GError argument. If you want to handle CSS loading errors, use the
+#GtkCssProvider::parsing-error signal instead. gtk_css_provider_get_named()
+has been replaced by gtk_css_provider_load_named().
+
+### Stop using GtkShadowType and GtkRelief properties
+
+The shadow-type properties in GtkScrolledWindow, GtkViewport,
+and GtkFrame, as well as the relief properties in GtkButton
+and its subclasses have been removed. GtkScrolledWindow, GtkButton
+and GtkMenuButton have instead gained a boolean has-frame
+property.
+
+### Adapt to GtkWidget's size request changes
+
+GTK 3 used five different virtual functions in GtkWidget to
+implement size requisition, namely the gtk_widget_get_preferred_width()
+family of functions. To simplify widget implementations, GTK 4 uses
+only one virtual function, GtkWidgetClass::measure() that widgets
+have to implement. gtk_widget_measure() replaces the various
+gtk_widget_get_preferred_ functions for querying sizes.
+
+### Adapt to GtkWidget's size allocation changes
+
+The #GtkWidget.size_allocate() vfunc takes the baseline as an argument
+now, so you no longer need to call gtk_widget_get_allocated_baseline()
+to get it.
+
+The ::size-allocate signal has been removed, since it is easy
+to misuse. If you need to learn about sizing changes of custom
+drawing widgets, use the #GtkDrawingArea::resize or #GtkGLArea::resize
+signals.
+
+### Switch to GtkWidget's children APIs
+
+In GTK 4, any widget can have children (and GtkContainer is gone).
+There is new API to navigate the widget tree, for use in widget
+implementations: gtk_widget_get_first_child(), gtk_widget_get_last_child(),
+gtk_widget_get_next_sibling(), gtk_widget_get_prev_sibling().
+
+### Don't use -gtk-gradient in your CSS
+
+GTK now supports standard CSS syntax for both linear and radial
+gradients, just use those.
+
+### Don't use -gtk-icon-effect in your CSS
+
+GTK now supports a more versatile -gtk-icon-filter instead. Replace
+-gtk-icon-effect: dim; with -gtk-icon-filter: opacity(0.5); and
+-gtk-icon-effect: hilight; with -gtk-icon-filter: brightness(1.2);.
+
+### Don't use -gtk-icon-theme in your CSS
+
+GTK now uses the current icon theme, without a way to change this.
+
+### Don't use -gtk-outline-...-radius in your CSS
+
+These non-standard properties have been removed from GTK
+CSS. Just use regular border radius.
+
+### Adapt to drawing model changes
+
+This area has seen the most radical changes in the transition from GTK 3
+to GTK 4. Widgets no longer use a draw() function to render their contents
+to a cairo surface. Instead, they have a snapshot() function that creates
+one or more GskRenderNodes to represent their content. Third-party widgets
+that use a draw() function or a #GtkWidget::draw signal handler for custom
+drawing will need to be converted to use gtk_snapshot_append_cairo().
+
+The auxiliary #GtkSnapshot object has APIs to help with creating render
+nodes.
+
+If you are using a #GtkDrawingArea for custom drawing, you need to switch
+to using gtk_drawing_area_set_draw_func() to set a draw function instead
+of connnecting a handler to the #GtkWidget::draw signal.
+
+### Stop using APIs to query GdkSurfaces
+
+A number of APIs for querying special-purpose windows have been removed,
+since these windows are no longer publically available:
+gtk_tree_view_get_bin_window(), gtk_viewport_get_bin_window(),
+gtk_viewport_get_view_window().
+
+### Widgets are now visible by default
+
+The default value of #GtkWidget:visible in GTK 4 is %TRUE, so you no
+longer need to explicitly show all your widgets. On the flip side, you
+need to hide widgets that are not meant to be visible from the start.
+The only widgets that still need to be explicitly shown are toplevel
+windows, dialogs and popovers.
+
+A convenient way to remove unnecessary property assignments like this
+from ui files it run the command `gtk4-builder-tool simplify --replace`
+on them.
+
+The function gtk_widget_show_all(), the #GtkWidget:no-show-all property
+and its getter and setter have been removed in  GTK 4, so you should stop
+using them.
+
+### Adapt to changes in animated hiding and showing of widgets
+
+Widgets that appear and disappear with an animation, such as GtkPopover,
+GtkInfoBar, GtkRevealer no longer use gtk_widget_show() and gtk_widget_hide()
+for this, but have gained dedicated APIs for this purpose that you should
+use.
+
+### Stop passing commandline arguments to gtk_init
+
+The gtk_init() and gtk_init_check() functions no longer accept commandline
+arguments. Just call them without arguments. Other initialization functions
+that were purely related to commandline argument handling, such as
+gtk_parse_args() and gtk_get_option_group(), are gone. The APIs to
+initialize GDK separately are also gone, but it is very unlikely
+that you are affected by that.
+
+### GdkPixbuf is deemphasized
+
+A number of #GdkPixbuf-based APIs have been removed. The available replacements
+are either using #GIcon, or the newly introduced #GdkTexture or #GdkPaintable
+classes instead. If you are dealing with pixbufs, you can use
+gdk_texture_new_for_pixbuf() to convert them to texture objects where needed.
+
+### GtkWidget event signals are removed
+
+Event controllers and #GtkGestures have already been introduced in GTK 3 to handle
+input for many cases. In GTK 4, the traditional widget signals for handling input,
+such as #GtkWidget::motion-event or #GtkWidget::event have been removed.
+
+### Invalidation handling has changed
+
+Only gtk_widget_queue_draw() is left to mark a widget as needing redraw.
+Variations like gtk_widget_queue_draw_rectangle() or gtk_widget_queue_draw_region()
+are no longer available.
+
+### Stop using GtkWidget::draw
+
+The #GtkWidget::draw signal has been removed. Widgets need to implement the
+#GtkWidgetClass.snapshot() function now. Connecting draw signal handlers is
+no longer possible. If you want to keep using cairo for drawing, use
+gtk_snaphot_append_cairo().
+
+### Window content observation has changed
+
+Observing widget contents and widget size is now done by using the
+#GtkWidgetPaintable object instead of connecting to widget signals.
+
+### Monitor handling has changed
+
+Instead of a monitor number, #GdkMonitor is now used throughout. 
+gdk_display_get_monitors() returns the list of monitors that can be queried
+or observed for monitors to pass to APIs like gtk_window_fullscreen_on_monitor().
+
+### Adapt to cursor API changes
+
+Use the new gtk_widget_set_cursor() function to set cursors, instead of
+setting the cursor on the underlying window directly. This is necessary
+because most widgets don't have their own window anymore, turning any
+such calls into global cursor changes.
+
+For creating standard cursors, gdk_cursor_new_for_display() has been removed,
+you have to use cursor names instead of GdkCursorType. For creating custom cursors,
+use gdk_cursor_new_from_texture(). The ability to get cursor images has been removed.
+
+### Adapt to icon size API changes
+
+Instead of the existing extensible set of symbolic icon sizes, GTK now only
+supports normal and large icons with the #GtkIconSize enumeration. The actual sizes
+can be defined by themes via the CSS property -gtk-icon-size.
+
+GtkImage setters like gtk_image_set_from_icon_name() no longer take a #GtkIconSize
+argument. You can use the separate gtk_image_set_icon_size() setter if you need
+to override the icon size.
+
+The :stock-size property of GtkCellRendererPixbuf has been renamed to
+#GtkCellRendererPixbuf:icon-size.
+
+### Adapt to changes in the GtkAssistant API
+
+The :has-padding property is gone, and GtkAssistant no longer adds padding
+to pages. You can easily do that yourself.
+
+### Adapt to changes in the API of GtkEntry, GtkSearchEntry and GtkSpinButton
+
+The GtkEditable interface has been made more useful, and the core functionality of
+GtkEntry has been broken out as a GtkText widget. GtkEntry, GtkSearchEntry,
+GtkSpinButton and the new GtkPasswordEntry now use a GtkText widget internally
+and implement GtkEditable. In particular, this means that it is no longer
+possible to use GtkEntry API such as gtk_entry_grab_focus_without_selecting()
+on a search entry.
+
+Use GtkEditable API for editable functionality, and widget-specific APIs for
+things that go beyond the common interface. For password entries, use
+GtkPasswordEntry. As an example, gtk_spin_button_set_max_width_chars()
+has been removed in favor of gtk_editable_set_max_width_chars().
+
+### Adapt to changes in GtkOverlay API
+
+The GtkOverlay :pass-through child property has been replaced by the
+#GtkWidget:can-target property. Note that they have the opposite sense:
+pass-through == !can-target.
+
+### Use GtkFixed instead of GtkLayout
+
+Since GtkScrolledWindow can deal with widgets that do not implement
+the GtkScrollable interface by automatically wrapping them into a
+GtkViewport, GtkLayout is redundant, and has been removed in favor
+of the existing GtkFixed container widget.
+
+### Adapt to search entry changes
+
+The way search entries are connected to global events has changed;
+gtk_search_entry_handle_event() has been dropped and replaced by
+gtk_search_entry_set_key_capture_widget() and
+gtk_event_controller_key_forward().
+
+### Stop using gtk_window_activate_default()
+
+The handling of default widgets has been changed, and activating
+the default now works by calling gtk_widget_activate_default()
+on the widget that caused the activation. If you have a custom widget
+that wants to override the default handling, you can provide an
+implementation of the default.activate action in your widgets' action
+groups.
+
+### Stop setting ::has-default and ::has-focus in .ui files
+
+The special handling for the ::has-default and ::has-focus properties
+has been removed. If you want to define the initial focus or the
+the default widget in a .ui file, set the ::default-widget or
+::focus-widget properties of the toplevel window.
+
+### Stop using the GtkWidget::display-changed signal
+
+To track the current display, use the #GtkWidget::root property instead.
+
+### GtkPopover::modal has been renamed to autohide
+
+The modal property has been renamed to autohide.
+gtk-builder-tool can assist with the rename in ui files.
+
+### gtk_widget_get_surface has been removed
+
+gtk_widget_get_surface() has been removed.
+Use gtk_native_get_surface() in combination with
+gtk_widget_get_native() instead.
+
+### gtk_widget_is_toplevel has been removed
+
+gtk_widget_is_toplevel() has been removed.
+Use GTK_IS_ROOT, GTK_IS_NATIVE or GTK_IS_WINDOW
+instead, as appropriate.
+
+### gtk_widget_get_toplevel has been removed
+
+gtk_widget_get_toplevel() has been removed.
+Use gtk_widget_get_root() or gtk_widget_get_native()
+instead, as appropriate.
+
+### GtkEntryBuffer ::deleted-text has changed
+
+To allow signal handlers to access the deleted text before it
+has been deleted #GtkEntryBuffer::deleted-text has changed from
+%G_SIGNAL_RUN_FIRST to %G_SIGNAL_RUN_LAST. The default handler
+removes the text from the #GtkEntryBuffer.
+
+To adapt existing code, use g_signal_connect_after() or
+%G_CONNECT_AFTER when using g_signal_connect_data() or
+g_signal_connect_object().
+
+### GtkMenu, GtkMenuBar and GtkMenuItem are gone
+
+These widgets were heavily relying on X11-centric concepts such as
+override-redirect windows and grabs, and were hard to adjust to other
+windowing systems.
+
+Menus can already be replaced using GtkPopoverMenu in GTK 3. Additionally,
+GTK 4 introduces GtkPopoverMenuBar to replace menubars. These new widgets
+can only be constructed from menu models, so the porting effort involves
+switching to menu models and actions.
+
+Tabular menus were rarely used and complicated the menu code,
+so they have not been brought over to #GtkPopoverMenu. If you need
+complex layout in menu-like popups, consider directly using a
+#GtkPopover instead.
+
+Since menus are gone, GtkMenuButton also lost its ability to show menus,
+and needs to be used with popovers in GTK 4.
+
+### GtkToolbar has been removed
+
+Toolbars were using outdated concepts such as requiring special toolitem
+widgets. Toolbars should be replaced by using a GtkBox with regular widgets
+instead and the "toolbar" style class.
+
+### GtkAspectFrame is no longer a frame
+
+GtkAspectFrame is no longer derived from GtkFrame and does not
+place a label and frame around its child anymore. It still lets
+you control the aspect ratio of its child.
+
+### Stop using custom tooltip windows
+
+Tooltips no longer use GtkWindows in GTK 4, and it is no longer
+possible to provide a custom window for tooltips. Replacing the content
+of the tooltip with a custom widget is still possible, with
+gtk_tooltip_set_custom().
+
+### Switch to the new Drag-and-Drop api
+
+The source-side Drag-and-Drop apis in GTK 4 have been changed to use an event
+controller, #GtkDragSource. Instead of calling gtk_drag_source_set()
+and connecting to #GtkWidget signals, you create a #GtkDragSource object,
+attach it to the widget with gtk_widget_add_controller(), and connect
+to #GtkDragSource signals. Instead of calling gtk_drag_begin() on a widget
+to start a drag manually, call gdk_drag_begin().
+The ::drag-data-get signal has been replaced by the #GtkDragSource::prepare
+signal, which returns a #GdkContentProvider for the drag operation.
+
+The destination-side Drag-and-Drop  apis in GTK 4 have also been changed
+to use an event controller, #GtkDropTarget. Instead of calling
+gtk_drag_dest_set() and connecting to #GtkWidget signals, you create
+a #GtkDropTarget object, attach it to the widget with
+gtk_widget_add_controller(), and connect to #GtkDropTarget signals.
+The ::drag-motion signal has been renamed to #GtkDropTarget::accept, and
+instead of ::drag-data-received, you need to use async read methods on the
+#GdkDrop object, such as gdk_drop_read_async() or gdk_drop_read_value_async().
+
+### Adapt to GtkIconTheme API changes
+
+gtk_icon_theme_lookup_icon() returns a #GtkIconPaintable object now, instead
+of a #GtkIconInfo. It always returns a paintable in the requested size, and
+never fails. A number of no-longer-relevant lookup flags and API variants
+have been removed.
+
+### Update to GtkFileChooser API changes
+
+GtkFileChooser moved to a GFile-based API. If you need to convert a
+path or a URI, use g_file_new_for_path(), g_file_new_for_commandline_arg(),
+or g_file_new_for_uri(); similarly, if you need to get a path or a URI
+from a GFile, use g_file_get_path(), or g_file_get_uri(). With the
+removal or path and URI-based functions, the "local-only" property has
+been removed; GFile can be used to access non-local as well as local
+resources.
+
+The GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER action has been removed. Use
+%GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, instead. If a new folder is needed,
+the user can create one.
+
+The "confirm-overwrite" signal, and the "do-overwrite-confirmation"
+property have been removed from GtkFileChooser. The file chooser widgets
+will automatically handle the confirmation of overwriting a file when
+using GTK_FILE_CHOOSER_ACTION_SAVE.
+
+GtkFileChooser does not support a custom extra widget any more. If you
+need to add extra widgets, use gtk_file_chooser_add_choice() instead.
+
+GtkFileChooser does not support a custom preview widget any more. If
+you need to show a custom preview, you can create your own GtkDialog
+with a GtkFileChooserWidget and your own preview widget that you
+update whenever the #GtkFileChooser::selection-changed signal is
+emitted.
+
+### Stop using blocking dialog functions
+
+GtkDialog, GtkNativeDialog, and GtkPrintOperation removed their
+blocking API using nested main loops. Nested main loops present
+re-entrancy issues and other hard to debug issues when coupled
+with other event sources (IPC, accessibility, network operations)
+that are not under the toolkit or the application developer's
+control. Additionally, "stop-the-world" functions do not fit
+the event-driven programming model of GTK.
+
+You can replace calls to <function>gtk_dialog_run()</function>
+by specifying that the #GtkDialog must be modal using
+gtk_window_set_modal() or the %GTK_DIALOG_MODAL flag, and
+connecting to the #GtkDialog::response signal.

docs/reference/gtk/osx.md

@@ -0,0 +1,10 @@
+# Using GTK on Apple macOS {#gtk-osx}
+
+The Apple macOS port of GTK is an implementation of GDK (and therefore GTK)
+on top of the Quartz API.
+
+Currently, the macOS port does not use any additional commandline options
+or environment variables.
+
+For up-to-date information about the current status of this port, see the
+[project page](https://wiki.gnome.org/Projects/GTK/OSX).

docs/reference/gtk/osx.xml

@@ -1,39 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-osx">
-<refmeta>
-<refentrytitle>Using GTK on Apple macOS</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>Using GTK on Apple macOS</refname>
-<refpurpose>
-MacOS-specific aspects of using GTK
-</refpurpose>
-</refnamediv>
-
-<refsect1>
-<title>Using GTK on Apple macOS</title>
-
-<para>
-The Apple macOS port of GTK is an implementation of GDK (and therefore GTK)
-on top of the Quartz API.
-</para>
-
-<para>
-Currently, the macOS port does not use any additional commandline options
-or environment variables.
-</para>
-
-<para>
-For up-to-date information about the current status of this port, see the
-<ulink url="https://wiki.gnome.org/Projects/GTK/OSX">project page</ulink>.
-</para>
-
-</refsect1>
-
-</refentry>

docs/reference/gtk/other_software.xml

@@ -1,211 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-other-software">
-<refmeta>
-<refentrytitle>Mixing GTK with other software</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>Mixing GTK with other software</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>Mixing GTK with other software</refname>
-<refpurpose>
-How to combine GTK with other code and event loops
-</refpurpose>
-</refnamediv>
-
-<refsect1>
-<title>Overview</title>
-
-<para>
-Often people want to use GTK in combination with another library or existing 
-body of code that is not GTK-aware. The general problem people encounter 
-is that the control flow of the other code does not return to GTK, so 
-widgets do not repaint, mouse and keyboard events are ignored, and so forth.
-</para>
-
-<para>
-This section describes some approaches to solving this problem. The most
-suitable approach depends on the code that's involved, the platforms you're
-targetting, and your own familiarity with each approach.
-</para>
-
-</refsect1>
-
-<refsect1>
-<title>Periodically yield to GTK main loop</title>
-
-<para>
-This is the simplest method, but requires you to modify the non-GTK code.
-Say you have a function that does some kind of lengthy task:
-<informalexample>
-<programlisting>
-  void
-  do_lengthy_task (void)
-  {
-     int i;
-     for (i = 0; i &lt; BIG_NUMBER; ++i)
-       {
-         do_small_part_of_task ();
-       }
-  }
-</programlisting>
-</informalexample>
-You simply insert code into this function that processes pending main loop tasks, if any:
-<informalexample>
-<programlisting>
-  void
-  do_lengthy_task (void)
-  {
-     int i;
-     for (i = 0; i &lt; BIG_NUMBER; ++i)
-       {
-         do_small_part_of_task ();
-
-         /* allow main loop to process pending events; NULL 
-          * means the default context. 
-          */
-         while (g_main_context_pending (NULL))
-           g_main_context_iteration (NULL, FALSE);
-       }
-  }
-</programlisting>
-</informalexample>
-</para>
-
-<para>
-The primary disadvantage of this approach is that you have to trade off UI
-responsiveness and the performance of the task. That is, if
-do_small_part_of_task() does very little of the task, you'll spend lots of CPU
-time on <link
-linkend="g-main-context-iteration">g_main_context_iteration()</link>. While if
-do_small_part_of_task() does a lot of work, the GUI will seem noticeably
-"chunky" to the user.
-</para>
-
-<para>
-Another disadvantage to this approach is that you can't have more than one
-lengthy task at the same time, unless you manually integrate them.
-</para>
-
-<para>
-The big advantage of this approach is that it's simple and straightforward, and
-works fine for simple applications such as tossing up a progress bar during the
-lengthy task.
-</para>
-
-</refsect1>
-
-<refsect1>
-<title>Run the other code as a slave of the GTK main loop</title>
-
-<para>
-As a slightly cleaner solution, you can ask the main loop to run a small part of your 
-task whenever it isn't busy &mdash; that is, when it's <firstterm>idle</firstterm>.
-GLib provides a function <link linkend="g-idle-add">g_idle_add()</link> that's useful 
-for this. An "idle handler" added with <link linkend="g-idle-add">g_idle_add()</link>
-will be run continuously as long as it returns <literal>TRUE</literal>. However, 
-the main loop gives higher priority to GUI-related tasks, so will run those instead
-when appropriate.
-</para>
-
-<para>
-Here's a simple example:
-<informalexample>
-<programlisting>
-  gboolean
-  my_idle_handler (gpointer user_data)
-  {
-    do_small_part_of_task ();
-  
-    if (task_complete)
-      return G_SOURCE_REMOVE; /* removes the idle handler */
-    else
-      return G_SOURCE_CONTINUE;  /* runs the idle handler again */
-  }
-
-  g_idle_add (my_idle_handler, NULL);
-</programlisting>
-</informalexample>
-</para>
-
-<para>
-If your task involves reading data from the network, you should instead use
-<link linkend="g-input-add">g_input_add()</link>; this will allow the 
-main loop to sleep until data is available on a file descriptor, then 
-wake up to read that data.
-</para>
-
-<para>
-<link linkend="g-idle-add">g_idle_add()</link> returns a main loop source ID you can 
-use to remove the idle handler with <link linkend="g-source-remove">g_source_remove()</link>.
-This is useful for cancelling a task, for example. Another approach is to keep a flag 
-variable and have the idle handler itself return <literal>FALSE</literal> when appropriate.
-</para>
-
-</refsect1>
-
-<refsect1>
-<title>Use multiple processes</title>
-
-<para>
-If you can't break a task into small chunks &mdash; the
-"do_small_part_of_task()" function in the above examples &mdash; you'll have to
-separate your program into two parts, by spawning a child thread or process.
-A process does not share the same address space (variables and data) with its parent.
-A thread does share the same address space, so a change made to a variable in 
-one thread will be visible to other threads as well.
-</para>
-
-<para>
-This manual can't go into full detail on processes, threads, and other UNIX
-programming topics.  You may wish to get a book or two &mdash; two I'm familiar
-with are Beginning Linux Programming (WROX Press) and Advanced Programming in
-the UNIX Environment (by Richard Stevens.
-</para>
-
-<para>
-Those books also cover the central issue you'll need to address in order to have
-a multi-process application: how to communicate between the processes. The
-simplest solution is to use pipes; <link
-linkend="g-input-add">g_input_add()</link> in combination with <link
-linkend="g-spawn-async-with-pipes">g_spawn_async_with_pipes()</link> should make
-this reasonably convenient. There are other possibilities, of course, such as
-sockets, shared memory, and X Window System client message events, depending on
-your needs.
-</para>
-
-</refsect1>
-
-
-<refsect1>
-<title>Use multiple threads</title>
-
-<para>
-
-</para>
-
-</refsect1>
-
-<refsect1>
-<title>Integrate the GTK main loop with another main loop</title>
-
-<para>
-</para>
-
-</refsect1>
-
-
-<refsect1>
-<title>Things that won't work</title>
-
-<para>
-signals
-</para>
-
-</refsect1>
-
-
-</refentry>

docs/reference/gtk/question_index.md

@@ -0,0 +1,557 @@
+# Common Questions {#gtk-question-index}
+
+This is an "index" of the reference manual organized by common "How do
+I..." questions. If you aren't sure which documentation to read for
+the question you have, this list is a good place to start.
+
+## General Questions
+
+1.  How do I get started with GTK?
+
+    The GTK [website](https://www.gtk.org) offers some
+    [tutorials](https://www.gtk.org/documentation.php) and other documentation
+    (most of it about GTK 2.x and 3.x, but still somewhat applicable). This
+    reference manual also contains a introductory
+    [Getting Started](#gtk-getting-started) part.
+    
+    More documentation ranging from whitepapers to online books can be found at
+    the [GNOME developer's site](https://developer.gnome.org). After studying these
+    materials you should be well prepared to come back to this reference manual for details.
+
+2.  Where can I get help with GTK, submit a bug report, or make a feature request?
+
+    See the [documentation](#gtk-resources) on this topic.
+
+3.  How do I port from one GTK version to another?
+
+    See the [migration guide](#migrating). You may also find useful information in
+    the documentation for specific widgets and functions. If you have a question not
+    covered in the manual, feel free to ask, and please
+    [file a bug report](https://gitlab.gnome.org/GNOME/gtk/issues/new) against the
+    documentation.
+
+4.  How does memory management work in GTK? Should I free data returned from functions?
+
+    See the documentation for #GObject and #GInitiallyUnowned. For #GObject note
+    specifically g_object_ref() and g_object_unref(). #GInitiallyUnowned is a
+    subclass of #GObject so the same points apply, except that it has a "floating"
+    state (explained in its documentation).
+
+    For strings returned from functions, they will be declared "const" if they should
+    not be freed. Non-const strings should be freed with g_free(). Arrays follow the
+    same rule. If you find an undocumented exception to the rules, please
+    [file a bug report.](https://gitlab.gnome.org/GNOME/gtk/issues/new).
+
+    The transfer annotations for gobject-introspection that are part of the
+    documentation can provide useful hints for memory handling semantics as well.
+
+5.  Why does my program leak memory, if I destroy a widget immediately
+    after creating it ?
+
+    If `GtkFooi` isn't a toplevel window, then
+
+        foo = gtk_foo_new ();
+        g_object_unref (foo);
+
+    is a memory leak, because no one assumed the initial floating reference
+    (you will get a warning about this too). If you are using a widget and
+    you aren't immediately packing it into a container, then you probably
+    want standard reference counting, not floating reference counting.
+
+    To get this, you must acquire a reference to the widget and drop the
+    floating reference (_ref and sink_ in GObject parlance) after creating it:
+
+        foo = gtk_foo_new ();
+        g_object_ref_sink (foo);
+        
+    When you immediately add a widget to a container, it takes care of assuming
+    the initial floating reference and you don't have to worry about reference
+    counting at all ... just remove the widget from the container to get rid of it.
+
+6.  How do I use GTK with threads?
+
+    GTK requires that all GTK API calls are made from the same thread in which
+    gtk_init() was called (the _main thread_).
+
+    If you want to take advantage of multi-threading in a GTK application,
+    it is usually best to send long-running tasks to worker threads, and feed
+    the results back to the main thread using g_idle_add() or GAsyncQueue. GIO
+    offers useful tools for such an approach such as GTask.
+
+7.  How do I internationalize a GTK program?
+
+    Most people use <[GNU gettext](https://www.gnu.org/software/gettext/),
+    already required in order to install GLib. On a UNIX or Linux system with
+    gettext installed, type `info gettext` to read the documentation.
+
+    The short checklist on how to use gettext is: call bindtextdomain() so
+    gettext can find the files containing your translations, call textdomain()
+    to set the default translation domain, call bind_textdomain_codeset() to
+    request that all translated strings are returned in UTF-8, then call
+    gettext() to look up each string to be translated in the default domain.
+
+    `gi18n.h` provides the following shorthand macros for convenience.
+    Conventionally, people define macros as follows for convenience:
+    
+        #define  _(x)     gettext (x)
+        #define N_(x)     x
+        #define C_(ctx,x) pgettext (ctx, x)
+        
+    You use N_() (N stands for no-op) to mark a string for translation in
+    a location where a function call to gettext() is not allowed, such as
+    in an array initializer. You eventually have to call gettext() on the
+    string to actually fetch the translation. _() both marks the string for
+    translation and actually translates it. The C_() macro (C stands for
+    context) adds an additional context to the string that is marked for
+    translation, which can help to disambiguate short strings that might
+    need different translations in different parts of your program.
+
+    Code using these macros ends up looking like this:
+
+        #include &lt;gi18n.h&gt;
+
+        static const char *global_variable = N_("Translate this string");
+
+        static void
+        make_widgets (void)
+        {
+          GtkWidget *label1;
+          GtkWidget *label2;
+
+          label1 = gtk_label_new (_("Another string to translate"));
+          label2 = gtk_label_new (_(global_variable));
+        ...
+
+    Libraries using gettext should use dgettext() instead of gettext(),
+    which allows them to specify the translation domain each time they
+    ask for a translation. Libraries should also avoid calling textdomain(),
+    since they will be specifying the domain instead of using the default.
+
+    With the convention that the macro `GETTEXT_PACKAGE` is defined to hold
+    your libraries translation domain, `gi18n-lib.h` can be included to provide
+    the following convenience:
+
+        #define _(x) dgettext (GETTEXT_PACKAGE, x)
+
+8.  How do I use non-ASCII characters in GTK programs ?
+
+    GTK uses [Unicode](http://www.unicode.org) (more exactly UTF-8) for all text.
+    UTF-8 encodes each Unicode codepoint as a sequence of one to six bytes and
+    has a number of nice properties which make it a good choice for working with
+    Unicode text in C programs:
+
+    - ASCII characters are encoded by their familiar ASCII codepoints.
+    - ASCII characters never appear as part of any other character.
+    - The zero byte doesn't occur as part of a character, so that UTF-8
+      string can be manipulated with the usual C library functions for
+      handling zero-terminated strings.
+
+    More information about Unicode and UTF-8 can be found in the
+    [UTF-8 and Unicode FAQ](https://www.cl.cam.ac.uk/~mgk25/unicode.html).
+    GLib provides functions for converting strings between UTF-8 and other
+    encodings, see g_locale_to_utf8() and g_convert().
+
+    Text coming from external sources (e.g. files or user input), has to be
+    converted to UTF-8 before being handed over to GTK. The following example
+    writes the content of a IS0-8859-1 encoded text file to `stdout`:
+
+        char *text, *utf8_text;
+        gsize length;
+        GError *error = NULL;
+
+        if (g_file_get_contents (filename, &amp;text, &amp;length, NULL))
+          {
+            utf8_text = g_convert (text, length, "UTF-8", "ISO-8859-1",
+                                   NULL, NULL, &amp;error);
+            if (error != NULL)
+              {
+                fprintf ("Couldn't convert file %s to UTF-8\n", filename);
+                g_error_free (error);
+              }
+            else
+              g_print (utf8_text);
+          }
+        else
+          fprintf (stderr, "Unable to read file %s\n", filename);
+
+    For string literals in the source code, there are several alternatives
+    for handling non-ASCII content:
+
+    - Direct UTF-8
+
+      If your editor and compiler are capable of handling UTF-8 encoded
+      sources, it is very convenient to simply use UTF-8 for string literals,
+      since it allows you to edit the strings in "wysiwyg". Note that choosing
+      this option may reduce the portability of your code.
+
+    - Escaped UTF-8
+
+      Even if your toolchain can't handle UTF-8 directly, you can still
+      encode string literals in UTF-8 by using octal or hexadecimal escapes
+      like `\\212` or `\\xa8` to encode each byte. This is portable, but
+      modifying the escaped strings is not very convenient. Be careful when
+      mixing hexadecimal escapes with ordinary text; `"\\xa8abcd" is a string
+      of length 1 !
+
+    - Runtime conversion
+
+      If the string literals can be represented in an encoding which your
+      toolchain can handle (e.g. IS0-8859-1), you can write your source
+      files in that encoding and use g_convert() to convert the strings
+      to UTF-8 at runtime. Note that this has some runtime overhead, so
+      you may want to move the conversion out of inner loops.
+
+    Here is an example showing the three approaches using the copyright
+    sign © which has Unicode and ISO-8859-1 codepoint 169 and is represented
+    in UTF-8 by the two bytes 194, 169, or `"\\302\\251"` as a string literal:
+    
+        g_print ("direct UTF-8: ©");
+        g_print ("escaped UTF-8: \302\251");
+        text = g_convert ("runtime conversion: ©", -1,
+                          "ISO-8859-1", "UTF-8", NULL, NULL, NULL);
+        g_print (text);
+        g_free (text);
+        
+    If you are using gettext() to localize your application, you need
+    to call bind_textdomain_codeset() to ensure that translated strings
+    are returned in UTF-8 encoding.
+
+9.  How do I use GTK with C++?
+
+    There are two ways to approach this. The GTK header files use the subset
+    of C that's also valid C++, so you can simply use the normal GTK API
+    in a C++ program. Alternatively, you can use a "C++ binding" such as
+    [gtkmm](https://www.gtkmm.org/) which provides a native C++ API.
+
+    When using GTK directly, keep in mind that only functions can be
+    connected to signals, not methods. So you will need to use global
+    functions or "static" class functions for signal connections.
+
+    Another common issue when using GTK directly is that C++ will not
+    implicitly convert an integer to an enumeration. This comes up when
+    using bitfields; in C you can write the following code:
+
+        gdk_surface_set_events (gdk_surface,
+                                GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
+
+    while in C++ you must write:
+
+        gdk_surface_set_events (gdk_surface,
+                                (GdkEventMask) GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
+        
+    There are very few functions that require this cast, however.
+
+10. How do I use GTK with other non-C languages?
+
+    See the list of [language bindings](https://www.gtk.org/language-bindings.php)
+    on the GTK [website](https://www.gtk.org).
+
+11. How do I load an image or animation from a file?
+
+    To load an image file straight into a display widget, use
+    gtk_image_new_from_file(). To load an image for another purpose, use
+    gdk_texture_new_from_file(). To load a video from a file, use
+    gtk_media_file_new_for_file().
+
+12. How do I draw text?
+
+    To draw a piece of text onto a cairo surface, use a Pango layout and
+    pango_cairo_show_layout().
+
+        layout = gtk_widget_create_pango_layout (widget, text);
+        fontdesc = pango_font_description_from_string ("Luxi Mono 12");
+        pango_layout_set_font_description (layout, fontdesc);
+        pango_cairo_show_layout (cr, layout);
+        pango_font_description_free (fontdesc);
+        g_object_unref (layout);
+        
+    See also the [Cairo Rendering](https://developer.gnome.org/pango/stable/pango-Cairo-Rendering.html)
+    section of the [Pango documentation](https://developer.gnome.org/pango/stable/).
+
+    To draw a piece of text in a widget snapshot() implementation, use
+    gtk_snapshot_append_layout().
+
+13. How do I measure the size of a piece of text?
+
+    To obtain the size of a piece of text, use a Pango layout and
+    pango_layout_get_pixel_size(), using code like the following:
+
+        layout = gtk_widget_create_pango_layout (widget, text);
+        fontdesc = pango_font_description_from_string ("Luxi Mono 12");
+        pango_layout_set_font_description (layout, fontdesc);
+        pango_layout_get_pixel_size (layout, &amp;width, &amp;height);
+        pango_font_description_free (fontdesc);
+        g_object_unref (layout);
+
+    See also the [Layout Objects](https://developer.gnome.org/pango/stable/pango-Layout-Objects.html)
+    section of the [Pango documentation](https://developer.gnome.org/pango/stable/).
+
+14. Why are types not registered if I use their `GTK_TYPE_BLAH` macro?
+
+    The %GTK_TYPE_BLAH macros are defined as calls to gtk_blah_get_type(), and
+    the `_get_type()` functions are declared as %G_GNUC_CONST which allows the
+    compiler to optimize the call away if it appears that the value is not
+    being used.
+
+    GLib provides the g_type_ensure() function to work around this problem.
+
+        g_type_ensure (GTK_TYPE_BLAH);
+
+15. How do I create a transparent toplevel window?
+
+    Any toplevel window can be transparent. It is just a matter of setting a
+    transparent background in the CSS style for it.
+
+## Which widget should I use...
+
+16. ...for lists and trees?
+
+    This question has different answers, depending on the size of the dataset
+    and the required formatting flexibility.
+
+    If you want to display a large amount of data in a uniform way, your best
+    option is a #GtkTreeView widget. See the [tree widget overview](#TreeWidget).
+    A list is just a tree with no branches, so the treeview widget is used for
+    lists as well.
+
+    If you want to display a small amount of items, but need flexible formatting
+    and widgetry inside the list, then you probably want to use a #GtkListBox,
+    which uses regular widgets for display.
+
+17. ...for multi-line text display or editing?
+
+    See the [text widget overview](#TextWidget) -- you should use the
+    #GtkTextView widget.
+
+    If you only have a small amount of text, #GtkLabel may also be appropriate
+    of course. It can be made selectable with gtk_label_set_selectable(). For a
+    single-line text entry, see #GtkEntry.
+
+18. ...to display an image or animation?
+
+    GTK has two widgets that are dedicated to displaying images. #GtkImage, for
+    small, fixed-size icons and #GtkPicture for content images.
+
+    Both can display images in just about any format GTK understands.
+    You can also use #GtkDrawingArea if you need to do something more complex,
+    such as draw text or graphics over the top of the image.
+
+    Both GtkImage and GtkPicture can display animations and videos as well.
+    To show an webm file, load it with the GtkMediaFile API and then use
+    it as a paintable:
+
+        mediafile = gtk_media_file_new_for_filename ("example.webm");
+        picture = gtk_picture_new_for_paintable (GDK_PAINTABLE (mediafile));
+
+19. ...for presenting a set of mutually-exclusive choices, where Windows
+    would use a combo box?
+
+    With GTK, a #GtkComboBox is the recommended widget to use for this use case.
+    If you need an editable text entry, use the #GtkComboBox:has-entry property.
+
+## Questions about GtkWidget
+
+20. How do I change the color of a widget?
+
+    The background color of a widget is determined by the CSS style that applies
+    to it. To change that, you can set style classes on the widget, and provide
+    custom CSS to change the appearance. Such CSS can be loaded with
+    gtk_css_provider_load_from_file() and its variants.
+    See gtk_style_context_add_provider().
+
+21. How do I change the font of a widget?
+
+    If you want to make the text of a label larger, you can use
+    gtk_label_set_markup():
+
+        gtk_label_set_markup (label, "<big>big tex</big>");
+
+    This is preferred for many apps because it's a relative size to the
+    user's chosen font size. See g_markup_escape_text() if you are
+    constructing such strings on the fly.
+
+    You can also change the font of a widget by putting
+
+        .my-widget-class {
+          font: Sans 30;
+        }
+
+    in a CSS file, loading it with gtk_css_provider_load_from_file(), and
+    adding the provider with gtk_style_context_add_provider_for_display().
+    To associate this style information with your widget, set a style class
+    on its #GtkStyleContext using gtk_style_context_add_class(). The advantage
+    of this approach is that users can then override the font you have chosen.
+    See the #GtkStyleContext documentation for more discussion.
+
+22. How do I disable/ghost/desensitize a widget?
+
+    In GTK a disabled widget is termed _insensitive_.
+    See gtk_widget_set_sensitive().
+
+## GtkTextView questions
+
+23. How do I get the contents of the entire text widget as a string?
+
+    See gtk_text_buffer_get_bounds() and gtk_text_buffer_get_text()
+    or gtk_text_iter_get_text().
+
+        GtkTextIter start, end;
+        GtkTextBuffer *buffer;
+        char *text;
+
+        buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
+        gtk_text_buffer_get_bounds (buffer, &start, &end);
+        text = gtk_text_iter_get_text (&start, &end);
+        /* use text */
+        g_free (text);
+        
+24. How do I make a text widget display its complete contents in a specific font?
+
+    If you use gtk_text_buffer_insert_with_tags() with appropriate tags to
+    select the font, the inserted text will have the desired appearance, but
+    text typed in by the user before or after the tagged block will appear in
+    the default style.
+
+    To ensure that all text has the desired appearance, use
+    gtk_widget_override_font() to change the default font for the widget.
+
+25. How do I make a text view scroll to the end of the buffer automatically ?
+
+    A good way to keep a text buffer scrolled to the end is to place a
+    [mark](#GtkTextMark) at the end of the buffer, and give it right gravity.
+    The gravity has the effect that text inserted at the mark gets inserted
+    *before*, keeping the mark at the end.
+
+    To ensure that the end of the buffer remains visible, use
+    gtk_text_view_scroll_to_mark() to scroll to the mark after
+    inserting new text.
+
+    The gtk-demo application contains an example of this technique.
+
+## GtkTreeView questions
+
+26. How do I associate some data with a row in the tree?
+
+    Remember that the #GtkTreeModel columns don't necessarily have to be
+    displayed. So you can put non-user-visible data in your model just
+    like any other data, and retrieve it with gtk_tree_model_get().
+    See the [tree widget overview](#TreeWidget).
+
+27. How do I put an image and some text in the same column?
+
+    You can pack more than one #GtkCellRenderer into a single #GtkTreeViewColumn
+    using gtk_tree_view_column_pack_start() or gtk_tree_view_column_pack_end().
+    So pack both a #GtkCellRendererPixbuf and a #GtkCellRendererText into the
+    column.
+
+28. I can set data easily on my #GtkTreeStore/#GtkListStore models using
+    gtk_list_store_set() and gtk_tree_store_set(), but can't read it back?
+
+    Both the #GtkTreeStore and the #GtkListStore implement the #GtkTreeModel
+    interface. Consequentially, you can use any function this interface
+    implements. The easiest way to read a set of data back is to use
+    gtk_tree_model_get().
+
+29. How do I change the way that numbers are formatted by #GtkTreeView?
+
+    Use gtk_tree_view_insert_column_with_data_func() or
+    gtk_tree_view_column_set_cell_data_func() and do the conversion
+    from number to string yourself (with, say, g_strdup_printf()).
+
+    The following example demonstrates this:
+
+        enum
+        {
+          DOUBLE_COLUMN,
+          N_COLUMNS
+        };
+
+        GtkListStore *mycolumns;
+
+        GtkTreeView *treeview;
+
+        void
+        my_cell_double_to_text (GtkTreeViewColumn *tree_column,
+	                            GtkCellRenderer   *cell,
+                                GtkTreeModel      *tree_model,
+	                            GtkTreeIter       *iter,
+                                gpointer           data)
+        {
+          GtkCellRendererText *cell_text = (GtkCellRendererText *)cell;
+          double d;
+          char *text;
+
+          /* Get the double value from the model. */
+          gtk_tree_model_get (tree_model, iter, (int)data, &d, -1);
+          /* Now we can format the value ourselves. */
+          text = g_strdup_printf ("%.2f", d);
+          g_object_set (cell, "text", text, NULL);
+          g_free (text);
+        }
+
+        void
+        set_up_new_columns (GtkTreeView *myview)
+        {
+          GtkCellRendererText *renderer;
+          GtkTreeViewColumn *column;
+          GtkListStore *mycolumns;
+
+          /* Create the data model and associate it with the given TreeView */
+          mycolumns = gtk_list_store_new (N_COLUMNS, G_TYPE_DOUBLE);
+          gtk_tree_view_set_model (myview, GTK_TREE_MODEL (mycolumns));
+
+          /* Create a GtkCellRendererText */
+          renderer = gtk_cell_renderer_text_new ();
+
+          /* Create a new column that has a title ("Example column"),
+           * uses the above created renderer that will render the double
+           * value into text from the associated model's rows.
+           */
+          column = gtk_tree_view_column_new ();
+          gtk_tree_view_column_set_title  (column, "Example column");
+          renderer = gtk_cell_renderer_text_new ();
+          gtk_tree_view_column_pack_start (column, renderer, TRUE);
+
+          /* Append the new column after the GtkTreeView's previous columns. */
+          gtk_tree_view_append_column (GTK_TREE_VIEW (myview), column);
+          /* Since we created the column by hand, we can set it up for our
+           * needs, e.g. set its minimum and maximum width, etc.
+           */
+          /* Set up a custom function that will be called when the column content
+           * is rendered. We use the func_data pointer as an index into our
+           * model. This is convenient when using multi column lists.
+           */
+          gtk_tree_view_column_set_cell_data_func (column, renderer,
+	                                               my_cell_double_to_text,
+                                                   (gpointer)DOUBLE_COLUMN, NULL);
+        }
+
+30. How do I hide the expander arrows in my tree view?
+
+    Set the expander-column property of the tree view to a hidden column.
+    See gtk_tree_view_set_expander_column() and gtk_tree_view_column_set_visible().
+
+## Using cairo with GTK
+
+31. How do I use cairo to draw in GTK applications?
+
+    Use gtk_snapshot_append_cairo() in your #GtkWidgetClass.snapshot() vfunc
+    to obtain a cairo context and draw with that.
+    
+32. Can I improve the performance of my application by using another backend
+    of cairo (such as GL)?
+
+    No. Most drawing in GTK is not done via cairo anymore (but instead
+    by the GL or Vulkan renderers of GSK).
+
+    If you use cairo for drawing your own widgets, gtk_snapshot_append_cairo()
+    will choose the most appropriate surface type for you.
+
+    If you are interested in using GL for your own drawing, see #GtkGLArea.
+
+33. Can I use cairo to draw on a #GdkPixbuf?
+
+    No. The cairo image surface does not support the pixel format used by GdkPixbuf.
+
+    If you need to get cairo drawing into a format that can be displayed efficiently
+    by GTK, you may want to use an image surface and gdk_memory_texture_new().

docs/reference/gtk/question_index.xml

@@ -1,973 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-question-index">
-<refmeta>
-<refentrytitle>Common Questions</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>Common Questions</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>Common Questions</refname>
-<refpurpose>
-Find answers to common questions in the GTK manual
-</refpurpose>
-</refnamediv>
-
-<refsect1>
-<title>Questions and Answers</title>
-
-<para>
-This is an "index" of the reference manual organized by common "How do
-I..." questions. If you aren't sure which documentation to read for
-the question you have, this list is a good place to start.
-</para>
-
-<qandaset>
-
-<qandadiv><title>General</title>
-
-<qandaentry>
-<question><para>
-How do I get started with GTK?
-</para></question>
-
-<answer><para>
-The GTK <ulink url="https://www.gtk.org">website</ulink> offers some
-<ulink url="https://www.gtk.org/documentation.php">tutorials</ulink> and other
-documentation (most of it about GTK 2.x, but still somewhat applicable). This
-reference manual also contains a introductory
-<link linkend="gtk-getting-started">Getting Started</link> part.</para>
-<para>More documentation ranging from whitepapers to online books can be found at
-the <ulink url="https://developer.gnome.org">GNOME developer's site</ulink>.
-After studying these materials you should be well prepared to come back to
-this reference manual for details.
-</para></answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-Where can I get help with GTK, submit a bug report, or make a feature request?
-</para></question>
-
-<answer>
-
-<para>
-See the <link linkend="gtk-resources">documentation on this topic</link>.
-</para>
-
-</answer>
-
-</qandaentry>
-
-
-<qandaentry>
-<question><para>
-How do I port from one GTK version to another?
-</para></question>
-
-<answer>
-
-<para>
-See <xref linkend="migrating"/>.
-You may also find useful information in the documentation for specific widgets
-and functions. If you have a question not covered in the manual, feel free to
-ask, and please <ulink
-url="https://gitlab.gnome.org/GNOME/gtk/issues/new">file a bug report</ulink>
-against the documentation.
-</para>
-
-</answer>
-
-</qandaentry>
-
-
-<qandaentry>
-<question><para>
-How does memory management work in GTK? Should I free data returned from functions?
-</para></question>
-
-<answer>
-
-<para>
-See the documentation for #GObject and #GInitiallyUnowned. For #GObject note
-specifically g_object_ref() and g_object_unref(). #GInitiallyUnowned is a
-subclass of #GObject so the same points apply, except that it has a "floating"
-state (explained in its documentation).
-</para>
-
-<para>
-For strings returned from functions, they will be declared "const"
-if they should not be freed. Non-const strings should be
-freed with g_free(). Arrays follow the same rule. If you find an
-undocumented exception to the rules, please
-<ulink url="https://gitlab.gnome.org/GNOME/gtk/issues/new">file a bug report</ulink>.
-</para>
-
-<para>
-The transfer annotations for gobject-introspection that are part of the
-documentation can provide useful hints for memory handling semantics as well.
-</para>
-
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question>
-<para>
-Why does my program leak memory, if I destroy a widget immediately
-after creating it ?
-</para>
-</question>
-
-<answer>
-<para>
-If <structname>GtkFoo</structname> isn't a toplevel window, then
-<informalexample><programlisting>
- foo = gtk_foo_new ();
- g_object_unref (foo);
-</programlisting></informalexample>
-is a memory leak, because no one assumed the initial floating reference
-(you will get a warning about this too). If you are using a widget and
-you aren't immediately packing it into a container, then you probably
-want standard reference counting, not floating reference counting.
-</para>
-
-<para>
-To get this, you must acquire a reference to the widget and drop the
-floating reference (<quote>ref and sink</quote> in GObject parlance) after
-creating it:
-<informalexample><programlisting>
- foo = gtk_foo_new ();
- g_object_ref_sink (foo);
-</programlisting></informalexample>
-When you immediately add a widget to a container, it takes care of assuming
-the initial floating reference and you don't have to worry about reference
-counting at all ... just remove the widget from the container to get rid of it.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I use GTK with threads?
-</para></question>
-
-<answer>
-
-<para>
-GTK requires that all GTK API calls are made from the same thread in which
-gtk_init() was called (the <quote>main thread</quote>).</para>
-
-<para>If you want to take advantage of multi-threading in a GTK application,
-it is usually best to send long-running tasks to worker threads, and feed
-the results back to the main thread using g_idle_add() or GAsyncQueue. GIO
-offers useful tools for such an approach such as GTask.
-</para>
-
-</answer>
-
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I internationalize a GTK program?
-</para></question>
-
-<answer>
-<para>
-Most people use <ulink url="https://www.gnu.org/software/gettext/">GNU
-gettext</ulink>, already required in order to install GLib. On a UNIX
-or Linux system with gettext installed, type <literal>info gettext</literal>
-to read the documentation.
-</para>
-<para>
-The short checklist on how to use gettext is: call bindtextdomain() so
-gettext can find the files containing your translations, call textdomain()
-to set the default translation domain, call bind_textdomain_codeset() to
-request that all translated strings are returned in UTF-8, then call
-gettext() to look up each string to be translated in the default domain.
-</para>
-<para>
-<filename>gi18n.h</filename> provides the following shorthand macros for
-convenience.
-Conventionally, people define macros as follows for convenience:
-<informalexample>
-<programlisting>
-  #define  _(x)     gettext (x)
-  #define N_(x)     x
-  #define C_(ctx,x) pgettext (ctx, x)
-</programlisting>
-</informalexample>
-You use N_() (N stands for no-op) to mark a string for translation in
-a location where a function call to gettext() is not allowed, such as
-in an array initializer.
-You eventually have to call gettext() on the string to actually fetch
-the translation. _() both marks the string for translation and actually
-translates it.
-The C_() macro (C stands for context) adds an additional context to
-the string that is marked for translation, which can help to disambiguate
-short strings that might need different translations in different
-parts of your program.
-</para>
-<para>
-Code using these macros ends up looking like this:
-<informalexample>
-<programlisting>
- #include &lt;gi18n.h&gt;
-
- static const char *global_variable = N_("Translate this string");
-
- static void
- make_widgets (void)
- {
-    GtkWidget *label1;
-    GtkWidget *label2;
-
-    label1 = gtk_label_new (_("Another string to translate"));
-    label2 = gtk_label_new (_(global_variable));
-...
-</programlisting>
-</informalexample>
-</para>
-<para>
-Libraries using gettext should use dgettext() instead of gettext(), which
-allows them to specify the translation domain each time they ask for a
-translation. Libraries should also avoid calling textdomain(), since
-they will be specifying the domain instead of using the default.
-</para>
-<para>
-With the convention that the macro <literal>GETTEXT_PACKAGE</literal> is
-defined to hold your libraries translation domain,
-<filename>gi18n-lib.h</filename> can be included to provide
-the following convenience:
-<informalexample>
-<programlisting>
-  #define _(x) dgettext (GETTEXT_PACKAGE, x)
-</programlisting>
-</informalexample>
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question>
-<para>
-How do I use non-ASCII characters in GTK programs ?
-</para>
-</question>
-
-<answer>
-<para>
-GTK uses <ulink url="http://www.unicode.org">Unicode</ulink> (more exactly
-UTF-8) for all text. UTF-8 encodes each Unicode codepoint as a sequence of
-one to six bytes and has a number of nice properties which make it a good
-choice for working with Unicode text in C programs:
-<itemizedlist>
-<listitem><para>
-ASCII characters are encoded by their familiar ASCII codepoints.
-</para></listitem>
-<listitem><para>
-ASCII characters never appear as part of any other character.
-</para></listitem>
-<listitem><para>
-The zero byte doesn't occur as part of a character, so that UTF-8 strings
-can be manipulated with the usual C library functions for handling
-zero-terminated strings.
-</para></listitem>
-</itemizedlist>
-More information about Unicode and UTF-8 can be found in the
-<ulink url="https://www.cl.cam.ac.uk/~mgk25/unicode.html">UTF-8 and Unicode
-FAQ for Unix/Linux</ulink>.
-GLib provides functions for converting strings between UTF-8 and other
-encodings, see g_locale_to_utf8() and g_convert().
-</para>
-<para>
-Text coming from external sources (e.g. files or user input), has to be
-converted to UTF-8 before being handed over to GTK. The following example
-writes the content of a IS0-8859-1 encoded text file to
-<literal>stdout</literal>:
-<informalexample><programlisting>
-gchar *text, *utf8_text;
-gsize length;
-GError *error = NULL;
-
-if (g_file_get_contents (filename, &amp;text, &amp;length, NULL))
-  {
-     utf8_text = g_convert (text, length, "UTF-8", "ISO-8859-1",
-                            NULL, NULL, &amp;error);
-     if (error != NULL)
-       {
-         fprintf ("Couldn't convert file &percnt;s to UTF-8\n", filename);
-         g_error_free (error);
-       }
-     else
-       g_print (utf8_text);
-  }
-else
-  fprintf (stderr, "Unable to read file &percnt;s\n", filename);
-</programlisting></informalexample>
-</para>
-<para>
-For string literals in the source code, there are several alternatives for
-handling non-ASCII content:
-<variablelist>
-<varlistentry><term>direct UTF-8</term>
-<listitem><para>
-If your editor and compiler are capable of handling UTF-8 encoded sources,
-it is very convenient to simply use UTF-8 for string literals, since it
-allows you to edit the strings in "wysiwyg". Note that choosing this option
-may reduce the portability of your code.
-</para></listitem>
-</varlistentry>
-
-<varlistentry><term>escaped UTF-8</term>
-<listitem><para>
-Even if your toolchain can't handle UTF-8 directly, you can still encode
-string literals in UTF-8 by using octal or hexadecimal escapes like
-<literal>\212</literal> or <literal>\xa8</literal> to encode each byte.
-This is portable, but modifying the escaped strings is not very convenient.
-Be careful when mixing hexadecimal escapes with ordinary text;
-<literal>"\xa8abcd"</literal> is a string of length 1 !
-</para></listitem>
-</varlistentry>
-
-<varlistentry><term>runtime conversion</term>
-<listitem><para>
-If the string literals can be represented in an encoding which your
-toolchain can handle (e.g. IS0-8859-1), you can write your source files
-in that encoding and use g_convert() to convert the strings to UTF-8 at
-runtime. Note that this has some runtime overhead, so you may want to move
-the conversion out of inner loops.
-</para></listitem>
-</varlistentry>
-</variablelist>
-Here is an example showing the three approaches using the copyright sign
-&copy; which has Unicode and ISO-8859-1 codepoint 169 and is represented
-in UTF-8 by the two bytes 194, 169, or <literal>"\302\251"</literal> as
-a string literal:
-<informalexample><programlisting>
-g_print ("direct UTF-8: &copy;");
-g_print ("escaped UTF-8: \302\251");
-text = g_convert ("runtime conversion: &copy;", -1, "ISO-8859-1", "UTF-8", NULL, NULL, NULL);
-g_print(text);
-g_free (text);
-</programlisting></informalexample>
-</para>
-<para>
-If you are using gettext() to localize your application, you need to
-call bind_textdomain_codeset() to ensure that translated strings are
-returned in UTF-8 encoding.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I use GTK with C++?
-</para></question>
-
-<answer>
-<para>
-There are two ways to approach this. The GTK header files use the subset
-of C that's also valid C++, so you can simply use the normal GTK API
-in a C++ program. Alternatively, you can use a "C++ binding"
-such as <ulink url="https://www.gtkmm.org/">gtkmm</ulink>
-which provides a native C++ API.
-</para>
-<para>
-When using GTK directly, keep in mind that only functions can be
-connected to signals, not methods. So you will need to use global
-functions or "static" class functions for signal connections.
-</para>
-<para>
-Another common issue when using GTK directly is that
-C++ will not implicitly convert an integer to an enumeration.
-This comes up when using bitfields; in C you can write the following
-code:
-<informalexample>
-<programlisting>
-  gdk_surface_set_events (gdk_surface,
-                         GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
-</programlisting>
-</informalexample>
-while in C++ you must write:
-<informalexample>
-<programlisting>
-  gdk_surface_set_events (gdk_surface,
-                         (GdkEventMask) GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
-</programlisting>
-</informalexample>
-There are very few functions that require this cast, however.
-</para>
-</answer>
-
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I use GTK with other non-C languages?
-</para></question>
-
-<answer>
-<para>
-See the <ulink url="https://www.gtk.org/language-bindings.php">list of language
-bindings</ulink> on <ulink
-url="https://www.gtk.org">https://www.gtk.org</ulink>.
-</para>
-
-</answer>
-
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I load an image or animation from a file?
-</para></question>
-
-<answer>
-
-<para>
-To load an image file straight into a display widget, use
-gtk_image_new_from_file(). To load an image for another purpose, use
-gdk_texture_new_from_file(). To load a video from a file, use
-gtk_media_file_new_for_file().
-</para>
-</answer>
-
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I draw text ?
-</para></question>
-
-<answer>
-<para>
-To draw a piece of text onto a cairo surface, use a Pango layout and
-pango_cairo_show_layout().
-<informalexample>
-<programlisting>
- layout = gtk_widget_create_pango_layout (widget, text);
- fontdesc = pango_font_description_from_string ("Luxi Mono 12");
- pango_layout_set_font_description (layout, fontdesc);
- pango_cairo_show_layout (cr, layout);
- pango_font_description_free (fontdesc);
- g_object_unref (layout);
-</programlisting>
-</informalexample>
-</para>
-
-<para>
-See also the
-<ulink url="https://developer.gnome.org/pango/stable/pango-Cairo-Rendering.html">Cairo Rendering</ulink>
-section of <ulink url="https://developer.gnome.org/pango/stable/">Pango manual</ulink>.
-</para>
-
-<para>
-To draw a piece of text in a widget snapshot() implementation, use
-gtk_snapshot_append_layout().
-</para>
-</answer>
-
-</qandaentry>
-
-<qandaentry>
-<question>
-<para>
-How do I measure the size of a piece of text ?
-</para>
-</question>
-
-<answer>
-<para>
-To obtain the size of a piece of text, use a Pango layout and
-pango_layout_get_pixel_size(), using code like the following:
-<informalexample>
-<programlisting>
- layout = gtk_widget_create_pango_layout (widget, text);
- fontdesc = pango_font_description_from_string ("Luxi Mono 12");
- pango_layout_set_font_description (layout, fontdesc);
- pango_layout_get_pixel_size (layout, &amp;width, &amp;height);
- pango_font_description_free (fontdesc);
- g_object_unref (layout);
-</programlisting>
-</informalexample>
-</para>
-
-<para>
-See also the
-<ulink url="https://developer.gnome.org/pango/stable/pango-Layout-Objects.html">Layout Objects</ulink>
-section of <ulink url="https://developer.gnome.org/pango/stable/">Pango manual</ulink>.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question>
-<para>
-Why are types not registered if I use their <literal>GTK_TYPE_BLAH</literal>
-macro ?
-</para>
-</question>
-
-<answer>
-<para>
-The %GTK_TYPE_BLAH macros are defined as calls to gtk_blah_get_type(), and
-the _get_type(<!-- -->) functions are declared as %G_GNUC_CONST which allows
-the compiler to optimize the call away if it appears that the value is not
-being used.
-</para>
-
-<para>
-GLib provides the g_type_ensure() function to work around this problem.
-<informalexample><programlisting>
-  g_type_ensure (GTK_TYPE_BLAH);
-</programlisting></informalexample>
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question>
-<para>
-How do I create a transparent toplevel window ?
-</para>
-</question>
-
-<answer>
-<para>
-Any toplevel window can be transparent.
-It is just a matter of setting a transparent background
-in the CSS style for it.
-</para>
-</answer>
-</qandaentry>
-
-</qandadiv>
-
-<qandadiv><title>Which widget should I use...</title>
-
-<qandaentry>
-<question><para>
-...for lists and trees?
-</para></question>
-
-<answer>
-<para>
-This question has different answers, depending on the size of the dataset
-and the required formatting flexibility.
-</para>
-<para>
-If you want to display a large amount of data in a uniform way, your
-best option is a #GtkTreeView widget. See <link linkend="TreeWidget">tree
-widget overview</link>. A list is just a tree with no branches, so the treeview
-widget is used for lists as well.
-</para>
-<para>
-If you want to display a small amount of items, but need flexible formatting
-and widgetry inside the list, then you probably want to use a #GtkListBox,
-which uses regular widgets for display.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-...for multi-line text display or editing?
-</para></question>
-
-<answer>
-<para>
-See <link linkend="TextWidget">text widget overview</link> &mdash; you
-should use the #GtkTextView widget.
-</para>
-<para>
-If you only have a small amount of text, #GtkLabel may also be appropriate
-of course. It can be made selectable with gtk_label_set_selectable(). For a
-single-line text entry, see #GtkEntry.
-</para>
-</answer>
-</qandaentry>
-
-
-<qandaentry>
-<question><para>
-...to display an image or animation?
-</para></question>
-
-<answer>
-<para>
-GTK has two widgets that are dedicated to displaying images. #GtkImage, for
-small, fixed-size icons and #GtkPicture for content images.
-</para>
-<para>
-Both can display images in just about any format GTK understands.
-You can also use #GtkDrawingArea if you need to do something more complex,
-such as draw text or graphics over the top of the image.
-</para>
-<para>
-Both GtkImage and GtkPicture can display animations and videos as well.
-To show an webm file, load it with the GtkMediaFile API and then use
-it as a paintable:
-<informalexample>
-<programlisting>
-mediafile = gtk_media_file_new_for_filename ("example.webm");
-picture = gtk_picture_new_for_paintable (GDK_PAINTABLE (mediafile));
-</programlisting>
-</informalexample>
-</para>
-
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-...for presenting a set of mutually-exclusive choices, where Windows
-would use a combo box?
-</para></question>
-
-<answer>
-<para>
-With GTK, a #GtkComboBox is the recommended widget to use for this use case.
-If you need an editable text entry, use the #GtkComboBox:has-entry property.
-</para>
-</answer>
-</qandaentry>
-
-</qandadiv>
-
-<qandadiv><title>GtkWidget</title>
-
-<qandaentry>
-<question><para>
-How do I change the color of a widget?
-</para></question>
-
-<answer><para>
-The background color of a widget is determined by the CSS style that applies
-to it. To change that, you can set style classes on the widget, and provide
-custom CSS to change the appearance. Such CSS can be loaded with
-gtk_css_provider_load_from_file() and its variants.
-See gtk_style_context_add_provider().
-</para></answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I change the font of a widget?
-</para></question>
-
-<answer><para>
-If you want to make the text of a label larger, you can use
-gtk_label_set_markup():
-<informalexample><programlisting>
-gtk_label_set_markup (label, "&lt;big&gt;big text&lt;/big&gt;");
-</programlisting></informalexample>
-This is preferred for many apps because it's a relative size to the
-user's chosen font size. See g_markup_escape_text() if you are
-constructing such strings on the fly.
-</para>
-<para>
-You can also change the font of a widget by putting
-<programlisting>
- .my-widget-class {
-   font: Sans 30;
- }
-</programlisting>
-in a CSS file, loading it with gtk_css_provider_load_from_file(), and
-adding the provider with gtk_style_context_add_provider_for_display().
-To associate this style information with your widget, set a style class
-on its #GtkStyleContext using gtk_style_context_add_class().
-The advantage of this approach is that users can then override the font
-you have chosen. See the #GtkStyleContext documentation for more discussion.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I disable/ghost/desensitize a widget?
-</para></question>
-
-<answer><para>
-In GTK a disabled widget is termed "insensitive."
-See gtk_widget_set_sensitive().
-</para></answer>
-</qandaentry>
-
-</qandadiv>
-
-
-<qandadiv><title>GtkTextView</title>
-
-<qandaentry>
-<question><para>
-How do I get the contents of the entire text widget as a string?
-</para></question>
-
-<answer><para>
-See gtk_text_buffer_get_bounds() and gtk_text_buffer_get_text()
-or gtk_text_iter_get_text().
-</para>
-<para>
-<informalexample><programlisting>
-  GtkTextIter start, end;
-  GtkTextBuffer *buffer;
-  char *text;
-
-  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
-  gtk_text_buffer_get_bounds (buffer, &amp;start, &amp;end);
-  text = gtk_text_iter_get_text (&amp;start, &amp;end);
-  /* use text */
-  g_free (text);
-</programlisting></informalexample>
-</para></answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I make a text widget display its complete contents in a specific font?
-</para></question>
-
-<answer><para>
-If you use gtk_text_buffer_insert_with_tags() with appropriate tags to
-select the font, the inserted text will have the desired appearance, but
-text typed in by the user before or after the tagged block will appear in
-the default style.
-</para>
-<para>
-To ensure that all text has the desired appearance, use
-gtk_widget_override_font() to change the default font for the widget.
-</para></answer>
-</qandaentry>
-
-<qandaentry>
-<question>
-<para>
-How do I make a text view scroll to the end of the buffer automatically ?
-</para>
-</question>
-
-<answer>
-<para>
-A good way to keep a text buffer scrolled to the end is to place a
-<link linkend="GtkTextMark">mark</link> at the end of the buffer, and
-give it right gravity. The gravity has the effect that text inserted
-at the mark gets inserted <emphasis>before</emphasis>, keeping the mark
-at the end.
-</para>
-
-<para>
-To ensure that the end of the buffer remains visible, use
-gtk_text_view_scroll_to_mark() to scroll to the mark after
-inserting new text.
-</para>
-
-<para>
-The gtk-demo application contains an example of this technique.
-</para>
-</answer>
-</qandaentry>
-</qandadiv>
-
-
-
-<qandadiv><title>#GtkTreeView</title>
-
-<qandaentry>
-<question><para>
-How do I associate some data with a row in the tree?
-</para></question>
-
-<answer>
-<para>
-Remember that the #GtkTreeModel columns don't necessarily have to be
-displayed. So you can put non-user-visible data in your model just
-like any other data, and retrieve it with gtk_tree_model_get().
-See the <link linkend="TreeWidget">tree widget overview</link>.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I put an image and some text in the same column?
-</para></question>
-
-<answer>
-<para>
-You can pack more than one #GtkCellRenderer into a single #GtkTreeViewColumn
-using gtk_tree_view_column_pack_start() or gtk_tree_view_column_pack_end().
-So pack both a #GtkCellRendererPixbuf and a #GtkCellRendererText into the
-column.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-I can set data easily on my #GtkTreeStore/#GtkListStore models using
-gtk_list_store_set() and gtk_tree_store_set(), but can't read it back?
-</para></question>
-
-<answer>
-<para>
-Both the #GtkTreeStore and the #GtkListStore implement the #GtkTreeModel
-interface. Consequentially, you can use any function this interface
-implements. The easiest way to read a set of data back is to use
-gtk_tree_model_get().
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I change the way that numbers are formatted by #GtkTreeView?
-</para></question>
-<answer><para>
-Use gtk_tree_view_insert_column_with_data_func()
-or gtk_tree_view_column_set_cell_data_func() and do the conversion
-from number to string yourself (with, say, g_strdup_printf()).
-</para>
-
-<para>
-The following example demonstrates this:
-<informalexample><programlisting>
-enum
-{
-  DOUBLE_COLUMN,
-  N_COLUMNS
-};
-
-GtkListStore *mycolumns;
-GtkTreeView *treeview;
-
-void
-my_cell_double_to_text (GtkTreeViewColumn *tree_column,
-	                GtkCellRenderer   *cell,
-                        GtkTreeModel      *tree_model,
-	                GtkTreeIter       *iter,
-                        gpointer           data)
-{
-  GtkCellRendererText *cell_text = (GtkCellRendererText *)cell;
-  gdouble d;
-  gchar *text;
-
-  /* Get the double value from the model. */
-  gtk_tree_model_get (tree_model, iter, (gint)data, &amp;d, -1);
-  /* Now we can format the value ourselves. */
-  text = g_strdup_printf ("&percnt;.2f", d);
-  g_object_set (cell, "text", text, NULL);
-  g_free (text);
-}
-
-void
-set_up_new_columns (GtkTreeView *myview)
-{
-  GtkCellRendererText *renderer;
-  GtkTreeViewColumn *column;
-  GtkListStore *mycolumns;
-
-  /* Create the data model and associate it with the given TreeView */
-  mycolumns = gtk_list_store_new (N_COLUMNS, G_TYPE_DOUBLE);
-  gtk_tree_view_set_model (myview, GTK_TREE_MODEL (mycolumns));
-
-  /* Create a GtkCellRendererText */
-  renderer = gtk_cell_renderer_text_new (<!-- -->);
-
-  /* Create a new column that has a title ("Example column"),
-   * uses the above created renderer that will render the double
-   * value into text from the associated model's rows.
-   */
-  column = gtk_tree_view_column_new (<!-- -->);
-  gtk_tree_view_column_set_title  (column, "Example column");
-  renderer = gtk_cell_renderer_text_new (<!-- -->);
-  gtk_tree_view_column_pack_start (column, renderer, TRUE);
-
-  /* Append the new column after the GtkTreeView's previous columns. */
-  gtk_tree_view_append_column (GTK_TREE_VIEW (myview), column);
-  /* Since we created the column by hand, we can set it up for our
-   * needs, e.g. set its minimum and maximum width, etc.
-   */
-  /* Set up a custom function that will be called when the column content
-   * is rendered. We use the func_data pointer as an index into our
-   * model. This is convenient when using multi column lists.
-   */
-  gtk_tree_view_column_set_cell_data_func (column, renderer,
-	                                   my_cell_double_to_text,
-                                           (gpointer)DOUBLE_COLUMN, NULL);
-}
-</programlisting></informalexample>
-</para></answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-How do I hide the expander arrows in my tree view ?
-</para></question>
-
-<answer><para>
-Set the expander-column property of the tree view to a hidden column.
-See gtk_tree_view_set_expander_column() and gtk_tree_view_column_set_visible().
-</para></answer>
-</qandaentry>
-
-</qandadiv>
-
-<qandadiv><title>Using cairo with GTK</title>
-
-<qandaentry>
-<question><para>
-How do I use cairo to draw in GTK applications ?
-</para></question>
-
-<answer><para>
-Use gtk_snapshot_append_cairo() in your #GtkWidgetClass.snapshot() vfunc
-to obtain a cairo context and draw with that.
-</para>
-</answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-Can I improve the performance of my application by using another backend
-of cairo (such as GL) ?
-</para></question>
-
-<answer><para>
-No. Most drawing in GTK is not done via cairo anymore (but instead
-by the GL or Vulkan renderers of GSK).
-</para>
-<para>
-If you use cairo for drawing your own widgets, gtk_snapshot_append_cairo()
-will choose the most appropriate surface type for you.
-</para>
-<para>
-If you are interested in using GL for your own drawing, see #GtkGLArea.
-</para></answer>
-</qandaentry>
-
-<qandaentry>
-<question><para>
-Can I use cairo to draw on a #GdkPixbuf ?
-</para></question>
-
-<answer><para>
-No. The cairo image surface does not support the pixel format used by GdkPixbuf.
-</para>
-<para>
-If you need to get cairo drawing into a format that can be displayed efficiently
-by GTK, you may want to use an image surface and gdk_memory_texture_new().
-</para></answer>
-</qandaentry>
-
-</qandadiv>
-
-</qandaset>
-
-</refsect1>
-
-</refentry>

docs/reference/gtk/resources.md

@@ -1,76 +1,39 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-resources">
-<refmeta>
-<refentrytitle>Contact information and bug reports</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>Contact information and bug reports</refmiscinfo>
-</refmeta>
+# Contact information and bug reports {#gtk-resources}
 
-<refnamediv>
-<refname>Contact information and bug reports</refname>
-<refpurpose>
-Getting help with GTK
-</refpurpose>
-</refnamediv>
+## Opening a bug or feature request
 
-<refsect1>
-<title>Opening a bug or feature request</title>
-
-<para>
 If you encounter a bug, misfeature, or missing feature in GTK, please
-file a bug report on our
-<ulink url="https://gitlab.gnome.org/GNOME/gtk/issues/new">GitLab project</ulink>.
+file a bug report on our [GitLab project](https://gitlab.gnome.org/GNOME/gtk/issues/new).
 You should also file issues if the documentation is out of date with the
 existing API, or unclear.
-</para>
 
-<para>
 Don't hesitate to file a bug report, even if you think we may know
 about it already, or aren't sure of the details. Just give us as much
 information as you have, and if it's already fixed or has already been
 discussed, we'll add a note to that effect in the report.
-</para>
 
-<para>
 The issue tracker should definitely be used for feature requests, it's
 not only for bugs. We track all GTK development in GitLab, to ensure
 that nothing gets lost.
-</para>
 
-</refsect1>
+## Working on GTK
 
-<refsect1>
-<title>Working on GTK</title>
-
-<para>
 If you develop a bugfix or enhancement for GTK, please open a merge
 request in GitLab as well. You should not attach patches to an issue,
 or describe the fix as a comment. Merge requests allow us to build
 GTK with your code applied, and run the test suite, on multiple platforms
 and architectures, and verify that nothing breaks. They also allow us to
 do proper code reviews, so we can iterate over the changes.
-</para>
 
-<para>
-You should follow the <ulink url="https://gitlab.gnome.org/GNOME/gtk/blob/master/CONTRIBUTING.md">contribution guide</ulink>
+You should follow the [contribution guide](https://gitlab.gnome.org/GNOME/gtk/blob/master/CONTRIBUTING.md)
 for GTK, available on GitLab.
-</para>
 
-<para>
 If you want to discuss your approach before or after working on it,
 good ways to contact the GTK developers, apart from GitLab issues,
 are
-<simplelist>
-<member>the #gtk IRC channel on irc.gnome.org</member>
-<member>the gtk tag on the <ulink url="https://discourse.gnome.org/tag/gtk">GNOME Discourse instance</ulink></member>
-</simplelist>
+
+- the #gtk IRC channel on irc.gnome.org
+- the gtk tag on the <[GNOME Discourse instance](https://discourse.gnome.org/tag/gtk)
+
 You should not send patches by email, as they will inevitably get lost,
 or forgotten. Always open a merge request.
-</para>
-
-</refsect1>
-
-</refentry>

docs/reference/gtk/running.md

@@ -0,0 +1,350 @@
+# Running and debugging GTK Applications {#gtk-running}
+
+## Environment variables
+
+GTK inspects a number of environment variables in addition to
+standard variables like `LANG`, `PATH`, `HOME` or `DISPLAY`; mostly
+to determine paths to look for certain files. The [X11]{#x11-envar},
+[Windows]{#win32-envar} and [Broadway]{#broadway-envar} GDK backends
+use some additional environment variables.
+
+### GTK_DEBUG {#GTK_Debug-Options}
+
+Unless GTK has been configured with `-Ddebug=false`, this variable
+can be set to a list of debug options, which cause GTK to print out
+different types of debugging information.
+
+actions
+ : Actions and menu models
+builder
+ : GtkBuilder support
+geometry
+ : Size allocation
+icontheme
+ : Icon themes
+keybindings
+ : Keybindings
+modules
+ : Loading of modules
+printing
+ : Printing support
+size-request
+ : Size requests
+text
+ : Text widget internals
+tree
+ : Tree widget internals
+ 
+  A number of keys are influencing behavior instead of just logging:
+  
+interactive
+ : Open the [interactive debugger](#interactive-debugging)
+no-css-cache
+ : Bypass caching for CSS style properties
+touchscreen
+ : Pretend the pointer is a touchscreen device
+updates
+ : Visual feedback about window updates
+resize
+ : Highlight resizing widgets
+layout
+ : Show layout borders
+snapshot
+ : Include debug render nodes in the generated snapshots
+ 
+The special value `all` can be used to turn on all debug options.
+The special value `help` can be used to obtain a list of all
+supported debug options.
+
+### GTK_PATH {#gtk-path}
+
+Specifies a list of directories to search when GTK is looking for
+dynamically loaded objects such as input method modules and print
+backends. If the path to the dynamically loaded object is given as
+an absolute path name, then GTK loads it directly. Otherwise, GTK
+goes in turn through the directories in `GTK_PATH`, followed by
+the directory `.gtk-4.0` in the user's home directory, followed
+by the system default directory, which is `libdir/gtk-4.0/modules`.
+(If `GTK_EXE_PREFIX` is defined, `libdir` is `$GTK_EXE_PREFIX/lib`.
+Otherwise it is the libdir specified when GTK was configured, usually
+`/usr/lib`, or `/usr/local/lib`.)
+
+For each directory in this list, GTK actually looks in a subdirectory
+`directory/version/host/type`. Where `version` is derived from the
+version of GTK (use `pkg-config --variable=gtk_binary_version gtk4`
+to determine this from a script), `host` is the architecture on
+which GTK was built. (use `pkg-config --variable=gtk_host gtk4` to
+determine this from a script), and `type` is a directory specific to
+the type of modules; currently it can be `modules`, `immodules` or
+`printbackends`, corresponding to the types of modules mentioned
+above. Either `version`, `host`, or both may be omitted. GTK looks
+first in the most specific directory, then in directories with
+fewer components.
+The components of `GTK_PATH` are separated by the ':' character on
+Linux and Unix, and the ';' character on Windows.
+
+Note that this environment variable is read by GTK 2.x and GTK 3.x
+too, which makes it unsuitable for setting it system-wide (or
+session-wide), since doing so will cause applications using
+different GTK versions to see incompatible modules.
+
+### GTK_IM_MODULE
+
+Specifies an IM module to use in preference to the one determined
+from the locale. If this isn't set and you are running on the system
+that enables `XSETTINGS` and has a value in `Gtk/IMModule`, that will
+be used for the default IM module. This also can be a colon-separated
+list of input-methods, which GTK will try in turn until it finds one
+available on the system.
+
+### GTK_EXE_PREFIX
+
+If set, GTK uses `$GTK_EXE_PREFIX/lib` instead of the libdir
+configured when GTK was compiled.
+
+### GTK_DATA_PREFIX
+
+If set, GTK uses `$GTK_DATA_PREFIX` instead of the prefix
+configured when GTK was compiled.
+
+### GTK_THEME
+
+If set, makes GTK use the named theme instead of the theme
+that is specified by the gtk-theme-name setting. This is intended
+mainly for easy debugging of theme issues.
+
+It is also possible to specify a theme variant to load, by appending
+the variant name with a colon, like this: `GTK_THEME=Adwaita:dark`.
+
+The following environment variables are used by GdkPixbuf, GDK or
+Pango, not by GTK itself, but we list them here for completeness
+nevertheless.
+
+### GDK_PIXBUF_MODULE_FILE
+
+Specifies the file listing the GdkPixbuf loader modules to load.
+This environment variable overrides the default value
+`libdir/gtk-4.0/4.0.0/loaders.cache` (`libdir` is the sysconfdir
+specified when GTK was configured, usually `/usr/lib`.)
+
+The `loaders.cache` file is generated by the
+`gdk-pixbuf-query-loaders` utility.
+
+### GDK_DEBUG
+
+Unless GTK has been configured with `-Ddebug=false`, this variable
+can be set to a list of debug options, which cause GDK to print out
+different types of debugging information.
+
+cursor
+ : Information about cursor objects (only win32)
+eventloop
+ : Information about event loop operation (mostly Quartz)
+misc
+ : Miscellaneous information
+frames
+ : Information about the frame clock
+settings
+ : Information about xsettings
+selection
+ : Information about selections
+clipboard
+ : Information about clipboards
+dnd
+ : Information about drag-and-drop
+opengl
+ : Information about OpenGL
+vulkan
+ : Information about Vulkan
+ 
+A number of options affect behavior instead of logging:
+
+nograbs
+ : Turn off all pointer and keyboard grabs
+gl-disable
+ : Disable OpenGL support
+gl-software
+ : Force OpenGL software rendering
+gl-texture-rect
+ : Use the OpenGL texture rectangle extension, if available
+gl-legacy
+ : Use a legacy OpenGL context
+gl-gles
+ : Use a GLES OpenGL context
+vulkan-disable
+ : Disable Vulkan support
+vulkan-validate
+ : Load the Vulkan validation layer, if available
+ 
+The special value `all` can be used to turn on all
+debug options. The special value `help` can be used
+to obtain a list of all supported debug options.
+
+### GSK_DEBUG {#GSK-Debug-Options}
+
+Unless GTK has been configured with `-Ddebug=false`,
+this variable can be set to a list of debug options,
+which cause GSK to print out different types of debugging
+information.
+
+renderer
+ : General renderer information
+cairo
+ : cairo renderer information
+opengl
+ : OpenGL renderer information
+shaders
+ : Shaders
+surface
+ : Surfaces
+vulkan
+ : Vulkan renderer information
+fallback
+ : Information about fallbacks
+glyphcache
+ : Information about glyph caching
+
+  A number of options affect behavior instead of logging:
+
+diff
+ : Show differences
+geometry
+ : Show borders
+full-redraw
+ : Force full redraws for every frame
+sync
+ : Sync after each frame
+vulkan-staging-image
+ : Use a staging image for Vulkan texture upload
+vulkan-staging-buffer
+ : Use a staging buffer for Vulkan texture upload
+
+The special value `all` can be used to turn on all
+debug options. The special value `help` can be used
+to obtain a list of all supported debug options.
+
+### GDK_BACKEND
+
+If set, selects the GDK backend to use. Selecting a backend
+requires that GTK is compiled with support for that backend.
+The following backends can be selected, provided they are
+included in the GDK libraries you are using:
+
+quartz
+ : Selects the native Quartz backend
+win32
+ : Selects the native backend for Microsoft Windows
+x11
+ : Selects the native backend for connecting to X11 servers
+broadway
+ : Selects the Broadway backend for display in web browsers
+wayland
+ : Selects the Wayland backend for connecting to Wayland compositors
+
+This environment variable can contain a comma-separated list of
+backend names, which are tried in order. The list may also contain
+a *, which means: try all remaining backends. The special value
+`help` can be used to make GDK print out a list of all available
+backends. For more information about selecting backends,
+see the gdk_display_manager_get() function.
+
+### GDK_VULKAN_DEVICE
+
+This variable can be set to the index of a Vulkan device to override
+the default selection of the device that is used for Vulkan rendering.
+The special value `list` can be used to obtain a list of all Vulkan
+devices.
+
+### GSK_RENDERER
+
+If set, selects the GSK renderer to use. The following renderers can
+be selected, provided they are included in the GTK library you are
+using and the GDK backend supports them:
+
+help
+ : Prints information about available options
+broadway
+ : Selects the Broadway-backend specific renderer
+cairo
+ : Selects the fallback Cairo renderer
+gl
+ : Selects the default OpenGL renderer
+vulkan
+ : Selects the Vulkan renderer
+
+### GTK_CSD
+
+The default value of this environment variable is 1. If changed
+to 0, this disables the default use of client-side decorations
+on GTK windows, thus making the window manager responsible for
+drawing the decorations of windows that do not have a custom
+titlebar widget.
+
+CSD is always used for windows with a custom titlebar widget set,
+as the WM should not draw another titlebar or other decorations
+around the custom one.
+
+### XDG_DTA_HOME, XDG_DATA_DIRS
+
+GTK uses these environment variables to locate icon themes
+and MIME information. For more information, see the
+[Icon Theme Specification](https://freedesktop.org/Standards/icon-theme-spec)
+the [Shared MIME-Info Database](https://freedesktop.org/Standards/shared-mime-info-spec)
+and the [Base Directory Specification](https://freedesktop.org/Standards/basedir-spec).
+
+### DESKTOP_STARTUP_ID
+
+GTK uses this environment variable to provide startup notification
+according to the [Startup Notification Spec](https://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt).
+Following the specification, GTK unsets this variable after reading
+it (to keep it from leaking to child processes). So, if you need its
+value for your own purposes, you have to read it before calling
+gtk_init().
+
+## Interactive debugging {#interactive-debugging}
+
+![The inspector](inspector.png)
+
+GTK includes an interactive debugger, called the GTK Inspector, which
+lets you explore the widget tree of any GTK application at runtime,
+as well as tweak the theme and trigger visual debugging aids. You can
+easily try out changes at runtime before putting them into the code.
+
+Note that the GTK inspector can only show GTK internals. It can not
+understand the application-specific logic of a GTK application. Also,
+the fact that the GTK inspector is running in the application process
+limits what it can do. It is meant as a complement to full-blown
+debuggers and system tracing facilities such as DTrace, not as a
+replacement.
+
+To enable the GTK inspector, you can use the Control-Shift-I or
+Control-Shift-D keyboard shortcuts, or set the `GTK_DEBUG=interactive`
+environment variable.
+
+There are a few more environment variables that can be set to influence
+how the inspector renders its UI. `GTK_INSPECTOR_DISPLAY` and
+`GTK_INSPECTOR_RENDERER` determine the GDK display and the GSK
+renderer that the inspector is using.
+
+In some situations, it may be inappropriate to give users access to
+the GTK inspector. The keyboard shortcuts can be disabled with the
+`enable-inspector-keybinding` key in the `org.gtk.Settings.Debug`
+GSettings schema.
+
+## Profiling {#profiling}
+
+GTK supports profiling with sysprof. It exports timing information
+about frameclock phases and various characteristics of GskRenders
+in a format that can be displayed by sysprof or GNOME Builder.
+
+A simple way to capture data is to set the `GTK_TRACE` environment
+variable. When it is set, GTK will write profiling data to a file
+called `gtk.PID.syscap`.
+
+When launching the application from sysprof, it will set the
+`SYSPROF_TRACE_FD` environment variable to point GTK at a file
+descriptor to write profiling data to.
+
+When GtkApplication registers with D-Bus, it exports the
+`org.gnome.Sysprof2.Profiler` D-Bus interface that lets sysprof
+request profiling data at runtime.

docs/reference/gtk/running.xml

@@ -1,601 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
-               "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
-]>
-<refentry id="gtk-running">
-<refmeta>
-<refentrytitle>Running GTK Applications</refentrytitle>
-<manvolnum>3</manvolnum>
-<refmiscinfo>GTK Library</refmiscinfo>
-</refmeta>
-
-<refnamediv>
-<refname>Running GTK Applications</refname>
-<refpurpose>
-How to run and debug your GTK application
-</refpurpose>
-</refnamediv>
-
-<refsect1>
-<title>Running and debugging GTK Applications</title>
-
-<refsect2>
-<title>Environment variables</title>
-
-<para>
-GTK inspects a number of environment variables in addition to standard
-variables like <envar>LANG</envar>, <envar>PATH</envar>, <envar>HOME</envar>
-or <envar>DISPLAY</envar>; mostly to determine paths to look for certain
-files. The <link linkend="x11-envar">X11</link>,
-<link linkend="win32-envar">Windows</link> and
-<link linkend="broadway-envar">Broadway</link> GDK backends use some
-additional environment variables.
-</para>
-
-<formalpara id="GTK-Debug-Options">
-  <title><envar>GTK_DEBUG</envar></title>
-
-  <para>
-  Unless GTK has been configured with <option>--enable-debug=no</option>,
-  this variable can be set to a list of debug options, which cause GTK
-  to print out different types of debugging information.
-  <variablelist>
-    <varlistentry>
-      <term>actions</term>
-      <listitem><para>Actions and menu models</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>builder</term>
-      <listitem><para>GtkBuilder support</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>geometry</term>
-      <listitem><para>Size allocation</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>icontheme</term>
-      <listitem><para>Icon themes</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>keybindings</term>
-      <listitem><para>Keybindings</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>modules</term>
-      <listitem><para>Loading of modules</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>printing</term>
-      <listitem><para>Printing support</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>size-request</term>
-      <listitem><para>Size requests</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>text</term>
-      <listitem><para>Text widget internals</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>tree</term>
-      <listitem><para>Tree widget internals</para></listitem>
-    </varlistentry>
-  </variablelist>
-  A number of keys are influencing behavior instead of just logging:
-  <variablelist>
-    <varlistentry>
-      <term>interactive</term>
-      <listitem><para>Open the <link linkend="interactive-debugging">interactive debugger</link></para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>no-css-cache</term>
-      <listitem><para>Bypass caching for CSS style properties</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>touchscreen</term>
-      <listitem><para>Pretend the pointer is a touchscreen device</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>updates</term>
-      <listitem><para>Visual feedback about window updates</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>resize</term>
-      <listitem><para>Highlight resizing widgets</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>layout</term>
-      <listitem><para>Show layout borders</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>snapshot</term>
-      <listitem><para>Include debug render nodes in the generated snapshots</para></listitem>
-    </varlistentry>
-  </variablelist>
-  The special value <literal>all</literal> can be used to turn on all
-  debug options. The special value <literal>help</literal> can be used
-  to obtain a list of all supported debug options.
-  </para>
-</formalpara>
-
-<formalpara id="gtk-path">
-  <title><envar>GTK_PATH</envar></title>
-
-  <para>
-    Specifies a list of directories to search when GTK is looking for
-    dynamically loaded objects such as input method
-    modules and print backends. If the path to
-    the dynamically loaded object is given as an absolute path name,
-    then GTK loads it directly.
-    Otherwise, GTK goes in turn through the directories in <envar>GTK_PATH</envar>,
-    followed by the directory <filename>.gtk-4.0</filename> in the user's
-    home directory, followed by the system default directory,
-    which is <filename><replaceable>libdir</replaceable>/gtk-4.0/modules</filename>.
-    (If <envar>GTK_EXE_PREFIX</envar> is defined, <replaceable>libdir</replaceable> is
-    <filename>$GTK_EXE_PREFIX/lib</filename>. Otherwise it is the libdir
-    specified when GTK was configured, usually
-    <filename>/usr/lib</filename>, or
-    <filename>/usr/local/lib</filename>.)
-    For each directory in this list, GTK actually looks in a
-    subdirectory
-    <filename><replaceable>directory</replaceable>/<replaceable>version</replaceable>/<replaceable>host</replaceable>/<replaceable>type</replaceable></filename>
-    Where <replaceable>version</replaceable> is derived from the
-    version of GTK (use <literal>pkg-config
-    --variable=gtk_binary_version gtk4</literal> to determine this from a
-    script), <replaceable>host</replaceable> is the architecture on
-    which GTK was built. (use <literal>pkg-config
-    --variable=gtk_host gtk4</literal> to determine this from a
-    script), and <replaceable>type</replaceable> is a directory
-    specific to the type of modules; currently it can be
-    <literal>modules</literal>, <literal>engines</literal>,
-    <literal>immodules</literal>, <literal>filesystems</literal> or
-    <literal>printbackends</literal>, corresponding to the types of
-    modules mentioned above. Either <replaceable>version</replaceable>,
-    <replaceable>host</replaceable>, or both may be omitted. GTK looks
-    first in the most specific directory, then in directories with
-    fewer components.
-    The components of GTK_PATH are separated by the ':' character on
-    Linux and Unix, and the ';' character on Windows.
-  </para>
-  <warning>
-    Note that this environment variable is read by GTK 2.x and GTK 3.x too,
-    which makes it unsuitable for setting it system-wide (or session-wide),
-    since doing so will cause applications using different GTK versions
-    to see incompatible modules.
-  </warning>
-</formalpara>
-
-<formalpara>
-  <title><envar>GTK_IM_MODULE</envar></title>
-
-  <para>
-    Specifies an IM module to use in preference to the one determined
-    from the locale. If this isn't set and you are running on the system
-    that enables <literal>XSETTINGS</literal> and has a value in
-    <literal>Gtk/IMModule</literal>, that will be used for the default
-    IM module.
-    This also can be a colon-separated list of input-methods, which
-    GTK will try in turn until it finds one available on the system.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>GTK_EXE_PREFIX</envar></title>
-
-  <para>
-    If set, GTK uses <filename>$GTK_EXE_PREFIX/lib</filename> instead of
-    the libdir configured when GTK was compiled.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>GTK_DATA_PREFIX</envar></title>
-
-  <para>
-    If set, makes GTK use <filename>$GTK_DATA_PREFIX</filename>
-    instead of the prefix configured when GTK was compiled.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>GTK_THEME</envar></title>
-
-  <para>
-    If set, makes GTK use the named theme instead of the theme
-    that is specified by the gtk-theme-name setting. This is intended
-    mainly for easy debugging of theme issues.
-  </para>
-  <para>
-    It is also possible to specify a theme variant to load, by appending
-    the variant name with a colon, like this: `GTK_THEME=Adwaita:dark`.
-  </para>
-</formalpara>
-
-<para>
-The following environment variables are used by GdkPixbuf, GDK or
-Pango, not by GTK itself, but we list them here for completeness
-nevertheless.
-</para>
-
-<formalpara>
-  <title><envar>GDK_PIXBUF_MODULE_FILE</envar></title>
-
-  <para>
-    Specifies the file listing the GdkPixbuf loader modules to load.
-    This environment variable overrides the default value
-    <filename><replaceable>libdir</replaceable>/gtk-4.0/4.0.0/loaders.cache</filename>
-    (<replaceable>libdir</replaceable> is the sysconfdir specified when
-    GTK was configured, usually <filename>/usr/local/lib</filename>.)
-  </para>
-  <para>
-    The <filename>loaders.cache</filename> file is generated by the
-    <command>gdk-pixbuf-query-loaders</command> utility.
-  </para>
- </formalpara>
-
-<formalpara id="GDK-Debug-Options">
-  <title><envar>GDK_DEBUG</envar></title>
-
-  <para>
-  If GTK has been configured with <option>--enable-debug=yes</option>,
-  this variable can be set to a list of debug options, which cause GDK
-  to print out different types of debugging information.
-  <variablelist>
-    <varlistentry>
-      <term>cursor</term>
-      <listitem><para>Information about cursor objects (only win32)</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>eventloop</term>
-      <listitem><para>Information about event loop operation (mostly Quartz)</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>misc</term>
-      <listitem><para>Miscellaneous information</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>frames</term>
-      <listitem><para>Information about the frame clock</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>settings</term>
-      <listitem><para>Information about xsettings</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>selection</term>
-      <listitem><para>Information about selections</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>clipboard</term>
-      <listitem><para>Information about clipboards</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>dnd</term>
-      <listitem><para>Information about drag-and-drop</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>opengl</term>
-      <listitem><para>Information about OpenGL</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>vulkan</term>
-      <listitem><para>Information about Vulkan</para></listitem>
-    </varlistentry>
-  </variablelist>
-  A number of options affect behavior instead of logging:
-  <variablelist>
-    <varlistentry>
-      <term>nograbs</term>
-      <listitem><para>Turn off all pointer and keyboard grabs</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>gl-disable</term>
-      <listitem><para>Disable OpenGL support</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>gl-software</term>
-      <listitem><para>Force OpenGL software rendering</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>gl-texture-rect</term>
-      <listitem><para>Use the OpenGL texture rectangle extension, if available</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>gl-legacy</term>
-      <listitem><para>Use a legacy OpenGL context</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>gl-gles</term>
-      <listitem><para>Use a GLES OpenGL context</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>vulkan-disable</term>
-      <listitem><para>Disable Vulkan support</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>vulkan-validate</term>
-      <listitem><para>Load the Vulkan validation layer, if available</para></listitem>
-    </varlistentry>
-  </variablelist>
-  The special value <literal>all</literal> can be used to turn on all
-  debug options. The special value <literal>help</literal> can be used
-  to obtain a list of all supported debug options.
-  </para>
-</formalpara>
-
-<formalpara id="GSK-Debug-Options">
-  <title><envar>GSK_DEBUG</envar></title>
-
-  <para>
-  If GTK has been configured with <option>--enable-debug=yes</option>,
-  this variable can be set to a list of debug options, which cause GSK
-  to print out different types of debugging information.
-  <variablelist>
-    <varlistentry>
-      <term>renderer</term>
-      <listitem><para>General renderer information</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>cairo</term>
-      <listitem><para>cairo renderer information</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>opengl</term>
-      <listitem><para>OpenGL renderer information</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>shaders</term>
-      <listitem><para>Shaders</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>ssurface</term>
-      <listitem><para>Surfaces</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>vulkan</term>
-      <listitem><para>Vulkan renderer information</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>fallback</term>
-      <listitem><para>Information about fallbacks</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>glyphcache</term>
-      <listitem><para>Information about glyph caching</para></listitem>
-    </varlistentry>
-  </variablelist>
-  A number of options affect behavior instead of logging:
-  <variablelist>
-    <varlistentry>
-      <term>diff</term>
-      <listitem><para>Show differences</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>geometry</term>
-      <listitem><para>Show borders</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>full-redraw</term>
-      <listitem><para>Force full redraws for every frame</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>sync</term>
-      <listitem><para>Sync after each frame</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>vulkan-staging-image</term>
-      <listitem><para>Use a staging image for Vulkan texture upload</para></listitem>
-    </varlistentry>
-    <varlistentry>
-      <term>vulkan-staging-buffer</term>
-      <listitem><para>Use a staging buffer for Vulkan texture upload</para></listitem>
-    </varlistentry>
-  </variablelist>
-  The special value <literal>all</literal> can be used to turn on all
-  debug options. The special value <literal>help</literal> can be used
-  to obtain a list of all supported debug options.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>GDK_BACKEND</envar></title>
-
-  <para>
-    If set, selects the GDK backend to use. Selecting a backend requires that
-    GTK is compiled with support for that backend. The following backends can
-    be selected, provided they are included in the GDK libraries you are using:
-    <variablelist>
-
-      <varlistentry>
-        <term>quartz</term>
-        <listitem><para>Selects the native Quartz backend</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>win32</term>
-        <listitem><para>Selects the native backend for Microsoft Windows</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>x11</term>
-        <listitem><para>Selects the native backend for connecting to X11 servers.</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>broadway</term>
-        <listitem><para>Selects the Broadway backend for display in web browsers</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>wayland</term>
-        <listitem><para>Selects the Wayland backend for connecting to Wayland display servers</para></listitem>
-      </varlistentry>
-
-    </variablelist>
-    Since 3.10, this environment variable can contain a comma-separated list
-    of backend names, which are tried in order. The list may also contain
-    a *, which means: try all remaining backends. The special value "help" can
-    be used to make GDK print out a list of all available backends.
-    For more information about selecting backends, see the gdk_display_manager_get() function.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>GDK_VULKAN_DEVICE</envar></title>
-
-  <para>
-    This variable can be set to the index of a Vulkan device to override the
-    default selection of the device that is used for Vulkan rendering.
-    The special value <literal>list</literal> can be used to obtain a list
-    of all Vulkan devices.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>GSK_RENDERER</envar></title>
-
-  <para>
-    If set, selects the GSK renderer to use. The following renderers can
-    be selected, provided they are included in the GTK library you are using
-    and the GDK backend supports them:
-    <variablelist>
-
-      <varlistentry>
-        <term>help</term>
-        <listitem><para>Prints information about available options</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>broadway</term>
-        <listitem><para>Selects the Broadway-backend specific renderer</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>cairo</term>
-        <listitem><para>Selects the fallback Cairo renderer</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>gl</term>
-        <listitem><para>Selects the default OpenGL renderer</para></listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>vulkan</term>
-        <listitem><para>Selects the Vulkan renderer</para></listitem>
-      </varlistentry>
-
-    </variablelist>
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>GTK_CSD</envar></title>
-
-  <para>
-    The default value of this environment variable is 1. If changed to 0, this
-    disables the default use of client-side decorations on GTK windows, thus
-    making the window manager responsible for drawing the decorations of
-    windows that do not have a custom titlebar widget.
-  </para>
-  <para>
-    CSD is always used for windows with a custom titlebar widget set, as the WM
-    should not draw another titlebar or other decorations around the custom one.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>XDG_DATA_HOME</envar>, <envar>XDG_DATA_DIRS</envar></title>
-
-  <para>
-    GTK uses these environment variables to locate icon themes
-    and MIME information. For more information, see
-    <ulink url="https://freedesktop.org/Standards/icon-theme-spec">Icon Theme Specification</ulink>,
-    the <ulink url="https://freedesktop.org/Standards/shared-mime-info-spec">Shared MIME-info Database</ulink>
-    and the <ulink url="https://freedesktop.org/Standards/basedir-spec">Base Directory Specification</ulink>.
-  </para>
-</formalpara>
-
-<formalpara>
-  <title><envar>DESKTOP_STARTUP_ID</envar></title>
-
-  <para>
-    GTK uses this environment variable to provide startup notification
-    according to the <ulink url="https://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt">Startup Notification Spec</ulink>.
-    Following the specification, GTK unsets this variable after reading
-    it (to keep it from leaking to child processes). So, if you need its
-    value for your own purposes, you have to read it before calling
-    gtk_init().
-  </para>
-</formalpara>
-
-</refsect2>
-
-<refsect2 id="interactive-debugging">
-<title>Interactive debugging</title>
-
-  <inlinegraphic fileref="inspector.png" format="PNG"></inlinegraphic>
-
-  <para>
-    GTK includes an interactive debugger, called the GTK Inspector, which
-    lets you explore the widget tree of any GTK application at runtime, as
-    well as tweak the theme and trigger visual debugging aids. You can
-    easily try out changes at runtime before putting them into the code.
-  </para>
-  <para>
-    Note that the GTK inspector can only show GTK internals. It can not
-    understand the application-specific logic of a GTK application. Also,
-    the fact that the GTK inspector is running in the application process
-    limits what it can do. It is meant as a complement to full-blown debuggers
-    and system tracing facilities such as DTrace, not as a replacement.
-  </para>
-  <para>
-    To enable the GTK inspector, you can use the Control-Shift-I or
-    Control-Shift-D keyboard shortcuts, or set the
-    <envar>GTK_DEBUG=interactive</envar> environment variable.
-  </para>
-  <para>
-    There are a few more environment variables that can be set to influence
-    how the inspector renders its UI. <envar>GTK_INSPECTOR_DISPLAY</envar> and
-    <envar>GTK_INSPECTOR_RENDERER</envar> determine the GDK display and
-    the GSK renderer that the inspector is using.
-  </para>
-
-  <para>
-    In some situations, it may be inappropriate to give users access to the
-    GTK inspector. The keyboard shortcuts can be disabled with the
-    `enable-inspector-keybinding` key in the `org.gtk.Settings.Debug`
-    GSettings schema.
-  </para>
-
-</refsect2>
-
-<refsect2 id="profiling">
-  <title>Profiling</title>
-
-  <para>
-    GTK supports profiling with sysprof. It exports timing information
-    about frameclock phases and various characteristics of GskRenders
-    in a format that can be displayed by sysprof or GNOME Builder.
-  </para>
-  <para>
-    A simple way to capture data is to set the <envar>GTK_TRACE</envar>
-    environment variable. When it is set, GTK will write profiling
-    data to a file called
-    <filename>gtk.<replaceable>PID</replaceable>.syscap</filename>.
-  </para>
-  <para>
-    When launching the application from sysprof, it will set the
-    <envar>SYSPROF_TRACE_FD</envar> environment variable to point
-    GTK at a file descriptor to write profiling data to.
-  </para>
-  <para>
-    When GtkApplication registers with D-Bus, it exports the
-    <literal>org.gnome.Sysprof2.Profiler</literal> interface
-    that lets sysprof request profiling data at runtime.
-  </para>
-</refsect2>
-
-</refsect1>
-
-</refentry>