Demo CSS cache invalidation failure.

.gitlab-ci.yml

@@ -27,41 +27,14 @@ variables:
 
 style-check-diff:
   extends: .only-default
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v17
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
   stage: .pre
   allow_failure: true
   script:
     - .gitlab-ci/run-style-check-diff.sh
 
-.build-fedora-default:
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v17
-  artifacts:
-    when: always
-    reports:
-      junit:
-        - "${CI_PROJECT_DIR}/_build/report-x11.xml"
-        - "${CI_PROJECT_DIR}/_build/report-wayland.xml"
-        - "${CI_PROJECT_DIR}/_build/report-broadway.xml"
-    name: "gtk-${CI_COMMIT_REF_NAME}"
-    paths:
-      - "${CI_PROJECT_DIR}/_build/meson-logs"
-      - "${CI_PROJECT_DIR}/_build/report*.xml"
-      - "${CI_PROJECT_DIR}/_build/report*.html"
-      - "${CI_PROJECT_DIR}/_build/testsuite/reftests/output/*/*.png"
-      - "${CI_PROJECT_DIR}/_build/testsuite/gsk/compare/*/*/*.png"
-      - "${CI_PROJECT_DIR}/_build/testsuite/css/output/*/*.syscap"
-  cache:
-    key: "$CI_JOB_NAME"
-    paths:
-      - _ccache/
-      - subprojects/gdk-pixbuf/
-      - subprojects/glib/
-      - subprojects/graphene/
-      - subprojects/libepoxy/
-      - subprojects/pango/
-
 fedora-x86_64:
-  extends: .build-fedora-default
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
   stage: build
   variables:
     EXTRA_MESON_FLAGS: "--buildtype=debug --default-library=both"
@@ -74,12 +47,26 @@ fedora-x86_64:
             -Dprofiler=true
             _build
     - ninja -C _build
-    - .gitlab-ci/run-tests.sh _build x11
-    - .gitlab-ci/run-tests.sh _build wayland
-    - .gitlab-ci/run-tests.sh _build broadway
+    - .gitlab-ci/run-tests.sh _build
+  artifacts:
+    when: always
+    reports:
+      junit:
+        - "${CI_PROJECT_DIR}/_build/report.xml"
+    name: "gtk-${CI_COMMIT_REF_NAME}"
+    paths:
+      - "${CI_PROJECT_DIR}/_build/meson-logs"
+      - "${CI_PROJECT_DIR}/_build/report.xml"
+      - "${CI_PROJECT_DIR}/_build/report.html"
+      - "${CI_PROJECT_DIR}/_build/testsuite/reftests/output/*.png"
+      - "${CI_PROJECT_DIR}/_build/testsuite/gsk/compare/*/*.png"
+      - "${CI_PROJECT_DIR}/_build/testsuite/css/output/*.syscap"
+  cache:
+    key: "$CI_JOB_NAME"
+    <<: *cache-paths
 
 release-build:
-  extends: .build-fedora-default
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
   stage: build
   variables:
     EXTRA_MESON_FLAGS: "--buildtype=release"
@@ -91,32 +78,42 @@ release-build:
             -Dvulkan=yes
             _build
     - ninja -C _build
-    - .gitlab-ci/run-tests.sh _build x11
+    - .gitlab-ci/run-tests.sh _build
+  artifacts:
+    when: always
+    reports:
+      junit:
+        - "${CI_PROJECT_DIR}/_build/report.xml"
+    name: "gtk-${CI_COMMIT_REF_NAME}"
+    paths:
+      - "${CI_PROJECT_DIR}/_build/meson-logs"
+      - "${CI_PROJECT_DIR}/_build/report.xml"
+      - "${CI_PROJECT_DIR}/_build/report.html"
+      - "${CI_PROJECT_DIR}/_build/testsuite/reftests/output/*.png"
+      - "${CI_PROJECT_DIR}/_build/testsuite/gsk/compare/*/*.png"
+      - "${CI_PROJECT_DIR}/_build/testsuite/css/output/*.syscap"
+  cache:
+    key: "$CI_JOB_NAME"
+    <<: *cache-paths
 
-.mingw-defaults:
+.mingw-defaults: &mingw-defaults
   stage: build
   tags:
-    - win32-ps
+    - win32
   script:
     - C:\msys64\usr\bin\pacman --noconfirm -Syyuu
     - C:\msys64\usr\bin\bash -lc "bash -x ./.gitlab-ci/test-msys2.sh"
   cache:
-    key: "$CI_JOB_NAME"
-    paths:
-      - _ccache/
-      - subprojects/gdk-pixbuf/
-      - subprojects/glib/
-      - subprojects/graphene/
-      - subprojects/libepoxy/
-      - subprojects/pango/
+    key: "%CI_JOB_NAME%"
+    <<: *cache-paths
 
 msys2-mingw32:
-  extends: .mingw-defaults
   variables:
     MSYSTEM: "MINGW32"
     CHERE_INVOKING: "yes"
+  <<: *mingw-defaults
 
-.flatpak-defaults:
+.flatpak-defaults: &flatpak-defaults
   image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:master
   stage: flatpak
   allow_failure: true
@@ -130,45 +127,45 @@ msys2-mingw32:
     - bash -x ./.gitlab-ci/flatpak-build.sh "${APPID}"
 
 # Manual jobs, for branches and MRs
-.flatpak-manual:
-  extends: .flatpak-defaults
+.flatpak-manual: &flatpak-manual
+  <<: *flatpak-defaults
   when: manual
 
 # Only build Flatpak bundles automatically on master
-.flatpak-master:
-  extends: .flatpak-defaults
+.flatpak-master: &flatpak-master
+  <<: *flatpak-defaults
   only:
     - master
 
 flatpak-manual:demo:
-  extends: .flatpak-manual
   variables:
     APPID: org.gtk.Demo4
+  <<: *flatpak-manual
 
 flatpak-master:demo:
-  extends: .flatpak-master
   variables:
     APPID: org.gtk.Demo4
+  <<: *flatpak-master
 
 flatpak-manual:widget-factory:
-  extends: .flatpak-manual
   variables:
     APPID: org.gtk.WidgetFactory4
+  <<: *flatpak-manual
 
 flatpak-master:widget-factory:
-  extends: .flatpak-master
   variables:
     APPID: org.gtk.WidgetFactory4
+  <<: *flatpak-master
 
 flatpak-manual:icon-browser:
-  extends: .flatpak-manual
   variables:
     APPID: org.gtk.IconBrowser4
+  <<: *flatpak-manual
 
 flatpak-master:icon-browser:
-  extends: .flatpak-master
   variables:
     APPID: org.gtk.IconBrowser4
+  <<: *flatpak-master
 
 static-scan:
   image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16

.gitlab-ci/fedora.Dockerfile

@@ -78,8 +78,6 @@ RUN dnf -y install \
     vulkan-devel \
     wayland-devel \
     wayland-protocols-devel \
-    weston \
-    weston-libs \
     which \
     xorg-x11-server-Xvfb \
  && dnf clean all

.gitlab-ci/meson-html-report.py

@@ -138,13 +138,12 @@ ul.images li {
 </head>
 <body>
   <header>
-    <h1>{{ report.project_name }}/{{ report.backend }}/{{ report.branch_name }} :: Test Reports</h1>
+    <h1>{{ report.project_name }}/{{ report.branch_name }} :: Test Reports</h1>
   </header>
 
   <article>
     <section>
       <div class="report-meta">
-        <p><strong>Backend:</strong> {{ report.backend }}</p>
         <p><strong>Branch:</strong> {{ report.branch_name }}</p>
         <p><strong>Date:</strong> <time datetime="{{ report.date.isoformat() }}">{{ report.locale_date }}</time></p>
         {% if report.job_id %}<p><strong>Job ID:</strong> {{ report.job_id }}</p>{% endif %}
@@ -260,9 +259,6 @@ aparser = argparse.ArgumentParser(description='Turns a Meson test log into an HT
 aparser.add_argument('--project-name', metavar='NAME',
                      help='The project name',
                      default='Unknown')
-aparser.add_argument('--backend', metavar='NAME',
-                     help='The used backend',
-                     default='unknown')
 aparser.add_argument('--job-id', metavar='ID',
                      help='The job ID for the report',
                      default=None)
@@ -323,7 +319,6 @@ report = {}
 report['date'] = datetime.datetime.utcnow()
 report['locale_date'] = report['date'].strftime("%c")
 report['project_name'] = args.project_name
-report['backend'] = args.backend
 report['job_id'] = args.job_id
 report['branch_name'] = args.branch
 report['total_successes'] = 0

.gitlab-ci/meson-junit-report.py

@@ -19,9 +19,6 @@ aparser = argparse.ArgumentParser(description='Turns a Meson test log into a JUn
 aparser.add_argument('--project-name', metavar='NAME',
                      help='The project name',
                      default='unknown')
-aparser.add_argument('--backend', metavar='NAME',
-                     help='The used backend',
-                     default='unknown')
 aparser.add_argument('--job-id', metavar='ID',
                      help='The job ID for the report',
                      default='Unknown')
@@ -95,18 +92,18 @@ for name, units in suites.items():
     for unit in successes:
         testcase = ET.SubElement(testsuite, 'testcase')
         testcase.set('classname', '{}/{}'.format(args.project_name, unit['suite']))
-        testcase.set('name', '{}/{}'.format(args.backend, unit['name']))
+        testcase.set('name', unit['name'])
         testcase.set('time', str(unit['duration']))
 
     for unit in failures:
         testcase = ET.SubElement(testsuite, 'testcase')
         testcase.set('classname', '{}/{}'.format(args.project_name, unit['suite']))
-        testcase.set('name', '{}/{}'.format(args.backend, unit['name']))
+        testcase.set('name', unit['name'])
         testcase.set('time', str(unit['duration']))
 
         failure = ET.SubElement(testcase, 'failure')
         failure.set('classname', '{}/{}'.format(args.project_name, unit['suite']))
-        testcase.set('name', '{}/{}'.format(args.backend, unit['name']))
+        failure.set('name', unit['name'])
         failure.set('type', 'error')
         failure.text = unit['stdout']
 

.gitlab-ci/run-docker.sh

@@ -81,7 +81,7 @@ fi
 
 if [ -z $base_version ]; then
         base_version="latest"
-elif [ $base_version != "latest" ]; then
+else
         base_version="v$base_version"
 fi
 
@@ -95,7 +95,7 @@ if [ ! -x "$(command -v docker)" ] || [ docker --help |& grep -q podman ]; then
 else
         echo "Using: Docker"
         format=""
-        CMD="sudo docker"
+        CMD="sudo socker"
 fi
 
 REGISTRY="registry.gitlab.gnome.org"

.gitlab-ci/run-tests.sh

@@ -5,75 +5,30 @@ set +e
 
 srcdir=$( pwd )
 builddir=$1
-backend=$2
 
-case "${backend}" in
-  x11)
-    xvfb-run -a -s "-screen 0 1024x768x24" \
-          meson test -C ${builddir} \
+export GDK_BACKEND=x11
+xvfb-run -a -s "-screen 0 1024x768x24" \
+        meson test -C ${builddir} \
                 --print-errorlogs \
-                --setup=${backend} \
                 --suite=gtk \
-                --no-suite=gtk:a11y \
-                --no-suite=gsk-compare-broadway
+                --no-suite=gtk:a11y
 
-    # Store the exit code for the CI run, but always
-    # generate the reports
-    exit_code=$?
-    ;;
-
-  wayland)
-    export XDG_RUNTIME_DIR="$(mktemp -p $(pwd) -d xdg-runtime-XXXXXX)"
-
-    weston --backend=headless-backend.so --socket=wayland-5 &
-    compositor=$!
-    export WAYLAND_DISPLAY=wayland-5
-
-    meson test -C ${builddir} \
-                --print-errorlogs \
-                --setup=${backend} \
-                --suite=gtk \
-                --no-suite=gtk:a11y \
-                --no-suite=gsk-compare-broadway
-
-    exit_code=$?
-    kill ${compositor}
-    ;;
-
-  broadway)
-    export XDG_RUNTIME_DIR="$(mktemp -p $(pwd) -d xdg-runtime-XXXXXX)"
-
-    ${builddir}/gdk/broadway/gtk4-broadwayd :5 &
-    server=$!
-    export BROADWAY_DISPLAY=:5
-
-    meson test -C ${builddir} \
-                --print-errorlogs \
-                --setup=${backend} \
-                --suite=gtk \
-                --no-suite=gtk:a11y \
-                --no-suite=gsk-compare-opengl
-
-    # don't let Broadway failures fail the run, for now
-    exit_code=0
-    kill ${server}
-    ;;
-esac
+# Store the exit code for the CI run, but always
+# generate the reports
+exit_code=$?
 
 cd ${builddir}
 
 $srcdir/.gitlab-ci/meson-junit-report.py \
         --project-name=gtk \
-        --backend=${backend} \
         --job-id="${CI_JOB_NAME}" \
-        --output=report-${backend}.xml \
-        meson-logs/testlog-${backend}.json
+        --output=report.xml \
+        meson-logs/testlog.json
 $srcdir/.gitlab-ci/meson-html-report.py \
         --project-name=gtk \
-        --backend=${backend} \
         --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" \
+        --output=report.html \
+        meson-logs/testlog.json
 
 exit $exit_code

.gitlab-ci/test-msys2.sh

@@ -34,12 +34,9 @@ pacman --noconfirm -S --needed \
     mingw-w64-$MSYS2_ARCH-shared-mime-info
 
 # https://gitlab.gnome.org/GNOME/gtk/issues/2243
-wget "https://gitlab.gnome.org/creiter/gitlab-ci-win32-runner-v2/raw/master/pango/mingw-w64-$MSYS2_ARCH-pango-1.44.7-1-any.pkg.tar.xz"
+wget "https://gitlab.gnome.org/creiter/gitlab-ci-win32-runner/raw/master/pango/mingw-w64-$MSYS2_ARCH-pango-1.44.7-1-any.pkg.tar.xz"
 pacman --noconfirm -U "mingw-w64-$MSYS2_ARCH-pango-1.44.7-1-any.pkg.tar.xz"
 
-# https://github.com/msys2/MINGW-packages/pull/6465
-pacman --noconfirm -S --needed mingw-w64-$MSYS2_ARCH-brotli
-
 mkdir -p _ccache
 export CCACHE_BASEDIR="$(pwd)"
 export CCACHE_DIR="${CCACHE_BASEDIR}/_ccache"
@@ -48,14 +45,11 @@ export CCACHE_DIR="${CCACHE_BASEDIR}/_ccache"
 ccache --zero-stats
 ccache --show-stats
 export CCACHE_DISABLE=true
-# FIXME: introspection disabled for now because of
-# https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/340
 meson \
     -Dx11-backend=false \
     -Dwayland-backend=false \
     -Dwin32-backend=true \
     -Dvulkan=no \
-    -Dintrospection=false \
     --werror \
     _build
 unset CCACHE_DISABLE

CONTRIBUTING.md

@@ -22,7 +22,12 @@ Please, do not use the issue tracker for support questions. If you have
 questions on how to use GTK effectively, you can use:
 
  - the `#gtk` IRC channel on irc.gnome.org
- - the [gtk tag on the GNOME Discourse instance](https://discourse.gnome.org/tag/gtk)
+ - the [gtk](https://mail.gnome.org/mailman/listinfo/gtk-list) mailing list,
+   for general questions on GTK
+ - the [gtk-app-devel](https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list)
+   mailing list, for questions on application development with GTK
+ - the [gtk-devel](https://mail.gnome.org/mailman/listinfo/gtk-devel-list)
+   mailing list, for questions on developing GTK itself
 
 You can also look at the GTK tag on [Stack
 Overflow](https://stackoverflow.com/questions/tagged/gtk).

NEWS

@@ -1,92 +1,3 @@
-Overview of Changes in GTK 3.98.4
-=================================
-
-* Themes
- - Refine menu styling
- - Tweak visible focus behavior
- - HighConstrast: Add public colors
- - HighContrast: Fix scale borders
-
-* CSS:
- - Drop the nonstandard -gtk-icon-theme property
- - Add a system_setting_changed vfunc to propagate global changes
-
-* Untangle titlebars from windows:
- - Add a GtkWindowControls widget
- - Add a GtkWindowHandle widget
- - Add actions for window menu items
- - Remove app menu fallback from GtkHeaderBar
- - Remove title and subtitle properties from GtkHeaderBar,
-   rename custom-title to title-widget
-
-* GtkWidget
- - Add a focusable property
-
-* GtkPopover:
- -  Fix (re-)positioning issues
-
-* GtkStack:
- - Drop the homogeneous property
- - Add a use-underline property to stack pages
-
-* GtkScale:
- - Make area around the trough clickable
-
-* GtkScrolledWindow:
- - Fix kinetic scrolling
-
-* GtkTreeView:
- - Break reference cycles in unroot
-
-* Drop GtkBin and GtkContainer. All existing GtkBin subclasses
-  have grown a child property with setter and getter. All
-  existing GtkContainer subclasses have grown widget-specific
-  remove (and in some cases, add) functions. <child> in ui
-  files continues to work as before
-
-* Replace gtk_widget_destroy by gtk_window_destroy
-
-* Drop the ::size-allocate signal. Use a GtkWidgetPaintable
-  if you need to be informed about changes to a widgets
-  content or size
-
-* Remove gtk_dialog_run
-
-* GDK:
- - Wayland: Provide a builtin cursor of last resort
- - Change the monitor api to use a GListModel
-
-* GSK:
- - Don't include renderer-specific headers automatically
- - GL: Fix nested rounded clips
-
-* Introspection:
- - Assorted annotation fixes
-
-* Inspector:
- - Preview media resources
- - Show media backend information
-
-* gtk4-widget-factory:
- - Add GtkVideo
- - Add text styles
- - Add a print dialog
- - Add a password entry
- - Improve toolbar styling
- - Revamp transition effects
-
-* gtk4-demo:
- - Replace some demos
-
-* Translation updates:
- Chinese (Taiwan)
- Esperanto
- Japanese
- Romanian
- Spanish
- Ukrainian
-
-
 Overview of Changes in GTK 3.98.3
 =================================
 
@@ -102,33 +13,15 @@ Overview of Changes in GTK 3.98.3
 * GtkEmojiChooser:
  - Improve keyboard navigation
 
-* GtkLabel:
- - Remove pattern API
-
-* GtkAspectFrame:
- - Modernize and simplify
-
 * Chooser buttons:
  - Make dialogs modal by default
 
-* Various widgets:
- - Replace shadow-type and relief properties by
-   a simpler has-frame
-
-* CSS:
- - Use :focus-visible instead of :focus(visible)
- - Add support for :focus-within
-
 * Focus handling
  - Fix crossing event generation
  - Fix focus handling in various widgets
  - Change :can-focus to be recursive
  - Fix GtkWindow:is-active setting
 
-* Scrolling
- - gtk_container_set_focus_[hv]adjustment has been removed
- - gtk_viewport_set_scroll_to_focus has been added
-
 * Accessibility:
  - Add a cursor-aspect-ratio setting
  - Set focus-related states properly
@@ -140,7 +33,6 @@ Overview of Changes in GTK 3.98.3
 * Wayland:
  - Fix .Compose file loading
  - Support popup repositioning
- - Fix problems with autohide popovers
 
 * GDK:
  - Remove GdkKeymap from public API, replaced by
@@ -149,13 +41,10 @@ Overview of Changes in GTK 3.98.3
  - Simplify modifier support, drop GdkModifierIntent
  - Move key event matching to GDK
  - Add GdkSurface::enter/leave-monitor signals
- - Turn GskEvent into a derivable type, and make
-   it introspectable
 
 * GSK:
  - Turn GskRenderNode into a derivable type, and make
    it introspectable
- - Fall back to cairo if compiling shaders fails
 
 * Translation updates:
  - Japanese

README.md

@@ -27,9 +27,9 @@ The official developers blog
 
   - https://blog.gtk.org
 
-Discussion forum
+Information about mailing lists can be found at
 
-  - https://discourse.gnome.org/c/platform/core/
+  - http://www.gtk.org/mailing-lists.php
 
 Nightly documentation can be found at
   - Gtk: https://gnome.pages.gitlab.gnome.org/gtk/gtk/
@@ -140,12 +140,6 @@ In the bug report please include:
 * Further information such as stack traces may be useful, but
   is not necessary.
 
-Contributing to GTK
--------------------
-
-Please, follow the [contribution guide](./CONTRIBUTING.md) to know how to
-start contributing to GTK.
-
 Release notes
 -------------
 
@@ -162,4 +156,4 @@ GTK is released under the terms of the GNU Lesser General Public License,
 version 2.1 or, at your option, any later version, as published by the Free
 Software Foundation.
 
-Please, see the [`COPYING`](./COPYING) file for further information.
+Please, see the `COPYING` file for further information.

config.h.meson

@@ -146,6 +146,9 @@
 /* Have the Xcursor library */
 #mesondefine HAVE_XCURSOR
 
+/* Have the XDAMAGE X extension */
+#mesondefine HAVE_XDAMAGE
+
 /* Have the XFIXES X extension */
 #mesondefine HAVE_XFIXES
 

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

@@ -317,7 +317,7 @@ save_response_cb (GtkNativeDialog        *dialog,
                                                    "Saving failed");
           gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message_dialog),
                                                     "%s", error->message);
-          g_signal_connect (message_dialog, "response", G_CALLBACK (gtk_window_destroy), NULL);
+          g_signal_connect (message_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
           gtk_widget_show (message_dialog);
           g_error_free (error);
         }
@@ -403,7 +403,7 @@ constraint_editor_done (ConstraintEditor *editor,
 
   g_clear_object (&old_constraint);
 
-  gtk_window_destroy (GTK_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW)));
+  gtk_widget_destroy (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW));
 }
 
 static void
@@ -426,7 +426,7 @@ edit_constraint (ConstraintEditorWindow *win,
 
   editor = constraint_editor_new (model, constraint);
 
-  gtk_window_set_child (GTK_WINDOW (window), GTK_WIDGET (editor));
+  gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (editor));
 
   g_signal_connect (editor, "done", G_CALLBACK (constraint_editor_done), win);
 
@@ -444,7 +444,7 @@ guide_editor_done (GuideEditor            *editor,
                    GtkConstraintGuide     *guide,
                    ConstraintEditorWindow *win)
 {
-  gtk_window_destroy (GTK_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW)));
+  gtk_widget_destroy (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW));
 }
 
 static void
@@ -460,7 +460,7 @@ edit_guide (ConstraintEditorWindow *win,
   gtk_window_set_title (GTK_WINDOW (window), "Edit Guide");
 
   editor = guide_editor_new (guide);
-  gtk_window_set_child (GTK_WINDOW (window), GTK_WIDGET (editor));
+  gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (editor));
 
   g_signal_connect (editor, "done", G_CALLBACK (guide_editor_done), win);
   gtk_widget_show (window);
@@ -607,8 +607,8 @@ create_widget_func (gpointer item,
   gtk_widget_set_margin_bottom (label, 10);
   gtk_label_set_xalign (GTK_LABEL (label), 0.0);
   gtk_widget_set_hexpand (label, TRUE);
-  gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box);
-  gtk_box_append (GTK_BOX (box), label);
+  gtk_container_add (GTK_CONTAINER (row), box);
+  gtk_container_add (GTK_CONTAINER (box), label);
 
   if (GTK_IS_CONSTRAINT (item) || GTK_IS_CONSTRAINT_GUIDE (item))
     {
@@ -616,18 +616,18 @@ create_widget_func (gpointer item,
       gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
       g_signal_connect (button, "clicked", G_CALLBACK (row_edit), win);
       g_object_set_data (G_OBJECT (row), "edit", button);
-      gtk_box_append (GTK_BOX (box), button);
+      gtk_container_add (GTK_CONTAINER (box), button);
       button = gtk_button_new_from_icon_name ("edit-delete-symbolic");
       gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
       g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
-      gtk_box_append (GTK_BOX (box), button);
+      gtk_container_add (GTK_CONTAINER (box), button);
     }
   else if (GTK_IS_WIDGET (item))
     {
       button = gtk_button_new_from_icon_name ("edit-delete-symbolic");
       gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
       g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
-      gtk_box_append (GTK_BOX (box), button);
+      gtk_container_add (GTK_CONTAINER (box), button);
     }
 
   g_free (freeme);

demos/constraint-editor/constraint-editor-window.ui

@@ -9,6 +9,7 @@
     <property name="default-height">768</property>
     <child type="titlebar">
       <object class="GtkHeaderBar" id="header">
+        <property name="title" translatable="yes">GTK Constraint Editor</property>
         <property name="show-title-buttons">1</property>
         <child type="start">
           <object class="GtkButton">

demos/constraint-editor/constraint-view.c

@@ -216,7 +216,7 @@ constraint_view_add_child (ConstraintView *view,
   frame = gtk_frame_new (NULL);
   gtk_widget_add_css_class (frame, "child");
   gtk_widget_set_name (frame, name);
-  gtk_frame_set_child (GTK_FRAME (frame), label);
+  gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_widget_set_parent (frame, GTK_WIDGET (view));
 
   update_weak_position (view, frame, 100, 100);
@@ -259,7 +259,7 @@ constraint_view_add_guide (ConstraintView *view,
   frame = gtk_frame_new (NULL);
   gtk_widget_add_css_class (frame, "guide");
   g_object_set_data (G_OBJECT (frame), "internal", (char *)"yes");
-  gtk_frame_set_child (GTK_FRAME (frame), label);
+  gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_widget_insert_after (frame, GTK_WIDGET (view), NULL);
 
   g_object_set_data (G_OBJECT (guide), "frame", frame);

demos/gtk-demo/application.c

@@ -47,7 +47,7 @@ show_action_dialog (GSimpleAction *action)
                                     name);
 
   g_signal_connect (dialog, "response",
-                    G_CALLBACK (gtk_window_destroy), NULL);
+                    G_CALLBACK (gtk_widget_destroy), NULL);
 
   gtk_widget_show (dialog);
 }
@@ -120,7 +120,7 @@ open_response_cb (GtkNativeDialog *dialog,
                                                    "Error loading file: \"%s\"",
                                                    error->message);
           g_signal_connect (message_dialog, "response",
-                            G_CALLBACK (gtk_window_destroy), NULL);
+                            G_CALLBACK (gtk_widget_destroy), NULL);
           gtk_widget_show (message_dialog);
           g_error_free (error);
         }
@@ -234,7 +234,7 @@ activate_quit (GSimpleAction *action,
       win = list->data;
       next = list->next;
 
-      gtk_window_destroy (GTK_WINDOW (win));
+      gtk_widget_destroy (GTK_WIDGET (win));
 
       list = next;
     }
@@ -503,13 +503,13 @@ demo_application_window_unrealize (GtkWidget *widget)
 }
 
 static void
-demo_application_window_dispose (GObject *object)
+demo_application_window_destroy (GtkWidget *widget)
 {
-  DemoApplicationWindow *window = (DemoApplicationWindow *)object;
+  DemoApplicationWindow *window = (DemoApplicationWindow *)widget;
 
   demo_application_window_store_state (window);
 
-  G_OBJECT_CLASS (demo_application_window_parent_class)->dispose (object);
+  GTK_WIDGET_CLASS (demo_application_window_parent_class)->destroy (widget);
 }
 
 static void
