colorstate: Change the rendering color state api

Pass an extra boolean that tells whether the target image is GL_SRGB, in which case, the rendering color state must be srgb-linear. Update all callers to pass FALSE, except for the one call in the node processor, where we want to take GL_LINEAR into account. Also update the draw context begin_frame implementations to just return GDK_COLOR_STATE_SRGB now.
2024-08-07 18:54:54 -04:00
737 changed files with 37384 additions and 71812 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -26,8 +26,7 @@ variables:
  BACKEND_FLAGS: "-Dx11-backend=true -Dwayland-backend=true -Dbroadway-backend=true"
  FEATURE_FLAGS: "-Dvulkan=enabled -Dcloudproviders=enabled -Dbuild-testsuite=true -Dintrospection=enabled"
  MESON_TEST_TIMEOUT_MULTIPLIER: 3
-  MESON_TEST_MAX_PROCESSES: 8
-  FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/gtk/fedora:v52"
+  FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/gtk/fedora:v49"

 workflow:
  rules:
@@ -68,6 +67,7 @@ style-check-diff:
        - "${CI_PROJECT_DIR}/_build/report-x11.xml"
        - "${CI_PROJECT_DIR}/_build/report-wayland.xml"
        - "${CI_PROJECT_DIR}/_build/report-wayland_gl.xml"
+        - "${CI_PROJECT_DIR}/_build/report-wayland_gles2.xml"
        - "${CI_PROJECT_DIR}/_build/report-broadway.xml"
    name: "gtk-${CI_COMMIT_REF_NAME}"
    paths:
@@ -118,9 +118,8 @@ release-build:
  script:
    - .gitlab-ci/show-info-linux.sh
    - mkdir _install
-    # don't use catch by default, since it causes sporadic test failures
-    # - export PATH="$HOME/.local/bin:${CI_PROJECT_DIR}/_install/bin:$PATH"
-    # - .gitlab-ci/install-meson-project.sh --prefix ${CI_PROJECT_DIR}/_install https://gitlab.gnome.org/jadahl/catch.git main
+    - export PATH="$HOME/.local/bin:${CI_PROJECT_DIR}/_install/bin:$PATH"
+    - .gitlab-ci/install-meson-project.sh --prefix ${CI_PROJECT_DIR}/_install https://gitlab.gnome.org/jadahl/catch.git main
    - meson subprojects download
    - meson subprojects update --reset
    - meson setup
@@ -135,6 +134,8 @@ release-build:
    - PKG_CONFIG_PATH=${CI_PROJECT_DIR}/_install/lib64/pkgconfig:${CI_PROJECT_DIR}/_install/share/pkgconfig meson setup _build_hello examples/hello
    - LD_LIBRARY_PATH=${CI_PROJECT_DIR}/_install/lib64 meson compile -C _build_hello
    - .gitlab-ci/run-tests.sh _build wayland gtk
+    # only repeat test runs that are likely affected by test setups
+    - .gitlab-ci/run-tests.sh _build wayland_gles2 gtk:gdk,gtk:gsk-gl

 fedora-clang:
  extends: .build-fedora-default
@@ -198,11 +199,11 @@ fedora-mingw64:
      - subprojects/libepoxy/
      - subprojects/pango/

-msys2-ucrt64:
+msys2-mingw64:
  extends: .mingw-defaults
  needs: []
  variables:
-    MSYSTEM: "UCRT64"
+    MSYSTEM: "MINGW64"
    CHERE_INVOKING: "yes"
  artifacts:
    when: always
@@ -327,6 +328,20 @@ flatpak:widget-factory:aarch64:
  variables:
    APPID: org.gtk.WidgetFactory4

+flatpak:icon-browser:
+  extends: '.flatpak-defaults'
+  needs: []
+  variables:
+    APPID: org.gtk.IconBrowser4
+
+flatpak:icon-browser:aarch64:
+  extends: '.flatpak-defaults'
+  needs: []
+  tags:
+    - flatpak-aarch64
+  variables:
+    APPID: org.gtk.IconBrowser4
+
 flatpak:node-editor:
  extends: '.flatpak-defaults'
  needs: []
@@ -360,6 +375,14 @@ nightly factory aarch64:
    extends: '.publish_nightly'
    needs: ['flatpak:widget-factory:aarch64']

+nightly icon-browser:
+    extends: '.publish_nightly'
+    needs: ['flatpak:icon-browser']
+
+nightly icon-browser aarch64:
+    extends: '.publish_nightly'
+    needs: ['flatpak:icon-browser:aarch64']
+
 nightly node-editor:
    extends: '.publish_nightly'
    needs: ['flatpak:node-editor']
@@ -391,12 +414,11 @@ static-scan:
 # Run tests with the address sanitizer. We need to turn off introspection
 # and f16c, since they are incompatible with asan
 asan-build:
-  extends: .build-fedora-default
+  image: $FEDORA_IMAGE
  tags: [ asan ]
  stage: analysis
  needs: []
  variables:
-    MESON_TEST_MAX_PROCESSES: 4
  script:
    - export PATH="$HOME/.local/bin:$PATH"
    - CC=clang meson setup
--- a/.gitlab-ci/fedora.Dockerfile
+++ b/.gitlab-ci/fedora.Dockerfile
@@ -1,4 +1,4 @@
-FROM fedora:40
+FROM fedora:39

 RUN dnf -y install \
    adwaita-icon-theme \
@@ -99,11 +99,8 @@ RUN dnf -y install \
    which \
    wireplumber \
    xorg-x11-server-Xvfb \
- && dnf -y update \
 && dnf clean all

-RUN rm /usr/share/vulkan/icd.d/powervr_mesa_icd.x86_64.json
-
 # Enable sudo for wheel users
 RUN sed -i -e 's/# %wheel/%wheel/' -e '0,/%wheel/{s/%wheel/# %wheel/}' /etc/sudoers

--- a/.gitlab-ci/run-tests.sh
+++ b/.gitlab-ci/run-tests.sh
@@ -8,19 +8,17 @@ builddir=$1
 setup=$2
 suite=$3
 multiplier=${MESON_TEST_TIMEOUT_MULTIPLIER:-1}
-n_processes=${MESON_TEST_MAX_PROCESSES:-1}

 # Ignore memory leaks lower in dependencies
 export LSAN_OPTIONS=suppressions=$srcdir/lsan.supp:print_suppressions=0:detect_leaks=0:allocator_may_return_null=1
+export G_SLICE=always-malloc

 case "${setup}" in
  x11*)
-    dbus-run-session -- \
-       xvfb-run -a -s "-screen 0 1024x768x24 -noreset" \
+    xvfb-run -a -s "-screen 0 1024x768x24 -noreset" \
          meson test -C ${builddir} \
                --quiet \
                --timeout-multiplier "${multiplier}" \
-                --num-processes "${n_processes}" \
                --print-errorlogs \
                --setup=${setup} \
                --suite=${suite//,/ --suite=} \
@@ -42,11 +40,9 @@ case "${setup}" in
    compositor=$!
    export WAYLAND_DISPLAY=wayland-5

-    dbus-run-session -- \
-          meson test -C ${builddir} \
+    meson test -C ${builddir} \
                --quiet \
                --timeout-multiplier "${multiplier}" \
-                --num-processes "${n_processes}" \
                --print-errorlogs \
                --setup=${setup} \
                --suite=${suite//,/ --suite=} \
@@ -67,11 +63,9 @@ case "${setup}" in
    server=$!
    export BROADWAY_DISPLAY=:5

-    dbus-run-session -- \
-          meson test -C ${builddir} \
+    meson test -C ${builddir} \
                --quiet \
                --timeout-multiplier "${multiplier}" \
-                --num-processes "${n_processes}" \
                --print-errorlogs \
                --setup=${setup} \
                --suite=${suite//,/ --suite=} \
--- a/.gitlab-ci/test-msys2.sh
+++ b/.gitlab-ci/test-msys2.sh
@@ -2,6 +2,12 @@

 set -e

+if [[ "$MSYSTEM" == "MINGW32" ]]; then
+    export MSYS2_ARCH="i686"
+else
+    export MSYS2_ARCH="x86_64"
+fi
+
 # Update everything
 pacman --noconfirm -Suy

@@ -9,27 +15,27 @@ pacman --noconfirm -Suy
 pacman --noconfirm -S --needed \
    base-devel \
    git \
-    ${MINGW_PACKAGE_PREFIX}-cc \
-    ${MINGW_PACKAGE_PREFIX}-ccache \
-    ${MINGW_PACKAGE_PREFIX}-pkgconf \
-    ${MINGW_PACKAGE_PREFIX}-gobject-introspection \
-    ${MINGW_PACKAGE_PREFIX}-meson \
-    ${MINGW_PACKAGE_PREFIX}-adwaita-icon-theme \
-    ${MINGW_PACKAGE_PREFIX}-atk \
-    ${MINGW_PACKAGE_PREFIX}-cairo \
-    ${MINGW_PACKAGE_PREFIX}-gdk-pixbuf2 \
-    ${MINGW_PACKAGE_PREFIX}-glib2 \
-    ${MINGW_PACKAGE_PREFIX}-graphene \
-    ${MINGW_PACKAGE_PREFIX}-json-glib \
-    ${MINGW_PACKAGE_PREFIX}-libepoxy \
-    ${MINGW_PACKAGE_PREFIX}-pango \
-    ${MINGW_PACKAGE_PREFIX}-fribidi \
-    ${MINGW_PACKAGE_PREFIX}-gst-plugins-bad-libs \
-    ${MINGW_PACKAGE_PREFIX}-shared-mime-info \
-    ${MINGW_PACKAGE_PREFIX}-python-gobject \
-    ${MINGW_PACKAGE_PREFIX}-shaderc \
-    ${MINGW_PACKAGE_PREFIX}-vulkan \
-    ${MINGW_PACKAGE_PREFIX}-vulkan-headers
+    mingw-w64-$MSYS2_ARCH-cc \
+    mingw-w64-$MSYS2_ARCH-ccache \
+    mingw-w64-$MSYS2_ARCH-pkgconf \
+    mingw-w64-$MSYS2_ARCH-gobject-introspection \
+    mingw-w64-$MSYS2_ARCH-meson \
+    mingw-w64-$MSYS2_ARCH-adwaita-icon-theme \
+    mingw-w64-$MSYS2_ARCH-atk \
+    mingw-w64-$MSYS2_ARCH-cairo \
+    mingw-w64-$MSYS2_ARCH-gdk-pixbuf2 \
+    mingw-w64-$MSYS2_ARCH-glib2 \
+    mingw-w64-$MSYS2_ARCH-graphene \
+    mingw-w64-$MSYS2_ARCH-json-glib \
+    mingw-w64-$MSYS2_ARCH-libepoxy \
+    mingw-w64-$MSYS2_ARCH-pango \
+    mingw-w64-$MSYS2_ARCH-fribidi \
+    mingw-w64-$MSYS2_ARCH-gst-plugins-bad-libs \
+    mingw-w64-$MSYS2_ARCH-shared-mime-info \
+    mingw-w64-$MSYS2_ARCH-python-gobject \
+    mingw-w64-$MSYS2_ARCH-shaderc \
+    mingw-w64-$MSYS2_ARCH-vulkan \
+    mingw-w64-$MSYS2_ARCH-vulkan-headers

 mkdir -p _ccache
 export CCACHE_BASEDIR="$(pwd)"
--- a/.gitlab/issue_templates/Bug.md
+++ b/.gitlab/issue_templates/Bug.md
@@ -34,9 +34,7 @@
 <!--
 - Which version of GTK you are using
 - What operating system and version
- - What windowing system (X11 or Wayland)
- - What graphics driver / mesa version
- - For Linux, which distribution
+  - For Linux, which distribution
 - If you built GTK yourself, the list of options used to configure the build
 -->

--- a/282
+++ b/282
@@ -1,286 +1,6 @@
-Overview of Changes in 4.17.0, xx-xx-xxxx
+Overview of Changes in 4.15.5, xx-xx-xxxx
 =========================================

-
-Overview of Changes in 4.16.2, 09-25-2024
-=========================================
-
-* GtkLabel:
- - Fix centered text in RTL
-
-* Gsk:
- - Speed up some Vulkan operations
- - Improve startup speed by avoiding initialization
-   of GL and Vulkan in most cases
- - Reduce critials at startup to warnings
- - Fix a crash on startup with some Vulkan drivers
- - Fix a big texture leak in NGL
-
-* Gdk:
- - Speed up memory format conversions
-
-* Wayland:
- - Be more careful with mimetypes during DND or copy-paste
-
-* Tools:
- - builder-tool: Improve conversion of boxes
-
-* Translation updates:
- Brazilian Portuguese
- Bulgarian
- Catalan
- Chinese (China)
- Georgian
- German
- Hebrew
- Indonesian
- Persian
- Polish
- Portuguese
- Slovenian
- Spanish
- Turkish
- Ukrainian
-
-
-Overview of Changes in 4.16.1, 09-16-2024
-=========================================
-
-* GtkFileChooser:
- - Plug a memory leak
-
-* GtkCalendar:
- - Avoid ending up with invalid dates
-
-* Printing:
- - Fix initial printer selection in the print dialog
-
-* Gsk:
- - Fix shadows for opaque textures
- - Fix a crash in a corner case
-
-* Css:
- - Make relative paths work again in theme files
-
-* Accessibility:
- - Fix detection of the Flatpak portal
-
-* MacOS:
- - Fix keyboard input in popovers
- - Keep DND icons above regular windows
- - Ignore events from DND icons
-
-* Translation updates
- Basque
- British English
- Bulgarian
- Czech
- Danish
- Georgian
- Hungarian
- Lithuanian
- Portuguese
- Spanish
- Swedish
-
-
-Overview of Changes in 4.16.0, 09-06-2024
-=========================================
-
-Note: This release changes the default GSK renderer to be Vulkan,
-on Wayland. Other platforms still use ngl. The intent of this change
-is to use the best available platform APIs. You can still override
-the renderer choice using the GSK_RENDERER environment variable.
-
-We believe that most of the problems reported with the new renderers
-during the 4.13 and 4.15 development cycles have been addressed by now.
-
-But the new renderers and dmabuf support are using graphics drivers
-in different ways than the old gl renderer, and trigger new driver bugs.
-Therefore, it is recommended to use the latest mesa release (24.2)
-with the new renderers.
-
-* GtkScale:
- - Fix positioning of scale values
-
-* GtkEmojiChooser:
- - Make Control-clicks work for the recent section
-
-* GtkPopover:
- - Make sure focus lands on the right widget when cascading
-
-* GtkSpinButton:
- - Disable Emoji input for numeric spin buttons
-
-* GtkSingleSelection:
- - Implement unselect_all
-
-* Accssibility:
- - Fix roles for radio buttons
- - Check if ATs are listening before exporting trees
- - Add a check for sandboxed accessibility bus
- - Fix handling of the error message relation
- - Turn criticals into debug messages
- - Set expanded states properly in menus
-
-* CSS:
- - Fix a few issues on bigendian systems
- - Avoid a crash with relative colors
-
-* GSK:
- - Use the right GL context when exporting textures
- - Don't let colors influence depth decisions
- - Allow uploading of mipmap levels when tiling textures
-
-* GDK:
- - Update keysyms from libX11 1.8.10
- - Implement cpu-side mipmapping
- - Use a thread pool for color conversions and mipmapping
-
-* Vulkan:
- - Fix drag surface offsets
-
-* Wayland:
- - Fix a crash
- - Associate EGL windows with context later
-
-* X11:
- - Fix initial EGL context creation
- - Fix a problem with GL context creation
-
-* Broadway:
- - Implement compute_size and request_layout
-
-* MacOS:
- - Set transparent backgroiund for toplevel windows
-
-* Windows:
- - Improve debug output
- - Detect Mesas d3d12 driver and request GDI compat
-
-* Demos:
- - Set window icons in demos
- - Add a 64k x 64k image to the image scaling demo
-
-* Translation updates
- Belarusian
- Brazilian Portuguese
- Catalan
- Czech
- Galician
- German
- Hebrew
- Indonesian
- Korean
- Lithuanian
- Persian
- Polish
- Portuguese
- Slovenian
- Spanish
- Turkish
- Ukrainian
-
-
-Overview of Changes in 4.15.6, 08-26-2024
-=========================================
-
-* GtkCheckButton:
- - Add a grouped style class for radio buttons
-
-* GtkScale:
- - Fix alignment and positioning problems
-
-* Css:
- - Fix crashes in the variable support
-
-* Gsk:
- - Make graphics offloading work better with kwin
- - Make colorstate transfer functions more robust
- - GC dead textures more agressively
- - Only use a single render pass per frame
-
-* GL:
- - Round damage rectangles properly
- - Use the shared context when creating textures
- - Fix a file descriptor leak in dmabuf export
-
-* Vulkan:
- - Round damage rectangles properly
-
-* Wayland:
- - Work with the kwin implementation of xx-color-management-v4
-
-* Windows:
- - Make gtk_show_uri use SHOpenWithDialog()
- - Enable incremental rendering with WGL
-
-* Macos:
- - Open context menus on Ctrl-left click
-
-* Debugging:
- - Show color state information in the inspector
- - Collect input event traces in the recorder
- - Add shortcuts for toggling recording: Super-r
-   and for screenshots: Super-c
- - Split the GDK_DEBUG env var into GDK_DEBUG and GDK_DISABLE
- - Add GDK_DISABLE=color-mgmt and GDK_DISABLE=offload
-
-* Tools:
- - Add a 'Paste as node' action in gtk4-node-editor
-
-* Translations updates
- Basque
- Belarusian
- Brazilian Portuguese
- Chinese (China)
- Georgian
- Hebrew
- Hindi
- Russian
- Slovenian
- Turkish
- Ukrainian
-
-
-Overview of Changes in 4.15.5, 11-08-2024
-=========================================
-
-* GtkTextView:
- - ADd GtkTextBufferCommitNotify
-
-* CSS:
- - Propagate color state information to GSK for many features:
-   colors, borders, shadows, text
-
-* Gdk:
- - Fix an fd leak in the Vulkan code
- - Fix a leak of EGLSurfaces and DMA buffers
- - Set the opaque region of surfaces automatically based on their content
-
-* Gsk:
- - Fix Emoji rendering in Vulkan
- - Rework color handling to take color states into account
- - Implement more powerful occlusion culling
- - Minimize our use of renderpasses
-
-* Macos:
- - Fix window transparency
-
-* Debugging:
- - The inspector shows details about color states
-
-* Deprecations:
- - gdk_draw_context_begin/end_frame
- - gdk_surface_set_opaque_region
-
-* Build:
- - Require gstreamer 1.24
-
-* Translation updates
- Romanian
-
-
 Overview of Changes in 4.15.4, 30-07-2024
 =========================================

--- a/README.md
+++ b/README.md
@@ -136,13 +136,9 @@ In the bug report please include:

   - which version of GTK you are using
   - what operating system and version
-   - what windowing system (X11 or Wayland)
-   - what graphics driver / mesa version
   - for Linux, which distribution
   - if you built GTK, the list of options used to configure the build

-  Most of this information can be found in the GTK inspector.
-
  And anything else you think is relevant.

 * How to reproduce the bug.
--- a/build-aux/flatpak/org.gtk.Demo4.json
+++ b/build-aux/flatpak/org.gtk.Demo4.json
@@ -196,5 +196,10 @@
                }
            ]
        }
-    ]
+    ],
+    "build-options" : {
+        "env" : {
+            "GSK_RENDERER" : "opengl"
+        }
+    }
 }
--- a/build-aux/flatpak/org.gtk.WidgetFactory4.json
+++ b/build-aux/flatpak/org.gtk.WidgetFactory4.json
@@ -129,6 +129,7 @@
    "build-options" : {
        "env" : {
            "DBUS_SESSION_BUS_ADDRESS" : "''",
+            "GSK_RENDERER" : "opengl",
            "G_ENABLE_DEBUG" : "true"
        }
    }
--- a/build-aux/flatpak/org.gtk.gtk4.NodeEditor.json
+++ b/build-aux/flatpak/org.gtk.gtk4.NodeEditor.json
@@ -129,6 +129,7 @@
    "build-options" : {
        "env" : {
            "DBUS_SESSION_BUS_ADDRESS" : "''",
+            "GSK_RENDERER" : "opengl",
            "G_ENABLE_DEBUG" : "true"
        }
    }
