Extend debug var support

Make our debug variable parser handle key=value strings, provided that a callback is provided for the key. This may be used in the future to accept settings like GDK_DEBUG=vsync=144fps
Merge branch 'wip/otte/for-main' into 'main'
2024-01-22 21:08:46 -05:00 · 2024-01-22 17:52:33 +00:00 · 2024-01-22 18:22:50 +01:00 · 2024-01-22 13:46:52 +00:00 · 2024-01-22 12:15:31 +00:00 · 2024-01-22 12:09:29 +00:00
1199 changed files with 143598 additions and 69634 deletions
@@ -26,12 +26,20 @@ 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
-  FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/gtk/fedora:v48"
+  FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/gtk/fedora:v49"

 workflow:
  rules:
-    - if: $CI_COMMIT_TAG
+    # run merge request pipelines
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    # do not run branch pipelines if corresponding merge requests exist...
+    # (this avoids duplicate pipelines)
+    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
+      when: never
+    # ...but otherwise run branch pipelines
    - if: $CI_COMMIT_BRANCH
+    # run tag pipelines
+    - if: $CI_COMMIT_TAG

 default:
  retry:
@@ -58,7 +66,8 @@ style-check-diff:
      junit:
        - "${CI_PROJECT_DIR}/_build/report-x11.xml"
        - "${CI_PROJECT_DIR}/_build/report-wayland.xml"
-        - "${CI_PROJECT_DIR}/_build/report-wayland_gles.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:
@@ -95,8 +104,9 @@ fedora-x86_64:
            ${FEATURE_FLAGS}
            _build
    - meson compile -C _build
-    - .gitlab-ci/run-tests.sh _build wayland
-    - .gitlab-ci/run-tests.sh _build wayland_gles
+    - .gitlab-ci/run-tests.sh _build x11 gtk
+    # only repeat test runs that are likely affected by test setups
+    - .gitlab-ci/run-tests.sh _build wayland_gl gtk:gdk,gtk:gsk-gl

 release-build:
  extends: .build-fedora-default
@@ -121,7 +131,9 @@ release-build:
    - meson install -C _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 x11
+    - .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
@@ -197,28 +209,44 @@ msys2-mingw64:
    paths:
      - "${CI_PROJECT_DIR}/_build/gtkdll.tar.gz"

-macos:
-  # Sadly, this fails regularly, and its failure is never enlightening
-  allow_failure: true
+macos-x86_64:
  rules:
+    # Do not run in forks as the runner is not available there.
    - if: $CI_PROJECT_NAMESPACE == "GNOME"
  stage: build
  tags:
-    - macos
+    - macosintel
  needs: []
+  variables:
+    MESON_FORCE_BACKTRACKE: 1
+    TMPDIR: /Users/Shared/work/tmp
+    SDKROOT: /opt/sdks/MacOSX10.13.4.sdk
+    PIP_CACHE_DIR: /Users/Shared/build/cache
+    PIPENV_CACHE_DIR: $PIP_CACHE_DIR
+    PYTHONPYCACHEPREFIX: $PIP_CACHE_DIR
+    EXTRA_MESON_FLAGS: "-Dgobject-introspection:werror=false"
  before_script:
+    # Not using ccache on purpose as it accelerates the build so much that it
+    # can trigger race conditions in the gobject-introspection subproject.
    - bash .gitlab-ci/show-info-osx.sh
-    - pip3 install --user meson~=1.0
-    - pip3 install --user ninja
-    - export PATH=/Users/gitlabrunner/Library/Python/3.7/bin:$PATH
-    - export MESON_FORCE_BACKTRACE=1
+    - /opt/macports/bin/python3.10 -m venv .venv
+    - ln -s /opt/cmake/CMake.app/Contents/bin/cmake .venv/bin
+    - ln -s /opt/pkg-config/bin/pkg-config .venv/bin
+    - ln -s /opt/bison/bin/bison .venv/bin
+    - source .venv/bin/activate
+    - pip3 install meson==1.2.0
+    - pip3 install ninja==1.11.1
+    - pip3 install /Users/Shared/build/pkgs/PyGObject-3.44.0-cp310-cp310-macosx_10_13_x86_64.whl
+                   /Users/Shared/build/pkgs/pycairo-1.23.0-cp310-cp310-macosx_10_13_x86_64.whl
  script:
-    - meson setup ${COMMON_MESON_FLAGS}
+    - meson setup
+            ${COMMON_MESON_FLAGS}
+            ${EXTRA_MESON_FLAGS}
            -Dx11-backend=false
            -Dbroadway-backend=true
            -Dmacos-backend=true
            -Dmedia-gstreamer=disabled
-            -Dintrospection=disabled
+            -Dintrospection=enabled
            -Dcpp_std=c++11
            -Dpixman:tests=disabled
            -Dlibjpeg-turbo:simd=disabled
@@ -399,11 +427,12 @@ asan-build:
            -Df16c=disabled
            _build
    - ninja -C _build
-    - .gitlab-ci/run-tests.sh _build wayland
-    - .gitlab-ci/run-tests.sh _build wayland_gles
-    - .gitlab-ci/run-tests.sh _build x11
+    - .gitlab-ci/run-tests.sh _build wayland gtk
  artifacts:
    when: always
+    reports:
+      junit:
+        - "${CI_PROJECT_DIR}/_build/report-wayland.xml"
    paths:
      - "${CI_PROJECT_DIR}/_build/meson-logs"

@@ -1,4 +1,4 @@
-FROM fedora:38
+FROM fedora:39

 RUN dnf -y install \
    adwaita-icon-theme \
@@ -19,6 +19,7 @@ flatpak build ${builddir} meson \
                --buildtype=debugoptimized \
                -Dx11-backend=true \
                -Dwayland-backend=true \
+                -Dvulkan=disabled \
                -Dbuild-tests=false \
                -Dbuild-testsuite=false \
                -Dbuild-examples=false \
@@ -27,7 +28,7 @@ flatpak build ${builddir} meson \
                -Ddemo-profile=devel \
                _flatpak_build

-flatpak build ${builddir} ninja -C _flatpak_build install
+flatpak build --env=CI_COMMIT_SHORT_SHA=$CI_COMMIT_SHORT_SHA ${builddir} ninja -C _flatpak_build install

 flatpak-builder \
        --user --disable-rofiles-fuse \
@@ -324,7 +324,7 @@ for line in args.infile:
    units.append(unit)

 report = {}
-report['date'] = datetime.datetime.utcnow()
+report['date'] = datetime.datetime.now(datetime.UTC)
 report['locale_date'] = report['date'].strftime("%c")
 report['project_name'] = args.project_name
 report['backend'] = args.backend
@@ -44,7 +44,7 @@ outfile = args.output
 testsuites = ET.Element('testsuites')
 testsuites.set('id', '{}/{}'.format(args.job_id, args.branch))
 testsuites.set('package', args.project_name)
-testsuites.set('timestamp', datetime.datetime.utcnow().isoformat(timespec='minutes'))
+testsuites.set('timestamp', datetime.datetime.now(datetime.UTC).isoformat(timespec='minutes'))

 suites = {}
 for line in args.infile:
@@ -1,28 +1,31 @@
 #!/bin/bash

-set +x
+set -x
 set +e

 srcdir=$( pwd )
 builddir=$1
-backend=$2
+setup=$2
+suite=$3
 multiplier=${MESON_TEST_TIMEOUT_MULTIPLIER:-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 "${backend}" in
-  x11)
+case "${setup}" in
+  x11*)
    xvfb-run -a -s "-screen 0 1024x768x24 -noreset" \
          meson test -C ${builddir} \
                --quiet \
                --timeout-multiplier "${multiplier}" \
                --print-errorlogs \
-                --setup=${backend} \
-                --suite=gtk \
+                --setup=${setup} \
+                --suite=${suite//,/ --suite=} \
                --no-suite=failing \
+                --no-suite=${setup}_failing \
                --no-suite=flaky \
+                --no-suite=headless \
                --no-suite=gsk-compare-broadway

    # Store the exit code for the CI run, but always
@@ -41,18 +44,19 @@ case "${backend}" in
                --quiet \
                --timeout-multiplier "${multiplier}" \
                --print-errorlogs \
-                --setup=${backend} \
-                --suite=gtk \
+                --setup=${setup} \
+                --suite=${suite//,/ --suite=} \
                --no-suite=failing \
+                --no-suite=${setup}_failing \
                --no-suite=flaky \
-                --no-suite=${backend}_failing \
+                --no-suite=headless \
                --no-suite=gsk-compare-broadway
    exit_code=$?

    kill ${compositor}
    ;;

-  broadway)
+  broadway*)
    export XDG_RUNTIME_DIR="$(mktemp -p $(pwd) -d xdg-runtime-XXXXXX)"

    ${builddir}/gdk/broadway/gtk4-broadwayd :5 &
@@ -63,17 +67,19 @@ case "${backend}" in
                --quiet \
                --timeout-multiplier "${multiplier}" \
                --print-errorlogs \
-                --setup=${backend} \
-                --suite=gtk \
+                --setup=${setup} \
+                --suite=${suite//,/ --suite=} \
                --no-suite=failing \
+                --no-suite=${setup}_failing \
                --no-suite=flaky \
+                --no-suite=headless \
                --no-suite=gsk-compare-opengl

    kill ${server}
    ;;

  *)
-    echo "Failed to add ${backend} to .gitlab-ci/run-tests.sh"
+    echo "Failed to add ${setup} to .gitlab-ci/run-tests.sh"
    exit 1
    ;;

@@ -83,17 +89,17 @@ cd ${builddir}

 $srcdir/.gitlab-ci/meson-junit-report.py \
            --project-name=gtk \
-            --backend="${backend}" \
+            --backend="${setup}" \
            --job-id="${CI_JOB_NAME}" \
-            --output="report-${backend}.xml" \
-            "meson-logs/testlog-${backend}.json"
+            --output="report-${setup}.xml" \
+            "meson-logs/testlog-${setup}.json"

 $srcdir/.gitlab-ci/meson-html-report.py \
            --project-name=gtk \
-            --backend="${backend}" \
+            --backend="${setup}" \
            --job-id="${CI_JOB_NAME}" \
-            --reftest-output-dir="testsuite/reftests/output/${backend}" \
-            --output="report-${backend}.html" \
-            "meson-logs/testlog-${backend}.json"
+            --reftest-output-dir="testsuite/reftests/output/${setup}" \
+            --output="report-${setup}.html" \
+            "meson-logs/testlog-${setup}.json"

 exit $exit_code
@@ -6,7 +6,7 @@ call "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliar

 :: FIXME: make warnings fatal
 pip3 install --upgrade --user meson~=0.64 || goto :error
-meson -Ddebug=false -Dmedia-gstreamer=disabled _build || goto :error
+meson setup -Dbackend_max_links=1 -Ddebug=false -Dmedia-gstreamer=disabled -Dvulkan=disabled _build || goto :error
 ninja -C _build || goto :error

 goto :EOF
@@ -33,7 +33,8 @@ pacman --noconfirm -S --needed \
    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-shaderc \
+    mingw-w64-$MSYS2_ARCH-vulkan

 mkdir -p _ccache
 export CCACHE_BASEDIR="$(pwd)"
@@ -47,7 +48,6 @@ meson \
    -Dx11-backend=false \
    -Dwayland-backend=false \
    -Dwin32-backend=true \
-    -Dvulkan=disabled \
    -Dintrospection=enabled \
    -Dgtk:werror=true \
    _build
@@ -35,8 +35,7 @@ The issue tracker is meant to be used for actionable issues only.

 You should not open a new issue for security related questions.