@@ -519,11 +519,11 @@ demo_application_window_class_init (DemoApplicationWindowClass *class)
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 
   object_class->constructed = demo_application_window_constructed;
-  object_class->dispose = demo_application_window_dispose;
 
   widget_class->size_allocate = demo_application_window_size_allocate;
   widget_class->realize = demo_application_window_realize;
   widget_class->unrealize = demo_application_window_unrealize;
+  widget_class->destroy = demo_application_window_destroy;
 
   gtk_widget_class_set_template_from_resource (widget_class, "/application_demo/application.ui");
   gtk_widget_class_bind_template_child (widget_class, DemoApplicationWindow, message);

demos/gtk-demo/application_demo.c

@@ -31,7 +31,12 @@ on_name_vanished (GDBusConnection *connection,
   if (!name_seen)
     return;
 
-  g_clear_object (&placeholder);
+  if (placeholder)
+    {
+      gtk_widget_destroy (placeholder);
+      g_object_unref (placeholder);
+      placeholder = NULL;
+    }
 }
 
 #ifdef G_OS_WIN32

demos/gtk-demo/assistant.c

@@ -26,7 +26,7 @@ apply_changes_gradually (gpointer data)
   else
     {
       /* Close automatically once changes are fully applied. */
-      gtk_window_destroy (GTK_WINDOW (data));
+      gtk_widget_destroy (data);
       return G_SOURCE_REMOVE;
     }
 }
@@ -41,7 +41,7 @@ on_assistant_apply (GtkWidget *widget, gpointer data)
 static void
 on_assistant_close_cancel (GtkWidget *widget, gpointer data)
 {
-  gtk_window_destroy (GTK_WINDOW (widget));
+  gtk_widget_destroy (widget);
 }
 
 static void
@@ -95,12 +95,12 @@ create_page1 (GtkWidget *assistant)
   gtk_widget_set_margin_bottom (box, 12);
 
   label = gtk_label_new ("You must fill out this entry to continue:");
-  gtk_box_append (GTK_BOX (box), label);
+  gtk_container_add (GTK_CONTAINER (box), label);
 
   entry = gtk_entry_new ();
   gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
   gtk_widget_set_valign (entry, GTK_ALIGN_CENTER);
-  gtk_box_append (GTK_BOX (box), entry);
+  gtk_container_add (GTK_CONTAINER (box), entry);
   g_signal_connect (G_OBJECT (entry), "changed",
                     G_CALLBACK (on_entry_changed), assistant);
 
@@ -123,7 +123,7 @@ create_page2 (GtkWidget *assistant)
   checkbutton = gtk_check_button_new_with_label ("This is optional data, you may continue "
                                                  "even if you do not check this");
   gtk_widget_set_valign (checkbutton, GTK_ALIGN_CENTER);
-  gtk_box_append (GTK_BOX (box), checkbutton);
+  gtk_container_add (GTK_CONTAINER (box), checkbutton);
 
   gtk_assistant_append_page (GTK_ASSISTANT (assistant), box);
   gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), box, TRUE);
@@ -178,7 +178,8 @@ do_assistant (GtkWidget *do_widget)
 
       gtk_window_set_display (GTK_WINDOW (assistant),
                               gtk_widget_get_display (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (assistant), (gpointer *)&assistant);
+      g_signal_connect (assistant, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &assistant);
 
       create_page1 (assistant);
       create_page2 (assistant);
@@ -198,7 +199,7 @@ do_assistant (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (assistant))
     gtk_widget_show (assistant);
   else
-    gtk_window_destroy (GTK_WINDOW (assistant));
+    gtk_widget_destroy (assistant);
 
   return assistant;
 }

demos/gtk-demo/bluroverlay.c

@@ -39,7 +39,7 @@ enum {
 static guint signals[LAST_SIGNAL] = { 0 };
 static GQuark child_data_quark = 0;
 
-G_DEFINE_TYPE (BlurOverlay, blur_overlay, GTK_TYPE_WIDGET)
+G_DEFINE_TYPE (BlurOverlay, blur_overlay, GTK_TYPE_BIN)
 
 static void
 blur_overlay_set_overlay_child (GtkWidget       *widget,
@@ -204,7 +204,7 @@ blur_overlay_size_allocate (GtkWidget *widget,
   GtkWidget *child;
   GtkWidget *main_widget;
 
-  main_widget = overlay->main_widget;
+  main_widget = gtk_bin_get_child (GTK_BIN (overlay));
   if (main_widget && gtk_widget_get_visible (main_widget))
     gtk_widget_size_allocate (main_widget,
                               &(GtkAllocation) {
@@ -290,6 +290,43 @@ blur_overlay_get_child_position (BlurOverlay    *overlay,
   return TRUE;
 }
 
+static void
+blur_overlay_add (GtkContainer *container,
+                  GtkWidget    *widget)
+{
+  BlurOverlay *overlay = BLUR_OVERLAY (container);
+  gtk_widget_insert_after (widget, GTK_WIDGET (container), NULL);
+  overlay->main_widget = widget;  
+}
+
+static void
+blur_overlay_remove (GtkContainer *container,
+                     GtkWidget    *widget)
+{
+  BlurOverlay *overlay = BLUR_OVERLAY (container);
+  gtk_widget_unparent (widget);
+  if (overlay->main_widget == widget)
+    overlay->main_widget = NULL;
+}
+
+static void
+blur_overlay_forall (GtkContainer *overlay,
+                    GtkCallback   callback,
+                    gpointer      callback_data)
+{
+  GtkWidget *child;
+
+  child = gtk_widget_get_first_child (GTK_WIDGET (overlay));
+  while (child != NULL)
+    {
+      GtkWidget *next = gtk_widget_get_next_sibling (child);
+
+      (* callback) (child, callback_data);
+
+      child = next;
+    }
+}
+
 static void
 blur_overlay_snapshot (GtkWidget   *widget,
                       GtkSnapshot *snapshot)
@@ -383,32 +420,21 @@ blur_overlay_snapshot (GtkWidget   *widget,
   gsk_render_node_unref (main_widget_node);
 }
 
-static void
-blur_overlay_dispose (GObject *object)
-{
-  BlurOverlay *overlay = BLUR_OVERLAY (object);
-  GtkWidget *child;
-
-  g_clear_pointer (&overlay->main_widget, gtk_widget_unparent);
-
-  while ((child = gtk_widget_get_first_child (GTK_WIDGET (overlay))))
-    gtk_widget_unparent (child);
-
-  G_OBJECT_CLASS (blur_overlay_parent_class)->dispose (object);
-}
-
 static void
 blur_overlay_class_init (BlurOverlayClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
-
-  object_class->dispose = blur_overlay_dispose;
+  GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 
   widget_class->measure = blur_overlay_measure;
   widget_class->size_allocate = blur_overlay_size_allocate;
   widget_class->snapshot = blur_overlay_snapshot;
 
+  container_class->add = blur_overlay_add;
+  container_class->remove = blur_overlay_remove;
+  container_class->forall = blur_overlay_forall;
+
   klass->get_child_position = blur_overlay_get_child_position;
 
   signals[GET_CHILD_POSITION] =
@@ -451,11 +477,3 @@ blur_overlay_add_overlay (BlurOverlay *overlay,
 
   blur_overlay_set_overlay_child (widget, child);
 }
-
-void
-blur_overlay_set_child (BlurOverlay *overlay,
-                        GtkWidget   *widget)
-{
-  gtk_widget_insert_after (widget, GTK_WIDGET (overlay), NULL);
-  overlay->main_widget = widget;
-}

demos/gtk-demo/bluroverlay.h

@@ -37,14 +37,14 @@ typedef struct _BlurOverlayClass    BlurOverlayClass;
 
 struct _BlurOverlay
 {
-  GtkWidget parent_instance;
+  GtkBin parent_instance;
 
   GtkWidget *main_widget;
 };
 
 struct _BlurOverlayClass
 {
-  GtkWidgetClass parent_class;
+  GtkBinClass parent_class;
 
   gboolean (*get_child_position) (BlurOverlay   *overlay,
                                   GtkWidget     *widget,
@@ -59,9 +59,6 @@ GDK_AVAILABLE_IN_ALL
 void       blur_overlay_add_overlay (BlurOverlay *overlay,
                                      GtkWidget   *widget,
                                      double       blur);
-GDK_AVAILABLE_IN_ALL
-void       blur_overlay_set_child   (BlurOverlay *overlay,
-                                     GtkWidget   *widget);
 
 G_END_DECLS
 

demos/gtk-demo/builder.c

@@ -12,7 +12,7 @@ quit_activate (GSimpleAction *action,
 {
   GtkWidget *window = user_data;
 
-  gtk_window_destroy (GTK_WINDOW (window));
+  gtk_widget_destroy (window);
 }
 
 static void
@@ -26,10 +26,8 @@ about_activate (GSimpleAction *action,
 
   builder = g_object_get_data (G_OBJECT (window), "builder");
   about_dlg = GTK_WIDGET (gtk_builder_get_object (builder, "aboutdialog1"));
-  gtk_window_set_transient_for (GTK_WINDOW (about_dlg), GTK_WINDOW (window));
-  gtk_window_set_hide_on_close (GTK_WINDOW (about_dlg), TRUE);
-  g_signal_connect (about_dlg, "response", G_CALLBACK (gtk_widget_hide), NULL);
-  gtk_widget_show (about_dlg);
+  gtk_dialog_run (GTK_DIALOG (about_dlg));
+  gtk_widget_hide (about_dlg);
 }
 
 static void
@@ -76,7 +74,8 @@ do_builder (GtkWidget *do_widget)
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
       actions = (GActionGroup*)g_simple_action_group_new ();
       g_action_map_add_action_entries (G_ACTION_MAP (actions),
                                        win_entries, G_N_ELEMENTS (win_entries),
@@ -89,7 +88,7 @@ do_builder (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/clipboard.c

@@ -12,7 +12,6 @@
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 #include <string.h>
-#include "demoimage.h"
 
 static GtkWidget *window = NULL;
 
@@ -69,7 +68,7 @@ paste_received (GObject      *source_object,
                                        "Could not paste text: %s",
                                        error->message);
       g_signal_connect (dialog, "response",
-                        G_CALLBACK (gtk_window_destroy), NULL);
+                        G_CALLBACK (gtk_widget_destroy), NULL);
       gtk_widget_show (dialog);
 
       g_error_free (error);
@@ -94,6 +93,147 @@ paste_button_clicked (GtkWidget *button,
   gdk_clipboard_read_text_async (clipboard, NULL, paste_received, entry);
 }
 
+static GdkPaintable *
+get_image_paintable (GtkImage *image)
+{
+  const gchar *icon_name;
+  GtkIconTheme *icon_theme;
+  GtkIconPaintable *icon;
+
+  switch (gtk_image_get_storage_type (image))
+    {
+    case GTK_IMAGE_PAINTABLE:
+      return g_object_ref (gtk_image_get_paintable (image));
+    case GTK_IMAGE_ICON_NAME:
+      icon_name = gtk_image_get_icon_name (image);
+      icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (GTK_WIDGET (image)));
+      icon = gtk_icon_theme_lookup_icon (icon_theme,
+                                         icon_name,
+                                         NULL,
+                                         48, 1,
+                                         gtk_widget_get_direction (GTK_WIDGET (image)),
+                                         0);
+      if (icon == NULL)
+        return NULL;
+      return GDK_PAINTABLE (icon);
+
+    case GTK_IMAGE_EMPTY:
+    case GTK_IMAGE_GICON:
+    default:
+      g_warning ("Image storage type %d not handled",
+                 gtk_image_get_storage_type (image));
+      return NULL;
+    }
+}
+
+static void
+drag_begin (GtkDragSource *source,
+            GdkDrag       *drag,
+            GtkWidget     *widget)
+{
+  GdkPaintable *paintable;
+
+  paintable = get_image_paintable (GTK_IMAGE (widget));
+  if (paintable)
+    {
+      gtk_drag_source_set_icon (source, paintable, -2, -2);
+      g_object_unref (paintable);
+    }
+}
+
+static GdkContentProvider *
+prepare_drag (GtkDragSource *source,
+              double         x,
+              double         y,
+              GtkWidget     *image)
+{
+  GdkPaintable *paintable = get_image_paintable (GTK_IMAGE (image));
+
+  if (!GDK_IS_TEXTURE (paintable))
+    return NULL;
+
+  return gdk_content_provider_new_typed (GDK_TYPE_TEXTURE, paintable);
+}
+
+static gboolean
+drag_drop (GtkDropTarget *dest,
+           const GValue  *value,
+           double         x,
+           double         y,
+           GtkImage      *image)
+{
+  GdkTexture *texture = g_value_get_object (value);
+  gtk_image_set_from_paintable (GTK_IMAGE (image), GDK_PAINTABLE (texture));
+
+  return TRUE;
+}
+
+static void
+copy_image (GSimpleAction *action,
+            GVariant      *value,
+            gpointer       data)
+{
+  GdkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (data));
+  GdkPaintable *paintable = get_image_paintable (GTK_IMAGE (data));
+
+  if (GDK_IS_TEXTURE (paintable))
+    gdk_clipboard_set_texture (clipboard, GDK_TEXTURE (paintable));
+
+  if (paintable)
+    g_object_unref (paintable);
+}
+
+static void
+paste_image_received (GObject      *source,
+                      GAsyncResult *result,
+                      gpointer      data)
+{
+  GdkTexture *texture;
+
+  texture = gdk_clipboard_read_texture_finish (GDK_CLIPBOARD (source), result, NULL);
+  if (texture == NULL)
+    return;
+    
+  gtk_image_set_from_paintable (GTK_IMAGE (data), GDK_PAINTABLE (texture));
+  g_object_unref (texture);
+}
+
+static void
+paste_image (GSimpleAction *action,
+             GVariant      *value,
+             gpointer       data)
+{
+  GdkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (data));
+  gdk_clipboard_read_texture_async (clipboard, NULL, paste_image_received, data);
+}
+
+static void
+pressed_cb (GtkGesture *gesture,
+            int         n_press,
+            double      x,
+            double      y,
+            GtkWidget  *image)
+{
+  GtkWidget *popover;
+  GMenu *menu;
+  GMenuItem *item;
+
+  menu = g_menu_new (); 
+  item = g_menu_item_new (_("_Copy"), "clipboard.copy");
+  g_menu_append_item (menu, item);
+
+  item = g_menu_item_new (_("_Paste"), "clipboard.paste");
+  g_menu_append_item (menu, item);
+
+  popover = gtk_popover_menu_new_from_model (G_MENU_MODEL (menu));
+  gtk_widget_set_parent (popover, image);
+
+  gtk_popover_set_pointing_to (GTK_POPOVER (popover), &(GdkRectangle) { x, y, 1, 1});
+  gtk_popover_popup (GTK_POPOVER (popover));
+
+  g_object_unref (menu);
+}
+
 GtkWidget *
 do_clipboard (GtkWidget *do_widget)
 {
@@ -103,12 +243,22 @@ do_clipboard (GtkWidget *do_widget)
       GtkWidget *label;
       GtkWidget *entry, *button;
       GtkWidget *image;
+      GtkGesture *gesture;
+      GActionEntry entries[] = {
+        { "copy", copy_image, NULL, NULL, NULL },
+        { "paste", paste_image, NULL, NULL, NULL },
+      };
+      GActionGroup *actions;
+      GtkDragSource *source;
+      GtkDropTarget *dest;
 
       window = gtk_window_new ();
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Clipboard");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
       gtk_widget_set_margin_start (vbox, 8);
@@ -116,76 +266,122 @@ do_clipboard (GtkWidget *do_widget)
       gtk_widget_set_margin_top (vbox, 8);
       gtk_widget_set_margin_bottom (vbox, 8);
 
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       label = gtk_label_new ("\"Copy\" will copy the text\nin the entry to the clipboard");
 
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
       gtk_widget_set_margin_start (hbox, 8);
       gtk_widget_set_margin_end (hbox, 8);
       gtk_widget_set_margin_top (hbox, 8);
       gtk_widget_set_margin_bottom (hbox, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
       /* Create the first entry */
       entry = gtk_entry_new ();
-      gtk_box_append (GTK_BOX (hbox), entry);
+      gtk_container_add (GTK_CONTAINER (hbox), entry);
 
       /* Create the button */
       button = gtk_button_new_with_mnemonic (_("_Copy"));
-      gtk_box_append (GTK_BOX (hbox), button);
+      gtk_container_add (GTK_CONTAINER (hbox), button);
       g_signal_connect (button, "clicked",
                         G_CALLBACK (copy_button_clicked), entry);
 
       label = gtk_label_new ("\"Paste\" will paste the text from the clipboard to the entry");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
       gtk_widget_set_margin_start (hbox, 8);
       gtk_widget_set_margin_end (hbox, 8);
       gtk_widget_set_margin_top (hbox, 8);
       gtk_widget_set_margin_bottom (hbox, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
       /* Create the second entry */
       entry = gtk_entry_new ();
-      gtk_box_append (GTK_BOX (hbox), entry);
+      gtk_container_add (GTK_CONTAINER (hbox), entry);
 
       /* Create the button */
       button = gtk_button_new_with_mnemonic (_("_Paste"));
-      gtk_box_append (GTK_BOX (hbox), button);
+      gtk_container_add (GTK_CONTAINER (hbox), button);
       g_signal_connect (button, "clicked",
                         G_CALLBACK (paste_button_clicked), entry);
 
       label = gtk_label_new ("Images can be transferred via the clipboard, too");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
       gtk_widget_set_margin_start (hbox, 8);
       gtk_widget_set_margin_end (hbox, 8);
       gtk_widget_set_margin_top (hbox, 8);
       gtk_widget_set_margin_bottom (hbox, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
       /* Create the first image */
-      image = demo_image_new ("dialog-warning");
-      gtk_box_append (GTK_BOX (hbox), image);
+      image = gtk_image_new_from_icon_name ("dialog-warning");
+      gtk_image_set_pixel_size (GTK_IMAGE (image), 48);
+      gtk_container_add (GTK_CONTAINER (hbox), image);
+
+      /* make image a drag source */
+      source = gtk_drag_source_new ();
+      g_signal_connect (source, "prepare", G_CALLBACK (prepare_drag), NULL);
+      g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), image);
+      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (source));
+
+      /* accept drops on image */
+      dest = gtk_drop_target_new (GDK_TYPE_TEXTURE, GDK_ACTION_COPY);
+      g_signal_connect (dest, "drop", G_CALLBACK (drag_drop), image);
+      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (dest));
+
+      /* context menu on image */
+      gesture = gtk_gesture_click_new ();
+      gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
+      g_signal_connect (gesture, "pressed", G_CALLBACK (pressed_cb), image);
+      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (gesture));
+
+      actions = G_ACTION_GROUP (g_simple_action_group_new ());
+      g_action_map_add_action_entries (G_ACTION_MAP (actions), entries, G_N_ELEMENTS (entries), image);
+
+      gtk_widget_insert_action_group (image, "clipboard", actions);
+
+      g_object_unref (actions);
 
       /* Create the second image */
-      image = demo_image_new ("process-stop");
-      gtk_box_append (GTK_BOX (hbox), image);
+      image = gtk_image_new_from_icon_name ("process-stop");
+      gtk_image_set_pixel_size (GTK_IMAGE (image), 48);
+      gtk_container_add (GTK_CONTAINER (hbox), image);
 
-      /* Create the third image */
-      image = demo_image_new ("weather-clear");
-      gtk_box_append (GTK_BOX (hbox), image);
+      /* make image a drag source */
+      source = gtk_drag_source_new ();
+      g_signal_connect (source, "prepare", G_CALLBACK (prepare_drag), NULL);
+      g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), image);
+      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (source));
+
+      /* accept drops on image */
+      dest = gtk_drop_target_new (GDK_TYPE_TEXTURE, GDK_ACTION_COPY);
+      g_signal_connect (dest, "drop", G_CALLBACK (drag_drop), image);
+      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (dest));
+
+      /* context menu on image */
+      gesture = gtk_gesture_click_new ();
+      gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
+      g_signal_connect (gesture, "pressed", G_CALLBACK (pressed_cb), image);
+      gtk_widget_add_controller (image, GTK_EVENT_CONTROLLER (gesture));
+
+      actions = G_ACTION_GROUP (g_simple_action_group_new ());
+      g_action_map_add_action_entries (G_ACTION_MAP (actions), entries, G_N_ELEMENTS (entries), image);
+
+      gtk_widget_insert_action_group (image, "clipboard", actions);
+
+      g_object_unref (actions);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/colorsel.c

@@ -0,0 +1,118 @@
+/* Color Chooser
+ *
+ * A GtkColorChooser lets the user choose a color. There are several
+ * implementations of the GtkColorChooser interface in GTK. The
+ * GtkColorChooserDialog is a prebuilt dialog containing a
+ * GtkColorChooserWidget.
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+static GtkWidget *da;
+static GdkRGBA color;
+static GtkWidget *frame;
+
+/* draw callback for the drawing area
+ */
+static void
+draw_function (GtkDrawingArea *drawing_area,
+               cairo_t        *cr,
+               int             width,
+               int             height,
+               gpointer        data)
+{
+  gdk_cairo_set_source_rgba (cr, &color);
+  cairo_paint (cr);
+}
+
+static void
+response_cb (GtkDialog *dialog,
+             gint       response_id,
+             gpointer   user_data)
+{
+  if (response_id == GTK_RESPONSE_OK)
+    {
+      gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (dialog), &color);
+      gtk_widget_queue_draw (da);
+    }
+
+  gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
+static void
+change_color_callback (GtkWidget *button,
+                       gpointer   data)
+{
+  GtkWidget *dialog;
+
+  dialog = gtk_color_chooser_dialog_new ("Changing color", GTK_WINDOW (window));
+  gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+  gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (dialog), &color);
+
+  g_signal_connect (dialog, "response",
+                    G_CALLBACK (response_cb), NULL);
+
+  gtk_widget_show (dialog);
+}
+
+GtkWidget *
+do_colorsel (GtkWidget *do_widget)
+{
+  GtkWidget *vbox;
+  GtkWidget *button;
+
+  if (!window)
+    {
+      color.red = 0;
+      color.blue = 1;
+      color.green = 0;
+      color.alpha = 1;
+
+      window = gtk_window_new ();
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Color Chooser");
+      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
+      gtk_widget_set_margin_start (vbox, 12);
+      gtk_widget_set_margin_end (vbox, 12);
+      gtk_widget_set_margin_top (vbox, 12);
+      gtk_widget_set_margin_bottom (vbox, 12);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
+
+      /*
+       * Create the color swatch area
+       */
+
+      frame = gtk_frame_new (NULL);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
+
+      da = gtk_drawing_area_new ();
+      gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 200);
+      gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (da), 200);
+      gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), draw_function, NULL, NULL);
+
+      gtk_container_add (GTK_CONTAINER (frame), da);
+
+      button = gtk_button_new_with_mnemonic ("_Change the above color");
+      gtk_widget_set_halign (button, GTK_ALIGN_END);
+      gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+
+      gtk_container_add (GTK_CONTAINER (vbox), button);
+
+      g_signal_connect (button, "clicked",
+                        G_CALLBACK (change_color_callback), NULL);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

demos/gtk-demo/combobox.c

@@ -315,32 +315,34 @@ do_combobox (GtkWidget *do_widget)
     gtk_window_set_display (GTK_WINDOW (window),
                             gtk_widget_get_display (do_widget));
     gtk_window_set_title (GTK_WINDOW (window), "Combo Boxes");
-    g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed), &window);
 
     vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
     gtk_widget_set_margin_start (vbox, 10);
     gtk_widget_set_margin_end (vbox, 10);
     gtk_widget_set_margin_top (vbox, 10);
     gtk_widget_set_margin_bottom (vbox, 10);
-    gtk_window_set_child (GTK_WINDOW (window), vbox);
+    gtk_container_add (GTK_CONTAINER (window), vbox);
 
     /* A combobox demonstrating cell renderers, separators and
      *  insensitive rows
      */
     frame = gtk_frame_new ("Items with icons");
-    gtk_box_append (GTK_BOX (vbox), frame);
+    gtk_container_add (GTK_CONTAINER (vbox), frame);
 
     box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
     gtk_widget_set_margin_start (box, 5);
     gtk_widget_set_margin_end (box, 5);
     gtk_widget_set_margin_top (box, 5);
     gtk_widget_set_margin_bottom (box, 5);
-    gtk_frame_set_child (GTK_FRAME (frame), box);
+    gtk_container_add (GTK_CONTAINER (frame), box);
 
     model = create_icon_store ();
     combo = gtk_combo_box_new_with_model (model);
     g_object_unref (model);
-    gtk_box_append (GTK_BOX (box), combo);
+    gtk_container_add (GTK_CONTAINER (box), combo);
 
     renderer = gtk_cell_renderer_pixbuf_new ();
     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
@@ -372,19 +374,19 @@ do_combobox (GtkWidget *do_widget)
     /* A combobox demonstrating trees.
      */
     frame = gtk_frame_new ("Where are we ?");
-    gtk_box_append (GTK_BOX (vbox), frame);
+    gtk_container_add (GTK_CONTAINER (vbox), frame);
 
     box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
     gtk_widget_set_margin_start (box, 5);
     gtk_widget_set_margin_end (box, 5);
     gtk_widget_set_margin_top (box, 5);
     gtk_widget_set_margin_bottom (box, 5);
-    gtk_frame_set_child (GTK_FRAME (frame), box);
+    gtk_container_add (GTK_CONTAINER (frame), box);
 
     model = create_capital_store ();
     combo = gtk_combo_box_new_with_model (model);
     g_object_unref (model);
-    gtk_box_append (GTK_BOX (box), combo);
+    gtk_container_add (GTK_CONTAINER (box), combo);
 
     renderer = gtk_cell_renderer_text_new ();
     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
@@ -403,52 +405,53 @@ do_combobox (GtkWidget *do_widget)
 
     /* A GtkComboBoxEntry with validation */
     frame = gtk_frame_new ("Editable");
-    gtk_box_append (GTK_BOX (vbox), frame);
+    gtk_container_add (GTK_CONTAINER (vbox), frame);
 
     box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
     gtk_widget_set_margin_start (box, 5);
     gtk_widget_set_margin_end (box, 5);
     gtk_widget_set_margin_top (box, 5);
     gtk_widget_set_margin_bottom (box, 5);
-    gtk_frame_set_child (GTK_FRAME (frame), box);
+    gtk_container_add (GTK_CONTAINER (frame), box);
 
     combo = gtk_combo_box_text_new_with_entry ();
     fill_combo_entry (combo);
-    gtk_box_append (GTK_BOX (box), combo);
+    gtk_container_add (GTK_CONTAINER (box), combo);
 
     entry = g_object_new (TYPE_MASK_ENTRY, NULL);
     MASK_ENTRY (entry)->mask = "^([0-9]*|One|Two|2\302\275|Three)$";
 
-    gtk_combo_box_set_child (GTK_COMBO_BOX (combo), entry);
+    gtk_container_remove (GTK_CONTAINER (combo), gtk_bin_get_child (GTK_BIN (combo)));
+    gtk_container_add (GTK_CONTAINER (combo), entry);
 
     /* A combobox with string IDs */
     frame = gtk_frame_new ("String IDs");