--- a/demos/constraint-editor/constraint-editor-application.c
+++ b/demos/constraint-editor/constraint-editor-application.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * 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: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "constraint-editor-application.h"
+#include "constraint-editor-window.h"
+
+struct _ConstraintEditorApplication
+{
+  GtkApplication parent_instance;
+};
+
+G_DEFINE_TYPE(ConstraintEditorApplication, constraint_editor_application, GTK_TYPE_APPLICATION);
+
+static void
+constraint_editor_application_init (ConstraintEditorApplication *app)
+{
+}
+
+static void
+quit_activated (GSimpleAction *action,
+                GVariant      *parameter,
+                gpointer       data)
+{
+  g_application_quit (G_APPLICATION (data));
+}
+
+static GActionEntry app_entries[] =
+{
+  { "quit", quit_activated, NULL, NULL, NULL }
+};
+
+static void
+constraint_editor_application_startup (GApplication *app)
+{
+  const char *quit_accels[2] = { "<Ctrl>Q", NULL };
+  const char *open_accels[2] = { "<Ctrl>O", NULL };
+  GtkCssProvider *provider;
+
+  G_APPLICATION_CLASS (constraint_editor_application_parent_class)->startup (app);
+
+  g_action_map_add_action_entries (G_ACTION_MAP (app),
+                                   app_entries, G_N_ELEMENTS (app_entries),
+                                   app);
+  gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.quit", quit_accels);
+  gtk_application_set_accels_for_action (GTK_APPLICATION (app), "win.open", open_accels);
+
+  provider = gtk_css_provider_new ();
+  gtk_css_provider_load_from_resource (provider, "/org/gtk/gtk4/constraint-editor/constraint-editor.css");
+  gtk_style_context_add_provider_for_display (gdk_display_get_default (),
+                                              GTK_STYLE_PROVIDER (provider),
+                                              GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+}
+
+static void
+constraint_editor_application_activate (GApplication *app)
+{
+  ConstraintEditorWindow *win;
+
+  win = constraint_editor_window_new (CONSTRAINT_EDITOR_APPLICATION (app));
+  gtk_window_present (GTK_WINDOW (win));
+}
+
+static void
+constraint_editor_application_open (GApplication  *app,
+                                    GFile        **files,
+                                    int            n_files,
+                                    const char    *hint)
+{
+  ConstraintEditorWindow *win;
+  int i;
+
+  for (i = 0; i < n_files; i++)
+    {
+      win = constraint_editor_window_new (CONSTRAINT_EDITOR_APPLICATION (app));
+      constraint_editor_window_load (win, files[i]);
+      gtk_window_present (GTK_WINDOW (win));
+    }
+}
+
+static void
+constraint_editor_application_class_init (ConstraintEditorApplicationClass *class)
+{
+  GApplicationClass *application_class = G_APPLICATION_CLASS (class);
+
+  application_class->startup = constraint_editor_application_startup;
+  application_class->activate = constraint_editor_application_activate;
+  application_class->open = constraint_editor_application_open;
+}
+
+ConstraintEditorApplication *
+constraint_editor_application_new (void)
+{
+  return g_object_new (CONSTRAINT_EDITOR_APPLICATION_TYPE,
+                       "application-id", "org.gtk.gtk4.ConstraintEditor",
+                       "flags", G_APPLICATION_HANDLES_OPEN,
+                       NULL);
+}
--- a/demos/constraint-editor/constraint-editor-application.h
+++ b/demos/constraint-editor/constraint-editor-application.h
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2024 Benjamin Otte
+ * Copyright © 2019 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -14,19 +14,15 @@
 * 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>
+ * Authors: Matthias Clasen
 */

 #pragma once

-#include <glib.h>
+#include <gtk/gtk.h>

-G_BEGIN_DECLS
+#define CONSTRAINT_EDITOR_APPLICATION_TYPE (constraint_editor_application_get_type ())

-typedef void (* GdkTaskFunc) (gpointer user_data);
-
-void                    gdk_parallel_task_run               (GdkTaskFunc                 task_func,
-                                                             gpointer                    task_data);
-
-G_END_DECLS
+G_DECLARE_FINAL_TYPE (ConstraintEditorApplication, constraint_editor_application, CONSTRAINT, EDITOR_APPLICATION, GtkApplication)

+ConstraintEditorApplication *constraint_editor_application_new (void);
--- a/demos/constraint-editor/constraint-editor-window.c
+++ b/demos/constraint-editor/constraint-editor-window.c
@@ -0,0 +1,652 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * 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: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "constraint-editor-window.h"
+#include "constraint-view.h"
+#include "constraint-editor.h"
+#include "guide-editor.h"
+
+struct _ConstraintEditorWindow
+{
+  GtkApplicationWindow parent_instance;
+
+  GtkWidget *paned;
+  GtkWidget *view;
+  GtkWidget *list;
+};
+
+G_DEFINE_TYPE(ConstraintEditorWindow, constraint_editor_window, GTK_TYPE_APPLICATION_WINDOW);
+
+static GtkConstraintTarget *
+find_target (GListModel          *model,
+             GtkConstraintTarget *orig)
+{
+  const char *name;
+  const char *model_name;
+  gpointer item;
+  int i;
+
+  if (orig == NULL)
+    return NULL;
+
+  if (GTK_IS_LABEL (orig))
+    name = gtk_label_get_label (GTK_LABEL (orig));
+  else if (GTK_IS_CONSTRAINT_GUIDE (orig))
+    name = gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (orig));
+  else
+    {
+      g_warning ("Don't know how to handle %s targets", G_OBJECT_TYPE_NAME (orig));
+      return NULL;
+    }
+  for (i = 0; i < g_list_model_get_n_items (model); i++)
+    {
+      item = g_list_model_get_item (model, i);
+      g_object_unref (item);
+      if (GTK_IS_WIDGET (item))
+        model_name = gtk_widget_get_name (GTK_WIDGET (item));
+      else
+        model_name = gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (item));
+
+      if (strcmp (name, model_name) == 0)
+        return GTK_CONSTRAINT_TARGET (item);
+    }
+  g_warning ("Failed to find target '%s'", name);
+
+  return NULL;
+}
+
+gboolean
+constraint_editor_window_load (ConstraintEditorWindow *self,
+                               GFile            *file)
+{
+  char *path;
+  GtkBuilder *builder;
+  GError *error = NULL;
+  GtkWidget *view;
+  GtkLayoutManager *layout;
+  GtkWidget *child;
+  const char *name;
+  gpointer item;
+  int i;
+  GListModel *list;
+
+  path = g_file_get_path (file);
+
+  builder = gtk_builder_new ();
+  if (!gtk_builder_add_from_file (builder, path, &error))
+    {
+      g_print ("Could not load %s: %s", path, error->message);
+      g_error_free (error);
+      g_free (path);
+      g_object_unref (builder);
+      return FALSE;
+    }
+
+  view = GTK_WIDGET (gtk_builder_get_object (builder, "view"));
+  if (!GTK_IS_BOX (view))
+    {
+      g_print ("Could not load %s: No GtkBox named 'view'", path);
+      g_free (path);
+      g_object_unref (builder);
+      return FALSE;
+    }
+  layout = gtk_widget_get_layout_manager (view);
+  if (!GTK_IS_CONSTRAINT_LAYOUT (layout))
+    {
+      g_print ("Could not load %s: Widget 'view' does not use GtkConstraintLayout", path);
+      g_free (path);
+      g_object_unref (builder);
+      return FALSE;
+    }
+
+  for (child = gtk_widget_get_first_child (view);
+       child;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      if (!GTK_IS_LABEL (child))
+        {
+          g_print ("Skipping non-GtkLabel child\n");
+          continue;
+        }
+
+      name = gtk_label_get_label (GTK_LABEL (child));
+      constraint_view_add_child (CONSTRAINT_VIEW (self->view), name);
+    }
+
+  list = gtk_constraint_layout_observe_guides (GTK_CONSTRAINT_LAYOUT (layout));
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      GtkConstraintGuide *guide, *clone;
+      int w, h;
+
+      item = g_list_model_get_item (list, i);
+      guide = GTK_CONSTRAINT_GUIDE (item);
+
+      /* need to clone here, to attach to the right targets */
+      clone = gtk_constraint_guide_new ();
+      gtk_constraint_guide_set_name (clone, gtk_constraint_guide_get_name (guide));
+      gtk_constraint_guide_set_strength (clone, gtk_constraint_guide_get_strength (guide));
+      gtk_constraint_guide_get_min_size (guide, &w, &h);
+      gtk_constraint_guide_set_min_size (clone, w, h);
+      gtk_constraint_guide_get_nat_size (guide, &w, &h);
+      gtk_constraint_guide_set_nat_size (clone, w, h);
+      gtk_constraint_guide_get_max_size (guide, &w, &h);
+      gtk_constraint_guide_set_max_size (clone, w, h);
+      constraint_view_add_guide (CONSTRAINT_VIEW (self->view), clone);
+      g_object_unref (guide);
+      g_object_unref (clone);
+    }
+  g_object_unref (list);
+
+  list = gtk_constraint_layout_observe_constraints (GTK_CONSTRAINT_LAYOUT (layout));
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      GtkConstraint *constraint;
+      GtkConstraint *clone;
+      GtkConstraintTarget *target;
+      GtkConstraintTarget *source;
+      GtkConstraintAttribute source_attr;
+
+      item = g_list_model_get_item (list, i);
+      constraint = GTK_CONSTRAINT (item);
+
+      target = gtk_constraint_get_target (constraint);
+      source = gtk_constraint_get_source (constraint);
+      source_attr = gtk_constraint_get_source_attribute (constraint);
+
+      if (source == NULL && source_attr == GTK_CONSTRAINT_ATTRIBUTE_NONE)
+        clone = gtk_constraint_new_constant (find_target (constraint_view_get_model (CONSTRAINT_VIEW (self->view)), target),
+                                  gtk_constraint_get_target_attribute (constraint),
+                                  gtk_constraint_get_relation (constraint),
+                                  gtk_constraint_get_constant (constraint),
+                                  gtk_constraint_get_strength (constraint));
+      else
+        clone = gtk_constraint_new (find_target (constraint_view_get_model (CONSTRAINT_VIEW (self->view)), target),
+                                    gtk_constraint_get_target_attribute (constraint),
+                                    gtk_constraint_get_relation (constraint),
+                                    find_target (constraint_view_get_model (CONSTRAINT_VIEW (self->view)), source),
+                                    source_attr,
+                                    gtk_constraint_get_multiplier (constraint),
+                                    gtk_constraint_get_constant (constraint),
+                                    gtk_constraint_get_strength (constraint));
+
+      constraint_view_add_constraint (CONSTRAINT_VIEW (self->view), clone);
+
+      g_object_unref (constraint);
+      g_object_unref (clone);
+    }
+  g_object_unref (list);
+
+  g_free (path);
+  g_object_unref (builder);
+
+  return TRUE;
+}
+
+static void
+open_response_cb (GObject *source,
+                  GAsyncResult *result,
+                  void *user_data)
+{
+  GtkFileDialog *dialog = GTK_FILE_DIALOG (source);
+  ConstraintEditorWindow *self = user_data;
+  GFile *file;
+
+  file = gtk_file_dialog_open_finish (dialog, result, NULL);
+  if (file)
+    {
+      constraint_editor_window_load (self, file);
+      g_object_unref (file);
+    }
+}
+
+static void
+open_cb (GtkWidget              *button,
+         ConstraintEditorWindow *self)
+{
+  GtkFileDialog *dialog;
+  GFile *cwd;
+
+  dialog = gtk_file_dialog_new ();
+  gtk_file_dialog_set_title (dialog, "Open file");
+  cwd = g_file_new_for_path (".");
+  gtk_file_dialog_set_initial_folder (dialog, cwd);
+  g_object_unref (cwd);
+  gtk_file_dialog_open (dialog, GTK_WINDOW (self), NULL, open_response_cb, self);
+  g_object_unref (dialog);
+}
+
+static void
+serialize_child (GString   *str,
+                 int        indent,
+                 GtkWidget *child)
+{
+  const char *name;
+
+  name = gtk_widget_get_name (child);
+  g_string_append_printf (str, "%*s<child>\n", indent, "");
+  g_string_append_printf (str, "%*s  <object class=\"GtkLabel\" id=\"%s\">\n", indent, "", name);
+  g_string_append_printf (str, "%*s    <property name=\"label\">%s</property>\n", indent, "", name);
+  g_string_append_printf (str, "%*s  </object>\n", indent, "");
+  g_string_append_printf (str, "%*s</child>\n", indent, "");
+}
+
+static char *
+serialize_model (GListModel *list)
+{
+  GString *str = g_string_new ("");
+  int i;
+
+  g_string_append (str, "<interface>\n");
+  g_string_append (str, "  <object class=\"GtkBox\" id=\"view\">\n");
+  g_string_append (str, "    <property name=\"layout-manager\">\n");
+  g_string_append (str, "      <object class=\"GtkConstraintLayout\">\n");
+  g_string_append (str, "        <constraints>\n");
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      gpointer item = g_list_model_get_item (list, i);
+      g_object_unref (item);
+      if (GTK_IS_CONSTRAINT (item))
+        constraint_editor_serialize_constraint (str, 10, GTK_CONSTRAINT (item));
+      else if (GTK_IS_CONSTRAINT_GUIDE (item))
+        guide_editor_serialize_guide (str, 10, GTK_CONSTRAINT_GUIDE (item));
+    }
+  g_string_append (str, "        </constraints>\n");
+  g_string_append (str, "      </object>\n");
+  g_string_append (str, "    </property>\n");
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      gpointer item = g_list_model_get_item (list, i);
+      g_object_unref (item);
+      if (GTK_IS_WIDGET (item))
+        serialize_child (str, 4, GTK_WIDGET (item));
+    }
+  g_string_append (str, "  </object>\n");
+  g_string_append (str, "</interface>\n");
+
+  return g_string_free (str, FALSE);
+}
+
+
+static void
+save_response_cb (GObject *source,
+                  GAsyncResult *result,
+                  void *user_data)
+{
+  GtkFileDialog *dialog = GTK_FILE_DIALOG (source);
+  ConstraintEditorWindow *self = user_data;
+  GFile *file;
+
+  file = gtk_file_dialog_save_finish (dialog, result, NULL);
+  if (file)
+    {
+      GListModel *model;
+      char *text;
+      GError *error = NULL;
+
+      model = constraint_view_get_model (CONSTRAINT_VIEW (self->view));
+      text = serialize_model (model);
+      g_file_replace_contents (file, text, strlen (text),
+                               NULL, FALSE,
+                               G_FILE_CREATE_NONE,
+                               NULL,
+                               NULL,
+                               &error);
+      if (error != NULL)
+        {
+          GtkAlertDialog *alert;
+
+          alert = gtk_alert_dialog_new ("Saving failed");
+          gtk_alert_dialog_set_detail (alert, error->message);
+          gtk_alert_dialog_show (alert,
+                                 GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (self))));
+          g_object_unref (alert);
+          g_error_free (error);
+        }
+
+      g_free (text);
+      g_object_unref (file);
+    }
+}
+
+static void
+save_cb (GtkWidget              *button,
+         ConstraintEditorWindow *self)
+{
+  GtkFileDialog *dialog;
+  GFile *cwd;
+
+  dialog = gtk_file_dialog_new ();
+  gtk_file_dialog_set_title (dialog, "Save constraints");
+  cwd = g_file_new_for_path (".");
+  gtk_file_dialog_set_initial_folder (dialog, cwd);
+  g_object_unref (cwd);
+  gtk_file_dialog_save (dialog,
+                        GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (button))),
+                        NULL,
+                        save_response_cb, self);
+  g_object_unref (dialog);
+}
+
+static void
+constraint_editor_window_dispose (GObject *object)
+{
+  gtk_widget_dispose_template (GTK_WIDGET (object), CONSTRAINT_EDITOR_WINDOW_TYPE);
+
+  G_OBJECT_CLASS (constraint_editor_window_parent_class)->dispose (object);
+}
+
+static int child_counter;
+static int guide_counter;
+
+static void
+add_child (ConstraintEditorWindow *win)
+{
+  char *name;
+
+  child_counter++;
+  name = g_strdup_printf ("Child %d", child_counter);
+  constraint_view_add_child (CONSTRAINT_VIEW (win->view), name);
+  g_free (name);
+}
+
+static void
+add_guide (ConstraintEditorWindow *win)
+{
+  char *name;
+  GtkConstraintGuide *guide;
+
+  guide_counter++;
+  name = g_strdup_printf ("Guide %d", guide_counter);
+  guide = gtk_constraint_guide_new ();
+  gtk_constraint_guide_set_name (guide, name);
+  g_free (name);
+
+  constraint_view_add_guide (CONSTRAINT_VIEW (win->view), guide);
+}
+
+static void
+constraint_editor_done (ConstraintEditor *editor,
+                        GtkConstraint    *constraint,
+                        ConstraintEditorWindow *win)
+{
+  GtkConstraint *old_constraint;
+
+  g_object_get (editor, "constraint", &old_constraint, NULL);
+
+  if (old_constraint)
+    constraint_view_remove_constraint (CONSTRAINT_VIEW (win->view), old_constraint);
+
+  constraint_view_add_constraint (CONSTRAINT_VIEW (win->view), constraint);
+
+  g_clear_object (&old_constraint);
+
+  gtk_window_destroy (GTK_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW)));
+}
+
+static void
+edit_constraint (ConstraintEditorWindow *win,
+                 GtkConstraint          *constraint)
+{
+  GtkWidget *window;
+  ConstraintEditor *editor;
+  GListModel *model;
+
+  window = gtk_window_new ();
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (win));
+  gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+  if (constraint)
+    gtk_window_set_title (GTK_WINDOW (window), "Edit Constraint");
+  else
+    gtk_window_set_title (GTK_WINDOW (window), "Create Constraint");
+
+  model = constraint_view_get_model (CONSTRAINT_VIEW (win->view));
+
+  editor = constraint_editor_new (model, constraint);
+
+  gtk_window_set_child (GTK_WINDOW (window), GTK_WIDGET (editor));
+
+  g_signal_connect (editor, "done", G_CALLBACK (constraint_editor_done), win);
+
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+static void
+add_constraint (ConstraintEditorWindow *win)
+{
+  edit_constraint (win, NULL);
+}
+
+static void
+guide_editor_done (GuideEditor            *editor,
+                   GtkConstraintGuide     *guide,
+                   ConstraintEditorWindow *win)
+{
+  gtk_window_destroy (GTK_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW)));
+}
+
+static void
+edit_guide (ConstraintEditorWindow *win,
+            GtkConstraintGuide     *guide)
+{
+  GtkWidget *window;
+  GuideEditor *editor;
+
+  window = gtk_window_new ();
+  gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (win));
+  gtk_window_set_title (GTK_WINDOW (window), "Edit Guide");
+
+  editor = guide_editor_new (guide);
+  gtk_window_set_child (GTK_WINDOW (window), GTK_WIDGET (editor));
+
+  g_signal_connect (editor, "done", G_CALLBACK (guide_editor_done), win);
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+static void
+row_activated (GtkListBox *list,
+               GtkListBoxRow *row,
+               ConstraintEditorWindow *win)
+{
+  GObject *item;
+
+  item = G_OBJECT (g_object_get_data (G_OBJECT (row), "item"));
+
+  if (GTK_IS_CONSTRAINT (item))
+    edit_constraint (win, GTK_CONSTRAINT (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    edit_guide (win, GTK_CONSTRAINT_GUIDE (item));
+}
+
+static void
+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->dispose = constraint_editor_window_dispose;
+
+  gtk_widget_class_set_template_from_resource (widget_class,
+                                               "/org/gtk/gtk4/constraint-editor/constraint-editor-window.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditorWindow, paned);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditorWindow, view);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditorWindow, list);
+
+  gtk_widget_class_bind_template_callback (widget_class, open_cb);
+  gtk_widget_class_bind_template_callback (widget_class, save_cb);
+  gtk_widget_class_bind_template_callback (widget_class, add_child);
+  gtk_widget_class_bind_template_callback (widget_class, add_guide);
+  gtk_widget_class_bind_template_callback (widget_class, add_constraint);
+  gtk_widget_class_bind_template_callback (widget_class, row_activated);
+}
+
+static void
+row_edit (GtkButton *button,
+          ConstraintEditorWindow *win)
+{
+  GtkWidget *row;
+  GObject *item;
+
+  row = gtk_widget_get_ancestor (GTK_WIDGET (button), GTK_TYPE_LIST_BOX_ROW);
+  item = (GObject *)g_object_get_data (G_OBJECT (row), "item");
+  if (GTK_IS_CONSTRAINT (item))
+    edit_constraint (win, GTK_CONSTRAINT (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    edit_guide (win, GTK_CONSTRAINT_GUIDE (item));
+}
+
+static void
+mark_constraints_invalid (ConstraintEditorWindow *win,
+                          gpointer                removed)
+{
+  GtkWidget *child;
+  GObject *item;
+
+  for (child = gtk_widget_get_first_child (win->list);
+       child;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      item = (GObject *)g_object_get_data (G_OBJECT (child), "item");
+      if (GTK_IS_CONSTRAINT (item))
+        {
+          GtkConstraint *constraint = GTK_CONSTRAINT (item);
+
+          if (gtk_constraint_get_target (constraint) == (GtkConstraintTarget *)removed ||
+              gtk_constraint_get_source (constraint) == (GtkConstraintTarget *)removed)
+            {
+              GtkWidget *button;
+              button = (GtkWidget *)g_object_get_data (G_OBJECT (child), "edit");
+              gtk_button_set_icon_name (GTK_BUTTON (button), "dialog-warning-symbolic");
+              gtk_widget_set_tooltip_text (button, "Constraint is invalid");
+            }
+        }
+    }
+}
+
+static void
+row_delete (GtkButton *button,
+            ConstraintEditorWindow *win)
+{
+  GtkWidget *row;
+  GObject *item;
+
+  row = gtk_widget_get_ancestor (GTK_WIDGET (button), GTK_TYPE_LIST_BOX_ROW);
+  item = (GObject *)g_object_get_data (G_OBJECT (row), "item");
+  if (GTK_IS_CONSTRAINT (item))
+    constraint_view_remove_constraint (CONSTRAINT_VIEW (win->view),
+                                       GTK_CONSTRAINT (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    {
+      mark_constraints_invalid (win, item);
+      constraint_view_remove_guide (CONSTRAINT_VIEW (win->view),
+                                    GTK_CONSTRAINT_GUIDE (item));
+    }
+  else if (GTK_IS_WIDGET (item))
+    {
+      mark_constraints_invalid (win, item);
+      constraint_view_remove_child (CONSTRAINT_VIEW (win->view),
+                                    GTK_WIDGET (item));
+    }
+}
+
+static GtkWidget *
+create_widget_func (gpointer item,
+                    gpointer user_data)
+{
+  ConstraintEditorWindow *win = user_data;
+  const char *name;
+  char *freeme = NULL;
+  GtkWidget *row, *box, *label, *button;
+
+  if (GTK_IS_WIDGET (item))
+    name = gtk_widget_get_name (GTK_WIDGET (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    name = gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (item));
+  else if (GTK_IS_CONSTRAINT (item))
+    name = freeme = constraint_editor_constraint_to_string (GTK_CONSTRAINT (item));
+  else
+    name = "";
+
+  row = gtk_list_box_row_new ();
+  g_object_set_data_full (G_OBJECT (row), "item", g_object_ref (item), g_object_unref);
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  label = gtk_label_new (name);
+  if (GTK_IS_WIDGET (item) || GTK_IS_CONSTRAINT_GUIDE (item))
+    g_object_bind_property (item, "name",
+                            label, "label",
+                            G_BINDING_DEFAULT);
+  gtk_widget_set_margin_start (label, 10);
+  gtk_widget_set_margin_end (label, 10);
+  gtk_widget_set_margin_top (label, 10);
+  gtk_widget_set_margin_bottom (label, 10);
+  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+  gtk_widget_set_hexpand (label, TRUE);
+  gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
+  gtk_box_append (GTK_BOX (box), label);
+
+  if (GTK_IS_CONSTRAINT (item) || GTK_IS_CONSTRAINT_GUIDE (item))
+    {
+      button = gtk_button_new_from_icon_name ("document-edit-symbolic");
+      gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
+      g_signal_connect (button, "clicked", G_CALLBACK (row_edit), win);
+      g_object_set_data (G_OBJECT (row), "edit", button);
+      gtk_box_append (GTK_BOX (box), button);
+      button = gtk_button_new_from_icon_name ("edit-delete-symbolic");
+      gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
+      g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
+      gtk_box_append (GTK_BOX (box), button);
+    }
+  else if (GTK_IS_WIDGET (item))
+    {
+      button = gtk_button_new_from_icon_name ("edit-delete-symbolic");
+      gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
+      g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
+      gtk_box_append (GTK_BOX (box), button);
+    }
+
+  g_free (freeme);
+
+  return row;
+}
+
+static void
+constraint_editor_window_init (ConstraintEditorWindow *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+
+  gtk_list_box_bind_model (GTK_LIST_BOX (self->list),
+                           constraint_view_get_model (CONSTRAINT_VIEW (self->view)),
+                           create_widget_func,
+                           self,
+                           NULL);
+}
+
+ConstraintEditorWindow *
+constraint_editor_window_new (ConstraintEditorApplication *application)
+{
+  return g_object_new (CONSTRAINT_EDITOR_WINDOW_TYPE,
+                       "application", application,
+                       NULL);
+}
--- a/demos/constraint-editor/constraint-editor-window.h
+++ b/demos/constraint-editor/constraint-editor-window.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * 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: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#include "constraint-editor-application.h"
+
+
+#define CONSTRAINT_EDITOR_WINDOW_TYPE (constraint_editor_window_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintEditorWindow, constraint_editor_window, CONSTRAINT, EDITOR_WINDOW, GtkApplicationWindow)
+
+ConstraintEditorWindow * constraint_editor_window_new  (ConstraintEditorApplication  *application);
+
+gboolean                 constraint_editor_window_load (ConstraintEditorWindow       *self,
+                                                        GFile                        *file);
--- a/demos/constraint-editor/constraint-editor-window.ui
+++ b/demos/constraint-editor/constraint-editor-window.ui
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="ConstraintEditorWindow" parent="GtkApplicationWindow">
+    <property name="title" translatable="yes">GTK Constraint Editor</property>
+    <property name="default-width">1024</property>
+    <property name="default-height">768</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar" id="header">
+        <child type="start">
+          <object class="GtkButton">
+            <property name="icon-name">document-open-symbolic</property>
+            <property name="tooltip-text">Open ui file</property>
+            <signal name="clicked" handler="open_cb"/>
+          </object>
+        </child>
+        <child type="start">
+          <object class="GtkButton">
+            <property name="icon-name">document-save-symbolic</property>
+            <property name="tooltip-text">Save to ui file</property>
+            <signal name="clicked" handler="save_cb"/>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkPaned" id="paned">
+        <property name="orientation">horizontal</property>
+        <child>
+          <object class="GtkBox">
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkBox">
+                <property name="orientation">horizontal</property>
+                <child>
+                  <object class="GtkButton">
+                    <property name="label">Add Child</property>
+                    <signal name="clicked" handler="add_child" swapped="yes"/>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkButton">
+                    <property name="label">Add Guide</property>
+                    <signal name="clicked" handler="add_guide" swapped="yes"/>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkButton">
+                    <property name="label">Add Constraint</property>
+                    <signal name="clicked" handler="add_constraint" swapped="yes"/>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow">
+                <property name="hscrollbar-policy">never</property>
+                <property name="vscrollbar-policy">automatic</property>
+                <property name="vexpand">1</property>
+                <child>
+                  <object class="GtkListBox" id="list">
+                    <property name="show-separators">1</property>
+                    <property name="selection-mode">none</property>
+                    <signal name="row-activated" handler="row_activated"/>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="ConstraintView" id="view">
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
--- a/demos/constraint-editor/constraint-editor.c
+++ b/demos/constraint-editor/constraint-editor.c
@@ -0,0 +1,716 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * 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: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "constraint-editor.h"
+#include "constraint-view.h"
+
+struct _ConstraintEditor
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *grid;
+  GtkWidget *target;
+  GtkWidget *target_attr;
+  GtkWidget *relation;
+  GtkWidget *source;
+  GtkWidget *source_attr;
+  GtkWidget *multiplier;
+  GtkWidget *constant;
+  GtkWidget *strength;
+  GtkWidget *preview;
+  GtkWidget *button;
+
+  GtkConstraint *constraint;
+  GListModel *model;
+
+  gboolean constructed;
+};
+
+enum {
+  PROP_MODEL = 1,
+  PROP_CONSTRAINT,
+  LAST_PROP
+};
+
+static GParamSpec *pspecs[LAST_PROP];
+
+enum {
+  DONE,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+G_DEFINE_TYPE(ConstraintEditor, constraint_editor, GTK_TYPE_WIDGET);
+
+static const char *
+get_target_name (GtkConstraintTarget *target)
+{
+  if (target == NULL)
+    return "Super";
+  else if (GTK_IS_WIDGET (target))
+    return gtk_widget_get_name (GTK_WIDGET (target));
+  else if (GTK_IS_CONSTRAINT_GUIDE (target))
+    return gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (target));
+  else
+    return "";
+}
+
+static void
+constraint_target_combo (GListModel *model,
+                         GtkWidget  *combo,
+                         gboolean    is_source)
+{
+  GtkStringList *targets;
+  int i;
+
+  targets = gtk_string_list_new (NULL);
+
+  gtk_string_list_append (targets, "Super");
+
+  if (model)
+    {
+      for (i = 0; i < g_list_model_get_n_items (model); i++)
+        {
+          GObject *item = g_list_model_get_object (model, i);
+
+          if (GTK_IS_CONSTRAINT (item))
+            continue;
+
+          gtk_string_list_append (targets, get_target_name (GTK_CONSTRAINT_TARGET (item)));
+          g_object_unref (item);
+        }
+    }
+
+  gtk_drop_down_set_model (GTK_DROP_DOWN (combo), G_LIST_MODEL (targets));
+  g_object_unref (targets);
+}
+
+static gpointer
+get_target (GListModel *model,
+            const char *id)
+{
+  int i;
+
+  if (id == NULL)
+    return NULL;
+
+  if (strcmp ("Super", id) == 0)
+    return NULL;
+
+  for (i = 0; i < g_list_model_get_n_items (model); i++)
+    {
+      GObject *item = g_list_model_get_object (model, i);
+      g_object_unref (item);
+      if (GTK_IS_CONSTRAINT (item))
+        continue;
+      else if (GTK_IS_WIDGET (item))
+        {
+          if (strcmp (id, gtk_widget_get_name (GTK_WIDGET (item))) == 0)
+            return item;
+        }
+      else if (GTK_IS_CONSTRAINT_GUIDE (item))
+        {
+          if (strcmp (id, gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (item))) == 0)
+            return item;
+        }
+    }
+
+  return NULL;
+}
+
+static void
+select_target (GtkDropDown *combo,
+               const char  *target_name)
+{
+  GListModel *model = gtk_drop_down_get_model (combo);
+
+  for (unsigned int i = 0; i < g_list_model_get_n_items (model); i++)
+    {
+      GtkStringObject *s = g_list_model_get_item (model, i);
+
+      g_object_unref (s);
+      if (strcmp (target_name, gtk_string_object_get_string (s)) == 0)
+        {
+          gtk_drop_down_set_selected (GTK_DROP_DOWN (combo), i);
+          return;
+        }
+    }
+}
+
+static GtkConstraintAttribute
+get_attr (unsigned int id)
+{
+  switch (id)
+    {
+    case 0: return GTK_CONSTRAINT_ATTRIBUTE_NONE;
+    case 1: return GTK_CONSTRAINT_ATTRIBUTE_LEFT;
+    case 2: return GTK_CONSTRAINT_ATTRIBUTE_RIGHT;
+    case 3: return GTK_CONSTRAINT_ATTRIBUTE_TOP;
+    case 4: return GTK_CONSTRAINT_ATTRIBUTE_BOTTOM;
+    case 5: return GTK_CONSTRAINT_ATTRIBUTE_START;
+    case 6: return GTK_CONSTRAINT_ATTRIBUTE_END;
+    case 7: return GTK_CONSTRAINT_ATTRIBUTE_WIDTH;
+    case 8: return GTK_CONSTRAINT_ATTRIBUTE_HEIGHT;
+    case 9: return GTK_CONSTRAINT_ATTRIBUTE_CENTER_X;
+    case 10: return GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y;
+    case 11: return GTK_CONSTRAINT_ATTRIBUTE_BASELINE;
+    default: g_assert_not_reached ();
+    }
+}
+
+static unsigned int
+get_attr_id (GtkConstraintAttribute attr)
+{
+  switch (attr)
+    {
+    case GTK_CONSTRAINT_ATTRIBUTE_NONE: return 0;
+    case GTK_CONSTRAINT_ATTRIBUTE_LEFT: return 1;
+    case GTK_CONSTRAINT_ATTRIBUTE_RIGHT: return 2;
+    case GTK_CONSTRAINT_ATTRIBUTE_TOP: return 3;
+    case GTK_CONSTRAINT_ATTRIBUTE_BOTTOM: return 4;
+    case GTK_CONSTRAINT_ATTRIBUTE_START: return 5;
+    case GTK_CONSTRAINT_ATTRIBUTE_END: return 6;
+    case GTK_CONSTRAINT_ATTRIBUTE_WIDTH: return 7;
+    case GTK_CONSTRAINT_ATTRIBUTE_HEIGHT: return 8;
+    case GTK_CONSTRAINT_ATTRIBUTE_CENTER_X: return 9;
+    case GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y: return 10;
+    case GTK_CONSTRAINT_ATTRIBUTE_BASELINE: return 11;
+    default: g_assert_not_reached ();
+    }
+}
+
+static const char *
+get_attr_nick (GtkConstraintAttribute attr)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_ATTRIBUTE);
+  GEnumValue *value = g_enum_get_value (class, attr);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+static GtkConstraintRelation
+get_relation (unsigned int id)
+{
+  switch (id)
+    {
+    case 0: return GTK_CONSTRAINT_RELATION_LE;
+    case 1: return GTK_CONSTRAINT_RELATION_EQ;
+    case 2: return GTK_CONSTRAINT_RELATION_GE;
+    default: g_assert_not_reached ();
+    }
+}
+
+static unsigned int
+get_relation_id (GtkConstraintRelation relation)
+{
+  switch (relation)
+    {
+    case GTK_CONSTRAINT_RELATION_LE: return 0;
+    case GTK_CONSTRAINT_RELATION_EQ: return 1;
+    case GTK_CONSTRAINT_RELATION_GE: return 2;
+    default: g_assert_not_reached ();
+    }
+}
+
+static const char *
+get_relation_nick (GtkConstraintRelation relation)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_RELATION);
+  GEnumValue *value = g_enum_get_value (class, relation);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+static const char *
+get_relation_display_name (GtkConstraintRelation relation)
+{
+  switch (relation)
+    {
+    case GTK_CONSTRAINT_RELATION_LE:
+      return "≤";
+    case GTK_CONSTRAINT_RELATION_EQ:
+      return "=";
+    case GTK_CONSTRAINT_RELATION_GE:
+      return "≥";
+    default:
+      return "?";
+    }
+}
+
+static GtkConstraintStrength
+get_strength (unsigned int id)
+{ 
+  switch (id)
+    {
+    case 0: return GTK_CONSTRAINT_STRENGTH_WEAK;
+    case 1: return GTK_CONSTRAINT_STRENGTH_MEDIUM;
+    case 2: return GTK_CONSTRAINT_STRENGTH_STRONG;
+    case 3: return GTK_CONSTRAINT_STRENGTH_REQUIRED;
+    default: g_assert_not_reached ();
+    }
+}
+
+static unsigned int
+get_strength_id (GtkConstraintStrength strength)
+{
+  switch (strength)
+    {
+    case GTK_CONSTRAINT_STRENGTH_WEAK: return 0;
+    case GTK_CONSTRAINT_STRENGTH_MEDIUM: return 1;
+    case GTK_CONSTRAINT_STRENGTH_STRONG: return 2;
+    case GTK_CONSTRAINT_STRENGTH_REQUIRED: return 3;
+    default: g_assert_not_reached ();
+    }
+}
+
+static const char *
+get_strength_nick (GtkConstraintStrength strength)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_STRENGTH);
+  GEnumValue *value = g_enum_get_value (class, strength);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+void
+constraint_editor_serialize_constraint (GString       *str,
+                                        int            indent,
+                                        GtkConstraint *constraint)
+{
+  const char *target;
+  const char *target_attr;
+  const char *relation;
+  const char *source;
+  const char *source_attr;
+  double multiplier;
+  double constant;
+  const char *strength;
+
+  target = get_target_name (gtk_constraint_get_target (constraint));
+  target_attr = get_attr_nick (gtk_constraint_get_target_attribute (constraint));
+  relation = get_relation_nick (gtk_constraint_get_relation (constraint));
+  source = get_target_name (gtk_constraint_get_source (constraint));
+  source_attr = get_attr_nick (gtk_constraint_get_source_attribute (constraint));
+  multiplier = gtk_constraint_get_multiplier (constraint);
+  constant = gtk_constraint_get_constant (constraint);
+  strength = get_strength_nick (gtk_constraint_get_strength (constraint));
+
+  g_string_append_printf (str, "%*s<constraint target=\"%s\" target-attribute=\"%s\"\n", indent, "", target, target_attr);
+  g_string_append_printf (str, "%*s            relation=\"%s\"\n", indent, "", relation);
+  if (strcmp (source_attr, "none") != 0)
+    {
+      g_string_append_printf (str, "%*s            source=\"%s\" source-attribute=\"%s\"\n", indent, "", source, source_attr);
+      g_string_append_printf (str, "%*s            multiplier=\"%g\"\n", indent, "", multiplier);
+    }
+  g_string_append_printf (str, "%*s            constant=\"%g\"\n", indent, "", constant);
+  g_string_append_printf (str, "%*s            strength=\"%s\" />\n", indent, "", strength);
+}
+
+static void
+create_constraint (GtkButton        *button,
+                   ConstraintEditor *editor)
+{
+  gpointer obj;
+  gpointer target;
+  GtkConstraintAttribute target_attr;
+  gpointer source;
+  GtkConstraintAttribute source_attr;
+  GtkConstraintRelation relation;
+  double multiplier;
+  double constant;
+  int strength;
+  GtkConstraint *constraint;
+
+  obj = gtk_drop_down_get_selected_item (GTK_DROP_DOWN (editor->target));
+  if (obj)
+    target = get_target (editor->model, gtk_string_object_get_string (GTK_STRING_OBJECT (obj)));
+  else
+    target = NULL;
+  target_attr = get_attr (gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->target_attr)));
+
+  obj = gtk_drop_down_get_selected_item (GTK_DROP_DOWN (editor->source));
+  if (obj)
+    source = get_target (editor->model, gtk_string_object_get_string (GTK_STRING_OBJECT (obj)));
+  else
+    source = NULL;
+  source_attr = get_attr (gtk_drop_down_get_selected (GTK_DROP_DOWN(editor->source_attr)));
+
+  relation = get_relation (gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->relation)));
+
+  multiplier = g_ascii_strtod (gtk_editable_get_text (GTK_EDITABLE (editor->multiplier)), NULL);
+
+  constant = g_ascii_strtod (gtk_editable_get_text (GTK_EDITABLE (editor->constant)), NULL);
+
+  strength = get_strength (gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->strength)));
+
+  constraint = gtk_constraint_new (target, target_attr,
+                                   relation,
+                                   source, source_attr,
+                                   multiplier,
+                                   constant,
+                                   strength);
+  g_signal_emit (editor, signals[DONE], 0, constraint);
+  g_object_unref (constraint);
+}
+
+static void
+source_attr_changed (ConstraintEditor *editor)
+{
+  if (get_attr (gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->source_attr))) == GTK_CONSTRAINT_ATTRIBUTE_NONE)
+    {
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->source), GTK_INVALID_LIST_POSITION);
+      gtk_editable_set_text (GTK_EDITABLE (editor->multiplier), "");
+      gtk_widget_set_sensitive (editor->source, FALSE);
+      gtk_widget_set_sensitive (editor->multiplier, FALSE);
+    }
+  else
+    {
+      gtk_widget_set_sensitive (editor->source, TRUE);
+      gtk_widget_set_sensitive (editor->multiplier, TRUE);
+      gtk_editable_set_text (GTK_EDITABLE (editor->multiplier), "1");
+    }
+}
+
+char *
+constraint_editor_constraint_to_string (GtkConstraint *constraint)
+{
+  GString *str;
+  const char *name;
+  const char *attr;
+  const char *relation;
+  double c, m;
+
+  str = g_string_new ("");
+
+  name = get_target_name (gtk_constraint_get_target (constraint));
+  attr = get_attr_nick (gtk_constraint_get_target_attribute (constraint));
+  relation = get_relation_display_name (gtk_constraint_get_relation (constraint));
+
+  if (name == NULL)
+    name = "[ ]";
+
+  g_string_append_printf (str, "%s.%s %s ", name, attr, relation);
+
+  c = gtk_constraint_get_constant (constraint);
+
+  attr = get_attr_nick (gtk_constraint_get_source_attribute (constraint));
+  if (strcmp (attr, "none") != 0)
+    {
+      name = get_target_name (gtk_constraint_get_source (constraint));
+      m = gtk_constraint_get_multiplier (constraint);
+
+      if (name == NULL)
+        name = "[ ]";
+
+      g_string_append_printf (str, "%s.%s", name, attr);
+
+      if (m != 1.0)
+        g_string_append_printf (str, " × %g", m);
+
+      if (c > 0.0)
+        g_string_append_printf (str, " + %g", c);
+      else if (c < 0.0)
+        g_string_append_printf (str, " - %g", -c);
+    }
+  else
+    g_string_append_printf (str, "%g", c);
+
+  return g_string_free (str, FALSE);
+}
+
+static void
+update_preview (ConstraintEditor *editor)
+{
+  GString *str;
+  const char *name;
+  const char *attr;
+  const char *relation;
+  const char *multiplier;
+  const char *constant;
+  double c, m;
+
+  if (!editor->constructed)
+    return;
+
+  str = g_string_new ("");
+
+  name = gtk_string_object_get_string (GTK_STRING_OBJECT (gtk_drop_down_get_selected_item (GTK_DROP_DOWN (editor->target))));
+  attr = get_attr_nick (get_attr (gtk_drop_down_get_selected ((GTK_DROP_DOWN (editor->target_attr)))));
+  relation = get_relation_nick (get_relation (gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->relation))));
+
+  if (name == NULL)
+    name = "[ ]";
+
+  g_string_append_printf (str, "%s.%s %s ", name, attr, relation);
+
+  constant = gtk_editable_get_text (GTK_EDITABLE (editor->constant));
+  c = g_ascii_strtod (constant, NULL);
+
+  attr = get_attr_nick (get_attr (gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->source_attr))));
+  if (strcmp (attr, "none") != 0)
+    {
+       name = gtk_string_object_get_string (GTK_STRING_OBJECT (gtk_drop_down_get_selected_item (GTK_DROP_DOWN (editor->source))));
+      multiplier = gtk_editable_get_text (GTK_EDITABLE (editor->multiplier));
+      m = g_ascii_strtod (multiplier, NULL);
+
+      if (name == NULL)
+        name = "[ ]";
+
+      g_string_append_printf (str, "%s.%s", name, attr);
+
+      if (m != 1.0)
+        g_string_append_printf (str, " × %g", m);
+
+      if (c > 0.0)
+        g_string_append_printf (str, " + %g", c);
+      else if (c < 0.0)
+        g_string_append_printf (str, " - %g", -c);
+    }
+  else
+    g_string_append_printf (str, "%g", c);
+
+  gtk_label_set_label (GTK_LABEL (editor->preview), str->str);
+
+  g_string_free (str, TRUE);
+}
+
+static void
+update_button (ConstraintEditor *editor)
+{
+  gpointer obj;
+  const char *target;
+  const char *source;
+  GtkConstraintAttribute source_attr = get_attr (gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->source_attr)));
+
+  obj = gtk_drop_down_get_selected_item (GTK_DROP_DOWN (editor->target));
+  target = obj ? gtk_string_object_get_string (GTK_STRING_OBJECT (obj)) : NULL;
+
+  obj = gtk_drop_down_get_selected_item (GTK_DROP_DOWN (editor->source));
+  source = obj ?  gtk_string_object_get_string (GTK_STRING_OBJECT (obj)) : NULL;
+
+  if (target && (source || (source_attr == GTK_CONSTRAINT_ATTRIBUTE_NONE)))
+    gtk_widget_set_sensitive (editor->button, TRUE);
+  else
+    gtk_widget_set_sensitive (editor->button, FALSE);
+}
+
+static void
+constraint_editor_init (ConstraintEditor *editor)
+{
+  gtk_widget_init_template (GTK_WIDGET (editor));
+}
+
+static void
+constraint_editor_constructed (GObject *object)
+{
+  ConstraintEditor *editor = CONSTRAINT_EDITOR (object);
+
+  constraint_target_combo (editor->model, editor->target, FALSE);
+  constraint_target_combo (editor->model, editor->source, TRUE);
+
+  if (editor->constraint)
+    {
+      GtkConstraintTarget *target;
+      GtkConstraintAttribute attr;
+      GtkConstraintRelation relation;
+      GtkConstraintStrength strength;
+      char *val;
+      double multiplier;
+      double constant;
+
+      target = gtk_constraint_get_target (editor->constraint);
+      select_target (GTK_DROP_DOWN (editor->target), get_target_name (target));
+
+      attr = gtk_constraint_get_target_attribute (editor->constraint);
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->target_attr), get_attr_id (attr));
+
+      target = gtk_constraint_get_source (editor->constraint);
+      select_target (GTK_DROP_DOWN (editor->source), get_target_name (target));
+
+      attr = gtk_constraint_get_source_attribute (editor->constraint);
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->source_attr), get_attr_id (attr));
+
+      relation = gtk_constraint_get_relation (editor->constraint);
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->relation), get_relation_id (relation));
+
+      multiplier = gtk_constraint_get_multiplier (editor->constraint);
+      val = g_strdup_printf ("%g", multiplier);
+      gtk_editable_set_text (GTK_EDITABLE (editor->multiplier), val);
+      g_free (val);
+
+      constant = gtk_constraint_get_constant (editor->constraint);
+      val = g_strdup_printf ("%g", constant);
+      gtk_editable_set_text (GTK_EDITABLE (editor->constant), val);
+      g_free (val);
+
+      strength = gtk_constraint_get_strength (editor->constraint);
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->strength), get_strength_id (strength));
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Apply");
+    }
+  else
+    {
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->target_attr), get_attr_id (GTK_CONSTRAINT_ATTRIBUTE_LEFT));
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->source_attr), get_attr_id (GTK_CONSTRAINT_ATTRIBUTE_LEFT));
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->relation), get_relation_id (GTK_CONSTRAINT_RELATION_EQ));
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->strength), get_strength_id (GTK_CONSTRAINT_STRENGTH_REQUIRED));
+
+      gtk_editable_set_text (GTK_EDITABLE (editor->multiplier), "1.0");
+      gtk_editable_set_text (GTK_EDITABLE (editor->constant), "0.0");
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Create");
+    }
+
+  editor->constructed = TRUE;
+  update_preview (editor);
+  update_button (editor);
+}
+
+static void
+constraint_editor_set_property (GObject      *object,
+                                guint         property_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  ConstraintEditor *self = CONSTRAINT_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_MODEL:
+      self->model = g_value_dup_object (value);
+      break;
+
+    case PROP_CONSTRAINT:
+      self->constraint = g_value_dup_object (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+constraint_editor_get_property (GObject    *object,
+                                guint       property_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  ConstraintEditor *self = CONSTRAINT_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_MODEL:
+      g_value_set_object (value, self->model);
+      break;
+
+    case PROP_CONSTRAINT:
+      g_value_set_object (value, self->constraint);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+constraint_editor_dispose (GObject *object)
+{
+  ConstraintEditor *self = (ConstraintEditor *)object;
+
+  g_clear_object (&self->model);
+  g_clear_object (&self->constraint);
+
+  gtk_widget_dispose_template (GTK_WIDGET (object), CONSTRAINT_EDITOR_TYPE);
+
+  G_OBJECT_CLASS (constraint_editor_parent_class)->dispose (object);
+}
+
+static void
+constraint_editor_class_init (ConstraintEditorClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->constructed = constraint_editor_constructed;
+  object_class->dispose = constraint_editor_dispose;
+  object_class->set_property = constraint_editor_set_property;
+  object_class->get_property = constraint_editor_get_property;
+
+  pspecs[PROP_CONSTRAINT] =
+    g_param_spec_object ("constraint", "constraint", "constraint",
+                         GTK_TYPE_CONSTRAINT,
+                         G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
+
+  pspecs[PROP_MODEL] =
+    g_param_spec_object ("model", "model", "model",
+                         G_TYPE_LIST_MODEL,
+                         G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, LAST_PROP, pspecs);
+
+  signals[DONE] =
+    g_signal_new ("done",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE, 1, GTK_TYPE_CONSTRAINT);
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+
+  gtk_widget_class_set_template_from_resource (widget_class,
+                                               "/org/gtk/gtk4/constraint-editor/constraint-editor.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, grid);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, target);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, target_attr);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, relation);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, source);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, source_attr);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, multiplier);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, constant);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, strength);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, preview);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, button);
+
+  gtk_widget_class_bind_template_callback (widget_class, update_preview);
+  gtk_widget_class_bind_template_callback (widget_class, update_button);
+  gtk_widget_class_bind_template_callback (widget_class, create_constraint);
+  gtk_widget_class_bind_template_callback (widget_class, source_attr_changed);
+}
+
+ConstraintEditor *
+constraint_editor_new (GListModel    *model,
+                       GtkConstraint *constraint)
+{
+  return g_object_new (CONSTRAINT_EDITOR_TYPE,
+                       "model", model,
+                       "constraint", constraint,
+                       NULL);
+}
--- a/demos/constraint-editor/constraint-editor.css
+++ b/demos/constraint-editor/constraint-editor.css
@@ -0,0 +1,12 @@
+constraintview {
+  background: black;
+  color: white;
+}
+
+constraintview .child {
+  background: red;
+}
+
+constraintview .guide {
+  background: blue;
+}
--- a/demos/constraint-editor/constraint-editor.gresource.xml
+++ b/demos/constraint-editor/constraint-editor.gresource.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gtk/gtk4/constraint-editor">
+    <file preprocess="xml-stripblanks">constraint-editor-window.ui</file>
+    <file preprocess="xml-stripblanks">constraint-editor.ui</file>
+    <file preprocess="xml-stripblanks">guide-editor.ui</file>
+    <file>constraint-editor.css</file>
+  </gresource>
+</gresources>
--- a/demos/constraint-editor/constraint-editor.h
+++ b/demos/constraint-editor/constraint-editor.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * 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: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define CONSTRAINT_EDITOR_TYPE (constraint_editor_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintEditor, constraint_editor, CONSTRAINT, EDITOR, GtkWidget)
+
+ConstraintEditor * constraint_editor_new (GListModel    *model,
+                                          GtkConstraint *constraint);
+
+void constraint_editor_serialize_constraint (GString       *str,
+                                             int            indent,
+                                             GtkConstraint *constraint);
+char *constraint_editor_constraint_to_string (GtkConstraint *constraint);
--- a/demos/constraint-editor/constraint-editor.ui
+++ b/demos/constraint-editor/constraint-editor.ui
@@ -0,0 +1,204 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkStringList" id="targets">
+    <items>
+      <item>None</item>
+      <item>Left</item>
+      <item>Right</item>
+      <item>Top</item>
+      <item>Bottom</item>
+      <item>Start</item>
+      <item>End</item>
+      <item>Width</item>
+      <item>Height</item>
+      <item>Center X</item>
+      <item>Center Y</item>
+      <item>Baseline</item>
+    </items>
+  </object>
+  <template class="ConstraintEditor" parent="GtkWidget">
+    <child>
+      <object class="GtkGrid" id="grid">
+        <property name="margin-start">20</property>
+        <property name="margin-end">20</property>
+        <property name="margin-top">20</property>
+        <property name="margin-bottom">20</property>
+        <property name="row-spacing">10</property>
+        <property name="column-spacing">10</property>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Target</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkDropDown" id="target">
+            <signal name="notify::selected" handler="update_preview" swapped="yes"/>
+            <signal name="notify::selected" handler="update_button" swapped="yes"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkDropDown" id="target_attr">
+            <property name="model">targets</property>
+            <signal name="notify::selected" handler="update_preview" swapped="yes"/>
+            <layout>
+              <property name="column">2</property>
+              <property name="row">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Relation</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkDropDown" id="relation">
+            <signal name="notify::selected" handler="update_preview" swapped="yes"/>
+            <property name="model">
+              <object class="GtkStringList">
+                <items>
+                  <item>≤</item>
+                  <item>=</item>
+                  <item>≥</item>
+                </items>
+              </object>
+            </property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Source</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkDropDown" id="source">
+            <signal name="notify::selected" handler="update_preview" swapped="yes"/>
+            <signal name="notify::selected" handler="update_button" swapped="yes"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkDropDown" id="source_attr">
+            <property name="model">targets</property>
+            <signal name="notify::selected" handler="update_preview" swapped="yes"/>
+            <signal name="notify::selected" handler="source_attr_changed" swapped="yes"/>
+            <signal name="notify::selected" handler="update_button" swapped="yes"/>
+            <layout>
+              <property name="column">2</property>
+              <property name="row">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Multiplier</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">4</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkEntry" id="multiplier">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">4</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Constant</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">5</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkEntry" id="constant">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">5</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Strength</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">6</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkDropDown" id="strength">
+            <property name="model">
+              <object class="GtkStringList">
+                <items>
+                  <item>Weak</item>
+                  <item>Medium</item>
+                  <item>Strong</item>
+                  <item>Required</item>
+                </items>
+              </object>
+            </property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">6</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel" id="preview">
+            <property name="xalign">0</property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">7</property>
+              <property name="column-span">2</property>
+            </layout>
+            <attributes>
+              <attribute name="scale" value="1.44"/>
+            </attributes>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="button">
+            <property name="label">Create</property>
+            <signal name="clicked" handler="create_constraint"/>
+            <layout>
+              <property name="column">2</property>
+              <property name="row">8</property>
+            </layout>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
--- a/demos/constraint-editor/constraint-view-child.c
+++ b/demos/constraint-editor/constraint-view-child.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * 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: Matthias Clasen
+ */
+
+#include "constraint-view-child.h"
+
+struct _ConstraintViewChild
+{
+  GObject parent_instance;
+
+  char *name;
+};
+
+enum {
+  PROP_NAME = 1,
+  LAST_PROP
+};
+
+static GParamSpec props[LAST_PROP];
+
+G_DEFINE_TYPE (ConstraintViewChild, constraint_view_child, G_TYPE_OBJECT)
+
+static void
+constraint_view_child_init (ConstraintViewChild *child)
+{
+}
+
+static void
+constraint_view_child_finalize (GObject *object)
+{
+  ConstraintViewChild *child = CONSTRAINT_VIEW_CHILD (object);
+
+  g_free (child->name);
+
+  G_OBJECT_CLASS (constraint_view_child_parent_class)->finalize (object);
+}
+
+static void
+constraint_view_child_set_property (GObject *object,
+                                    
+static void
+constraint_view_child_class_init (ConstraintViewChildClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = constraint_view_child_finalize;
+  object_class->get_property = constraint_view_child_get_property;
+  object_class->set_property = constraint_view_child_set_property;
+
+  props[PROP_NAME] =
+    g_param_spec_string ("name", "name", "name",
+                         NULL,
+                         G_PARAM_READWRITE);
+
+  g_object_class_install_properties (object_class, LAST_PROP, props);
+}
+
+#define CONSTRAINT_VIEW_CHILD_TYPE (constraint_view_get_type ())
+
+G_DECLARE_TYPE (ConstraintViewChild, constraint_view_child, CONSTRAINT, VIEW_CHILD, GObject)
+
+#define CONSTRAINT_VIEW_WIDGET_TYPE (constraint_view_widget_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewWidget, constraint_view_widget, CONSTRAINT, VIEW_WIDGET, ConstraintViewChild)
+
+ConstraintViewWidget * constraint_view_widget_new (void);
+
+#define CONSTRAINT_VIEW_GUIDE_TYPE (constraint_view_guide_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewGuide, constraint_view_guide, CONSTRAINT, VIEW_GUIDE, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_guide_new (void);
+
+#define CONSTRAINT_VIEW_CONSTRAINT_TYPE (constraint_view_constraint_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewConstraint, constraint_view_constraint, CONSTRAINT, VIEW_CONSTRAINT, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_constraint_new (void);
--- a/demos/constraint-editor/constraint-view-child.h
+++ b/demos/constraint-editor/constraint-view-child.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * 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: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define CONSTRAINT_VIEW_CHILD_TYPE (constraint_view_get_type ())
+
+G_DECLARE_TYPE (ConstraintViewChild, constraint_view_child, CONSTRAINT, VIEW_CHILD, GObject)
+
+#define CONSTRAINT_VIEW_WIDGET_TYPE (constraint_view_widget_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewWidget, constraint_view_widget, CONSTRAINT, VIEW_WIDGET, ConstraintViewChild)
+
+ConstraintViewWidget * constraint_view_widget_new (void);
+
+#define CONSTRAINT_VIEW_GUIDE_TYPE (constraint_view_guide_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewGuide, constraint_view_guide, CONSTRAINT, VIEW_GUIDE, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_guide_new (void);
+
+#define CONSTRAINT_VIEW_CONSTRAINT_TYPE (constraint_view_constraint_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewConstraint, constraint_view_constraint, CONSTRAINT, VIEW_CONSTRAINT, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_constraint_new (void);
--- a/demos/constraint-editor/constraint-view.c
+++ b/demos/constraint-editor/constraint-view.c
@@ -0,0 +1,345 @@
+/* Copyright (C) 2019 Red Hat, Inc.
+ *
+ * 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 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/>.
+ */
+
+#include <gtk/gtk.h>
+#include "constraint-view.h"
+
+struct _ConstraintView
+{
+  GtkWidget parent;
+
+  GListModel *model;
+
+  GtkWidget *drag_widget;
+};
+
+G_DEFINE_TYPE (ConstraintView, constraint_view, GTK_TYPE_WIDGET);
+
+static void
+constraint_view_dispose (GObject *object)
+{
+  ConstraintView *view = CONSTRAINT_VIEW (object);
+  GtkWidget *child;
+
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (view))) != NULL)
+    gtk_widget_unparent (child);
+
+  g_clear_object (&view->model);
+
+  G_OBJECT_CLASS (constraint_view_parent_class)->dispose (object);
+}
+
+static void
+constraint_view_class_init (ConstraintViewClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = constraint_view_dispose;
+
+  gtk_widget_class_set_css_name (widget_class, "constraintview");
+}
+
+static void
+update_weak_position (ConstraintView *self,
+                      GtkWidget      *child,
+                      double          x,
+                      double          y)
+{
+  GtkLayoutManager *manager;
+  GtkConstraint *constraint;
+
+  manager = gtk_widget_get_layout_manager (GTK_WIDGET (self));
+  constraint = (GtkConstraint *)g_object_get_data (G_OBJECT (child), "x-constraint");
+  if (constraint)
+    {
+      gtk_constraint_layout_remove_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                               constraint);
+      g_object_set_data (G_OBJECT (child), "x-constraint", NULL);
+    }
+  if (x != -100)
+    {
+      constraint = gtk_constraint_new_constant (child,
+                                                GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
+                                                GTK_CONSTRAINT_RELATION_EQ,
+                                                x,
+                                                GTK_CONSTRAINT_STRENGTH_WEAK);
+      g_object_set_data (G_OBJECT (constraint), "internal", (char *)"yes");
+      gtk_constraint_layout_add_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                            constraint);
+      g_object_set_data (G_OBJECT (child), "x-constraint", constraint);
+    }
+
+  constraint = (GtkConstraint *)g_object_get_data (G_OBJECT (child), "y-constraint");
+  if (constraint)
+    {
+      gtk_constraint_layout_remove_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                                   constraint);
+      g_object_set_data (G_OBJECT (child), "y-constraint", NULL);
+    }
+  if (y != -100)
+    {
+      constraint = gtk_constraint_new_constant (child,
+                                                GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
+                                                GTK_CONSTRAINT_RELATION_EQ,
+                                                y,
+                                                GTK_CONSTRAINT_STRENGTH_WEAK);
+      g_object_set_data (G_OBJECT (constraint), "internal", (char *)"yes");
+      gtk_constraint_layout_add_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                            constraint);
+      g_object_set_data (G_OBJECT (child), "y-constraint", constraint);
+    }
+}
+
+static void
+drag_begin (GtkGestureDrag *drag,
+            double          start_x,
+            double          start_y,
+            ConstraintView *self)
+{
+  GtkWidget *widget;
+
+  widget = gtk_widget_pick (GTK_WIDGET (self), start_x, start_y, GTK_PICK_DEFAULT);
+
+  if (GTK_IS_LABEL (widget))
+    {
+      widget = gtk_widget_get_ancestor (widget, GTK_TYPE_FRAME);
+      if (widget &&
+          gtk_widget_get_parent (widget) == (GtkWidget *)self)
+        {
+          self->drag_widget = widget;
+        }
+    }
+}
+
+static void
+drag_update (GtkGestureDrag *drag,
+             double          offset_x,
+             double          offset_y,
+             ConstraintView *self)
+{
+  double x, y;
+
+  if (!self->drag_widget)
+    return;
+
+  gtk_gesture_drag_get_start_point (drag, &x, &y);
+  update_weak_position (self, self->drag_widget, x + offset_x, y + offset_y);
+}
+
+static void
+drag_end (GtkGestureDrag *drag,
+          double          offset_x,
+          double          offset_y,
+          ConstraintView *self)
+{
+  self->drag_widget = NULL;
+}
+
+static gboolean
+omit_internal (gpointer item, gpointer user_data)
+{
+  if (g_object_get_data (G_OBJECT (item), "internal"))
+    return FALSE;
+
+  return TRUE;
+}
+
+static void
+constraint_view_init (ConstraintView *self)
+{
+  GtkLayoutManager *manager;
+  GtkEventController *controller;
+  GListStore *list;
+  GListModel *all_children;
+  GListModel *all_constraints;
+  GListModel *guides;
+  GListModel *children;
+  GListModel *constraints;
+  GtkFilter *filter;
+
+  manager = gtk_constraint_layout_new ();
+  gtk_widget_set_layout_manager (GTK_WIDGET (self), manager);
+
+  guides = gtk_constraint_layout_observe_guides (GTK_CONSTRAINT_LAYOUT (manager));
+
+  all_constraints = gtk_constraint_layout_observe_constraints (GTK_CONSTRAINT_LAYOUT (manager));
+  filter = GTK_FILTER (gtk_custom_filter_new (omit_internal, NULL, NULL));
+  constraints = (GListModel *)gtk_filter_list_model_new (all_constraints, filter);
+
+  all_children = gtk_widget_observe_children (GTK_WIDGET (self));
+  filter = GTK_FILTER (gtk_custom_filter_new (omit_internal, NULL, NULL));
+  children = (GListModel *)gtk_filter_list_model_new (all_children, filter);
+
+  list = g_list_store_new (G_TYPE_LIST_MODEL);
+  g_list_store_append (list, children);
+  g_list_store_append (list, guides);
+  g_list_store_append (list, constraints);
+  g_object_unref (children);
+  g_object_unref (guides);
+  g_object_unref (constraints);
+
+  self->model = G_LIST_MODEL (gtk_flatten_list_model_new (G_LIST_MODEL (list)));
+
+  controller = (GtkEventController *)gtk_gesture_drag_new ();
+  g_signal_connect (controller, "drag-begin", G_CALLBACK (drag_begin), self);
+  g_signal_connect (controller, "drag-update", G_CALLBACK (drag_update), self);
+  g_signal_connect (controller, "drag-end", G_CALLBACK (drag_end), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+}
+
+ConstraintView *
+constraint_view_new (void)
+{
+  return g_object_new (CONSTRAINT_VIEW_TYPE, NULL);
+}
+
+void
+constraint_view_add_child (ConstraintView *view,
+                           const char     *name)
+{
+  GtkWidget *frame;
+  GtkWidget *label;
+
+  label = gtk_label_new (name);
+  frame = gtk_frame_new (NULL);
+  gtk_widget_add_css_class (frame, "child");
+  gtk_widget_set_name (frame, name);
+  gtk_frame_set_child (GTK_FRAME (frame), label);
+  gtk_widget_set_parent (frame, GTK_WIDGET (view));
+
+  update_weak_position (view, frame, 100, 100);
+}
+
+void
+constraint_view_remove_child (ConstraintView *view,
+                              GtkWidget      *child)
+{
+  update_weak_position (view, child, -100, -100);
+  gtk_widget_unparent (child);
+}
+
+void
+constraint_view_add_guide (ConstraintView *view,
+                           GtkConstraintGuide *guide)
+{
+  GtkConstraintLayout *layout;
+  GtkWidget *frame;
+  GtkWidget *label;
+  const char *name;
+  GtkConstraint *constraint;
+  struct {
+    const char *name;
+    GtkConstraintAttribute attr;
+  } names[] = {
+    { "left-constraint", GTK_CONSTRAINT_ATTRIBUTE_LEFT },
+    { "top-constraint", GTK_CONSTRAINT_ATTRIBUTE_TOP },
+    { "width-constraint", GTK_CONSTRAINT_ATTRIBUTE_WIDTH },
+    { "height-constraint", GTK_CONSTRAINT_ATTRIBUTE_HEIGHT },
+  };
+  int i;
+
+  name = gtk_constraint_guide_get_name (guide);
+  label = gtk_label_new (name);
+  g_object_bind_property (guide, "name",
+                          label, "label",
+                          G_BINDING_DEFAULT);
+
+  frame = gtk_frame_new (NULL);
+  gtk_widget_add_css_class (frame, "guide");
+  g_object_set_data (G_OBJECT (frame), "internal", (char *)"yes");
+  gtk_frame_set_child (GTK_FRAME (frame), label);
+  gtk_widget_insert_after (frame, GTK_WIDGET (view), NULL);
+
+  g_object_set_data (G_OBJECT (guide), "frame", frame);
+
+  layout = GTK_CONSTRAINT_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (view)));
+  gtk_constraint_layout_add_guide (layout, g_object_ref (guide));
+
+  for (i = 0; i < G_N_ELEMENTS (names); i++)
+    {
+      constraint = gtk_constraint_new (frame,
+                                       names[i].attr,
+                                       GTK_CONSTRAINT_RELATION_EQ,
+                                       guide,
+                                       names[i].attr,
+                                       1.0, 0.0,
+                                       GTK_CONSTRAINT_STRENGTH_REQUIRED);
+      g_object_set_data (G_OBJECT (constraint), "internal", (char *)"yes");
+      gtk_constraint_layout_add_constraint (layout, constraint);
+      g_object_set_data (G_OBJECT (guide), names[i].name, constraint);
+    }
+
+  update_weak_position (view, frame, 150, 150);
+}
+
+void
+constraint_view_remove_guide (ConstraintView     *view,
+                              GtkConstraintGuide *guide)
+{
+  GtkConstraintLayout *layout;
+  GtkWidget *frame;
+  GtkConstraint *constraint;
+  const char *names[] = {
+    "left-constraint",
+    "top-constraint",
+    "width-constraint",
+    "height-constraint"
+  };
+  int i;
+
+  layout = GTK_CONSTRAINT_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (view)));
+
+  for (i = 0; i < G_N_ELEMENTS (names); i++)
+    {
+      constraint = (GtkConstraint*)g_object_get_data (G_OBJECT (guide), names[i]);
+      gtk_constraint_layout_remove_constraint (layout, constraint);
+    }
+
+  frame = (GtkWidget *)g_object_get_data (G_OBJECT (guide), "frame");
+  update_weak_position (view, frame, -100, -100);
+  gtk_widget_unparent (frame);
+
+  gtk_constraint_layout_remove_guide (layout, guide);
+}
+
+void
+constraint_view_add_constraint (ConstraintView *view,
+                                GtkConstraint  *constraint)
+{
+  GtkLayoutManager *manager;
+
+  manager = gtk_widget_get_layout_manager (GTK_WIDGET (view));
+  gtk_constraint_layout_add_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                        g_object_ref (constraint));
+}
+
+void
+constraint_view_remove_constraint (ConstraintView *view,
+                                   GtkConstraint  *constraint)
+{
+  GtkLayoutManager *manager;
+
+  manager = gtk_widget_get_layout_manager (GTK_WIDGET (view));
+  gtk_constraint_layout_remove_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                           constraint);
+}
+
+GListModel *
+constraint_view_get_model (ConstraintView *view)
+{
+  return view->model;
+}
--- a/demos/constraint-editor/constraint-view.h
+++ b/demos/constraint-editor/constraint-view.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * 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: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#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);
+
+void             constraint_view_add_child (ConstraintView *view,
+                                            const char     *name);
+void             constraint_view_remove_child (ConstraintView *view,
+                                               GtkWidget      *child);
+void             constraint_view_add_guide (ConstraintView     *view,
+                                            GtkConstraintGuide *guide);
+void             constraint_view_remove_guide (ConstraintView     *view,
+                                               GtkConstraintGuide *guide);
+void             constraint_view_guide_changed (ConstraintView     *view,
+                                                GtkConstraintGuide *guide);
+void             constraint_view_add_constraint (ConstraintView *view,
+                                                 GtkConstraint  *constraint);
+void             constraint_view_remove_constraint (ConstraintView *view,
+                                                    GtkConstraint  *constraint);
+GListModel *     constraint_view_get_model (ConstraintView *view);
--- a/demos/constraint-editor/guide-editor.c
+++ b/demos/constraint-editor/guide-editor.c
@@ -0,0 +1,355 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * 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: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "guide-editor.h"
+
+struct _GuideEditor
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *grid;
+  GtkWidget *name;
+  GtkWidget *min_width;
+  GtkWidget *min_height;
+  GtkWidget *nat_width;
+  GtkWidget *nat_height;
+  GtkWidget *max_width;
+  GtkWidget *max_height;
+  GtkWidget *strength;
+  GtkWidget *button;
+
+  GtkConstraintGuide *guide;
+
+  gboolean constructed;
+};
+
+enum {
+  PROP_GUIDE = 1,
+  LAST_PROP
+};
+
+static GParamSpec *pspecs[LAST_PROP];
+
+enum {
+  DONE,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+G_DEFINE_TYPE(GuideEditor, guide_editor, GTK_TYPE_WIDGET);
+
+static GtkConstraintStrength
+get_strength (unsigned int id)
+{
+  switch (id)
+    {
+    case 0: return GTK_CONSTRAINT_STRENGTH_WEAK;
+    case 1: return GTK_CONSTRAINT_STRENGTH_MEDIUM;
+    case 2: return GTK_CONSTRAINT_STRENGTH_STRONG;
+    case 3: return GTK_CONSTRAINT_STRENGTH_REQUIRED;
+    default: g_assert_not_reached ();
+    }
+}
+
+static unsigned int
+get_strength_id (GtkConstraintStrength strength)
+{
+  switch (strength)
+    {
+    case GTK_CONSTRAINT_STRENGTH_WEAK: return 0;
+    case GTK_CONSTRAINT_STRENGTH_MEDIUM: return 1;
+    case GTK_CONSTRAINT_STRENGTH_STRONG: return 2;
+    case GTK_CONSTRAINT_STRENGTH_REQUIRED: return 3;
+    default: g_assert_not_reached ();
+    }
+}
+
+static const char *
+get_strength_nick (GtkConstraintStrength strength)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_STRENGTH);
+  GEnumValue *value = g_enum_get_value (class, strength);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+void
+guide_editor_serialize_guide (GString *str,
+                              int      indent,
+                              GtkConstraintGuide *guide)
+{
+  int min_width, min_height;
+  int nat_width, nat_height;
+  int max_width, max_height;
+  const char *name;
+  const char *strength;
+
+  gtk_constraint_guide_get_min_size (guide, &min_width, &min_height);
+  gtk_constraint_guide_get_nat_size (guide, &nat_width, &nat_height);
+  gtk_constraint_guide_get_max_size (guide, &max_width, &max_height);
+  name = gtk_constraint_guide_get_name (guide);
+  strength = get_strength_nick (gtk_constraint_guide_get_strength (guide));
+
+  g_string_append_printf (str, "%*s<guide min-width=\"%d\" min-height=\"%d\"\n", indent, "", min_width, min_height);
+  g_string_append_printf (str, "%*s       nat-width=\"%d\" nat-height=\"%d\"\n", indent, "", nat_width, nat_height);
+  g_string_append_printf (str, "%*s       max-width=\"%d\" max-height=\"%d\"\n", indent, "", max_width, max_height);
+  g_string_append_printf (str, "%*s       name=\"%s\" strength=\"%s\" />\n", indent, "", name, strength);
+}
+
+static void
+create_guide (GtkButton   *button,
+              GuideEditor *editor)
+{
+  int strength;
+  const char *name;
+  int w, h;
+  GtkConstraintGuide *guide;
+  unsigned int id;
+
+  if (editor->guide)
+    guide = g_object_ref (editor->guide);
+  else
+    guide = gtk_constraint_guide_new ();
+
+  name = gtk_editable_get_text (GTK_EDITABLE (editor->name));
+  gtk_constraint_guide_set_name (guide, name);
+
+  w = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->min_width));
+  h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->min_height));
+  gtk_constraint_guide_set_min_size (guide, w, h);
+
+  w = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->nat_width));
+  h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->nat_height));
+  gtk_constraint_guide_set_nat_size (guide, w, h);
+
+  w = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->max_width));
+  h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->max_height));
+  gtk_constraint_guide_set_max_size (guide, w, h);
+
+  id = gtk_drop_down_get_selected (GTK_DROP_DOWN (editor->strength));
+  strength = get_strength (id);
+  gtk_constraint_guide_set_strength (guide, strength);
+
+  g_signal_emit (editor, signals[DONE], 0, guide);
+  g_object_unref (guide);
+}
+
+static void
+guide_editor_init (GuideEditor *editor)
+{
+  gtk_widget_init_template (GTK_WIDGET (editor));
+}
+
+static int guide_counter;
+
+static int
+min_input (GtkSpinButton *spin_button,
+           double        *new_val)
+{
+  if (strcmp (gtk_editable_get_text (GTK_EDITABLE (spin_button)), "") == 0)
+    {
+      *new_val = 0.0;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static int
+max_input (GtkSpinButton *spin_button,
+           double        *new_val)
+{
+  if (strcmp (gtk_editable_get_text (GTK_EDITABLE (spin_button)), "") == 0)
+    {
+      *new_val = G_MAXINT;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+guide_editor_constructed (GObject *object)
+{
+  GuideEditor *editor = GUIDE_EDITOR (object);
+
+  g_signal_connect (editor->min_width, "input", G_CALLBACK (min_input), NULL);
+  g_signal_connect (editor->min_height, "input", G_CALLBACK (min_input), NULL);
+  g_signal_connect (editor->max_width, "input", G_CALLBACK (max_input), NULL);
+  g_signal_connect (editor->max_height, "input", G_CALLBACK (max_input), NULL);
+
+  if (editor->guide)
+    {
+      GtkConstraintStrength strength;
+      const char *nick;
+      int w, h;
+
+      nick = gtk_constraint_guide_get_name (editor->guide);
+      if (nick)
+        gtk_editable_set_text (GTK_EDITABLE (editor->name), nick);
+
+      gtk_constraint_guide_get_min_size (editor->guide, &w, &h);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_width), w);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_height), h);
+
+      gtk_constraint_guide_get_nat_size (editor->guide, &w, &h);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_width), w);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_height), h);
+
+      gtk_constraint_guide_get_max_size (editor->guide, &w, &h);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_width), w);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_height), h);
+
+      strength = gtk_constraint_guide_get_strength (editor->guide);
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->strength), get_strength_id (strength));
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Apply");
+    }
+  else
+    {
+      char *name;
+
+      guide_counter++;
+      name = g_strdup_printf ("Guide %d", guide_counter);
+      gtk_editable_set_text (GTK_EDITABLE (editor->name), name);
+      g_free (name);
+
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_width), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_height), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_width), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_height), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_width), G_MAXINT);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_height), G_MAXINT);
+
+      gtk_drop_down_set_selected (GTK_DROP_DOWN (editor->strength), get_strength_id (GTK_CONSTRAINT_STRENGTH_MEDIUM));
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Create");
+    }
+
+  editor->constructed = TRUE;
+}
+
+static void
+guide_editor_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  GuideEditor *self = GUIDE_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_GUIDE:
+      self->guide = g_value_dup_object (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+guide_editor_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  GuideEditor *self = GUIDE_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_GUIDE:
+      g_value_set_object (value, self->guide);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+guide_editor_dispose (GObject *object)
+{
+  GuideEditor *self = (GuideEditor *)object;
+
+  g_clear_object (&self->guide);
+
+  gtk_widget_dispose_template (GTK_WIDGET (self), GUIDE_EDITOR_TYPE);
+
+  G_OBJECT_CLASS (guide_editor_parent_class)->dispose (object);
+}
+
+static void
+guide_editor_class_init (GuideEditorClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->constructed = guide_editor_constructed;
+  object_class->dispose = guide_editor_dispose;
+  object_class->set_property = guide_editor_set_property;
+  object_class->get_property = guide_editor_get_property;
+
+  pspecs[PROP_GUIDE] =
+    g_param_spec_object ("guide", "guide", "guide",
+                         GTK_TYPE_CONSTRAINT_GUIDE,
+                         G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, LAST_PROP, pspecs);
+
+  signals[DONE] =
+    g_signal_new ("done",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE, 1, GTK_TYPE_CONSTRAINT_GUIDE);
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+
+  gtk_widget_class_set_template_from_resource (widget_class,
+                                               "/org/gtk/gtk4/constraint-editor/guide-editor.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, grid);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, name);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, min_width);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, min_height);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, nat_width);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, nat_height);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, max_width);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, max_height);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, strength);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, button);
+
+  gtk_widget_class_bind_template_callback (widget_class, create_guide);
+}
+
+GuideEditor *
+guide_editor_new (GtkConstraintGuide *guide)
+{
+  return g_object_new (GUIDE_EDITOR_TYPE,
+                       "guide", guide,
+                       NULL);
+}
--- a/demos/constraint-editor/guide-editor.h
+++ b/demos/constraint-editor/guide-editor.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * 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: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define GUIDE_EDITOR_TYPE (guide_editor_get_type ())
+
+G_DECLARE_FINAL_TYPE (GuideEditor, guide_editor, GUIDE, EDITOR, GtkWidget)
+
+GuideEditor * guide_editor_new (GtkConstraintGuide  *guide);
+
+void guide_editor_serialize_guide (GString            *str,
+                                   int                 indent,
+                                   GtkConstraintGuide *guide);
--- a/demos/constraint-editor/guide-editor.ui
+++ b/demos/constraint-editor/guide-editor.ui
@@ -0,0 +1,201 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkAdjustment" id="min_width_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="min_height_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="nat_width_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="nat_height_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="max_width_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="max_height_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <template class="GuideEditor" parent="GtkWidget">
+    <child>
+      <object class="GtkGrid" id="grid">
+        <property name="margin-start">20</property>
+        <property name="margin-end">20</property>
+        <property name="margin-top">20</property>
+        <property name="margin-bottom">20</property>
+        <property name="row-spacing">10</property>
+        <property name="column-spacing">10</property>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Name</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">0</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkEntry" id="name">
+            <property name="max-width-chars">20</property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">0</property>
+              <property name="column-span">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Min Size</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="min_width">
+            <property name="adjustment">min_width_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="min_height">
+            <property name="adjustment">min_height_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="column">2</property>
+              <property name="row">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Nat Size</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="nat_width">
+            <property name="adjustment">nat_width_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="nat_height">
+            <property name="adjustment">nat_height_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="column">2</property>
+              <property name="row">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Max Size</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="max_width">
+            <property name="adjustment">max_width_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="max_height">
+            <property name="adjustment">max_height_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="column">2</property>
+              <property name="row">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Strength</property>
+            <layout>
+              <property name="column">0</property>
+              <property name="row">4</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkDropDown" id="strength">
+            <property name="model">
+              <object class="GtkStringList">
+                <items>
+                  <item>Weak</item>
+                  <item>Medium</item>
+                  <item>Strong</item>
+                  <item>Required</item>
+                </items>
+              </object>
+            </property>
+            <layout>
+              <property name="column">1</property>
+              <property name="row">4</property>
+              <property name="column-span">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="button">
+            <property name="label">Create</property>
+            <signal name="clicked" handler="create_guide"/>
+            <layout>
+              <property name="column">2</property>
+              <property name="row">5</property>
+            </layout>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
--- a/demos/constraint-editor/main.c
+++ b/demos/constraint-editor/main.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * 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: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#include "config.h"
+
+#include <constraint-editor-application.h>
+
+int
+main (int argc, char *argv[])
+{
+  return g_application_run (G_APPLICATION (constraint_editor_application_new ()), argc, argv);
+}
--- a/demos/constraint-editor/meson.build
+++ b/demos/constraint-editor/meson.build
@@ -0,0 +1,23 @@
+constraint_editor_sources = [
+  'main.c',
+  'constraint-editor-application.c',
+  'constraint-editor-window.c',
+  'constraint-view.c',
+  'constraint-editor.c',
+  'guide-editor.c',
+]
+
+constraint_editor_resources = gnome.compile_resources('constraint_editor_resources',
+  'constraint-editor.gresource.xml',
+  source_dir: meson.current_source_dir(),
+)
+
+executable('gtk4-constraint-editor',
+  sources: [ constraint_editor_sources, constraint_editor_resources, ],
+  c_args: common_cflags,
+  dependencies: libgtk_dep,
+  include_directories: confinc,
+  win_subsystem: 'windows',
+  link_args: extra_demo_ldflags,
+  install: false,
+)
--- a/demos/gtk-demo/Moby-Dick.txt
+++ b/demos/gtk-demo/Moby-Dick.txt
--- a/demos/gtk-demo/background.glsl
+++ b/demos/gtk-demo/background.glsl
@@ -0,0 +1,26 @@
+uniform float u_time;
+
+void
+mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv)
+{
+  vec2 pos = (fragCoord.xy * 2.0 - resolution.xy)/ min (resolution.x, resolution.y) ;
+
+  float t0 = sin ((u_time + 0.00)*1.0);
+  float t1 = sin ((u_time + 0.30)*0.4);
+  float t2 = cos ((u_time + 0.23)*0.9);
+  float t3 = cos ((u_time + 0.41)*0.6);
+  float t4 = cos ((u_time + 0.11)*0.3);
+
+  vec2 p0 = vec2 (t1, t0) ;
+  vec2 p1 = vec2 (t2, t3) ;
+  vec2 p2 = vec2 (t4, t3) ;
+
+  float r = 1.0/distance (pos, p0);
+  float g = 1.0/distance (pos, p1);
+  float b = 1.0/distance (pos, p2);
+  float sum = r + g + b;
+
+  float alpha = 1.0 - pow (1.0/(sum), 40.0)*pow (10.0, 40.0*0.7);
+
+  fragColor = vec4 (r*0.5, g*0.5, b*0.5, 1.0) * alpha;
+}
--- a/demos/gtk-demo/cogs2.glsl
+++ b/demos/gtk-demo/cogs2.glsl
@@ -0,0 +1,226 @@
+uniform float iTime;
+
+// Originally from: https://www.shadertoy.com/view/3ljyDD
+// License CC0: Hexagonal tiling + cog wheels
+//  Nothing fancy, just hexagonal tiling + cog wheels
+
+#define PI      3.141592654
+#define TAU     (2.0*PI)
+#define MROT(a) mat2(cos(a), sin(a), -sin(a), cos(a))
+
+float hash(in vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,58.233))) * 13758.5453);
+}
+
+float pcos(float a) {
+  return 0.5 + 0.5*cos(a);
+}
+
+void rot(inout vec2 p, float a) {
+  float c = cos(a);
+  float s = sin(a);
+  p = vec2(c*p.x + s*p.y, -s*p.x + c*p.y);
+}
+
+float modPolar(inout vec2 p, float repetitions) {
+  float angle = 2.0*PI/repetitions;
+  float a = atan(p.y, p.x) + angle/2.;
+  float r = length(p);
+  float c = floor(a/angle);
+  a = mod(a,angle) - angle/2.;
+  p = vec2(cos(a), sin(a))*r;
+  // For an odd number of repetitions, fix cell index of the cell in -x direction
+  // (cell index would be e.g. -5 and 5 in the two halves of the cell):
+  if (abs(c) >= (repetitions/2.0)) c = abs(c);
+  return c;
+}
+
+float pmin(float a, float b, float k) {
+  float h = clamp( 0.5+0.5*(b-a)/k, 0.0, 1.0 );
+  return mix( b, a, h ) - k*h*(1.0-h);
+}
+
+const vec2 sz       = vec2(1.0, sqrt(3.0));
+const vec2 hsz      = 0.5*sz;
+const float smallCount = 16.0;
+
+vec2 hextile(inout vec2 p) {
+  // See Art of Code: Hexagonal Tiling Explained!
+  // https://www.youtube.com/watch?v=VmrIDyYiJBA
+
+  vec2 p1 = mod(p, sz)-hsz;
+  vec2 p2 = mod(p - hsz*1.0, sz)-hsz;
+  vec2 p3 = mix(p2, p1, vec2(length(p1) < length(p2)));
+  vec2 n = p3 - p;
+  p = p3;
+
+  return n;
+}
+
+float circle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float box(vec2 p, vec2 b) {
+  vec2 d = abs(p)-b;
+  return length(max(d,0.0)) + min(max(d.x,d.y),0.0);
+}
+
+float unevenCapsule(vec2 p, float r1, float r2, float h) {
+  p.x = abs(p.x);
+  float b = (r1-r2)/h;
+  float a = sqrt(1.0-b*b);
+  float k = dot(p,vec2(-b,a));
+  if( k < 0.0 ) return length(p) - r1;
+  if( k > a*h ) return length(p-vec2(0.0,h)) - r2;
+  return dot(p, vec2(a,b) ) - r1;
+}
+
+float cogwheel(vec2 p, float innerRadius, float outerRadius, float cogs, float holes) {
+  float cogWidth  = 0.25*innerRadius*TAU/cogs;
+
+  float d0 = circle(p, innerRadius);
+
+  vec2 icp = p;
+  modPolar(icp, holes);
+  icp -= vec2(innerRadius*0.55, 0.0);
+  float d1 = circle(icp, innerRadius*0.25);
+
+  vec2 cp = p;
+  modPolar(cp, cogs);
+  cp -= vec2(innerRadius, 0.0);
+  float d2 = unevenCapsule(cp.yx, cogWidth, cogWidth*0.75, (outerRadius-innerRadius));
+
+  float d3 = circle(p, innerRadius*0.20);
+
+  float d = 1E6;
+  d = min(d, d0);
+  d = pmin(d, d2, 0.5*cogWidth);
+  d = min(d, d2);
+  d = max(d, -d1);
+  d = max(d, -d3);
+
+  return d;
+}
+
+float ccell1(vec2 p, float r) {
+  float d = 1E6;
+  const float bigCount = 60.0;
+
+  vec2 cp0 = p;
+  rot(cp0, -iTime*TAU/bigCount);
+  float d0 = cogwheel(cp0, 0.36, 0.38, bigCount, 5.0);
+
+  vec2 cp1 = p;
+  float nm = modPolar(cp1, 6.0);
+
+  cp1 -= vec2(0.5, 0.0);
+  rot(cp1, 0.2+TAU*nm/2.0 + iTime*TAU/smallCount);
+  float d1 = cogwheel(cp1, 0.11, 0.125, smallCount, 5.0);
+
+  d = min(d, d0);
+  d = min(d, d1);
+  return d;
+}
+
+float ccell2(vec2 p, float r) {
+  float d = 1E6;
+  vec2 cp0 = p;
+  float nm = modPolar(cp0, 6.0);
+  vec2 cp1 = cp0;
+  const float off = 0.275;
+  const float count = smallCount + 2.0;
+  cp0 -= vec2(off, 0.0);
+  rot(cp0, 0.+TAU*nm/2.0 - iTime*TAU/count);
+  float d0 = cogwheel(cp0, 0.09, 0.105, count, 5.0);
+
+
+  cp1 -= vec2(0.5, 0.0);
+  rot(cp1, 0.2+TAU*nm/2.0 + iTime*TAU/smallCount);
+  float d1 = cogwheel(cp1, 0.11, 0.125, smallCount, 5.0);
+
+  float l = length(p);
+  float d2 = l - (off+0.055);
+  float d3 = d2 + 0.020;;
+
+  vec2 tp0 = p;
+  modPolar(tp0, 60.0);
+  tp0.x -= off;
+  float d4 = box(tp0, vec2(0.0125, 0.005));
+
+  float ctime = -(iTime*0.05 + r)*TAU;
+
+  vec2 tp1 = p;
+  rot(tp1, ctime*12.0);
+  tp1.x -= 0.13;
+  float d5 = box(tp1, vec2(0.125, 0.005));
+
+  vec2 tp2 = p;
+  rot(tp2, ctime);
+  tp2.x -= 0.13*0.5;
+  float d6 = box(tp2, vec2(0.125*0.5, 0.0075));
+
+  float d7 = l - 0.025;
+  float d8 = l - 0.0125;
+
+  d = min(d, d0);
+  d = min(d, d1);
+  d = min(d, d2);
+  d = max(d, -d3);
+  d = min(d, d4);
+  d = min(d, d5);
+  d = min(d, d6);
+  d = min(d, d7);
+  d = max(d, -d8);
+
+  return d;
+}
+
+float df(vec2 p, float scale, inout vec2 nn) {
+  p /= scale;
+  nn = hextile(p);
+  nn = floor(nn + 0.5);
+  float r = hash(nn);
+
+  float d;;
+
+  if (r < 0.5) {
+    d = ccell1(p, r);
+  } else {
+    d = ccell2(p, r);
+  }
+
+  return d*scale;
+}
+
+vec3 postProcess(vec3 col, vec2 q)  {
+  //col = saturate(col);
+  col=pow(clamp(col,0.0,1.0),vec3(0.75));
+  col=col*0.6+0.4*col*col*(3.0-2.0*col);  // contrast
+  col=mix(col, vec3(dot(col, vec3(0.33))), -0.4);  // satuation
+  col*=0.5+0.5*pow(19.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.7);  // vigneting
+  return col;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv) {
+  vec2 q = fragCoord/resolution.xy;
+  vec2 p = -1.0 + 2.0*q;
+  p.x *= resolution.x/resolution.y;
+  float tm = iTime*0.1;
+  p += vec2(cos(tm), sin(tm*sqrt(0.5)));
+  float z = mix(0.5, 1.0, pcos(tm*sqrt(0.3)));
+  float aa = 4.0 / resolution.y;
+
+  vec2 nn = vec2(0.0);
+  float d = df(p, z, nn);
+
+  vec3 col = vec3(160.0)/vec3(255.0);
+  vec3 baseCol = vec3(0.3);
+  vec4 logoCol = vec4(baseCol, 1.0)*smoothstep(-aa, 0.0, -d);
+  col = mix(col, logoCol.xyz, pow(logoCol.w, 8.0));
+  col += 0.4*pow(abs(sin(20.0*d)), 0.6);
+
+  col = postProcess(col, q);
+
+  fragColor = vec4(col, 1.0);
+}
--- a/demos/gtk-demo/crosswarp.glsl
+++ b/demos/gtk-demo/crosswarp.glsl
@@ -0,0 +1,27 @@
+uniform float progress;
+uniform sampler2D u_texture1;
+uniform sampler2D u_texture2;
+
+vec4 getFromColor (vec2 uv) {
+  return GskTexture(u_texture1, uv);
+}
+
+vec4 getToColor (vec2 uv) {
+  return GskTexture(u_texture2, uv);
+}
+
+// Source: https://gl-transitions.com/editor/crosswarp
+// Author: Eke Péter <peterekepeter@gmail.com>
+// License: MIT
+
+vec4 transition(vec2 p) {
+  float x = progress;
+  x=smoothstep(.0,1.0,(x*2.0+p.x-1.0));
+  return mix(getFromColor((p-.5)*(1.-x)+.5), getToColor((p-.5)*x+.5), x);
+}
+
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv)
+{
+  fragColor = transition(uv);
+}
--- a/demos/gtk-demo/demo.gresource.xml
+++ b/demos/gtk-demo/demo.gresource.xml
@@ -146,6 +146,21 @@
    <file>cogs.glsl</file>
    <file>glowingstars.glsl</file>
  </gresource>