-When in doubt, send an email to the [security](mailto:security@gnome.org)
-mailing list.
+When in doubt, follow [security](https://security.gnome.org/).

 ### Bug reports

@@ -214,7 +213,7 @@ Closes #1234
 `git commit -a --author "Joe Coder <joe@coder.org>"` and `--signoff`.

 - If your commit is addressing an issue, use the
- [GitLab syntax](https://docs.gitlab.com/ce/user/project/issues/automatic_issue_closing.html)
+ [GitLab syntax](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
 to automatically close the issue when merging the commit with the upstream
 repository:

@@ -244,13 +243,11 @@ people committing to GTK to follow a few rules:
   code, you should always ask. If your change is minor and you've been
   working on GTK for a while it probably isn't necessary to ask. But when
   in doubt, ask. Even if your change is correct, somebody may know a
-   better way to do things. If you are making changes to GTK, you should
-   be subscribed to the [gtk-devel](https://mail.gnome.org/mailman/listinfo/gtk-devel-list)
-   mailing list; this is a good place to ask about intended changes.
-   The `#gtk` IRC channel on irc.gnome.org is also a good place to find GTK
-   developers to discuss changes, but if you live outside of the EU/US time
-   zones, an email to the gtk-devel mailing list is the most certain and
-   preferred method.
+   better way to do things.
+   The `gtk` [room on matrix](https://matrix.to/#/#gtk:gnome.org) is also a
+   good place to find GTK developers to discuss changes, but if you live
+   outside of the EU/US time zones, the [gtk tag on the GNOME Discourse instance](https://discourse.gnome.org/tag/gtk)
+   is the most certain and preferred method.

 0. Ask _first_.

@@ -1,3 +1,340 @@
+Overview of Changes in 4.13.6, xx-xx-xxxx
+=========================================
+
+Overview of Changes in 4.13.5, 07-01-2024
+=========================================
+
+This release adds two new GSK renderers called vulkan and ngl,
+that are built from the same sources. The new renderers can
+handle many corner cases correctly that the current gl renderer
+does not handle, and they offer advantages such as antialiasing
+and supersampled gradients.
+
+The new renderers are still considered experimental, and GTK
+will only use them if they are explicitly selected using the
+GSK_RENDERER environment variable.
+
+As part of this work, the GSK include files have been rearranged.
+It is no longer necessary to include renderer-specific headers for
+ngl and vulkan (and doing so will trigger deprecation warnings),
+and their constructors are always available.
+
+The previously available experimental GdkVulkanContext APIs and
+the old Vulkan renderer have been removed.
+
+Vulkan is now enabled by default, and Linux distributions should
+build GTK with Vulkan support. This requires the glslc shader
+compiler as a new dependency.
+
+Vulkan is now also used for dmabuf support.
+
+* GtkDropdown:
+ - Fix display of initial selection
+
+* GtkShortcutsWindow:
+ - Make the window adapt to smaller screen widths
+
+* GtkTextView:
+ - Fix a possible NULL dereference in history
+
+* GDK:
+ - Make the png loader safer against overflows
+
+* GL:
+ - Fix some errors in handling of texture formats and mipmaps
+
+
+Overview of Changes in 4.13.4, 30-12-2023
+=========================================
+
+* GtkFileDialog:
+ - Return an error if no file is selected
+
+* GtkFileLauncher:
+ - Add a writable property
+
+* GtkFileChooserNative:
+ - Make closing portal file dialogs work
+
+* GtkEmojiChooser:
+ - Update Emoji data to CLDR v43
+
+* GtkStringList:
+ - Add item-type and n-itmes properties
+
+* Input:
+ - Respect GTK grabs on DND events
+ - Fix crossing event generation for enter/leave
+
+* Wayland:
+ - Avoid recreating wl_buffers needlessly
+ - Be more careful when loading cursors
+
+* Dmabuf:
+ - Add support for all Dmabuf formats
+ - Tweak the offload code a bit, allow offloading translucent
+   textures, as long as they are raised. Decline to offload
+   with fractional scales.
+
+* Accessibility:
+ - Add a few more accessible roles
+
+* GL:
+ - Use GLES by default
+ - Tweak GDK_DEBUG values. The new values are
+   gl-disable-gl, gl-disable-gles and gl-prefer-gl.
+   The gl-legacy and nograbs values have been dropped.
+
+* Css:
+ - Reduce memory consumption during theme loading
+ - Fix opacity handling
+
+* Theme:
+ - Refresh some of the included symbolic icons
+
+* MacOs:
+ - Silence secure-restore message
+
+* Build:
+ - Require Vulkan 1.3
+
+* Translation updates:
+ Chinese (China)
+ Czech
+ Hebrew
+ Icelandic
+ Polish
+ Russian
+
+
+Overview of Changes in 4.13.3, 15-11-2023
+=========================================
+
+* GtkGraphicsOffload: A new widget to support passthrough
+  of dmabuf textures with subsurfaces on Wayland
+
+* GtkListView:
+ - reduce tree indentation
+
+* GtkInspector:
+ - Show more GL information
+ - Add a subsurface overlay
+ - Improve the fps overlay
+
+* GDK
+ - Allow implicit modifiers for dmabufs
+ - Support more dmabuf formats: NV16, NV61, NV24, NV42
+   and 3-plane YUV formats
+
+* GSK
+ - Fix padding of icons in the GL atlas
+ - Fix handling of texture-scale nodes in cairo
+ - Treat texture-scale nodes more faithfully in GL
+
+* Accessibility:
+ - Tweak the accessible name computation for corner cases
+
+* The GTK/GDK/GSK_DEBUG environment variables now
+  work in productions as well as in debug builds
+
+* Translation updates
+ Catalan
+ French
+ Russian
+
+
+Overview of Changes in 4.13.2, 22-10-2023
+=========================================
+
+* GtkPrintdialog:
+ - New async-style api to replace GtkPrintOperation
+
+* GtkEmojiChooser:
+ - Add more languages: Bengali, Hindi, Japanese, Finnish,
+   Thai and Norwegian bokmål
+
+* Accessibility:
+ - Fix some utf8 handling issues
+
+* GDK:
+ - Add support for dmabuf textures, with GdkDmabufTextureBuilder
+ - Add a few more supported memory formats for textures
+
+* GSK:
+ - Add a fast-path for masking color
+ - Add support for importing dmabuf textures
+ - Handle GLES better by using some extensions
+
+* Translation updates:
+ Catalan
+ Russian
+ Turkish
+
+
+Overview of Changes in 4.13.1, 28-09-2023
+=========================================
+
+* GtkTooltip:
+ - Don't cross native boundaries when looking for tooltips
+
+* GtkCenterLayout, GtkEntry, GtkSearchEntry:
+ - Fix some issues with baseline handling
+
+* GtkColorButton, GtkFontButton:
+ - Propagate focus-on-click
+
+* GtkFileChooser:
+ - Make "Visit file" scroll to the file
+
+* GtkSwitch:
+ - Respect text direction
+
+* GtkWindow:
+ - Don't assume titlebars are GtkHeaderBars
+
+* Printing:
+ - Fix some problems with the portal implementation
+ - Add a new simple print API: GtkPrintDialog
+
+* Paths:
+ - GskPathMeasure performance has been improved
+ - Add custom contours for circles, rounded rectangles and rectangles
+ - Simplify GskPathPoint handling
+ - gsk_path_point_get_closest_point now returns the distance as well
+ - Make GskPathBuilder simplify curves
+
+* Input:
+ - Handle (some) single-key compose sequences
+ - Fix active state tracking with sensitivity changes and grabs
+
+* GSK:
+ - Make the repeated gradients match between GL and cairo
+ - Make rounded rect shrinking match between Vulkan, GL and cairo
+ - Fix parsing of text nodes with color glyphs
+ - Restrict an optimization to the cases where it is crrect
+ - Fix rendering of shadows with opacity
+ - The Vulkan renderer now requires Vulkan 1.2
+ - GL: Transition gradients unpremultiplied
+ - GL: Fix clipping of shadows
+ - GL: Some optimizations
+ - Broadway: Fix memory leaks in the renderer
+
+* Wayland:
+ - Make activation more reliable
+
+* macOS:
+ - Clamp damage regions to the surface size
+
+* Tools:
+ - gtk4-path-tool gained restrict and reverse commands
+ - gtk4-path-tool show and render can show control points
+
+* Demos:
+ - Add a demo for hit testing with paths
+
+* Build:
+ - Fix build problems with C++ compilers
+
+* Deprecations:
+ - gtk_window_present_with_time
+
+* Translation updates
+ Brazilian Portuguese
+ British English
+ Catalan
+ Chinese (China)
+ Czech
+ Danish
+ Dutch
+ Esperanto
+ Galician
+ Georgian
+ Italian
+ Korean
+ Latvian
+ Lithuanian
+ Persian
+ Polish
+ Punjabi
+ Slovenian
+ Turkish
+
+
+Overview of Changes in 4.13.0, 25-08-2023
+=========================================
+
+* GskPath, GskPathBuilder, GskPathMeasure:
+  Data types and APIs for path rendering. These APIs are still
+  considered experimental, and may change until 4.14. Please try
+  them out and give us feedback. Documentation can be found
+  here: https://docs.gtk.org/gsk4/paths.html
+
+* GtkGridView:
+ - Fix a crash when scrolling
+
+* GtkColumnView:
+ - Fix a refcounting issue in the new scroll_to api
+
+* GtkTreeView
+ - Fix style classes for sort arrows
+
+* GtkEntry:
+ - Improve tracking of user changes (for undo)
+
+* GtkNotebook:
+ - Fix a critical when switching pages
+
+* GtkColor/FontDialogButton:
+ - Make these widgets activatable
+
+* GtkMenuButton:
+ - Fix problems with focus handling
+ - Fix problems with DND
+ - Make flags a settable property
+
+* GtkShortcutsWindow:
+ - Add API to build shortcuts windows programmatically
+
+* Printing
+ - Fix the cpdb backend build
+
+* MacOS:
+ - Make file filters work again
+
+* GSK:
+ - Fix issues with color matrix nodes
+
+* Wayland:
+ - Fix a crash with compositors other than gnome-shell
+
+* Deprecations:
+ - Remaining GtkTreeModel-related types
+
+* Demos:
+ - Add a few path demos to gtk4-demo
+
+* Tools:
+ - gtk4-path-tool provides a commandline interface for paths
+
+* Translation updates:
+ Basque
+ Catalan
+ Finnish
+ Galician
+ Georgian
+ German
+ Greek
+ Indonesian
+ Kazakh
+ Persian
+ Polish
+ Romanian
+ Spanish
+ Swedish
+ Turkish
+ Ukrainian
+
+
 Overview of Changes in 4.12.0, 05-08-2023
 =========================================

@@ -185,7 +522,7 @@ Overview of Changes in 4.11.4, 03-07-2023
 - Center newly created transient windows

 * Vulkan:
- - Add antialising for gradients
+ - Add antialiasing for gradients
 - Do less work on clipped away nodes
 - Redo image uploading
 - Support different image depths and formats
@@ -1169,7 +1506,7 @@ Overview of Changes in 4.7.0, 07-05-2022
 - Event handling fixes
 - Fix keyboard input on popovers
 - Support OpenGL-based video playback
- - Suport fullscreen
+ - Support fullscreen
 - Improve native filechoooser size allocation
 - Use CALayer and IOSurface for rendering
 - Use a per-monitor CVDisplayLink
@@ -1566,7 +1903,7 @@ Overview of Changes in 4.4.0
 - Activate when moving focus

 * GtkLabel:
- - Propertly ignore double underscores for mnemonics
+ - Properly ignore double underscores for mnemonics

 * GtkPopoverMenu:
 - Fix focus cycling
@@ -2113,7 +2450,7 @@ Overview of Changes in 4.1.0
 - Set sort arrows in CSS
 - Set menu button arrows in CSS
 - Make scrollbars larger
- - Supprt circular menubuttons
+ - Support circular menubuttons

 * CSS:
 - Implement transform-origin
@@ -0,0 +1,41 @@
+#ifndef _MSC_VER
+#pragma error "This header is for Microsoft VC or clang-cl only."
+#endif /* _MSC_VER */
+
+/* Make MSVC more pedantic, this is a recommended pragma list
+ * from _Win32_Programming_ by Rector and Newcomer.
+ */
+#ifndef __clang__
+#pragma warning(error:4002) /* too many actual parameters for macro */
+#pragma warning(error:4003) /* not enough actual parameters for macro */
+#pragma warning(1:4010)     /* single-line comment contains line-continuation character */
+#pragma warning(error:4013) /* 'function' undefined; assuming extern returning int */
+#pragma warning(1:4016)     /* no function return type; using int as default */
+#pragma warning(error:4020) /* too many actual parameters */
+#pragma warning(error:4021) /* too few actual parameters */
+#pragma warning(error:4027) /* function declared without formal parameter list */
+#pragma warning(error:4029) /* declared formal parameter list different from definition */
+#pragma warning(error:4033) /* 'function' must return a value */
+#pragma warning(error:4035) /* 'function' : no return value */
+#pragma warning(error:4045) /* array bounds overflow */
+#pragma warning(error:4047) /* different levels of indirection */
+#pragma warning(error:4049) /* terminating line number emission */
+#pragma warning(error:4053) /* An expression of type void was used as an operand */
+#pragma warning(error:4071) /* no function prototype given */
+#pragma warning(disable:4101) /* unreferenced local variable */
+#pragma warning(error:4150)
+
+/* G_NORETURN */
+#pragma warning(error:4646) /* function declared with __declspec(noreturn) has non-void return type */
+#pragma warning(error:4715) /* 'function': not all control paths return a value */
+#pragma warning(error:4098) /* 'void' function returning a value */
+
+#pragma warning(disable:4244)	/* No possible loss of data warnings */
+#pragma warning(disable:4305)   /* No truncation from int to char warnings */
+
+#pragma warning(error:4819) /* The file contains a character that cannot be represented in the current code page */
+#endif                      /* __clang__ */
+
+/* work around Microsoft's premature attempt to deprecate the C-Library */
+#define _CRT_SECURE_NO_WARNINGS
+#define _CRT_NONSTDC_NO_WARNINGS
@@ -35,7 +35,7 @@ show_action_dialog (GSimpleAction *action)
 {
  GtkAlertDialog *dialog;

-  dialog = gtk_alert_dialog_new ("You activated action: \"%s\n",
+  dialog = gtk_alert_dialog_new ("You activated action: \"%s\"",
                                 g_action_get_name (G_ACTION (action)));
  gtk_alert_dialog_show (dialog, NULL);
  g_object_unref (dialog);
@@ -223,7 +223,7 @@ delete_messages (gpointer data)
 static void
 pop_message (GtkWidget *status)
 {
-  GList *messages = (GList *) g_object_get_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_steal_data (G_OBJECT (status), "messages");

  if (messages)
    {
@@ -241,7 +241,7 @@ static void
 push_message (GtkWidget  *status,
              const char *message)
 {
-  GList *messages = (GList *) g_object_get_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_steal_data (G_OBJECT (status), "messages");

  gtk_label_set_label (GTK_LABEL (status), message);
  messages = g_list_prepend (messages, g_strdup (message));
@@ -18,8 +18,7 @@
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

-#ifndef __BLUR_OVERLAY_H__
-#define __BLUR_OVERLAY_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -60,5 +59,3 @@ void       blur_overlay_set_child   (BlurOverlay *overlay,
                                     GtkWidget   *widget);

 G_END_DECLS
-
-#endif /* __BLUR_OVERLAY_H__ */
@@ -127,6 +127,7 @@
    <file>fishbowl.ui</file>
    <file>gtkfishbowl.c</file>
    <file>gtkfishbowl.h</file>
+    <file>tiger.node</file>
  </gresource>
  <gresource prefix="/frames">
    <file>frames.ui</file>
@@ -335,6 +336,11 @@
    <file>paintable_symbolic.c</file>
    <file>panes.c</file>
    <file>password_entry.c</file>
+    <file>path_fill.c</file>
+    <file>path_maze.c</file>
+    <file>path_spinner.c</file>
+    <file>path_walk.c</file>
+    <file>path_text.c</file>
    <file>peg_solitaire.c</file>
    <file>pickers.c</file>
    <file>printing.c</file>
@@ -420,6 +426,13 @@
  <gresource prefix="/fontrendering">
    <file>fontrendering.ui</file>
  </gresource>
+  <gresource prefix="/path_walk">
+    <file>path_walk.ui</file>
+    <file compressed="true">path_world.txt</file>
+  </gresource>
+  <gresource prefix="/path_text">
+    <file>path_text.ui</file>
+  </gresource>
  <gresource prefix="/org/gtk/Demo4">
    <file>icons/16x16/actions/application-exit.png</file>
    <file>icons/16x16/actions/document-new.png</file>
@@ -75,7 +75,9 @@ query_tooltip (GtkWidget  *widget,
  gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);

  precision = 1;
+  s = NULL;
  do {
+    g_free (s);
    s = g_strdup_printf ("%.*f", precision, self->scale);
    l = strlen (s) - 1;
    while (s[l] == '0')
@@ -18,8 +18,7 @@
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

-#ifndef __DEMO_TAGGED_ENTRY_H__
-#define __DEMO_TAGGED_ENTRY_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -57,5 +56,3 @@ void            demo_tagged_entry_tag_set_has_close_button (DemoTaggedEntryTag *
                                                            gboolean            has_close_button);

 G_END_DECLS
-
-#endif /* __DEMO_TAGGED_ENTRY_H__ */
@@ -34,7 +34,7 @@ transition (GtkWidget     *widget,
 {
  DemoWidget *self = DEMO_WIDGET (widget);
  DemoLayout *demo_layout = DEMO_LAYOUT (gtk_widget_get_layout_manager (widget));
-  gint64 now = g_get_monotonic_time ();
+  gint64 now = gdk_frame_clock_get_frame_time (frame_clock);

  gtk_widget_queue_allocate (widget);

@@ -66,11 +66,13 @@ clicked (GtkGestureClick *gesture,
         gpointer         data)
 {
  DemoWidget *self = data;
+  GdkFrameClock *frame_clock;

  if (self->tick_id != 0)
    return;

-  self->start_time = g_get_monotonic_time ();
+  frame_clock = gtk_widget_get_frame_clock (GTK_WIDGET (self));
+  self->start_time = gdk_frame_clock_get_frame_time (frame_clock);
  self->tick_id = gtk_widget_add_tick_callback (GTK_WIDGET (self), transition, NULL, NULL);
 }

@@ -11,6 +11,9 @@
 #include "gtkgears.h"
 #include "gskshaderpaintable.h"

+#include "nodewidget.h"
+#include "graphwidget.h"
+
 const char *const css =
 ".blurred-button {"
 "  box-shadow: 0px 0px 5px 10px rgba(0, 0, 0, 0.5);"
@@ -71,14 +74,7 @@ create_blurred_button (void)
 static GtkWidget *
 create_font_button (void)
 {
-  GtkFontDialog *dialog;
-  GtkWidget *button;
-
-  dialog = gtk_font_dialog_new ();
-  button = gtk_font_dialog_button_new (dialog);
-  g_object_unref (dialog);
-
-  return button;
+  return gtk_font_dialog_button_new (gtk_font_dialog_new ());
 }

 static GtkWidget *
@@ -208,6 +204,18 @@ create_menu_button (void)
  return w;
 }

+static GtkWidget *
+create_tiger (void)
+{
+  return node_widget_new ("/fishbowl/tiger.node");
+}
+
+static GtkWidget *
+create_graph (void)
+{
+  return graph_widget_new ();
+}
+
 static const struct {
  const char *name;
  GtkWidget * (*create_func) (void);
@@ -225,6 +233,8 @@ static const struct {
  { "Switch",     create_switch         },
  { "Menubutton", create_menu_button    },
  { "Shader",     create_cogs           },
+  { "Tiger",      create_tiger          },
+  { "Graph",      create_graph          },
 };

 static int selected_widget_type = -1;
@@ -1586,7 +1586,7 @@ update_font_variations (void)
        }

      gtk_grid_attach (GTK_GRID (demo->variations_grid), combo, 1, -1, 3, 1);
-      g_signal_connect (combo, "notify::selecte", G_CALLBACK (instance_changed), NULL);
+      g_signal_connect (combo, "notify::selected", G_CALLBACK (instance_changed), NULL);
      demo->instance_combo = combo;
   }

@@ -15,8 +15,7 @@
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

-#ifndef __GTK_FONT_PLANE_H__
-#define __GTK_FONT_PLANE_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -60,5 +59,3 @@ GtkWidget * gtk_font_plane_new      (GtkAdjustment *width_adj,
                                     GtkAdjustment *weight_adj);

 G_END_DECLS
-
-#endif /* __GTK_FONT_PLANE_H__ */
@@ -0,0 +1,153 @@
+#include "graphwidget.h"
+
+struct _GraphWidget
+{
+  GtkWidget parent_instance;
+
+  GskPath *path;
+  GskStroke *stroke;
+  GdkRGBA color;
+
+  guint tick_cb;
+  guint64 start_time;
+
+  double period;
+  double amplitude;
+};
+
+struct _GraphWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (GraphWidget, graph_widget, GTK_TYPE_WIDGET)
+
+static void
+update_path (GraphWidget *self,
+             float        amplitude)
+{
+  graphene_point_t p[20];
+  GskPathBuilder *builder;
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+
+  for (int i = 0; i < 20; i++)
+    {
+      p[i].x = 10 * i;
+      p[i].y = 50;
+
+      if (i % 4 == 1 || i % 4 == 2)
+        {
+          if (i % 8 < 4)
+            p[i].y += amplitude;
+          else
+            p[i].y -= amplitude;
+        }
+    }
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_move_to (builder, p[0].x, p[0].y);
+
+  for (int i = 0; i < 20; i += 4)
+    gsk_path_builder_cubic_to (builder,
+                               p[i+1].x, p[i+1].y,
+                               p[i+2].x, p[i+2].y,
+                               p[i+3].x, p[i+3].y);
+
+  self->path = gsk_path_builder_free_to_path (builder);
+}
+
+static gboolean
+tick_cb (GtkWidget     *widget,
+         GdkFrameClock *frame_clock,
+         gpointer       user_data)
+{
+  GraphWidget *self = GRAPH_WIDGET (widget);
+  guint64 now;
+  double angle;
+
+  now = gdk_frame_clock_get_frame_time (frame_clock);
+
+  if (self->start_time == 0)
+    self->start_time = now;
+
+  angle = 360 * (now - self->start_time) / (double)(self->period * G_TIME_SPAN_MINUTE);
+  update_path (self, sin (angle) * self->amplitude);
+
+  gtk_widget_queue_draw (widget);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+graph_widget_init (GraphWidget *self)
+{
+  self->color.red = g_random_double_range (0, 1);
+  self->color.green = g_random_double_range (0, 1);
+  self->color.blue = g_random_double_range (0, 1);
+  self->color.alpha = 1;
+
+  self->period = g_random_double_range (0.5, 1);
+  self->amplitude = g_random_double_range (10, 25);
+
+  self->stroke = gsk_stroke_new (2);
+
+  update_path (self, 0);
+
+  self->start_time = 0;
+  self->tick_cb = gtk_widget_add_tick_callback (GTK_WIDGET (self), tick_cb, NULL, NULL);
+}
+
+static void
+graph_widget_dispose (GObject *object)
+{
+  GraphWidget *self = GRAPH_WIDGET (object);
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  gsk_stroke_free (self->stroke);
+
+  G_OBJECT_CLASS (graph_widget_parent_class)->dispose (object);
+}
+
+static void
+graph_widget_snapshot (GtkWidget   *widget,
+                      GtkSnapshot *snapshot)
+{
+  GraphWidget *self = GRAPH_WIDGET (widget);
+
+  gtk_snapshot_append_stroke (snapshot, self->path, self->stroke, &self->color);
+}
+
+static void
+graph_widget_measure (GtkWidget      *widget,
+                      GtkOrientation  orientation,
+                      int             for_size,
+                      int            *minimum,
+                      int            *natural,
+                      int            *minimum_baseline,
+                      int            *natural_baseline)
+{
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = 200;
+  else
+    *minimum = *natural = 100;
+}
+
+
+static void
+graph_widget_class_init (GraphWidgetClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = graph_widget_dispose;
+
+  widget_class->snapshot = graph_widget_snapshot;
+  widget_class->measure = graph_widget_measure;
+}
+
+GtkWidget *
+graph_widget_new (void)
+{
+  return g_object_new (GRAPH_TYPE_WIDGET, NULL);
+}
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define GRAPH_TYPE_WIDGET (graph_widget_get_type ())
+G_DECLARE_FINAL_TYPE (GraphWidget, graph_widget, GRAPH, WIDGET, GtkWidget)
+
+GtkWidget * graph_widget_new       (void);
@@ -17,8 +17,7 @@
 * Authors: Matthias Clasen <mclasen@redhat.com>
 */

-#ifndef __GSK_SHADER_PAINTABLE_H__
-#define __GSK_SHADER_PAINTABLE_H__
+#pragma once

 #include <gdk/gdk.h>
 #include <gsk/gsk.h>
@@ -42,5 +41,3 @@ void             gsk_shader_paintable_update_time      (GskShaderPaintable *self
                                                        int                 time_idx,
                                                        gint64              frame_time);
 G_END_DECLS
-
-#endif /* __GSK_SHADER_PAINTABLE_H__ */
@@ -15,8 +15,7 @@
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

-#ifndef __GTK_FISHBOWL_H__
-#define __GTK_FISHBOWL_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -65,5 +64,3 @@ void       gtk_fishbowl_set_creation_func (GtkFishbowl       *fishbowl,
                                           GtkFishCreationFunc creation_func);

 G_END_DECLS
-
-#endif /* __GTK_FISHBOWL_H__ */
@@ -840,24 +840,24 @@ gtk_gears_unrealize (GtkWidget *widget)
  GtkGearsPrivate *priv = gtk_gears_get_instance_private ((GtkGears *) widget);

  gtk_gl_area_make_current (glarea);
-  if (gtk_gl_area_get_error (glarea) != NULL)
-    return;
+  if (gtk_gl_area_get_error (glarea) == NULL)
+    {
+      /* Release the resources associated with OpenGL */
+      if (priv->gear_vbo[0] != 0)
+        glDeleteBuffers (1, &(priv->gear_vbo[0]));

-  /* Release the resources associated with OpenGL */
-  if (priv->gear_vbo[0] != 0)
-    glDeleteBuffers (1, &(priv->gear_vbo[0]));
+      if (priv->gear_vbo[1] != 0)
+        glDeleteBuffers (1, &(priv->gear_vbo[1]));

-  if (priv->gear_vbo[1] != 0)
-    glDeleteBuffers (1, &(priv->gear_vbo[1]));
+      if (priv->gear_vbo[2] != 0)
+        glDeleteBuffers (1, &(priv->gear_vbo[2]));

-  if (priv->gear_vbo[2] != 0)
-    glDeleteBuffers (1, &(priv->gear_vbo[2]));
+      if (priv->vao != 0)
+        glDeleteVertexArrays (1, &priv->vao);

-  if (priv->vao != 0)
-    glDeleteVertexArrays (1, &priv->vao);
-
-  if (priv->program != 0)
-    glDeleteProgram (priv->program);
+      if (priv->program != 0)
+        glDeleteProgram (priv->program);
+    }

  priv->ModelViewProjectionMatrix_location = 0;
  priv->NormalMatrix_location = 0;
@@ -1,5 +1,4 @@
-#ifndef __GTK_GEARS_H__
-#define __GTK_GEARS_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -44,5 +43,3 @@ void       gtk_gears_set_fps_label (GtkGears *gears,


 G_END_DECLS
-
-#endif /* __GTK_GEARS_H__ */
@@ -1,5 +1,4 @@
-#ifndef __GTK_SHADER_BIN_H__
-#define __GTK_SHADER_BIN_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -19,5 +18,3 @@ void       gtk_shader_bin_set_child   (GtkShaderBin *self,
 GtkWidget *gtk_shader_bin_get_child   (GtkShaderBin *self);

 G_END_DECLS
-
-#endif /* __GTK_SHADER_BIN_H__ */
@@ -1,5 +1,4 @@
-#ifndef __GTK_SHADER_STACK_H__
-#define __GTK_SHADER_STACK_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -19,5 +18,3 @@ void        gtk_shader_stack_set_active   (GtkShaderStack *self,
                                           int             index);

 G_END_DECLS
-
-#endif /* __GTK_SHADER_STACK_H__ */
@@ -1,5 +1,4 @@
-#ifndef __GTK_SHADERTOY_H__
-#define __GTK_SHADERTOY_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -30,5 +29,3 @@ void        gtk_shadertoy_set_image_shader (GtkShadertoy *shadertoy,
                                            const char   *shader);

 G_END_DECLS
-
-#endif /* __GTK_SHADERTOY_H__ */
@@ -1,5 +1,4 @@
-#ifndef LANGUAGE_NAMES_H
-#define LANGUAGE_NAMES_H
+#pragma once

 #include <pango/pango.h>

@@ -9,5 +8,3 @@ const char * get_language_name (PangoLanguage *language);
 const char * get_language_name_for_tag (guint32 tag);

 G_END_DECLS
-
-#endif
@@ -24,7 +24,7 @@
 #include "demos.h"
 #include "fontify.h"

-#include "demo_conf.h"
+#include "profile_conf.h"

 static GtkWidget *info_view;
 static GtkWidget *source_view;
@@ -72,6 +72,11 @@ demos = files([
  'paintable_symbolic.c',
  'panes.c',
  'password_entry.c',
+  'path_fill.c',
+  'path_maze.c',
+  'path_spinner.c',
+  'path_walk.c',
+  'path_text.c',
  'peg_solitaire.c',
  'pickers.c',
  'printing.c',
@@ -136,6 +141,8 @@ extra_demo_sources = files([
  'unicode-names.c',
  'suggestionentry.c',
  'language-names.c',
+  'nodewidget.c',
+  'graphwidget.c',
 ])

 if os_unix
@@ -229,7 +236,7 @@ foreach flag: common_cflags
  endif
 endforeach

-gtkdemo_deps += [ demo_conf_h ]
+gtkdemo_deps += [ profile_conf_h ]

 executable('gtk4-demo',
  sources: [demos, demos_h, extra_demo_sources, gtkdemo_resources],
@@ -0,0 +1,76 @@
+#include "nodewidget.h"
+
+struct _NodeWidget
+{
+  GtkWidget parent_instance;
+
+  GskRenderNode *node;
+};
+
+struct _NodeWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (NodeWidget, node_widget, GTK_TYPE_WIDGET)
+
+static void
+node_widget_init (NodeWidget *self)
+{
+}
+
+static void
+node_widget_dispose (GObject *object)
+{
+  NodeWidget *self = NODE_WIDGET (object);
+
+  gsk_render_node_unref (self->node);
+
+  G_OBJECT_CLASS (node_widget_parent_class)->dispose (object);
+}
+
+static void
+node_widget_snapshot (GtkWidget   *widget,
+                      GtkSnapshot *snapshot)
+{
+  NodeWidget *self = NODE_WIDGET (widget);
+
+  gtk_snapshot_append_node (snapshot, self->node);
+}
+
+static void
+node_widget_class_init (NodeWidgetClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = node_widget_dispose;
+
+  widget_class->snapshot = node_widget_snapshot;
+}
+
+GtkWidget *
+node_widget_new (const char *resource)
+{
+  NodeWidget *self;
+  GBytes *bytes;
+  GskRenderNode *node;
+  graphene_rect_t bounds;
+  float scale;
+  GskTransform *transform;
+
+  self = g_object_new (NODE_TYPE_WIDGET, NULL);
+
+  bytes = g_resources_lookup_data (resource, 0, NULL);
+  node = gsk_render_node_deserialize (bytes, NULL, NULL);
+  g_bytes_unref (bytes);
+
+  gsk_render_node_get_bounds (node, &bounds);
+  scale = MIN (100.0/bounds.size.width, 100.0/bounds.size.height);
+  transform = gsk_transform_scale (NULL, scale, scale);
+  self->node = gsk_transform_node_new (node, transform);
+  gsk_transform_unref (transform);
+  gsk_render_node_unref (node);
+
+  return GTK_WIDGET (self);
+}
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define NODE_TYPE_WIDGET (node_widget_get_type ())
+G_DECLARE_FINAL_TYPE (NodeWidget, node_widget, NODE, WIDGET, GtkWidget)
+
+GtkWidget * node_widget_new       (const char *file);
@@ -53,7 +53,9 @@ gtk_nuclear_snapshot (GtkSnapshot   *snapshot,
                      double         rotation)
 {
 #define RADIUS 0.3
-  cairo_t *cr;
+  GskPathBuilder *builder;
+  GskPath *path;
+  GskStroke *stroke;
  double size;

  gtk_snapshot_append_color (snapshot,
@@ -61,24 +63,29 @@ gtk_nuclear_snapshot (GtkSnapshot   *snapshot,
                             &GRAPHENE_RECT_INIT (0, 0, width, height));

  size = MIN (width, height);
-  cr = gtk_snapshot_append_cairo (snapshot,
-                                  &GRAPHENE_RECT_INIT ((width - size) / 2.0,
-                                                       (height - size) / 2.0,
-                                                       size, size));
-  gdk_cairo_set_source_rgba (cr, foreground);
-  cairo_translate (cr, width / 2.0, height / 2.0);
-  cairo_scale (cr, size, size);
-  cairo_rotate (cr, rotation);

-  cairo_arc (cr, 0, 0, 0.1, - G_PI, G_PI);
-  cairo_fill (cr);
+  gtk_snapshot_save (snapshot);

-  cairo_set_line_width (cr, RADIUS);
-  cairo_set_dash (cr, (double[1]) { RADIUS * G_PI / 3 }, 1, 0.0);
-  cairo_arc (cr, 0, 0, RADIUS, - G_PI, G_PI);
-  cairo_stroke (cr);
+  gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (width / 2.0, height / 2.0));
+  gtk_snapshot_scale (snapshot, size, size);
+  gtk_snapshot_rotate (snapshot, rotation);

-  cairo_destroy (cr);
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_circle (builder, graphene_point_zero (), 0.1);
+  path = gsk_path_builder_free_to_path (builder);
+  gtk_snapshot_append_fill (snapshot, path, GSK_FILL_RULE_WINDING, foreground);
+  gsk_path_unref (path);
+
+  stroke = gsk_stroke_new (RADIUS);
+  gsk_stroke_set_dash (stroke, (float[1]) { RADIUS * G_PI / 3 }, 1);
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_circle (builder, graphene_point_zero(), RADIUS);
+  path = gsk_path_builder_free_to_path (builder);
+  gtk_snapshot_append_stroke (snapshot, path, stroke, foreground);
+  gsk_path_unref (path);
+  gsk_stroke_free (stroke);
+
+  gtk_snapshot_restore (snapshot);
 }

 /* Here, we implement the functionality required by the GdkPaintable interface */
@@ -1,5 +1,4 @@
-#ifndef __PAINTABLE_H__
-#define __PAINTABLE_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -13,5 +12,3 @@ void            gtk_nuclear_snapshot           (GtkSnapshot     *snapshot,
 GdkPaintable *  gtk_nuclear_icon_new            (double          rotation);
 GdkPaintable *  gtk_nuclear_animation_new       (gboolean        draw_background);
 GtkMediaStream *gtk_nuclear_media_stream_new    (void);
-
-#endif /* __PAINTABLE_H__ */
@@ -70,7 +70,7 @@ gtk_nuclear_animation_snapshot (GdkPaintable *paintable,
                          ? &(GdkRGBA) { 0.9, 0.75, 0.15, 1.0 } /* yellow */
                          : &(GdkRGBA) { 0, 0, 0, 0 }, /* transparent */
                        width, height,
-                        2 * G_PI * nuclear->progress / MAX_PROGRESS);
+                        360 * nuclear->progress / MAX_PROGRESS);
 }

 static GdkPaintable *
@@ -85,7 +85,7 @@ gtk_nuclear_animation_get_current_image (GdkPaintable *paintable)
   * Luckily we added the rotation property to the nuclear icon
   * object previously, so we can just return an instance of that one.
   */
-  return gtk_nuclear_icon_new (2 * G_PI * nuclear->progress / MAX_PROGRESS);
+  return gtk_nuclear_icon_new (360 * nuclear->progress / MAX_PROGRESS);
 }

 static GdkPaintableFlags
@@ -76,7 +76,7 @@ gtk_nuclear_media_stream_snapshot (GdkPaintable *paintable,
                        &(GdkRGBA) { 0, 0, 0, 1 }, /* black */
                        &(GdkRGBA) { 0.9, 0.75, 0.15, 1.0 }, /* yellow */
                        width, height,
-                        2 * G_PI * nuclear->progress / DURATION);
+                        360 * nuclear->progress / DURATION);
 }

 static GdkPaintable *
@@ -85,7 +85,7 @@ gtk_nuclear_media_stream_get_current_image (GdkPaintable *paintable)
  GtkNuclearMediaStream *nuclear = GTK_NUCLEAR_MEDIA_STREAM (paintable);

  /* Same thing as with the animation */
-  return gtk_nuclear_icon_new (2 * G_PI * nuclear->progress / DURATION);
+  return gtk_nuclear_icon_new (360 * nuclear->progress / DURATION);
 }

 static GdkPaintableFlags
@@ -0,0 +1,295 @@
+/* Path/Fill and Stroke
+ *
+ * This demo shows how to use GskPath to draw shapes that are (a bit)
+ * more complex than a rounded rectangle.
+ *
+ * It also demonstrates printing to a stream with GtkPrintDialog.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <cairo-pdf.h>
+
+#include "paintable.h"
+
+#define GTK_TYPE_LOGO_PAINTABLE (gtk_logo_paintable_get_type ())
+G_DECLARE_FINAL_TYPE (GtkLogoPaintable, gtk_logo_paintable, GTK, LOGO_PAINTABLE, GObject)
+
+struct _GtkLogoPaintable
+{
+  GObject parent_instance;
+
+  int width;
+  int height;
+  GskPath *path[3];
+  GdkRGBA color[3];
+
+  GskPath *stroke_path;
+  GskStroke *stroke1;
+  GskStroke *stroke2;
+  GdkRGBA stroke_color;
+};
+
+struct _GtkLogoPaintableClass
+{
+  GObjectClass parent_class;
+};
+
+static int
+gtk_logo_paintable_get_intrinsic_width (GdkPaintable *paintable)
+{
+  GtkLogoPaintable *self = GTK_LOGO_PAINTABLE (paintable);
+
+  return self->width;
+}
+
+static int
+gtk_logo_paintable_get_intrinsic_height (GdkPaintable *paintable)
+{
+  GtkLogoPaintable *self = GTK_LOGO_PAINTABLE (paintable);
+
+  return self->height;
+}
+
+static void
+gtk_logo_paintable_snapshot (GdkPaintable *paintable,
+                             GdkSnapshot  *snapshot,
+                             double        width,
+                             double        height)
+{
+  GtkLogoPaintable *self = GTK_LOGO_PAINTABLE (paintable);
+
+  for (unsigned int i = 0; i < 3; i++)
+    {
+      gtk_snapshot_push_fill (snapshot, self->path[i], GSK_FILL_RULE_WINDING);
+      gtk_snapshot_append_color (snapshot,
+                                 &self->color[i],
+                                 &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+    }
+  for (unsigned int i = 0; i < 3; i++)
+    {
+      gtk_snapshot_push_stroke (snapshot, self->stroke_path, self->stroke1);
+      gtk_snapshot_append_color (snapshot,
+                                 &self->stroke_color,
+                                 &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+    }
+
+  gtk_snapshot_push_stroke (snapshot, self->stroke_path, self->stroke2);
+  gtk_snapshot_append_color (snapshot,
+                             &self->stroke_color,
+                             &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gtk_snapshot_pop (snapshot);
+}
+
+static GdkPaintableFlags
+gtk_logo_paintable_get_flags (GdkPaintable *paintable)
+{
+  return GDK_PAINTABLE_STATIC_CONTENTS | GDK_PAINTABLE_STATIC_SIZE;
+}
+
+static void
+gtk_logo_paintable_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->get_intrinsic_width = gtk_logo_paintable_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_logo_paintable_get_intrinsic_height;
+  iface->snapshot = gtk_logo_paintable_snapshot;
+  iface->get_flags = gtk_logo_paintable_get_flags;
+}
+
+/* When defining the GType, we need to implement the GdkPaintable interface */
+G_DEFINE_TYPE_WITH_CODE (GtkLogoPaintable, gtk_logo_paintable, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                                gtk_logo_paintable_paintable_init))
+
+static void
+gtk_logo_paintable_dispose (GObject *object)
+{
+  GtkLogoPaintable *self = GTK_LOGO_PAINTABLE (object);
+
+  for (unsigned int i = 0; i < 3; i++)
+    gsk_path_unref (self->path[i]);
+
+  gsk_path_unref (self->stroke_path);
+
+  gsk_stroke_free (self->stroke1);
+  gsk_stroke_free (self->stroke2);
+
+  G_OBJECT_CLASS (gtk_logo_paintable_parent_class)->dispose (object);
+}
+
+static void
+gtk_logo_paintable_class_init (GtkLogoPaintableClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_logo_paintable_dispose;
+}
+
+static void
+gtk_logo_paintable_init (GtkLogoPaintable *self)
+{
+}
+
+static GdkPaintable *
+gtk_logo_paintable_new (void)
+{
+  GtkLogoPaintable *self;
+  graphene_rect_t bounds, bounds2;
+
+  self = g_object_new (GTK_TYPE_LOGO_PAINTABLE, NULL);
+
+  /* Paths and colors extracted from gtk-logo.svg */
+  self->path[0] = gsk_path_parse ("m3.12,66.17 -2.06,-51.46 32.93,24.7 v55.58 l-30.87,-28.82 z");
+  self->path[1] = gsk_path_parse ("m34,95 49.4,-20.58 4.12,-51.46 -53.52,16.47 v55.58 z");
+  self->path[2] = gsk_path_parse ("m1.06,14.71 32.93,24.7 53.52,-16.47 -36.75,-21.88 -49.7,13.65 z");
+
+  gdk_rgba_parse (&self->color[0], "#e40000");
+  gdk_rgba_parse (&self->color[1], "#7fe719");
+  gdk_rgba_parse (&self->color[2], "#729fcf");
+
+  self->stroke_path = gsk_path_parse ("m50.6,51.3 -47.3,14 z l33,23 z v-50");
+  self->stroke1 = gsk_stroke_new (2.12);
+  self->stroke2 = gsk_stroke_new (1.25);
+  gdk_rgba_parse (&self->stroke_color, "#ffffff");
+
+  gsk_path_get_stroke_bounds (self->path[0], self->stroke1, &bounds);
+  gsk_path_get_stroke_bounds (self->path[1], self->stroke1, &bounds2);
+  graphene_rect_union (&bounds, &bounds2, &bounds);
+  gsk_path_get_stroke_bounds (self->path[2], self->stroke1, &bounds2);
+  graphene_rect_union (&bounds, &bounds2, &bounds);
+  gsk_path_get_stroke_bounds (self->stroke_path, self->stroke2, &bounds2);
+  graphene_rect_union (&bounds, &bounds2, &bounds);
+
+  self->width = bounds.origin.x + bounds.size.width;
+  self->height = bounds.origin.y + bounds.size.height;
+
+  return GDK_PAINTABLE (self);
+}
+
+static cairo_status_t
+write_cairo (void                *closure,
+             const unsigned char *data,
+             unsigned int         length)
+{
+  GOutputStream *stream = closure;
+  gsize written;
+  GError *error = NULL;
+
+  if (!g_output_stream_write_all (stream, data, length, &written, NULL, &error))
+    {
+      g_print ("Error writing pdf stream: %s\n", error->message);
+      g_error_free (error);
+      return CAIRO_STATUS_WRITE_ERROR;
+    }
+
+  return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+print_ready (GObject      *source,
+             GAsyncResult *result,
+             gpointer      data)
+{
+  GtkPrintDialog *dialog = GTK_PRINT_DIALOG (source);
+  GError *error = NULL;
+  GOutputStream *stream;
+  GtkSnapshot *snapshot;
+  GdkPaintable *paintable;
+  GskRenderNode *node;
+  cairo_surface_t *surface;
+  cairo_t *cr;
+
+  stream = gtk_print_dialog_print_finish (dialog, result, &error);
+  if (stream == NULL)
+    {
+      g_print ("Failed to get output stream: %s\n", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  snapshot = gtk_snapshot_new ();
+  paintable = gtk_picture_get_paintable (GTK_PICTURE (data));
+  gdk_paintable_snapshot (paintable, snapshot, 100, 100);
+  node = gtk_snapshot_free_to_node (snapshot);
+
+  surface = cairo_pdf_surface_create_for_stream (write_cairo, stream, 100, 100);
+  cr = cairo_create (surface);
+
+  gsk_render_node_draw (node, cr);
+
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+  gsk_render_node_unref (node);
+
+  if (!g_output_stream_close (stream, NULL, &error))
+    {
+      g_print ("Error from close: %s\n", error->message);
+      g_error_free (error);
+    }
+
+  g_object_unref (stream);
+}
+
+static void
+print (GtkButton *button,
+       gpointer   data)
+{
+  GtkWidget *picture = data;
+  GtkPrintDialog *dialog;
+
+  dialog = gtk_print_dialog_new ();
+
+  gtk_print_dialog_print (dialog,
+                          GTK_WINDOW (gtk_widget_get_root (picture)),
+                          NULL,
+                          NULL,
+                          print_ready,
+                          picture);
+
+  g_object_unref (dialog);
+}
+
+GtkWidget *
+do_path_fill (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *header, *button, *label;
+      GtkWidget *picture;
+      GdkPaintable *paintable;
+
+      window = gtk_window_new ();
+      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+      gtk_window_set_default_size (GTK_WINDOW (window), 100, 100);
+      gtk_window_set_title (GTK_WINDOW (window), "Fill and Stroke");
+      header = gtk_header_bar_new ();
+      button = gtk_button_new_from_icon_name ("printer-symbolic");
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);
+      label = gtk_label_new ("Fill and Stroke");
+      gtk_widget_add_css_class (label, "title");
+      gtk_header_bar_set_title_widget (GTK_HEADER_BAR (header), label);
+      gtk_window_set_titlebar (GTK_WINDOW (window), header);
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      paintable = gtk_logo_paintable_new ();
+      picture = gtk_picture_new_for_paintable (paintable);
+      gtk_picture_set_content_fit (GTK_PICTURE (picture), GTK_CONTENT_FIT_CONTAIN);
+      gtk_picture_set_can_shrink (GTK_PICTURE (picture), FALSE);
+      g_object_unref (paintable);
+
+      g_signal_connect (button, "clicked", G_CALLBACK (print), picture);
+
+      gtk_window_set_child (GTK_WINDOW (window), picture);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}
@@ -0,0 +1,369 @@
+/* Path/Maze
+ *
+ * This demo shows how to use a GskPath to create a maze and use
+ * gsk_path_get_closest_point() to check the mouse stays
+ * on the path.
+ *
+ * It also shows off the performance of GskPath (or not) as this
+ * is a rather complex path.
+ */
+
+#include "config.h"
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "paintable.h"
+
+#define MAZE_GRID_SIZE 20
+#define MAZE_STROKE_SIZE_ACTIVE (MAZE_GRID_SIZE - 4)
+#define MAZE_STROKE_SIZE_INACTIVE (MAZE_GRID_SIZE - 12)
+#define MAZE_WIDTH 31
+#define MAZE_HEIGHT 21
+
+#define GTK_TYPE_MAZE (gtk_maze_get_type ())
+G_DECLARE_FINAL_TYPE (GtkMaze, gtk_maze, GTK, MAZE, GtkWidget)
+
+struct _GtkMaze
+{
+  GtkWidget parent_instance;
+
+  int width;
+  int height;
+  GskPath *path;
+  GskPathMeasure *measure;
+  GdkPaintable *background;
+
+  gboolean active;
+};
+
+struct _GtkMazeClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkMaze, gtk_maze, GTK_TYPE_WIDGET)
+
+static void
+gtk_maze_measure (GtkWidget      *widget,
+                  GtkOrientation  orientation,
+                  int             for_size,
+                  int            *minimum,
+                  int            *natural,
+                  int            *minimum_baseline,
+                  int            *natural_baseline)
+{
+  GtkMaze *self = GTK_MAZE (widget);
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = self->width;
+  else
+    *minimum = *natural = self->height;
+}
+
+static void
+gtk_maze_snapshot (GtkWidget   *widget,
+                   GdkSnapshot *snapshot)
+{
+  GtkMaze *self = GTK_MAZE (widget);
+  double width = gtk_widget_get_width (widget);
+  double height = gtk_widget_get_height (widget);
+  GskStroke *stroke;
+
+  stroke = gsk_stroke_new (MAZE_STROKE_SIZE_INACTIVE);
+  if (self->active)
+    gsk_stroke_set_line_width (stroke, MAZE_STROKE_SIZE_ACTIVE);
+  gsk_stroke_set_line_join (stroke, GSK_LINE_JOIN_ROUND);
+  gsk_stroke_set_line_cap (stroke, GSK_LINE_CAP_ROUND);
+  gtk_snapshot_push_stroke (snapshot, self->path, stroke);
+  gsk_stroke_free (stroke);
+
+  if (self->background)
+    {
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+    }
+  else
+    {
+      gtk_snapshot_append_linear_gradient (snapshot,
+                                           &GRAPHENE_RECT_INIT (0, 0, width, height),
+                                           &GRAPHENE_POINT_INIT (0, 0),
+                                           &GRAPHENE_POINT_INIT (width, height),
+                                           (GskColorStop[8]) {
+                                             { 0.0, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.2, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.3, { 1.0, 1.0, 0.0, 1.0 } },
+                                             { 0.4, { 0.0, 1.0, 0.0, 1.0 } },
+                                             { 0.6, { 0.0, 1.0, 1.0, 1.0 } },
+                                             { 0.7, { 0.0, 0.0, 1.0, 1.0 } },
+                                             { 0.8, { 1.0, 0.0, 1.0, 1.0 } },
+                                             { 1.0, { 1.0, 0.0, 1.0, 1.0 } }
+                                           },
+                                           8);
+    }
+
+  gtk_snapshot_pop (snapshot);
+
+}
+
+static void
+gtk_maze_dispose (GObject *object)
+{
+  GtkMaze *self = GTK_MAZE (object);
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->measure, gsk_path_measure_unref);
+  if (self->background)
+    {
+      g_signal_handlers_disconnect_matched (self->background, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
+      g_clear_object (&self->background);
+    }
+
+  G_OBJECT_CLASS (gtk_maze_parent_class)->dispose (object);
+}
+
+static void
+gtk_maze_class_init (GtkMazeClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_maze_dispose;
+
+  widget_class->measure = gtk_maze_measure;
+  widget_class->snapshot = gtk_maze_snapshot;
+}
+
+static void
+celebrate (gboolean win)
+{
+  char *path;
+  GtkMediaStream *stream;
+
+  if (win)
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "complete.oga", NULL);
+  else
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "suspend-error.oga", NULL);
+  stream = gtk_media_file_new_for_filename (path);
+  gtk_media_stream_set_volume (stream, 1.0);
+  gtk_media_stream_play (stream);
+
+  g_signal_connect (stream, "notify::ended", G_CALLBACK (g_object_unref), NULL);
+  g_free (path);
+}
+
+static void
+pointer_motion (GtkEventControllerMotion *controller,
+                double                    x,
+                double                    y,
+                GtkMaze                  *self)
+{
+  GskPathPoint point;
+  float distance;
+
+  if (!self->active)
+    return;
+
+  if (gsk_path_get_closest_point (self->path,
+                                  &GRAPHENE_POINT_INIT (x, y),
+                                  INFINITY,
+                                  &point,
+                                  &distance))
+    {
+      if (distance < MAZE_STROKE_SIZE_ACTIVE / 2.f)
+        return;
+    }
+
+  celebrate (FALSE);
+
+  self->active = FALSE;
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+pointer_leave (GtkEventControllerMotion *controller,
+               GtkMaze                  *self)
+{
+  if (!self->active)
+    {
+      self->active = TRUE;
+      gtk_widget_queue_draw (GTK_WIDGET (self));
+    }
+}
+
+static void
+gtk_maze_init (GtkMaze *self)
+{
+  GtkEventController *controller;
+
+  controller = GTK_EVENT_CONTROLLER (gtk_event_controller_motion_new ());
+  g_signal_connect (controller, "motion", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "leave", G_CALLBACK (pointer_leave), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  self->active = TRUE;
+}
+
+static void
+gtk_maze_set_path (GtkMaze *self,
+                   GskPath *path)
+{
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->measure, gsk_path_measure_unref);
+  self->path = gsk_path_ref (path);
+  self->measure = gsk_path_measure_new (path);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+GtkWidget *
+gtk_maze_new (GskPath      *path,
+              GdkPaintable *background,
+              int           width,
+              int           height)
+{
+  GtkMaze *self;
+
+  self = g_object_new (GTK_TYPE_MAZE, NULL);
+
+  gtk_maze_set_path (self, path);
+  gsk_path_unref (path);
+  self->background = background;
+  if (self->background)
+    {
+      g_signal_connect_swapped (self->background, "invalidate-contents", G_CALLBACK (gtk_widget_queue_draw), self);
+      g_signal_connect_swapped (self->background, "invalidate-size", G_CALLBACK (gtk_widget_queue_resize), self);
+    }
+  self->width = width;
+  self->height = height;
+
+  return GTK_WIDGET (self);
+}
+
+static void
+add_point_to_maze (GtkBitset      *maze,
+                   GskPathBuilder *builder,
+                   guint           x,
+                   guint           y)
+{
+  gboolean set[4] = { FALSE, FALSE, FALSE, FALSE };
+  guint dir;
+
+  gtk_bitset_add (maze, y * MAZE_WIDTH + x);
+
+  while (TRUE)
+    {
+      set[0] = set[0] || x == 0 || gtk_bitset_contains (maze, y * MAZE_WIDTH + x - 1);
+      set[1] = set[1] || y == 0 || gtk_bitset_contains (maze, (y - 1) * MAZE_WIDTH + x);
+      set[2] = set[2] || x + 1 == MAZE_WIDTH || gtk_bitset_contains (maze, y * MAZE_WIDTH + x + 1);
+      set[3] = set[3] || y + 1 == MAZE_HEIGHT || gtk_bitset_contains (maze, (y + 1) * MAZE_WIDTH + x);
+
+      if (set[0] && set[1] && set[2] && set[3])
+        return;
+      
+      do
+        {
+          dir = g_random_int_range (0, 4);
+        }
+      while (set[dir]);
+
+      switch (dir)
+        {
+          case 0:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x - 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x - 1, y);
+            break;
+
+          case 1:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y - 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x, y - 1);
+            break;
+
+          case 2:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 1.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x + 1, y);
+            break;
+
+          case 3:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 1.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x, y + 1);
+            break;
+
+          default:
+            g_assert_not_reached ();
+            break;
+        }
+    }
+}
+
+static GskPath *
+create_path_for_maze (GtkWidget *widget)
+{
+  GskPathBuilder *builder;
+  GtkBitset *maze;
+
+  builder = gsk_path_builder_new ();
+  maze = gtk_bitset_new_empty ();
+  /* make sure the outer lines are unreachable:
+   * Set the full range, then remove the center again. */
+  gtk_bitset_add_range (maze, 0, MAZE_WIDTH * MAZE_HEIGHT);
+  gtk_bitset_remove_rectangle (maze, MAZE_WIDTH + 1, MAZE_WIDTH - 2, MAZE_HEIGHT - 2, MAZE_WIDTH);
+
+  /* Fill the maze */
+  add_point_to_maze (maze, builder, MAZE_WIDTH / 2, MAZE_HEIGHT / 2);
+
+  /* Add start and stop lines */
+  gsk_path_builder_move_to (builder, 1.5 * MAZE_GRID_SIZE, -0.5 * MAZE_GRID_SIZE);
+  gsk_path_builder_line_to (builder, 1.5 * MAZE_GRID_SIZE, 1.5 * MAZE_GRID_SIZE);
+  gsk_path_builder_move_to (builder, (MAZE_WIDTH - 1.5) * MAZE_GRID_SIZE, (MAZE_HEIGHT - 1.5) * MAZE_GRID_SIZE);
+  gsk_path_builder_line_to (builder, (MAZE_WIDTH - 1.5) * MAZE_GRID_SIZE, (MAZE_HEIGHT + 0.5) * MAZE_GRID_SIZE);
+
+
+  gtk_bitset_unref (maze);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+GtkWidget *
+do_path_maze (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *maze;
+      GtkMediaStream *stream;
+      GskPath *path;
+
+      window = gtk_window_new ();
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_title (GTK_WINDOW (window), "Follow the maze with the mouse");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+#if 0
+      stream = gtk_media_file_new_for_resource ("/images/gtk-logo.webm");
+#else
+      stream = gtk_nuclear_media_stream_new ();
+#endif
+      gtk_media_stream_play (stream);
+      gtk_media_stream_set_loop (stream, TRUE);
+
+      path = create_path_for_maze (window);
+
+      maze = gtk_maze_new (path,
+                           GDK_PAINTABLE (stream),
+                           MAZE_WIDTH * MAZE_GRID_SIZE,
+                           MAZE_HEIGHT * MAZE_GRID_SIZE);
+
+      gtk_window_set_child (GTK_WINDOW (window), maze);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}
@@ -0,0 +1,323 @@
+/* Path/Spinner
+ *
+ * This demo shows how to use GskPath to draw a simple animation
+ * that could be used as a spinner.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "paintable.h"
+
+#undef SHOW_CONTROLS
+
+#define GTK_TYPE_SPINNER_PAINTABLE (gtk_spinner_paintable_get_type ())
+G_DECLARE_FINAL_TYPE (GtkSpinnerPaintable, gtk_spinner_paintable, GTK, SPINNER_PAINTABLE, GObject)
+
+struct _GtkSpinnerPaintable
+{
+  GObject parent_instance;
+
+  gint64 start_time;
+
+  int width;
+  double angle;
+  double completion;
+
+  GskPath *circle;
+  GskPath *path;
+  GskStroke *stroke;
+  GdkRGBA color;
+  GdkRGBA circle_color;
+#ifdef SHOW_CONTROLS
+  GskPath *controls;
+  GdkRGBA control_color;
+#endif
+};
+
+struct _GtkSpinnerPaintableClass
+{
+  GObjectClass parent_class;
+};
+
+static int
+gtk_spinner_paintable_get_intrinsic_width (GdkPaintable *paintable)
+{
+  GtkSpinnerPaintable *self = GTK_SPINNER_PAINTABLE (paintable);
+
+  return self->width;
+}
+
+static int
+gtk_spinner_paintable_get_intrinsic_height (GdkPaintable *paintable)
+{
+  GtkSpinnerPaintable *self = GTK_SPINNER_PAINTABLE (paintable);
+
+  return self->width;
+}
+
+static void
+gtk_spinner_paintable_snapshot (GdkPaintable *paintable,
+                                GdkSnapshot  *snapshot,
+                                double        width,
+                                double        height)
+{
+  GtkSpinnerPaintable *self = GTK_SPINNER_PAINTABLE (paintable);
+
+  gtk_snapshot_append_stroke (snapshot, self->circle, self->stroke, &self->circle_color);
+  gtk_snapshot_append_stroke (snapshot, self->path, self->stroke, &self->color);
+#ifdef SHOW_CONTROLS
+  GskStroke *stroke = gsk_stroke_new (1);
+  gtk_snapshot_append_stroke (snapshot, self->controls, stroke, &self->control_color);
+  gsk_stroke_free (stroke);
+#endif
+}
+
+static GdkPaintableFlags
+gtk_spinner_paintable_get_flags (GdkPaintable *paintable)
+{
+  return GDK_PAINTABLE_STATIC_SIZE;
+}
+
+static void
+gtk_spinner_paintable_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->get_intrinsic_width = gtk_spinner_paintable_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_spinner_paintable_get_intrinsic_height;
+  iface->snapshot = gtk_spinner_paintable_snapshot;
+  iface->get_flags = gtk_spinner_paintable_get_flags;
+}
+
+/* When defining the GType, we need to implement the GdkPaintable interface */
+G_DEFINE_TYPE_WITH_CODE (GtkSpinnerPaintable, gtk_spinner_paintable, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                                gtk_spinner_paintable_paintable_init))
+
+static void
+gtk_spinner_paintable_dispose (GObject *object)
+{
+  GtkSpinnerPaintable *self = GTK_SPINNER_PAINTABLE (object);
+
+  gsk_path_unref (self->circle);
+  gsk_path_unref (self->path);
+#ifdef SHOW_CONTROLS
+  gsk_path_unref (self->controls);
+#endif
+
+  gsk_stroke_free (self->stroke);
+
+  G_OBJECT_CLASS (gtk_spinner_paintable_parent_class)->dispose (object);
+}
+
+static void
+gtk_spinner_paintable_class_init (GtkSpinnerPaintableClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_spinner_paintable_dispose;
+}
+
+static void
+gtk_spinner_paintable_init (GtkSpinnerPaintable *self)
+{
+}
+
+static GdkPaintable *
+gtk_spinner_paintable_new (void)
+{
+  GtkSpinnerPaintable *self;
+  GskPathBuilder *builder;
+
+  self = g_object_new (GTK_TYPE_SPINNER_PAINTABLE, NULL);
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_circle (builder, &GRAPHENE_POINT_INIT (50, 50), 40);
+  self->circle = gsk_path_builder_free_to_path (builder);
+
+  self->width = 100;
+  self->angle = 0;
+  self->completion = 1;
+  gdk_rgba_parse (&self->color, "green");
+  gdk_rgba_parse (&self->circle_color, "lightgray");
+#ifdef SHOW_CONTROLS
+  gdk_rgba_parse (&self->control_color, "black");
+#endif
+  self->stroke = gsk_stroke_new (5);
+
+  return GDK_PAINTABLE (self);
+}
+
+#ifdef SHOW_CONTROLS
+static gboolean
+add_controls (GskPathOperation        op,
+              const graphene_point_t *pts,
+              gsize                   n_pts,
+              float                   weight,
+              gpointer                data)
+{
+  GskPathBuilder *builder = data;
+
+  switch (op)
+    {
+    case GSK_PATH_MOVE:
+      gsk_path_builder_move_to (builder, pts[0].x, pts[0].y);
+      break;
+
+    case GSK_PATH_CLOSE:
+    case GSK_PATH_LINE:
+      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
+      break;
+
+    case GSK_PATH_QUAD:
+    case GSK_PATH_CONIC:
+      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
+      gsk_path_builder_line_to (builder, pts[2].x, pts[2].y);
+      break;
+
+    case GSK_PATH_CUBIC:
+      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
+      gsk_path_builder_line_to (builder, pts[2].x, pts[2].y);
+      gsk_path_builder_line_to (builder, pts[3].x, pts[3].y);
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+
+  return TRUE;
+}
+#endif
+
+static void
+update_path (GtkSpinnerPaintable *self)
+{
+  GskPathBuilder *builder;
+  GskPathPoint start, end;
+  graphene_point_t p0, p1;
+  float start_angle, end_angle;
+
+  start_angle = self->angle;
+  end_angle = fmod (self->angle + 360 * self->completion / 100, 360);
+
+  p0 = GRAPHENE_POINT_INIT (50 + 40 * cos (M_PI * start_angle / 180),
+                            50 + 40 * sin (M_PI * start_angle / 180));
+  p1 = GRAPHENE_POINT_INIT (50 + 40 * cos (M_PI * end_angle / 180),
+                            50 + 40 * sin (M_PI * end_angle / 180));
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+
+  gsk_path_get_closest_point (self->circle, &p0, INFINITY, &start, NULL);
+  gsk_path_get_closest_point (self->circle, &p1, INFINITY, &end, NULL);
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_segment (builder, self->circle, &start, &end);
+  self->path = gsk_path_builder_free_to_path (builder);
+
+#ifdef SHOW_CONTROLS
+  g_clear_pointer (&self->controls, gsk_path_unref);
+  builder = gsk_path_builder_new ();
+  gsk_path_foreach (self->path, -1, add_controls, builder);
+  self->controls = gsk_path_builder_free_to_path (builder);
+#endif
+
+  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+}
+
+static void
+gtk_spinner_paintable_set_completion (GtkSpinnerPaintable *self,
+                                   float             completion)
+{
+  self->completion = CLAMP (completion, 0, 100);
+  update_path (self);
+}
+
+static float
+gtk_spinner_paintable_get_completion (GtkSpinnerPaintable *self)
+{
+  return self->completion;
+}
+
+static void
+gtk_spinner_paintable_set_frame_time (GtkSpinnerPaintable *self,
+                                      gint64            time)
+{
+  double delta;
+
+  if (self->start_time == 0)
+    self->start_time = time;
+
+  delta = (time - self->start_time) / (double) G_TIME_SPAN_SECOND;
+  self->angle = fmod (60 * delta, 360);
+  update_path (self);
+}
+
+static gboolean
+tick_cb (GtkWidget *widget,
+         GdkFrameClock *clock,
+         gpointer data)
+{
+  GtkSpinnerPaintable *self = data;
+
+  gtk_spinner_paintable_set_frame_time (self, gdk_frame_clock_get_frame_time (clock));
+  return G_SOURCE_CONTINUE;
+}
+
+static gboolean
+progress_timeout (gpointer data)
+{
+  GtkSpinnerPaintable *self = data;
+  static float progress_delta = 0.5;
+  float progress;
+
+  progress = gtk_spinner_paintable_get_completion (self);
+  if (progress >= 100 || progress <= 0)
+    progress_delta = -progress_delta;
+
+  gtk_spinner_paintable_set_completion (self, progress + progress_delta);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+unset_timeout (gpointer data)
+{
+  g_source_remove (GPOINTER_TO_UINT (data));
+}
+
+GtkWidget *
+do_path_spinner (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *picture;
+      GdkPaintable *paintable;
+      guint timeout_id;
+
+      window = gtk_window_new ();
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_title (GTK_WINDOW (window), "Spinner");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      paintable = gtk_spinner_paintable_new ();
+      picture = gtk_picture_new_for_paintable (paintable);
+      gtk_picture_set_content_fit (GTK_PICTURE (picture), GTK_CONTENT_FIT_CONTAIN);
+      gtk_picture_set_can_shrink (GTK_PICTURE (picture), FALSE);
+      g_object_unref (paintable);
+
+      gtk_widget_add_tick_callback (picture, tick_cb, paintable, NULL);
+      timeout_id = g_timeout_add (100, progress_timeout, paintable);
+
+      g_object_set_data_full (G_OBJECT (picture), "timeout", GUINT_TO_POINTER (timeout_id), unset_timeout);
+
+      gtk_window_set_child (GTK_WINDOW (window), picture);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}
@@ -0,0 +1,584 @@
+/* Path/Text
+ *
+ * This demo shows how to use GskPath to transform a path along another path.
+ *
+ * It also demonstrates that paths can be filled with more interesting
+ * content than just plain colors.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_PATH_WIDGET (gtk_path_widget_get_type ())
+G_DECLARE_FINAL_TYPE (GtkPathWidget, gtk_path_widget, GTK, PATH_WIDGET, GtkWidget)
+
+#define POINT_SIZE 8
+
+enum {
+  PROP_0,
+  PROP_TEXT,
+  PROP_EDITABLE,
+  N_PROPS
+};
+
+struct _GtkPathWidget
+{
+  GtkWidget parent_instance;
+
+  char *text;
+  gboolean editable;
+
+  graphene_point_t points[4];
+
+  guint active_point;
+
+  GskPath *line_path;
+  GskPath *text_path;
+
+  GdkPaintable *background;
+};
+
+struct _GtkPathWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+G_DEFINE_TYPE (GtkPathWidget, gtk_path_widget, GTK_TYPE_WIDGET)
+
+static GskPath *
+create_path_from_text (GtkWidget  *widget,
+                       const char *text,
+                       graphene_point_t *out_offset)
+{
+  PangoLayout *layout;
+  PangoFontDescription *desc;
+  GskPathBuilder *builder;
+  GskPath *result;
+
+  layout = gtk_widget_create_pango_layout (widget, text);
+  desc = pango_font_description_from_string ("sans bold 36");
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_add_layout (builder, layout);
+  result = gsk_path_builder_free_to_path (builder);
+
+  if (out_offset)
+    graphene_point_init (out_offset, 0, - pango_layout_get_baseline (layout) / (double) PANGO_SCALE);
+  g_object_unref (layout);
+
+  return result;
+}
+
+typedef struct
+{
+  GskPathMeasure *measure;
+  GskPathBuilder *builder;
+  graphene_point_t offset;
+  double scale;
+} GtkPathTransform;
+
+static void
+gtk_path_transform_point (GskPathMeasure         *measure,
+                          const graphene_point_t *pt,
+                          const graphene_point_t *offset,
+                          float                   scale,
+                          graphene_point_t       *res)
+{
+  graphene_vec2_t tangent;
+  GskPathPoint point;
+
+  if (gsk_path_measure_get_point (measure, (pt->x + offset->x) * scale, &point))
+    {
+      GskPath *path = gsk_path_measure_get_path (measure);
+
+      gsk_path_point_get_position (&point, path, res);
+      gsk_path_point_get_tangent (&point, path, GSK_PATH_TO_END, &tangent);
+
+      res->x -= (pt->y + offset->y) * scale * graphene_vec2_get_y (&tangent);
+      res->y += (pt->y + offset->y) * scale * graphene_vec2_get_x (&tangent);
+    }
+}
+
+static gboolean
+gtk_path_transform_op (GskPathOperation        op,
+                       const graphene_point_t *pts,
+                       gsize                   n_pts,
+                       float                   weight,
+                       gpointer                data)
+{
+  GtkPathTransform *transform = data;
+
+  switch (op)
+  {
+    case GSK_PATH_MOVE:
+      {
+        graphene_point_t res;
+        gtk_path_transform_point (transform->measure, &pts[0], &transform->offset, transform->scale, &res);
+        gsk_path_builder_move_to (transform->builder, res.x, res.y);
+      }
+      break;
+
+    case GSK_PATH_LINE:
+      {
+        graphene_point_t res;
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res);
+        gsk_path_builder_line_to (transform->builder, res.x, res.y);
+      }
+      break;
+
+    case GSK_PATH_QUAD:
+      {
+        graphene_point_t res[2];
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res[0]);
+        gtk_path_transform_point (transform->measure, &pts[2], &transform->offset, transform->scale, &res[1]);
+        gsk_path_builder_quad_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y);
+      }
+      break;
+
+    case GSK_PATH_CUBIC:
+      {
+        graphene_point_t res[3];
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res[0]);
+        gtk_path_transform_point (transform->measure, &pts[2], &transform->offset, transform->scale, &res[1]);
+        gtk_path_transform_point (transform->measure, &pts[3], &transform->offset, transform->scale, &res[2]);
+        gsk_path_builder_cubic_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y, res[2].x, res[2].y);
+      }
+      break;
+
+    case GSK_PATH_CONIC:
+      {
+        graphene_point_t res[2];
+        gtk_path_transform_point (transform->measure, &pts[1], &transform->offset, transform->scale, &res[0]);
+        gtk_path_transform_point (transform->measure, &pts[3], &transform->offset, transform->scale, &res[1]);
+        gsk_path_builder_conic_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y, weight);
+      }
+      break;
+
+    case GSK_PATH_CLOSE:
+      gsk_path_builder_close (transform->builder);
+      break;
+
+    default:
+      g_assert_not_reached();
+      return FALSE;
+  }
+
+  return TRUE;
+}
+
+static GskPath *
+gtk_path_transform (GskPath                *line_path,
+                    GskPath                *path,
+                    const graphene_point_t *offset)
+{
+  GskPathMeasure *measure = gsk_path_measure_new (line_path);
+  GtkPathTransform transform = { measure, gsk_path_builder_new (), *offset };
+  graphene_rect_t bounds;
+
+  gsk_path_get_bounds (path, &bounds);
+  if (bounds.origin.x + bounds.size.width > 0)
+    transform.scale = gsk_path_measure_get_length (measure) / (bounds.origin.x + bounds.size.width);
+  else
+    transform.scale = 1.0f;
+
+  gsk_path_foreach (path, -1, gtk_path_transform_op, &transform);
+
+  gsk_path_measure_unref (measure);
+
+  return gsk_path_builder_free_to_path (transform.builder);
+}
+
+static void
+gtk_path_widget_clear_text_path (GtkPathWidget *self)
+{
+  g_clear_pointer (&self->text_path, gsk_path_unref);
+}
+
+static void
+gtk_path_widget_clear_paths (GtkPathWidget *self)
+{
+  gtk_path_widget_clear_text_path (self);
+
+  g_clear_pointer (&self->line_path, gsk_path_unref);
+}
+
+static void
+gtk_path_widget_create_text_path (GtkPathWidget *self)
+{
+  GskPath *path;
+  graphene_point_t offset;
+
+  gtk_path_widget_clear_text_path (self);
+
+  path = create_path_from_text (GTK_WIDGET (self), self->text, &offset);
+  self->text_path = gtk_path_transform (self->line_path, path, &offset);
+
+  gsk_path_unref (path);
+}
+
+static void
+gtk_path_widget_create_paths (GtkPathWidget *self)
+{
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  GskPathBuilder *builder;
+
+  gtk_path_widget_clear_paths (self);
+
+  if (width <= 0 || height <= 0)
+    return;
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_move_to (builder,
+                            self->points[0].x * width, self->points[0].y * height);
+  gsk_path_builder_cubic_to (builder,
+                             self->points[1].x * width, self->points[1].y * height,
+                             self->points[2].x * width, self->points[2].y * height,
+                             self->points[3].x * width, self->points[3].y * height);
+  self->line_path = gsk_path_builder_free_to_path (builder);
+
+  gtk_path_widget_create_text_path (self);
+}
+
+static void
+gtk_path_widget_allocate (GtkWidget *widget,
+                          int        width,
+                          int        height,
+                          int        baseline)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (widget);
+
+  GTK_WIDGET_CLASS (gtk_path_widget_parent_class)->size_allocate (widget, width, height, baseline);
+
+  gtk_path_widget_create_paths (self);
+}
+
+static void
+gtk_path_widget_snapshot (GtkWidget   *widget,
+                          GtkSnapshot *snapshot)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (widget);
+  double width = gtk_widget_get_width (widget);
+  double height = gtk_widget_get_height (widget);
+  GskPath *path;
+  GskStroke *stroke;
+  gsize i;
+
+  /* frosted glass the background */
+  gtk_snapshot_push_blur (snapshot, 100);
+  gdk_paintable_snapshot (self->background, snapshot, width, height);
+  gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 1, 1, 1, 0.6 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gtk_snapshot_pop (snapshot);
+
+  /* draw the text */
+  if (self->text_path)
+    {
+      gtk_snapshot_push_fill (snapshot, self->text_path, GSK_FILL_RULE_WINDING);
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+
+      /* ... with an emboss effect */
+      stroke = gsk_stroke_new (2.0);
+      gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT(1, 1));
+      gtk_snapshot_push_stroke (snapshot, self->text_path, stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 0.2 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gsk_stroke_free (stroke);
+      gtk_snapshot_pop (snapshot);
+
+      gtk_snapshot_pop (snapshot);
+    }
+
+  if (self->editable && self->line_path)
+    {
+      GskPathBuilder *builder;
+
+      /* draw the control line */
+      stroke = gsk_stroke_new (1.0);
+      gtk_snapshot_push_stroke (snapshot, self->line_path, stroke);
+      gsk_stroke_free (stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      /* draw the points */
+      builder = gsk_path_builder_new ();
+      for (i = 0; i < 4; i++)
+        {
+          gsk_path_builder_add_circle (builder, &GRAPHENE_POINT_INIT (self->points[i].x * width, self->points[i].y * height), POINT_SIZE);
+        }
+      path = gsk_path_builder_free_to_path (builder);
+
+      gtk_snapshot_push_fill (snapshot, path, GSK_FILL_RULE_WINDING);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 1, 1, 1, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      stroke = gsk_stroke_new (1.0);
+      gtk_snapshot_push_stroke (snapshot, path, stroke);
+      gsk_stroke_free (stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      gsk_path_unref (path);
+    }
+}
+
+static void
+gtk_path_widget_set_text (GtkPathWidget *self,
+                          const char    *text)
+{
+  if (g_strcmp0 (self->text, text) == 0)
+    return;
+
+  g_free (self->text);
+  self->text = g_strdup (text);
+
+  gtk_path_widget_create_paths (self);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TEXT]);
+}
+
+static void
+gtk_path_widget_set_editable (GtkPathWidget *self,
+                              gboolean       editable)
+{
+  if (self->editable == editable)
+    return;
+
+  self->editable = editable;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_EDITABLE]);
+}
+
+static void
+gtk_path_widget_set_property (GObject      *object,
+                              guint         prop_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  switch (prop_id)
+    {
+    case PROP_TEXT:
+      gtk_path_widget_set_text (self, g_value_get_string (value));
+      break;
+
+    case PROP_EDITABLE:
+      gtk_path_widget_set_editable (self, g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_widget_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  switch (prop_id)
+    {
+    case PROP_TEXT:
+      g_value_set_string (value, self->text);
+      break;
+
+    case PROP_EDITABLE:
+      g_value_set_boolean (value, self->editable);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_widget_dispose (GObject *object)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  gtk_path_widget_clear_paths (self);
+
+  G_OBJECT_CLASS (gtk_path_widget_parent_class)->dispose (object);
+}
+
+static void
+gtk_path_widget_class_init (GtkPathWidgetClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_path_widget_dispose;
+  object_class->set_property = gtk_path_widget_set_property;
+  object_class->get_property = gtk_path_widget_get_property;
+
+  widget_class->size_allocate = gtk_path_widget_allocate;
+  widget_class->snapshot = gtk_path_widget_snapshot;
+
+  properties[PROP_TEXT] =
+    g_param_spec_string ("text",
+                         "text",
+                         "Text transformed along a path",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_EDITABLE] =
+    g_param_spec_boolean ("editable",
+                          "editable",
+                          "If the path can be edited by the user",
+                          FALSE,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+drag_begin (GtkGestureDrag *gesture,
+            double          x,
+            double          y,
+            GtkPathWidget  *self)
+{
+  graphene_point_t mouse = GRAPHENE_POINT_INIT (x, y);
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  gsize i;
+
+  for (i = 0; i < 4; i++)
+    {
+      if (graphene_point_distance (&GRAPHENE_POINT_INIT (self->points[i].x * width, self->points[i].y * height), &mouse, NULL, NULL) <= POINT_SIZE)
+        {
+          self->active_point = i;
+          break;
+        }
+    }
+  if (i == 4)
+    {
+      gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
+      return;
+    }
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+drag_update (GtkGestureDrag *drag,
+             double          offset_x,
+             double          offset_y,
+             GtkPathWidget  *self)
+{
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  double start_x, start_y;
+
+  gtk_gesture_drag_get_start_point (drag, &start_x, &start_y);
+
+  self->points[self->active_point] = GRAPHENE_POINT_INIT ((start_x + offset_x) / width,
+                                                          (start_y + offset_y) / height);
+  self->points[self->active_point].x = CLAMP (self->points[self->active_point].x, 0, 1);
+  self->points[self->active_point].y = CLAMP (self->points[self->active_point].y, 0, 1);
+
+  gtk_path_widget_create_paths (self);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+pointer_motion (GtkEventControllerMotion *controller,
+                double                    x,
+                double                    y,
+                GtkPathWidget            *self)
+{
+  GskPathPoint point;
+
+  if (gsk_path_get_closest_point (self->line_path,
+                                  &GRAPHENE_POINT_INIT (x, y),
+                                  INFINITY,
+                                  &point,
+                                  NULL))
+    {
+      gtk_widget_queue_draw (GTK_WIDGET (self));
+    }
+}
+
+static void
+pointer_leave (GtkEventControllerMotion *controller,
+               GtkPathWidget            *self)
+{
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+gtk_path_widget_init (GtkPathWidget *self)
+{
+  GtkEventController *controller;
+
+  controller = GTK_EVENT_CONTROLLER (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_update), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  controller = GTK_EVENT_CONTROLLER (gtk_event_controller_motion_new ());
+  g_signal_connect (controller, "enter", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "motion", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "leave", G_CALLBACK (pointer_leave), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  self->points[0] = GRAPHENE_POINT_INIT (0.1, 0.9);
+  self->points[1] = GRAPHENE_POINT_INIT (0.3, 0.1);
+  self->points[2] = GRAPHENE_POINT_INIT (0.7, 0.1);
+  self->points[3] = GRAPHENE_POINT_INIT (0.9, 0.9);
+
+  self->background = GDK_PAINTABLE (gdk_texture_new_from_resource ("/sliding_puzzle/portland-rose.jpg"));
+
+  gtk_path_widget_set_text (self, "It's almost working");
+}
+
+GtkWidget *
+gtk_path_widget_new (void)
+{
+  GtkPathWidget *self;
+
+  self = g_object_new (GTK_TYPE_PATH_WIDGET, NULL);
+
+  return GTK_WIDGET (self);
+}
+
+GtkWidget *
+do_path_text (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (GTK_TYPE_PATH_WIDGET);
+
+      builder = gtk_builder_new_from_resource ("/path_text/path_text.ui");
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+      g_object_unref (builder);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">Text along a Path</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <child type="end">
+          <object class="GtkToggleButton" id="edit-toggle">
+            <property name="icon-name">document-edit-symbolic</property>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkRevealer">
+            <property name="reveal-child" bind-source="edit-toggle" bind-property="active" bind-flags="sync-create"></property>
+            <child>
+              <object class="GtkEntry" id="text">
+                <property name="text">Through the looking glass</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkPathWidget" id="view">
+            <property name="editable" bind-source="edit-toggle" bind-property="active" bind-flags="sync-create"></property>
+            <property name="text" bind-source="text" bind-property="text" bind-flags="sync-create"></property>
+            <property name="hexpand">true</property>
+            <property name="vexpand">true</property>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>
@@ -0,0 +1,373 @@
+/* Path/Walk
+ *
+ * This demo draws a world map and shows how to animate objects along a GskPath.
+ *
+ * The world map that is used here is a path with 211 lines and 1569 cubic
+ * Bėzier segments in 121 contours.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_PATH_WALK (gtk_path_walk_get_type ())
+G_DECLARE_FINAL_TYPE (GtkPathWalk, gtk_path_walk, GTK, PATH_WALK, GtkWidget)
+
+#define POINT_SIZE 8
+
+enum {
+  PROP_0,
+  PROP_N_POINTS,
+  PROP_PATH,
+  N_PROPS
+};
+
+struct _GtkPathWalk
+{
+  GtkWidget parent_instance;
+
+  GskPath *path;
+  GskPathMeasure *measure;
+  graphene_rect_t bounds;
+  GskPath *arrow_path;
+  guint n_points;
+};
+
+struct _GtkPathWalkClass
+{
+  GtkWidgetClass parent_class;
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+G_DEFINE_TYPE (GtkPathWalk, gtk_path_walk, GTK_TYPE_WIDGET)
+
+static void
+rgba_init_from_hsla (GdkRGBA *rgba,
+                     float    hue,
+                     float    saturation,
+                     float    lightness,
+                     float    alpha)
+{
+  float m1, m2;
+
+  if (lightness <= 0.5)
+    m2 = lightness * (1 + saturation);
+  else
+    m2 = lightness + saturation - lightness * saturation;
+  m1 = 2 * lightness - m2;
+
+  rgba->alpha = alpha;
+
+  if (saturation == 0)
+    {
+      rgba->red = lightness;
+      rgba->green = lightness;
+      rgba->blue = lightness;
+    }
+  else
+    {
+      hue = hue + 120;
+      while (hue > 360)
+        hue -= 360;
+      while (hue < 0)
+        hue += 360;
+
+      if (hue < 60)
+        rgba->red = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        rgba->red = m2;
+      else if (hue < 240)
+        rgba->red = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        rgba->red = m1;
+
+      hue -= 120;
+      if (hue < 0)
+        hue += 360;
+
+      if (hue < 60)
+        rgba->green = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        rgba->green = m2;
+      else if (hue < 240)
+        rgba->green = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        rgba->green = m1;
+
+      hue -= 120;
+      if (hue < 0)
+        hue += 360;
+
+      if (hue < 60)
+        rgba->blue = m1 + (m2 - m1) * hue / 60;
+      else if (hue < 180)
+        rgba->blue = m2;
+      else if (hue < 240)
+        rgba->blue = m1 + (m2 - m1) * (240 - hue) / 60;
+      else
+        rgba->blue = m1;
+    }
+}
+
+static void
+gtk_path_walk_snapshot (GtkWidget   *widget,
+                        GtkSnapshot *snapshot)
+{
+  GtkPathWalk *self = GTK_PATH_WALK (widget);
+  double width = gtk_widget_get_width (widget);
+  double height = gtk_widget_get_height (widget);
+  float length, progress;
+  GskStroke *stroke;
+  guint i;
+
+  if (self->path == NULL)
+    return;
+
+  gtk_snapshot_save (snapshot);
+
+  stroke = gsk_stroke_new (2.0);
+  gtk_snapshot_push_stroke (snapshot, self->path, stroke);
+  gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gtk_snapshot_pop (snapshot);
+  gsk_stroke_free (stroke);
+
+  length = gsk_path_measure_get_length (self->measure);
+  progress = 25.f * gdk_frame_clock_get_frame_time (gtk_widget_get_frame_clock (widget)) / G_USEC_PER_SEC;
+
+  stroke = gsk_stroke_new (1.0);
+  for (i = 0; i < self->n_points; i++)
+    {
+      GskPathPoint point;
+      graphene_point_t position;
+      float angle;
+      GdkRGBA color;
+      float distance;
+
+      distance = i * length / self->n_points;
+      distance = fmod (distance + progress, length);
+
+      gsk_path_measure_get_point (self->measure, distance, &point);
+      gsk_path_point_get_position (&point, self->path, &position);
+      angle = gsk_path_point_get_rotation (&point, self->path, GSK_PATH_FROM_START);
+      rgba_init_from_hsla (&color, 360.f * i / self->n_points, 1, 0.5, 1);
+
+      gtk_snapshot_save (snapshot);
+      gtk_snapshot_translate (snapshot, &position);
+      gtk_snapshot_rotate (snapshot, angle);
+      gtk_snapshot_append_fill (snapshot, self->arrow_path, GSK_FILL_RULE_EVEN_ODD, &color);
+      gtk_snapshot_append_stroke (snapshot, self->arrow_path, stroke, &(GdkRGBA) { 0, 0, 0, 1 });
+      gtk_snapshot_restore (snapshot);
+    }
+
+  gsk_stroke_free (stroke);
+  gtk_snapshot_restore (snapshot);
+}
+
+static void
+gtk_path_walk_measure (GtkWidget      *widget,
+                       GtkOrientation  orientation,
+                       int             for_size,
+                       int            *minimum,
+                       int            *natural,
+                       int            *minimum_baseline,
+                       int            *natural_baseline)
+{
+  GtkPathWalk *self = GTK_PATH_WALK (widget);
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = (int) ceilf (self->bounds.size.width);
+  else
+    *minimum = *natural = (int) ceilf (self->bounds.size.height);
+}
+
+static void
+gtk_path_walk_set_n_points (GtkPathWalk *self,
+                            gsize        n_points)
+{
+  if (self->n_points == n_points)
+    return;
+
+  self->n_points = n_points;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_N_POINTS]);
+}
+
+static void
+gtk_path_walk_set_path (GtkPathWalk *self,
+                        GskPath     *path)
+{
+  if (self->path == path)
+    return;
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  graphene_rect_init (&self->bounds, 0, 0, 0, 0);
+  if (path)
+    {
+      GskStroke *stroke;
+
+      self->path = gsk_path_ref (path);
+      stroke = gsk_stroke_new (2.0);
+      gsk_path_get_stroke_bounds (path, stroke, &self->bounds);
+      gsk_stroke_free (stroke);
+      self->measure = gsk_path_measure_new (self->path);
+    }
+
+  gtk_widget_queue_resize (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PATH]);
+}
+
+static void
+gtk_path_walk_set_property (GObject      *object,
+                            guint         prop_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+
+{
+  GtkPathWalk *self = GTK_PATH_WALK (object);
+
+  switch (prop_id)
+    {
+    case PROP_N_POINTS:
+      gtk_path_walk_set_n_points (self, g_value_get_uint (value));
+      break;
+
+    case PROP_PATH:
+      gtk_path_walk_set_path (self, g_value_get_boxed (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_walk_get_property (GObject    *object,
+                            guint       prop_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  GtkPathWalk *self = GTK_PATH_WALK (object);
+
+  switch (prop_id)
+    {
+    case PROP_N_POINTS:
+      g_value_set_uint (value, self->n_points);
+      break;
+
+    case PROP_PATH:
+      g_value_set_boxed (value, self->path);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_walk_dispose (GObject *object)
+{
+  GtkPathWalk *self = GTK_PATH_WALK (object);
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->measure, gsk_path_measure_unref);
+  g_clear_pointer (&self->arrow_path, gsk_path_unref);
+
+  G_OBJECT_CLASS (gtk_path_walk_parent_class)->dispose (object);
+}
+
+static void
+gtk_path_walk_class_init (GtkPathWalkClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_path_walk_dispose;
+  object_class->set_property = gtk_path_walk_set_property;
+  object_class->get_property = gtk_path_walk_get_property;
+
+  widget_class->snapshot = gtk_path_walk_snapshot;
+  widget_class->measure = gtk_path_walk_measure;
+
+  properties[PROP_N_POINTS] =
+    g_param_spec_uint ("n-points",
+                       NULL, NULL,
+                       1, G_MAXUINT,
+                       500,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_PATH] =
+    g_param_spec_boxed ("path",
+                        NULL, NULL,
+                        GSK_TYPE_PATH,
+                        G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static gboolean
+tick_tick_tick (GtkWidget     *self,
+                GdkFrameClock *frame_clock,
+                gpointer       unused)
+{
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+gtk_path_walk_init (GtkPathWalk *self)
+{
+  /* Data taken from
+   * https://commons.wikimedia.org/wiki/Maps_of_the_world#/media/File:Simplified_blank_world_map_without_Antartica_(no_borders).svg
+   */
+  GBytes *data = g_resources_lookup_data ("/path_walk/path_world.txt", 0, NULL);
+  GskPath *path = gsk_path_parse (g_bytes_get_data (data, NULL));
+  g_bytes_unref (data);
+  gtk_path_walk_set_path (self, path);
+  gsk_path_unref (path);
+  self->arrow_path = gsk_path_parse ("M 5 0 L 0 -5. 0 -2, -5 -2, -5 2, 0 2, 0 5 Z");
+  self->n_points = 500;
+  gtk_widget_add_tick_callback (GTK_WIDGET (self), tick_tick_tick, NULL, NULL);
+}
+
+GtkWidget *
+gtk_path_walk_new (void)
+{
+  GtkPathWalk *self;
+
+  self = g_object_new (GTK_TYPE_PATH_WALK, NULL);
+
+  return GTK_WIDGET (self);
+}
+
+GtkWidget *
+do_path_walk (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (GTK_TYPE_PATH_WALK);
+
+      builder = gtk_builder_new_from_resource ("/path_walk/path_walk.ui");
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+      g_object_unref (builder);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">World Map</property>
+    <property name="titlebar">
+      <object class="GtkHeaderBar">
+        <child type="end">
+          <object class="GtkSpinButton">
+            <property name="adjustment">
+              <object class="GtkAdjustment" id="adjustment">
+                <property name="lower">0</property>
+                <property name="upper">5000</property>
+                <property name="value">500</property>
+                <property name="step-increment">1</property>
+                <property name="page-increment">10</property>
+              </object>
+            </property>
+          </object>
+        </child>
+      </object>
+    </property>
+    <property name="child">
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkPathWalk" id="view">
+            <property name="n-points" bind-source="adjustment" bind-property="value"/>
+            <property name="hexpand">true</property>
+            <property name="vexpand">true</property>
+          </object>
+        </child>
+      </object>
+    </property>
+  </object>
+</interface>
@@ -1,8 +1,9 @@
 /* Pickers and Launchers
- * #Keywords: GtkColorDialog, GtkFontDialog, GtkFileDialog, GtkFileLauncher, GtkUriLauncher
+ * #Keywords: GtkColorDialog, GtkFontDialog, GtkFileDialog, GtkPrintDialog, GtkFileLauncher, GtkUriLauncher
 *
 * The dialogs are mainly intended for use in preference dialogs.
- * They allow to select colors, fonts and applications.
+ * They allow to select colors, fonts and files. There is also a
+ * print dialog.
 *
 * The launchers let you open files or URIs in applications that
 * can handle them.
@@ -11,11 +12,13 @@
 #include <gtk/gtk.h>

 static GtkWidget *app_picker;
+static GtkWidget *print_button;

 static void
 set_file (GFile    *file,
          gpointer  data)
 {
+  GFileInfo *info;
  char *name;

  if (!file)
@@ -31,6 +34,13 @@ set_file (GFile    *file,

  gtk_widget_set_sensitive (app_picker, TRUE);
  g_object_set_data_full (G_OBJECT (app_picker), "file", g_object_ref (file), g_object_unref);
+
+  info = g_file_query_info (file, "standard::content-type", 0, NULL, NULL);
+  if (strcmp (g_file_info_get_content_type (info), "application/pdf") == 0)
+    {
+      gtk_widget_set_sensitive (print_button, TRUE);
+      g_object_set_data_full (G_OBJECT (print_button), "file", g_object_ref (file), g_object_unref);
+    }
 }

 static void
@@ -47,6 +57,10 @@ file_opened (GObject *source,
    {
      g_print ("%s\n", error->message);
      g_error_free (error);
+      gtk_widget_set_sensitive (app_picker, FALSE);
+      g_object_set_data (G_OBJECT (app_picker), "file", NULL);
+      gtk_widget_set_sensitive (print_button, FALSE);
+      g_object_set_data (G_OBJECT (print_button), "file", NULL);
    }

  set_file (file, data);
@@ -114,6 +128,53 @@ open_app (GtkButton *picker)
  g_object_unref (launcher);
 }

+static void
+print_file_done (GObject      *source,
+                 GAsyncResult *result,
+                 gpointer      data)
+{
+  GtkPrintDialog *dialog = GTK_PRINT_DIALOG (source);
+  GError *error = NULL;
+  GCancellable *cancellable;
+  unsigned int id;
+
+  cancellable = g_task_get_cancellable (G_TASK (result));
+  id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (cancellable), "timeout"));
+  if (id)
+    g_source_remove (id);
+
+  if (!gtk_print_dialog_print_file_finish (dialog, result, &error))
+    {
+      g_print ("%s\n", error->message);
+      g_error_free (error);
+    }
+}
+
+static void
+print_file (GtkButton *picker)
+{
+  GtkWindow *parent = GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (picker)));
+  GtkPrintDialog *dialog;
+  GCancellable *cancellable;
+  GFile *file;
+  unsigned int id;
+
+  file = G_FILE (g_object_get_data (G_OBJECT (picker), "file"));
+  dialog = gtk_print_dialog_new ();
+
+  cancellable = g_cancellable_new ();
+
+  id = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
+                                   20,
+                                   abort_mission, g_object_ref (cancellable), g_object_unref);
+  g_object_set_data (G_OBJECT (cancellable), "timeout", GUINT_TO_POINTER (id));
+
+  gtk_print_dialog_print_file (dialog, parent, NULL, file, cancellable, print_file_done, NULL);
+
+  g_object_unref (cancellable);
+  g_object_unref (dialog);
+}
+
 static void
 open_uri_done (GObject      *source,
               GAsyncResult *result,
@@ -234,8 +295,14 @@ do_pickers (GtkWidget *do_widget)
    gtk_widget_set_sensitive (app_picker, FALSE);
    g_signal_connect (app_picker, "clicked", G_CALLBACK (open_app), NULL);
    gtk_box_append (GTK_BOX (picker), app_picker);
-    gtk_grid_attach (GTK_GRID (table), picker, 1, 2, 1, 1);

+    print_button = gtk_button_new_from_icon_name ("printer-symbolic");
+    gtk_widget_set_tooltip_text (print_button, "Print file");
+    gtk_widget_set_sensitive (print_button, FALSE);
+    g_signal_connect (print_button, "clicked", G_CALLBACK (print_file), NULL);
+    gtk_box_append (GTK_BOX (picker), print_button);
+
+    gtk_grid_attach (GTK_GRID (table), picker, 1, 2, 1, 1);

    label = gtk_label_new ("URI:");
    gtk_widget_set_halign (label, GTK_ALIGN_START);
@@ -1,5 +1,4 @@
-#ifndef __PUZZLE_PIECE_H__
-#define __PUZZLE_PIECE_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -19,5 +18,3 @@ GdkPaintable *  gtk_puzzle_piece_new            (GdkPaintable           *puzzle,
 GdkPaintable *  gtk_puzzle_piece_get_puzzle     (GtkPuzzlePiece         *self);
 guint           gtk_puzzle_piece_get_x          (GtkPuzzlePiece         *self);
 guint           gtk_puzzle_piece_get_y          (GtkPuzzlePiece         *self);
-
-#endif /* __PUZZLE_PIECE_H__ */
@@ -1,5 +1,4 @@
-#ifndef SCRIPT_NAMES_H
-#define SCRIPT_NAMES_H
+#pragma once

 #include <glib.h>

@@ -9,5 +8,3 @@ const char * get_script_name (GUnicodeScript script);
 const char * get_script_name_for_tag (guint32 tag);

 G_END_DECLS
-
-#endif
@@ -139,6 +139,7 @@ do_video_player (GtkWidget *do_widget)

      video = gtk_video_new ();
      gtk_video_set_autoplay (GTK_VIDEO (video), TRUE);
+      gtk_video_set_graphics_offload (GTK_VIDEO (video), GTK_GRAPHICS_OFFLOAD_ENABLED);
      gtk_window_set_child (GTK_WINDOW (window), video);

      title = gtk_header_bar_new ();
@@ -4,7 +4,7 @@
 #include "iconbrowserapp.h"
 #include "iconbrowserwin.h"

-#include "demo_conf.h"
+#include "profile_conf.h"

 struct _IconBrowserApp
 {
@@ -1,5 +1,4 @@
-#ifndef __ICON_BROWSER_APP_H
-#define __ICON_BROWSER_APP_H
+#pragma once

 #include <gtk/gtk.h>

@@ -14,6 +13,3 @@ typedef struct _IconBrowserAppClass  IconBrowserAppClass;

 GType           icon_browser_app_get_type    (void);
 IconBrowserApp *icon_browser_app_new         (void);
-
-
-#endif /* __ICON_BROWSER_APP_H */
@@ -1,5 +1,4 @@
-#ifndef __ICON_BROWSER_WIN_H
-#define __ICON_BROWSER_WIN_H
+#pragma once

 #include <gtk/gtk.h>
 #include "iconbrowserapp.h"
@@ -15,6 +14,3 @@ typedef struct _IconBrowserWindowClass    IconBrowserWindowClass;

 GType              icon_browser_window_get_type     (void);
 IconBrowserWindow *icon_browser_window_new          (IconBrowserApp    *app);
-
-
-#endif /* __ICON_BROWSER_WIN_H */
@@ -14,7 +14,7 @@ iconbrowser_resources = gnome.compile_resources('iconbrowser_resources',
 executable('gtk4-icon-browser',
  sources: [iconbrowser_sources, iconbrowser_resources],
  c_args: common_cflags,
-  dependencies: [ libgtk_dep, demo_conf_h ],
+  dependencies: [ libgtk_dep, profile_conf_h ],
  include_directories: confinc,
  win_subsystem: 'windows',
  link_args: extra_demo_ldflags,
@@ -1,16 +1,3 @@
-gen_demo_header = find_program('../build-aux/meson/gen-demo-header.py')
-demo_profile = get_option('demo-profile')
-
-demo_conf_h = declare_dependency(
-  sources: custom_target('demo-header',
-    command: [gen_demo_header, meson.project_source_root(), demo_profile],
-    capture: true,
-    output: 'demo_conf.h',
-    build_by_default: true,
-    build_always_stale: true,
-  )
-)
-
 # appdata

 appdata_config = configuration_data()
@@ -17,8 +17,7 @@
 * Authors: Benjamin Otte <otte@gnome.org>
 */

-#ifndef __GTK_RENDERER_PAINTABLE_H__
-#define __GTK_RENDERER_PAINTABLE_H__
+#pragma once

 #include <gsk/gsk.h>

@@ -39,5 +38,3 @@ void            gtk_renderer_paintable_set_paintable      (GtkRendererPaintable
 GdkPaintable *  gtk_renderer_paintable_get_paintable      (GtkRendererPaintable *self) G_GNUC_PURE;

 G_END_DECLS
-
-#endif /* __GTK_RENDERER_PAINTABLE_H__ */
@@ -12,7 +12,7 @@ node_editor_resources = gnome.compile_resources('node_editor_resources',

 executable('gtk4-node-editor',
  sources: [node_editor_sources, node_editor_resources],
-  dependencies: [ libgtk_dep, demo_conf_h ],
+  dependencies: [ libgtk_dep, profile_conf_h ],
  include_directories: confinc,
  c_args: common_cflags,
  win_subsystem: 'windows',
@@ -19,11 +19,13 @@

 #include "config.h"

+#include <glib/gstdio.h>
+
 #include "node-editor-application.h"

 #include "node-editor-window.h"

-#include "demo_conf.h"
+#include "profile_conf.h"

 static const char *css =
 "textview.editor {"
@@ -247,11 +249,63 @@ node_editor_application_class_init (NodeEditorApplicationClass *class)
  application_class->open = node_editor_application_open;
 }

+static void
+print_version (void)
+{
+  g_print ("gtk4-node-editor %s%s%s\n",
+           PACKAGE_VERSION,
+           g_strcmp0 (PROFILE, "devel") == 0 ? "-" : "",
+           g_strcmp0 (PROFILE, "devel") == 0 ? VCS_TAG : "");
+}
+
+static int
+local_options (GApplication *app,
+               GVariantDict *options,
+               gpointer      data)
+{
+  gboolean version = FALSE;
+  gboolean reset = FALSE;
+
+  g_variant_dict_lookup (options, "version", "b", &version);
+
+  if (version)
+    {
+      print_version ();
+      return 0;
+    }
+
+  g_variant_dict_lookup (options, "reset", "b", &reset);
+
+  if (reset)
+    {
+      char *path;
+
+      path = get_autosave_path ("-unsafe");
+      g_remove (path);
+      g_free (path);
+      path = get_autosave_path (NULL);
+      g_remove (path);
+      g_free (path);
+    }
+
+  return -1;
+}
+
+
 NodeEditorApplication *
 node_editor_application_new (void)
 {
-  return g_object_new (NODE_EDITOR_APPLICATION_TYPE,
-                       "application-id", "org.gtk.gtk4.NodeEditor",
-                       "flags", G_APPLICATION_HANDLES_OPEN,
-                       NULL);
+  NodeEditorApplication *app;
+
+  app = g_object_new (NODE_EDITOR_APPLICATION_TYPE,
+                      "application-id", "org.gtk.gtk4.NodeEditor",
+                      "flags", G_APPLICATION_HANDLES_OPEN,
+                      NULL);
+
+  g_application_add_main_option (G_APPLICATION (app), "version", 0, 0,G_OPTION_ARG_NONE, "Show program version", NULL);
+  g_application_add_main_option (G_APPLICATION (app), "reset", 0, 0,G_OPTION_ARG_NONE, "Remove autosave content", NULL);
+
+  g_signal_connect (app, "handle-local-options", G_CALLBACK (local_options), NULL);
+
+  return app;
 }
@@ -17,8 +17,7 @@
 * Authors: Benjamin Otte <otte@gnome.org>
 */

-#ifndef __NODE_EDITOR_APPLICATION_H__
-#define __NODE_EDITOR_APPLICATION_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -33,6 +32,3 @@ typedef struct _NodeEditorApplicationClass  NodeEditorApplicationClass;

 GType           node_editor_application_get_type    (void);
 NodeEditorApplication *node_editor_application_new         (void);
-
-
-#endif /* __NODE_EDITOR_APPLICATION_H__ */
@@ -24,13 +24,11 @@
 #include "gtkrendererpaintableprivate.h"

 #include "gsk/gskrendernodeparserprivate.h"
-#include "gsk/gl/gskglrenderer.h"
 #ifdef GDK_WINDOWING_BROADWAY
 #include "gsk/broadway/gskbroadwayrenderer.h"
 #endif
-#ifdef GDK_RENDERING_VULKAN
-#include "gsk/vulkan/gskvulkanrenderer.h"
-#endif
+
+#include <glib/gstdio.h>

 #include <cairo.h>
 #ifdef CAIRO_HAS_SVG_SURFACE
@@ -59,6 +57,7 @@ struct _NodeEditorWindow
  GtkWidget *testcase_name_entry;
  GtkWidget *testcase_save_button;
  GtkWidget *scale_scale;
+  GtkWidget *crash_warning;

  GtkWidget *renderer_listbox;
  GListStore *renderers;
@@ -68,6 +67,9 @@ struct _NodeEditorWindow
  GFileMonitor *file_monitor;

  GArray *errors;
+
+  guint update_timeout;
+  gboolean auto_reload;
 };

 struct _NodeEditorWindowClass
@@ -75,6 +77,13 @@ struct _NodeEditorWindowClass
  GtkApplicationWindowClass parent_class;
 };

+enum {
+  PROP_AUTO_RELOAD = 1,
+  NUM_PROPERTIES
+};
+
+static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
+
 G_DEFINE_TYPE(NodeEditorWindow, node_editor_window, GTK_TYPE_APPLICATION_WINDOW);

 static void
@@ -167,19 +176,84 @@ text_iter_skip_whitespace_backward (GtkTextIter *iter)
 }

 static void
-text_changed (GtkTextBuffer    *buffer,
-              NodeEditorWindow *self)
+highlight_text (NodeEditorWindow *self)
+{
+  GtkTextIter iter;
+  GtkTextIter start, end;
+
+  gtk_text_buffer_get_start_iter (self->text_buffer, &iter);
+
+  while (!gtk_text_iter_is_end (&iter))
+    {
+      gunichar c = gtk_text_iter_get_char (&iter);
+
+      if (c == '{')
+        {
+          GtkTextIter word_end = iter;
+          GtkTextIter word_start;
+
+          gtk_text_iter_backward_char (&word_end);
+          text_iter_skip_whitespace_backward (&word_end);
+
+          word_start = word_end;
+          gtk_text_iter_backward_word_start (&word_start);
+          text_iter_skip_alpha_backward (&word_start);
+
+          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "nodename", &word_start, &word_end);
+        }
+      else if (c == ':')
+        {
+          GtkTextIter word_end = iter;
+          GtkTextIter word_start;
+
+          gtk_text_iter_backward_char (&word_end);
+          text_iter_skip_whitespace_backward (&word_end);
+
+          word_start = word_end;
+          gtk_text_iter_backward_word_start (&word_start);
+          text_iter_skip_alpha_backward (&word_start);
+
+          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "propname", &word_start, &word_end);
+        }
+      else if (c == '"')
+        {
+          GtkTextIter string_start = iter;
+          GtkTextIter string_end = iter;
+
+          gtk_text_iter_forward_char (&iter);
+          while (!gtk_text_iter_is_end (&iter))
+            {
+              c = gtk_text_iter_get_char (&iter);
+
+              if (c == '"')
+                {
+                  gtk_text_iter_forward_char (&iter);
+                  string_end = iter;
+                  break;
+                }
+
+              gtk_text_iter_forward_char (&iter);
+            }
+
+          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "string", &string_start, &string_end);
+        }
+
+      gtk_text_iter_forward_char (&iter);
+    }
+
+  gtk_text_buffer_get_bounds (self->text_buffer, &start, &end);
+  gtk_text_buffer_apply_tag_by_name (self->text_buffer, "no-hyphens", &start, &end);
+}
+
+static void
+reload (NodeEditorWindow *self)
 {
  char *text;
  GBytes *bytes;
-  GtkTextIter iter;
-  GtkTextIter start, end;
  float scale;
  GskRenderNode *big_node;

-  g_array_remove_range (self->errors, 0, self->errors->len);
  text = get_current_text (self->text_buffer);
-  text_buffer_remove_all_tags (self->text_buffer);
  bytes = g_bytes_new_take (text, strlen (text));

  g_clear_pointer (&self->node, gsk_render_node_unref);
@@ -240,73 +314,19 @@ text_changed (GtkTextBuffer    *buffer,
    }

  g_clear_pointer (&big_node, gsk_render_node_unref);
+}

-  gtk_text_buffer_get_start_iter (self->text_buffer, &iter);
+static void
+text_changed (GtkTextBuffer    *buffer,
+              NodeEditorWindow *self)
+{
+  g_array_remove_range (self->errors, 0, self->errors->len);
+  text_buffer_remove_all_tags (self->text_buffer);

-  while (!gtk_text_iter_is_end (&iter))
-    {
-      gunichar c = gtk_text_iter_get_char (&iter);
+  if (self->auto_reload)
+    reload (self);

-      if (c == '{')
-        {
-          GtkTextIter word_end = iter;
-          GtkTextIter word_start;
-
-          gtk_text_iter_backward_char (&word_end);
-          text_iter_skip_whitespace_backward (&word_end);
-
-          word_start = word_end;
-          gtk_text_iter_backward_word_start (&word_start);
-          text_iter_skip_alpha_backward (&word_start);
-
-          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "nodename",
-                                             &word_start, &word_end);
-        }
-      else if (c == ':')
-        {
-          GtkTextIter word_end = iter;
-          GtkTextIter word_start;
-
-          gtk_text_iter_backward_char (&word_end);
-          text_iter_skip_whitespace_backward (&word_end);
-
-          word_start = word_end;
-          gtk_text_iter_backward_word_start (&word_start);
-          text_iter_skip_alpha_backward (&word_start);
-
-          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "propname",
-                                             &word_start, &word_end);
-        }
-      else if (c == '"')
-        {
-          GtkTextIter string_start = iter;
-          GtkTextIter string_end = iter;
-
-          gtk_text_iter_forward_char (&iter);
-          while (!gtk_text_iter_is_end (&iter))
-            {
-              c = gtk_text_iter_get_char (&iter);
-
-              if (c == '"')
-                {
-                  gtk_text_iter_forward_char (&iter);
-                  string_end = iter;
-                  break;
-                }
-
-              gtk_text_iter_forward_char (&iter);
-            }
-
-          gtk_text_buffer_apply_tag_by_name (self->text_buffer, "string",
-                                             &string_start, &string_end);
-        }
-
-      gtk_text_iter_forward_char (&iter);
-    }
-
-  gtk_text_buffer_get_bounds (self->text_buffer, &start, &end);
-  gtk_text_buffer_apply_tag_by_name (self->text_buffer, "no-hyphens",
-                                     &start, &end);
+  highlight_text (self);
 }

 static void
@@ -794,7 +814,7 @@ create_cairo_texture (NodeEditorWindow *self)
    return NULL;

  renderer = gsk_cairo_renderer_new ();
-  gsk_renderer_realize (renderer, NULL, NULL);
+  gsk_renderer_realize_for_display (renderer, gtk_widget_get_display (GTK_WIDGET (self)), NULL);

  texture = gsk_renderer_render_texture (renderer, node, NULL);
  gsk_render_node_unref (node);
@@ -866,11 +886,11 @@ export_image_response_cb (GObject      *source,
      GskRenderer *renderer;

      renderer = gsk_gl_renderer_new ();
-      if (!gsk_renderer_realize (renderer, NULL, NULL))
+      if (!gsk_renderer_realize_for_display (renderer, gdk_display_get_default (), NULL))
        {
          g_object_unref (renderer);
          renderer = gsk_cairo_renderer_new ();
-          if (!gsk_renderer_realize (renderer, NULL, NULL))
+          if (!gsk_renderer_realize_for_display (renderer, gdk_display_get_default (), NULL))
            {
              g_assert_not_reached ();
            }
@@ -1105,6 +1125,9 @@ node_editor_window_finalize (GObject *object)
 {
  NodeEditorWindow *self = (NodeEditorWindow *)object;

+  if (self->update_timeout)
+    g_source_remove (self->update_timeout);
+
  g_array_free (self->errors, TRUE);

  g_clear_pointer (&self->node, gsk_render_node_unref);
@@ -1121,8 +1144,11 @@ node_editor_window_add_renderer (NodeEditorWindow *self,
                                 const char       *description)
 {
  GdkPaintable *paintable;
+  GdkDisplay *display;

-  if (!gsk_renderer_realize (renderer, NULL, NULL))
+  display = gtk_widget_get_display (GTK_WIDGET (self));
+
+  if (!gsk_renderer_realize_for_display (renderer, display, NULL))
    {
      GdkSurface *surface = gtk_native_get_surface (GTK_NATIVE (self));
      g_assert (surface != NULL);
@@ -1157,6 +1183,9 @@ node_editor_window_realize (GtkWidget *widget)
  node_editor_window_add_renderer (self,
                                   gsk_gl_renderer_new (),
                                   "OpenGL");
+  node_editor_window_add_renderer (self,
+                                   gsk_ngl_renderer_new (),
+                                   "NGL");
 #ifdef GDK_RENDERING_VULKAN
  node_editor_window_add_renderer (self,
                                   gsk_vulkan_renderer_new (),
@@ -1538,6 +1567,79 @@ edit_action_cb (GtkWidget  *widget,
  node_editor_window_edit (self, &start);
 }

+static void
+node_editor_window_map (GtkWidget *widget)
+{
+  char *path;
+
+  GTK_WIDGET_CLASS (node_editor_window_parent_class)->map (widget);
+
+  path = get_autosave_path (NULL);
+  if (g_file_test (path, G_FILE_TEST_EXISTS))
+    {
+      g_free (path);
+      return;
+    }
+
+  g_free (path);
+}
+
+static void
+node_editor_window_set_property (GObject      *object,
+                                 guint         prop_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+  NodeEditorWindow *self = NODE_EDITOR_WINDOW (object);
+
+  switch (prop_id)
+    {
+    case PROP_AUTO_RELOAD:
+      {
+        gboolean auto_reload = g_value_get_boolean (value);
+        if (self->auto_reload != auto_reload)
+          {
+            self->auto_reload = auto_reload;
+
+            if (self->auto_reload)
+              reload (self);
+          }
+      }
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+node_editor_window_get_property (GObject    *object,
+                                 guint       prop_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+  NodeEditorWindow *self = NODE_EDITOR_WINDOW (object);
+
+  switch (prop_id)
+    {
+    case PROP_AUTO_RELOAD:
+      g_value_set_boolean (value, self->auto_reload);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+close_crash_warning (GtkButton        *button,
+                     NodeEditorWindow *self)
+{
+  gtk_revealer_set_reveal_child (GTK_REVEALER (self->crash_warning), FALSE);
+}
+
 static void
 node_editor_window_class_init (NodeEditorWindowClass *class)
 {
@@ -1549,6 +1651,8 @@ node_editor_window_class_init (NodeEditorWindowClass *class)

  object_class->dispose = node_editor_window_dispose;
  object_class->finalize = node_editor_window_finalize;
+  object_class->set_property = node_editor_window_set_property;
+  object_class->get_property = node_editor_window_get_property;

  gtk_widget_class_set_template_from_resource (widget_class,
                                               "/org/gtk/gtk4/node-editor/node-editor-window.ui");
@@ -1556,6 +1660,14 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
  widget_class->realize = node_editor_window_realize;
  widget_class->unrealize = node_editor_window_unrealize;

+  widget_class->map = node_editor_window_map;
+
+  properties[PROP_AUTO_RELOAD] = g_param_spec_boolean ("auto-reload", NULL, NULL,
+                                                       TRUE,
+                                                       G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_STATIC_NAME);
+
+  g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
+
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, text_view);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, picture);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, renderer_listbox);
@@ -1565,6 +1677,7 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, testcase_name_entry);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, testcase_save_button);
  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, scale_scale);
+  gtk_widget_class_bind_template_child (widget_class, NodeEditorWindow, crash_warning);

  gtk_widget_class_bind_template_callback (widget_class, text_view_query_tooltip_cb);
  gtk_widget_class_bind_template_callback (widget_class, open_cb);
@@ -1577,6 +1690,7 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
  gtk_widget_class_bind_template_callback (widget_class, on_picture_drag_prepare_cb);
  gtk_widget_class_bind_template_callback (widget_class, on_picture_drop_cb);
  gtk_widget_class_bind_template_callback (widget_class, click_gesture_pressed);
+  gtk_widget_class_bind_template_callback (widget_class, close_crash_warning);

  gtk_widget_class_install_action (widget_class, "smart-edit", NULL, edit_action_cb);

@@ -1628,11 +1742,133 @@ static GActionEntry win_entries[] = {
  { "open", window_open, NULL, NULL, NULL },
 };

+char *
+get_autosave_path (const char *suffix)
+{
+  char *path;
+  char *name;
+
+  name = g_strconcat ("autosave", suffix, NULL);
+  path = g_build_filename (g_get_user_cache_dir (), "gtk4-node-editor", name, NULL);
+  g_free (name);
+
+  return path;
+}
+
+static void
+set_initial_text (NodeEditorWindow *self)
+{
+  char *path, *path1;
+  char *initial_text;
+  gsize len;
+
+  path = get_autosave_path (NULL);
+  path1 = get_autosave_path ("-unsafe");
+
+  if (g_file_get_contents (path, &initial_text, &len, NULL))
+    {
+      gtk_text_buffer_set_text (self->text_buffer, initial_text, len);
+      g_free (initial_text);
+    }
+  else if (g_file_get_contents (path1, &initial_text, &len, NULL))
+    {
+      self->auto_reload = FALSE;
+      gtk_revealer_set_reveal_child (GTK_REVEALER (self->crash_warning), TRUE);
+
+      gtk_text_buffer_set_text (self->text_buffer, initial_text, len);
+      g_free (initial_text);
+    }
+  else
+    {
+      /* Default */
+      gtk_text_buffer_set_text (self->text_buffer,
+         "shadow {\n"
+         "  child: texture {\n"
+         "    bounds: 0 0 128 128;\n"
+         "    texture: url(\"resource:///org/gtk/gtk4/node-editor/icons/apps/org.gtk.gtk4.NodeEditor.svg\");\n"
+         "  }\n"
+         "  shadows: rgba(0,0,0,0.5) 0 1 12;\n"
+         "}\n"
+         "\n"
+         "transform {\n"
+         "  child: text {\n"
+         "    color: rgb(46,52,54);\n"
+         "    font: \"Cantarell Bold 11\";\n"
+         "    glyphs: \"GTK Node Editor\";\n"
+         "    offset: 8 14.418;\n"
+         "  }\n"
+         "  transform: translate(0, 140);\n"
+         "}", -1);
+    }
+
+  g_free (path);
+  g_free (path1);
+}
+
+static void
+autosave_contents (NodeEditorWindow *self)
+{
+  char *path = NULL;
+  char *dir = NULL;
+  char *contents;
+  GtkTextIter start, end;
+
+  gtk_text_buffer_get_bounds (self->text_buffer, &start, &end);
+  contents = gtk_text_buffer_get_text (self->text_buffer, &start, &end, TRUE);
+  path = get_autosave_path ("-unsafe");
+  dir = g_path_get_dirname (path);
+  g_mkdir_with_parents (dir, 0755);
+  g_file_set_contents (path, contents, -1, NULL);
+
+  g_free (dir);
+  g_free (path);
+  g_free (contents);
+}
+
+static void
+mark_autosave_as_safe (void)
+{
+  char *path1 = NULL;
+  char *path2 = NULL;
+
+  path1 = get_autosave_path ("-unsafe");
+  path2 = get_autosave_path (NULL);
+
+  g_rename (path1, path2);
+}
+
+static gboolean
+update_timeout_cb (gpointer data)
+{
+  NodeEditorWindow *self = data;
+
+  self->update_timeout = 0;
+
+  mark_autosave_as_safe ();
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+initiate_autosave (NodeEditorWindow *self)
+{
+  autosave_contents (self);
+
+  if (self->update_timeout != 0)
+    g_source_remove (self->update_timeout);
+
+  self->update_timeout = g_timeout_add (100, update_timeout_cb, self);
+}
+
 static void
 node_editor_window_init (NodeEditorWindow *self)
 {
+  GAction *action;
+
  gtk_widget_init_template (GTK_WIDGET (self));

+  self->auto_reload = TRUE;
+
  self->renderers = g_list_store_new (GDK_TYPE_PAINTABLE);
  gtk_list_box_bind_model (GTK_LIST_BOX (self->renderer_listbox),
                           G_LIST_MODEL (self->renderers),
@@ -1645,6 +1881,10 @@ node_editor_window_init (NodeEditorWindow *self)

  g_action_map_add_action_entries (G_ACTION_MAP (self), win_entries, G_N_ELEMENTS (win_entries), self);

+  action = G_ACTION (g_property_action_new ("auto-reload", self, "auto-reload"));
+  g_action_map_add_action (G_ACTION_MAP (self), action);
+  g_object_unref (action);
+
  self->tag_table = gtk_text_tag_table_new ();
  gtk_text_tag_table_add (self->tag_table,
                          g_object_new (GTK_TYPE_TEXT_TAG,
@@ -1682,25 +1922,9 @@ node_editor_window_init (NodeEditorWindow *self)
  g_signal_connect (self->scale_scale, "notify::value", G_CALLBACK (scale_changed), self);
  gtk_text_view_set_buffer (GTK_TEXT_VIEW (self->text_view), self->text_buffer);

-  /* Default */
-  gtk_text_buffer_set_text (self->text_buffer,
-         "shadow {\n"
-         "  child: texture {\n"
-         "    bounds: 0 0 128 128;\n"
-         "    texture: url(\"resource:///org/gtk/gtk4/node-editor/icons/apps/org.gtk.gtk4.NodeEditor.svg\");\n"
-         "  }\n"
-         "  shadows: rgba(0,0,0,0.5) 0 1 12;\n"
-         "}\n"
-         "\n"
-         "transform {\n"
-         "  child: text {\n"
-         "    color: rgb(46,52,54);\n"
-         "    font: \"Cantarell Bold 11\";\n"
-         "    glyphs: \"GTK Node Editor\";\n"
-         "    offset: 8 14.418;\n"
-         "  }\n"
-         "  transform: translate(0, 140);\n"
-         "}", -1);
+  set_initial_text (self);
+
+  g_signal_connect_swapped (self->text_buffer, "changed", G_CALLBACK (initiate_autosave), self);

  if (g_getenv ("GSK_RENDERER"))
    {
@@ -17,8 +17,7 @@
 * Authors: Benjamin Otte <otte@gnome.org>
 */

-#ifndef __NODE_EDITOR_WINDOW_H__
-#define __NODE_EDITOR_WINDOW_H__
+#pragma once

 #include <gtk/gtk.h>

@@ -39,4 +38,4 @@ NodeEditorWindow *      node_editor_window_new          (NodeEditorApplication
 gboolean                node_editor_window_load         (NodeEditorWindow       *self,
                                                         GFile                  *file);

-#endif /* __NODE_EDITOR_WINDOW_H__ */
+char *                  get_autosave_path               (const char             *suffix);
@@ -2,6 +2,14 @@
 <interface>
  <menu id="gear_menu">
    <section>
+      <item>
+        <attribute name="label" translatable="yes">_Reload automatically</attribute>
+        <attribute name="action">win.auto-reload</attribute>
+      </item>
+      <item>
+        <attribute name="label" translatable="yes">_Help</attribute>
+        <attribute name="action">app.help</attribute>
+      </item>
      <item>
        <attribute name="label" translatable="yes">_Help</attribute>
        <attribute name="action">app.help</attribute>
@@ -24,7 +32,6 @@
      </item>
    </section>
  </menu>
-
  <object class="GtkPopover" id="testcase_popover">
    <child>
      <object class="GtkGrid">
@@ -39,7 +46,7 @@
          <object class="GtkEntry" id="testcase_name_entry">
            <property name="hexpand">1</property>
            <property name="activates-default">1</property>
-            <signal name="notify::text" handler="testcase_name_entry_changed_cb" />
+            <signal name="notify::text" handler="testcase_name_entry_changed_cb"/>
          </object>
        </child>
        <child>
@@ -52,7 +59,6 @@
            </layout>
          </object>
        </child>
-
        <child>
          <object class="GtkLabel">
            <property name="wrap">1</property>
@@ -66,7 +72,6 @@
            </layout>
          </object>
        </child>
-
        <child>
          <object class="GtkLabel" id="testcase_error_label">
            <property name="wrap">1</property>
@@ -78,7 +83,6 @@
            </layout>
          </object>
        </child>
-
        <child>
          <object class="GtkButton" id="testcase_save_button">
            <property name="label">Save</property>
@@ -86,9 +90,9 @@
            <property name="halign">end</property>
            <property name="receives-default">1</property>
            <property name="sensitive">0</property>
-            <signal name="clicked" handler="testcase_save_clicked_cb" />
+            <signal name="clicked" handler="testcase_save_clicked_cb"/>
            <style>
-              <class name="suggested-action" />
+              <class name="suggested-action"/>
            </style>
            <layout>
              <property name="row">4</property>
@@ -100,7 +104,6 @@
      </object>
    </child>
  </object>
-
  <template class="NodeEditorWindow" parent="GtkApplicationWindow">
    <property name="title" translatable="yes">GTK Node Editor</property>
    <property name="default-width">1024</property>
@@ -185,83 +188,128 @@
      </object>
    </child>
    <child>
-      <object class="GtkPaned">
-        <property name="shrink-start-child">false</property>
-        <property name="shrink-end-child">false</property>
-        <property name="position">400</property>
-        <property name="start-child">
-          <object class="GtkScrolledWindow">
-            <property name="hscrollbar-policy">never</property>
-            <property name="hexpand">1</property>
-            <property name="vexpand">1</property>
-            <child>
-              <object class="GtkTextView" id="text_view">
-                <property name="wrap-mode">word</property>
-                <property name="monospace">1</property>
-                <property name="top-margin">6</property>
-                <property name="left-margin">6</property>
-                <property name="right-margin">6</property>
-                <property name="bottom-margin">6</property>
-                <property name="has-tooltip">1</property>
-                <property name="extra-menu">extra_menu</property>
-                <signal name="query-tooltip" handler="text_view_query_tooltip_cb"/>
+      <object class="GtkOverlay">
+        <child type="overlay">
+          <object class="GtkRevealer" id="crash_warning">
+            <property name="transition-type">slide-down</property>
+            <property name="halign">center</property>
+            <property name="valign">start</property>
+            <property name="child">
+              <object class="GtkFrame">
                <style>
-                  <class name="editor" />
+                  <class name="app-notification"/>
                </style>
+                <property name="child">
+                  <object class="GtkBox">
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">20</property>
+                    <property name="margin-start">10</property>
+                    <property name="margin-end">10</property>
+                    <property name="margin-top">10</property>
+                    <property name="margin-bottom">10</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="hexpand">1</property>
+                        <property name="halign">1</property>
+                        <property name="label" translatable="1">The application may have crashed.
+As a precaution, auto-loading has been turned off.
+</property>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="GtkButton">
+                        <property name="valign">3</property>
+                        <property name="use-underline">1</property>
+                        <property name="label" translatable="1">_Close</property>
+                        <signal name="clicked" handler="close_crash_warning"/>
+                      </object>
+                    </child>
+                  </object>
+                </property>
+              </object>
+            </property>
+          </object>
+        </child>
+        <property name="child">
+          <object class="GtkPaned">
+            <property name="shrink-start-child">false</property>
+            <property name="shrink-end-child">false</property>
+            <property name="position">400</property>
+            <property name="start-child">
+              <object class="GtkScrolledWindow">
+                <property name="hscrollbar-policy">never</property>
+                <property name="hexpand">1</property>
+                <property name="vexpand">1</property>
                <child>
-                  <object class="GtkGestureClick">
-                    <property name="button">1</property>
-                    <signal name="pressed" handler="click_gesture_pressed"/>
+                  <object class="GtkTextView" id="text_view">
+                    <property name="wrap-mode">word</property>
+                    <property name="monospace">1</property>
+                    <property name="top-margin">6</property>
+                    <property name="left-margin">6</property>
+                    <property name="right-margin">6</property>
+                    <property name="bottom-margin">6</property>
+                    <property name="has-tooltip">1</property>
+                    <property name="extra-menu">extra_menu</property>
+                    <signal name="query-tooltip" handler="text_view_query_tooltip_cb"/>
+                    <style>
+                      <class name="editor"/>
+                    </style>
+                    <child>
+                      <object class="GtkGestureClick">
+                        <property name="button">1</property>
+                        <signal name="pressed" handler="click_gesture_pressed"/>
+                      </object>
+                    </child>
                  </object>
                </child>
              </object>
-            </child>
-          </object>
-        </property>
-        <property name="end-child">
-          <object class="GtkBox">
-            <child>
-              <object class="GtkScrolledWindow">
-                <property name="hexpand">1</property>
-                <property name="vexpand">1</property>
-                <property name="min-content-height">100</property>
-                <property name="min-content-width">100</property>
+            </property>
+            <property name="end-child">
+              <object class="GtkBox">
                <child>
-                  <object class="GtkViewport">
+                  <object class="GtkScrolledWindow">
+                    <property name="hexpand">1</property>
+                    <property name="vexpand">1</property>
+                    <property name="min-content-height">100</property>
+                    <property name="min-content-width">100</property>
                    <child>
-                      <object class="GtkPicture" id="picture">
-                        <property name="can-shrink">0</property>
-                        <property name="halign">center</property>
-                        <property name="valign">center</property>
+                      <object class="GtkViewport">
                        <child>
-                          <object class="GtkDragSource">
+                          <object class="GtkPicture" id="picture">
+                            <property name="can-shrink">0</property>
+                            <property name="halign">center</property>
+                            <property name="valign">center</property>
+                            <child>
+                              <object class="GtkDragSource">
+                                <property name="actions">copy</property>
+                                <signal name="prepare" handler="on_picture_drag_prepare_cb" swapped="no"/>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <child>
+                          <object class="GtkDropTargetAsync">
                            <property name="actions">copy</property>
-                            <signal name="prepare" handler="on_picture_drag_prepare_cb" swapped="no"/>
+                            <property name="formats">application/x-gtk-render-node</property>
+                            <signal name="drop" handler="on_picture_drop_cb" swapped="no"/>
                          </object>
                        </child>
                      </object>
                    </child>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkScrolledWindow">
+                    <property name="hscrollbar-policy">never</property>
                    <child>
-                      <object class="GtkDropTargetAsync">
-                        <property name="actions">copy</property>
-                        <property name="formats">application/x-gtk-render-node</property>
-                        <signal name="drop" handler="on_picture_drop_cb" swapped="no"/>
+                      <object class="GtkListBox" id="renderer_listbox">
+                        <property name="selection-mode">none</property>
                      </object>
                    </child>
                  </object>
                </child>
              </object>
-            </child>
-            <child>
-              <object class="GtkScrolledWindow">
-                <property name="hscrollbar-policy">never</property>
-                <child>
-                  <object class="GtkListBox" id="renderer_listbox">
-                    <property name="selection-mode">none</property>
-                  </object>
-                </child>
-              </object>
-            </child>
+            </property>
          </object>
        </property>
      </object>
--- a/Show More
+++ b/Show More