-    gtk_box_append (GTK_BOX (vbox), frame);
+    gtk_container_add (GTK_CONTAINER (vbox), frame);
 
     box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
     gtk_widget_set_margin_start (box, 5);
     gtk_widget_set_margin_end (box, 5);
     gtk_widget_set_margin_top (box, 5);
     gtk_widget_set_margin_bottom (box, 5);
-    gtk_frame_set_child (GTK_FRAME (frame), box);
+    gtk_container_add (GTK_CONTAINER (frame), box);
 
     combo = gtk_combo_box_text_new ();
     gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "never", "Not visible");
     gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "when-active", "Visible when active");
     gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "always", "Always visible");
-    gtk_box_append (GTK_BOX (box), combo);
+    gtk_container_add (GTK_CONTAINER (box), combo);
 
     entry = gtk_entry_new ();
     g_object_bind_property (combo, "active-id",
                             entry, "text",
                             G_BINDING_BIDIRECTIONAL);
-    gtk_box_append (GTK_BOX (box), entry);
+    gtk_container_add (GTK_CONTAINER (box), entry);
   }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/constraints.c

@@ -21,24 +21,23 @@ struct _SimpleGrid
 G_DEFINE_TYPE (SimpleGrid, simple_grid, GTK_TYPE_WIDGET)
 
 static void
-simple_grid_dispose (GObject *object)
+simple_grid_destroy (GtkWidget *widget)
 {
-  SimpleGrid *self = SIMPLE_GRID (object);
+  SimpleGrid *self = SIMPLE_GRID (widget);
 
-  g_clear_pointer (&self->button1, gtk_widget_unparent);
-  g_clear_pointer (&self->button2, gtk_widget_unparent);
-  g_clear_pointer (&self->button3, gtk_widget_unparent);
+  g_clear_pointer (&self->button1, gtk_widget_destroy);
+  g_clear_pointer (&self->button2, gtk_widget_destroy);
+  g_clear_pointer (&self->button3, gtk_widget_destroy);
 
-  G_OBJECT_CLASS (simple_grid_parent_class)->dispose (object);
+  GTK_WIDGET_CLASS (simple_grid_parent_class)->destroy (widget);
 }
 
 static void
 simple_grid_class_init (SimpleGridClass *klass)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
-  object_class->dispose = simple_grid_dispose;
+  widget_class->destroy = simple_grid_destroy;
 
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_CONSTRAINT_LAYOUT);
 }
@@ -258,32 +257,33 @@ do_constraints (GtkWidget *do_widget)
 
      window = gtk_window_new ();
      gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget));
-     gtk_window_set_title (GTK_WINDOW (window), "Constraints");
 
      header = gtk_header_bar_new ();
+     gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Constraints");
      gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
      gtk_window_set_titlebar (GTK_WINDOW (window), header);
-     g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+     g_signal_connect (window, "destroy",
+                       G_CALLBACK (gtk_widget_destroyed), &window);
 
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
-     gtk_window_set_child (GTK_WINDOW (window), box);
+     gtk_container_add (GTK_CONTAINER (window), box);
 
      grid = g_object_new (simple_grid_get_type (), NULL);
      gtk_widget_set_hexpand (grid, TRUE);
      gtk_widget_set_vexpand (grid, TRUE);
-     gtk_box_append (GTK_BOX (box), grid);
+     gtk_container_add (GTK_CONTAINER (box), grid);
 
      button = gtk_button_new_with_label ("Close");
-     gtk_box_append (GTK_BOX (box), button);
+     gtk_container_add (GTK_CONTAINER (box), button);
      gtk_widget_set_hexpand (grid, TRUE);
      g_signal_connect_swapped (button, "clicked",
-                               G_CALLBACK (gtk_window_destroy), window);
+                               G_CALLBACK (gtk_widget_destroy), window);
    }
 
  if (!gtk_widget_get_visible (window))
    gtk_widget_show (window);
  else
-   gtk_window_destroy (GTK_WINDOW (window));
+   gtk_widget_destroy (window);
 
  return window;
 }

demos/gtk-demo/constraints2.c

@@ -22,24 +22,23 @@ struct _InteractiveGrid
 G_DEFINE_TYPE (InteractiveGrid, interactive_grid, GTK_TYPE_WIDGET)
 
 static void
-interactive_grid_dispose (GObject *object)
+interactive_grid_destroy (GtkWidget *widget)
 {
-  InteractiveGrid *self = INTERACTIVE_GRID (object);
+  InteractiveGrid *self = INTERACTIVE_GRID (widget);
 
-  g_clear_pointer (&self->button1, gtk_widget_unparent);
-  g_clear_pointer (&self->button2, gtk_widget_unparent);
-  g_clear_pointer (&self->button3, gtk_widget_unparent);
+  g_clear_pointer (&self->button1, gtk_widget_destroy);
+  g_clear_pointer (&self->button2, gtk_widget_destroy);
+  g_clear_pointer (&self->button3, gtk_widget_destroy);
 
-  G_OBJECT_CLASS (interactive_grid_parent_class)->dispose (object);
+  GTK_WIDGET_CLASS (interactive_grid_parent_class)->destroy (widget);
 }
 
 static void
 interactive_grid_class_init (InteractiveGridClass *klass)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
-  object_class->dispose = interactive_grid_dispose;
+  widget_class->destroy = interactive_grid_destroy;
 
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_CONSTRAINT_LAYOUT);
 }
@@ -214,32 +213,33 @@ do_constraints2 (GtkWidget *do_widget)
 
      window = gtk_window_new ();
      gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget));
-     gtk_window_set_title (GTK_WINDOW (window), "Constraints");
 
      header = gtk_header_bar_new ();
+     gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Constraints");
      gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
      gtk_window_set_titlebar (GTK_WINDOW (window), header);
-     g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+     g_signal_connect (window, "destroy",
+                       G_CALLBACK (gtk_widget_destroyed), &window);
 
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
-     gtk_window_set_child (GTK_WINDOW (window), box);
+     gtk_container_add (GTK_CONTAINER (window), box);
 
      grid = g_object_new (interactive_grid_get_type (), NULL);
      gtk_widget_set_hexpand (grid, TRUE);
      gtk_widget_set_vexpand (grid, TRUE);
-     gtk_box_append (GTK_BOX (box), grid);
+     gtk_container_add (GTK_CONTAINER (box), grid);
 
      button = gtk_button_new_with_label ("Close");
-     gtk_box_append (GTK_BOX (box), button);
+     gtk_container_add (GTK_CONTAINER (box), button);
      gtk_widget_set_hexpand (grid, TRUE);
      g_signal_connect_swapped (button, "clicked",
-                               G_CALLBACK (gtk_window_destroy), window);
+                               G_CALLBACK (gtk_widget_destroy), window);
    }
 
  if (!gtk_widget_get_visible (window))
    gtk_widget_show (window);
  else
-   gtk_window_destroy (GTK_WINDOW (window));
+   gtk_widget_destroy (window);
 
  return window;
 }

demos/gtk-demo/constraints3.c

@@ -20,24 +20,23 @@ struct _VflGrid
 G_DEFINE_TYPE (VflGrid, vfl_grid, GTK_TYPE_WIDGET)
 
 static void
-vfl_grid_dispose (GObject *object)
+vfl_grid_destroy (GtkWidget *widget)
 {
-  VflGrid *self = VFL_GRID (object);
+  VflGrid *self = VFL_GRID (widget);
 
-  g_clear_pointer (&self->button1, gtk_widget_unparent);
-  g_clear_pointer (&self->button2, gtk_widget_unparent);
-  g_clear_pointer (&self->button3, gtk_widget_unparent);
+  g_clear_pointer (&self->button1, gtk_widget_destroy);
+  g_clear_pointer (&self->button2, gtk_widget_destroy);
+  g_clear_pointer (&self->button3, gtk_widget_destroy);
 
-  G_OBJECT_CLASS (vfl_grid_parent_class)->dispose (object);
+  GTK_WIDGET_CLASS (vfl_grid_parent_class)->destroy (widget);
 }
 
 static void
 vfl_grid_class_init (VflGridClass *klass)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 
-  object_class->dispose = vfl_grid_dispose;
+  widget_class->destroy = vfl_grid_destroy;
 
   gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_CONSTRAINT_LAYOUT);
 }
@@ -134,32 +133,33 @@ do_constraints3 (GtkWidget *do_widget)
 
      window = gtk_window_new ();
      gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget));
-     gtk_window_set_title (GTK_WINDOW (window), "Constraints");
 
      header = gtk_header_bar_new ();
+     gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Constraints");
      gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
      gtk_window_set_titlebar (GTK_WINDOW (window), header);
-     g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+     g_signal_connect (window, "destroy",
+                       G_CALLBACK (gtk_widget_destroyed), &window);
 
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
-     gtk_window_set_child (GTK_WINDOW (window), box);
+     gtk_container_add (GTK_CONTAINER (window), box);
 
      grid = g_object_new (vfl_grid_get_type (), NULL);
      gtk_widget_set_hexpand (grid, TRUE);
      gtk_widget_set_vexpand (grid, TRUE);
-     gtk_box_append (GTK_BOX (box), grid);
+     gtk_container_add (GTK_CONTAINER (box), grid);
 
      button = gtk_button_new_with_label ("Close");
-     gtk_box_append (GTK_BOX (box), button);
+     gtk_container_add (GTK_CONTAINER (box), button);
      gtk_widget_set_hexpand (grid, TRUE);
      g_signal_connect_swapped (button, "clicked",
-                               G_CALLBACK (gtk_window_destroy), window);
+                               G_CALLBACK (gtk_widget_destroy), window);
    }
 
  if (!gtk_widget_get_visible (window))
    gtk_widget_show (window);
  else
-   gtk_window_destroy (GTK_WINDOW (window));
+   gtk_widget_destroy (window);
 
  return window;
 }

demos/gtk-demo/css_accordion.c

@@ -9,13 +9,9 @@
 static void
 apply_css (GtkWidget *widget, GtkStyleProvider *provider)
 {
-  GtkWidget *child;
-
   gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
-  for (child = gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = gtk_widget_get_next_sibling (child))
-    apply_css (child, provider);
+  if (GTK_IS_CONTAINER (widget))
+    gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
 }
 
 GtkWidget *