+  <gresource prefix="/gltransition">
+    <file>gtkshaderstack.c</file>
+    <file>gtkshaderstack.h</file>
+    <file>gtkshaderbin.h</file>
+    <file>gtkshaderbin.c</file>
+    <file>gskshaderpaintable.h</file>
+    <file>gskshaderpaintable.c</file>
+    <file>wind.glsl</file>
+    <file>radial.glsl</file>
+    <file>crosswarp.glsl</file>
+    <file>kaleidoscope.glsl</file>
+    <file>cogs2.glsl</file>
+    <file>ripple.glsl</file>
+    <file>background.glsl</file>
+  </gresource>
  <gresource prefix="/iconscroll">
    <file>iconscroll.ui</file>
  </gresource>
@@ -281,6 +296,7 @@
    <file>gears.c</file>
    <file>gestures.c</file>
    <file>glarea.c</file>
+    <file>gltransition.c</file>
    <file>headerbar.c</file>
    <file>hypertext.c</file>
    <file>iconscroll.c</file>
@@ -438,10 +454,6 @@
    <file>icons/16x16/categories/applications-other.png</file>
    <file>icons/48x48/status/starred.png</file>
    <file alias="icons/scalable/apps/org.gtk.Demo4.svg">data/scalable/apps/org.gtk.Demo4.svg</file>