@@ -32,30 +28,31 @@ do_css_accordion (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "CSS Accordion");
       gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
       gtk_window_set_default_size (GTK_WINDOW (window), 600, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
       gtk_widget_set_halign (container, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (container, GTK_ALIGN_CENTER);
-      gtk_window_set_child (GTK_WINDOW (window), container);
+      gtk_container_add (GTK_CONTAINER (window), container);
 
       child = gtk_button_new_with_label ("This");
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
 
       child = gtk_button_new_with_label ("Is");
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
 
       child = gtk_button_new_with_label ("A");
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
 
       child = gtk_button_new_with_label ("CSS");
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
 
       child = gtk_button_new_with_label ("Accordion");
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
 
       child = gtk_button_new_with_label (":-)");
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
 
       provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
       gtk_css_provider_load_from_resource (GTK_CSS_PROVIDER (provider), "/css_accordion/css_accordion.css");
@@ -66,7 +63,7 @@ do_css_accordion (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/css_basics.c

@@ -55,13 +55,9 @@ css_text_changed (GtkTextBuffer  *buffer,
 static void
 apply_css (GtkWidget *widget, GtkStyleProvider *provider)
 {
-  GtkWidget *child;
-
   gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
-  for (child = gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = gtk_widget_get_next_sibling (child))
-    apply_css (child, provider);
+  if (GTK_IS_CONTAINER (widget))
+    gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
 }
 
 GtkWidget *
@@ -80,7 +76,8 @@ do_css_basics (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "CSS Basics");
       gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       text = gtk_text_buffer_new (NULL);
       gtk_text_buffer_create_tag (text,
@@ -95,9 +92,9 @@ do_css_basics (GtkWidget *do_widget)
       provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
 
       container = gtk_scrolled_window_new (NULL, NULL);
-      gtk_window_set_child (GTK_WINDOW (window), container);
+      gtk_container_add (GTK_CONTAINER (window), container);
       child = gtk_text_view_new_with_buffer (text);
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
       g_signal_connect (text, "changed",
                         G_CALLBACK (css_text_changed), provider);
 
@@ -116,7 +113,7 @@ do_css_basics (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/css_blendmodes.c

@@ -79,7 +79,7 @@ setup_listbox (GtkBuilder       *builder,
 
   normal_row = NULL;
   listbox = gtk_list_box_new ();
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (WID ("scrolledwindow")), listbox);
+  gtk_container_add (GTK_CONTAINER (WID ("scrolledwindow")), listbox);
 
   g_signal_connect (listbox, "row-activated", G_CALLBACK (row_activated), provider);
 
@@ -95,8 +95,9 @@ setup_listbox (GtkBuilder       *builder,
                             "xalign", 0.0,
                             NULL);
 
-      gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), label);
-      gtk_list_box_insert (GTK_LIST_BOX (listbox), row, -1);
+      gtk_container_add (GTK_CONTAINER (row), label);
+
+      gtk_container_add (GTK_CONTAINER (listbox), row);
 
       /* The first selected row is "normal" */
       if (g_strcmp0 (blend_modes[i].id, "normal") == 0)
@@ -124,7 +125,7 @@ do_css_blendmodes (GtkWidget *do_widget)
 
       window = WID ("window");
       gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
 
       /* Setup the CSS provider for window */
       provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
@@ -139,7 +140,7 @@ do_css_blendmodes (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/css_multiplebgs.c

@@ -69,13 +69,9 @@ drawing_area_draw (GtkDrawingArea *da,
 static void
 apply_css (GtkWidget *widget, GtkStyleProvider *provider)
 {
-  GtkWidget *child;
-
   gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
-  for (child = gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = gtk_widget_get_next_sibling (child))
-    apply_css (child, provider);
+  if (GTK_IS_CONTAINER (widget))
+    gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
 }
 
 GtkWidget *
@@ -94,17 +90,18 @@ do_css_multiplebgs (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "Multiple Backgrounds");
       gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       container = gtk_overlay_new ();
-      gtk_window_set_child (GTK_WINDOW (window), container);
+      gtk_container_add (GTK_CONTAINER (window), container);
 
       child = gtk_drawing_area_new ();
       gtk_widget_set_name (child, "canvas");
       gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (child),
                                       drawing_area_draw,
                                       NULL, NULL);
-      gtk_box_append (GTK_BOX (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
 
       child = gtk_button_new ();
       gtk_overlay_add_overlay (GTK_OVERLAY (container), child);
@@ -118,7 +115,7 @@ do_css_multiplebgs (GtkWidget *do_widget)
 
       /* Need a filler so we get a handle */
       child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_paned_set_start_child (GTK_PANED (paned), child);
+      gtk_container_add (GTK_CONTAINER (paned), child);
 
       text = gtk_text_buffer_new (NULL);
       gtk_text_buffer_create_tag (text,
@@ -133,9 +130,9 @@ do_css_multiplebgs (GtkWidget *do_widget)
       provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
 
       container = gtk_scrolled_window_new (NULL, NULL);
-      gtk_paned_set_end_child (GTK_PANED (paned), container);
+      gtk_container_add (GTK_CONTAINER (paned), container);
       child = gtk_text_view_new_with_buffer (text);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
       g_signal_connect (text,
                         "changed",
                         G_CALLBACK (css_text_changed),
@@ -156,7 +153,7 @@ do_css_multiplebgs (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/css_pixbufs.c

@@ -55,13 +55,9 @@ css_text_changed (GtkTextBuffer  *buffer,
 static void
 apply_css (GtkWidget *widget, GtkStyleProvider *provider)
 {
-  GtkWidget *child;
-
   gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
-  for (child = gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = gtk_widget_get_next_sibling (child))
-    apply_css (child, provider);
+  if (GTK_IS_CONTAINER (widget))
+    gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
 }
 
 GtkWidget *
@@ -80,14 +76,15 @@ do_css_pixbufs (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "Animated Backgrounds");
       gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
-      gtk_window_set_child (GTK_WINDOW (window), paned);
+      gtk_container_add (GTK_CONTAINER (window), paned);
 
       /* Need a filler so we get a handle */
       child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_paned_set_start_child (GTK_PANED (paned), child);
+      gtk_container_add (GTK_CONTAINER (paned), child);
 
       text = gtk_text_buffer_new (NULL);
       gtk_text_buffer_create_tag (text,
@@ -102,9 +99,9 @@ do_css_pixbufs (GtkWidget *do_widget)
       provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
 
       container = gtk_scrolled_window_new (NULL, NULL);
-      gtk_paned_set_end_child (GTK_PANED (paned), container);
+      gtk_container_add (GTK_CONTAINER (paned), container);
       child = gtk_text_view_new_with_buffer (text);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
       g_signal_connect (text, "changed",
                         G_CALLBACK (css_text_changed), provider);
 
@@ -123,7 +120,7 @@ do_css_pixbufs (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/css_shadows.c

@@ -53,13 +53,9 @@ css_text_changed (GtkTextBuffer  *buffer,
 static void
 apply_css (GtkWidget *widget, GtkStyleProvider *provider)
 {
-  GtkWidget *child;
-
   gtk_style_context_add_provider (gtk_widget_get_style_context (widget), provider, G_MAXUINT);
-  for (child = gtk_widget_get_first_child (widget);
-       child != NULL;
-       child = gtk_widget_get_next_sibling (child))
-    apply_css (child, provider);
+  if (GTK_IS_CONTAINER (widget))
+    gtk_container_forall (GTK_CONTAINER (widget), (GtkCallback) apply_css, provider);
 }
 
 static GtkWidget *
@@ -72,13 +68,13 @@ create_toolbar (void)
   gtk_widget_set_valign (toolbar, GTK_ALIGN_CENTER);
 
   item = gtk_button_new_from_icon_name ("go-next");
-  gtk_box_append (GTK_BOX (toolbar), item);
+  gtk_container_add (GTK_CONTAINER (toolbar), item);
 
   item = gtk_button_new_from_icon_name ("go-previous");
-  gtk_box_append (GTK_BOX (toolbar), item);
+  gtk_container_add (GTK_CONTAINER (toolbar), item);
 
   item = gtk_button_new_with_label ("Hello World");
-  gtk_box_append (GTK_BOX (toolbar), item);
+  gtk_container_add (GTK_CONTAINER (toolbar), item);
 
   return toolbar;
 }
@@ -99,13 +95,14 @@ do_css_shadows (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "Shadows");
       gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
-      gtk_window_set_child (GTK_WINDOW (window), paned);
+      gtk_container_add (GTK_CONTAINER (window), paned);
 
       child = create_toolbar ();
-      gtk_paned_set_start_child (GTK_PANED (paned), child);
+      gtk_container_add (GTK_CONTAINER (paned), child);
 
       text = gtk_text_buffer_new (NULL);
       gtk_text_buffer_create_tag (text,
@@ -120,9 +117,9 @@ do_css_shadows (GtkWidget *do_widget)
       provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
 
       container = gtk_scrolled_window_new (NULL, NULL);
-      gtk_paned_set_end_child (GTK_PANED (paned), container);
+      gtk_container_add (GTK_CONTAINER (paned), container);
       child = gtk_text_view_new_with_buffer (text);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (container), child);
+      gtk_container_add (GTK_CONTAINER (container), child);
       g_signal_connect (text, "changed",
                         G_CALLBACK (css_text_changed), provider);
 
@@ -141,7 +138,7 @@ do_css_shadows (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/cursors.c

@@ -36,7 +36,7 @@ do_cursors (GtkWidget *do_widget)
     gtk_widget_show (window);
   else
     {
-      gtk_window_destroy (GTK_WINDOW (window));
+      gtk_widget_destroy (window);
     }
 
   return window;

demos/gtk-demo/demo.gresource.xml

@@ -12,10 +12,6 @@
   <gresource prefix="/builder">
     <file>demo.ui</file>
   </gresource>
-  <gresource prefix="/clipboard">
-    <file>demoimage.c</file>
-    <file>demoimage.h</file>
-  </gresource>
   <gresource prefix="/css_accordion">
     <file>css_accordion.css</file>
     <file>reset.css</file>
@@ -158,6 +154,7 @@
     <file>assistant.c</file>
     <file>builder.c</file>
     <file>clipboard.c</file>
+    <file>colorsel.c</file>
     <file>combobox.c</file>
     <file>constraints.c</file>
     <file>constraints2.c</file>
@@ -280,6 +277,9 @@
   <gresource prefix="/modelbutton">
     <file>modelbutton.ui</file>
   </gresource>
+  <gresource prefix="/dnd">
+    <file>dnd.css</file>
+  </gresource>
   <gresource prefix="/tagged_entry">
     <file>demotaggedentry.c</file>
     <file>demotaggedentry.h</file>
@@ -309,7 +309,4 @@
     <file>icons/16x16/status/battery-caution-charging-symbolic.symbolic.png</file>
     <file>icons/16x16/categories/applications-other.png</file>
   </gresource>
-  <gresource prefix="/org/gtk/Demo4/gtk">
-    <file preprocess="xml-stripblanks">help-overlay.ui</file>
-  </gresource>
 </gresources>

demos/gtk-demo/demo.ui

@@ -94,7 +94,6 @@
   <object class="GtkAboutDialog" id="aboutdialog1">
     <property name="program-name" translatable="yes">Builder demo</property>
     <property name="logo-icon-name" translatable="yes">gtk3-demo</property>
-    <property name="modal">True</property>
     <accessibility>
       <relation target="window1" type="subwindow-of"/>
     </accessibility>

demos/gtk-demo/demoimage.c

@@ -1,259 +0,0 @@
-#include "demoimage.h"
-#include <glib/gi18n.h>
-
-struct _DemoImage {
-  GtkWidget parent_instance;
- 
-  GtkWidget *image;
-  GtkWidget *popover;
-};
-
-enum {
-  PROP_ICON_NAME = 1
-};
-
-G_DEFINE_TYPE(DemoImage, demo_image, GTK_TYPE_WIDGET)
-
-static GdkPaintable *
-get_image_paintable (GtkImage *image)
-{
-  const gchar *icon_name;
-  GtkIconTheme *icon_theme;
-  GtkIconPaintable *icon;
-
-  switch (gtk_image_get_storage_type (image))
-    {
-    case GTK_IMAGE_PAINTABLE:
-      return g_object_ref (gtk_image_get_paintable (image));
-    case GTK_IMAGE_ICON_NAME:
-      icon_name = gtk_image_get_icon_name (image);
-      icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (GTK_WIDGET (image)));
-      icon = gtk_icon_theme_lookup_icon (icon_theme,
-                                         icon_name,
-                                         NULL,
-                                         48, 1,
-                                         gtk_widget_get_direction (GTK_WIDGET (image)),
-                                         0);
-      if (icon == NULL)
-        return NULL;
-      return GDK_PAINTABLE (icon);
-
-    case GTK_IMAGE_EMPTY:
-    case GTK_IMAGE_GICON:
-    default:
-      g_warning ("Image storage type %d not handled",
-                 gtk_image_get_storage_type (image));
-      return NULL;
-    }
-}
-
-static void
-drag_begin (GtkDragSource *source,
-            GdkDrag       *drag,
-            gpointer       data)
-{
-  GtkWidget *widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
-  DemoImage *demo = DEMO_IMAGE (widget);
-  GdkPaintable *paintable;
-
-  paintable = get_image_paintable (GTK_IMAGE (demo->image));
-  if (paintable)
-    {
-      gtk_drag_icon_set_from_paintable (drag, paintable, -2, -2);
-      g_object_unref (paintable);
-    }
-}
-
-static GdkContentProvider *
-prepare_drag (GtkDragSource *source,
-              double         x,
-              double         y,
-              gpointer       data)
-{
-  GtkWidget *widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
-  DemoImage *demo = DEMO_IMAGE (widget);
-  GdkPaintable *paintable = get_image_paintable (GTK_IMAGE (demo->image));
-
-  return gdk_content_provider_new_typed (GDK_TYPE_PAINTABLE, paintable);
-}
-
-static gboolean
-drag_drop (GtkDropTarget *dest,
-           const GValue  *value,
-           double         x,
-           double         y,
-           gpointer       data)
-{
-  GtkWidget *widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (dest));
-  DemoImage *demo = DEMO_IMAGE (widget);
-  GdkPaintable *paintable = g_value_get_object (value);
-
-  gtk_image_set_from_paintable (GTK_IMAGE (demo->image), paintable);
-
-  return TRUE;
-}
-
-static void
-copy_image (GtkWidget *widget,
-            const char *action_name,
-            GVariant *parameter)
-{
-  GdkClipboard *clipboard = gtk_widget_get_clipboard (widget);
-  DemoImage *demo = DEMO_IMAGE (widget);
-  GdkPaintable *paintable = get_image_paintable (GTK_IMAGE (demo->image));
-  GValue value = G_VALUE_INIT;
-
-  g_value_init (&value, GDK_TYPE_PAINTABLE);
-  g_value_set_object (&value, paintable);
-  gdk_clipboard_set_value (clipboard, &value);
-  g_value_unset (&value);
-
-  if (paintable)
-    g_object_unref (paintable);
-}
-
-static void
-paste_image (GtkWidget *widget,
-             const char *action_name,
-             GVariant *parameter)
-{
-  GdkClipboard *clipboard = gtk_widget_get_clipboard (widget);
-  DemoImage *demo = DEMO_IMAGE (widget);
-  GdkContentProvider *content = gdk_clipboard_get_content (clipboard);
-  GValue value = G_VALUE_INIT;
-  GdkPaintable *paintable;
-
-  g_value_init (&value, GDK_TYPE_PAINTABLE);
-  if (!gdk_content_provider_get_value (content, &value, NULL))
-    return;
-
-  paintable = GDK_PAINTABLE (g_value_get_object (&value));
-  gtk_image_set_from_paintable (GTK_IMAGE (demo->image), paintable);
-  g_value_unset (&value);
-}
-
-static void
-pressed_cb (GtkGesture *gesture,
-            int         n_press,
-            double      x,
-            double      y,
-            gpointer    data)
-{
-  DemoImage *demo = DEMO_IMAGE (gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)));
-
-  gtk_popover_popup (GTK_POPOVER (demo->popover));
-}
-
-static void
-demo_image_init (DemoImage *demo)
-{
-  GMenu *menu;
-  GMenuItem *item;
-  GtkDragSource *source;
-  GtkDropTarget *dest;
-  GtkGesture *gesture;
-
-  demo->image = gtk_image_new ();
-  gtk_image_set_pixel_size (GTK_IMAGE (demo->image), 48);
-  gtk_widget_set_parent (demo->image, GTK_WIDGET (demo));
-
-  menu = g_menu_new (); 
-  item = g_menu_item_new (_("_Copy"), "clipboard.copy");
-  g_menu_append_item (menu, item);
-
-  item = g_menu_item_new (_("_Paste"), "clipboard.paste");
-  g_menu_append_item (menu, item);
-
-  demo->popover = gtk_popover_menu_new_from_model (G_MENU_MODEL (menu));
-  gtk_widget_set_parent (demo->popover, GTK_WIDGET (demo));
-
-  source = gtk_drag_source_new ();
-  g_signal_connect (source, "prepare", G_CALLBACK (prepare_drag), NULL);
-  g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), NULL);
-  gtk_widget_add_controller (GTK_WIDGET (demo), GTK_EVENT_CONTROLLER (source));
-
-  dest = gtk_drop_target_new (GDK_TYPE_PAINTABLE, GDK_ACTION_COPY);
-  g_signal_connect (dest, "drop", G_CALLBACK (drag_drop), NULL);
-  gtk_widget_add_controller (GTK_WIDGET (demo), GTK_EVENT_CONTROLLER (dest));
-
-  gesture = gtk_gesture_click_new ();
-  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
-  g_signal_connect (gesture, "pressed", G_CALLBACK (pressed_cb), NULL);
-  gtk_widget_add_controller (GTK_WIDGET (demo), GTK_EVENT_CONTROLLER (gesture));
-}
-
-static void
-demo_image_dispose (GObject *object)
-{
-  DemoImage *demo = DEMO_IMAGE (object);
-
-  g_clear_pointer (&demo->image, gtk_widget_unparent);
-  g_clear_pointer (&demo->popover, gtk_widget_unparent);
-
-  G_OBJECT_CLASS (demo_image_parent_class)->dispose (object);
-}
-
-static void
-demo_image_get_property (GObject    *object,
-                         guint       prop_id,
-                         GValue     *value,
-                         GParamSpec *pspec)
-{
-  DemoImage *demo = DEMO_IMAGE (object);
-
-  switch (prop_id)
-    {
-    case PROP_ICON_NAME:
-      g_value_set_string (value, gtk_image_get_icon_name (GTK_IMAGE (demo->image)));
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-demo_image_set_property (GObject      *object,
-                         guint         prop_id,
-                         const GValue *value,
-                         GParamSpec   *pspec)
-{
-  DemoImage *demo = DEMO_IMAGE (object);
-
-  switch (prop_id)
-    {
-    case PROP_ICON_NAME:
-      gtk_image_set_from_icon_name (GTK_IMAGE (demo->image),
-                                    g_value_get_string (value));
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-demo_image_class_init (DemoImageClass *class)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (class);
-  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
-
-  object_class->dispose = demo_image_dispose;
-  object_class->get_property = demo_image_get_property;
-  object_class->set_property = demo_image_set_property;
-
-  g_object_class_install_property (object_class, PROP_ICON_NAME,
-      g_param_spec_string ("icon-name", "Icon name", "Icon name",
-                           NULL, G_PARAM_READWRITE));
-                       
-  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
-
-  gtk_widget_class_install_action (widget_class, "clipboard.copy", NULL, copy_image);
-  gtk_widget_class_install_action (widget_class, "clipboard.paste", NULL, paste_image);
-}
-
-GtkWidget *
-demo_image_new (const char *icon_name)
-{
-  return g_object_new (DEMO_TYPE_IMAGE, "icon-name", icon_name, NULL);
-}

demos/gtk-demo/demoimage.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include <gtk/gtk.h>
-
-G_BEGIN_DECLS
-
-#define DEMO_TYPE_IMAGE (demo_image_get_type ())
-
-G_DECLARE_FINAL_TYPE(DemoImage, demo_image, DEMO, IMAGE, GtkWidget)
-
-GtkWidget * demo_image_new (const char *icon_name);
-
-G_END_DECLS

demos/gtk-demo/demotaggedentry.c

@@ -49,7 +49,7 @@ demo_tagged_entry_init (DemoTaggedEntry *entry)
   gtk_widget_set_vexpand (priv->entry, TRUE);
   gtk_widget_set_hexpand (priv->box, FALSE);
   gtk_widget_set_vexpand (priv->box, FALSE);
-  gtk_box_append (GTK_BOX (priv->box), priv->entry);
+  gtk_container_add (GTK_CONTAINER (priv->box), priv->entry);
   gtk_editable_init_delegate (GTK_EDITABLE (entry));
 }
 
@@ -188,7 +188,7 @@ demo_tagged_entry_add_tag (DemoTaggedEntry *entry,
 
   g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
 
-  gtk_box_append (GTK_BOX (priv->box), tag);
+  gtk_container_add (GTK_CONTAINER (priv->box), tag);
 }
 
 void
@@ -201,7 +201,7 @@ demo_tagged_entry_insert_tag_after (DemoTaggedEntry *entry,
   g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
 
   if (sibling == NULL)
-    gtk_box_append (GTK_BOX (priv->box), tag);
+    gtk_container_add (GTK_CONTAINER (priv->box), tag);
   else
     gtk_box_insert_child_after (GTK_BOX (priv->box), tag, sibling); 
 }
@@ -214,7 +214,7 @@ demo_tagged_entry_remove_tag (DemoTaggedEntry *entry,
 
   g_return_if_fail (DEMO_IS_TAGGED_ENTRY (entry));
 
-  gtk_box_remove (GTK_BOX (priv->box), tag);
+  gtk_container_remove (GTK_CONTAINER (priv->box), tag);
 }
 
 struct _DemoTaggedEntryTag
@@ -268,7 +268,7 @@ demo_tagged_entry_tag_init (DemoTaggedEntryTag *tag)
   tag->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_set_parent (tag->box, GTK_WIDGET (tag));
   tag->label = gtk_label_new ("");
-  gtk_box_append (GTK_BOX (tag->box), tag->label);
+  gtk_container_add (GTK_CONTAINER (tag->box), tag->label);
 
   gesture = gtk_gesture_click_new ();
   g_signal_connect (gesture, "released", G_CALLBACK (on_released), tag);
@@ -460,7 +460,7 @@ demo_tagged_entry_tag_set_has_close_button (DemoTaggedEntryTag *tag,
 
   if (!has_close_button && tag->button)
     {
-      gtk_box_remove (GTK_BOX (tag->box), tag->button);
+      gtk_container_remove (GTK_CONTAINER (tag->box), tag->button);
       tag->button = NULL;
     }
   else if (has_close_button && tag->button == NULL)
@@ -469,11 +469,11 @@ demo_tagged_entry_tag_set_has_close_button (DemoTaggedEntryTag *tag,
 
       image = gtk_image_new_from_icon_name ("window-close-symbolic");
       tag->button = gtk_button_new ();
-      gtk_box_append (GTK_BOX (tag->button), image);
+      gtk_container_add (GTK_CONTAINER (tag->button), image);
       gtk_widget_set_halign (tag->button, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (tag->button, GTK_ALIGN_CENTER);
       gtk_button_set_has_frame (GTK_BUTTON (tag->button), FALSE);
-      gtk_box_append (GTK_BOX (tag->box), tag->button);
+      gtk_container_add (GTK_CONTAINER (tag->box), tag->button);
       g_signal_connect (tag->button, "clicked", G_CALLBACK (on_button_clicked), tag);
     }
 

demos/gtk-demo/dialog.c

@@ -25,36 +25,11 @@ message_dialog_clicked (GtkButton *button,
                                    "number of times:");
   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
                                             "%d", i);
-  g_signal_connect (dialog, "response", G_CALLBACK (gtk_window_destroy), NULL);
-  gtk_widget_show (dialog);
+  gtk_dialog_run (GTK_DIALOG (dialog));
+  gtk_widget_destroy (dialog);
   i++;
 }
 
-typedef struct {
-  GtkWidget *local_entry1;
-  GtkWidget *local_entry2;
-  GtkWidget *global_entry1;
-  GtkWidget *global_entry2;
-} ResponseData;
-
-static void
-on_dialog_response (GtkDialog *dialog,
-                    int        response,
-                    gpointer   user_data)
-{
-  ResponseData *data = user_data;
-
-  if (response == GTK_RESPONSE_OK)
-    {
-      gtk_editable_set_text (GTK_EDITABLE (data->global_entry1),
-                             gtk_editable_get_text (GTK_EDITABLE (data->local_entry1)));
-      gtk_editable_set_text (GTK_EDITABLE (data->global_entry2),
-                             gtk_editable_get_text (GTK_EDITABLE (data->local_entry2)));
-    }
-
-  gtk_window_destroy (GTK_WINDOW (dialog));
-}
-
 static void
 interactive_dialog_clicked (GtkButton *button,
                             gpointer   user_data)
@@ -67,7 +42,7 @@ interactive_dialog_clicked (GtkButton *button,
   GtkWidget *local_entry1;
   GtkWidget *local_entry2;
   GtkWidget *label;
-  ResponseData *data;
+  gint response;
 
   dialog = gtk_dialog_new_with_buttons ("Interactive Dialog",
                                         GTK_WINDOW (window),
@@ -81,16 +56,16 @@ interactive_dialog_clicked (GtkButton *button,
   content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
 
   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
-  gtk_box_append (GTK_BOX (content_area), hbox);
+  gtk_container_add (GTK_CONTAINER (content_area), hbox);
 
   image = gtk_image_new_from_icon_name ("dialog-question");
   gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
-  gtk_box_append (GTK_BOX (hbox), image);
+  gtk_container_add (GTK_CONTAINER (hbox), image);
 
   table = gtk_grid_new ();
   gtk_grid_set_row_spacing (GTK_GRID (table), 4);
   gtk_grid_set_column_spacing (GTK_GRID (table), 4);
-  gtk_box_append (GTK_BOX (hbox), table);
+  gtk_container_add (GTK_CONTAINER (hbox), table);
   label = gtk_label_new_with_mnemonic ("_Entry 1");
   gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
   local_entry1 = gtk_entry_new ();
@@ -106,18 +81,15 @@ interactive_dialog_clicked (GtkButton *button,
   gtk_grid_attach (GTK_GRID (table), local_entry2, 1, 1, 1, 1);
   gtk_label_set_mnemonic_widget (GTK_LABEL (label), local_entry2);
 
-  data = g_new (ResponseData, 1);
-  data->local_entry1 = local_entry1;
-  data->local_entry2 = local_entry2;
-  data->global_entry1 = entry1;
-  data->global_entry2 = entry2;
+  response = gtk_dialog_run (GTK_DIALOG (dialog));
 
-  g_signal_connect_data (dialog, "response",
-                         G_CALLBACK (on_dialog_response),
-                         data, (GClosureNotify) g_free,
-                         0);
+  if (response == GTK_RESPONSE_OK)
+    {
+      gtk_editable_set_text (GTK_EDITABLE (entry1), gtk_editable_get_text (GTK_EDITABLE (local_entry1)));
+      gtk_editable_set_text (GTK_EDITABLE (entry2), gtk_editable_get_text (GTK_EDITABLE (local_entry2)));
+    }
 
-  gtk_widget_show (dialog);
+  gtk_widget_destroy (dialog);
 }
 
 GtkWidget *
@@ -137,47 +109,49 @@ do_dialog (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Dialogs and Message Boxes");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       frame = gtk_frame_new ("Dialogs");
       gtk_widget_set_margin_start (frame, 8);
       gtk_widget_set_margin_end (frame, 8);
       gtk_widget_set_margin_top (frame, 8);
       gtk_widget_set_margin_bottom (frame, 8);
-      gtk_window_set_child (GTK_WINDOW (window), frame);
+      gtk_container_add (GTK_CONTAINER (window), frame);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
       gtk_widget_set_margin_start (vbox, 8);
       gtk_widget_set_margin_end (vbox, 8);
       gtk_widget_set_margin_top (vbox, 8);
       gtk_widget_set_margin_bottom (vbox, 8);
-      gtk_frame_set_child (GTK_FRAME (frame), vbox);
+      gtk_container_add (GTK_CONTAINER (frame), vbox);
 
       /* Standard message dialog */
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
       button = gtk_button_new_with_mnemonic ("_Message Dialog");
       g_signal_connect (button, "clicked",
                         G_CALLBACK (message_dialog_clicked), NULL);
-      gtk_box_append (GTK_BOX (hbox), button);
+      gtk_container_add (GTK_CONTAINER (hbox), button);
 
-      gtk_box_append (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
+      gtk_container_add (GTK_CONTAINER (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
 
       /* Interactive dialog*/
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
       vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 
       button = gtk_button_new_with_mnemonic ("_Interactive Dialog");
       g_signal_connect (button, "clicked",
                         G_CALLBACK (interactive_dialog_clicked), NULL);
-      gtk_box_append (GTK_BOX (hbox), vbox2);
-      gtk_box_append (GTK_BOX (vbox2), button);
+      gtk_container_add (GTK_CONTAINER (hbox), vbox2);
+      gtk_container_add (GTK_CONTAINER (vbox2), button);
 
       table = gtk_grid_new ();
       gtk_grid_set_row_spacing (GTK_GRID (table), 4);
       gtk_grid_set_column_spacing (GTK_GRID (table), 4);
-      gtk_box_append (GTK_BOX (hbox), table);
+      gtk_container_add (GTK_CONTAINER (hbox), table);
 
       label = gtk_label_new_with_mnemonic ("_Entry 1");
       gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
@@ -196,7 +170,7 @@ do_dialog (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/dnd.c

@@ -1,126 +1,202 @@
 /* Drag-and-Drop
  *
- * This demo shows dragging colors and widgets.
- * The items in this demo can be moved, recolored
- * and rotated.
+ * I can't believe its not glade!
+ *
+ * Try right-clicking in the window.
  */
 
+#include <glib/gi18n.h>
 #include <gtk/gtk.h>
+#include <string.h>
 
-static GdkContentProvider *
-prepare (GtkDragSource *source,
-         double         x,
-         double         y)
+typedef struct _GtkDemoWidget GtkDemoWidget;
+struct _GtkDemoWidget
 {
-  GtkWidget *canvas;
-  GtkWidget *item;
+  GType type;
+  union {
+    char *text;
+    gboolean active;
+  };
+};
 
-  canvas = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
-  item = gtk_widget_pick (canvas, x, y, GTK_PICK_DEFAULT);
+static gpointer
+copy_demo_widget (gpointer data)
+{
+  GtkDemoWidget *demo = g_memdup (data, sizeof (GtkDemoWidget));
 
-  if (!GTK_IS_LABEL (item))
-    return NULL;
+  if (demo->type == GTK_TYPE_LABEL)
+    demo->text = g_strdup (demo->text);
 
-  g_object_set_data (G_OBJECT (canvas), "dragged-item", item);
-
-  return gdk_content_provider_new_typed (GTK_TYPE_WIDGET, item);
+  return demo;
 }
 
 static void
-drag_begin (GtkDragSource *source,
-            GdkDrag       *drag)
+free_demo_widget (gpointer data)
 {
-  GtkWidget *canvas;
-  GtkWidget *item;
+  GtkDemoWidget *demo = data;
 
-  canvas = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
-  item = g_object_get_data (G_OBJECT (canvas), "dragged-item");
+  if (demo->type == GTK_TYPE_LABEL)
+    g_free (demo->text);
 
-  gtk_widget_set_opacity (item, 0.5);
+  g_free (demo);
 }
 
-static void
-drag_end (GtkDragSource *source,
-          GdkDrag       *drag)
+#define GTK_TYPE_DEMO_WIDGET (gtk_demo_widget_get_type ())
+static GType gtk_demo_widget_get_type (void);
+G_DEFINE_BOXED_TYPE (GtkDemoWidget, gtk_demo_widget, copy_demo_widget, free_demo_widget)
+
+static GtkDemoWidget *
+serialize_widget (GtkWidget *widget)
 {
-  GtkWidget *canvas;
-  GtkWidget *item;
+  GtkDemoWidget *demo;
 
-  canvas = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
-  item = g_object_get_data (G_OBJECT (canvas), "dragged-item");
-  g_object_set_data (G_OBJECT (canvas), "dragged-item", NULL);
+  demo = g_new0 (GtkDemoWidget, 1);
+  demo->type = G_OBJECT_TYPE (widget);
 
-  gtk_widget_set_opacity (item, 1.0);
+  if (GTK_IS_LABEL (widget))
+    {
+      demo->text = g_strdup (gtk_label_get_text (GTK_LABEL (widget)));
+    }
+  else if (GTK_IS_SPINNER (widget))
+    {
+      g_object_get (widget, "spinning", &demo->active, NULL);
+    }
+  else
+    {
+      g_print ("Type %s not supported\n", g_type_name (demo->type));
+    }
+
+  return demo;
 }
 
-static gboolean
-drag_cancel (GtkDragSource       *source,
-             GdkDrag             *drag,
-             GdkDragCancelReason  reason)
+static GtkWidget *
+deserialize_widget (GtkDemoWidget *demo)
 {
-  return FALSE;
-}
+  GtkWidget *widget = NULL;
 
-typedef struct {
-  double x, y;
-  double angle;
-  double delta;
-} TransformData;
+  if (demo->type == GTK_TYPE_LABEL)
+    {
+      widget = gtk_label_new (demo->text);
+    }
+  else if (demo->type == GTK_TYPE_SPINNER)
+    {
+      widget = g_object_new (demo->type, "spinning", demo->active, NULL);
+      gtk_widget_add_css_class (widget, "demo");
+    }
+  else
+    {
+      g_print ("Type %s not supported\n", g_type_name (demo->type));
+    }
 
-static void
-apply_transform (GtkWidget *item)
-{
-  GtkWidget *canvas = gtk_widget_get_parent (item);
-  TransformData *data;
-  GskTransform *transform;
-
-  data = g_object_get_data (G_OBJECT (item), "transform-data");
-  transform = gsk_transform_rotate (gsk_transform_translate (NULL, &(graphene_point_t){data->x, data->y}),
-                                    data->angle + data->delta);
-  gtk_fixed_set_child_transform (GTK_FIXED (canvas), item, transform);
-  gsk_transform_unref (transform);
-}
-
-static gboolean
-drag_drop (GtkDropTarget *target,
-           const GValue  *value,
-           double         x,
-           double         y)
-{
-  GtkWidget *item;
-  TransformData *transform_data;
-  GtkWidget *canvas;
-  GtkWidget *last_child;
-
-  item = g_value_get_object (value);
-  transform_data = g_object_get_data (G_OBJECT (item), "transform-data");
-
-  transform_data->x = x;
-  transform_data->y = y;
-
-  canvas = gtk_widget_get_parent (item);
-  last_child = gtk_widget_get_last_child (canvas);
-  if (item != last_child)
-    gtk_widget_insert_after (item, canvas, last_child);
-
-  apply_transform (item);
-
-  return TRUE;
+  return widget;
 }
 
 static double pos_x, pos_y;
 
-static GtkWidget * canvas_item_new (double x, double y);
+static void
+new_label_cb (GtkWidget *button,
+              gpointer     data)
+{
+  GtkFixed *fixed = data;
+  GtkWidget *widget;
+
+  widget = gtk_label_new ("Label");
+  gtk_fixed_put (fixed, widget, pos_x, pos_y);
+
+  gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
+}
 
 static void
-new_item_cb (GtkWidget *button, gpointer data)
+new_spinner_cb (GtkWidget *button,
+                gpointer     data)
 {
-  GtkWidget *canvas = data;
-  GtkWidget *item;
+  GtkFixed *fixed = data;
+  GtkWidget *widget;
 
-  item = canvas_item_new (pos_x, pos_y);
-  gtk_fixed_put (GTK_FIXED (canvas), item, 0, 0);
-  apply_transform (item);
+  widget = gtk_spinner_new ();
+  gtk_widget_add_css_class (widget, "demo");
+  gtk_spinner_start (GTK_SPINNER (widget));
+  gtk_fixed_put (fixed, widget, pos_x, pos_y);
+
+  gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
+}
+
+static void
+copy_cb (GtkWidget *button, GtkWidget *child)
+{
+  GdkClipboard *clipboard;
+  GtkDemoWidget *demo;
+
+  demo = serialize_widget (child);
+
+  clipboard = gdk_display_get_clipboard (gdk_display_get_default ());
+  gdk_clipboard_set (clipboard, GTK_TYPE_DEMO_WIDGET, demo);
+
+  gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
+}
+
+static void
+delete_cb (GtkWidget *button, GtkWidget *child)
+{
+  gtk_widget_destroy (child);
+
+  gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
+}
+
+static void
+cut_cb (GtkWidget *button, GtkWidget *child)
+{
+  copy_cb (button, child);
+  delete_cb (button, child);
+
+  gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
+}
+
+static void
+value_read (GObject      *source,
+            GAsyncResult *res,
+            gpointer      data)
+{
+  GdkClipboard *clipboard = GDK_CLIPBOARD (source);
+  GError *error = NULL;
+  const GValue *value;
+  GtkDemoWidget *demo;
+  GtkWidget *widget = NULL;
+
+  value = gdk_clipboard_read_value_finish (clipboard, res, &error);
+
+  if (value == NULL)
+    {
+      g_print ("error: %s\n", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  if (!G_VALUE_HOLDS (value, GTK_TYPE_DEMO_WIDGET))
+    {
+      g_print ("can't handle clipboard contents\n");
+      return;
+    }
+
+  demo = g_value_get_boxed (value);
+  widget = deserialize_widget (demo);
+
+  gtk_fixed_put (GTK_FIXED (data), widget, pos_x, pos_y);
+}
+
+static void
+paste_cb (GtkWidget *button, GtkWidget *fixed)
+{
+  GdkClipboard *clipboard;
+
+  clipboard = gdk_display_get_clipboard (gdk_display_get_default ());
+  if (gdk_content_formats_contain_gtype (gdk_clipboard_get_formats (clipboard), GTK_TYPE_DEMO_WIDGET))
+    {
+      g_print ("Paste %s\n", g_type_name (GTK_TYPE_DEMO_WIDGET));
+      gdk_clipboard_read_value_async (clipboard, GTK_TYPE_DEMO_WIDGET, 0, NULL, value_read, fixed);
+    }
+  else
+    g_print ("Don't know how to handle clipboard contents\n");
 
   gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
 }
@@ -128,26 +204,25 @@ new_item_cb (GtkWidget *button, gpointer data)
 static void
 edit_label_done (GtkWidget *entry, gpointer data)
 {
-  GtkWidget *canvas = gtk_widget_get_parent (entry);
+  GtkWidget *fixed = gtk_widget_get_parent (entry);
   GtkWidget *label;
   int x, y;
 
-  gtk_fixed_get_child_position (GTK_FIXED (canvas), entry, &x, &y);
+  gtk_fixed_get_child_position (GTK_FIXED (fixed), entry, &x, &y);
 
   label = GTK_WIDGET (g_object_get_data (G_OBJECT (entry), "label"));
   gtk_label_set_text (GTK_LABEL (label), gtk_editable_get_text (GTK_EDITABLE (entry)));
-  gtk_widget_show (label);
 
-  gtk_fixed_remove (GTK_FIXED (canvas), entry);
+  gtk_widget_destroy (entry);
 }
 
 static void
 edit_cb (GtkWidget *button, GtkWidget *child)
 {
-  GtkWidget *canvas = gtk_widget_get_parent (child);
+  GtkWidget *fixed = gtk_widget_get_parent (child);
   int x, y;
 
-  gtk_fixed_get_child_position (GTK_FIXED (canvas), child, &x, &y);
+  gtk_fixed_get_child_position (GTK_FIXED (fixed), child, &x, &y);
 
   if (GTK_IS_LABEL (child))
     {
@@ -158,25 +233,21 @@ edit_cb (GtkWidget *button, GtkWidget *child)
       gtk_editable_set_text (GTK_EDITABLE (entry), gtk_label_get_text (GTK_LABEL (child)));
       gtk_editable_set_width_chars (GTK_EDITABLE (entry), 12);
       g_signal_connect (entry, "activate", G_CALLBACK (edit_label_done), NULL);
-      gtk_fixed_put (GTK_FIXED (canvas), entry, x, y);
+      gtk_fixed_put (GTK_FIXED (fixed), entry, x, y);
       gtk_widget_grab_focus (entry);
-      gtk_widget_hide (child);
+    }
+  else if (GTK_IS_SPINNER (child))
+    {
+      gboolean active;
+
+      g_object_get (child, "spinning", &active, NULL);
+      g_object_set (child, "spinning", !active, NULL);
     }
 
   if (button)
     gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
 }
 
-static void
-delete_cb (GtkWidget *button, GtkWidget *child)
-{
-  GtkWidget *canvas = gtk_widget_get_parent (child);
-
-  gtk_fixed_remove (GTK_FIXED (canvas), child);
-
-  gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
-}
-
 static void
 pressed_cb (GtkGesture *gesture,
             int         n_press,
@@ -195,6 +266,7 @@ pressed_cb (GtkGesture *gesture,
       GtkWidget *menu;
       GtkWidget *box;
       GtkWidget *item;
+      GdkClipboard *clipboard;
 
       pos_x = x;
       pos_y = y;
@@ -204,30 +276,51 @@ pressed_cb (GtkGesture *gesture,
       gtk_popover_set_has_arrow (GTK_POPOVER (menu), FALSE);
       gtk_popover_set_pointing_to (GTK_POPOVER (menu), &(GdkRectangle){ x, y, 1, 1});
       box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_popover_set_child (GTK_POPOVER (menu), box);
+      gtk_container_add (GTK_CONTAINER (menu), box);
 
-      item = gtk_button_new_with_label ("New");
+      item = gtk_button_new_with_label ("New Label");
       gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
-      g_signal_connect (item, "clicked", G_CALLBACK (new_item_cb), widget);
-      gtk_box_append (GTK_BOX (box), item);
+      g_signal_connect (item, "clicked", G_CALLBACK (new_label_cb), widget);
+      gtk_container_add (GTK_CONTAINER (box), item);
+      item = gtk_button_new_with_label ("New Spinner");
+      gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
+      g_signal_connect (item, "clicked", G_CALLBACK (new_spinner_cb), widget);
+      gtk_container_add (GTK_CONTAINER (box), item);
 
       item = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
-      gtk_box_append (GTK_BOX (box), item);
+      gtk_container_add (GTK_CONTAINER (box), item);
 
       item = gtk_button_new_with_label ("Edit");
       gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
       gtk_widget_set_sensitive (item, child != NULL && child != widget);
       g_signal_connect (item, "clicked", G_CALLBACK (edit_cb), child);
-      gtk_box_append (GTK_BOX (box), item);
+      gtk_container_add (GTK_CONTAINER (box), item);
 
       item = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
-      gtk_box_append (GTK_BOX (box), item);
+      gtk_container_add (GTK_CONTAINER (box), item);
 
+      item = gtk_button_new_with_label ("Cut");
+      gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
+      gtk_widget_set_sensitive (item, child != NULL && child != widget);
+      g_signal_connect (item, "clicked", G_CALLBACK (cut_cb), child);
+      gtk_container_add (GTK_CONTAINER (box), item);
+      item = gtk_button_new_with_label ("Copy");
+      gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
+      gtk_widget_set_sensitive (item, child != NULL && child != widget);
+      g_signal_connect (item, "clicked", G_CALLBACK (copy_cb), child);
+      gtk_container_add (GTK_CONTAINER (box), item);
+      item = gtk_button_new_with_label ("Paste");
+      gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
+      clipboard = gdk_display_get_clipboard (gdk_display_get_default ());
+      gtk_widget_set_sensitive (item,
+                                gdk_content_formats_contain_gtype (gdk_clipboard_get_formats (clipboard), GTK_TYPE_DEMO_WIDGET));
+      g_signal_connect (item, "clicked", G_CALLBACK (paste_cb), widget);
+      gtk_container_add (GTK_CONTAINER (box), item);
       item = gtk_button_new_with_label ("Delete");
       gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
       gtk_widget_set_sensitive (item, child != NULL && child != widget);
       g_signal_connect (item, "clicked", G_CALLBACK (delete_cb), child);
-      gtk_box_append (GTK_BOX (box), item);
+      gtk_container_add (GTK_CONTAINER (box), item);
 
       gtk_popover_popup (GTK_POPOVER (menu));
     }
@@ -253,165 +346,6 @@ released_cb (GtkGesture *gesture,
     }
 }
 
-static GtkWidget *
-canvas_new (void)
-{
-  GtkWidget *canvas;
-  GtkDragSource *source;
-  GtkDropTarget *dest;
-  GtkGesture *gesture;
-
-  canvas = gtk_fixed_new ();
-  gtk_widget_set_hexpand (canvas, TRUE);
-  gtk_widget_set_vexpand (canvas, TRUE);
-  gtk_widget_add_css_class (canvas, "frame");
-
-  source = gtk_drag_source_new ();
-  gtk_drag_source_set_actions (source, GDK_ACTION_MOVE);
-  g_signal_connect (source, "prepare", G_CALLBACK (prepare), NULL);
-  g_signal_connect (source, "drag-begin", G_CALLBACK (drag_begin), NULL);
-  g_signal_connect (source, "drag-end", G_CALLBACK (drag_end), NULL);
-  g_signal_connect (source, "drag-cancel", G_CALLBACK (drag_cancel), NULL);
-  gtk_widget_add_controller (canvas, GTK_EVENT_CONTROLLER (source));
-
-  dest = gtk_drop_target_new (GTK_TYPE_WIDGET, GDK_ACTION_MOVE);
-  g_signal_connect (dest, "drop", G_CALLBACK (drag_drop), NULL);
-  gtk_widget_add_controller (canvas, GTK_EVENT_CONTROLLER (dest));
-
-  gesture = gtk_gesture_click_new ();
-  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), 0);
-  g_signal_connect (gesture, "pressed", G_CALLBACK (pressed_cb), NULL);
-  g_signal_connect (gesture, "released", G_CALLBACK (released_cb), NULL);
-  gtk_widget_add_controller (canvas, GTK_EVENT_CONTROLLER (gesture));
-
-  return canvas;
-}
-
-static void
-set_color (GtkWidget *item,
-           GdkRGBA   *color)
-{
-  char *css;
-  char *str;
-  GtkStyleContext *context;
-  GtkCssProvider *provider;
-
-  str = gdk_rgba_to_string (color);
-  css = g_strdup_printf ("* { background: %s; padding: 10px; }", str);
-
-  context = gtk_widget_get_style_context (item);
-  provider = g_object_get_data (G_OBJECT (context), "style-provider");
-  if (provider)
-    gtk_style_context_remove_provider (context, GTK_STYLE_PROVIDER (provider));
-
-  provider = gtk_css_provider_new ();
-  gtk_css_provider_load_from_data (provider, css, -1);
-  gtk_style_context_add_provider (gtk_widget_get_style_context (item), GTK_STYLE_PROVIDER (provider), 800);
-  g_object_set_data_full (G_OBJECT (context), "style-provider", provider, g_object_unref);
-
-  g_free (str);
-  g_free (css);
-}
-
-static gboolean
-item_drag_drop (GtkDropTarget *dest,
-                const GValue  *value,
-                double         x,
-                double         y)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (dest));
-
-  set_color (item, g_value_get_boxed (value));
-
-  return TRUE;
-}
-
-static void
-angle_changed (GtkGestureRotate *gesture,
-               double            angle,
-               double            delta)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  TransformData *data = g_object_get_data (G_OBJECT (item), "transform-data");
-
-  data->delta = angle / M_PI * 180.0;
-
-  apply_transform (item);
-}
-
-static void
-rotate_done (GtkGesture *gesture)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  TransformData *data = g_object_get_data (G_OBJECT (item), "transform-data");
-
-  data->angle = data->angle + data->delta;
-  data->delta = 0;
-}
-
-static void
-click_done (GtkGesture *gesture)
-{
-  GtkWidget *item = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  GtkWidget *canvas = gtk_widget_get_parent (item);
-  GtkWidget *last_child;
-
-  last_child = gtk_widget_get_last_child (canvas);
-  if (item != last_child)
-    gtk_widget_insert_after (item, canvas, last_child);
-}
-
-static int n_items = 0;
-
-static GtkWidget *
-canvas_item_new (double x,
-                 double y)
-{
-  GtkWidget *widget;
-  char *label;
-  char *id;
-  TransformData *transform_data;
-  GdkRGBA rgba;
-  GtkDropTarget *dest;
-  GtkGesture *gesture;
-
-  n_items++;
-
-  label = g_strdup_printf ("Item %d", n_items);
-  id = g_strdup_printf ("item%d", n_items);
-
-  gdk_rgba_parse (&rgba, "yellow");
-
-  widget = gtk_label_new (label);
-  gtk_widget_add_css_class (widget, "frame");
-  gtk_widget_set_name (widget, id);
-
-  set_color (widget, &rgba);
-  transform_data = g_new0 (TransformData, 1);
-  transform_data->x = x;
-  transform_data->y = y;
-  transform_data->angle = 0.0;
-  g_object_set_data_full (G_OBJECT (widget), "transform-data", transform_data, g_free);
-
-  g_free (label);
-  g_free (id);
-
-  dest = gtk_drop_target_new (GDK_TYPE_RGBA, GDK_ACTION_COPY);
-  g_signal_connect (dest, "drop", G_CALLBACK (item_drag_drop), NULL);
-  gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (dest));
-
-  gesture = gtk_gesture_rotate_new ();
-  g_signal_connect (gesture, "angle-changed", G_CALLBACK (angle_changed), NULL);
-  g_signal_connect (gesture, "end", G_CALLBACK (rotate_done), NULL);
-  gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture));
-
-  gesture = gtk_gesture_click_new ();
-  g_signal_connect (gesture, "released", G_CALLBACK (click_done), NULL);
-  gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture));
-  
-  return widget;
-}
-
 static GtkWidget *window = NULL;
 
 GtkWidget *
@@ -419,82 +353,43 @@ do_dnd (GtkWidget *do_widget)
 {
   if (!window)
     {
-      GtkWidget *button;
-      GtkWidget *sw;
-      GtkWidget *canvas;
-      GtkWidget *box, *box2, *box3;
-      const char *colors[] = {
-        "red", "green", "blue", "magenta", "orange", "gray", "black", "yellow",
-        "white", "gray", "brown", "pink",  "cyan", "bisque", "gold", "maroon",
-        "navy", "orchid", "olive", "peru", "salmon", "silver", "wheat",
-        NULL
-      };
-      int i;
-      int x, y;
-
-      button = gtk_color_button_new ();
-      g_object_unref (g_object_ref_sink (button));
+      GtkWidget *vbox, *fixed;
+      GtkGesture *multipress;
+      GtkCssProvider *provider;
 
       window = gtk_window_new ();
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      gtk_window_set_title (GTK_WINDOW (window), "Drag-and-Drop");
-      gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      gtk_window_set_title (GTK_WINDOW (window), "Drag-and-drop");
 
-      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_window_set_child (GTK_WINDOW (window), box);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
-      box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-      gtk_box_append (GTK_BOX (box), box2);
+      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
-      canvas = canvas_new ();
-      gtk_box_append (GTK_BOX (box2), canvas);
+      fixed = gtk_fixed_new ();
+      gtk_container_add (GTK_CONTAINER (vbox), fixed);
+      gtk_widget_set_hexpand (fixed, TRUE);
+      gtk_widget_set_vexpand (fixed, TRUE);
 
-      n_items = 0;
+      multipress = gtk_gesture_click_new ();
+      gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (multipress), 0);
+      g_signal_connect (multipress, "pressed", G_CALLBACK (pressed_cb), NULL);
+      g_signal_connect (multipress, "released", G_CALLBACK (released_cb), NULL);
+      gtk_widget_add_controller (fixed, GTK_EVENT_CONTROLLER (multipress));
 
-      x = y = 40;
-      for (i = 0; i < 4; i++)
-        {
-          GtkWidget *item;
-
-          item = canvas_item_new (x, y);
-          gtk_fixed_put (GTK_FIXED (canvas), item, 0, 0);
-          apply_transform (item);
-
-          x += 150;
-          y += 100;
-        }
-
-      sw = gtk_scrolled_window_new (NULL, NULL);
-      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
-                                      GTK_POLICY_AUTOMATIC,
-                                      GTK_POLICY_NEVER);
-      gtk_box_append (GTK_BOX (box), sw);
-
-      box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-      gtk_widget_add_css_class (box3, "linked");
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), box3);
-
-      for (i = 0; colors[i]; i++)
-        {
-          GdkRGBA rgba;
-          GtkWidget *swatch;
-
-          gdk_rgba_parse (&rgba, colors[i]);
-
-          swatch = g_object_new (g_type_from_name ("GtkColorSwatch"),
-                                 "rgba", &rgba,
-                                 "selectable", FALSE,
-                                 NULL);
-          gtk_box_append (GTK_BOX (box3), swatch);
-        }
+      provider = gtk_css_provider_new ();
+      gtk_css_provider_load_from_resource (provider, "/dnd/dnd.css");
+      gtk_style_context_add_provider_for_display (gdk_display_get_default (),
+                                                  GTK_STYLE_PROVIDER (provider),
+                                                  800);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/dnd.css

@@ -0,0 +1,3 @@
+spinner.demo {
+  opacity: 1;
+}

demos/gtk-demo/drawingarea.c

@@ -42,9 +42,7 @@ create_surface (GtkWidget *widget)
 }
 
 static void
-scribble_resize (GtkWidget *widget,
-                 int        width,
-                 int        height)
+scribble_size_allocate (GtkWidget *widget)
 {
   create_surface (widget);
 }
@@ -125,164 +123,49 @@ drag_end (GtkGestureDrag *gesture,
 }
 
 static void
-oval_path (cairo_t *cr,
-           double xc, double yc,
-           double xr, double yr)
+checkerboard_draw (GtkDrawingArea *da,
+                   cairo_t        *cr,
+                   int             width,
+                   int             height,
+                   gpointer        data)
 {
-  cairo_save (cr);
+  gint i, j, xcount, ycount;
 
-  cairo_translate (cr, xc, yc);
-  cairo_scale (cr, 1.0, yr / xr);
-  cairo_move_to (cr, xr, 0.0);
-  cairo_arc (cr,
-             0, 0,
-             xr,
-             0, 2 * G_PI);
-  cairo_close_path (cr);
+#define CHECK_SIZE 10
+#define SPACING 2
 
-  cairo_restore (cr);
-}
+  /* At the start of a draw handler, a clip region has been set on
+   * the Cairo context, and the contents have been cleared to the
+   * widget's background color. The docs for
+   * gdk_surface_begin_paint_region() give more details on how this
+   * works.
+   */
 
-/* Fill the given area with checks in the standard style
- * for showing compositing effects.
- *
- * It would make sense to do this as a repeating surface,
- * but most implementations of RENDER currently have broken
- * implementations of repeat + transform, even when the
- * transform is a translation.
- */
-static void
-fill_checks (cairo_t *cr,
-             int x,     int y,
-             int width, int height)
-{
-  int i, j;
-
-#define CHECK_SIZE 16
-
-  cairo_rectangle (cr, x, y, width, height);
-  cairo_set_source_rgb (cr, 0.4, 0.4, 0.4);
-  cairo_fill (cr);
-
-  /* Only works for CHECK_SIZE a power of 2 */
-  j = x & (-CHECK_SIZE);
-
-  for (; j < height; j += CHECK_SIZE)
+  xcount = 0;
+  i = SPACING;
+  while (i < width)
     {
-      i = y & (-CHECK_SIZE);
-      for (; i < width; i += CHECK_SIZE)
-        if ((i / CHECK_SIZE + j / CHECK_SIZE) % 2 == 0)
+      j = SPACING;
+      ycount = xcount % 2; /* start with even/odd depending on row */
+      while (j < height)
+        {
+          if (ycount % 2)
+            cairo_set_source_rgb (cr, 0.45777, 0, 0.45777);
+          else
+            cairo_set_source_rgb (cr, 1, 1, 1);
+
+          /* If we're outside the clip, this will do nothing.
+           */
           cairo_rectangle (cr, i, j, CHECK_SIZE, CHECK_SIZE);
+          cairo_fill (cr);
+
+          j += CHECK_SIZE + SPACING;
+          ++ycount;
+        }
+
+      i += CHECK_SIZE + SPACING;
+      ++xcount;
     }
-
-  cairo_set_source_rgb (cr, 0.7, 0.7, 0.7);
-  cairo_fill (cr);
-
-#undef CHECK_SIZE
-}
-
-/* Draw a red, green, and blue circle equally spaced inside
- * the larger circle of radius r at (xc, yc)
- */
-static void
-draw_3circles (cairo_t *cr,
-               double xc, double yc,
-               double radius,
-               double alpha)
-{
-  double subradius = radius * (2 / 3. - 0.1);
-
-  cairo_set_source_rgba (cr, 1., 0., 0., alpha);
-  oval_path (cr,
-             xc + radius / 3. * cos (G_PI * (0.5)),
-             yc - radius / 3. * sin (G_PI * (0.5)),
-             subradius, subradius);
-  cairo_fill (cr);
-
-  cairo_set_source_rgba (cr, 0., 1., 0., alpha);
-  oval_path (cr,
-             xc + radius / 3. * cos (G_PI * (0.5 + 2/.3)),
-             yc - radius / 3. * sin (G_PI * (0.5 + 2/.3)),
-             subradius, subradius);
-  cairo_fill (cr);
-
-  cairo_set_source_rgba (cr, 0., 0., 1., alpha);
-  oval_path (cr,
-             xc + radius / 3. * cos (G_PI * (0.5 + 4/.3)),
-             yc - radius / 3. * sin (G_PI * (0.5 + 4/.3)),
-             subradius, subradius);
-  cairo_fill (cr);
-}
-
-static void
-groups_draw (GtkDrawingArea *darea,
-             cairo_t        *cr,
-             int             width,
-             int             height,
-             gpointer        data)
-{
-  cairo_surface_t *overlay, *punch, *circles;
-  cairo_t *overlay_cr, *punch_cr, *circles_cr;
-
-  /* Fill the background */
-  double radius = 0.5 * (width < height ? width : height) - 10;
-  double xc = width / 2.;
-  double yc = height / 2.;
-
-  overlay = cairo_surface_create_similar (cairo_get_target (cr),
-                                          CAIRO_CONTENT_COLOR_ALPHA,
-                                          width, height);
-
-  punch = cairo_surface_create_similar (cairo_get_target (cr),
-                                        CAIRO_CONTENT_ALPHA,
-                                        width, height);
-
-  circles = cairo_surface_create_similar (cairo_get_target (cr),
-                                          CAIRO_CONTENT_COLOR_ALPHA,
-                                          width, height);
-
-  fill_checks (cr, 0, 0, width, height);
-
-  /* Draw a black circle on the overlay
-   */
-  overlay_cr = cairo_create (overlay);
-  cairo_set_source_rgb (overlay_cr, 0., 0., 0.);
-  oval_path (overlay_cr, xc, yc, radius, radius);
-  cairo_fill (overlay_cr);
-
-  /* Draw 3 circles to the punch surface, then cut
-   * that out of the main circle in the overlay
-   */
-  punch_cr = cairo_create (punch);
-  draw_3circles (punch_cr, xc, yc, radius, 1.0);
-  cairo_destroy (punch_cr);
-
-  cairo_set_operator (overlay_cr, CAIRO_OPERATOR_DEST_OUT);
-  cairo_set_source_surface (overlay_cr, punch, 0, 0);
-  cairo_paint (overlay_cr);
-
-  /* Now draw the 3 circles in a subgroup again
-   * at half intensity, and use OperatorAdd to join up
-   * without seams.
-   */
-  circles_cr = cairo_create (circles);
-
-  cairo_set_operator (circles_cr, CAIRO_OPERATOR_OVER);
-  draw_3circles (circles_cr, xc, yc, radius, 0.5);
-  cairo_destroy (circles_cr);
-
-  cairo_set_operator (overlay_cr, CAIRO_OPERATOR_ADD);
-  cairo_set_source_surface (overlay_cr, circles, 0, 0);
-  cairo_paint (overlay_cr);
-
-  cairo_destroy (overlay_cr);
-
-  cairo_set_source_surface (cr, overlay, 0, 0);
-  cairo_paint (cr);
-
-  cairo_surface_destroy (overlay);
-  cairo_surface_destroy (punch);
-  cairo_surface_destroy (circles);
 }
 
 static void
@@ -319,25 +202,26 @@ do_drawingarea (GtkWidget *do_widget)
       gtk_widget_set_margin_end (vbox, 16);
       gtk_widget_set_margin_top (vbox, 16);
       gtk_widget_set_margin_bottom (vbox, 16);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       /*
-       * Create the groups area
+       * Create the checkerboard area
        */
+
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
-                            "<u>Knockout groups</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+                            "<u>Checkerboard pattern</u>");
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_vexpand (frame, TRUE);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       da = gtk_drawing_area_new ();
       gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 100);
       gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (da), 100);
-      gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), groups_draw, NULL, NULL);
-      gtk_frame_set_child (GTK_FRAME (frame), da);
+      gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), checkerboard_draw, NULL, NULL);
+      gtk_container_add (GTK_CONTAINER (frame), da);
 
       /*
        * Create the scribble area
@@ -346,20 +230,20 @@ do_drawingarea (GtkWidget *do_widget)
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "<u>Scribble area</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_vexpand (frame, TRUE);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       da = gtk_drawing_area_new ();
       gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 100);
       gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (da), 100);
       gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), scribble_draw, NULL, NULL);
-      gtk_frame_set_child (GTK_FRAME (frame), da);
+      gtk_container_add (GTK_CONTAINER (frame), da);
 
-      g_signal_connect (da, "resize",
-                        G_CALLBACK (scribble_resize), NULL);
+      g_signal_connect (da, "size-allocate",
+                        G_CALLBACK (scribble_size_allocate), NULL);
 
       drag = gtk_gesture_drag_new ();
       gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (drag), GDK_BUTTON_PRIMARY);
@@ -374,7 +258,7 @@ do_drawingarea (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
       gtk_widget_show (window);
   else
-      gtk_window_destroy (GTK_WINDOW (window));
+      gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/editable_cells.c

@@ -352,16 +352,17 @@ do_editable_cells (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Editable Cells");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
       gtk_widget_set_margin_start (vbox, 5);
       gtk_widget_set_margin_end (vbox, 5);
       gtk_widget_set_margin_top (vbox, 5);
       gtk_widget_set_margin_bottom (vbox, 5);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
-      gtk_box_append (GTK_BOX (vbox),
+      gtk_container_add (GTK_CONTAINER (vbox),
                           gtk_label_new ("Shopping list (you can edit the cells!)"));
 
       sw = gtk_scrolled_window_new (NULL, NULL);
@@ -369,7 +370,7 @@ do_editable_cells (GtkWidget *do_widget)
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                       GTK_POLICY_AUTOMATIC,
                                       GTK_POLICY_AUTOMATIC);
-      gtk_box_append (GTK_BOX (vbox), sw);
+      gtk_container_add (GTK_CONTAINER (vbox), sw);
 
       /* create models */
       items_model = create_items_model ();
@@ -386,22 +387,22 @@ do_editable_cells (GtkWidget *do_widget)
       g_object_unref (numbers_model);
       g_object_unref (items_model);
 
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), treeview);
+      gtk_container_add (GTK_CONTAINER (sw), treeview);
 
       /* some buttons */
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
       gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
       button = gtk_button_new_with_label ("Add item");
       g_signal_connect (button, "clicked",
                         G_CALLBACK (add_item), treeview);
-      gtk_box_append (GTK_BOX (hbox), button);
+      gtk_container_add (GTK_CONTAINER (hbox), button);
 
       button = gtk_button_new_with_label ("Remove item");
       g_signal_connect (button, "clicked",
                         G_CALLBACK (remove_item), treeview);
-      gtk_box_append (GTK_BOX (hbox), button);
+      gtk_container_add (GTK_CONTAINER (hbox), button);
 
       gtk_window_set_default_size (GTK_WINDOW (window), 320, 200);
     }
@@ -409,7 +410,7 @@ do_editable_cells (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/entry_completion.c

@@ -50,22 +50,24 @@ do_entry_completion (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Entry Completion");
       gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
       gtk_widget_set_margin_start (vbox, 5);
       gtk_widget_set_margin_end (vbox, 5);
       gtk_widget_set_margin_top (vbox, 5);
       gtk_widget_set_margin_bottom (vbox, 5);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label), "Completion demo, try writing <b>total</b> or <b>gnome</b> for example.");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       /* Create our entry */
       entry = gtk_entry_new ();
-      gtk_box_append (GTK_BOX (vbox), entry);
+      gtk_container_add (GTK_CONTAINER (vbox), entry);
 
       /* Create the completion object */
       completion = gtk_entry_completion_new ();
@@ -86,7 +88,7 @@ do_entry_completion (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/entry_undo.c

@@ -25,30 +25,31 @@ do_entry_undo (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Entry Undo");
       gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
       gtk_widget_set_margin_start (vbox, 5);
       gtk_widget_set_margin_end (vbox, 5);
       gtk_widget_set_margin_top (vbox, 5);
       gtk_widget_set_margin_bottom (vbox, 5);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "Use Primary+z or Primary+Shift+z to undo or redo changes");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       /* Create our entry */
       entry = gtk_entry_new ();
       gtk_editable_set_enable_undo (GTK_EDITABLE (entry), TRUE);
-      gtk_box_append (GTK_BOX (vbox), entry);
+      gtk_container_add (GTK_CONTAINER (vbox), entry);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/expander.c

@@ -15,7 +15,7 @@ static GtkWidget *window = NULL;
 static void
 response_cb (GtkDialog *dialog, gint response_id)
 {
-  gtk_window_destroy (GTK_WINDOW (window));
+  gtk_widget_destroy (window);
   window = NULL;
 }
 
@@ -78,9 +78,9 @@ do_expander (GtkWidget *do_widget)
                                 "A second paragraph will contain even more "
                                 "innuendo, just to make you scroll down or "
                                 "resize the window. Do it already !", -1);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), tv);
-      gtk_expander_set_child (GTK_EXPANDER (expander), sw);
-      gtk_box_append (GTK_BOX (area), expander);
+      gtk_container_add (GTK_CONTAINER (sw), tv);
+      gtk_container_add (GTK_CONTAINER (expander), sw);
+      gtk_container_add (GTK_CONTAINER (area), expander);
       g_signal_connect (expander, "notify::expanded",
                         G_CALLBACK (expander_cb), window);
 
@@ -90,7 +90,7 @@ do_expander (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/filtermodel.c

@@ -125,7 +125,8 @@ do_filtermodel (GtkWidget *do_widget)
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       store = (GtkListStore*)gtk_builder_get_object (builder, "liststore1");
 
@@ -198,7 +199,7 @@ do_filtermodel (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/fishbowl.c

@@ -161,7 +161,7 @@ create_menu_button (void)
   GtkWidget *w = gtk_menu_button_new ();
   GtkWidget *popover = gtk_popover_new ();
 
-  gtk_popover_set_child (GTK_POPOVER (popover), gtk_button_new_with_label ("Hey!"));
+  gtk_container_add (GTK_CONTAINER (popover), gtk_button_new_with_label ("Hey!"));
   gtk_popover_set_autohide (GTK_POPOVER (popover), FALSE);
   gtk_menu_button_set_popover (GTK_MENU_BUTTON (w), popover);
   g_signal_connect (w, "map", G_CALLBACK (mapped), NULL);
@@ -194,7 +194,7 @@ static void
 set_widget_type (GtkFishbowl *fishbowl,
                  int          widget_type_index)
 {
-  GtkWidget *window;
+  GtkWidget *window, *headerbar;
 
   if (widget_type_index == selected_widget_type)
     return;
@@ -205,8 +205,9 @@ set_widget_type (GtkFishbowl *fishbowl,
                                   widget_types[selected_widget_type].create_func);
 
   window = GTK_WIDGET (gtk_widget_get_root (GTK_WIDGET (fishbowl)));
-  gtk_window_set_title (GTK_WINDOW (window),
-                        widget_types[selected_widget_type].name);
+  headerbar = gtk_window_get_titlebar (GTK_WINDOW (window));
+  gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar),
+                            widget_types[selected_widget_type].name);
 }
 
 void
@@ -273,13 +274,15 @@ do_fishbowl (GtkWidget *do_widget)
 
       builder = gtk_builder_new_from_resource ("/fishbowl/fishbowl.ui");
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
-
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
       bowl = GTK_WIDGET (gtk_builder_get_object (builder, "bowl"));
       selected_widget_type = -1;
       set_widget_type (GTK_FISHBOWL (bowl), 0);
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       gtk_widget_realize (window);
       g_object_unref (builder);
@@ -288,7 +291,7 @@ do_fishbowl (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/fishbowl.ui

@@ -58,7 +58,6 @@
     <child>
       <object class="GtkFishbowl" id="bowl">
         <property name="visible">True</property>
-        <property name="overflow">hidden</property>
         <property name="animating">True</property>
         <property name="benchmark" bind-source="changes_allow" bind-property="active" bind-flags="invert-boolean | sync-create"/>
       </object>

demos/gtk-demo/fixed.c

@@ -53,7 +53,7 @@ create_faces (void)
       faces[i].face = gtk_frame_new (NULL);
       gtk_widget_set_size_request (faces[i].face, face_size, face_size);
       gtk_widget_add_css_class (faces[i].face, faces[i].css_class);
-      gtk_fixed_put (GTK_FIXED (fixed), faces[i].face, 0, 0);
+      gtk_container_add (GTK_CONTAINER (fixed), faces[i].face);
 
       /* Set up the transformation for each face */
       transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (w, h));
@@ -131,15 +131,15 @@ create_demo_window (GtkWidget *do_widget)
   g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);
 
   sw = gtk_scrolled_window_new (NULL, NULL);
-  gtk_window_set_child (GTK_WINDOW (window), sw);
+  gtk_container_add (GTK_CONTAINER (window), sw);
 
   fixed = gtk_fixed_new ();
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), fixed);
+  gtk_container_add (GTK_CONTAINER (sw), fixed);
   gtk_widget_set_halign (GTK_WIDGET (fixed), GTK_ALIGN_CENTER);
   gtk_widget_set_valign (GTK_WIDGET (fixed), GTK_ALIGN_CENTER);
 
   cube = create_faces ();
-  gtk_fixed_put (GTK_FIXED (fixed), cube, 0, 0);
+  gtk_container_add (GTK_CONTAINER (fixed), cube);
   gtk_widget_set_overflow (fixed, GTK_OVERFLOW_VISIBLE);
 
   provider = gtk_css_provider_new ();
@@ -161,7 +161,7 @@ do_fixed (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (demo_window))
     gtk_widget_show (demo_window);
   else
-    gtk_window_destroy (GTK_WINDOW (demo_window));
+    gtk_widget_destroy (demo_window);
 
   return demo_window;
 }

demos/gtk-demo/flowbox.c

@@ -37,7 +37,7 @@ color_swatch_new (const gchar *color)
   gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (area), 24);
   gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (area), 24);
   gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (area), draw_color, (gpointer) color, NULL);
-  gtk_button_set_child (GTK_BUTTON (button), area);
+  gtk_container_add (GTK_CONTAINER (button), area);
 
   return button;
 }