-    <file>portland-rose-thumbnail.png</file>
-    <file>large-image-thumbnail.png</file>
-    <file compressed="true">large-image.png</file>
-    <file compressed="true">Moby-Dick.txt</file>
  </gresource>
  <gresource prefix="/org/gtk/Demo4/gtk">
    <file preprocess="xml-stripblanks">help-overlay.ui</file>
--- a/demos/gtk-demo/errorstates.c
+++ b/demos/gtk-demo/errorstates.c
@@ -55,7 +55,7 @@ mode_switch_state_set (GtkSwitch *sw,
    {
      gtk_widget_set_visible (label, TRUE);
      gtk_accessible_update_relation (GTK_ACCESSIBLE (sw),
-                                      GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE, label, NULL,
+                                      GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE, label,
                                      -1);
      gtk_accessible_update_state (GTK_ACCESSIBLE (sw),
                                   GTK_ACCESSIBLE_STATE_INVALID, GTK_ACCESSIBLE_INVALID_TRUE,
--- a/demos/gtk-demo/fishbowl.c
+++ b/demos/gtk-demo/fishbowl.c
@@ -9,6 +9,7 @@

 #include "gtkfishbowl.h"
 #include "gtkgears.h"
+#include "gskshaderpaintable.h"

 #include "nodewidget.h"
 #include "graphwidget.h"
@@ -151,6 +152,46 @@ create_switch (void)
  return w;
 }

+static gboolean
+update_paintable (GtkWidget     *widget,
+                  GdkFrameClock *frame_clock,
+                  gpointer       user_data)
+{
+  GskShaderPaintable *paintable;
+  gint64 frame_time;
+
+  paintable = GSK_SHADER_PAINTABLE (gtk_picture_get_paintable (GTK_PICTURE (widget)));
+  frame_time = gdk_frame_clock_get_frame_time (frame_clock);
+  gsk_shader_paintable_update_time (paintable, 0, frame_time);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static GtkWidget *
+create_cogs (void)
+{
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+  GtkWidget *picture;
+  static GskGLShader *cog_shader = NULL;
+  GdkPaintable *paintable;
+
+ if (cog_shader == NULL)
+    cog_shader = gsk_gl_shader_new_from_resource ("/gltransition/cogs2.glsl");
+  paintable = gsk_shader_paintable_new (g_object_ref (cog_shader), NULL);
+  picture = gtk_picture_new_for_paintable (paintable);
+  gtk_widget_set_size_request (picture, 150, 75);
+  gtk_widget_add_tick_callback (picture, update_paintable, NULL, NULL);
+
+  return picture;
+G_GNUC_END_IGNORE_DEPRECATIONS
+}
+
+static gboolean
+check_cogs (GtkFishbowl *fb)
+{
+  return GSK_IS_GL_RENDERER (gtk_native_get_renderer (gtk_widget_get_native (GTK_WIDGET (fb))));
+}
+
 static void
 mapped (GtkWidget *w)
 {
@@ -200,6 +241,7 @@ static const struct {
  { "Gears",      create_gears,          NULL },
  { "Switch",     create_switch,         NULL },
  { "Menubutton", create_menu_button,    NULL },
+  { "Shader",     create_cogs,           check_cogs },
  { "Tiger",      create_tiger,          NULL },
  { "Graph",      create_graph,          NULL },
 };
--- a/demos/gtk-demo/fontplane.c
+++ b/demos/gtk-demo/fontplane.c
@@ -276,7 +276,7 @@ gtk_font_plane_class_init (GtkFontPlaneClass *class)

 GtkWidget *
 gtk_font_plane_new (GtkAdjustment *weight_adj,
-                    GtkAdjustment *width_adj)
+                     GtkAdjustment *width_adj)
 {
  return g_object_new (GTK_TYPE_FONT_PLANE,
                       "weight-adjustment", weight_adj,
--- a/demos/gtk-demo/fontplane.h
+++ b/demos/gtk-demo/fontplane.h
@@ -55,7 +55,7 @@ struct _GtkFontPlaneClass


 GType       gtk_font_plane_get_type (void) G_GNUC_CONST;
-GtkWidget * gtk_font_plane_new      (GtkAdjustment *weight_adj,
-                                     GtkAdjustment *width_adj);
+GtkWidget * gtk_font_plane_new      (GtkAdjustment *width_adj,
+                                     GtkAdjustment *weight_adj);

 G_END_DECLS
--- a/demos/gtk-demo/gltransition.c
+++ b/demos/gtk-demo/gltransition.c
@@ -0,0 +1,366 @@
+/* OpenGL/Transitions and Effects
+ * #Keywords: OpenGL, shader, effect
+ *
+ * Create transitions between pages using a custom fragment shader.
+ *
+ * The example transitions here are taken from gl-transitions.com, and you
+ * can edit the shader code itself on the last page of the stack.
+ *
+ * The transitions work with arbitrary content. We use images, shaders
+ * GL areas and plain old widgets to demonstrate this.
+ *
+ * The demo also shows some over-the-top effects like wobbly widgets,
+ * and animated backgrounds.
+ */
+
+#include <math.h>
+#include <gtk/gtk.h>
+#include "gtkshaderstack.h"
+#include "gtkshaderbin.h"
+#include "gtkshadertoy.h"
+#include "gskshaderpaintable.h"
+
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+static GtkWidget *demo_window = NULL;
+
+static void
+close_window (GtkWidget *widget)
+{
+  /* Reset the state */
+  demo_window = NULL;
+}
+
+static void
+text_changed (GtkTextBuffer *buffer,
+              GtkWidget     *button)
+{
+  gtk_widget_set_visible (button, TRUE);
+}
+
+static void
+apply_text (GtkWidget     *button,
+            GtkTextBuffer *buffer)
+{
+  GtkWidget *stack;
+  GskGLShader *shader;
+  GtkTextIter start, end;
+  char *text;
+
+  stack = g_object_get_data (G_OBJECT (button), "the-stack");
+
+  gtk_text_buffer_get_bounds (buffer, &start, &end);
+  text = gtk_text_buffer_get_text (buffer, &start, &end, TRUE);
+
+  GBytes *bytes = g_bytes_new_take (text, strlen (text));
+  shader = gsk_gl_shader_new_from_bytes (bytes);
+
+  gtk_shader_stack_set_shader (GTK_SHADER_STACK (stack), shader);
+
+  g_object_unref (shader);
+  g_bytes_unref (bytes);
+
+  gtk_widget_set_visible (button, FALSE);
+}
+
+static void
+go_back (GtkWidget     *button,
+         GtkWidget     *stack)
+{
+  gtk_shader_stack_transition (GTK_SHADER_STACK (stack), FALSE);
+}
+
+static void
+go_forward (GtkWidget     *button,
+            GtkWidget     *stack)
+{
+  gtk_shader_stack_transition (GTK_SHADER_STACK (stack), TRUE);
+}
+
+static void
+clicked_cb (GtkGestureClick *gesture,
+            guint            n_pressed,
+            double           x,
+            double           y,
+            gpointer         data)
+{
+  gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
+}
+
+static GtkWidget *
+ripple_bin_new (void)
+{
+  GtkWidget *bin = gtk_shader_bin_new ();
+  static GskGLShader *shader = NULL;
+
+  if (shader == NULL)
+    shader = gsk_gl_shader_new_from_resource ("/gltransition/ripple.glsl");
+
+  gtk_shader_bin_add_shader (GTK_SHADER_BIN (bin), shader, GTK_STATE_FLAG_PRELIGHT, GTK_STATE_FLAG_PRELIGHT, 20);
+
+  return bin;
+}
+
+static GtkWidget *
+new_shadertoy (const char *path)
+{
+  GBytes *shader;
+  GtkWidget *toy;
+
+  toy = gtk_shadertoy_new ();
+  shader = g_resources_lookup_data (path, 0, NULL);
+  gtk_shadertoy_set_image_shader (GTK_SHADERTOY (toy),
+                                  g_bytes_get_data (shader, NULL));
+  g_bytes_unref (shader);
+
+  return toy;
+}
+
+static gboolean
+update_paintable (GtkWidget     *widget,
+                  GdkFrameClock *frame_clock,
+                  gpointer       user_data)
+{
+  GskShaderPaintable *paintable;
+  gint64 frame_time;
+
+  paintable = GSK_SHADER_PAINTABLE (gtk_picture_get_paintable (GTK_PICTURE (widget)));
+  frame_time = gdk_frame_clock_get_frame_time (frame_clock);
+  gsk_shader_paintable_update_time (paintable, 0, frame_time);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static GtkWidget *
+make_shader_stack (const char *name,
+                   const char *resource_path,
+                   int active_child,
+                   GtkWidget  *scale)
+{
+  GtkWidget *stack, *child, *widget, *vbox, *hbox, *bin;
+  GtkWidget *label, *button, *tv;
+  GskGLShader *shader;
+  GObjectClass *class;
+  GParamSpecFloat *pspec;
+  GtkAdjustment *adjustment;
+  GtkTextBuffer *buffer;
+  GBytes *bytes;
+  GtkEventController *controller;
+  GdkPaintable *paintable;
+
+  stack = gtk_shader_stack_new ();
+  shader = gsk_gl_shader_new_from_resource (resource_path);
+  gtk_shader_stack_set_shader (GTK_SHADER_STACK (stack), shader);
+  g_object_unref (shader);
+
+  child = gtk_picture_new_for_resource ("/css_blendmodes/ducky.png");
+  gtk_picture_set_can_shrink (GTK_PICTURE (child), TRUE);
+  gtk_shader_stack_add_child (GTK_SHADER_STACK (stack), child);
+
+  shader = gsk_gl_shader_new_from_resource ("/gltransition/cogs2.glsl");
+  paintable = gsk_shader_paintable_new (shader, NULL);
+
+  child = gtk_picture_new_for_paintable (paintable);
+  gtk_widget_add_tick_callback (child, update_paintable, NULL, NULL);
+  gtk_picture_set_can_shrink (GTK_PICTURE (child), TRUE);
+  gtk_shader_stack_add_child (GTK_SHADER_STACK (stack), child);
+
+  child = gtk_picture_new_for_resource ("/transparent/portland-rose.jpg");
+  gtk_picture_set_can_shrink (GTK_PICTURE (child), TRUE);
+  gtk_shader_stack_add_child (GTK_SHADER_STACK (stack), child);
+
+  child = new_shadertoy ("/shadertoy/neon.glsl");
+  gtk_shader_stack_add_child (GTK_SHADER_STACK (stack), child);
+
+  child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+
+  class = g_type_class_ref (GTK_TYPE_SHADER_STACK);
+  pspec = G_PARAM_SPEC_FLOAT (g_object_class_find_property (class, "duration"));
+
+  adjustment = gtk_range_get_adjustment (GTK_RANGE (scale));
+  if (gtk_adjustment_get_lower (adjustment) == 0.0 &&
+      gtk_adjustment_get_upper (adjustment) == 0.0)
+    {
+      gtk_adjustment_configure (adjustment,
+                                pspec->default_value,
+                                pspec->minimum,
+                                pspec->maximum,
+                                0.1, 0.5, 0);
+    }
+
+  g_type_class_unref (class);
+
+  g_object_bind_property (adjustment, "value",
+                          stack, "duration",
+                          G_BINDING_DEFAULT);
+
+  widget = gtk_scrolled_window_new ();
+  gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (widget), TRUE);
+  gtk_widget_set_hexpand (widget, TRUE);
+  gtk_widget_set_vexpand (widget, TRUE);
+
+  controller = GTK_EVENT_CONTROLLER (gtk_gesture_click_new ());
+  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (controller), 0);
+  g_signal_connect (controller, "released", G_CALLBACK (clicked_cb), NULL);
+  gtk_event_controller_set_propagation_phase (controller, GTK_PHASE_BUBBLE);
+  gtk_widget_add_controller (GTK_WIDGET (widget), controller);
+
+  tv = gtk_text_view_new ();
+  gtk_text_view_set_left_margin (GTK_TEXT_VIEW (tv), 4);
+  gtk_text_view_set_right_margin (GTK_TEXT_VIEW (tv), 4);
+  gtk_text_view_set_top_margin (GTK_TEXT_VIEW (tv), 4);
+  gtk_text_view_set_bottom_margin (GTK_TEXT_VIEW (tv), 4);
+  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv));
+  bytes = g_resources_lookup_data (resource_path, 0, NULL);
+  gtk_text_buffer_set_text (buffer,
+                            (const char *)g_bytes_get_data (bytes, NULL),
+                            g_bytes_get_size (bytes));
+  g_bytes_unref (bytes);
+  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (widget), tv);
+
+  gtk_box_append (GTK_BOX (child), widget);
+
+  gtk_shader_stack_add_child (GTK_SHADER_STACK (stack), child);
+
+  gtk_shader_stack_set_active (GTK_SHADER_STACK (stack), active_child);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+
+  widget = gtk_center_box_new ();
+  label = gtk_label_new (name);
+  gtk_widget_add_css_class (label, "title-4");
+  gtk_widget_set_size_request (label, -1, 26);
+  gtk_center_box_set_center_widget (GTK_CENTER_BOX (widget), label);
+
+  button = gtk_button_new_from_icon_name ("view-refresh-symbolic");
+  g_signal_connect (buffer, "changed", G_CALLBACK (text_changed), button);
+  g_object_set_data (G_OBJECT (button), "the-stack", stack);
+  g_signal_connect (button, "clicked", G_CALLBACK (apply_text), buffer);
+  gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
+  gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+  gtk_widget_add_css_class (button, "small");
+  gtk_widget_set_visible (button, FALSE);
+  gtk_center_box_set_end_widget (GTK_CENTER_BOX (widget), button);
+
+  gtk_box_append (GTK_BOX (vbox), widget);
+
+  GtkWidget *bin2 = ripple_bin_new ();
+  gtk_shader_bin_set_child (GTK_SHADER_BIN (bin2), stack);
+
+  gtk_box_append (GTK_BOX (vbox), bin2);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+  gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);
+
+  gtk_box_append (GTK_BOX (vbox), hbox);
+
+  button = gtk_button_new_from_icon_name ("go-previous-symbolic");
+  g_signal_connect (button, "clicked", G_CALLBACK (go_back), stack);
+  bin = ripple_bin_new ();
+  gtk_shader_bin_set_child (GTK_SHADER_BIN (bin), button);
+  gtk_box_append (GTK_BOX (hbox), bin);
+
+  button = gtk_button_new_from_icon_name ("go-next-symbolic");
+  g_signal_connect (button, "clicked", G_CALLBACK (go_forward), stack);
+  bin = ripple_bin_new ();
+  gtk_shader_bin_set_child (GTK_SHADER_BIN (bin), button);
+  gtk_box_append (GTK_BOX (hbox), bin);
+
+  return vbox;
+}
+
+static void
+remove_provider (gpointer data)
+{
+  GtkStyleProvider *provider = GTK_STYLE_PROVIDER (data);
+
+  gtk_style_context_remove_provider_for_display (gdk_display_get_default (), provider);
+  g_object_unref (provider);
+}
+
+static GtkWidget *
+create_gltransition_window (GtkWidget *do_widget)
+{
+  GtkWidget *window, *headerbar, *scale, *outer_grid, *grid, *background;
+  GdkPaintable *paintable;
+  GtkCssProvider *provider;
+
+  window = gtk_window_new ();
+  gtk_window_set_display (GTK_WINDOW (window),  gtk_widget_get_display (do_widget));
+  gtk_window_set_title (GTK_WINDOW (window), "Transitions and Effects");
+  headerbar = gtk_header_bar_new ();
+  scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL);
+  gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
+  gtk_widget_set_size_request (scale, 100, -1);
+  gtk_widget_set_tooltip_text (scale, "Transition duration");
+  gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), scale);
+  gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
+  gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
+  g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);
+
+  outer_grid = gtk_grid_new ();
+  gtk_window_set_child (GTK_WINDOW (window), outer_grid);
+
+  paintable = gsk_shader_paintable_new (gsk_gl_shader_new_from_resource ("/gltransition/background.glsl"), NULL);
+  background = gtk_picture_new_for_paintable (paintable);
+  gtk_widget_add_tick_callback (background, update_paintable, NULL, NULL);
+
+  gtk_grid_attach (GTK_GRID (outer_grid),
+                   background,
+                   0, 0, 1, 1);
+
+  grid = gtk_grid_new ();
+  gtk_grid_attach (GTK_GRID (outer_grid),
+                   grid,
+                   0, 0, 1, 1);
+
+  gtk_widget_set_halign (grid, GTK_ALIGN_CENTER);
+  gtk_widget_set_valign (grid, GTK_ALIGN_CENTER);
+  gtk_widget_set_margin_start (grid, 12);
+  gtk_widget_set_margin_end (grid, 12);
+  gtk_widget_set_margin_top (grid, 12);
+  gtk_widget_set_margin_bottom (grid, 12);
+  gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
+  gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
+  gtk_grid_set_row_homogeneous (GTK_GRID (grid), TRUE);
+  gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
+
+  gtk_grid_attach (GTK_GRID (grid),
+                   make_shader_stack ("Wind", "/gltransition/wind.glsl", 0, scale),
+                   0, 0, 1, 1);
+  gtk_grid_attach (GTK_GRID (grid),
+                   make_shader_stack ("Radial", "/gltransition/radial.glsl", 1, scale),
+                   1, 0, 1, 1);
+  gtk_grid_attach (GTK_GRID (grid),
+                   make_shader_stack ("Crosswarp", "/gltransition/crosswarp.glsl", 2, scale),
+                   0, 1, 1, 1);
+  gtk_grid_attach (GTK_GRID (grid),
+                   make_shader_stack ("Kaleidoscope", "/gltransition/kaleidoscope.glsl", 3, scale),
+                   1, 1, 1, 1);
+
+  provider = gtk_css_provider_new ();
+  gtk_css_provider_load_from_string (provider, "button.small { padding: 0; }");
+  gtk_style_context_add_provider_for_display (gdk_display_get_default (),
+                                              GTK_STYLE_PROVIDER (provider),
+                                              GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+  g_object_set_data_full (G_OBJECT (window), "provider", provider, remove_provider);
+
+  return window;
+}
+
+GtkWidget *
+do_gltransition (GtkWidget *do_widget)
+{
+  if (!demo_window)
+    demo_window = create_gltransition_window (do_widget);
+
+  if (!gtk_widget_get_visible (demo_window))
+    gtk_widget_set_visible (demo_window, TRUE);
+  else
+    gtk_window_destroy (GTK_WINDOW (demo_window));
+
+  return demo_window;
+}
+
+G_GNUC_END_IGNORE_DEPRECATIONS
--- a/demos/gtk-demo/gskshaderpaintable.c
+++ b/demos/gtk-demo/gskshaderpaintable.c
@@ -0,0 +1,338 @@
+/*
+ * Copyright © 2020 Red Hat, Inc
+ *
+ * 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: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#include "config.h"
+
+#include <gtk/gtk.h>
+#include "gskshaderpaintable.h"
+
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+/**
+ * GskShaderPaintable:
+ *
+ * `GskShaderPaintable` is an implementation of the `GdkPaintable` interface
+ * that uses a `GskGLShader` to create pixels.
+ *
+ * You can set the uniform data that the shader needs for rendering
+ * using gsk_shader_paintable_set_args(). This function can
+ * be called repeatedly to change the uniform data for the next
+ * snapshot.
+ *
+ * Commonly, time is passed to shaders as a float uniform containing
+ * the elapsed time in seconds. The convenience API
+ * gsk_shader_paintable_update_time() can be called from a `GtkTickCallback`
+ * to update the time based on the frame time of the frame clock.
+ */
+
+
+struct _GskShaderPaintable
+{
+  GObject parent_instance;
+
+  GskGLShader *shader;
+  GBytes *args;
+
+  gint64 start_time;
+};
+
+struct _GskShaderPaintableClass
+{
+  GObjectClass parent_class;
+};
+
+enum {
+  PROP_0,
+  PROP_SHADER,
+  PROP_ARGS,
+
+  N_PROPS,
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gsk_shader_paintable_paintable_snapshot (GdkPaintable *paintable,
+                                         GdkSnapshot  *snapshot,
+                                         double        width,
+                                         double        height)
+{
+  GskShaderPaintable *self = GSK_SHADER_PAINTABLE (paintable);
+
+  gtk_snapshot_push_gl_shader (snapshot, self->shader, &GRAPHENE_RECT_INIT(0, 0, width, height), g_bytes_ref (self->args));
+  gtk_snapshot_pop (snapshot);
+}
+
+static void
+gsk_shader_paintable_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->snapshot = gsk_shader_paintable_paintable_snapshot;
+}
+
+G_DEFINE_TYPE_EXTENDED (GskShaderPaintable, gsk_shader_paintable, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                               gsk_shader_paintable_paintable_init))
+
+static void
+gsk_shader_paintable_set_property (GObject      *object,
+                                   guint         prop_id,
+                                   const GValue *value,
+                                   GParamSpec   *pspec)
+
+{
+  GskShaderPaintable *self = GSK_SHADER_PAINTABLE (object);
+
+  switch (prop_id)
+    {
+    case PROP_SHADER:
+      gsk_shader_paintable_set_shader (self, g_value_get_object (value));
+      break;
+
+    case PROP_ARGS:
+      gsk_shader_paintable_set_args (self, g_value_get_boxed (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gsk_shader_paintable_get_property (GObject    *object,
+                                   guint       prop_id,
+                                   GValue     *value,
+                                   GParamSpec *pspec)
+{
+  GskShaderPaintable *self = GSK_SHADER_PAINTABLE (object);
+
+  switch (prop_id)
+    {
+    case PROP_SHADER:
+      g_value_set_object (value, self->shader);
+      break;
+
+    case PROP_ARGS:
+      g_value_set_boxed (value, self->args);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gsk_shader_paintable_finalize (GObject *object)
+{
+  GskShaderPaintable *self = GSK_SHADER_PAINTABLE (object);
+
+  g_clear_pointer (&self->args, g_bytes_unref);
+  g_clear_object (&self->shader);
+
+  G_OBJECT_CLASS (gsk_shader_paintable_parent_class)->finalize (object);
+}
+
+static void
+gsk_shader_paintable_class_init (GskShaderPaintableClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = gsk_shader_paintable_get_property;
+  gobject_class->set_property = gsk_shader_paintable_set_property;
+  gobject_class->finalize = gsk_shader_paintable_finalize;
+
+  properties[PROP_SHADER] =
+    g_param_spec_object ("shader", "Shader", "The shader",
+                         GSK_TYPE_GL_SHADER,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_ARGS] =
+    g_param_spec_boxed ("args", "Arguments", "The uniform arguments",
+                        G_TYPE_BYTES,
+                        G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gsk_shader_paintable_init (GskShaderPaintable *self)
+{
+}
+
+/**
+ * gsk_shader_paintable_new:
+ * @shader: (transfer full) (nullable): the shader to use
+ * @data: (transfer full) (nullable): uniform data
+ *
+ * Creates a paintable that uses the @shader to create
+ * pixels. The shader must not require input textures.
+ * If @data is %NULL, all uniform values are set to zero.
+ *
+ * Returns: (transfer full): a new `GskShaderPaintable`
+ */
+GdkPaintable *
+gsk_shader_paintable_new (GskGLShader *shader,
+                          GBytes      *data)
+{
+  GdkPaintable *ret;
+
+  g_return_val_if_fail (shader == NULL || GSK_IS_GL_SHADER (shader), NULL);
+
+  if (shader && !data)
+    {
+      int size = gsk_gl_shader_get_args_size (shader);
+      data = g_bytes_new_take (g_new0 (guchar, size), size);
+    }
+
+  ret = g_object_new (GSK_TYPE_SHADER_PAINTABLE,
+                      "shader", shader,
+                      "args", data,
+                      NULL);
+
+  g_clear_object (&shader);
+  g_clear_pointer (&data, g_bytes_unref);
+
+  return ret;
+}
+
+/**
+ * gsk_shader_paintable_set_shader:
+ * @self: a `GskShaderPaintable`
+ * @shader: the `GskGLShader` to use
+ *
+ * Sets the shader that the paintable will use
+ * to create pixels. The shader must not require
+ * input textures.
+ */
+void
+gsk_shader_paintable_set_shader (GskShaderPaintable *self,
+                                 GskGLShader        *shader)
+{
+  g_return_if_fail (GSK_IS_SHADER_PAINTABLE (self));
+  g_return_if_fail (shader == NULL || GSK_IS_GL_SHADER (shader));
+  g_return_if_fail (shader == NULL || gsk_gl_shader_get_n_textures (shader) == 0);
+
+  if (!g_set_object (&self->shader, shader))
+    return;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SHADER]);
+  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+
+  g_clear_pointer (&self->args, g_bytes_unref);
+}
+
+/**
+ * gsk_shader_paintable_get_shader:
+ * @self: a `GskShaderPaintable`
+ *
+ * Returns the shader that the paintable is using.
+ *
+ * Returns: (transfer none): the `GskGLShader` that is used
+ */
+GskGLShader *
+gsk_shader_paintable_get_shader (GskShaderPaintable *self)
+{
+  g_return_val_if_fail (GSK_IS_SHADER_PAINTABLE (self), NULL);
+
+  return self->shader;
+}
+
+/**
+ * gsk_shader_paintable_set_args:
+ * @self: a `GskShaderPaintable`
+ * @data: Data block with uniform data for the shader
+ *
+ * Sets the uniform data that will be passed to the
+ * shader when rendering. The @data will typically
+ * be produced by a `GskUniformDataBuilder`.
+ *
+ * Note that the @data should be considered immutable
+ * after it has been passed to this function.
+ */
+void
+gsk_shader_paintable_set_args (GskShaderPaintable *self,
+                                       GBytes             *data)
+{
+  g_return_if_fail (GSK_IS_SHADER_PAINTABLE (self));
+  g_return_if_fail (data == NULL || g_bytes_get_size (data) == gsk_gl_shader_get_args_size (self->shader));
+
+  g_clear_pointer (&self->args, g_bytes_unref);
+  if (data)
+    self->args = g_bytes_ref (data);
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ARGS]);
+  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+}
+
+/**
+ * gsk_shader_paintable_get_args:
+ * @self: a `GskShaderPaintable`
+ *
+ * Returns the uniform data set with
+ * gsk_shader_paintable_get_args().
+ *
+ * Returns: (transfer none): the uniform data
+ */
+GBytes *
+gsk_shader_paintable_get_args (GskShaderPaintable *self)
+{
+  g_return_val_if_fail (GSK_IS_SHADER_PAINTABLE (self), NULL);
+
+  return self->args;
+}
+
+/**
+ * gsk_shader_paintable_update_time:
+ * @self: a `GskShaderPaintable`
+ * @time_idx: the index of the uniform for time in seconds as float
+ * @frame_time: the current frame time, as returned by `GdkFrameClock`
+ *
+ * This function is a convenience wrapper for
+ * gsk_shader_paintable_set_args() that leaves all
+ * uniform values unchanged, except for the uniform with
+ * index @time_idx, which will be set to the elapsed time
+ * in seconds, since the first call to this function.
+ *
+ * This function is usually called from a `GtkTickCallback`.
+ */
+void
+gsk_shader_paintable_update_time (GskShaderPaintable *self,
+                                  int                 time_idx,
+                                  gint64              frame_time)
+{
+  GskShaderArgsBuilder *builder;
+  GBytes *args;
+  float time;
+
+  if (self->start_time == 0)
+    self->start_time = frame_time;
+
+  time = (frame_time - self->start_time) / (float)G_TIME_SPAN_SECOND;
+
+  builder = gsk_shader_args_builder_new (self->shader, self->args);
+  gsk_shader_args_builder_set_float (builder, time_idx, time);
+  args = gsk_shader_args_builder_free_to_args (builder);
+
+  gsk_shader_paintable_set_args (self, args);
+
+  g_bytes_unref (args);
+}
+
+G_GNUC_END_IGNORE_DEPRECATIONS
--- a/demos/gtk-demo/gskshaderpaintable.h
+++ b/demos/gtk-demo/gskshaderpaintable.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2020 Red Hat, Inc.
+ *
+ * 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: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#pragma once
+
+#include <gdk/gdk.h>
+#include <gsk/gsk.h>
+
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_SHADER_PAINTABLE (gsk_shader_paintable_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskShaderPaintable, gsk_shader_paintable, GSK, SHADER_PAINTABLE, GObject)
+
+GdkPaintable *   gsk_shader_paintable_new              (GskGLShader        *shader,
+                                                        GBytes             *data);
+
+GskGLShader *    gsk_shader_paintable_get_shader       (GskShaderPaintable *self);
+void             gsk_shader_paintable_set_shader       (GskShaderPaintable *self,
+                                                        GskGLShader        *shader);
+GBytes *         gsk_shader_paintable_get_args         (GskShaderPaintable *self);
+void             gsk_shader_paintable_set_args         (GskShaderPaintable *self,
+                                                        GBytes             *data);
+void             gsk_shader_paintable_update_time      (GskShaderPaintable *self,
+                                                        int                 time_idx,
+                                                        gint64              frame_time);
+G_END_DECLS
+
+G_GNUC_END_IGNORE_DEPRECATIONS
--- a/demos/gtk-demo/gtkfishbowl.h
+++ b/demos/gtk-demo/gtkfishbowl.h
@@ -55,7 +55,7 @@ void       gtk_fishbowl_set_animating     (GtkFishbowl       *fishbowl,
                                           gboolean           animating);
 gboolean   gtk_fishbowl_get_benchmark     (GtkFishbowl       *fishbowl);
 void       gtk_fishbowl_set_benchmark     (GtkFishbowl       *fishbowl,
-                                           gboolean           benchmark);
+                                           gboolean           animating);
 double     gtk_fishbowl_get_framerate     (GtkFishbowl       *fishbowl);
 gint64     gtk_fishbowl_get_update_delay  (GtkFishbowl       *fishbowl);
 void       gtk_fishbowl_set_update_delay  (GtkFishbowl       *fishbowl,
--- a/demos/gtk-demo/gtkshaderbin.c
+++ b/demos/gtk-demo/gtkshaderbin.c
@@ -0,0 +1,268 @@
+#include "gtkshaderbin.h"
+
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+typedef struct {
+  GskGLShader *shader;
+  GtkStateFlags state;
+  GtkStateFlags state_mask;
+  float extra_border;
+  gboolean compiled;
+  gboolean compiled_ok;
+} ShaderInfo;
+
+struct _GtkShaderBin
+{
+  GtkWidget parent_instance;
+  GtkWidget *child;
+  ShaderInfo *active_shader;
+  GPtrArray *shaders;
+  guint tick_id;
+  float time;
+  float mouse_x, mouse_y;
+  gint64 first_frame_time;
+};
+
+struct _GtkShaderBinClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkShaderBin, gtk_shader_bin, GTK_TYPE_WIDGET)
+
+static void
+shader_info_free (ShaderInfo *info)
+{
+  g_object_unref (info->shader);
+  g_free (info);
+}
+
+static void
+gtk_shader_bin_finalize (GObject *object)
+{
+  GtkShaderBin *self = GTK_SHADER_BIN (object);
+
+  g_ptr_array_free (self->shaders, TRUE);
+
+  G_OBJECT_CLASS (gtk_shader_bin_parent_class)->finalize (object);
+}
+
+static void
+gtk_shader_bin_dispose (GObject *object)
+{
+  GtkShaderBin *self = GTK_SHADER_BIN (object);
+
+  g_clear_pointer (&self->child, gtk_widget_unparent);
+
+  G_OBJECT_CLASS (gtk_shader_bin_parent_class)->dispose (object);
+}
+
+static gboolean
+gtk_shader_bin_tick (GtkWidget     *widget,
+                     GdkFrameClock *frame_clock,
+                     gpointer       unused)
+{
+  GtkShaderBin *self = GTK_SHADER_BIN (widget);
+  gint64 frame_time;
+
+  frame_time = gdk_frame_clock_get_frame_time (frame_clock);
+  if (self->first_frame_time == 0)
+    self->first_frame_time = frame_time;
+  self->time = (frame_time - self->first_frame_time) / (float)G_USEC_PER_SEC;
+
+  gtk_widget_queue_draw (widget);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+motion_cb (GtkEventControllerMotion *controller,
+           double                    x,
+           double                    y,
+           GtkShaderBin             *self)
+{
+  self->mouse_x = x;
+  self->mouse_y = y;
+}
+
+static void
+gtk_shader_bin_init (GtkShaderBin *self)
+{
+  GtkEventController *controller;
+  self->shaders = g_ptr_array_new_with_free_func ((GDestroyNotify)shader_info_free);
+
+  controller = gtk_event_controller_motion_new ();
+  g_signal_connect (controller, "motion", G_CALLBACK (motion_cb), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+}
+
+void
+gtk_shader_bin_update_active_shader (GtkShaderBin *self)
+{
+  GtkStateFlags new_state = gtk_widget_get_state_flags (GTK_WIDGET (self));
+  ShaderInfo *new_shader = NULL;
+
+  for (int i = 0; i < self->shaders->len; i++)
+    {
+      ShaderInfo *info = g_ptr_array_index (self->shaders, i);
+
+      if ((info->state_mask & new_state) == info->state)
+        {
+          new_shader = info;
+          break;
+        }
+    }
+
+  if (self->active_shader == new_shader)
+    return;
+
+  self->active_shader = new_shader;
+  self->first_frame_time = 0;
+
+  if (self->active_shader)
+    {
+      if (self->tick_id == 0)
+        self->tick_id = gtk_widget_add_tick_callback (GTK_WIDGET (self),
+                                                      gtk_shader_bin_tick,
+                                                      NULL, NULL);
+    }
+  else
+    {
+      if (self->tick_id != 0)
+        {
+          gtk_widget_remove_tick_callback (GTK_WIDGET (self), self->tick_id);
+          self->tick_id = 0;
+        }
+    }
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+gtk_shader_bin_state_flags_changed (GtkWidget        *widget,
+                                    GtkStateFlags     previous_state_flags)
+{
+  GtkShaderBin *self = GTK_SHADER_BIN (widget);
+
+  gtk_shader_bin_update_active_shader (self);
+}
+
+void
+gtk_shader_bin_add_shader (GtkShaderBin *self,
+                           GskGLShader  *shader,
+                           GtkStateFlags state,
+                           GtkStateFlags state_mask,
+                           float         extra_border)
+{
+  ShaderInfo *info = g_new0 (ShaderInfo, 1);
+  info->shader = g_object_ref (shader);
+  info->state = state;
+  info->state_mask = state_mask;
+  info->extra_border = extra_border;
+
+  g_ptr_array_add (self->shaders, info);
+
+  gtk_shader_bin_update_active_shader (self);
+}
+
+void
+gtk_shader_bin_set_child (GtkShaderBin *self,
+                          GtkWidget    *child)
+{
+
+  if (self->child == child)
+    return;
+
+  g_clear_pointer (&self->child, gtk_widget_unparent);
+
+  if (child)
+    {
+      self->child = child;
+      gtk_widget_set_parent (child, GTK_WIDGET (self));
+    }
+}
+
+GtkWidget *
+gtk_shader_bin_get_child   (GtkShaderBin *self)
+{
+  return self->child;
+}
+
+static void
+gtk_shader_bin_snapshot (GtkWidget   *widget,
+                         GtkSnapshot *snapshot)
+{
+  GtkShaderBin *self = GTK_SHADER_BIN (widget);
+  int width, height;
+
+  width = gtk_widget_get_width (widget);
+  height = gtk_widget_get_height (widget);
+
+  if (self->active_shader)
+    {
+      if (!self->active_shader->compiled)
+        {
+          GtkNative *native = gtk_widget_get_native (widget);
+          GskRenderer *renderer = gtk_native_get_renderer (native);
+          GError *error = NULL;
+
+          self->active_shader->compiled = TRUE;
+          self->active_shader->compiled_ok =
+            gsk_gl_shader_compile (self->active_shader->shader,
+                                   renderer, &error);
+          if (!self->active_shader->compiled_ok)
+            {
+              g_warning ("GtkShaderBin failed to compile shader: %s", error->message);
+              g_error_free (error);
+            }
+        }
+
+      if (self->active_shader->compiled_ok)
+        {
+          float border = self->active_shader->extra_border;
+          graphene_vec2_t mouse;
+          graphene_vec2_init (&mouse, self->mouse_x + border, self->mouse_y + border);
+          gtk_snapshot_push_gl_shader (snapshot, self->active_shader->shader,
+                                       &GRAPHENE_RECT_INIT(-border, -border, width+2*border, height+2*border),
+                                       gsk_gl_shader_format_args (self->active_shader->shader,
+                                                                  "u_time", self->time,
+                                                                  "u_mouse", &mouse,
+                                                                  NULL));
+          gtk_widget_snapshot_child (widget, self->child, snapshot);
+          gtk_snapshot_gl_shader_pop_texture (snapshot);
+          gtk_snapshot_pop (snapshot);
+
+          return;
+        }
+    }
+
+  /* Non-shader fallback */
+  gtk_widget_snapshot_child (widget, self->child, snapshot);
+}
+
+static void
+gtk_shader_bin_class_init (GtkShaderBinClass *class)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = gtk_shader_bin_finalize;
+  object_class->dispose = gtk_shader_bin_dispose;
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+
+  widget_class->snapshot = gtk_shader_bin_snapshot;
+  widget_class->state_flags_changed = gtk_shader_bin_state_flags_changed;
+}
+
+GtkWidget *
+gtk_shader_bin_new (void)
+{
+  GtkShaderBin *self;
+
+  self = g_object_new (GTK_TYPE_SHADER_BIN, NULL);
+
+  return GTK_WIDGET (self);
+}
+
+G_GNUC_END_IGNORE_DEPRECATIONS
--- a/demos/gtk-demo/gtkshaderbin.h
+++ b/demos/gtk-demo/gtkshaderbin.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_SHADER_BIN      (gtk_shader_bin_get_type ())
+G_DECLARE_FINAL_TYPE (GtkShaderBin, gtk_shader_bin, GTK, SHADER_BIN, GtkWidget)
+
+GtkWidget  *gtk_shader_bin_new        (void);
+void        gtk_shader_bin_add_shader (GtkShaderBin *self,
+                                       GskGLShader  *shader,
+                                       GtkStateFlags state,
+                                       GtkStateFlags state_mask,
+                                       float         extra_border);
+void       gtk_shader_bin_set_child   (GtkShaderBin *self,
+                                       GtkWidget    *child);
+GtkWidget *gtk_shader_bin_get_child   (GtkShaderBin *self);
+
+G_END_DECLS
+
+G_GNUC_END_IGNORE_DEPRECATIONS
--- a/demos/gtk-demo/gtkshaderstack.c
+++ b/demos/gtk-demo/gtkshaderstack.c
@@ -0,0 +1,365 @@
+#include "gtkshaderstack.h"
+
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+struct _GtkShaderStack
+{
+  GtkWidget parent_instance;
+
+  GskGLShader *shader;
+  GPtrArray *children;
+  int current;
+  int next;
+  gboolean backwards;
+
+  guint tick_id;
+  float time;
+  float duration;
+  gint64 start_time;
+};
+
+struct _GtkShaderStackClass
+{
+  GtkWidgetClass parent_class;
+};
+
+
+enum {
+  PROP_DURATION = 1,
+  NUM_PROPERTIES
+};
+
+static GParamSpec *properties[NUM_PROPERTIES] = { NULL };
+
+G_DEFINE_TYPE (GtkShaderStack, gtk_shader_stack, GTK_TYPE_WIDGET)
+
+static void
+gtk_shader_stack_finalize (GObject *object)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (object);
+
+  g_object_unref (self->shader);
+
+  G_OBJECT_CLASS (gtk_shader_stack_parent_class)->finalize (object);
+}
+
+static void
+update_child_visible (GtkShaderStack *self)
+{
+  int i;
+
+  for (i = 0; i < self->children->len; i++)
+    {
+      GtkWidget *child = g_ptr_array_index (self->children, i);
+
+      gtk_widget_set_child_visible (child,
+                                    i == self->current || i == self->next);
+    }
+}
+
+static gboolean
+transition_cb (GtkWidget     *widget,
+               GdkFrameClock *clock,
+               gpointer       unused)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (widget);
+  gint64 frame_time;
+
+  frame_time = gdk_frame_clock_get_frame_time (clock);
+
+  if (self->start_time == 0)
+    self->start_time = frame_time;
+
+  self->time = (frame_time - self->start_time) / (float)G_USEC_PER_SEC;
+
+  gtk_widget_queue_draw (widget);
+
+  if (self->time >= self->duration)
+    {
+      self->current = self->next;
+      self->next = -1;
+
+      update_child_visible (self);
+
+      return G_SOURCE_REMOVE;
+    }
+  else
+    return G_SOURCE_CONTINUE;
+}
+
+static void
+start_transition (GtkShaderStack *self)
+{
+  self->start_time = 0;
+  self->tick_id = gtk_widget_add_tick_callback (GTK_WIDGET (self),
+                                                transition_cb,
+                                                NULL, NULL);
+}
+
+static void
+stop_transition (GtkShaderStack *self)
+{
+  if (self->tick_id != 0)
+    {
+      gtk_widget_remove_tick_callback (GTK_WIDGET (self), self->tick_id);
+      self->tick_id = 0;
+    }
+
+  if (self->next != -1)
+    self->current = self->next;
+  self->next = -1;
+
+  update_child_visible (self);
+}
+
+static void
+gtk_shader_stack_dispose (GObject *object)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (object);
+
+  stop_transition (self);
+
+  g_clear_pointer (&self->children, g_ptr_array_unref);
+
+  G_OBJECT_CLASS (gtk_shader_stack_parent_class)->dispose (object);
+}
+
+void
+gtk_shader_stack_transition (GtkShaderStack *self,
+                             gboolean forward)
+{
+  stop_transition (self);
+
+  self->backwards = !forward;
+  if (self->backwards)
+    self->next = (self->current + self->children->len - 1) % self->children->len;
+  else
+    self->next = (self->current + 1) % self->children->len;
+
+  update_child_visible (self);
+
+  start_transition (self);
+}
+
+static void
+gtk_shader_stack_init (GtkShaderStack *self)
+{
+  self->children = g_ptr_array_new_with_free_func ((GDestroyNotify)gtk_widget_unparent);
+  self->current = -1;
+  self->next = -1;
+  self->backwards = FALSE;
+  self->duration = 1.0;
+}
+
+static void
+gtk_shader_stack_measure (GtkWidget      *widget,
+                          GtkOrientation  orientation,
+                          int             for_size,
+                          int            *minimum,
+                          int            *natural,
+                          int            *minimum_baseline,
+                          int            *natural_baseline)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (widget);
+  int i;
+
+  *minimum = 0;
+  *natural = 0;
+
+  for (i = 0; i < self->children->len; i++)
+    {
+      GtkWidget *child = g_ptr_array_index (self->children, i);
+      int child_min, child_nat;
+
+      if (gtk_widget_get_visible (child))
+        {
+          gtk_widget_measure (child, orientation, for_size, &child_min, &child_nat, NULL, NULL);
+
+          *minimum = MAX (*minimum, child_min);
+          *natural = MAX (*natural, child_nat);
+        }
+    }
+}
+
+static void
+gtk_shader_stack_size_allocate (GtkWidget *widget,
+                                int        width,
+                                int        height,
+                                int        baseline)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (widget);
+  GtkAllocation child_allocation;
+  GtkWidget *child;
+  int i;
+
+  child_allocation.x = 0;
+  child_allocation.y = 0;
+  child_allocation.width = width;
+  child_allocation.height = height;
+
+  for (i = 0; i < self->children->len; i++)
+    {
+      child = g_ptr_array_index (self->children, i);
+      if (gtk_widget_get_visible (child))
+        gtk_widget_size_allocate (child, &child_allocation, -1);
+    }
+}
+
+static void
+gtk_shader_stack_snapshot (GtkWidget   *widget,
+                           GtkSnapshot *snapshot)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (widget);
+  int width, height;
+  GtkWidget *current, *next;
+
+  width = gtk_widget_get_width (widget);
+  height = gtk_widget_get_height (widget);
+
+  current = g_ptr_array_index (self->children, self->current);
+
+  if (self->next == -1)
+    {
+      gtk_widget_snapshot_child (widget, current, snapshot);
+    }
+  else
+    {
+      GtkNative *native = gtk_widget_get_native (widget);
+      GskRenderer *renderer = gtk_native_get_renderer (native);
+      float progress;
+
+      next = g_ptr_array_index (self->children, self->next);
+
+      progress = self->time / self->duration;
+
+      if (self->backwards)
+        {
+          GtkWidget *tmp = next;
+          next = current;
+          current = tmp;
+          progress = 1. - progress;
+        }
+
+      if (gsk_gl_shader_compile (self->shader, renderer, NULL))
+        {
+          gtk_snapshot_push_gl_shader (snapshot,
+                                       self->shader,
+                                       &GRAPHENE_RECT_INIT(0, 0, width, height),
+                                       gsk_gl_shader_format_args (self->shader,
+                                                                  "progress", progress,
+                                                                  NULL));
+
+          gtk_widget_snapshot_child (widget, current, snapshot);
+          gtk_snapshot_gl_shader_pop_texture (snapshot); /* current child */
+          gtk_widget_snapshot_child (widget, next, snapshot);
+          gtk_snapshot_gl_shader_pop_texture (snapshot); /* next child */
+          gtk_snapshot_pop (snapshot);
+        }
+      else
+        {
+          /* Non-shader fallback */
+          gtk_widget_snapshot_child (widget, current, snapshot);
+        }
+    }
+}
+
+static void
+gtk_shader_stack_get_property (GObject      *object,
+                               guint         prop_id,
+                               GValue       *value,
+                               GParamSpec   *pspec)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (object);
+
+  switch (prop_id)
+    {
+    case PROP_DURATION:
+      g_value_set_float (value, self->duration);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_shader_stack_set_property (GObject      *object,
+                               guint         prop_id,
+                               const GValue *value,
+                               GParamSpec   *pspec)
+{
+  GtkShaderStack *self = GTK_SHADER_STACK (object);
+
+  switch (prop_id)
+    {
+    case PROP_DURATION:
+      self->duration = g_value_get_float (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_shader_stack_class_init (GtkShaderStackClass *class)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = gtk_shader_stack_finalize;
+  object_class->dispose = gtk_shader_stack_dispose;
+  object_class->get_property = gtk_shader_stack_get_property;
+  object_class->set_property = gtk_shader_stack_set_property;
+
+  widget_class->snapshot = gtk_shader_stack_snapshot;
+  widget_class->measure = gtk_shader_stack_measure;
+  widget_class->size_allocate = gtk_shader_stack_size_allocate;
+
+  properties[PROP_DURATION] =
+      g_param_spec_float ("duration", "Duration", "Duration",
+                          0.1, 3.0, 1.0,
+                          G_PARAM_READWRITE);
+
+  g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
+}
+
+GtkWidget *
+gtk_shader_stack_new (void)
+{
+  return g_object_new (GTK_TYPE_SHADER_STACK, NULL);
+}
+
+void
+gtk_shader_stack_set_shader (GtkShaderStack *self,
+                             GskGLShader    *shader)
+{
+  g_set_object (&self->shader, shader);
+}
+
+void
+gtk_shader_stack_add_child (GtkShaderStack *self,
+                            GtkWidget      *child)
+{
+  g_ptr_array_add (self->children, child);
+  gtk_widget_set_parent (child, GTK_WIDGET (self));
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  if (self->current == -1)
+    self->current = 0;
+  else
+    gtk_widget_set_child_visible (child, FALSE);
+}
+
+void
+gtk_shader_stack_set_active (GtkShaderStack *self,
+                             int             index)
+{
+  stop_transition (self);
+  self->current = MIN (index, self->children->len);
+  update_child_visible (self);
+}
+
+G_GNUC_END_IGNORE_DEPRECATIONS
--- a/demos/gtk-demo/gtkshaderstack.h
+++ b/demos/gtk-demo/gtkshaderstack.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_SHADER_STACK     (gtk_shader_stack_get_type ())
+G_DECLARE_FINAL_TYPE (GtkShaderStack, gtk_shader_stack, GTK, SHADER_STACK, GtkWidget)
+
+GtkWidget * gtk_shader_stack_new          (void);
+void        gtk_shader_stack_set_shader   (GtkShaderStack *self,
+                                           GskGLShader    *shader);
+void        gtk_shader_stack_add_child    (GtkShaderStack *self,
+                                           GtkWidget      *child);
+void        gtk_shader_stack_transition   (GtkShaderStack *self,
+                                           gboolean        forward);
+void        gtk_shader_stack_set_active   (GtkShaderStack *self,
+                                           int             index);
+
+G_END_DECLS
+
+G_GNUC_END_IGNORE_DEPRECATIONS
--- a/demos/gtk-demo/hsla.h
+++ b/demos/gtk-demo/hsla.h
@@ -1,7 +1,5 @@
 #pragma once

-#include <gdk/gdk.h>
-
 typedef struct _GdkHSLA GdkHSLA;

 struct _GdkHSLA {
--- a/demos/gtk-demo/iconscroll.c
+++ b/demos/gtk-demo/iconscroll.c
@@ -13,7 +13,7 @@ static GtkWidget *window = NULL;
 static GtkWidget *scrolledwindow;
 static int selected;

-#define N_WIDGET_TYPES 9
+#define N_WIDGET_TYPES 8


 static int hincrement = 5;
@@ -73,77 +73,30 @@ populate_icons (void)
  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), grid);
 }

+static char *content;
+static gsize content_len;
+
 extern void fontify (const char *format, GtkTextBuffer *buffer);

-enum {
-  PLAIN_TEXT,
-  HIGHLIGHTED_TEXT,
-  UNDERLINED_TEXT,
-};
-
 static void
-underlinify (GtkTextBuffer *buffer)
-{
-  GtkTextTagTable *tags;
-  GtkTextTag *tag[3];
-  GtkTextIter start, end;
-
-  tags = gtk_text_buffer_get_tag_table (buffer);
-  tag[0] = gtk_text_tag_new ("error");
-  tag[1] = gtk_text_tag_new ("strikeout");
-  tag[2] = gtk_text_tag_new ("double");
-  g_object_set (tag[0], "underline", PANGO_UNDERLINE_ERROR, NULL);
-  g_object_set (tag[1], "strikethrough", TRUE, NULL);
-  g_object_set (tag[2],
-                "underline", PANGO_UNDERLINE_DOUBLE,
-                "underline-rgba", &(GdkRGBA){0., 1., 1., 1. },
-                NULL);
-  gtk_text_tag_table_add (tags, tag[0]);
-  gtk_text_tag_table_add (tags, tag[1]);
-  gtk_text_tag_table_add (tags, tag[2]);
-
-  gtk_text_buffer_get_start_iter (buffer, &end);
-
-  while (TRUE)
-    {
-      gtk_text_iter_forward_word_end (&end);
-      start = end;
-      gtk_text_iter_backward_word_start (&start);
-      gtk_text_buffer_apply_tag (buffer, tag[g_random_int_range (0, 3)], &start, &end);
-      if (!gtk_text_iter_forward_word_ends (&end, 3))
-        break;
-    }
-}
-
-static void
-populate_text (const char *resource, int kind)
+populate_text (gboolean highlight)
 {
  GtkWidget *textview;
  GtkTextBuffer *buffer;
-  char *content;
-  gsize content_len;
-  GBytes *bytes;

-  bytes = g_resources_lookup_data (resource, 0, NULL);
-  content = g_bytes_unref_to_data (bytes, &content_len);
+  if (!content)
+    {
+      GBytes *bytes;
+
+      bytes = g_resources_lookup_data ("/sources/font_features.c", 0, NULL);
+      content = g_bytes_unref_to_data (bytes, &content_len);
+    }

  buffer = gtk_text_buffer_new (NULL);
  gtk_text_buffer_set_text (buffer, content, (int)content_len);

-  switch (kind)
-    {
-    case HIGHLIGHTED_TEXT:
-      fontify ("c", buffer);
-      break;
-
-    case UNDERLINED_TEXT:
-      underlinify (buffer);
-      break;
-
-    case PLAIN_TEXT:
-    default:
-      break;
-    }
+  if (highlight)
+    fontify ("c", buffer);

  textview = gtk_text_view_new ();
  gtk_text_view_set_buffer (GTK_TEXT_VIEW (textview), buffer);
@@ -202,6 +155,14 @@ populate_image (void)
 {
  GtkWidget *image;

+  if (!content)
+    {
+      GBytes *bytes;
+
+      bytes = g_resources_lookup_data ("/sources/font_features.c", 0, NULL);
+      content = g_bytes_unref_to_data (bytes, &content_len);
+    }
+
  image = gtk_picture_new_for_resource ("/sliding_puzzle/portland-rose.jpg");
  gtk_picture_set_can_shrink (GTK_PICTURE (image), FALSE);

@@ -294,40 +255,35 @@ set_widget_type (int type)

    case 1:
      gtk_window_set_title (GTK_WINDOW (window), "Scrolling plain text");
-      populate_text ("/sources/font_features.c", PLAIN_TEXT);
+      populate_text (FALSE);
      break;

    case 2:
-      gtk_window_set_title (GTK_WINDOW (window), "Scrolling colored text");
-      populate_text ("/sources/font_features.c", HIGHLIGHTED_TEXT);
+      gtk_window_set_title (GTK_WINDOW (window), "Scrolling complex text");
+      populate_text (TRUE);
      break;

    case 3:
-      gtk_window_set_title (GTK_WINDOW (window), "Scrolling text with underlines");
-      populate_text ("/org/gtk/Demo4/Moby-Dick.txt", UNDERLINED_TEXT);
-      break;
-
-    case 4:
      gtk_window_set_title (GTK_WINDOW (window), "Scrolling text with Emoji");
      populate_emoji_text ();
      break;

-    case 5:
+    case 4:
      gtk_window_set_title (GTK_WINDOW (window), "Scrolling a big image");
      populate_image ();
      break;

-    case 6:
+    case 5:
      gtk_window_set_title (GTK_WINDOW (window), "Scrolling a list");
      populate_list ();
      break;

-    case 7:
+    case 6:
      gtk_window_set_title (GTK_WINDOW (window), "Scrolling a columned list");
      populate_list2 ();
      break;

-    case 8:
+    case 7:
      gtk_window_set_title (GTK_WINDOW (window), "Scrolling a grid");
      populate_grid ();
      break;
--- a/demos/gtk-demo/iconscroll.ui
+++ b/demos/gtk-demo/iconscroll.ui
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
  <object class="GtkWindow" id="window">
-    <property name="resizable">1</property>
+    <property name="resizable">0</property>
    <property name="default-width">500</property>
    <property name="default-height">500</property>
    <child type="titlebar">
--- a/demos/gtk-demo/image_scaling.c
+++ b/demos/gtk-demo/image_scaling.c
@@ -14,103 +14,6 @@
 #include <gtk/gtk.h>
 #include "demo3widget.h"

-static GtkWidget *window = NULL;
-static GCancellable *cancellable = NULL;
-
-static void
-load_texture (GTask        *task,
-              gpointer      source_object,
-              gpointer      task_data,
-              GCancellable *cable)
-{
-  GFile *file = task_data;
-  GdkTexture *texture;
-  GError *error = NULL;
-
-  texture = gdk_texture_new_from_file (file, &error);
-
-  if (texture)
-    g_task_return_pointer (task, texture, g_object_unref);
-  else
-    g_task_return_error (task, error);
-}
-
-static void
-set_wait_cursor (GtkWidget *widget)
-{
-  gtk_widget_set_cursor_from_name (GTK_WIDGET (gtk_widget_get_root (widget)), "wait");
-}
-
-static void
-unset_wait_cursor (GtkWidget *widget)
-{
-  gtk_widget_set_cursor (GTK_WIDGET (gtk_widget_get_root (widget)), NULL);
-}
-
-static void
-texture_loaded (GObject      *source,
-                GAsyncResult *result,
-                gpointer      data)
-{
-  GdkTexture *texture;
-  GError *error = NULL;
-
-  texture = g_task_propagate_pointer (G_TASK (result), &error);
-
-  if (!texture)
-    {
-      g_print ("%s\n", error->message);
-      g_error_free (error);
-      return;
-    }
-
-  if (!window)
-    {
-      g_object_unref (texture);
-      return;
-    }
-
-  unset_wait_cursor (GTK_WIDGET (data));
-
-  g_object_set (G_OBJECT (data), "texture", texture, NULL);
-}
-
-static void
-open_file_async (GFile     *file,
-                 GtkWidget *demo)
-{
-  GTask *task;
-
-  set_wait_cursor (demo);
-
-  task = g_task_new (demo, cancellable, texture_loaded, demo);
-  g_task_set_task_data (task, g_object_ref (file), g_object_unref);
-  g_task_run_in_thread (task, load_texture);
-  g_object_unref (task);
-}
-
-static void
-open_portland_rose (GtkWidget *button,
-                    GtkWidget *demo)
-{
-  GFile *file;
-
-  file = g_file_new_for_uri ("resource:///transparent/portland-rose.jpg");
-  open_file_async (file, demo);
-  g_object_unref (file);
-}
-
-static void
-open_large_image (GtkWidget *button,
-                  GtkWidget *demo)
-{
-  GFile *file;
-
-  file = g_file_new_for_uri ("resource:///org/gtk/Demo4/large-image.png");
-  open_file_async (file, demo);
-  g_object_unref (file);
-}
-
 static void
 file_opened (GObject      *source,
             GAsyncResult *result,
@@ -118,6 +21,7 @@ file_opened (GObject      *source,
 {
  GFile *file;
  GError *error = NULL;
+  GdkTexture *texture;

  file = gtk_file_dialog_open_finish (GTK_FILE_DIALOG (source), result, &error);

@@ -128,9 +32,17 @@ file_opened (GObject      *source,
      return;
    }

-  open_file_async (file, data);
-
+  texture = gdk_texture_new_from_file (file, &error);
  g_object_unref (file);
+  if (!texture)
+    {
+      g_print ("%s\n", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  g_object_set (G_OBJECT (data), "texture", texture, NULL);
+  g_object_unref (texture);
 }

 static void
@@ -204,26 +116,11 @@ transform_from (GBinding     *binding,
  return TRUE;
 }

-static void
-free_cancellable (gpointer data)
-{
-  g_cancellable_cancel (cancellable);
-  g_clear_object (&cancellable);
-}
-
-static gboolean
-cancel_load (GtkWidget *widget,
-             GVariant  *args,
-             gpointer   data)
-{
-  unset_wait_cursor (widget);
-  g_cancellable_cancel (G_CANCELLABLE (data));
-  return TRUE;
-}
-
 GtkWidget *
 do_image_scaling (GtkWidget *do_widget)
 {
+  static GtkWidget *window = NULL;
+
  if (!window)
    {
      GtkWidget *box;
@@ -233,7 +130,6 @@ do_image_scaling (GtkWidget *do_widget)
      GtkWidget *scale;
      GtkWidget *dropdown;
      GtkWidget *button;
-      GtkEventController *controller;

      window = gtk_window_new ();
      gtk_window_set_title (GTK_WINDOW (window), "Image Scaling");
@@ -242,20 +138,6 @@ do_image_scaling (GtkWidget *do_widget)
                              gtk_widget_get_display (do_widget));
      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);

-      cancellable = g_cancellable_new ();
-      g_object_set_data_full (G_OBJECT (window), "cancellable",
-                              cancellable, free_cancellable);
-
-      controller = gtk_shortcut_controller_new ();
-      gtk_shortcut_controller_add_shortcut (GTK_SHORTCUT_CONTROLLER (controller),
-                                            gtk_shortcut_new (
-                                                gtk_keyval_trigger_new (GDK_KEY_Escape, 0),
-                                                gtk_callback_action_new (cancel_load, cancellable, NULL)
-                                                ));
-      gtk_shortcut_controller_set_scope (GTK_SHORTCUT_CONTROLLER (controller),
-                                         GTK_SHORTCUT_SCOPE_GLOBAL);
-      gtk_widget_add_controller (window, controller);
-
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
      gtk_window_set_child (GTK_WINDOW (window), box);

@@ -274,22 +156,6 @@ do_image_scaling (GtkWidget *do_widget)
      g_signal_connect (button, "clicked", G_CALLBACK (open_file), widget);
      gtk_box_append (GTK_BOX (box2), button);

-      button = gtk_button_new ();
-      gtk_button_set_child (GTK_BUTTON (button),
-                            gtk_image_new_from_resource ("/org/gtk/Demo4/portland-rose-thumbnail.png"));
-      gtk_widget_add_css_class (button, "image-button");
-      gtk_widget_set_tooltip_text (button, "Portland Rose");
-      g_signal_connect (button, "clicked", G_CALLBACK (open_portland_rose), widget);
-      gtk_box_append (GTK_BOX (box2), button);
-
-      button = gtk_button_new ();
-      gtk_button_set_child (GTK_BUTTON (button),
-                            gtk_image_new_from_resource ("/org/gtk/Demo4/large-image-thumbnail.png"));
-      gtk_widget_add_css_class (button, "image-button");
-      gtk_widget_set_tooltip_text (button, "Large image");
-      g_signal_connect (button, "clicked", G_CALLBACK (open_large_image), widget);
-      gtk_box_append (GTK_BOX (box2), button);
-
      button = gtk_button_new_from_icon_name ("object-rotate-right-symbolic");
      gtk_widget_set_tooltip_text (button, "Rotate");
      g_signal_connect (button, "clicked", G_CALLBACK (rotate), widget);
@@ -325,9 +191,7 @@ do_image_scaling (GtkWidget *do_widget)
  if (!gtk_widget_get_visible (window))
    gtk_widget_set_visible (window, TRUE);
  else
-    {
-      gtk_window_destroy (GTK_WINDOW (window));
-    }
+    gtk_window_destroy (GTK_WINDOW (window));

  return window;
 }
--- a/demos/gtk-demo/kaleidoscope.glsl
+++ b/demos/gtk-demo/kaleidoscope.glsl
@@ -0,0 +1,41 @@
+uniform float progress;
+uniform sampler2D u_texture1;
+uniform sampler2D u_texture2;
+
+vec4 getFromColor (vec2 uv) {
+  return GskTexture(u_texture1, uv);
+}
+
+vec4 getToColor (vec2 uv) {
+  return GskTexture(u_texture2, uv);
+}
+
+// Source: https://gl-transitions.com/editor/kaleidoscope
+// Author: nwoeanhinnogaehr
+// License: MIT
+
+const float speed = 1.0;
+const float angle = 1.0;
+const float power = 1.5;
+
+vec4 transition(vec2 uv) {
+  vec2 p = uv.xy / vec2(1.0).xy;
+  vec2 q = p;
+  float t = pow(progress, power)*speed;
+  p = p -0.5;
+  for (int i = 0; i < 7; i++) {
+    p = vec2(sin(t)*p.x + cos(t)*p.y, sin(t)*p.y - cos(t)*p.x);
+    t += angle;
+    p = abs(mod(p, 2.0) - 1.0);
+  }
+  abs(mod(p, 1.0));
+  return mix(
+    mix(getFromColor(q), getToColor(q), progress),
+    mix(getFromColor(p), getToColor(p), progress), 1.0 - 2.0*abs(progress - 0.5));
+}
+
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv)
+{
+  fragColor = transition(uv);
+}
--- a/demos/gtk-demo/large-image-thumbnail.png
+++ b/demos/gtk-demo/large-image-thumbnail.png
--- a/demos/gtk-demo/large-image.png
+++ b/demos/gtk-demo/large-image.png
--- a/demos/gtk-demo/listview_clocks.c
+++ b/demos/gtk-demo/listview_clocks.c
@@ -355,28 +355,28 @@ create_clocks_model (void)
  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_identifier ("America/Los_Angeles"));
+  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 ("Xalapa", g_time_zone_new_identifier ("America/Mexico_City"));
+  clock = gtk_clock_new ("Xalapa", g_time_zone_new ("America/Mexico_City"));
  g_list_store_append (result, clock);
  g_object_unref (clock);
-  clock = gtk_clock_new ("Boston", g_time_zone_new_identifier ("America/New_York"));
+  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_identifier ("Europe/London"));
+  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_identifier ("Europe/Berlin"));
+  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_identifier ("Europe/Moscow"));
+  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_identifier ("Asia/Kolkata"));
+  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_identifier ("Asia/Shanghai"));
+  clock = gtk_clock_new ("Shanghai", g_time_zone_new ("Asia/Shanghai"));
  g_list_store_append (result, clock);
  g_object_unref (clock);