@@ -724,7 +724,9 @@ do_flowbox (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Flow Box");
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 600);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       scrolled = gtk_scrolled_window_new (NULL, NULL);
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
@@ -733,17 +735,17 @@ do_flowbox (GtkWidget *do_widget)
       gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (flowbox), 30);
       gtk_flow_box_set_selection_mode (GTK_FLOW_BOX (flowbox), GTK_SELECTION_NONE);
 
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled), flowbox);
-      gtk_window_set_child (GTK_WINDOW (window), scrolled);
+      gtk_container_add (GTK_CONTAINER (scrolled), flowbox);
+      gtk_container_add (GTK_CONTAINER (window), scrolled);
 
       for (i = 0; colors[i]; i++)
-        gtk_flow_box_insert (GTK_FLOW_BOX (flowbox), color_swatch_new (colors[i]), -1);
+        gtk_container_add (GTK_CONTAINER (flowbox), color_swatch_new (colors[i]));
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/font-features.ui

@@ -4,10 +4,10 @@
   <object class="GtkWindow" id="window">
     <property name="default-width">600</property>
     <property name="default-height">500</property>
-    <property name="title">Font Explorer</property>
     <child type="titlebar">
       <object class="GtkHeaderBar">
         <property name="show-title-buttons">1</property>
+        <property name="title">Font Explorer</property>
         <child>
           <object class="GtkButton" id="reset">
             <property name="receives-default">1</property>

demos/gtk-demo/font_features.c

@@ -194,7 +194,7 @@ add_check_group (GtkWidget   *box,
   pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
   gtk_label_set_attributes (GTK_LABEL (label), attrs);
   pango_attr_list_unref (attrs);
-  gtk_box_append (GTK_BOX (group), label);
+  gtk_container_add (GTK_CONTAINER (group), label);
 
   for (i = 0; tags[i]; i++)
     {
@@ -211,7 +211,7 @@ add_check_group (GtkWidget   *box,
       g_signal_connect (feat, "notify::inconsistent", G_CALLBACK (update_display), NULL);
       g_signal_connect (feat, "clicked", G_CALLBACK (feat_clicked), NULL);
 
-      gtk_box_append (GTK_BOX (group), feat);
+      gtk_container_add (GTK_CONTAINER (group), feat);
 
       item = g_new (FeatureItem, 1);
       item->name = tags[i];
@@ -223,7 +223,7 @@ add_check_group (GtkWidget   *box,
       feature_items = g_list_prepend (feature_items, item);
     }
 
-  gtk_box_append (GTK_BOX (box), group);
+  gtk_container_add (GTK_CONTAINER (box), group);
 }
 
 static void
@@ -248,7 +248,7 @@ add_radio_group (GtkWidget *box,
   pango_attr_list_insert (attrs, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
   gtk_label_set_attributes (GTK_LABEL (label), attrs);
   pango_attr_list_unref (attrs);
-  gtk_box_append (GTK_BOX (group), label);
+  gtk_container_add (GTK_CONTAINER (group), label);
 
   for (i = 0; tags[i]; i++)
     {
@@ -268,7 +268,7 @@ add_radio_group (GtkWidget *box,
       g_signal_connect (feat, "notify::active", G_CALLBACK (update_display), NULL);
       g_object_set_data (G_OBJECT (feat), "default", group_button);
 
-      gtk_box_append (GTK_BOX (group), feat);
+      gtk_container_add (GTK_CONTAINER (group), feat);
 
       item = g_new (FeatureItem, 1);
       item->name = tags[i];
@@ -280,7 +280,7 @@ add_radio_group (GtkWidget *box,
       feature_items = g_list_prepend (feature_items, item);
     }
 
-  gtk_box_append (GTK_BOX (box), group);
+  gtk_container_add (GTK_CONTAINER (box), group);
 }
 
 static void
@@ -1025,7 +1025,7 @@ denorm_coord (hb_ot_var_axis_info_t *axis, int coord)
 static void
 update_font_variations (void)
 {
-  GtkWidget *child;
+  GtkWidget *child, *next;
   PangoFont *pango_font = NULL;
   hb_font_t *hb_font;
   hb_face_t *hb_face;
@@ -1037,8 +1037,12 @@ update_font_variations (void)
   int i;
 
   child = gtk_widget_get_first_child (variations_grid);
-  while ((child = gtk_widget_get_first_child (variations_grid)))
-    gtk_grid_remove (GTK_GRID (variations_grid), child);
+  while (child != NULL)
+    {
+      next = gtk_widget_get_next_sibling (child);
+      gtk_widget_destroy (child);
+      child = next;
+    }
 
   instance_combo = NULL;
 
@@ -1329,7 +1333,8 @@ do_font_features (GtkWidget *do_widget)
 
       font_features_font_changed ();
 
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       g_object_unref (builder);
 
@@ -1339,7 +1344,7 @@ do_font_features (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_window_present (GTK_WINDOW (window));
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/fontrendering.c

@@ -281,7 +281,7 @@ do_fontrendering (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/gears.c

@@ -53,7 +53,7 @@ create_axis_slider (GtkGears *gears,
     }
 
   label = gtk_label_new (text);
-  gtk_box_append (GTK_BOX (box), label);
+  gtk_container_add (GTK_CONTAINER (box), label);
   gtk_widget_show (label);
 
   adj = gtk_adjustment_new (gtk_gears_get_axis (gears, axis), 0.0, 360.0, 1.0, 12.0, 0.0);
@@ -63,7 +63,7 @@ create_axis_slider (GtkGears *gears,
                     gears);
   slider = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
   gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
-  gtk_box_append (GTK_BOX (box), slider);
+  gtk_container_add (GTK_CONTAINER (box), slider);
   gtk_widget_set_vexpand (slider, TRUE);
   gtk_widget_show (slider);
 
@@ -85,7 +85,7 @@ do_gears (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "Gears");
       gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
       gtk_window_set_default_size (GTK_WINDOW (window), 640, 640);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
 
       overlay = gtk_overlay_new ();
       gtk_widget_set_margin_start (overlay, 12);
@@ -93,7 +93,7 @@ do_gears (GtkWidget *do_widget)
       gtk_widget_set_margin_top (overlay, 12);
       gtk_widget_set_margin_bottom (overlay, 12);
 
-      gtk_window_set_child (GTK_WINDOW (window), overlay);
+      gtk_container_add (GTK_CONTAINER (window), overlay);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_halign (frame, GTK_ALIGN_START);
@@ -103,27 +103,27 @@ do_gears (GtkWidget *do_widget)
 
       fps_label = gtk_label_new ("");
       gtk_widget_set_halign (fps_label, GTK_ALIGN_START);
-      gtk_frame_set_child (GTK_FRAME (frame), fps_label);
+      gtk_container_add (GTK_CONTAINER (frame), fps_label);
 
       box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
       gtk_box_set_spacing (GTK_BOX (box), 6);
-      gtk_overlay_set_child (GTK_OVERLAY (overlay), box);
+      gtk_container_add (GTK_CONTAINER (overlay), box);
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
       gtk_box_set_spacing (GTK_BOX (box), 6);
-      gtk_box_append (GTK_BOX (box), hbox);
+      gtk_container_add (GTK_CONTAINER (box), hbox);
 
       gears = gtk_gears_new ();
       gtk_widget_set_hexpand (gears, TRUE);
       gtk_widget_set_vexpand (gears, TRUE);
-      gtk_box_append (GTK_BOX (hbox), gears);
+      gtk_container_add (GTK_CONTAINER (hbox), gears);
 
       for (i = 0; i < GTK_GEARS_N_AXIS; i++)
-        gtk_box_append (GTK_BOX (hbox), create_axis_slider (GTK_GEARS (gears), i));
+        gtk_container_add (GTK_CONTAINER (hbox), create_axis_slider (GTK_GEARS (gears), i));
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
       gtk_box_set_spacing (GTK_BOX (hbox), 6);
-      gtk_box_append (GTK_BOX (box), hbox);
+      gtk_container_add (GTK_CONTAINER (box), hbox);
 
       gtk_gears_set_fps_label (GTK_GEARS (gears), GTK_LABEL (fps_label));
     }
@@ -131,7 +131,7 @@ do_gears (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/gestures.c

@@ -149,10 +149,11 @@ do_gestures (GtkWidget *do_widget)
       window = gtk_window_new ();
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
       gtk_window_set_title (GTK_WINDOW (window), "Gestures");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       drawing_area = gtk_drawing_area_new ();
-      gtk_window_set_child (GTK_WINDOW (window), drawing_area);
+      gtk_container_add (GTK_CONTAINER (window), drawing_area);
 
       gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area),
                                       drawing_area_draw,
@@ -209,7 +210,7 @@ do_gestures (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/glarea.c

@@ -354,7 +354,7 @@ create_axis_slider (int axis)
     }
 
   label = gtk_label_new (text);
-  gtk_box_append (GTK_BOX (box), label);
+  gtk_container_add (GTK_CONTAINER (box), label);
   gtk_widget_show (label);
 
   adj = gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 12.0, 0.0);
@@ -362,7 +362,7 @@ create_axis_slider (int axis)
                     G_CALLBACK (on_axis_value_change),
                     GINT_TO_POINTER (axis));
   slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj);
-  gtk_box_append (GTK_BOX (box), slider);
+  gtk_container_add (GTK_CONTAINER (box), slider);
   gtk_widget_set_hexpand (slider, TRUE);
   gtk_widget_show (slider);
 
@@ -401,12 +401,12 @@ create_glarea_window (GtkWidget *do_widget)
   gtk_widget_set_margin_top (box, 12);
   gtk_widget_set_margin_bottom (box, 12);
   gtk_box_set_spacing (GTK_BOX (box), 6);
-  gtk_window_set_child (GTK_WINDOW (window), box);
+  gtk_container_add (GTK_CONTAINER (window), box);
 
   gl_area = gtk_gl_area_new ();
   gtk_widget_set_hexpand (gl_area, TRUE);
   gtk_widget_set_vexpand (gl_area, TRUE);
-  gtk_box_append (GTK_BOX (box), gl_area);
+  gtk_container_add (GTK_CONTAINER (box), gl_area);
 
   /* We need to initialize and free GL resources, so we use
    * the realize and unrealize signals on the widget
@@ -418,16 +418,16 @@ create_glarea_window (GtkWidget *do_widget)
   g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
 
   controls = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
-  gtk_box_append (GTK_BOX (box), controls);
+  gtk_container_add (GTK_CONTAINER (box), controls);
   gtk_widget_set_hexpand (controls, TRUE);
 
   for (i = 0; i < N_AXIS; i++)
-    gtk_box_append (GTK_BOX (controls), create_axis_slider (i));
+    gtk_container_add (GTK_CONTAINER (controls), create_axis_slider (i));
 
   button = gtk_button_new_with_label ("Quit");
   gtk_widget_set_hexpand (button, TRUE);
-  gtk_box_append (GTK_BOX (box), button);
-  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
+  gtk_container_add (GTK_CONTAINER (box), button);
+  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
 
   return window;
 }
@@ -441,7 +441,7 @@ do_glarea (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (demo_window))
     gtk_widget_show (demo_window);
   else
-    gtk_window_destroy (GTK_WINDOW (demo_window));
+    gtk_widget_destroy (demo_window);
 
   return demo_window;
 }

demos/gtk-demo/headerbar.c

@@ -2,8 +2,9 @@
  *
  * GtkHeaderBar is a container that is suitable for implementing
  * window titlebars. One of its features is that it can position
- * a title centered with regard to the full width, regardless of
- * variable-width content at the left or right.
+ * a title (and optional subtitle) centered with regard to the
+ * full width, regardless of variable-width content at the left
+ * or right.
  *
  * It is commonly used with gtk_window_set_titlebar()
  */
@@ -24,41 +25,42 @@ do_headerbar (GtkWidget *do_widget)
     {
       window = gtk_window_new ();
       gtk_window_set_display (GTK_WINDOW (window),  gtk_widget_get_display (do_widget));
-      gtk_window_set_title (GTK_WINDOW (window), "Welcome to Facebook - Log in, sign up or learn more");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
-
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
       gtk_window_set_default_size (GTK_WINDOW (window), 600, 400);
 
       header = gtk_header_bar_new ();
       gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE);
+      gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Welcome to Facebook - Log in, sign up or learn more");
+      gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE);
 
       button = gtk_button_new ();
       icon = g_themed_icon_new ("mail-send-receive-symbolic");
       image = gtk_image_new_from_gicon (icon);
       g_object_unref (icon);
-      gtk_button_set_child (GTK_BUTTON (button), image);
+      gtk_container_add (GTK_CONTAINER (button), image);
       gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);
 
       box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
       gtk_widget_add_css_class (box, "linked");
       button = gtk_button_new ();
-      gtk_button_set_child (GTK_BUTTON (button), gtk_image_new_from_icon_name ("pan-start-symbolic"));
-      gtk_box_append (GTK_BOX (box), button);
+      gtk_container_add (GTK_CONTAINER (button), gtk_image_new_from_icon_name ("pan-start-symbolic"));
+      gtk_container_add (GTK_CONTAINER (box), button);
       button = gtk_button_new ();
-      gtk_button_set_child (GTK_BUTTON (button), gtk_image_new_from_icon_name ("pan-end-symbolic"));
-      gtk_box_append (GTK_BOX (box), button);
+      gtk_container_add (GTK_CONTAINER (button), gtk_image_new_from_icon_name ("pan-end-symbolic"));
+      gtk_container_add (GTK_CONTAINER (box), button);
 
       gtk_header_bar_pack_start (GTK_HEADER_BAR (header), box);
 
       gtk_window_set_titlebar (GTK_WINDOW (window), header);
 
-      gtk_window_set_child (GTK_WINDOW (window), gtk_text_view_new ());
+      gtk_container_add (GTK_CONTAINER (window), gtk_text_view_new ());
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/help-overlay.ui

@@ -1,25 +0,0 @@
-<interface>
-  <object class="GtkShortcutsWindow" id="help_overlay">
-    <child>
-      <object class="GtkShortcutsSection">
-        <child>
-          <object class="GtkShortcutsGroup">
-            <property name="title">General</property>
-            <child>
-              <object class="GtkShortcutsShortcut">
-                <property name="accelerator">F1</property>
-                <property name="title">Show About Dialog</property>
-              </object>
-            </child>
-            <child>
-              <object class="GtkShortcutsShortcut">
-                <property name="accelerator">&lt;Control&gt;q</property>
-                <property name="title">Quit</property>
-              </object>
-            </child>
-          </object>
-        </child>
-      </object>
-    </child>
-  </object>
-</interface>

demos/gtk-demo/hypertext.c

@@ -237,7 +237,9 @@ do_hypertext (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_default_size (GTK_WINDOW (window), 450, 450);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       view = gtk_text_view_new ();
       gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
@@ -264,8 +266,8 @@ do_hypertext (GtkWidget *do_widget)
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                       GTK_POLICY_AUTOMATIC,
                                       GTK_POLICY_AUTOMATIC);
-      gtk_window_set_child (GTK_WINDOW (window), sw);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), view);
+      gtk_container_add (GTK_CONTAINER (window), sw);
+      gtk_container_add (GTK_CONTAINER (sw), view);
 
       show_page (buffer, 1);
     }
@@ -273,7 +275,7 @@ do_hypertext (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/iconscroll.c

@@ -66,9 +66,9 @@ populate_icons (void)
   hincrement = 0;
 
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
-                                  GTK_POLICY_NEVER,
-                                  GTK_POLICY_AUTOMATIC);
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), grid);
+		                  GTK_POLICY_NEVER,
+		                  GTK_POLICY_AUTOMATIC);
+  gtk_container_add (GTK_CONTAINER (scrolledwindow), grid);
 }
 
 static char *content;
@@ -102,9 +102,9 @@ populate_text (gboolean hilight)
   hincrement = 0;
 
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
-                                  GTK_POLICY_NEVER,
-                                  GTK_POLICY_AUTOMATIC);
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), textview);
+		                  GTK_POLICY_NEVER,
+		                  GTK_POLICY_AUTOMATIC);
+  gtk_container_add (GTK_CONTAINER (scrolledwindow), textview);
 }
 
 static void
@@ -126,9 +126,9 @@ populate_image (void)
   hincrement = 5;
 
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
-                                  GTK_POLICY_AUTOMATIC,
-                                  GTK_POLICY_AUTOMATIC);
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), image);
+		                  GTK_POLICY_AUTOMATIC,
+		                  GTK_POLICY_AUTOMATIC);
+  gtk_container_add (GTK_CONTAINER (scrolledwindow), image);
 }
 
 static void
@@ -137,8 +137,9 @@ set_widget_type (int type)
   if (tick_cb)
     gtk_widget_remove_tick_callback (window, tick_cb);
 
-  if (gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (scrolledwindow)))
-    gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolledwindow), NULL);
+  if (gtk_bin_get_child (GTK_BIN (scrolledwindow)))
+    gtk_container_remove (GTK_CONTAINER (scrolledwindow),
+                          gtk_bin_get_child (GTK_BIN (scrolledwindow)));
 
   selected = type;
 
@@ -209,23 +210,23 @@ do_iconscroll (GtkWidget *do_widget)
 
       builder = gtk_builder_new_from_resource ("/iconscroll/iconscroll.ui");
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
       scrolledwindow = GTK_WIDGET (gtk_builder_get_object (builder, "scrolledwindow"));
       gtk_widget_realize (window);
       hadjustment = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "hadjustment"));
       vadjustment = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "vadjustment"));
       set_widget_type (0);
-
-      g_object_unref (builder);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/iconview.c

@@ -228,7 +228,7 @@ home_clicked (GtkButton *item,
 
 static void close_window(void)
 {
-  gtk_window_destroy (GTK_WINDOW (window));
+  gtk_widget_destroy (window);
   window = NULL;
 
   g_object_unref (file_pixbuf);
@@ -263,17 +263,17 @@ do_iconview (GtkWidget *do_widget)
       load_pixbufs ();
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       tool_bar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-      gtk_box_append (GTK_BOX (vbox), tool_bar);
+      gtk_container_add (GTK_CONTAINER (vbox), tool_bar);
 
       up_button = gtk_button_new_with_mnemonic ("_Up");
       gtk_widget_set_sensitive (GTK_WIDGET (up_button), FALSE);
-      gtk_box_append (GTK_BOX (tool_bar), up_button);
+      gtk_container_add (GTK_CONTAINER (tool_bar), up_button);
 
       home_button = gtk_button_new_with_mnemonic ("_Home");
-      gtk_box_append (GTK_BOX (tool_bar), home_button);
+      gtk_container_add (GTK_CONTAINER (tool_bar), home_button);
 
 
       sw = gtk_scrolled_window_new (NULL, NULL);
@@ -283,7 +283,7 @@ do_iconview (GtkWidget *do_widget)
                                       GTK_POLICY_AUTOMATIC);
       gtk_widget_set_vexpand (sw, TRUE);
 
-      gtk_box_append (GTK_BOX (vbox), sw);
+      gtk_container_add (GTK_CONTAINER (vbox), sw);
 
       /* Create the store and fill it with the contents of '/' */
       parent = g_strdup ("/");
@@ -312,7 +312,7 @@ do_iconview (GtkWidget *do_widget)
       /* Connect to the "item-activated" signal */
       g_signal_connect (icon_view, "item-activated",
                         G_CALLBACK (item_activated), store);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), icon_view);
+      gtk_container_add (GTK_CONTAINER (sw), icon_view);
 
       gtk_widget_grab_focus (icon_view);
     }
@@ -320,7 +320,7 @@ do_iconview (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/iconview_edit.c

@@ -111,7 +111,9 @@ do_iconview_edit (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Editing and Drag-and-Drop");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       store = create_store ();
       fill_store (store);
@@ -144,13 +146,13 @@ do_iconview_edit (GtkWidget *do_widget)
                                       "text", COL_TEXT,
                                       NULL);
 
-      gtk_window_set_child (GTK_WINDOW (window), icon_view);
+      gtk_container_add (GTK_CONTAINER (window), icon_view);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/images.c

@@ -91,7 +91,7 @@ progressive_timeout (gpointer data)
           g_error_free (error);
 
           g_signal_connect (dialog, "response",
-                            G_CALLBACK (gtk_window_destroy), NULL);
+                            G_CALLBACK (gtk_widget_destroy), NULL);
 
           g_object_unref (image_stream);
           image_stream = NULL;
@@ -119,7 +119,7 @@ progressive_timeout (gpointer data)
           g_error_free (error);
 
           g_signal_connect (dialog, "response",
-                            G_CALLBACK (gtk_window_destroy), NULL);
+                            G_CALLBACK (gtk_widget_destroy), NULL);
 
           g_object_unref (image_stream);
           image_stream = NULL;
@@ -152,7 +152,7 @@ progressive_timeout (gpointer data)
               g_error_free (error);
 
               g_signal_connect (dialog, "response",
-                                G_CALLBACK (gtk_window_destroy), NULL);
+                                G_CALLBACK (gtk_widget_destroy), NULL);
 
               gtk_widget_show (dialog);
 
@@ -189,7 +189,7 @@ progressive_timeout (gpointer data)
               g_error_free (error);
 
               g_signal_connect (dialog, "response",
-                                G_CALLBACK (gtk_window_destroy), NULL);
+                                G_CALLBACK (gtk_widget_destroy), NULL);
 
               gtk_widget_show (dialog);
 
@@ -223,7 +223,7 @@ progressive_timeout (gpointer data)
           g_error_free (error);
 
           g_signal_connect (dialog, "response",
-                            G_CALLBACK (gtk_window_destroy), NULL);
+                            G_CALLBACK (gtk_widget_destroy), NULL);
 
           gtk_widget_show (dialog);
 
@@ -293,16 +293,24 @@ static void
 toggle_sensitivity_callback (GtkWidget *togglebutton,
                              gpointer   user_data)
 {
-  GtkWidget *child;
+  GtkContainer *container = user_data;
+  GList *list;
+  GList *tmp;
 
-  for (child = gtk_widget_get_first_child (GTK_WIDGET (user_data));
-       child != NULL;
-       child = gtk_widget_get_next_sibling (child))
+  list = gtk_container_get_children (container);
+
+  tmp = list;
+  while (tmp != NULL)
     {
       /* don't disable our toggle */
-      if (child != togglebutton)
-        gtk_widget_set_sensitive (child, !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (togglebutton)));
+      if (GTK_WIDGET (tmp->data) != togglebutton)
+        gtk_widget_set_sensitive (GTK_WIDGET (tmp->data),
+                                  !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (togglebutton)));
+
+      tmp = tmp->next;
     }
+
+  g_list_free (list);
 }
 
 
@@ -327,8 +335,9 @@ do_images (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Images");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
 
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
       g_signal_connect (window, "destroy",
                         G_CALLBACK (cleanup_callback), NULL);
 
@@ -337,28 +346,28 @@ do_images (GtkWidget *do_widget)
       gtk_widget_set_margin_end (base_vbox, 16);
       gtk_widget_set_margin_top (base_vbox, 16);
       gtk_widget_set_margin_bottom (base_vbox, 16);
-      gtk_window_set_child (GTK_WINDOW (window), base_vbox);
+      gtk_container_add (GTK_CONTAINER (window), base_vbox);
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 16);
-      gtk_box_append (GTK_BOX (base_vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (base_vbox), hbox);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
-      gtk_box_append (GTK_BOX (hbox), vbox);
+      gtk_container_add (GTK_CONTAINER (hbox), vbox);
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "<u>Image loaded from a file</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       image = gtk_image_new_from_icon_name ("gtk3-demo");
       gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
 
-      gtk_frame_set_child (GTK_FRAME (frame), image);
+      gtk_container_add (GTK_CONTAINER (frame), image);
 
 
       /* Animation */
@@ -366,94 +375,94 @@ do_images (GtkWidget *do_widget)
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "<u>Animation loaded from a file</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       picture = gtk_picture_new_for_resource ("/images/floppybuddy.gif");
 
-      gtk_frame_set_child (GTK_FRAME (frame), picture);
+      gtk_container_add (GTK_CONTAINER (frame), picture);
 
       /* Symbolic icon */
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "<u>Symbolic themed icon</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic");
       image = gtk_image_new_from_gicon (gicon);
       gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
 
-      gtk_frame_set_child (GTK_FRAME (frame), image);
+      gtk_container_add (GTK_CONTAINER (frame), image);
 
 
       /* Progressive */
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
-      gtk_box_append (GTK_BOX (hbox), vbox);
+      gtk_container_add (GTK_CONTAINER (hbox), vbox);
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "<u>Progressive image loading</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       /* Create an empty image for now; the progressive loader
        * will create the pixbuf and fill it in.
        */
       picture = gtk_picture_new ();
-      gtk_frame_set_child (GTK_FRAME (frame), picture);
+      gtk_container_add (GTK_CONTAINER (frame), picture);
 
       start_progressive_loading (picture);
 
       /* Video */
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
-      gtk_box_append (GTK_BOX (hbox), vbox);
+      gtk_container_add (GTK_CONTAINER (hbox), vbox);
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "<u>Displaying video</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
       gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       video = gtk_video_new_for_resource ("/images/gtk-logo.webm");
       gtk_media_stream_set_loop (gtk_video_get_media_stream (GTK_VIDEO (video)), TRUE);
-      gtk_frame_set_child (GTK_FRAME (frame), video);
+      gtk_container_add (GTK_CONTAINER (frame), video);
 
       /* Widget paintables */
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
-      gtk_box_append (GTK_BOX (hbox), vbox);
+      gtk_container_add (GTK_CONTAINER (hbox), vbox);
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
                             "<u>GtkWidgetPaintable</u>");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       paintable = gtk_widget_paintable_new (do_widget);
       picture = gtk_picture_new_for_paintable (paintable);
       gtk_widget_set_size_request (picture, 100, 100);
       gtk_widget_set_valign (picture, GTK_ALIGN_START);
-      gtk_box_append (GTK_BOX (vbox), picture);
+      gtk_container_add (GTK_CONTAINER (vbox), picture);
 
       /* Sensitivity control */
       button = gtk_toggle_button_new_with_mnemonic ("_Insensitive");
-      gtk_box_append (GTK_BOX (base_vbox), button);
+      gtk_container_add (GTK_CONTAINER (base_vbox), button);
 
       g_signal_connect (button, "toggled",
                         G_CALLBACK (toggle_sensitivity_callback),
@@ -463,7 +472,7 @@ do_images (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/infobar.c

@@ -29,8 +29,10 @@ on_bar_response (GtkInfoBar *info_bar,
   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
                                             "Your response has id %d", response_id);
 
-  g_signal_connect_swapped (dialog, "response",
-                            G_CALLBACK (gtk_window_destroy), dialog);
+  g_signal_connect_swapped (dialog,
+                            "response",
+                            G_CALLBACK (gtk_widget_destroy),
+                            dialog);
 
   gtk_widget_show (dialog);
 }
@@ -42,6 +44,7 @@ do_infobar (GtkWidget *do_widget)
   GtkWidget *frame;
   GtkWidget *bar;
   GtkWidget *vbox;
+  GtkWidget *vbox2;
   GtkWidget *label;
   GtkWidget *actions;
   GtkWidget *button;
@@ -49,104 +52,108 @@ do_infobar (GtkWidget *do_widget)
   if (!window)
     {
       actions = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-      gtk_widget_add_css_class (actions, "linked");
 
       window = gtk_window_new ();
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Info Bars");
-      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
       gtk_widget_set_margin_start (vbox, 8);
       gtk_widget_set_margin_end (vbox, 8);
       gtk_widget_set_margin_top (vbox, 8);
       gtk_widget_set_margin_bottom (vbox, 8);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       bar = gtk_info_bar_new ();
-      gtk_box_append (GTK_BOX (vbox), bar);
+      gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_INFO);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_INFO");
       gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
-      gtk_info_bar_add_child (GTK_INFO_BAR (bar), label);
+      gtk_container_add (GTK_CONTAINER (bar), label);
 
       button = gtk_toggle_button_new_with_label ("Message");
       g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
-      gtk_box_append (GTK_BOX (actions), button);
+      gtk_container_add (GTK_CONTAINER (actions), button);
 
       bar = gtk_info_bar_new ();
-      gtk_box_append (GTK_BOX (vbox), bar);
+      gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_WARNING);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_WARNING");
       gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
-      gtk_info_bar_add_child (GTK_INFO_BAR (bar), label);
+      gtk_container_add (GTK_CONTAINER (bar), label);
 
       button = gtk_toggle_button_new_with_label ("Warning");
       g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
-      gtk_box_append (GTK_BOX (actions), button);
+      gtk_container_add (GTK_CONTAINER (actions), button);
 
       bar = gtk_info_bar_new_with_buttons (_("_OK"), GTK_RESPONSE_OK, NULL);
       gtk_info_bar_set_show_close_button (GTK_INFO_BAR (bar), TRUE);
       g_signal_connect (bar, "response", G_CALLBACK (on_bar_response), window);
-      gtk_box_append (GTK_BOX (vbox), bar);
+      gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_QUESTION);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_QUESTION");
       gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
-      gtk_info_bar_add_child (GTK_INFO_BAR (bar), label);
+      gtk_container_add (GTK_CONTAINER (bar), label);
       gtk_info_bar_set_default_response (GTK_INFO_BAR (bar), GTK_RESPONSE_OK);
 
       button = gtk_toggle_button_new_with_label ("Question");
       g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
-      gtk_box_append (GTK_BOX (actions), button);
+      gtk_container_add (GTK_CONTAINER (actions), button);
 
       bar = gtk_info_bar_new ();
-      gtk_box_append (GTK_BOX (vbox), bar);
+      gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_ERROR);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_ERROR");
       gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
-      gtk_info_bar_add_child (GTK_INFO_BAR (bar), label);
+      gtk_container_add (GTK_CONTAINER (bar), label);
 
       button = gtk_toggle_button_new_with_label ("Error");
       g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
 
-      gtk_box_append (GTK_BOX (actions), button);
+      gtk_container_add (GTK_CONTAINER (actions), button);
 
       bar = gtk_info_bar_new ();
-      gtk_box_append (GTK_BOX (vbox), bar);
+      gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_OTHER);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_OTHER");
       gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
-      gtk_info_bar_add_child (GTK_INFO_BAR (bar), label);
+      gtk_container_add (GTK_CONTAINER (bar), label);
 
       button = gtk_toggle_button_new_with_label ("Other");
       g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
-      gtk_box_append (GTK_BOX (actions), button);
+      gtk_container_add (GTK_CONTAINER (actions), button);
 
-      frame = gtk_frame_new ("An example of different info bars");
+      frame = gtk_frame_new ("Info bars");
       gtk_widget_set_margin_top (frame, 8);
       gtk_widget_set_margin_bottom (frame, 8);
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
-      gtk_widget_set_halign (actions, GTK_ALIGN_CENTER);
+      vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
+      gtk_widget_set_margin_start (vbox2, 8);
+      gtk_widget_set_margin_end (vbox2, 8);
+      gtk_widget_set_margin_top (vbox2, 8);
+      gtk_widget_set_margin_bottom (vbox2, 8);
+      gtk_container_add (GTK_CONTAINER (frame), vbox2);
 
-      gtk_widget_set_margin_start (actions, 8);
-      gtk_widget_set_margin_end (actions, 8);
-      gtk_widget_set_margin_top (actions, 8);
-      gtk_widget_set_margin_bottom (actions, 8);
-      gtk_frame_set_child (GTK_FRAME (frame), actions);
+      /* Standard message dialog */
+      label = gtk_label_new ("An example of different info bars");
+      gtk_container_add (GTK_CONTAINER (vbox2), label);
+
+      gtk_container_add (GTK_CONTAINER (vbox2), actions);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/links.c

@@ -1,7 +1,7 @@
 /* Links
  *
  * GtkLabel can show hyperlinks. The default action is to call
- * gtk_show_uri() on their URI, but it is possible to override
+ * gtk_show_uri_on_window() on their URI, but it is possible to override
  * this with a custom handler.
  */
 
@@ -12,7 +12,7 @@ response_cb (GtkWidget *dialog,
              gint       response_id,
              gpointer   data)
 {
-  gtk_window_destroy (GTK_WINDOW (dialog));
+  gtk_widget_destroy (dialog);
 }
 
 static gboolean
@@ -30,8 +30,6 @@ activate_link (GtkWidget   *label,
                  GTK_DIALOG_DESTROY_WITH_PARENT,
                  GTK_MESSAGE_INFO,
                  GTK_BUTTONS_OK,
-                 "Keyboard navigation");
-      gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
                  "The term <i>keynav</i> is a shorthand for "
                  "keyboard navigation and refers to the process of using "
                  "a program (exclusively) via keyboard input.");
@@ -58,36 +56,29 @@ do_links (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Links");
-      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\""
-                             "title=\"plain text\">text</a> may be marked up "
-                             "as hyperlinks, which can be clicked "
-                             "or activated via <a href=\"keynav\">keynav</a> "
-                             "and they work fine with other markup, like when "
+                             "title=\"plain text\">text</a> may be marked up\n"
+                             "as hyperlinks, which can be clicked\n"
+                             "or activated via <a href=\"keynav\">keynav</a>\n"
+                             "and they work fine with other markup, like when\n"
                              "searching on <a href=\"http://www.google.com/\">"
                              "<span color=\"#0266C8\">G</span><span color=\"#F90101\">o</span>"
                              "<span color=\"#F2B50F\">o</span><span color=\"#0266C8\">g</span>"
                              "<span color=\"#00933B\">l</span><span color=\"#F90101\">e</span>"
                              "</a>.");
       gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
-      gtk_label_set_max_width_chars (GTK_LABEL (label), 40);
-      gtk_label_set_wrap (GTK_LABEL (label), TRUE);
-      gtk_label_set_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD);
       g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
-      gtk_widget_set_margin_start (label, 20);
-      gtk_widget_set_margin_end (label, 20);
-      gtk_widget_set_margin_top (label, 20);
-      gtk_widget_set_margin_bottom (label, 20);
-      gtk_window_set_child (GTK_WINDOW (window), label);
+      gtk_container_add (GTK_CONTAINER (window), label);
       gtk_widget_show (label);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/list_store.c

@@ -257,24 +257,26 @@ do_list_store (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "List Store");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
       gtk_widget_set_margin_start (vbox, 8);
       gtk_widget_set_margin_end (vbox, 8);
       gtk_widget_set_margin_top (vbox, 8);
       gtk_widget_set_margin_bottom (vbox, 8);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       label = gtk_label_new ("This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       sw = gtk_scrolled_window_new (NULL, NULL);
       gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                       GTK_POLICY_NEVER,
                                       GTK_POLICY_AUTOMATIC);
-      gtk_box_append (GTK_BOX (vbox), sw);
+      gtk_container_add (GTK_CONTAINER (vbox), sw);
 
       /* create tree model */
       model = create_model ();
@@ -287,7 +289,7 @@ do_list_store (GtkWidget *do_widget)
 
       g_object_unref (model);
 
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), treeview);
+      gtk_container_add (GTK_CONTAINER (sw), treeview);
 
       /* add columns to the tree view */
       add_columns (GTK_TREE_VIEW (treeview));
@@ -307,7 +309,7 @@ do_list_store (GtkWidget *do_widget)
     }
   else
     {
-      gtk_window_destroy (GTK_WINDOW (window));
+      gtk_widget_destroy (window);
       window = NULL;
       if (timeout != 0)
         {

demos/gtk-demo/listbox.c

@@ -351,19 +351,24 @@ do_listbox (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "List Box");
-      gtk_window_set_default_size (GTK_WINDOW (window), 400, 600);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      gtk_window_set_default_size (GTK_WINDOW (window),
+                                   400, 600);
+
+      /* NULL window variable when window is closed */
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed),
+                        &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
       label = gtk_label_new ("Messages from GTK and friends");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
       scrolled = gtk_scrolled_window_new (NULL, NULL);
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
       gtk_widget_set_vexpand (scrolled, TRUE);
-      gtk_box_append (GTK_BOX (vbox), scrolled);
+      gtk_container_add (GTK_CONTAINER (vbox), scrolled);
       listbox = gtk_list_box_new ();
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled), listbox);
+      gtk_container_add (GTK_CONTAINER (scrolled), listbox);
 
       gtk_list_box_set_sort_func (GTK_LIST_BOX (listbox), (GtkListBoxSortFunc)gtk_message_row_sort, listbox, NULL);
       gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (listbox), FALSE);
@@ -377,7 +382,7 @@ do_listbox (GtkWidget *do_widget)
           message = gtk_message_new (lines[i]);
           row = gtk_message_row_new (message);
           gtk_widget_show (GTK_WIDGET (row));
-          gtk_list_box_insert (GTK_LIST_BOX (listbox), GTK_WIDGET (row), -1);
+          gtk_container_add (GTK_CONTAINER (listbox), GTK_WIDGET (row));
         }
 
       g_strfreev (lines);
@@ -387,7 +392,7 @@ do_listbox (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/main.c

@@ -17,7 +17,7 @@ static gchar *current_file = NULL;
 
 static GtkWidget *notebook;
 static GtkWidget *treeview;
-static GtkWidget *toplevel;
+static GtkWidget *headerbar;
 
 enum {
   NAME_COLUMN,
@@ -55,8 +55,6 @@ activate_about (GSimpleAction *action,
                           glib_major_version,
                           glib_minor_version,
                           glib_micro_version);
-  g_string_append_printf (s, "\tPango\t%s\n",
-                          pango_version_string ());
   g_string_append_printf (s, "\tGTK\t%d.%d.%d\n",
                           gtk_get_major_version (),
                           gtk_get_minor_version (),
@@ -72,7 +70,7 @@ activate_about (GSimpleAction *action,
   gtk_show_about_dialog (GTK_WINDOW (gtk_application_get_active_window (app)),
                          "program-name", "GTK Demo",
                          "version", version,
-                         "copyright", "© 1997—2020 The GTK Team",
+                         "copyright", "© 1997—2019 The GTK Team",
                          "license-type", GTK_LICENSE_LGPL_2_1,
                          "website", "http://www.gtk.org",
                          "comments", "Program to demonstrate GTK widgets",
@@ -101,7 +99,7 @@ activate_quit (GSimpleAction *action,
       win = list->data;
       next = list->next;
 
-      gtk_window_destroy (GTK_WINDOW (win));
+      gtk_widget_destroy (GTK_WIDGET (win));
 
       list = next;
     }
@@ -571,7 +569,7 @@ display_image (const char *resource)
   gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
   gtk_widget_set_valign (image, GTK_ALIGN_CENTER);
   sw = gtk_scrolled_window_new (NULL, NULL);
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), image);
+  gtk_container_add (GTK_CONTAINER (sw), image);
 
   return sw;
 }
@@ -614,7 +612,7 @@ display_text (const char *resource)
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                   GTK_POLICY_AUTOMATIC,
                                   GTK_POLICY_AUTOMATIC);
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), textview);
+  gtk_container_add (GTK_CONTAINER (sw), textview);
 
   return sw;
 }
@@ -915,7 +913,7 @@ selection_cb (GtkTreeSelection *selection,
   if (filename)
     load_file (name, filename);
 
-  gtk_window_set_title (GTK_WINDOW (toplevel), title);
+  gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), title);
 
   g_free (name);
   g_free (title);
@@ -1030,9 +1028,9 @@ activate (GApplication *app)
 
   info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview");
   source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview");
+  headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar");
   treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview");
   model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
-  toplevel = GTK_WIDGET (window);
 
   load_file (gtk_demos[0].name, gtk_demos[0].filename);
 
@@ -1186,14 +1184,6 @@ main (int argc, char **argv)
     { "quit", activate_quit, NULL, NULL, NULL },
     { "inspector", activate_inspector, NULL, NULL, NULL },
   };
-  struct {
-    const gchar *action_and_target;
-    const gchar *accelerators[2];
-  } accels[] = {
-    { "app.about", { "F1", NULL } },
-    { "app.quit", { "<Control>q", NULL } },
-  };
-  int i;
 
   /* Most code in gtk-demo is intended to be exemplary, but not
    * these few lines, which are just a hack so gtk-demo will work
@@ -1211,9 +1201,6 @@ main (int argc, char **argv)
                                    app_entries, G_N_ELEMENTS (app_entries),
                                    app);
 
-  for (i = 0; i < G_N_ELEMENTS (accels); i++)
-    gtk_application_set_accels_for_action (app, accels[i].action_and_target, accels[i].accelerators);
-
   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), "run", 0, 0, G_OPTION_ARG_STRING, "Run an example", "EXAMPLE");
   g_application_add_main_option (G_APPLICATION (app), "list", 0, 0, G_OPTION_ARG_NONE, "List examples", NULL);

demos/gtk-demo/main.ui

@@ -6,10 +6,6 @@
         <attribute name="label" translatable="yes">_Inspector</attribute>
         <attribute name="action">app.inspector</attribute>
       </item>
-      <item>
-        <attribute name="label" translatable="yes">_Keyboard Shortcuts</attribute>
-        <attribute name="action">win.show-help-overlay</attribute>
-      </item>
       <item>
         <attribute name="label" translatable="yes">_About GTK Demo</attribute>
         <attribute name="action">app.about</attribute>
@@ -31,6 +27,7 @@
     </style>
     <property name="default-width">800</property>
     <property name="default-height">600</property>
+    <property name="title">GTK Demo</property>
     <child type="titlebar">
       <object class="GtkHeaderBar" id="headerbar">
         <property name="show-title-buttons">1</property>
@@ -60,31 +57,35 @@
     <child>
       <object class="GtkBox">
         <child>
-          <object class="GtkScrolledWindow">
-            <property name="width-request">120</property>
-            <property name="hscrollbar-policy">never</property>
-            <property name="min-content-width">150</property>
+          <object class="GtkFrame">
             <child>
-              <object class="GtkTreeView" id="treeview">
-                <property name="model">treestore</property>
-                <property name="headers-visible">0</property>
-                <child internal-child="selection">
-                  <object class="GtkTreeSelection" id="treeview-selection">
-                    <property name="mode">browse</property>
-                  </object>
-                </child>
+              <object class="GtkScrolledWindow">
+                <property name="width-request">120</property>
+                <property name="hscrollbar-policy">never</property>
+                <property name="min-content-width">150</property>
                 <child>
-                  <object class="GtkTreeViewColumn">
-                    <child>
-                      <object class="GtkCellRendererText"/>
-                      <attributes>
-                        <attribute name="style">4</attribute>
-                        <attribute name="text">1</attribute>
-                      </attributes>
+                  <object class="GtkTreeView" id="treeview">
+                    <property name="model">treestore</property>
+                    <property name="headers-visible">0</property>
+                    <child internal-child="selection">
+                      <object class="GtkTreeSelection" id="treeview-selection">
+                        <property name="mode">browse</property>
+                      </object>
                     </child>
                     <child>
-                      <object class="GtkCellRendererText">
-                        <property name="text">  </property>
+                      <object class="GtkTreeViewColumn">
+                        <child>
+                          <object class="GtkCellRendererText"/>
+                          <attributes>
+                            <attribute name="style">4</attribute>
+                            <attribute name="text">1</attribute>
+                          </attributes>
+                        </child>
+                        <child>
+                          <object class="GtkCellRendererText">
+                            <property name="text">  </property>
+                          </object>
+                        </child>
                       </object>
                     </child>
                   </object>
@@ -93,9 +94,6 @@
             </child>
           </object>
         </child>
-        <child>
-          <object class="GtkSeparator"/>
-        </child>
         <child>
           <object class="GtkNotebook" id="notebook">
             <property name="scrollable">1</property>

demos/gtk-demo/markup.c

@@ -58,11 +58,12 @@ do_markup (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_default_size (GTK_WINDOW (window), 450, 450);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       stack = gtk_stack_new ();
       gtk_widget_show (stack);
-      gtk_window_set_child (GTK_WINDOW (window), stack);
+      gtk_container_add (GTK_CONTAINER (window), stack);
 
       show_source = gtk_check_button_new_with_label ("Source");
       gtk_widget_set_valign (show_source, GTK_ALIGN_CENTER);
@@ -85,7 +86,7 @@ do_markup (GtkWidget *do_widget)
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                       GTK_POLICY_AUTOMATIC,
                                       GTK_POLICY_AUTOMATIC);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), view);
+      gtk_container_add (GTK_CONTAINER (sw), view);
 
       gtk_stack_add_named (GTK_STACK (stack), sw, "formatted");
 
@@ -98,7 +99,7 @@ do_markup (GtkWidget *do_widget)
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                       GTK_POLICY_AUTOMATIC,
                                       GTK_POLICY_AUTOMATIC);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), view2);
+      gtk_container_add (GTK_CONTAINER (sw), view2);
 
       gtk_stack_add_named (GTK_STACK (stack), sw, "source");
 
@@ -125,7 +126,7 @@ do_markup (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/meson.build

@@ -5,6 +5,7 @@ demos = files([
   'assistant.c',
   'builder.c',
   'clipboard.c',
+  'colorsel.c',
   'combobox.c',
   'constraints.c',
   'constraints2.c',
@@ -89,7 +90,6 @@ extra_demo_sources = files(['main.c',
                             'gtkgears.c',
                             'puzzlepiece.c',
                             'bluroverlay.c',
-                            'demoimage.c',
                             'demotaggedentry.c'])
 
 if harfbuzz_dep.found() and pangoft_dep.found()

demos/gtk-demo/modelbutton.c

@@ -43,7 +43,8 @@ do_modelbutton (GtkWidget *do_widget)
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       actions = (GActionGroup*)g_simple_action_group_new ();
       g_action_map_add_action_entries (G_ACTION_MAP (actions),
@@ -58,7 +59,7 @@ do_modelbutton (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
 
   return window;

demos/gtk-demo/modelbutton.ui

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
   <object class="GtkWindow" id="window1">
-    <property name="title" translatable="yes">Model Button</property>
     <property name="resizable">0</property>
     <child type="titlebar">
       <object class="GtkHeaderBar">
         <property name="show-title-buttons">1</property>
+        <property name="title" translatable="yes">Model Button</property>
       </object>
     </child>
     <child>

demos/gtk-demo/overlay.c

@@ -37,7 +37,7 @@ do_overlay (GtkWidget *do_widget)
 
       overlay = gtk_overlay_new ();
       grid = gtk_grid_new ();
-      gtk_overlay_set_child (GTK_OVERLAY (overlay), grid);
+      gtk_container_add (GTK_CONTAINER (overlay), grid);
 
       entry = gtk_entry_new ();
 
@@ -66,7 +66,7 @@ do_overlay (GtkWidget *do_widget)
       gtk_widget_set_can_target (label, FALSE);
       gtk_widget_set_margin_top (label, 8);
       gtk_widget_set_margin_bottom (label, 8);
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
       gtk_overlay_add_overlay (GTK_OVERLAY (overlay), vbox);
@@ -76,16 +76,18 @@ do_overlay (GtkWidget *do_widget)
       gtk_entry_set_placeholder_text (GTK_ENTRY (entry), "Your Lucky Number");
       gtk_widget_set_margin_top (entry, 8);
       gtk_widget_set_margin_bottom (entry, 8);
-      gtk_box_append (GTK_BOX (vbox), entry);
+      gtk_container_add (GTK_CONTAINER (vbox), entry);
 
-      gtk_window_set_child (GTK_WINDOW (window), overlay);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      gtk_container_add (GTK_CONTAINER (window), overlay);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/overlay2.c

@@ -57,10 +57,12 @@ do_overlay2 (GtkWidget *do_widget)
       gtk_text_iter_forward_word_end (&end);
       gtk_text_buffer_apply_tag (buffer, tag, &start, &end);
 
-      gtk_window_set_child (GTK_WINDOW (window), overlay);
-      gtk_overlay_set_child (GTK_OVERLAY (overlay), sw);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), text);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      gtk_container_add (GTK_CONTAINER (window), overlay);
+      gtk_container_add (GTK_CONTAINER (overlay), sw);
+      gtk_container_add (GTK_CONTAINER (sw), text);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       image = gtk_picture_new_for_resource ("/overlay2/decor1.png");
       gtk_overlay_add_overlay (GTK_OVERLAY (overlay), image);
@@ -95,7 +97,7 @@ do_overlay2 (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/pagesetup.c

@@ -11,7 +11,7 @@
 static void
 done_cb (GtkDialog *dialog, gint response, gpointer data)
 {
-  gtk_window_destroy (GTK_WINDOW (dialog));
+  gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 GtkWidget *
@@ -22,14 +22,14 @@ do_pagesetup (GtkWidget *do_widget)
   if (!window)
     {
       window = gtk_page_setup_unix_dialog_new ("Page Setup", GTK_WINDOW (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
       g_signal_connect (window, "response", G_CALLBACK (done_cb), NULL);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/paint.c

@@ -339,7 +339,6 @@ drawing_area_init (DrawingArea *area)
   gtk_widget_add_controller (GTK_WIDGET (area), GTK_EVENT_CONTROLLER (gesture));
 
   area->draw_color = (GdkRGBA) { 0, 0, 0, 1 };
-  area->brush_size = 1;
 }
 
 static GtkWidget *
@@ -389,9 +388,10 @@ do_paint (GtkWidget *toplevel)
       window = gtk_window_new ();
 
       draw_area = drawing_area_new ();
-      gtk_window_set_child (GTK_WINDOW (window), draw_area);
+      gtk_container_add (GTK_CONTAINER (window), draw_area);
 
       headerbar = gtk_header_bar_new ();
+      gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Paint");
       gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (headerbar), TRUE);
 
       colorbutton = gtk_color_button_new ();
@@ -404,14 +404,16 @@ do_paint (GtkWidget *toplevel)
 
       gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), colorbutton);
       gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
-      gtk_window_set_title (GTK_WINDOW (window), "Paint");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/paintable.c

@@ -164,14 +164,14 @@ do_paintable (GtkWidget *do_widget)
 
       nuclear = gtk_nuclear_icon_new (0.0);
       image = gtk_image_new_from_paintable (nuclear);
-      gtk_window_set_child (GTK_WINDOW (window), image);
+      gtk_container_add (GTK_CONTAINER (window), image);
       g_object_unref (nuclear);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/paintable_animated.c

@@ -196,14 +196,14 @@ do_paintable_animated (GtkWidget *do_widget)
 
       nuclear = gtk_nuclear_animation_new ();
       image = gtk_image_new_from_paintable (nuclear);
-      gtk_window_set_child (GTK_WINDOW (window), image);
+      gtk_container_add (GTK_CONTAINER (window), image);
       g_object_unref (nuclear);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/paintable_mediastream.c

@@ -298,7 +298,7 @@ do_paintable_mediastream (GtkWidget *do_widget)
       gtk_media_stream_set_loop (GTK_MEDIA_STREAM (nuclear), TRUE);
 
       video = gtk_video_new_for_media_stream (nuclear);
-      gtk_window_set_child (GTK_WINDOW (window), video);
+      gtk_container_add (GTK_CONTAINER (window), video);
 
       g_object_unref (nuclear);
     }
@@ -306,7 +306,7 @@ do_paintable_mediastream (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/panes.c

@@ -19,14 +19,32 @@ toggle_resize (GtkWidget *widget,
 {
   GtkWidget *parent;
   GtkPaned *paned;
+  gboolean is_child1;
+  gboolean resize, shrink;
 
   parent = gtk_widget_get_parent (child);
   paned = GTK_PANED (parent);
 
-  if (child == gtk_paned_get_start_child (paned))
-    gtk_paned_set_resize_start_child (paned, !gtk_paned_get_resize_start_child (paned));
+  is_child1 = (child == gtk_paned_get_child1 (paned));
+
+  if (is_child1)
+    g_object_get (paned,
+                  "resize-child1", &resize,
+                  "shrink-child1", &shrink,
+                  NULL);
   else
-    gtk_paned_set_resize_end_child (paned, !gtk_paned_get_resize_end_child (paned));
+    g_object_get (paned,
+                  "resize-child2", &resize,
+                  "shrink-child2", &shrink,
+                  NULL);
+
+  g_object_ref (child);
+  gtk_container_remove (GTK_CONTAINER (parent), child);
+  if (is_child1)
+    gtk_paned_pack1 (paned, child, !resize, shrink);
+  else
+    gtk_paned_pack2 (paned, child, !resize, shrink);
+  g_object_unref (child);
 }
 
 static void
@@ -35,14 +53,32 @@ toggle_shrink (GtkWidget *widget,
 {
   GtkWidget *parent;
   GtkPaned *paned;
+  gboolean is_child1;
+  gboolean resize, shrink;
 
   parent = gtk_widget_get_parent (child);
   paned = GTK_PANED (parent);
 
-  if (child == gtk_paned_get_start_child (paned))
-    gtk_paned_set_shrink_start_child (paned, !gtk_paned_get_shrink_start_child (paned));
+  is_child1 = (child == gtk_paned_get_child1 (paned));
+
+  if (is_child1)
+    g_object_get (paned,
+                  "resize-child1", &resize,
+                  "shrink-child1", &shrink,
+                  NULL);
   else
-    gtk_paned_set_shrink_end_child (paned, !gtk_paned_get_shrink_end_child (paned));
+    g_object_get (paned,
+                  "resize-child2", &resize,
+                  "shrink-child2", &shrink,
+                  NULL);
+
+  g_object_ref (child);
+  gtk_container_remove (GTK_CONTAINER (parent), child);
+  if (is_child1)
+    gtk_paned_pack1 (paned, child, resize, !shrink);
+  else
+    gtk_paned_pack2 (paned, child, resize, !shrink);
+  g_object_unref (child);
 }
 
 static GtkWidget *
@@ -57,8 +93,8 @@ create_pane_options (GtkPaned    *paned,
   GtkWidget *label;
   GtkWidget *check_button;
 
-  child1 = gtk_paned_get_start_child (paned);
-  child2 = gtk_paned_get_end_child (paned);
+  child1 = gtk_paned_get_child1 (paned);
+  child2 = gtk_paned_get_child2 (paned);
 
   frame = gtk_frame_new (frame_label);
   gtk_widget_set_margin_start (frame, 4);
@@ -67,7 +103,7 @@ create_pane_options (GtkPaned    *paned,
   gtk_widget_set_margin_bottom (frame, 4);
 
   table = gtk_grid_new ();
-  gtk_frame_set_child (GTK_FRAME (frame), table);
+  gtk_container_add (GTK_CONTAINER (frame), table);
 
   label = gtk_label_new (label1);
   gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
@@ -116,47 +152,49 @@ do_panes (GtkWidget *do_widget)
       window = gtk_window_new ();
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       gtk_window_set_title (GTK_WINDOW (window), "Paned Widgets");
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
       gtk_widget_set_margin_start (vpaned, 5);
       gtk_widget_set_margin_end (vpaned, 5);
       gtk_widget_set_margin_top (vpaned, 5);
       gtk_widget_set_margin_bottom (vpaned, 5);
-      gtk_box_append (GTK_BOX (vbox), vpaned);
+      gtk_container_add (GTK_CONTAINER (vbox), vpaned);
 
       hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
-      gtk_paned_set_start_child (GTK_PANED (vpaned), hpaned);
+      gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_size_request (frame, 60, 60);
-      gtk_paned_set_start_child (GTK_PANED (hpaned), frame);
+      gtk_paned_add1 (GTK_PANED (hpaned), frame);
 
       button = gtk_button_new_with_mnemonic ("_Hi there");
-      gtk_frame_set_child (GTK_FRAME (frame), button);
+      gtk_container_add (GTK_CONTAINER(frame), button);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_size_request (frame, 80, 60);
-      gtk_paned_set_end_child (GTK_PANED (hpaned), frame);
+      gtk_paned_add2 (GTK_PANED (hpaned), frame);
 
       frame = gtk_frame_new (NULL);
       gtk_widget_set_size_request (frame, 60, 80);
-      gtk_paned_set_end_child (GTK_PANED (vpaned), frame);
+      gtk_paned_add2 (GTK_PANED (vpaned), frame);
 
       /* Now create toggle buttons to control sizing */
 