--- a/demos/gtk-demo/main.c
+++ b/demos/gtk-demo/main.c
@@ -156,6 +156,11 @@ gtk_demo_run (GtkDemo   *self,
  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;
 }

@@ -827,6 +832,9 @@ static gboolean
 demo_can_run (GtkWidget  *window,
              const char *name)
 {
+  if (name != NULL && strcmp (name, "gltransition") == 0)
+    return GSK_IS_GL_RENDERER (gtk_native_get_renderer (GTK_NATIVE (window)));
+
  return TRUE;
 }

@@ -1060,8 +1068,6 @@ command_line (GApplication            *app,

  window = gtk_application_get_windows (GTK_APPLICATION (app))->data;

-  gtk_window_set_icon_name (GTK_WINDOW (window), "org.gtk.Demo4");
-
  if (name == NULL)
    goto out;

--- a/demos/gtk-demo/meson.build
+++ b/demos/gtk-demo/meson.build
@@ -33,6 +33,7 @@ demos = files([
  'gears.c',
  'gestures.c',
  'glarea.c',
+  'gltransition.c',
  'headerbar.c',
  'hypertext.c',
  'iconscroll.c',
@@ -116,7 +117,10 @@ extra_demo_sources = files([
  'gtkfishbowl.c',
  'fontplane.c',
  'gtkgears.c',
+  'gtkshaderbin.c',
  'gtkshadertoy.c',
+  'gtkshaderstack.c',
+  'gskshaderpaintable.c',
  'hsla.c',
  'puzzlepiece.c',
  'bluroverlay.c',
--- a/demos/gtk-demo/nodewidget.h
+++ b/demos/gtk-demo/nodewidget.h
@@ -5,4 +5,4 @@
 #define NODE_TYPE_WIDGET (node_widget_get_type ())
 G_DECLARE_FINAL_TYPE (NodeWidget, node_widget, NODE, WIDGET, GtkWidget)

-GtkWidget * node_widget_new       (const char *resource);
+GtkWidget * node_widget_new       (const char *file);
--- a/demos/gtk-demo/path_fill.c
+++ b/demos/gtk-demo/path_fill.c
@@ -225,8 +225,7 @@ print_ready (GObject      *source,

  if (!g_output_stream_close (stream, NULL, &error))
    {
-      if (!g_error_matches (error, GTK_DIALOG_ERROR, GTK_DIALOG_ERROR_DISMISSED))
-        g_print ("Error from close: %s\n", error->message);
+      g_print ("Error from close: %s\n", error->message);
      g_error_free (error);
    }

--- a/demos/gtk-demo/portland-rose-thumbnail.png
+++ b/demos/gtk-demo/portland-rose-thumbnail.png
--- a/demos/gtk-demo/radial.glsl
+++ b/demos/gtk-demo/radial.glsl
@@ -0,0 +1,34 @@
+uniform float progress;
+uniform sampler2D u_texture1;
+uniform sampler2D u_texture2;
+
+vec4 getFromColor (vec2 uv) {
+  return GskTexture(u_texture1, uv);
+}
+
+vec4 getToColor (vec2 uv) {
+  return GskTexture(u_texture2, uv);
+}
+
+// Source: https://gl-transitions.com/editor/Radial
+// License: MIT
+// Author: Xaychru
+
+const float smoothness = 1.0;
+
+const float PI = 3.141592653589;
+
+vec4 transition(vec2 p) {
+  vec2 rp = p*2.-1.;
+  return mix(
+    getToColor(p),
+    getFromColor(p),
+    smoothstep(0., smoothness, atan(rp.y,rp.x) - (progress-.5) * PI * 2.5)
+  );
+}
+
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv)
+{
+  fragColor = transition(uv);
+}
--- a/demos/gtk-demo/ripple.glsl
+++ b/demos/gtk-demo/ripple.glsl
@@ -0,0 +1,43 @@
+uniform float u_time;
+uniform vec2 u_mouse;
+uniform sampler2D u_texture1;
+
+#define PI      3.141592654
+
+float decay(float v, float t)
+{
+  return v * (1.0 / (1.0 + t*t));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv)
+{
+  // Temporary to loop time every 1 sec
+  float time = u_time;
+  // we normalize all the effects according to the min height/width
+  float size = min(resolution.x, resolution.y);
+
+  // Animate one wave over size in 0.3 sec
+  float wave_speed = size / 0.3;
+  float wave_length = size / 1.0;
+  float wave_height = size  * 0.1;
+
+  vec2 center = u_mouse;
+  vec2 direction_from_center = fragCoord - center;
+  float distance_from_center = length(direction_from_center);
+
+  /* Normalize direction */
+  direction_from_center = direction_from_center / distance_from_center;
+
+  float propagation_length = time * wave_speed;
+
+  float t = (propagation_length - distance_from_center) / wave_length;
+  float offset_magnitude = 0.0;
+  if (t > 0.0)
+    offset_magnitude = decay(wave_height * sin(t * 2.0 * PI), t);
+
+  vec2 offset = direction_from_center * min(offset_magnitude, distance_from_center);
+  vec2 source = fragCoord - offset;
+
+  vec2 uv2 = source / resolution;
+  fragColor = GskTexture(u_texture1, vec2(uv2.x, 1.0-uv2.y));
+}
--- a/demos/gtk-demo/suggestionentry.h
+++ b/demos/gtk-demo/suggestionentry.h
@@ -43,7 +43,7 @@ GtkListItemFactory *
                suggestion_entry_get_factory        (SuggestionEntry     *self);

 void            suggestion_entry_set_use_filter     (SuggestionEntry     *self,
-                                                     gboolean             use_filter);
+                                                     gboolean             use_ilter);
 gboolean        suggestion_entry_get_use_filter     (SuggestionEntry     *self);

 void            suggestion_entry_set_expression     (SuggestionEntry     *self,
--- a/demos/gtk-demo/wind.glsl
+++ b/demos/gtk-demo/wind.glsl
@@ -0,0 +1,33 @@
+uniform float progress;
+uniform sampler2D u_texture1;
+uniform sampler2D u_texture2;
+
+vec4 getFromColor (vec2 uv) {
+  return GskTexture(u_texture1, uv);
+}
+
+vec4 getToColor (vec2 uv) {
+  return GskTexture(u_texture2, uv);
+}
+
+// Source: https://gl-transitions.com/editor/wind
+// Author: gre
+// License: MIT
+
+const float size = 0.2;
+
+float rand(vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+vec4 transition(vec2 p) {
+  float r = rand(vec2(0, p.y));
+  float m = smoothstep(0.0, -size, p.x*(1.0-size) + size*r - (progress * (1.0 + size)));
+  return mix(getFromColor(p), getToColor(p), m);
+}
+
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv)
+{
+  fragColor = transition(uv);
+}
--- a/demos/icon-browser/data/scalable/apps/org.gtk.IconBrowser4.svg
+++ b/demos/icon-browser/data/scalable/apps/org.gtk.IconBrowser4.svg
--- a/demos/icon-browser/data/symbolic/apps/org.gtk.IconBrowser4-symbolic.svg
+++ b/demos/icon-browser/data/symbolic/apps/org.gtk.IconBrowser4-symbolic.svg
@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:osb="http://www.openswatchbook.org/uri/2009/osb"
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   sodipodi:docname="org.gtk.IconBrowser4-symbolic.svg"
+   height="16.03125"
+   id="svg7384"
+   inkscape:version="0.92.4 5da689c313, 2019-01-14"
+   version="1.1"
+   width="16">
+  <metadata
+     id="metadata90">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title>Gnome Symbolic Icon Theme</dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <sodipodi:namedview
+     inkscape:bbox-paths="true"
+     bordercolor="#666666"
+     borderopacity="1"
+     inkscape:current-layer="layer9"
+     inkscape:cx="-2.5662459"
+     inkscape:cy="11.558672"
+     gridtolerance="10"
+     inkscape:guide-bbox="true"
+     guidetolerance="10"
+     id="namedview88"
+     inkscape:object-nodes="false"
+     inkscape:object-paths="false"
+     objecttolerance="10"
+     pagecolor="#555753"
+     inkscape:pageopacity="1"
+     inkscape:pageshadow="2"
+     showborder="true"
+     showgrid="false"
+     showguides="true"
+     inkscape:snap-bbox="true"
+     inkscape:snap-bbox-midpoints="false"
+     inkscape:snap-global="true"
+     inkscape:snap-grids="true"
+     inkscape:snap-nodes="true"
+     inkscape:snap-others="false"
+     inkscape:snap-to-guides="true"
+     inkscape:window-height="1375"
+     inkscape:window-maximized="1"
+     inkscape:window-width="2560"
+     inkscape:window-x="0"
+     inkscape:window-y="27"
+     inkscape:zoom="1">
+    <inkscape:grid
+       empspacing="2"
+       enabled="true"
+       id="grid4866"
+       originx="-203"
+       originy="-251.96875"
+       snapvisiblegridlinesonly="true"
+       spacingx="1"
+       spacingy="1"
+       type="xygrid"
+       visible="true" />
+  </sodipodi:namedview>
+  <title
+     id="title9167">Gnome Symbolic Icon Theme</title>
+  <defs
+     id="defs7386">
+    <linearGradient
+       id="linearGradient7212"
+       osb:paint="solid">
+      <stop
+         id="stop7214"
+         offset="0"
+         style="stop-color:#000000;stop-opacity:1;" />
+    </linearGradient>
+  </defs>
+  <g
+     inkscape:groupmode="layer"
+     id="layer9"
+     inkscape:label="apps"
+     style="display:inline"
+     transform="translate(-444.0002,35)">
+    <path
+       style="display:inline;opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;marker-start:none;marker-mid:none;marker-end:none;paint-order:normal;enable-background:new"
+       d="m 457.9846,-27.96875 v -3 h 1 l -3,-3 -3,3 h 1 v 3 z"
+       id="path2809"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="cccccccc" />
+    <path
+       style="display:inline;opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;marker-start:none;marker-mid:none;marker-end:none;paint-order:normal;enable-background:new"
+       d="m 451.9846,-23.96875 v 2 h 1 l 2,2 v -6 l -2,2 z"
+       id="path2811"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="ccccccc" />
+    <path
+       style="display:inline;opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;marker-start:none;marker-mid:none;marker-end:none;paint-order:normal;enable-background:new"
+       d="m 455.9846,-24.96875 v 4 c 0,0 1,-1 1,-2 0,-1.31515 -1,-2 -1,-2 z"
+       id="path2813"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="ccsc" />
+    <path
+       style="display:inline;opacity:1;vector-effect:none;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:bevel;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none;marker-start:none;marker-mid:none;marker-end:none;paint-order:normal;enable-background:new"
+       d="m 457.9846,-25.96875 v 6 c 0,0 1,-1.94591 1,-3 0,-1.05409 -1,-3 -1,-3 z"
+       id="path2815"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="ccsc" />
+    <path
+       inkscape:connector-curvature="0"
+       style="display:inline;opacity:1;fill:#000000;fill-opacity:1;stroke:none;stroke-width:2;enable-background:new"
+       d="m 450.53751,-25.96846 c 0.24647,0 0.44708,0.19694 0.44708,0.44708 v 0.0289 c -0.008,3.05189 -2.48438,5.5237 -5.53812,5.5237 h -0.0148 c -0.25145,0 -0.44711,-0.20581 -0.44711,-0.4615 v -0.46152 -0.92302 c 0,-0.25567 0.20581,-0.4615 0.4615,-0.4615 h 0.92302 c 0.25569,0 0.46152,0.20581 0.46152,0.4615 v 0.21634 c 1.18002,-0.41715 2.10674,-1.34386 2.52389,-2.52388 h -0.21635 c -0.25566,0 -0.4615,-0.20581 -0.4615,-0.46152 v -0.92302 c 0,-0.25567 0.20581,-0.4615 0.4615,-0.4615 h 0.46152 0.4615 0.44709 0.0148 0.0148 z"
+       id="rect5922-7-3" />
+    <g
+       id="g904-6"
+       transform="matrix(0.26785369,0,0,0.26785369,436.44908,-87.00581)"
+       style="display:inline;fill:#000000;fill-opacity:1;stroke-width:3.73338151;enable-background:new">
+      <path
+         sodipodi:nodetypes="csscccssssccccccsccsssssccccccsssss"
+         inkscape:connector-curvature="0"
+         style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:7.46676302;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+         d="m 37,198.00759 c -2.76142,0 -5,2.23858 -5,5 0,2.76142 2.23858,5 5,5 0.89216,0 1.71236,-0.27804 2.4375,-0.6875 l 3.9375,3.6875 -3.9375,3.6875 c -0.72514,-0.40946 -1.54534,-0.6875 -2.4375,-0.6875 -2.76142,0 -5,2.23858 -5,5 0,2.76142 2.23858,5 5,5 2.76142,0 5,-2.23858 5,-5 0,-0.45832 -0.072,-0.89082 -0.1874,-1.3125 l 4.25,-4.125 8.9374,8.4375 h 3 v -2 l -16.1875,-15.6875 c 0.1156,-0.42168 0.1874,-0.85418 0.1874,-1.3125 0,-2.76142 -2.23858,-5 -5,-5 z m 0,3 c 1.10456,0 2,0.89544 2,2 0,1.10456 -0.89544,2 -2,2 -1.10456,0 -2,-0.89544 -2,-2 0,-1.10456 0.89544,-2 2,-2 z m 18,-1 -7.875,7.4375 2.625,2.5625 8.25,-8 v -2 z m -18,17 c 1.10456,0 2,0.89544 2,2 0,1.10456 -0.89544,2 -2,2 -1.10456,0 -2,-0.89544 -2,-2 0,-1.10456 0.89544,-2 2,-2 z"
+         id="path1079-7" />
+    </g>
+  </g>
+</svg>
--- a/demos/icon-browser/iconbrowserapp.c
+++ b/demos/icon-browser/iconbrowserapp.c
@@ -139,8 +139,6 @@ icon_browser_app_activate (GApplication *app)
  if (g_strcmp0 (PROFILE, "devel") == 0)
    gtk_widget_add_css_class (GTK_WIDGET (win), "devel");

-  gtk_window_set_icon_name (GTK_WINDOW (win), "org.gtk.IconBrowser4");
-
  gtk_window_present (GTK_WINDOW (win));
 }

--- a/demos/meson.build
+++ b/demos/meson.build
@@ -3,7 +3,9 @@
 appdata_config = configuration_data()
 appdata_config.set('BUILD_VERSION', meson.project_version())

+subdir('constraint-editor')
 subdir('gtk-demo')
+subdir('icon-browser')
 subdir('node-editor')
 subdir('widget-factory')
 subdir('print-editor')
--- a/demos/node-editor/node-editor-application.c
+++ b/demos/node-editor/node-editor-application.c
@@ -219,8 +219,6 @@ node_editor_application_activate (GApplication *app)
  if (g_strcmp0 (PROFILE, "devel") == 0)
    gtk_widget_add_css_class (GTK_WIDGET (win), "devel");

-  gtk_window_set_icon_name (GTK_WINDOW (win), "org.gtk.gtk4.NodeEditor");
-
  gtk_window_present (GTK_WINDOW (win));
 }

--- a/demos/node-editor/node-editor-window.c
+++ b/demos/node-editor/node-editor-window.c
@@ -925,7 +925,7 @@ export_image_response_cb (GObject      *source,
      GdkTexture *texture;
      GskRenderer *renderer;

-      renderer = gsk_ngl_renderer_new ();
+      renderer = gsk_gl_renderer_new ();
      if (!gsk_renderer_realize_for_display (renderer, gdk_display_get_default (), NULL))
        {
          g_object_unref (renderer);
@@ -1205,19 +1205,6 @@ node_editor_window_add_renderer (NodeEditorWindow *self,
  g_object_unref (paintable);
 }

-static void
-update_paste_action (GdkClipboard *clipboard,
-                     GParamSpec   *pspec,
-                     gpointer      data)
-{
-  GtkWidget *widget = GTK_WIDGET (data);
-  gboolean has_node;
-
-  has_node = gdk_content_formats_contain_mime_type (gdk_clipboard_get_formats (clipboard), "application/x-gtk-render-node");
-
-  gtk_widget_action_set_enabled (widget, "paste-node", has_node);
-}
-
 static void
 node_editor_window_realize (GtkWidget *widget)
 {
@@ -1255,7 +1242,6 @@ node_editor_window_realize (GtkWidget *widget)
  self->after_paint_handler = g_signal_connect (frameclock, "after-paint",
                                                G_CALLBACK (after_paint), self);

-  g_signal_connect (gtk_widget_get_clipboard (widget), "notify::formats", G_CALLBACK (update_paste_action), widget);
 }

 static void
@@ -1265,8 +1251,6 @@ node_editor_window_unrealize (GtkWidget *widget)
  GdkFrameClock *frameclock;
  guint i;

-  g_signal_handlers_disconnect_by_func (gtk_widget_get_clipboard (widget), update_paste_action, widget);
-
  frameclock = gtk_widget_get_frame_clock (widget);
  g_signal_handler_disconnect (frameclock, self->after_paint_handler);
  self->after_paint_handler = 0;
@@ -1631,41 +1615,6 @@ edit_action_cb (GtkWidget  *widget,
  node_editor_window_edit (self, &start);
 }

-static void
-text_received (GObject      *source,
-               GAsyncResult *result,
-               gpointer      data)
-{
-  GdkClipboard *clipboard = GDK_CLIPBOARD (source);
-  NodeEditorWindow *self = NODE_EDITOR_WINDOW (data);
-  char *text;
-
-  text = gdk_clipboard_read_text_finish (clipboard, result, NULL);
-  if (text)
-    {
-      GtkTextBuffer *buffer;
-      GtkTextIter start, end;
-
-      buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->text_view));
-      gtk_text_buffer_begin_user_action (buffer);
-      gtk_text_buffer_get_bounds (buffer, &start, &end);
-      gtk_text_buffer_delete (buffer, &start, &end);
-      gtk_text_buffer_insert (buffer, &start, text, -1);
-      gtk_text_buffer_end_user_action (buffer);
-      g_free (text);
-    }
-}
-
-static void
-paste_node_cb (GtkWidget  *widget,
-               const char *action_name,
-               GVariant   *parameter)
-{
-  GdkClipboard *clipboard = gtk_widget_get_clipboard (widget);
-
-  gdk_clipboard_read_text_async (clipboard, NULL, text_received, widget);
-}
-
 static void
 node_editor_window_set_property (GObject      *object,
                                 guint         prop_id,
@@ -1778,13 +1727,6 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
  action = gtk_named_action_new ("smart-edit");
  shortcut = gtk_shortcut_new (trigger, action);
  gtk_widget_class_add_shortcut (widget_class, shortcut);
-
-  gtk_widget_class_install_action (widget_class, "paste-node", NULL, paste_node_cb);
-
-  trigger = gtk_keyval_trigger_new (GDK_KEY_v, GDK_CONTROL_MASK | GDK_SHIFT_MASK);
-  action = gtk_named_action_new ("paste-node");
-  shortcut = gtk_shortcut_new (trigger, action);
-  gtk_widget_class_add_shortcut (widget_class, shortcut);
 }

 static GtkWidget *
--- a/demos/node-editor/node-editor-window.ui
+++ b/demos/node-editor/node-editor-window.ui
@@ -22,10 +22,6 @@
  </menu>
  <menu id="extra_menu">
    <section>
-      <item>
-        <attribute name="label" translatable="yes">Paste _Node</attribute>
-        <attribute name="action">paste-node</attribute>
-      </item>
      <item>
        <attribute name="label" translatable="yes">Assisted _Edit</attribute>
        <attribute name="action">smart-edit</attribute>
--- a/demos/print-editor/print-editor.c
+++ b/demos/print-editor/print-editor.c
@@ -798,7 +798,7 @@ activate (GApplication *app)
  if (g_strcmp0 (PROFILE, "devel") == 0)
    gtk_widget_add_css_class (GTK_WIDGET (main_window), "devel");

-  gtk_window_set_icon_name (GTK_WINDOW (main_window), "org.gtk.PrintEditor4");
+  gtk_window_set_icon_name (GTK_WINDOW (main_window), "text-editor");
  gtk_window_set_default_size (GTK_WINDOW (main_window), 400, 600);
  gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (main_window), TRUE);
  update_title (GTK_WINDOW (main_window));
--- a/demos/widget-factory/widget-factory.c
+++ b/demos/widget-factory/widget-factory.c
@@ -2241,7 +2241,6 @@ activate (GApplication *app)
  if (g_strcmp0 (PROFILE, "devel") == 0)
    gtk_widget_add_css_class (GTK_WIDGET (window), "devel");

-  gtk_window_set_icon_name (window, "org.gtk.WidgetFactory4");
  gtk_application_add_window (GTK_APPLICATION (app), window);
  g_action_map_add_action_entries (G_ACTION_MAP (window),
                                   win_entries, G_N_ELEMENTS (win_entries),
--- a/docs/reference/README.md
+++ b/docs/reference/README.md
@@ -151,11 +151,10 @@ Checks whether the widget is set to be visible or not.
 - 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
-   `GtkClassName:prop-name`, and if its name does not match the naming scheme
-   `gtk_class_name_{g,s}et_prop_name`, you should add a `(set-property
-   prop-name)` or a `(get-property prop-name)` annotation to the method's
-   identifier
+ - If a method is a setter or a getter for an object property, you should
+   add an `(attributes org.gtk.Method.set_property=property-name)` or a
+   an `(attributes org.gtk.Method.get_property=property-name)` annotation
+   to the method's identifier
 - 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, you should use the
@@ -193,10 +192,9 @@ Checks whether the widget is set to be visible or not.
   purposes.
 - Always note if setting a property has side effects, like causing another
   property to change state.
- - If a property `GtkClassName:prop-name` has a public getter or setter, and
-   they do not match the naming scheme `gtk_class_name_{g,s}et_prop_name` you
-   should annotate it with the `(setter setter_function)` and `(getter
-   getter_function)`.
+ - If the property has public accessors you should annotate it with
+   the `(attributes org.gtk.Property.set=setter_function)` and
+   `(attributes org.gtk.Property.get=getter_function)` attributes
 - The syntax for property documentation is:

 ```c
--- a/docs/reference/gdk/meson.build
+++ b/docs/reference/gdk/meson.build
@@ -38,7 +38,7 @@ if get_option('documentation')
      gdk_gir[0],
    ],
    depends: gdk_gir[0],
-    suite: ['docs', 'failing'],
+    suite: ['docs'],
  )

  if x11_enabled
--- a/docs/reference/gtk/broadway.md
+++ b/docs/reference/gtk/broadway.md
@@ -1,16 +1,12 @@
 Title: The Broadway windowing system
 Slug: broadway

+## Using GTK with Broadway
+
 The GDK Broadway backend provides support for displaying GTK applications in
 a web browser, using HTML5 and web sockets.

-Broadway was written as an experiment and is not the most actively developed
-backend. It supports the features that were required of GDK backends in GTK 4.0,
-but may not be up-to-date with the latest developments.
-
-## Using GTK with Broadway
-
-To run your application under Broadway, first run the broadway server,
+To run your application in this way, first run the broadway server,
 `gtk-broadwayd`, that ships with GTK:

 ```
--- a/docs/reference/gtk/drawing-model.md
+++ b/docs/reference/gtk/drawing-model.md
@@ -66,8 +66,8 @@ The clock has several phases:
 - Layout
 - Paint

-The phases happen in this order and all phases will always run
-through before going back to the start.
+ 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
--- a/docs/reference/gtk/getting_started.md
+++ b/docs/reference/gtk/getting_started.md
@@ -66,6 +66,10 @@ You can compile the program above with GCC using:
 gcc $( pkg-config --cflags gtk4 ) -o example-0 example-0.c $( pkg-config --libs gtk4 )
 ```

+**Note**: If the above compilation does not work due to an error regarding `G_APPLICATION_DEFAULT_FLAGS`
+this could be due to your OS providing an older version of GLib. For GLib versions older than 2.74 you
+will need to replace `G_APPLICATION_DEFAULT_FLAGS` with `G_APPLICATION_FLAGS_NONE` in this example, and
+others in this documentation.
 For more information on how to compile a GTK application, please
 refer to the [Compiling GTK Applications](compiling.html)
 section in this reference.
--- a/docs/reference/gtk/gtk4-icon-browser.rst
+++ b/docs/reference/gtk/gtk4-icon-browser.rst
@@ -0,0 +1,32 @@
+.. _gtk4-icon-browser(1):
+
+=================
+gtk4-icon-browser
+=================
+
+-----------------
+List themed icons
+-----------------
+
+:Version: GTK
+:Manual section: 1
+:Manual group: GTK commands
+
+SYNOPSIS
+--------
+
+|   **gtk4-icon-browser** [OPTIONS...]
+
+DESCRIPTION
+-----------
+
+``gtk4-icon-browser`` is a utility to explore the icons in the current icon
+theme. It shows icons in various sizes, their symbolic variants where available,
+as well as a description of the icon and its context.
+
+OPTIONS
+-------
+
+``-h, --help``
+
+  Show the application help.
--- a/docs/reference/gtk/gtk4.toml.in
+++ b/docs/reference/gtk/gtk4.toml.in
@@ -260,4 +260,4 @@ name = "StyleProvider"
  hidden = true

 [check]
-ignore_deprecated = true
+skip_deprecated = true
--- a/docs/reference/gtk/meson.build
+++ b/docs/reference/gtk/meson.build
@@ -74,7 +74,7 @@ if get_option('documentation')
      gtk_gir[0],
    ],
    depends: gtk_gir[0],
-    suite: ['docs', 'failing'],
+    suite: ['docs'],
  )
 endif

@@ -98,6 +98,7 @@ if get_option('build-demos')
    [ 'gtk4-demo', '1', ],
    [ 'gtk4-demo-application', '1', ],
    [ 'gtk4-widget-factory', '1', ],
+    [ 'gtk4-icon-browser', '1', ],
    [ 'gtk4-node-editor', '1', ],
  ]
 endif
--- a/docs/reference/gtk/migrating-4to5.md
+++ b/docs/reference/gtk/migrating-4to5.md
@@ -24,36 +24,36 @@ the motivation and goals of larger API changes.
 ## Cell renderers are going away

 Cell renderers were introduced in GTK 2 to support rendering of
-“big data” UIs, in particular treeviews. Over the years, more
-“data-like” widgets have started to use them, and cell renderers
+"big data" UIs, in particular treeviews. Over the years, more
+"data-like" widgets have started to use them, and cell renderers
 have grown into a shadowy, alternative rendering infrastructure
 that duplicates much of what widgets do, while duplicating the
 code and adding their own dose of bugs.

-In GTK 4, replacement widgets for `GtkTreeView`, `GtkIconView` and
-`GtkComboBox` have appeared: [class@Gtk.ListView], [class@Gtk.ColumnView], [class@Gtk.GridView]
-and [class@Gtk.DropDown]. For GTK 5, we will take the next step and remove
+In GTK 4, replacement widgets for GtkTreeView, GtkIconView and
+GtkComboBox have appeared: GtkListView, GtkColumnView, GtkGridView
+and GtkDropDown. For GTK 5, we will take the next step and remove
 all cell renderer-based widgets.

 ## Themed rendering APIs are going away

 The old GTK 2 era rendering APIs for theme components like
-`gtk_render_frame()` or `gtk_render_check()` have not been used by
+gtk_render_frame() or gtk_render_check() have not been used by
 GTK itself even in later GTK 3, but they have been kept around
-for the benefit of “external drawing” users — applications that
+for the benefit of "external drawing" users - applications that
 want their controls to look like GTK without using widgets.

 Supporting this is increasingly getting in the way of making
 the GTK CSS machinery fast and correct. One notable problem is
-that temporary style changes (using `gtk_style_context_save()`)
+that temporary style changes (using gtk_style_context_save())
 is breaking animations. Therefore, these APIs will be going away
-in GTK 5, together with their more modern [class@Gtk.Snapshot] variants
-like `gtk_snapshot_render_background()` or `gtk_snapshot_render_focus()`.
+in GTK 5, together with their more modern GtkSnapshot variants
+like gtk_snapshot_render_background() or gtk_snapshot_render_focus().

 The best way to render parts of your widget using CSS styling
 is to use subwidgets. For example, to show a piece of text with
 fonts, effects and shadows according to the current CSS style,
-use a [class@Gtk.Label].
+use a GtkLabel.

 If you have a need for custom drawing that fits into the current
 (dark or light) theme, e.g. for rendering a graph, you can still
@@ -62,28 +62,28 @@ get the current style foreground color, using

 ## Local stylesheets are going away

-The cascading part of GTK’s CSS implementation is complicated by
+The cascading part of GTK's CSS implementation is complicated by
 the existence of local stylesheets (i.e. those added with
-`gtk_style_context_add_provider()`). And local stylesheets are
+gtk_style_context_add_provider()). And local stylesheets are
 unintuitive in that they do not apply to the whole subtree of
 widgets, but just to the one widget where the stylesheet was
 added.

-GTK 5 will no longer provide this functionality. The recommendation
-is to use a global stylesheet (i.e. [func@Gtk.StyleContext.add_provider_for_display])
+GTK 5 will no longer provide this functionality. The recommendations
+is to use a global stylesheet (i.e. gtk_style_context_add_provider_for_display())
 and rely on style classes to make your CSS apply only where desired.

 ## Non-standard CSS extensions are going away

-GTK’s CSS machinery has a some non-standard extensions around colors:
-named colors with `@define-color` and color functions: `lighter()`, `darker()`,
-`shade()`, `alpha()`, `mix()`.
+GTK's CSS machinery has a some non-standard extensions around colors:
+named colors with \@define-color and color functions: lighter(), darker(),
+shade(), alpha(), mix().

 GTK now implements equivalent functionality from the CSS specs.

-### `@define-color` is going away
+### \@define-color is going away

-`@define-color` should be replaced by custom properties in the `:root` scope.
+\@define-color should be replaced by custom properties in the :root scope.

 Instead of

@@ -117,9 +117,9 @@ spec.

 ### Color expressions are going away

-The color functions can all be replaced by combinations of `calc()` and `color-mix()`.
+The color functions can all be replaced by combinations of calc() and color-mix().

-`lighter(c)` and `darker(c)` are just `shade(c, 1.3)` or `shade(c, 0.7)`, respectively, and
+ligher(c) and darker(c) are just shade(c, 1.3) or shade(c, 0.7), respectively, and
 thus can be handled the same way as shade in the examples below.

 Replace
@@ -164,7 +164,7 @@ d {

 Variations of these replacements are possible.

-Note that GTK has historically computed `mix()` and `shade()` values in the SRGB and HSL
+Note that GTK has historically computed mix() and shade() values in the SRGB and HSL
 colorspaces, but using OKLAB instead might yield slightly better results.

 For more information about color-mix(), see the
@@ -172,32 +172,32 @@ For more information about color-mix(), see the

 ## Chooser interfaces are going away

-The `GtkColorChooser`, `GtkFontChooser`, `GtkFileChooser` and `GtkAppChooser`
+The GtkColorChooser, GtkFontChooser, GtkFileChooser and GtkAppChooser
 interfaces and their implementations as dialogs, buttons and widgets
 are phased out. The are being replaced by a new family of async APIs
 that will be more convenient to use from language bindings, in particular
 for languages that have concepts like promises. The new APIs are
 [class@Gtk.ColorDialog], [class@Gtk.FontDialog] and [class@Gtk.FileDialog],
-There are also equivalents for some of the “button” widgets:
+There are also equivalents for some of the 'button' widgets:
 [class@Gtk.ColorDialogButton], [class@Gtk.FontDialogButton].

 ## GtkMessageDialog is going away

-Like the Chooser interfaces, `GtkMessageDialog` has been replaced by
+Like the Chooser interfaces, GtkMessageDialog has been replaced by
 a new async API that will be more convenient, in particular for
 language binding. The new API is [class@Gtk.AlertDialog].

 ## GtkDialog is going away

-After `gtk_dialog_run()` was removed, the usefulness of `GtkDialog`
-is much reduced, and it has awkward, archaic APIs. Therefore,
+After gtk_dialog_run() was removed, the usefulness of GtkDialog
+is much reduced, and it has awkward, archaice APIs. Therefore,
 it is dropped. The recommended replacement is to just create
 your own window and add buttons as required, either in the header
 or elsewhere.

 ## GtkInfoBar is going away

-`GtkInfoBar` had a dialog API, and with dialogs going away, it was time to
+GtkInfoBar had a dialog API, and with dialogs going away, it was time to
 retire it. If you need such a widget, it is relatively trivial to create one
 using a [class@Gtk.Revealer] with labels and buttons.

@@ -205,11 +205,11 @@ Other libraries, such as libadwaita, may provide replacements as well.

 ## gtk_show_uri is being replaced

-Instead of `gtk_show_uri()`, you should use [class@Gtk.UriLauncher]or [class@Gtk.FileLauncher].
+Instead of gtk_show_uri(), you should use GtkUriLauncher or GtkFileLauncher.

 ## GtkStatusbar is going away

-This is an old fashioned widget that does not do all that much any more, since
+This is an oldfashioned widget that does not do all that much anymore, since
 it no longer has a resize handle for the window.

 ## GtkLockButton and GtkVolumeButton are going away
@@ -217,22 +217,22 @@ it no longer has a resize handle for the window.
 These are very specialized widgets that should better live with the application
 where they are used.

-## Widget size API changes
+## Widget size api changes

-The functions `gtk_widget_get_allocated_width()` and `gtk_widget_get_allocated_height()`
+The functions gtk_widget_get_allocated_width() and gtk_widget_get_allocated_height()
 are going away. In most cases, [method@Gtk.Widget.get_width] and [method@Gtk.Widget.get_height]
 are suitable replacements. Note that the semantics are slightly different though:
 the old functions return the size of the CSS border area, while the new functions return
 the size of the widgets content area. In places where this difference matters, you can
 use `gtk_widget_compute_bounds (widget, widget, &bounds)` instead.

-The function `gtk_widget_get_allocation()` is also going away. It does not have a direct
+The function gtk_widget_get_allocation() is also going away. It does not have a direct
 replacement, but the previously mentioned alternatives can be used for it too.

-The function `gtk_widget_get_allocated_baseline()` has been renamed to [method@Gtk.Widget.get_baseline].
+The function gtk_widget_get_allocated_baseline() has been renamed to [method@Gtk.Widget.get_baseline].

 ## Stop using GdkPixbuf

-GTK is moving away from `GdkPixbuf` as the primary API for transporting image data, in favor
-of [class@Gdk.Texture]. APIs that are accepting or returning `GdkPixbuf`s are being replaced by equivalent
-APIs using `GdkTexture` or [iface@Gdk.Paintable] objects.
+GTK is moving away from GdkPixbuf as the primary API for transporting image data, in favor
+of GdkTexture. APIs that are accepting or returning GdkPixbufs are being replaced by equivalent
+APIs using GdkTexture or GdkPaintable objects.
--- a/docs/reference/gtk/node-format.md
+++ b/docs/reference/gtk/node-format.md
@@ -6,7 +6,7 @@ The format is a text format that follows the [CSS syntax rules](https://drafts.c

 The grammar of a node text representation using [the CSS value definition syntax](https://drafts.csswg.org/css-values-3/#value-defs) looks like this:

-    document: <@-rule>*<node>
+    document: <@-rule>*<node>*
    @-rule: @cicp "name" { <property>* }
    node: container [ "name" ] { <document> } | <node-type> [ "name" ] { <property>* } | "name"
    property: <property-name>: <node> | <value> ;
@@ -49,16 +49,12 @@ The following properties can be set for custom color states:
 | primaries | `<integer>`      | 2        | always      |
 | transfer  | `<integer>`      | 2        | always      |
 | matrix    | `<integer>`      | 2        | always      |
-| range     | `<range>`        | full     | non-default |
+| range     | `narrow | full`  | full     | non-default |

 Note that the primaries, transfer and matrix properties always need
 to be specified, since GTK does not allow creating color state objects
 with these being set to 2 (== unspecified).

-Range can have the following values:
-
-    range: narrow | full
-
 # Colors

 Colors can be specified with a variation of the modern CSS color syntax:
@@ -70,16 +66,6 @@ The traditional syntax for sRGB colors still works as well:
    rgba(<number>, <number>, <number>, <number)
    rgb(<number, <number>, <number>)

-# Rectangles
-
-Rectangles can be specified just as four integers for x, y, width and height:
-
-    rect: <number> <number> <number> <number>
-
-Rounded rectangles use a CSS-like syntax:
-
-    rounded-rect: <rect> [ "/" <number>{1,4} [ "/" <number>{1,4} ] ]
-
 # Nodes

 ### container
@@ -96,13 +82,6 @@ The **container** node is a special node that allows specifying a list of child

 Creates a node like `gsk_blend_node_new()` with the given properties.

-Possible values for the mode property are:
-
-    blend-mode: normal | multiply | screen | overlay | darken |
-                lighten | color-dodge | color-burn | hard-light |
-                soft-light | difference | exclusion | color |
-                hue | saturation | luminosity
-
 ### blur

 | property | syntax           | default                | printed     |
@@ -181,21 +160,15 @@ matrix3d() production to specify all 16 values individually.

 ### conic-gradient

-| property          | syntax          | default        | printed     |
-| ----------------- | --------------- | -------------- | ----------- |
-| bounds            | `<rect>`        | 50             | always      |
-| center            | `<point>`       | 25, 25         | always      |
-| rotation          | `<number>`      | 0              | always      |
-| stops             | `<color-stop>`  | 0 #AF0, 1 #F0C | always      |
-| interpolation     | `<color-state>` | srgb           | non-default |
-| hue-interpolation | `<hue-interp>`  | shorter        | non-default |
+| property | syntax           | default                | printed     |
+| -------- | ---------------- | ---------------------- | ----------- |
+| bounds   | `<rect>`         | 50                     | always      |
+| center   | `<point>`        | 25, 25                 | always      |
+| rotation | `<number>`       | 0                      | always      |
+| stops    | `<color-stop>`   | 0 #AF0, 1 #F0C         | always      |

 Creates a node like `gsk_conic_gradient_node_new()` with the given properties.

-Possible values for the hue-interpolation property are:
-
-    hue-interpolation: shorter | longer | increasing | decreasing
-
 ### cross-fade

 | property | syntax           | default                | printed     |
@@ -228,10 +201,6 @@ Creates a node like `gsk_fill_node_new()` with the given properties.
 The default child node is the default color node, but created with the
 bounds of the path.

-Possible values for the fill-rule property are:
-
-    fill-rule: winding | even-odd
-
 ### glshader

 | property   | syntax             | default                | printed     |
@@ -264,14 +233,12 @@ Creates a node like `gsk_inset_shadow_node_new()` with the given properties.

 ### linear-gradient

-| property          | syntax          | default        | printed     |
-| ----------------- | --------------- | -------------- | ----------- |
-| bounds            | `<rect>`        | 50             | always      |
-| start             | `<point>`       | 0 0            | always      |
-| end               | `<point>`       | 0 50           | always      |
-| stops             | `<color-stop>`  | 0 #AF0, 1 #F0C | always      |
-| interpolation     | `<color-state>` | srgb           | non-default |
-| hue-interpolation | `<hue-interp>`  | shorter        | non-default |
+| property | syntax           | default                | printed     |
+| -------- | ---------------- | ---------------------- | ----------- |
+| bounds   | `<rect>`         | 50                     | always      |
+| start    | `<point>`        | 0 0                    | always      |
+| end      | `<point>`        | 0 50                   | always      |
+| stops    | `<color-stop>`   | 0 #AF0, 1 #F0C         | always      |

 Creates a node like `gsk_linear_gradient_node_new()` with the given properties.

@@ -285,10 +252,6 @@ Creates a node like `gsk_linear_gradient_node_new()` with the given properties.

 Creates a node like `gsk_mask_node_new()` with the given properties.

-Possible values for the mode property are:
-
-    mask-mode: alpha | inverted-alpha | luminance | inverted-luminance
-
 ### opacity

 | property | syntax           | default                | printed     |
@@ -313,27 +276,25 @@ Creates a node like `gsk_outset_shadow_node_new()` with the given properties.

 ### radial-gradient

-| property          | syntax          | default        | printed     |
-| ----------------- | --------------- | -------------- | ----------- |
-| bounds            | `<rect>`        | 50             | always      |
-| center            | `<point>`       | 25 25          | always      |
-| hradius           | `<number>`      | 25             | always      |
-| vradius           | `<number>`      | 25             | always      |
-| start             | `<number>`      | 0              | always      |
-| end               | `<number>`      | 1              | always      |
-| stops             | `<color-stop>`  | 0 #AF0, 1 #F0C | always      |
-| interpolation     | `<color-state>` | srgb           | non-default |
-| hue-interpolation | `<hue-interp>`  | shorter        | non-default |
+| property | syntax           | default                | printed     |
+| -------- | ---------------- | ---------------------- | ----------- |
+| bounds   | `<rect>`         | 50                     | always      |
+| center   | `<point>`        | 25 25                  | always      |
+| hradius  | `<number>`       | 25                     | always      |
+| vradius  | `<number>`       | 25                     | always      |
+| start    | `<number>`       | 0                      | always      |
+| end      | `<number>`       | 1                      | always      |
+| stops    | `<color-stop>`   | 0 #AF0, 1 #F0C         | always      |

 Creates a node like `gsk_radial_gradient_node_new()` with the given properties.

 ### repeat

-| property     | syntax     | default                | printed     |
-| ------------ | ---------- | ---------------------- | ----------- |
-| bounds       | `<rect>`   | *bounds of child node* | non-default |
-| child        | `<node>`   | color { }              | always      |
-| child-bounds | `<rect>`   | *bounds of child node* | non-default |
+| property    | syntax           | default                | printed     |
+| ----------- | ---------------- | ---------------------- | ----------- |
+| bounds      | `<rect>`         | *bounds of child node* | non-default |
+| child       | `<node>`         | color { }              | always      |
+| child-bounds| `<rect>`         | *bounds of child node* | non-default |

 Creates a node like `gsk_repeat_node_new()` with the given properties.

@@ -400,14 +361,6 @@ Creates a node like `gsk_stroke_node_new()` with the given properties.
 The default child node is the default color node, but created with the
 stroke bounds of the path.

-Possible values for the line-cap property are:
-
-    line-cap: butt | round | square
-
-Possible values for the line-join property are:
-
-    line-join: miter | round | bevel
-
 ### text

 | property     | syntax              | default             | printed     |
@@ -416,9 +369,9 @@ Possible values for the line-join property are:
 | font         | `<string>` `<url>`? | "Cantarell 15px"    | always      |
 | glyphs       | `<glyphs>`          | "Hello"             | always      |
 | offset       | `<point>`           | 0 0                 | non-default |
-| hint-style   | `<hint-style>`      | slight              | non-default |
+| hint-style   | `<hint style>`      | slight              | non-default |
 | antialias    | `<antialias>`       | gray                | non-default |
-| hint-metrics | `<hint-metrics>`    | off                 | non-default |
+| hint-metrics | `<hint metrics>`    | off                 | non-default |

 Creates a node like `gsk_text_node_new()` with the given properties.

@@ -433,17 +386,9 @@ be specified as well, like this: 40 10 0 0 color.
 If the given font does not exist or the given glyphs are invalid for the given
 font, an error node will be returned.

-Possible values for the hint-style property are:
-
-    hint-style: none | slight | full
-
-Possible value for the antialias property are:
-
-    antialias:  none | gray
-
-Possible value for hint-metrics are:
-
-    hint-metrics:  on | off
+Possible values for hint-style are none, slight or full.
+Possible value for antialias are none or gray.
+Possible value for hint-metrics are on or off.

 ### texture

@@ -469,15 +414,14 @@ representation for this texture is `url("data:image/png;base64,iVBORw0KGgoAAAANS
 | -------- | ---------------- | ---------------------- | ----------- |
 | bounds   | `<rect>`         | 50                     | always      |
 | texture  | `<url>`          | *see below*            | always      |
-| filter   | `filter`         | linear                 | non-default |
+| filter   | `filter`         | *see below*            | non-default |

 Creates a node like `gsk_texture_scale_node_new()` with the given properties.

 The default texture is a 10x10 checkerboard, just like for texture.

-Possible values for the filter property are:
-
-    filter: linear | nearest | trilinear
+The possible filter values are `linear`, `nearest` and `trilinear`, with
+`linear` being the default.

 ### transform

--- a/docs/reference/gtk/running.md
+++ b/docs/reference/gtk/running.md
@@ -19,7 +19,8 @@ be used for end-user configuration and customization.
 ### `GTK_DEBUG`

 This variable can be set to a list of debug options, which cause GTK to
-print out different types of debugging information.
+print out different types of debugging information. Some of these options
+are only available when GTK has been configured with `-Ddebug=true`.

 `actions`
 : Actions and menu models
@@ -64,7 +65,7 @@ print out different types of debugging information.
 : Layout managers

 `accessibility`
-: Accessibility state changes
+: Accessibility state changs

 A number of keys are influencing behavior instead of just logging:

@@ -168,7 +169,8 @@ The `loaders.cache` file is generated by the
 ### `GDK_DEBUG`

 This variable can be set to a list of debug options, which cause GDK to
-print out different types of debugging information.
+print out different types of debugging information. Some of these options
+are only available when GTK has been configured with `-Ddebug=true`.

 `misc`
 : Miscellaneous information
@@ -221,15 +223,36 @@ A number of options affect behavior instead of logging:
 : Force graphics offload for all textures, even when slower. This allows
  to debug offloading in the absence of dmabufs.

+`gl-disable`
+: Disable OpenGL support
+
 `gl-no-fractional`
 : Disable fractional scaling for OpenGL.

 `gl-debug`
 : Insert debugging information in OpenGL

+`gl-disable-gl`
+: Don't allow the use of OpenGL GL API. This forces GLES to be used
+
+`gl-disable-gles`
+: Don't allow the use of OpenGL GLES API. This forces GL to be used
+
 `gl-prefer-gl`
 : Prefer OpenGL over OpenGL ES. This was the default behavior before GTK 4.14.

+`gl-egl`
+: Use an EGL context on X11 or Windows
+
+`gl-glx`
+: Use GLX on X11
+
+`gl-wgl`
+: Use WGL on Windows
+
+`vulkan-disable`
+: Disable Vulkan support
+
 `vulkan-validate`
 : Load the Vulkan validation layer, if available

@@ -239,26 +262,27 @@ A number of options affect behavior instead of logging:
 `high-depth`
 : Use high bit depth rendering if possible

-`linear`
-: Enable linear rendering
-
-`hdr`
-: Force HDR rendering
-
 `no-vsync`
 : Repaint instantly (uses 100% CPU with animations)

+`dmabuf-disable`
+: Disable dmabuf support
+
 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`

 This variable can be set to a list of debug options, which cause GSK to
-print out different types of debugging information.
+print out different types of debugging information. Some of these options
+are only available when GTK has been configured with `-Ddebug=true`.

 `renderer`
 : General renderer information

+`opengl`
+: OpenGL renderer information
+
 `vulkan`
 : Check Vulkan errors

@@ -285,12 +309,12 @@ A number of options affect behavior instead of logging:
 `staging`
 : Use a staging image for texture upload (Vulkan only)

+`offload-disable`
+: Disable graphics offload to subsurfaces
+
 `cairo`
 : Overlay error pattern over cairo drawing (finds fallbacks)

-`occlusion`
-: Overlay highlight over areas optimized via occlusion culling
-
 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.

@@ -323,41 +347,6 @@ a `*`, which means: try all remaining backends. The special value
 backends. For more information about selecting backends,
 see the [func@Gdk.DisplayManager.get] function.

-### `GDK_DISABLE`
-
-This variable can be set to a list of values, which cause GDK to
-disable certain features.
-
-`gl`
-: Disable OpenGL support
-
-`gl-api`
-: Don't allow the use of OpenGL GL API. This forces GLES to be used
-
-`gles-api`
-: Don't allow the use of OpenGL GLES API. This forces GL to be used
-
-`egl`
-: Don't allow the use of an EGL context
-
-`glx`
-: Don't allow the use of GLX
-
-`wgl`
-: Don't allow the use of WGL
-
-`vulkan`
-: Disable Vulkan support
-
-`dmabuf`
-: Disable dmabuf support
-
-`offload`
-: Disable graphics offload to subsurfaces
-
-`color-mgmt`
-: Disable color management
-
 ### `GDK_GL_DISABLE`

 This variable can be set to a list of values, which cause GDK to
@@ -380,6 +369,13 @@ does not support them.
 `base-instance`
 :GL_EXT_base_instance

+### `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.
+
 ### `GDK_VULKAN_DISABLE`

 This variable can be set to a list of values, which cause GDK to
@@ -393,6 +389,15 @@ does not support them.
 `ycbr`
 : Do not support Ycbcr textures

+`descriptor-indexing`
+: Force slow descriptor set layout codepath
+
+`dynamic-indexing`
+: Hardcode small number of buffer and texture arrays
+
+`nonuniform-indexing`
+: Split draw calls to ensure uniform texture accesses
+
 `semaphore-export`
 : Disable sync of exported dmabufs

@@ -402,9 +407,6 @@ does not support them.
 `incremental-present`
 : Do not send damage regions

-`swapchain-maintenance`
-: Do not use advanced swapchain features
-
 The special value `all` can be used to turn on all values. The special
 value `help` can be used to obtain a list of all supported values.

@@ -423,8 +425,14 @@ using and the GDK backend supports them:
 `cairo`
 : Selects the fallback Cairo renderer

+`opengl`
+: Selects the default OpenGL renderer
+
+`gl`
+: Selects the "gl" OpenGL renderer
+
 `ngl`
-: Selects the OpenGL renderer
+: Selects the "ngl" OpenGL renderer

 `vulkan`
 : Selects the Vulkan renderer
@@ -453,12 +461,12 @@ using and the GDK backend supports them:
 This variable can be set to a list of values, which cause GSK to
 disable certain optimizations of the "ngl" and "vulkan" renderer.

+`uber`
+: Don't use the uber shader
+
 `clear`
 : Use shaders instead of vkCmdClearAttachment()/glClear()

-`merge`
-: USe one vkCmdDraw()/glDrawArrays() per operation
-
 `blit`
 : Use shaders instead of vkCmdBlit()/glBlitFramebuffer()

@@ -468,15 +476,6 @@ disable certain optimizations of the "ngl" and "vulkan" renderer.
 `mipmap`
 : Avoid creating mipmaps

-`to-image`
-: Don't fast-path creation of images for nodes
-
-`occlusion`
-: Disable occlusion culling via opacity tracking
-
-`repeat`
-: Repeat drawing operations instead of using offscreen and GL_REPEAT
-
 The special value `all` can be used to turn on all values. The special
 value `help` can be used to obtain a list of all supported values.

@@ -564,12 +563,6 @@ To enable the GTK inspector, you can use the <kbd>Control</kbd>+<kbd>Shift</kbd>
 <kbd>Control</kbd>+<kbd>Shift</kbd>+<kbd>D</kbd> keyboard shortcuts, or
 set the `GTK_DEBUG=interactive` environment variable.

-After opening the inspector, it listens for a few keyboard shortcuts that
-let you use its frame and event recording functionality without moving the
-focus away from the application window: <kbd>Super</kbd>+<kbd>R</kbd> turns
-the recording on and off, and <kbd>Super</kbd>+<kbd>C</kbd> records a single
-frame.
-
 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
@@ -580,7 +573,6 @@ the GTK inspector. The keyboard shortcuts can be disabled with the
 `enable-inspector-keybinding` key in the `org.gtk.Settings.Debug`
 GSettings schema.

-
 ## Profiling

 GTK supports profiling with sysprof. It exports timing information
--- a/docs/reference/gtk/section-accessibility.md
+++ b/docs/reference/gtk/section-accessibility.md
@@ -171,7 +171,7 @@ Each relation name is part of the `GtkAccessibleRelation` enumeration.
 | %GTK_ACCESSIBLE_RELATION_CONTROLS | “aria-controls” | a list of `GtkAccessible` |
 | %GTK_ACCESSIBLE_RELATION_DESCRIBED_BY | “aria-describedby” | a list of `GtkAccessible` |
 | %GTK_ACCESSIBLE_RELATION_DETAILS | “aria-details” | a list of `GtkAccessible` |
-| %GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE | “aria-errormessage” | a list of `GtkAccessible` |
+| %GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE | “aria-errormessage” | `GtkAccessible` |
 | %GTK_ACCESSIBLE_RELATION_FLOW_TO | “aria-flowto” | a list of `GtkAccessible` |
 | %GTK_ACCESSIBLE_RELATION_LABELLED_BY | “aria-labelledby” | a list of `GtkAccessible` |
 | %GTK_ACCESSIBLE_RELATION_OWNS | “aria-owns” | a list of `GtkAccessible` |
@@ -300,7 +300,7 @@ The attributes can also enhance the UI:

 ```c
 gtk_button_set_label (GTK_BUTTON (button), "Download");
-gtk_box_append (GTK_BOX (box), button);
+gtk_box_append (GTK_BOX (button), button);

 gtk_label_set_text (GTK_LABEL (label), "Final report.pdf");
 gtk_box_append (GTK_BOX (box), label);
--- a/docs/reference/gtk/tools.md
+++ b/docs/reference/gtk/tools.md
@@ -9,7 +9,6 @@ documentation in the form of man pages.
 - [gtk4-demo-application](gtk4-demo-application.html)
 - [gtk4-encode-symbolic-svg](gtk4-encode-symbolic-svg.html)
 - [gtk4-icon-browser](gtk4-icon-browser.html)
- - [gtk4-image-tool](gtk4-image-tool.html)
 - [gtk4-launch](gtk4-launch.html)
 - [gtk4-node-editor](gtk4-node-editor.html)
 - [gtk4-path-tool](gtk4-path-tool.html)
--- a/examples/builder.c
+++ b/examples/builder.c
@@ -49,7 +49,7 @@ main (int   argc,
  g_chdir (GTK_SRCDIR);
 #endif

-  GtkApplication *app = gtk_application_new ("org.gtk.example", G_APPLICATION_DEFAULT_FLAGS);
+  GtkApplication *app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);

  int status = g_application_run (G_APPLICATION (app), argc, argv);
--- a/examples/drawing.c
+++ b/examples/drawing.c
@@ -173,7 +173,7 @@ main (int    argc,
  GtkApplication *app;
  int status;

-  app = gtk_application_new ("org.gtk.example", G_APPLICATION_DEFAULT_FLAGS);
+  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);
--- a/examples/grid-packing.c
+++ b/examples/grid-packing.c
@@ -60,7 +60,7 @@ main (int    argc,
  GtkApplication *app;
  int status;

-  app = gtk_application_new ("org.gtk.example", G_APPLICATION_DEFAULT_FLAGS);
+  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);
--- a/examples/search-bar.c
+++ b/examples/search-bar.c
@@ -37,8 +37,10 @@ main (int argc,
 {
  GtkApplication *app;

-  app = gtk_application_new ("org.gtk.Example.GtkSearchBar", G_APPLICATION_DEFAULT_FLAGS);
-  g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL);
+  app = gtk_application_new ("org.gtk.Example.GtkSearchBar",
+      G_APPLICATION_FLAGS_NONE);
+  g_signal_connect (app, "activate",
+      G_CALLBACK (activate_cb), NULL);

  return g_application_run (G_APPLICATION (app), argc, argv);
 }
--- a/examples/window-default.c
+++ b/examples/window-default.c
@@ -19,7 +19,7 @@ main (int    argc,
  GtkApplication *app;
  int status;

-  app = gtk_application_new ("org.gtk.example", G_APPLICATION_DEFAULT_FLAGS);
+  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);
--- a/gdk/broadway/broadway-server.h
+++ b/gdk/broadway/broadway-server.h
@@ -111,7 +111,7 @@ gboolean            broadway_server_surface_translate         (BroadwayServer  *
                                                               int              dx,
                                                               int              dy);
 guint32             broadway_server_upload_texture            (BroadwayServer  *server,
-                                                               GBytes          *bytes);
+                                                               GBytes          *texture);
 void                broadway_server_release_texture           (BroadwayServer  *server,
                                                               guint32          id);
 cairo_surface_t   * broadway_server_create_surface            (int              width,
--- a/gdk/broadway/gdkprivate-broadway.h
+++ b/gdk/broadway/gdkprivate-broadway.h
@@ -56,7 +56,7 @@ void     _gdk_broadway_surface_translate          (GdkSurface *surface,
                                                   int        dx,
                                                   int        dy);
 gboolean _gdk_broadway_moveresize_handle_event    (GdkDisplay *display,
-                                                   BroadwayInputMsg *event);
+                                                   BroadwayInputMsg *msg);
 gboolean _gdk_broadway_moveresize_configure_done  (GdkDisplay *display,
                                                   GdkSurface  *surface);
 void     _gdk_broadway_roundtrip_notify           (GdkSurface  *surface,
--- a/gdk/broadway/gdksurface-broadway.c
+++ b/gdk/broadway/gdksurface-broadway.c
@@ -49,135 +49,6 @@

 G_DEFINE_TYPE (GdkBroadwaySurface, gdk_broadway_surface, GDK_TYPE_SURFACE)

-static void
-gdk_broadway_surface_toplevel_resize (GdkSurface *surface,
-                                      int         width,
-                                      int         height);
-
-static void
-gdk_broadway_surface_set_geometry_hints (GdkSurface        *surface,
-                                         const GdkGeometry *geometry,
-                                         GdkSurfaceHints    geom_mask);
-
-static void
-gdk_broadway_surface_move_resize_internal (GdkSurface *surface,
-                                           gboolean    with_move,
-                                           int         x,
-                                           int         y,
-                                           int         width,
-                                           int         height);
-
-static void
-compute_toplevel_size (GdkSurface *surface,
-                       gboolean    resizible,
-                       int        *width,
-                       int        *height)
-{
-  GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
-  GdkDisplay *display = gdk_surface_get_display (surface);
-  GdkMonitor *monitor;
-  GdkToplevelSize size;
-  int bounds_width, bounds_height;
-  GdkGeometry geometry;
-  GdkSurfaceHints mask;
-
-  monitor = gdk_display_get_monitor_at_surface (display, surface);
-  if (monitor)
-    {
-      GdkRectangle monitor_geometry;
-
-      gdk_monitor_get_geometry (monitor, &monitor_geometry);
-      bounds_width = monitor_geometry.width;
-      bounds_height = monitor_geometry.height;
-    }
-  else
-    {
-      bounds_width = G_MAXINT;
-      bounds_height = G_MAXINT;
-    }
-
-  gdk_toplevel_size_init (&size, bounds_width, bounds_height);
-  gdk_toplevel_notify_compute_size (GDK_TOPLEVEL (surface), &size);
-  g_warn_if_fail (size.width > 0);
-  g_warn_if_fail (size.height > 0);
-  *width = size.width;
-  *height = size.height;
-  impl->resizible = (impl->resizible && resizible);
-
-  if (impl->resizible)
-    {
-      geometry.min_width = size.min_width;
-      geometry.min_height = size.min_height;
-      mask = GDK_HINT_MIN_SIZE;
-    }
-  else
-    {
-      geometry.max_width = geometry.min_width = size.width;
-      geometry.max_height = geometry.min_height = size.height;
-      mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
-    }
-  gdk_broadway_surface_set_geometry_hints (surface, &geometry, mask);
-
-  if (!(surface->state & (GDK_TOPLEVEL_STATE_FULLSCREEN |
-                          GDK_TOPLEVEL_STATE_MAXIMIZED |
-                          GDK_TOPLEVEL_STATE_TILED |
-                          GDK_TOPLEVEL_STATE_TOP_TILED |
-                          GDK_TOPLEVEL_STATE_RIGHT_TILED |
-                          GDK_TOPLEVEL_STATE_BOTTOM_TILED |
-                          GDK_TOPLEVEL_STATE_LEFT_TILED |
-                          GDK_TOPLEVEL_STATE_MINIMIZED)))
-    {
-      gdk_surface_constrain_size (&geometry, mask,
-				  size.width, size.height,
-				  &size.width, &size.height);
-
-      if (impl->last_computed_width != size.width ||
-           impl->last_computed_height != size.height)
-        {
-          *width = size.width;
-          *height = size.height;
-          impl->last_computed_width = size.width;
-          impl->last_computed_height = size.height;
-
-	  gdk_broadway_surface_toplevel_resize (surface, *width, *height);
-        }
-    }
-
-  if (size.shadow.is_valid)
-    {
-      impl->shadow_left = size.shadow.left;
-      impl->shadow_right = size.shadow.right;
-      impl->shadow_top = size.shadow.top;
-      impl->shadow_bottom = size.shadow.bottom;
-    }
-}
-
-static gboolean
-compute_size_idle (gpointer user_data)
-{
-  GdkSurface *surface = user_data;
-  GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
-  int width, height;
-
-  impl->compute_size_source_id = 0;
-  compute_toplevel_size (surface, TRUE, &width, &height);
-
-  return G_SOURCE_REMOVE;
-}
-
-static void
-on_frame_clock_after_update (GdkFrameClock *clock,
-                             GdkSurface    *surface)
-{
-  GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
-
-  if (impl->compute_size_source_id)
-    {
-      g_clear_handle_id (&impl->compute_size_source_id, g_source_remove);
-      compute_size_idle (surface);
-    }
-}
-
 /* We need to flush in an idle rather than AFTER_PAINT, as the clock
   is frozen during e.g. surface resizes so the paint will not happen
   and the surface resize request is never flushed. */
@@ -241,8 +112,6 @@ connect_frame_clock (GdkSurface *surface)

  g_signal_connect (frame_clock, "before-paint",
                    G_CALLBACK (on_frame_clock_before_paint), surface);
-  g_signal_connect_after (frame_clock, "update",
-			  G_CALLBACK (on_frame_clock_after_update), surface);
  g_signal_connect (frame_clock, "after-paint",
                    G_CALLBACK (on_frame_clock_after_paint), surface);
 }
@@ -254,8 +123,6 @@ disconnect_frame_clock (GdkSurface *surface)

  g_signal_handlers_disconnect_by_func (frame_clock,
                                        on_frame_clock_before_paint, surface);
-  g_signal_handlers_disconnect_by_func (frame_clock,
-                                        on_frame_clock_after_update, surface);
  g_signal_handlers_disconnect_by_func (frame_clock,
                                        on_frame_clock_after_paint, surface);
 }
@@ -270,7 +137,6 @@ gdk_broadway_surface_constructed (GObject *object)
  if (!surface->parent)
    broadway_display->toplevels = g_list_prepend (broadway_display->toplevels, self);

-  self->resizible = TRUE;
  self->id = _gdk_broadway_server_new_surface (broadway_display->server,
                                               self->root_x,
                                               self->root_y,
@@ -450,7 +316,6 @@ gdk_broadway_surface_hide (GdkSurface *surface)

  _gdk_broadway_surface_grab_check_unmap (surface,
                                         _gdk_broadway_server_get_next_serial (broadway_display->server));
-  g_clear_handle_id (&impl->compute_size_source_id, g_source_remove);

  if (_gdk_broadway_server_surface_hide (broadway_display->server, impl->id))
    queue_flush (surface);
@@ -1144,8 +1009,6 @@ _gdk_broadway_moveresize_configure_done (GdkDisplay *display,
  BroadwayInputMsg *tmp_event;
  MoveResizeData *mv_resize = get_move_resize_data (display, FALSE);

-  gdk_surface_request_layout (surface);
-
  if (!mv_resize || surface != mv_resize->moveresize_surface)
    return FALSE;

@@ -1305,43 +1168,6 @@ gdk_broadway_surface_beep (GdkSurface *surface)
  return FALSE;
 }

-static void
-gdk_broadway_surface_request_layout (GdkSurface *surface)
-{
-  GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
-
-  if (!impl->compute_size_source_id &&
-      GDK_IS_TOPLEVEL (surface))
-    {
-      impl->compute_size_source_id = g_idle_add_full (G_PRIORITY_HIGH - 10,
-                                                      compute_size_idle,
-                                                      surface,
-                                                      NULL);
-    }
-}
-
-static gboolean
-gdk_broadway_surface_compute_size (GdkSurface *surface)
-{
-  int width, height;
-
-  if (GDK_IS_TOPLEVEL (surface))
-    {
-      compute_toplevel_size (surface, TRUE, &width, &height);
-    }
-  else
-    {
-      width = gdk_surface_get_width(surface);
-      height = gdk_surface_get_height(surface);
-
-      gdk_broadway_surface_move_resize_internal (surface, FALSE,
-						 0, 0,
-						 width,
-						 height);
-    }
-  return FALSE;
-}
-
 static void
 gdk_broadway_surface_class_init (GdkBroadwaySurfaceClass *klass)
 {
@@ -1361,8 +1187,6 @@ gdk_broadway_surface_class_init (GdkBroadwaySurfaceClass *klass)
  impl_class->destroy_notify = gdk_broadway_surface_destroy_notify;
  impl_class->drag_begin = _gdk_broadway_surface_drag_begin;
  impl_class->get_scale = gdk_broadway_surface_get_scale;
-  impl_class->request_layout = gdk_broadway_surface_request_layout;
-  impl_class->compute_size = gdk_broadway_surface_compute_size;
 }

 #define LAST_PROP 1
@@ -1680,12 +1504,55 @@ gdk_broadway_toplevel_present (GdkToplevel       *toplevel,
                               GdkToplevelLayout *layout)
 {
  GdkSurface *surface = GDK_SURFACE (toplevel);
+  GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
+  GdkDisplay *display = gdk_surface_get_display (surface);
+  GdkMonitor *monitor;
+  GdkToplevelSize size;
+  int bounds_width, bounds_height;
  int width, height;
+  GdkGeometry geometry;
+  GdkSurfaceHints mask;
  gboolean maximize;

  gdk_broadway_surface_unminimize (surface);

-  compute_toplevel_size (surface, gdk_toplevel_layout_get_resizable (layout), &width, &height);
+  monitor = gdk_display_get_monitor_at_surface (display, surface);
+  if (monitor)
+    {
+      GdkRectangle monitor_geometry;
+
+      gdk_monitor_get_geometry (monitor, &monitor_geometry);
+      bounds_width = monitor_geometry.width;
+      bounds_height = monitor_geometry.height;
+    }
+  else
+    {
+      bounds_width = G_MAXINT;
+      bounds_height = G_MAXINT;
+    }
+
+  gdk_toplevel_size_init (&size, bounds_width, bounds_height);
+  gdk_toplevel_notify_compute_size (toplevel, &size);
+  g_warn_if_fail (size.width > 0);
+  g_warn_if_fail (size.height > 0);
+  width = size.width;
+  height = size.height;
+
+  if (gdk_toplevel_layout_get_resizable (layout))
+    {
+      geometry.min_width = size.min_width;
+      geometry.min_height = size.min_height;
+      mask = GDK_HINT_MIN_SIZE;
+    }
+  else
+    {
+      geometry.max_width = geometry.min_width = width;
+      geometry.max_height = geometry.min_height = height;
+      mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
+    }
+  gdk_broadway_surface_set_geometry_hints (surface, &geometry, mask);
+  gdk_surface_constrain_size (&geometry, mask, width, height, &width, &height);
+  gdk_broadway_surface_toplevel_resize (surface, width, height);

  if (gdk_toplevel_layout_get_maximized (layout, &maximize))
    {
@@ -1695,7 +1562,14 @@ gdk_broadway_toplevel_present (GdkToplevel       *toplevel,
        gdk_broadway_surface_unmaximize (surface);
    }

-  gdk_surface_request_layout (surface);
+  if (size.shadow.is_valid)
+    {
+      impl->shadow_left = size.shadow.left;
+      impl->shadow_right = size.shadow.right;
+      impl->shadow_top = size.shadow.top;
+      impl->shadow_bottom = size.shadow.bottom;
+    }
+
  show_surface (surface);
 }

--- a/gdk/broadway/gdksurface-broadway.h
+++ b/gdk/broadway/gdksurface-broadway.h
@@ -76,13 +76,6 @@ struct _GdkBroadwaySurface
  int shadow_right;
  int shadow_top;
  int shadow_bottom;
-
-  int last_computed_width;
-  int last_computed_height;
-
-  guint compute_size_source_id;
-
-  gboolean resizible;
 };

 struct _GdkBroadwaySurfaceClass
--- a/gdk/filetransferportalprivate.h
+++ b/gdk/filetransferportalprivate.h
@@ -17,7 +17,6 @@

 #pragma once

-#include <gio/gio.h>

 void     file_transfer_portal_register              (void);

--- a/gdk/gdk.c
+++ b/gdk/gdk.c
@@ -133,35 +133,22 @@ static const GdkDebugKey gdk_debug_keys[] = {
  { "portals",         GDK_DEBUG_PORTALS, "Force use of portals" },
  { "no-portals",      GDK_DEBUG_NO_PORTALS, "Disable use of portals" },
  { "force-offload",   GDK_DEBUG_FORCE_OFFLOAD, "Force graphics offload for all textures" },
+  { "gl-disable",      GDK_DEBUG_GL_DISABLE, "Disable OpenGL support" },
  { "gl-no-fractional", GDK_DEBUG_GL_NO_FRACTIONAL, "Disable fractional scaling for OpenGL" },
  { "gl-debug",        GDK_DEBUG_GL_DEBUG, "Insert debugging information in OpenGL" },
+  { "gl-disable-gl",   GDK_DEBUG_GL_DISABLE_GL, "Only allow OpenGL GLES API" },
+  { "gl-disable-gles", GDK_DEBUG_GL_DISABLE_GLES, "Don't allow OpenGL GLES API" },
  { "gl-prefer-gl",    GDK_DEBUG_GL_PREFER_GL, "Prefer GL over GLES API" },
+  { "gl-egl",          GDK_DEBUG_GL_EGL, "Use EGL on X11 or Windows" },
+  { "gl-glx",          GDK_DEBUG_GL_GLX, "Use GLX on X11" },
+  { "gl-wgl",          GDK_DEBUG_GL_WGL, "Use WGL on Windows" },
+  { "vulkan-disable",  GDK_DEBUG_VULKAN_DISABLE, "Disable Vulkan support" },
  { "default-settings",GDK_DEBUG_DEFAULT_SETTINGS, "Force default values for xsettings" },
  { "high-depth",      GDK_DEBUG_HIGH_DEPTH, "Use high bit depth rendering if possible" },
  { "no-vsync",        GDK_DEBUG_NO_VSYNC, "Repaint instantly (uses 100% CPU with animations)" },
+  { "dmabuf-disable",  GDK_DEBUG_DMABUF_DISABLE, "Disable dmabuf support" },
 };

-static const GdkDebugKey gdk_feature_keys[] = {
-  { "gl",         GDK_FEATURE_OPENGL,           "Disable OpenGL support" },
-  { "gl-api",     GDK_FEATURE_GL_API,           "Disable non-GLES GL API" },
-  { "gles-api",   GDK_FEATURE_GLES_API,         "Disable GLES GL API" },
-  { "egl",        GDK_FEATURE_EGL,              "Disable EGL" },
-  { "glx",        GDK_FEATURE_GLX,              "Disable GLX" },
-  { "wgl",        GDK_FEATURE_WGL,              "Disable WGL" },
-  { "vulkan",     GDK_FEATURE_VULKAN,           "Disable Vulkan support" },
-  { "dmabuf",     GDK_FEATURE_DMABUF,           "Disable dmabuf support" },
-  { "offload",    GDK_FEATURE_OFFLOAD,          "Disable graphics offload" },
-  { "color-mgmt", GDK_FEATURE_COLOR_MANAGEMENT, "Disable color management" },
-};
-
-
-static GdkFeatures gdk_features;
-
-gboolean
-gdk_has_feature (GdkFeatures features)
-{
-  return (features & gdk_features) == features;
-}

 #ifdef G_HAS_CONSTRUCTORS
 #ifdef G_DEFINE_CONSTRUCTOR_NEEDS_PRAGMA
@@ -229,7 +216,6 @@ gdk_ensure_resources (void)

 guint
 gdk_parse_debug_var (const char        *variable,
-                     const char        *docs,
                     const GdkDebugKey *keys,
                     guint              nkeys)
 {
@@ -290,7 +276,6 @@ gdk_parse_debug_var (const char        *variable,
        max_width = MAX (max_width, strlen (keys[i].key));
      max_width += 4;

-      fprintf (stderr, "%s\n", docs);
      fprintf (stderr, "Supported %s values:\n", variable);
      for (i = 0; i < nkeys; i++) {
        fprintf (stderr, "  %s%*s%s\n", keys[i].key, (int)(max_width - strlen (keys[i].key)), " ", keys[i].help);
@@ -318,26 +303,21 @@ gdk_parse_debug_var (const char        *variable,
 void
 gdk_pre_parse (void)
 {
-  GdkFeatures disabled_features;
-
  gdk_initialized = TRUE;

  gdk_ensure_resources ();

  _gdk_debug_flags = gdk_parse_debug_var ("GDK_DEBUG",
-      "GDK_DEBUG can be set to values that make GDK print out different\n"
-      "types of debugging information or change the behavior of GDK for\n"
-      "debugging purposes.\n",
-      gdk_debug_keys,
-      G_N_ELEMENTS (gdk_debug_keys));
+                                          gdk_debug_keys,
+                                          G_N_ELEMENTS (gdk_debug_keys));

-  disabled_features = gdk_parse_debug_var ("GDK_DISABLE",
-      "GDK_DISABLE can be set to values which cause GDK to disable\n"
-      "certain features.\n",
-      gdk_feature_keys,
-      G_N_ELEMENTS (gdk_feature_keys));
-
-  gdk_features = GDK_ALL_FEATURES & ~disabled_features;
+  /* These are global */
+  if (_gdk_debug_flags & GDK_DEBUG_GL_EGL)
+    gdk_gl_backend_use (GDK_GL_EGL);
+  else if (_gdk_debug_flags & GDK_DEBUG_GL_GLX)
+    gdk_gl_backend_use (GDK_GL_GLX);
+  else if (_gdk_debug_flags & GDK_DEBUG_GL_WGL)
+    gdk_gl_backend_use (GDK_GL_WGL);

 #ifndef G_HAS_CONSTRUCTORS
  stash_and_unset_environment ();
--- a/gdk/gdkapplaunchcontext.c
+++ b/gdk/gdkapplaunchcontext.c
@@ -120,7 +120,7 @@ gdk_app_launch_context_class_init (GdkAppLaunchContextClass *klass)
  context_class->launch_failed = gdk_app_launch_context_launch_failed;

  /**
-   * GdkAppLaunchContext:display:
+   * GdkAppLaunchContext:display: (attributes org.gtk.Property.get=gdk_app_launch_context_get_display)
   *
   * The display that the `GdkAppLaunchContext` is on.
   */
@@ -169,7 +169,7 @@ gdk_app_launch_context_get_display_name (GAppLaunchContext *context,
 }

 /**
- * gdk_app_launch_context_get_display:
+ * gdk_app_launch_context_get_display: (attributes org.gtk.Method.get_property=display)
 * @context: a `GdkAppLaunchContext`
 *
 * Gets the `GdkDisplay` that @context is for.
--- a/gdk/gdkcairocontext.c
+++ b/gdk/gdkcairocontext.c
@@ -82,10 +82,8 @@ gdk_cairo_context_cairo_create (GdkCairoContext *self)

  draw_context = GDK_DRAW_CONTEXT (self);

-G_GNUC_BEGIN_IGNORE_DEPRECATIONS
  if (!gdk_draw_context_is_in_frame (draw_context))
    return NULL;
-G_GNUC_END_IGNORE_DEPRECATIONS

  cr = GDK_CAIRO_CONTEXT_GET_CLASS (self)->cairo_create (self);

--- a/gdk/gdkcairoprivate.h
+++ b/gdk/gdkcairoprivate.h
@@ -122,18 +122,6 @@ gdk_cairo_pattern_add_color_stop_rgba_ccs (cairo_pattern_t *pattern,
  cairo_pattern_add_color_stop_rgba (pattern, offset, color[0], color[1], color[2], color[3]);
 }

-static inline void
-gdk_cairo_pattern_add_color_stop_color (cairo_pattern_t *pattern,
-                                        GdkColorState   *ccs,
-                                        double           offset,
-                                        const GdkColor  *color)
-{
-  float values[4];
-
-  gdk_color_to_float (color, ccs, values);
-  cairo_pattern_add_color_stop_rgba (pattern, offset, values[0], values[1], values[2], values[3]);
-}
-
 static inline void
 gdk_cairo_rect (cairo_t               *cr,
                const graphene_rect_t *rect)
--- a/gdk/gdkcicpparams.h
+++ b/gdk/gdkcicpparams.h
@@ -58,7 +58,7 @@ void            gdk_cicp_params_set_matrix_coefficients (GdkCicpParams    *self,
 /**
 * GdkCicpRange:
 * @GDK_CICP_RANGE_NARROW: The values use the range of 16-235 (for Y) and 16-240 for u and v.
- * @GDK_CICP_RANGE_FULL: The values use the full range.
+ * @GDK_CICO_RANGE_FULL: The values use the full range.
 *
 * The values of this enumeration describe whether image data uses
 * the full range of 8-bit values.
--- a/Show More
+++ b/Show More