-      gtk_box_append (GTK_BOX (vbox),
+      gtk_container_add (GTK_CONTAINER (vbox),
                           create_pane_options (GTK_PANED (hpaned),
                                                "Horizontal",
                                                "Left",
                                                "Right"));
 
-      gtk_box_append (GTK_BOX (vbox),
+      gtk_container_add (GTK_CONTAINER (vbox),
                           create_pane_options (GTK_PANED (vpaned),
                                                "Vertical",
                                                "Top",
@@ -166,7 +204,7 @@ do_panes (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/password_entry.c

@@ -40,19 +40,20 @@ do_password_entry (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       header = gtk_header_bar_new ();
+      gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Choose a Password");
       gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), FALSE);
       gtk_window_set_titlebar (GTK_WINDOW (window), header);
-      gtk_window_set_title (GTK_WINDOW (window), "Choose a Password");
       gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
       gtk_window_set_deletable (GTK_WINDOW (window), FALSE);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
       gtk_widget_set_margin_start (box, 18);
       gtk_widget_set_margin_end (box, 18);
       gtk_widget_set_margin_top (box, 18);
       gtk_widget_set_margin_bottom (box, 18);
-      gtk_window_set_child (GTK_WINDOW (window), box);
+      gtk_container_add (GTK_CONTAINER (window), box);
 
       entry = gtk_password_entry_new ();
       gtk_password_entry_set_show_peek_icon (GTK_PASSWORD_ENTRY (entry), TRUE);
@@ -61,7 +62,7 @@ do_password_entry (GtkWidget *do_widget)
                     "activates-default", TRUE,
                     NULL);
       g_signal_connect (entry, "notify::text", G_CALLBACK (update_button), NULL);
-      gtk_box_append (GTK_BOX (box), entry);
+      gtk_container_add (GTK_CONTAINER (box), entry);
 
       entry2 = gtk_password_entry_new ();
       gtk_password_entry_set_show_peek_icon (GTK_PASSWORD_ENTRY (entry2), TRUE);
@@ -70,11 +71,11 @@ do_password_entry (GtkWidget *do_widget)
                     "activates-default", TRUE,
                     NULL);
       g_signal_connect (entry2, "notify::text", G_CALLBACK (update_button), NULL);
-      gtk_box_append (GTK_BOX (box), entry2);
+      gtk_container_add (GTK_CONTAINER (box), entry2);
 
       button = gtk_button_new_with_mnemonic ("_Done");
       gtk_widget_add_css_class (button, "suggested-action");
-      g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
+      g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
       gtk_widget_set_sensitive (button, FALSE);
       gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);
 
@@ -84,7 +85,7 @@ do_password_entry (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/peg_solitaire.c

@@ -276,15 +276,17 @@ do_peg_solitaire (GtkWidget *do_widget)
       g_signal_connect (restart, "clicked", G_CALLBACK (restart), NULL);
 
       header = gtk_header_bar_new ();
+      gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Peg Solitaire");
       gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE);
       gtk_header_bar_pack_start (GTK_HEADER_BAR (header), restart);
       window = gtk_window_new ();
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      gtk_window_set_title (GTK_WINDOW (window), "Peg Solitaire");
+      gtk_window_set_title (GTK_WINDOW (window), "Sliding Puzzle");
       gtk_window_set_titlebar (GTK_WINDOW (window), header);
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       grid = gtk_grid_new ();
       gtk_widget_set_halign (grid, GTK_ALIGN_CENTER);
@@ -293,7 +295,7 @@ do_peg_solitaire (GtkWidget *do_widget)
       gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
       gtk_grid_set_row_homogeneous (GTK_GRID (grid), TRUE);
       gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
-      gtk_window_set_child (GTK_WINDOW (window), grid);
+      gtk_container_add (GTK_CONTAINER (window), grid);
 
       for (x = 0; x < 7; x++)
         {
@@ -348,7 +350,7 @@ do_peg_solitaire (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/pickers.c

@@ -18,7 +18,9 @@ do_pickers (GtkWidget *do_widget)
     gtk_window_set_display (GTK_WINDOW (window),
                             gtk_widget_get_display (do_widget));
     gtk_window_set_title (GTK_WINDOW (window), "Pickers");
-    g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed), &window);
 
     table = gtk_grid_new ();
     gtk_widget_set_margin_start (table, 20);
@@ -27,7 +29,7 @@ do_pickers (GtkWidget *do_widget)
     gtk_widget_set_margin_bottom (table, 20);
     gtk_grid_set_row_spacing (GTK_GRID (table), 3);
     gtk_grid_set_column_spacing (GTK_GRID (table), 10);
-    gtk_window_set_child (GTK_WINDOW (window), table);
+    gtk_container_add (GTK_CONTAINER (window), table);
 
     label = gtk_label_new ("Color:");
     gtk_widget_set_halign (label, GTK_ALIGN_START);
@@ -75,7 +77,7 @@ do_pickers (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/pixbufs.c

@@ -179,7 +179,9 @@ do_pixbufs (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Pixbufs");
       gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       error = NULL;
       if (!load_pixbufs (&error))
@@ -196,7 +198,7 @@ do_pixbufs (GtkWidget *do_widget)
           g_error_free (error);
 
           g_signal_connect (dialog, "response",
-                            G_CALLBACK (gtk_window_destroy), NULL);
+                            G_CALLBACK (gtk_widget_destroy), NULL);
 
           gtk_widget_show (dialog);
         }
@@ -210,7 +212,7 @@ do_pixbufs (GtkWidget *do_widget)
           gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (da), back_height);
           gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), draw_func, NULL, NULL);
 
-          gtk_window_set_child (GTK_WINDOW (window), da);
+          gtk_container_add (GTK_CONTAINER (window), da);
 
           gtk_widget_add_tick_callback (da, on_tick, NULL, NULL);
         }
@@ -220,7 +222,7 @@ do_pixbufs (GtkWidget *do_widget)
     gtk_widget_show (window);
   else
     {
-      gtk_window_destroy (GTK_WINDOW (window));
+      gtk_widget_destroy (window);
       g_object_unref (frame);
     }
 

demos/gtk-demo/printing.c

@@ -188,7 +188,7 @@ do_printing (GtkWidget *do_widget)
       g_error_free (error);
 
       g_signal_connect (dialog, "response",
-                        G_CALLBACK (gtk_window_destroy), NULL);
+                        G_CALLBACK (gtk_widget_destroy), NULL);
 
       gtk_widget_show (dialog);
     }

demos/gtk-demo/revealer.c

@@ -85,7 +85,7 @@ do_revealer (GtkWidget *do_widget)
     }
   else
     {
-      gtk_window_destroy (GTK_WINDOW (window));
+      gtk_widget_destroy (window);
     }
 
 

demos/gtk-demo/rotated_text.c

@@ -180,15 +180,16 @@ do_rotated_text (GtkWidget *do_widget)
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Rotated Text");
       gtk_window_set_default_size (GTK_WINDOW (window), 4 * RADIUS, 2 * RADIUS);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
       gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
-      gtk_window_set_child (GTK_WINDOW (window), box);
+      gtk_container_add (GTK_CONTAINER (window), box);
 
       /* Add a drawing area */
       drawing_area = gtk_drawing_area_new ();
-      gtk_box_append (GTK_BOX (box), drawing_area);
+      gtk_container_add (GTK_CONTAINER (box), drawing_area);
       gtk_widget_add_css_class (drawing_area, GTK_STYLE_CLASS_VIEW);
 
       gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area),
@@ -197,7 +198,7 @@ do_rotated_text (GtkWidget *do_widget)
 
       /* And a label */
       label = gtk_label_new (text);
-      gtk_box_append (GTK_BOX (box), label);
+      gtk_container_add (GTK_CONTAINER (box), label);
 
       /* Set up fancy stuff on the label */
       layout = gtk_label_get_layout (GTK_LABEL (label));
@@ -212,7 +213,7 @@ do_rotated_text (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/scale.c

@@ -1,4 +1,4 @@
-/* Scales
+/* Scale
  *
  * GtkScale is a way to select a value from a range.
  * Scales can have marks to help pick special values,
@@ -21,7 +21,8 @@ do_scale (GtkWidget *do_widget)
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       g_object_unref (builder);
     }
@@ -29,7 +30,7 @@ do_scale (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
 
   return window;

demos/gtk-demo/scale.ui

@@ -20,7 +20,6 @@
   </object>
   <object class="GtkWindow" id="window1">
     <property name="title" translatable="yes">Scales</property>
-    <property name="resizable">0</property>
     <child>
       <object class="GtkGrid" id="grid1">
         <property name="row-spacing">10</property>

demos/gtk-demo/search_entry.c

@@ -269,27 +269,27 @@ do_search_entry (GtkWidget *do_widget)
       gtk_widget_set_margin_end (vbox, 5);
       gtk_widget_set_margin_top (vbox, 5);
       gtk_widget_set_margin_bottom (vbox, 5);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label), "Search entry demo");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
       /* Create our entry */
       entry = gtk_entry_new ();
       gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
                                          GTK_ENTRY_ICON_PRIMARY,
                                          "edit-find-symbolic");
-      gtk_box_append (GTK_BOX (hbox), entry);
+      gtk_container_add (GTK_CONTAINER (hbox), entry);
 
       /* Create the find and cancel buttons */
       notebook = gtk_notebook_new ();
       gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
       gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
-      gtk_box_append (GTK_BOX (hbox), notebook);
+      gtk_container_add (GTK_CONTAINER (hbox), notebook);
 
       find_button = gtk_button_new_with_label ("Find");
       g_signal_connect (find_button, "clicked",
@@ -319,7 +319,7 @@ do_search_entry (GtkWidget *do_widget)
   else
     {
       g_clear_object (&actions);
-      gtk_window_destroy (GTK_WINDOW (window));
+      gtk_widget_destroy (window);
     }
 
   return window;

demos/gtk-demo/search_entry2.c

@@ -73,46 +73,48 @@ do_search_entry2 (GtkWidget *do_widget)
       gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
       gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
       gtk_widget_set_size_request (window, 200, -1);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       entry = gtk_search_entry_new ();
       container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
       gtk_widget_set_halign (container, GTK_ALIGN_CENTER);
-      gtk_box_append (GTK_BOX (container), entry);
+      gtk_container_add (GTK_CONTAINER (container), entry);
       searchbar = gtk_search_bar_new ();
       gtk_search_bar_connect_entry (GTK_SEARCH_BAR (searchbar), GTK_EDITABLE (entry));
       gtk_search_bar_set_show_close_button (GTK_SEARCH_BAR (searchbar), FALSE);
-      gtk_search_bar_set_child (GTK_SEARCH_BAR (searchbar), container);
-      gtk_box_append (GTK_BOX (vbox), searchbar);
+      gtk_container_add (GTK_CONTAINER (searchbar), container);
+      gtk_container_add (GTK_CONTAINER (vbox), searchbar);
 
       /* Hook the search bar to key presses */
       gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (searchbar), window);
 
       /* Help */
       label = gtk_label_new ("Start Typing to search");
-      gtk_box_append (GTK_BOX (vbox), label);
+      gtk_container_add (GTK_CONTAINER (vbox), label);
 
       /* Toggle button */
       button = gtk_toggle_button_new_with_label ("Search");
       g_object_bind_property (button, "active",
                               searchbar, "search-mode-enabled",
                               G_BINDING_BIDIRECTIONAL);
-      gtk_box_append (GTK_BOX (vbox), button);
+      gtk_container_add (GTK_CONTAINER (vbox), button);
 
       /* Result */
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
       label = gtk_label_new ("Result:");
       gtk_label_set_xalign (GTK_LABEL (label), 0.0);
       gtk_widget_set_margin_start (label, 6);
-      gtk_box_append (GTK_BOX (hbox), label);
+      gtk_container_add (GTK_CONTAINER (hbox), label);
 
       label = gtk_label_new ("");
-      gtk_box_append (GTK_BOX (hbox), label);
+      gtk_container_add (GTK_CONTAINER (hbox), label);
 
       g_signal_connect (entry, "search-changed",
                         G_CALLBACK (search_changed_cb), label);
@@ -120,15 +122,15 @@ do_search_entry2 (GtkWidget *do_widget)
                         G_CALLBACK (changed_cb), label);
 
       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
-      gtk_box_append (GTK_BOX (vbox), hbox);
+      gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
       label = gtk_label_new ("Signal:");
       gtk_label_set_xalign (GTK_LABEL (label), 0.0);
       gtk_widget_set_margin_start (label, 6);
-      gtk_box_append (GTK_BOX (hbox), label);
+      gtk_container_add (GTK_CONTAINER (hbox), label);
 
       label = gtk_label_new ("");
-      gtk_box_append (GTK_BOX (hbox), label);
+      gtk_container_add (GTK_CONTAINER (hbox), label);
 
       g_signal_connect (entry, "search-changed",
                         G_CALLBACK (search_changed), label);
@@ -143,7 +145,7 @@ do_search_entry2 (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/shortcut_triggers.c

@@ -56,14 +56,16 @@ do_shortcut_triggers (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Shortcuts");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       list = gtk_list_box_new ();
       gtk_widget_set_margin_top (list, 6);
       gtk_widget_set_margin_bottom (list, 6);
       gtk_widget_set_margin_start (list, 6);
       gtk_widget_set_margin_end (list, 6);
-      gtk_window_set_child (GTK_WINDOW (window), list);
+      gtk_container_add (GTK_CONTAINER (window), list);
 
       for (i = 0; i < G_N_ELEMENTS (shortcuts); i++)
         {
@@ -71,7 +73,7 @@ do_shortcut_triggers (GtkWidget *do_widget)
           GtkWidget *row;
 
           row = gtk_label_new (shortcuts[i].description);
-          gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
+          gtk_container_add (GTK_CONTAINER (list), row);
 
           controller = gtk_shortcut_controller_new ();
           gtk_shortcut_controller_set_scope (GTK_SHORTCUT_CONTROLLER (controller), GTK_SHORTCUT_SCOPE_GLOBAL);
@@ -86,7 +88,7 @@ do_shortcut_triggers (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/shortcuts.c

@@ -89,7 +89,8 @@ do_shortcuts (GtkWidget *do_widget)
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
       gtk_window_set_display (GTK_WINDOW (window),
                               gtk_widget_get_display (do_widget));
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       g_object_unref (builder);
     }
@@ -97,7 +98,7 @@ do_shortcuts (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/sidebar.c

@@ -43,18 +43,20 @@ do_sidebar (GtkWidget *do_widget)
       gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR(header), TRUE);
       gtk_window_set_titlebar (GTK_WINDOW(window), header);
       gtk_window_set_title (GTK_WINDOW(window), "Stack Sidebar");
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
       sidebar = gtk_stack_sidebar_new ();
-      gtk_box_append (GTK_BOX (box), sidebar);
+      gtk_container_add (GTK_CONTAINER (box), sidebar);
 
       stack = gtk_stack_new ();
       gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
       gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
       gtk_widget_set_hexpand (stack, TRUE);
 
-      gtk_box_append (GTK_BOX (box), stack);
+      gtk_container_add (GTK_CONTAINER (box), stack);
 
       for (i=0; (c = *(pages+i)) != NULL; i++ )
         {
@@ -72,13 +74,13 @@ do_sidebar (GtkWidget *do_widget)
           g_object_set (gtk_stack_get_page (GTK_STACK (stack), widget), "title", c, NULL);
         }
 
-      gtk_window_set_child (GTK_WINDOW (window), box);
+       gtk_container_add (GTK_CONTAINER (window), box);
     }
 
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/sizegroup.c

@@ -104,21 +104,22 @@ do_sizegroup (GtkWidget *do_widget)
       gtk_window_set_display (GTK_WINDOW (window),  gtk_widget_get_display (do_widget));
       gtk_window_set_title (GTK_WINDOW (window), "Size Groups");
       gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
       gtk_widget_set_margin_start (vbox, 5);
       gtk_widget_set_margin_end (vbox, 5);
       gtk_widget_set_margin_top (vbox, 5);
       gtk_widget_set_margin_bottom (vbox, 5);
-      gtk_window_set_child (GTK_WINDOW (window), vbox);
+      gtk_container_add (GTK_CONTAINER (window), vbox);
 
       size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
       g_object_set_data_full (G_OBJECT (window), "size-group", size_group, g_object_unref);
 
       /* Create one frame holding color options */
       frame = gtk_frame_new ("Color Options");
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       table = gtk_grid_new ();
       gtk_widget_set_margin_start (table, 5);
@@ -127,14 +128,14 @@ do_sizegroup (GtkWidget *do_widget)
       gtk_widget_set_margin_bottom (table, 5);
       gtk_grid_set_row_spacing (GTK_GRID (table), 5);
       gtk_grid_set_column_spacing (GTK_GRID (table), 10);
-      gtk_frame_set_child (GTK_FRAME (frame), table);
+      gtk_container_add (GTK_CONTAINER (frame), table);
 
       add_row (GTK_GRID (table), 0, size_group, "_Foreground", color_options);
       add_row (GTK_GRID (table), 1, size_group, "_Background", color_options);
 
       /* And another frame holding line style options */
       frame = gtk_frame_new ("Line Options");
-      gtk_box_append (GTK_BOX (vbox), frame);
+      gtk_container_add (GTK_CONTAINER (vbox), frame);
 
       table = gtk_grid_new ();
       gtk_widget_set_margin_start (table, 5);
@@ -143,14 +144,14 @@ do_sizegroup (GtkWidget *do_widget)
       gtk_widget_set_margin_bottom (table, 5);
       gtk_grid_set_row_spacing (GTK_GRID (table), 5);
       gtk_grid_set_column_spacing (GTK_GRID (table), 10);
-      gtk_frame_set_child (GTK_FRAME (frame), table);
+      gtk_container_add (GTK_CONTAINER (frame), table);
 
       add_row (GTK_GRID (table), 0, size_group, "_Dashing", dash_options);
       add_row (GTK_GRID (table), 1, size_group, "_Line ends", end_options);
 
       /* And a check button to turn grouping on and off */
       check_button = gtk_check_button_new_with_mnemonic ("_Enable grouping");
-      gtk_box_append (GTK_BOX (vbox), check_button);
+      gtk_container_add (GTK_CONTAINER (vbox), check_button);
 
       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
       g_signal_connect (check_button, "toggled",
@@ -160,7 +161,7 @@ do_sizegroup (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/sliding_puzzle.c

@@ -267,10 +267,15 @@ start_puzzle (GdkPaintable *paintable)
   guint x, y;
   float aspect_ratio;
 
+  /* Remove the old grid (if there is one) */
+  grid = gtk_bin_get_child (GTK_BIN (frame));
+  if (grid)
+    gtk_container_remove (GTK_CONTAINER (frame), grid);
+
   /* Create a new grid */
   grid = gtk_grid_new ();
   gtk_widget_set_can_focus (grid, TRUE);
-  gtk_aspect_frame_set_child (GTK_ASPECT_FRAME (frame), grid);
+  gtk_container_add (GTK_CONTAINER (frame), grid);
   aspect_ratio = gdk_paintable_get_intrinsic_aspect_ratio (paintable);
   if (aspect_ratio == 0.0)
     aspect_ratio = 1.0;
@@ -340,7 +345,7 @@ reshuffle (void)
 {
   GtkWidget *grid;
 
-  grid = gtk_aspect_frame_get_child (GTK_ASPECT_FRAME (frame));
+  grid = gtk_bin_get_child (GTK_BIN (frame));
   if (solved)
     start_puzzle (puzzle);
   else
@@ -367,14 +372,13 @@ reconfigure (void)
       child = selected->data;
       g_list_free (selected);
     }
-
-  image = gtk_flow_box_child_get_child (GTK_FLOW_BOX_CHILD (child));
+  image = gtk_bin_get_child (GTK_BIN (child));
   puzzle = gtk_image_get_paintable (GTK_IMAGE (image));
 
-  start_puzzle (puzzle);
+  start_puzzle (puzzle); 
   popover = gtk_widget_get_ancestor (size_spin, GTK_TYPE_POPOVER);
   gtk_popover_popdown (GTK_POPOVER (popover));
-  grid = gtk_aspect_frame_get_child (GTK_ASPECT_FRAME (frame));
+  grid = gtk_bin_get_child (GTK_BIN (frame));
   gtk_widget_grab_focus (grid);
 }
 
@@ -387,7 +391,7 @@ add_choice (GtkWidget    *container,
   icon = gtk_image_new_from_paintable (paintable);
   gtk_image_set_icon_size (GTK_IMAGE (icon), GTK_ICON_SIZE_LARGE);
 
-  gtk_box_append (GTK_BOX (container), icon);
+  gtk_container_add (GTK_CONTAINER (container), icon);
 }
 
 GtkWidget *
@@ -425,7 +429,7 @@ do_sliding_puzzle (GtkWidget *do_widget)
       gtk_media_stream_play (media);
       add_choice (choices, GDK_PAINTABLE (media));
       sw = gtk_scrolled_window_new (NULL, NULL);
-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), choices);
+      gtk_container_add (GTK_CONTAINER (sw), choices);
       gtk_grid_attach (GTK_GRID (tweaks), sw, 0, 0, 2, 1);
 
       label = gtk_label_new ("Size");
@@ -441,7 +445,7 @@ do_sliding_puzzle (GtkWidget *do_widget)
       g_signal_connect (apply, "clicked", G_CALLBACK (reconfigure), NULL);
 
       popover = gtk_popover_new ();
-      gtk_popover_set_child (GTK_POPOVER (popover), tweaks);
+      gtk_container_add (GTK_CONTAINER (popover), tweaks);
 
       tweak = gtk_menu_button_new ();
       gtk_menu_button_set_popover (GTK_MENU_BUTTON (tweak), popover);
@@ -460,10 +464,11 @@ do_sliding_puzzle (GtkWidget *do_widget)
       gtk_window_set_title (GTK_WINDOW (window), "Sliding Puzzle");
       gtk_window_set_titlebar (GTK_WINDOW (window), header);
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
-      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
 
       frame = gtk_aspect_frame_new (0.5, 0.5, (float) gdk_paintable_get_intrinsic_aspect_ratio (puzzle), FALSE);
-      gtk_window_set_child (GTK_WINDOW (window), frame);
+      gtk_container_add (GTK_CONTAINER (window), frame);
 
       start_puzzle (puzzle);
     }
@@ -471,7 +476,7 @@ do_sliding_puzzle (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/spinbutton.c

@@ -1,4 +1,4 @@
-/* Spin Buttons
+/* Spin Button
  *
  * GtkSpinButton provides convenient ways to input data
  * that can be seen as a value in a range. The examples
@@ -196,7 +196,8 @@ do_spinbutton (GtkWidget *do_widget)
                             gtk_widget_get_display (do_widget));
     gtk_window_set_title (GTK_WINDOW (window), "Spin Buttons");
     gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
-    g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed), &window);
 
     adj = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "basic_adjustment"));
     label = GTK_WIDGET (gtk_builder_get_object (builder, "basic_label"));
@@ -237,7 +238,7 @@ do_spinbutton (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }

demos/gtk-demo/spinner.c

@@ -45,8 +45,9 @@ do_spinner (GtkWidget *do_widget)
     gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
 
     g_signal_connect (window, "response",
-                      G_CALLBACK (gtk_window_destroy), NULL);
-    g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+                      G_CALLBACK (gtk_widget_destroy), NULL);
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed), &window);
 
     content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
 
@@ -55,34 +56,34 @@ do_spinner (GtkWidget *do_widget)
     gtk_widget_set_margin_end (vbox, 5);
     gtk_widget_set_margin_top (vbox, 5);
     gtk_widget_set_margin_bottom (vbox, 5);
-    gtk_box_append (GTK_BOX (content_area), vbox);
+    gtk_container_add (GTK_CONTAINER (content_area), vbox);
 
     /* Sensitive */
     hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
     spinner = gtk_spinner_new ();
-    gtk_box_append (GTK_BOX (hbox), spinner);
-    gtk_box_append (GTK_BOX (hbox), gtk_entry_new ());
-    gtk_box_append (GTK_BOX (vbox), hbox);
+    gtk_container_add (GTK_CONTAINER (hbox), spinner);
+    gtk_container_add (GTK_CONTAINER (hbox), gtk_entry_new ());
+    gtk_container_add (GTK_CONTAINER (vbox), hbox);
     spinner_sensitive = spinner;
 
     /* Disabled */
     hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
     spinner = gtk_spinner_new ();
-    gtk_box_append (GTK_BOX (hbox), spinner);
-    gtk_box_append (GTK_BOX (hbox), gtk_entry_new ());
-    gtk_box_append (GTK_BOX (vbox), hbox);
+    gtk_container_add (GTK_CONTAINER (hbox), spinner);
+    gtk_container_add (GTK_CONTAINER (hbox), gtk_entry_new ());
+    gtk_container_add (GTK_CONTAINER (vbox), hbox);
     spinner_unsensitive = spinner;
     gtk_widget_set_sensitive (hbox, FALSE);
 
     button = gtk_button_new_with_label (_("Play"));
     g_signal_connect (G_OBJECT (button), "clicked",
                       G_CALLBACK (on_play_clicked), spinner);
-    gtk_box_append (GTK_BOX (vbox), button);
+    gtk_container_add (GTK_CONTAINER (vbox), button);
 
     button = gtk_button_new_with_label (_("Stop"));
     g_signal_connect (G_OBJECT (button), "clicked",
                       G_CALLBACK (on_stop_clicked), spinner);
-    gtk_box_append (GTK_BOX (vbox), button);
+    gtk_container_add (GTK_CONTAINER (vbox), button);
 
     /* Start by default to test for:
      * https://bugzilla.gnome.org/show_bug.cgi?id=598496 */
@@ -92,7 +93,7 @@ do_spinner (GtkWidget *do_widget)
   if (!gtk_widget_get_visible (window))
     gtk_widget_show (window);
   else
-    gtk_window_destroy (GTK_WINDOW (window));
+    gtk_widget_destroy (window);
 
   return window;
 }