entry: Add <attributes> support

Make entries support the same <attributes> syntax as labels. Closes: #1335
Move label attribute parser code
2020-04-06 22:13:10 -04:00 · 2020-04-06 21:46:12 -04:00
847 changed files with 41819 additions and 54631 deletions
@@ -27,14 +27,14 @@ variables:

 style-check-diff:
  extends: .only-default
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v15
  stage: .pre
  allow_failure: true
  script:
    - .gitlab-ci/run-style-check-diff.sh

 fedora-x86_64:
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v15
  stage: build
  variables:
    EXTRA_MESON_FLAGS: "--buildtype=debug --default-library=both"
@@ -66,7 +66,7 @@ fedora-x86_64:
    <<: *cache-paths

 release-build:
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v15
  stage: build
  variables:
    EXTRA_MESON_FLAGS: "--buildtype=release"
@@ -99,12 +99,12 @@ release-build:
 .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"
+    key: "%CI_JOB_NAME%"
    <<: *cache-paths

 msys2-mingw32:
@@ -168,7 +168,7 @@ flatpak-master:icon-browser:
  <<: *flatpak-master

 static-scan:
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v15
  stage: analysis
  variables:
    EXTRA_MESON_FLAGS: "--buildtype=debug"
@@ -181,7 +181,7 @@ static-scan:
  allow_failure: true

 reference:
-  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v16
+  image: registry.gitlab.gnome.org/gnome/gtk/fedora:v15
  stage: docs
  variables:
    EXTRA_MESON_FLAGS: "--buildtype=release"
@@ -82,7 +82,7 @@ RUN dnf -y install \
    xorg-x11-server-Xvfb \
 && dnf clean all

-RUN pip3 install meson==0.53.1
+RUN pip3 install meson==0.52.1

 ARG HOST_USER_ID=5555
 ENV HOST_USER_ID ${HOST_USER_ID}
@@ -174,7 +174,7 @@ ul.images li {
        <div class="failures">
          <h4><a name="{{ suite_result.suite_name }}-failed">Failures</a></h4>
          <ul class="failed">
-            {% for failure in suite_result.failures if failure.result in [ 'ERROR', 'FAIL', 'UNEXPECTEDPASS' ] %}
+            {% for failure in suite_result.failures if failure.result in [ 'FAIL', 'UNEXPECTEDPASS' ] %}
            <li><a name="{{ failure.name }}">{{ failure.name }}</a> - result: <span class="result fail">{{ failure.result }}</span><br/>
              {% if failure.stdout %}
              Output: <pre>{{ failure.stdout }}</pre>
@@ -207,6 +207,24 @@ ul.images li {
        </div>

        <div class="successes">
+          <h4><a name="{{ suite_result.suite_name }}-skipped">Skipped</a></h4>
+          <ul>
+            {% for success in suite_result.successes if success.result == 'SKIP' %}
+            <li>{{ success.name }} - result: <span class="result skip">{{ success.result }}</li>
+            {% else %}
+            <li>None</li>
+            {% endfor %}
+          </ul>
+
+          <h4><a name="{{ suite_result.suite_name }}-passed">Passed</a></h4>
+          <ul class="passed">
+            {% for success in suite_result.successes if success.result == 'OK' %}
+            <li>{{ success.name }} - result: <span class="result pass">{{ success.result }}</li>
+            {% else %}
+            <li>None</li>
+            {% endfor %}
+          </ul>
+
          <h4><a name="{{ suite_result.suite_name }}-expected-fail">Expected failures</a></h4>
          <ul>
          {% for success in suite_result.successes if success.result == 'EXPECTEDFAIL' %}
@@ -226,24 +244,6 @@ ul.images li {
            <li>None</li>
          {% endfor %}
          </ul>
-
-          <h4><a name="{{ suite_result.suite_name }}-skipped">Skipped</a></h4>
-          <ul>
-            {% for success in suite_result.successes if success.result == 'SKIP' %}
-            <li>{{ success.name }} - result: <span class="result skip">{{ success.result }}</li>
-            {% else %}
-            <li>None</li>
-            {% endfor %}
-          </ul>
-
-          <h4><a name="{{ suite_result.suite_name }}-passed">Passed</a></h4>
-          <ul class="passed">
-            {% for success in suite_result.successes if success.result == 'OK' %}
-            <li>{{ success.name }} - result: <span class="result pass">{{ success.result }}</li>
-            {% else %}
-            <li>None</li>
-            {% endfor %}
-          </ul>
        </div>

      </div>
@@ -331,7 +331,7 @@ for name, units in suites.items():
    print('Processing {} suite {}:'.format(project_name, suite_name))

    def if_failed(unit):
-        if unit['result'] in ['FAIL', 'UNEXPECTEDPASS', 'TIMEOUT', 'ERROR',]:
+        if unit['result'] in ['FAIL', 'UNEXPECTEDPASS', 'TIMEOUT']:
            return True
        return False

@@ -70,7 +70,7 @@ for name, units in suites.items():
    print('Processing suite {} (units: {})'.format(name, len(units)))

    def if_failed(unit):
-        if unit['result'] in ['ERROR', 'FAIL', 'UNEXPECTEDPASS', 'TIMEOUT']:
+        if unit['result'] in ['FAIL', 'UNEXPECTEDPASS', 'TIMEOUT']:
            return True
        return False

@@ -34,7 +34,7 @@ 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"

 mkdir -p _ccache
@@ -45,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
@@ -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).
@@ -1,79 +1,3 @@
-Overview of Changes in GTK 3.98.3
-=================================
-
-* GtkEntry:
- - Support setting attributes in ui files
-
-* GtkScaleButton:
- - Don't derive from GtkButton
-
-* GtkAboutDialog:
- - Support more common licenses
-
-* 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
-
-* Themes:
- - Use blue focus outlines more
- - Numerous minor improvements
-
-* Wayland:
- - Fix .Compose file loading
- - Support popup repositioning
- - Fix problems with autohide popovers
-
-* GDK:
- - Remove GdkKeymap from public API, replaced by
-   GdkDevice properties
- - Add full keyboard translation state to key events
- - 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
- - Lithuanian
- - Turkish
-
-
 Overview of Changes in GTK 3.98.2
 =================================

@@ -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.
@@ -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);

@@ -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);
@@ -613,19 +613,19 @@ create_widget_func (gpointer item,
  if (GTK_IS_CONSTRAINT (item) || GTK_IS_CONSTRAINT_GUIDE (item))
    {
      button = gtk_button_new_from_icon_name ("document-edit-symbolic");
-      gtk_button_set_has_frame (GTK_BUTTON (button), FALSE);
+      gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
      g_signal_connect (button, "clicked", G_CALLBACK (row_edit), win);
      g_object_set_data (G_OBJECT (row), "edit", 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);
+      gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
      g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
      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);
+      gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
      g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
      gtk_container_add (GTK_CONTAINER (box), button);
    }
@@ -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">
@@ -214,9 +214,9 @@ constraint_view_add_child (ConstraintView *view,

  label = gtk_label_new (name);
  frame = gtk_frame_new (NULL);
-  gtk_widget_add_css_class (frame, "child");
+  gtk_style_context_add_class (gtk_widget_get_style_context (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);
@@ -257,9 +257,9 @@ constraint_view_add_guide (ConstraintView *view,
                          G_BINDING_DEFAULT);

  frame = gtk_frame_new (NULL);
-  gtk_widget_add_css_class (frame, "guide");
+  gtk_style_context_add_class (gtk_widget_get_style_context (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);
@@ -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);
@@ -61,7 +61,7 @@
        </child>
        <child>
          <object class="GtkScrolledWindow">
-            <property name="has-frame">1</property>
+            <property name="shadow-type">in</property>
            <child>
              <object class="GtkTextView">
                <property name="hexpand">1</property>
@@ -26,7 +26,7 @@
        <child>
          <object class="GtkScrolledWindow" id="scrolledwindow">
            <property name="vexpand">1</property>
-            <property name="has-frame">1</property>
+            <property name="shadow-type">in</property>
            <property name="min-content-width">150</property>
            <layout>
              <property name="left-attach">0</property>
@@ -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,
@@ -131,11 +131,13 @@ blur_overlay_child_update_style_classes (BlurOverlay *overlay,
  GtkAlign valign, halign;
  gboolean is_left, is_right, is_top, is_bottom;
  gboolean has_left, has_right, has_top, has_bottom;
+  GtkStyleContext *context;

-  has_left = gtk_widget_has_css_class (child, GTK_STYLE_CLASS_LEFT);
-  has_right = gtk_widget_has_css_class (child, GTK_STYLE_CLASS_RIGHT);
-  has_top = gtk_widget_has_css_class (child, GTK_STYLE_CLASS_TOP);
-  has_bottom = gtk_widget_has_css_class (child, GTK_STYLE_CLASS_BOTTOM);
+  context = gtk_widget_get_style_context (child);
+  has_left = gtk_style_context_has_class (context, GTK_STYLE_CLASS_LEFT);
+  has_right = gtk_style_context_has_class (context, GTK_STYLE_CLASS_RIGHT);
+  has_top = gtk_style_context_has_class (context, GTK_STYLE_CLASS_TOP);
+  has_bottom = gtk_style_context_has_class (context, GTK_STYLE_CLASS_BOTTOM);

  is_left = is_right = is_top = is_bottom = FALSE;

@@ -158,24 +160,24 @@ blur_overlay_child_update_style_classes (BlurOverlay *overlay,
    is_bottom = (child_allocation->y + child_allocation->height == height);

  if (has_left && !is_left)
-    gtk_widget_remove_css_class (child, GTK_STYLE_CLASS_LEFT);
+    gtk_style_context_remove_class (context, GTK_STYLE_CLASS_LEFT);
  else if (!has_left && is_left)
-    gtk_widget_add_css_class (child, GTK_STYLE_CLASS_LEFT);
+    gtk_style_context_add_class (context, GTK_STYLE_CLASS_LEFT);

  if (has_right && !is_right)
-    gtk_widget_remove_css_class (child, GTK_STYLE_CLASS_RIGHT);
+    gtk_style_context_remove_class (context, GTK_STYLE_CLASS_RIGHT);
  else if (!has_right && is_right)
-    gtk_widget_add_css_class (child, GTK_STYLE_CLASS_RIGHT);
+    gtk_style_context_add_class (context, GTK_STYLE_CLASS_RIGHT);

  if (has_top && !is_top)
-    gtk_widget_remove_css_class (child, GTK_STYLE_CLASS_TOP);
+    gtk_style_context_remove_class (context, GTK_STYLE_CLASS_TOP);
  else if (!has_top && is_top)
-    gtk_widget_add_css_class (child, GTK_STYLE_CLASS_TOP);
+    gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOP);

  if (has_bottom && !is_bottom)
-    gtk_widget_remove_css_class (child, GTK_STYLE_CLASS_BOTTOM);
+    gtk_style_context_remove_class (context, GTK_STYLE_CLASS_BOTTOM);
  else if (!has_bottom && is_bottom)
-    gtk_widget_add_css_class (child, GTK_STYLE_CLASS_BOTTOM);
+    gtk_style_context_add_class (context, GTK_STYLE_CLASS_BOTTOM);
 }

 static void
@@ -204,7 +206,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 +292,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 +422,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 +479,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;
-}
@@ -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

@@ -12,7 +12,6 @@
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 #include <string.h>
-#include "demoimage.h"

 static GtkWidget *window = NULL;

@@ -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,6 +243,14 @@ 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),
@@ -118,7 +266,7 @@ 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");

@@ -172,16 +320,62 @@ do_clipboard (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (vbox), hbox);

      /* Create the first image */
-      image = demo_image_new ("dialog-warning");
+      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");
+      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_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);
    }

  if (!gtk_widget_get_visible (window))
@@ -0,0 +1,119 @@
+/* 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_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+      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;
+}
@@ -324,7 +324,7 @@ do_combobox (GtkWidget *do_widget)
    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
@@ -337,7 +337,7 @@ do_combobox (GtkWidget *do_widget)
    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);
@@ -381,7 +381,7 @@ do_combobox (GtkWidget *do_widget)
    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);
@@ -412,7 +412,7 @@ do_combobox (GtkWidget *do_widget)
    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);
@@ -421,7 +421,8 @@ do_combobox (GtkWidget *do_widget)
    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");
@@ -432,7 +433,7 @@ do_combobox (GtkWidget *do_widget)
    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");
@@ -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_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,16 +257,16 @@ 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_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);
@@ -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_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,16 +213,16 @@ 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_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);
@@ -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_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,16 +133,16 @@ 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_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);
@@ -34,7 +34,7 @@ do_css_accordion (GtkWidget *do_widget)
      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_container_add (GTK_CONTAINER (container), child);
@@ -92,7 +92,7 @@ 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_container_add (GTK_CONTAINER (container), child);
      g_signal_connect (text, "changed",
@@ -94,7 +94,7 @@ do_css_multiplebgs (GtkWidget *do_widget)
                        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");
@@ -80,7 +80,7 @@ do_css_pixbufs (GtkWidget *do_widget)
                        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);
@@ -99,7 +99,7 @@ do_css_shadows (GtkWidget *do_widget)
                        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_container_add (GTK_CONTAINER (paned), child);
@@ -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>
@@ -108,10 +104,6 @@
    <file>gtkfishbowl.c</file>
    <file>gtkfishbowl.h</file>
  </gresource>
-  <gresource prefix="/gears">
-    <file>gtkgears.c</file>
-    <file>gtkgears.h</file>
-  </gresource>
  <gresource prefix="/iconscroll">
    <file>iconscroll.ui</file>
  </gresource>
@@ -158,6 +150,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>
@@ -183,7 +176,6 @@
    <file>font_features.c</file>
    <file>fontplane.c</file>
    <file>fontrendering.c</file>
-    <file>gears.c</file>
    <file>gestures.c</file>
    <file>glarea.c</file>
    <file>headerbar.c</file>
@@ -280,6 +272,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 +304,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>
@@ -166,7 +166,7 @@
        </child>
        <child>
          <object class="GtkScrolledWindow" id="scrolledwindow1">
-            <property name="has-frame">1</property>
+            <property name="shadow-type">in</property>
            <property name="hexpand">1</property>
            <property name="vexpand">1</property>
            <child>
@@ -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);
-}
@@ -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
@@ -472,7 +472,7 @@ demo_tagged_entry_tag_set_has_close_button (DemoTaggedEntryTag *tag,
      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_button_set_relief (GTK_BUTTON (tag->button), GTK_RELIEF_NONE);
      gtk_container_add (GTK_CONTAINER (tag->box), tag->button);
      g_signal_connect (tag->button, "clicked", G_CALLBACK (on_button_clicked), tag);
    }
@@ -118,14 +118,14 @@ do_dialog (GtkWidget *do_widget)
      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);
@@ -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 void
-drag_cancel (GtkDragSource       *source,
-             GdkDrag             *drag,
-             GdkDragCancelReason  reason)
+static GtkWidget *
+deserialize_widget (GtkDemoWidget *demo)
 {
-  drag_end (source, drag);
-}
+  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_style_context_add_class (gtk_widget_get_style_context (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_container_add (GTK_CONTAINER (canvas), item);
-  apply_transform (item);
+  widget = gtk_spinner_new ();
+  gtk_style_context_add_class (gtk_widget_get_style_context (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,15 +204,14 @@ 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_widget_destroy (entry);
 }
@@ -144,10 +219,10 @@ edit_label_done (GtkWidget *entry, gpointer data)
 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,23 +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)
-{
-  gtk_widget_destroy (child);
-
-  gtk_popover_popdown (GTK_POPOVER (gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER)));
-}
-
 static void
 pressed_cb (GtkGesture *gesture,
            int         n_press,
@@ -193,6 +266,7 @@ pressed_cb (GtkGesture *gesture,
      GtkWidget *menu;
      GtkWidget *box;
      GtkWidget *item;
+      GdkClipboard *clipboard;

      pos_x = x;
      pos_y = y;
@@ -204,16 +278,20 @@ pressed_cb (GtkGesture *gesture,
      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
      gtk_container_add (GTK_CONTAINER (menu), box);

-      item = gtk_button_new_with_label ("New");
-      gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
-      g_signal_connect (item, "clicked", G_CALLBACK (new_item_cb), widget);
+      item = gtk_button_new_with_label ("New Label");
+      gtk_button_set_relief (GTK_BUTTON (item), GTK_RELIEF_NONE);
+      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_relief (GTK_BUTTON (item), GTK_RELIEF_NONE);
+      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_container_add (GTK_CONTAINER (box), item);

      item = gtk_button_new_with_label ("Edit");
-      gtk_button_set_has_frame (GTK_BUTTON (item), FALSE);
+      gtk_button_set_relief (GTK_BUTTON (item), GTK_RELIEF_NONE);
      gtk_widget_set_sensitive (item, child != NULL && child != widget);
      g_signal_connect (item, "clicked", G_CALLBACK (edit_cb), child);
      gtk_container_add (GTK_CONTAINER (box), item);
@@ -221,8 +299,25 @@ pressed_cb (GtkGesture *gesture,
      item = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
      gtk_container_add (GTK_CONTAINER (box), item);

+      item = gtk_button_new_with_label ("Cut");
+      gtk_button_set_relief (GTK_BUTTON (item), GTK_RELIEF_NONE);
+      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_relief (GTK_BUTTON (item), GTK_RELIEF_NONE);
+      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_relief (GTK_BUTTON (item), GTK_RELIEF_NONE);
+      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_button_set_relief (GTK_BUTTON (item), GTK_RELIEF_NONE);
      gtk_widget_set_sensitive (item, child != NULL && child != widget);
      g_signal_connect (item, "clicked", G_CALLBACK (delete_cb), child);
      gtk_container_add (GTK_CONTAINER (box), item);
@@ -251,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 *
@@ -417,78 +353,37 @@ do_dnd (GtkWidget *do_widget)
 {
  if (!window)
    {
-      GtkWidget *sw;
-      GtkWidget *canvas;
-      GtkWidget *widget;
-      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;
+      GtkWidget *vbox, *fixed;
+      GtkGesture *multipress;
+      GtkCssProvider *provider;

-      widget = gtk_color_button_new ();
-      gtk_widget_destroy (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), "Drag-and-Drop");
-      gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
+      gtk_window_set_title (GTK_WINDOW (window), "Drag-and-drop");

      g_signal_connect (window, "destroy",
                        G_CALLBACK (gtk_widget_destroyed), &window);

-      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_window_set_child (GTK_WINDOW (window), box);
+      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+      gtk_container_add (GTK_CONTAINER (window), vbox);

-      box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-      gtk_container_add (GTK_CONTAINER (box), box2);
+      fixed = gtk_fixed_new ();
+      gtk_container_add (GTK_CONTAINER (vbox), fixed);
+      gtk_widget_set_hexpand (fixed, TRUE);
+      gtk_widget_set_vexpand (fixed, TRUE);

-      canvas = canvas_new ();
-      gtk_container_add (GTK_CONTAINER (box2), canvas);
+      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));

-      n_items = 0;
-
-      x = y = 40;
-      for (i = 0; i < 4; i++)
-        {
-          GtkWidget *item;
-
-          item = canvas_item_new (x, y);
-          gtk_container_add (GTK_CONTAINER (canvas), item);
-          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_container_add (GTK_CONTAINER (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_container_add (GTK_CONTAINER (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))
@@ -0,0 +1,3 @@
+spinner.demo {
+  opacity: 1;
+}
@@ -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);
 }
@@ -204,7 +202,7 @@ 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 checkerboard area
@@ -216,6 +214,7 @@ do_drawingarea (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (vbox), label);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_widget_set_vexpand (frame, TRUE);
      gtk_container_add (GTK_CONTAINER (vbox), frame);

@@ -223,7 +222,7 @@ do_drawingarea (GtkWidget *do_widget)
      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), checkerboard_draw, NULL, NULL);
-      gtk_frame_set_child (GTK_FRAME (frame), da);
+      gtk_container_add (GTK_CONTAINER (frame), da);

      /*
       * Create the scribble area
@@ -236,16 +235,17 @@ do_drawingarea (GtkWidget *do_widget)

      frame = gtk_frame_new (NULL);
      gtk_widget_set_vexpand (frame, TRUE);
+      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      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);
@@ -360,13 +360,14 @@ do_editable_cells (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);

      gtk_container_add (GTK_CONTAINER (vbox),
                          gtk_label_new ("Shopping list (you can edit the cells!)"));

      sw = gtk_scrolled_window_new (NULL, NULL);
-      gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
+      gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+                                           GTK_SHADOW_ETCHED_IN);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                      GTK_POLICY_AUTOMATIC,
                                      GTK_POLICY_AUTOMATIC);
@@ -387,7 +388,7 @@ 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);
@@ -59,7 +59,7 @@ do_entry_completion (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), "Completion demo, try writing <b>total</b> or <b>gnome</b> for example.");
@@ -33,7 +33,7 @@ do_entry_undo (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),
@@ -59,7 +59,7 @@ do_expander (GtkWidget *do_widget)
      gtk_widget_set_vexpand (expander, TRUE);
      sw = gtk_scrolled_window_new (NULL, NULL);
      gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 100);
-      gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
+      gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                      GTK_POLICY_NEVER,
                                      GTK_POLICY_AUTOMATIC);
@@ -78,7 +78,7 @@ 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_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",
@@ -62,7 +62,7 @@ create_blurred_button (void)
 {
  GtkWidget *w = gtk_button_new ();

-  gtk_widget_add_css_class (w, "blurred-button");
+  gtk_style_context_add_class (gtk_widget_get_style_context (w), "blurred-button");

  return w;
 }
@@ -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
@@ -49,7 +49,7 @@
        <child type="end">
          <object class="GtkToggleButton" id="changes_allow">
            <property name="icon-name">changes-allow</property>
-            <property name="has-frame">0</property>
+            <property name="relief">none</property>
            <signal name="notify::active" handler="fishbowl_changes_toggled_cb"/>
          </object>
        </child>
@@ -52,7 +52,7 @@ create_faces (void)
      /* Add a face */
      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_style_context_add_class (gtk_widget_get_style_context (faces[i].face), faces[i].css_class);
      gtk_container_add (GTK_CONTAINER (fixed), faces[i].face);

      /* Set up the transformation for each face */
@@ -131,10 +131,10 @@ 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);

@@ -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;
 }
@@ -735,8 +735,8 @@ 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_container_add (GTK_CONTAINER (flowbox), color_swatch_new (colors[i]));
@@ -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>
@@ -189,6 +189,8 @@ gtk_font_plane_init (GtkFontPlane *plane)
 {
  GtkGesture *gesture;

+  gtk_widget_set_can_focus (GTK_WIDGET (plane), TRUE);
+
  gesture = gtk_gesture_drag_new ();
  g_signal_connect (gesture, "drag-begin",
 		    G_CALLBACK (plane_drag_gesture_begin), plane);
@@ -193,7 +193,7 @@
        <child>
          <object class="GtkScrolledWindow">
            <property name="propagate-natural-height">1</property>
-            <property name="has-frame">1</property>
+            <property name="shadow-type">in</property>
            <property name="hexpand">1</property>
            <property name="vexpand">1</property>
            <child>
@@ -1,137 +0,0 @@
-/* OpenGL/Gears
- *
- * This is a classic OpenGL demo, running in a GtkGLArea.
- */
-
-
-#include <stdlib.h>
-#include <gtk/gtk.h>
-
-#include "gtkgears.h"
-
-/************************************************************************
- *                 DEMO CODE                                            *
- ************************************************************************/
-
-static void
-on_axis_value_change (GtkAdjustment *adjustment,
-                      gpointer       data)
-{
-  GtkGears *gears = GTK_GEARS (data);
-  int axis = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (adjustment), "axis"));
-
-  gtk_gears_set_axis (gears, axis, gtk_adjustment_get_value (adjustment));
-}
-
-
-static GtkWidget *
-create_axis_slider (GtkGears *gears,
-                    int axis)
-{
-  GtkWidget *box, *label, *slider;
-  GtkAdjustment *adj;
-  const char *text;
-
-  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE);
-
-  switch (axis)
-    {
-    case GTK_GEARS_X_AXIS:
-      text = "X";
-      break;
-
-    case GTK_GEARS_Y_AXIS:
-      text = "Y";
-      break;
-
-    case GTK_GEARS_Z_AXIS:
-      text = "Z";
-      break;
-
-    default:
-      g_assert_not_reached ();
-    }
-
-  label = gtk_label_new (text);
-  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);
-  g_object_set_data (G_OBJECT (adj), "axis", GINT_TO_POINTER (axis));
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (on_axis_value_change),
-                    gears);
-  slider = gtk_scale_new (GTK_ORIENTATION_VERTICAL, adj);
-  gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
-  gtk_container_add (GTK_CONTAINER (box), slider);
-  gtk_widget_set_vexpand (slider, TRUE);
-  gtk_widget_show (slider);
-
-  gtk_widget_show (box);
-
-  return box;
-}
-
-GtkWidget *
-do_gears (GtkWidget *do_widget)
-{
-  static GtkWidget *window = NULL;
-  GtkWidget *box, *hbox, *fps_label, *gears, *overlay, *frame;
-  int i;
-
-  if (!window)
-    {
-      window = gtk_window_new ();
-      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_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
-
-      overlay = gtk_overlay_new ();
-      gtk_widget_set_margin_start (overlay, 12);
-      gtk_widget_set_margin_end (overlay, 12);
-      gtk_widget_set_margin_top (overlay, 12);
-      gtk_widget_set_margin_bottom (overlay, 12);
-
-      gtk_window_set_child (GTK_WINDOW (window), overlay);
-
-      frame = gtk_frame_new (NULL);
-      gtk_widget_set_halign (frame, GTK_ALIGN_START);
-      gtk_widget_set_valign (frame, GTK_ALIGN_START);
-      gtk_widget_add_css_class (frame, "app-notification");
-      gtk_overlay_add_overlay (GTK_OVERLAY (overlay), frame);
-
-      fps_label = gtk_label_new ("");
-      gtk_widget_set_halign (fps_label, GTK_ALIGN_START);
-      gtk_frame_set_child (GTK_FRAME (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);
-
-      hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE);
-      gtk_box_set_spacing (GTK_BOX (box), 6);
-      gtk_container_add (GTK_CONTAINER (box), hbox);
-
-      gears = gtk_gears_new ();
-      gtk_widget_set_hexpand (gears, TRUE);
-      gtk_widget_set_vexpand (gears, TRUE);
-      gtk_container_add (GTK_CONTAINER (hbox), gears);
-
-      for (i = 0; i < GTK_GEARS_N_AXIS; 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_container_add (GTK_CONTAINER (box), hbox);
-
-      gtk_gears_set_fps_label (GTK_GEARS (gears), GTK_LABEL (fps_label));
-    }
-
-  if (!gtk_widget_get_visible (window))
-    gtk_widget_show (window);
-  else
-    gtk_widget_destroy (window);
-
-  return window;
-}
@@ -153,7 +153,7 @@ do_gestures (GtkWidget *do_widget)
                        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,
@@ -1,4 +1,4 @@
-/* OpenGL/OpenGL Area
+/* OpenGL Area
 *
 * GtkGLArea is a widget that allows custom drawing using OpenGL calls.
 */
@@ -401,7 +401,7 @@ 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);
@@ -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,35 +25,36 @@ 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_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");
+      gtk_style_context_add_class (gtk_widget_get_style_context (box), "linked");
      button = gtk_button_new ();
-      gtk_button_set_child (GTK_BUTTON (button), gtk_image_new_from_icon_name ("pan-start-symbolic"));
+      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_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))
@@ -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>
@@ -266,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);
    }
@@ -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;

@@ -263,7 +263,7 @@ 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_container_add (GTK_CONTAINER (vbox), tool_bar);
@@ -277,7 +277,8 @@ do_iconview (GtkWidget *do_widget)


      sw = gtk_scrolled_window_new (NULL, NULL);
-      gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
+      gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+                                           GTK_SHADOW_ETCHED_IN);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                      GTK_POLICY_AUTOMATIC,
                                      GTK_POLICY_AUTOMATIC);
@@ -312,7 +313,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);
    }
@@ -146,7 +146,7 @@ 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))
@@ -346,7 +346,7 @@ 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_container_add (GTK_CONTAINER (base_vbox), hbox);
@@ -360,6 +360,7 @@ do_images (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (vbox), label);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
      gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
      gtk_container_add (GTK_CONTAINER (vbox), frame);
@@ -367,7 +368,7 @@ do_images (GtkWidget *do_widget)
      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 */
@@ -378,13 +379,14 @@ do_images (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (vbox), label);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
      gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
      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 */

@@ -394,6 +396,7 @@ do_images (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (vbox), label);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
      gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
      gtk_container_add (GTK_CONTAINER (vbox), frame);
@@ -402,7 +405,7 @@ do_images (GtkWidget *do_widget)
      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 */
@@ -415,6 +418,7 @@ do_images (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (vbox), label);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
      gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
      gtk_container_add (GTK_CONTAINER (vbox), frame);
@@ -423,7 +427,7 @@ do_images (GtkWidget *do_widget)
       * 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);

@@ -437,13 +441,14 @@ do_images (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (vbox), label);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
      gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
      gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
      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);
@@ -44,6 +44,7 @@ do_infobar (GtkWidget *do_widget)
  GtkWidget *frame;
  GtkWidget *bar;
  GtkWidget *vbox;
+  GtkWidget *vbox2;
  GtkWidget *label;
  GtkWidget *actions;
  GtkWidget *button;
@@ -51,13 +52,11 @@ 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_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);

@@ -66,7 +65,7 @@ do_infobar (GtkWidget *do_widget)
      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_container_add (GTK_CONTAINER (vbox), bar);
@@ -132,18 +131,23 @@ do_infobar (GtkWidget *do_widget)
      g_object_bind_property (bar, "revealed", button, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
      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_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))
@@ -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.
 */

@@ -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,30 +56,22 @@ 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_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);
    }

@@ -266,13 +266,14 @@ do_list_store (GtkWidget *do_widget)
      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_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_shadow_type (GTK_SCROLLED_WINDOW (sw),
+                                           GTK_SHADOW_ETCHED_IN);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                      GTK_POLICY_NEVER,
                                      GTK_POLICY_AUTOMATIC);
@@ -289,7 +290,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));
@@ -360,7 +360,7 @@ do_listbox (GtkWidget *do_widget)
                        &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_container_add (GTK_CONTAINER (vbox), label);
      scrolled = gtk_scrolled_window_new (NULL, NULL);
@@ -368,7 +368,7 @@ do_listbox (GtkWidget *do_widget)
      gtk_widget_set_vexpand (scrolled, TRUE);
      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);
@@ -40,7 +40,7 @@
              <object class="GtkButton" id="button2">
                <property name="receives-default">1</property>
                <property name="valign">baseline</property>
-                <property name="has-frame">0</property>
+                <property name="relief">none</property>
                <child>
                  <object class="GtkLabel" id="source_name">
                    <property name="valign">baseline</property>
@@ -109,7 +109,7 @@
              <object class="GtkLinkButton" id="resent_by_button">
                <property name="label" translatable="0">reshareer</property>
                <property name="receives-default">1</property>
-                <property name="has-frame">0</property>
+                <property name="relief">none</property>
                <property name="uri">http://www.gtk.org</property>
              </object>
            </child>
@@ -126,7 +126,7 @@
              <object class="GtkButton" id="expand_button">
                <property name="label" translatable="yes">Expand</property>
                <property name="receives-default">1</property>
-                <property name="has-frame">0</property>
+                <property name="relief">none</property>
                <signal name="clicked" handler="expand_clicked" swapped="yes"/>
              </object>
            </child>
@@ -138,14 +138,14 @@
                  <object class="GtkButton" id="reply-button">
                    <property name="label" translatable="yes">Reply</property>
                    <property name="receives-default">1</property>
-                    <property name="has-frame">0</property>
+                    <property name="relief">none</property>
                  </object>
                </child>
                <child>
                  <object class="GtkButton" id="reshare-button">
                    <property name="label" translatable="yes">Reshare</property>
                    <property name="receives-default">1</property>
-                    <property name="has-frame">0</property>
+                    <property name="relief">none</property>
                    <signal name="clicked" handler="reshare_clicked" swapped="yes"/>
                  </object>
                </child>
@@ -153,7 +153,7 @@
                  <object class="GtkButton" id="favorite-buttton">
                    <property name="label" translatable="yes">Favorite</property>
                    <property name="receives-default">1</property>
-                    <property name="has-frame">0</property>
+                    <property name="relief">none</property>
                    <signal name="clicked" handler="favorite_clicked" swapped="yes"/>
                  </object>
                </child>
@@ -161,7 +161,7 @@
                  <object class="GtkMenuButton" id="more-button">
                    <property name="receives-default">1</property>
                    <property name="menu-model">menu1</property>
-                    <property name="has-frame">0</property>
+                    <property name="relief">none</property>
                    <property name="label" translatable="yes">More...</property>
                  </object>
                </child>
@@ -185,6 +185,7 @@
                    <property name="spacing">8</property>
                    <child>
                      <object class="GtkFrame" id="frame1">
+                        <property name="shadow-type">none</property>
                        <child>
                          <object class="GtkLabel" id="n_reshares_label">
                            <property name="label" translatable="0">&lt;b&gt;2&lt;/b&gt;
@@ -197,6 +198,7 @@ Reshares</property>
                    </child>
                    <child>
                      <object class="GtkFrame" id="frame2">
+                        <property name="shadow-type">none</property>
                        <child>
                          <object class="GtkLabel" id="n_favorites_label">
                            <property name="label" translatable="0">&lt;b&gt;2&lt;/b&gt;
@@ -223,7 +225,7 @@ FAVORITES</property>
                      <object class="GtkButton" id="button5">
                        <property name="label" translatable="yes">Details</property>
                        <property name="receives-default">1</property>
-                        <property name="has-frame">0</property>
+                        <property name="relief">none</property>
                        <style>
                          <class name="dim-label"/>
                        </style>
@@ -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",
@@ -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,9 @@ 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_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+                                       GTK_SHADOW_NONE);
+  gtk_container_add (GTK_CONTAINER (sw), textview);

  return sw;
 }
@@ -915,7 +915,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 +1030,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 +1186,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 +1203,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);
@@ -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>
@@ -63,7 +63,7 @@ do_markup (GtkWidget *do_widget)

      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);
@@ -86,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");

@@ -99,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");

@@ -5,6 +5,7 @@ demos = files([
  'assistant.c',
  'builder.c',
  'clipboard.c',
+  'colorsel.c',
  'combobox.c',
  'constraints.c',
  'constraints2.c',
@@ -27,7 +28,6 @@ demos = files([
  'fishbowl.c',
  'fixed.c',
  'fontrendering.c',
-  'gears.c',
  'gestures.c',
  'glarea.c',
  'headerbar.c',
@@ -89,7 +89,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()
@@ -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>
@@ -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 ();

@@ -78,7 +78,7 @@ do_overlay (GtkWidget *do_widget)
      gtk_widget_set_margin_bottom (entry, 8);
      gtk_container_add (GTK_CONTAINER (vbox), entry);

-      gtk_window_set_child (GTK_WINDOW (window), overlay);
+      gtk_container_add (GTK_CONTAINER (window), overlay);

      g_signal_connect (window, "destroy",
                        G_CALLBACK (gtk_widget_destroyed), &window);
@@ -57,9 +57,9 @@ 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);
+      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);
@@ -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,7 +404,6 @@ 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_signal_connect (window, "destroy",
                        G_CALLBACK (gtk_widget_destroyed), &window);
@@ -164,7 +164,7 @@ 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);
    }

@@ -196,7 +196,7 @@ 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);
    }

@@ -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);
    }
@@ -103,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);
@@ -159,7 +159,7 @@ do_panes (GtkWidget *do_widget)
      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);
@@ -172,17 +172,20 @@ do_panes (GtkWidget *do_widget)
      gtk_paned_add1 (GTK_PANED (vpaned), hpaned);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
      gtk_widget_set_size_request (frame, 60, 60);
      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_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
      gtk_widget_set_size_request (frame, 80, 60);
      gtk_paned_add2 (GTK_PANED (hpaned), frame);

      frame = gtk_frame_new (NULL);
+      gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
      gtk_widget_set_size_request (frame, 60, 80);
      gtk_paned_add2 (GTK_PANED (vpaned), frame);

@@ -40,9 +40,9 @@ 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_signal_connect (window, "destroy",
@@ -53,7 +53,7 @@ do_password_entry (GtkWidget *do_widget)
      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);
@@ -74,7 +74,7 @@ do_password_entry (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (box), entry2);

      button = gtk_button_new_with_mnemonic ("_Done");
-      gtk_widget_add_css_class (button, "suggested-action");
+      gtk_style_context_add_class (gtk_widget_get_style_context (button), "suggested-action");
      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);
@@ -276,12 +276,13 @@ 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_signal_connect (window, "destroy",
@@ -294,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++)
        {
@@ -29,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);
@@ -212,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);
        }
@@ -185,12 +185,13 @@ do_rotated_text (GtkWidget *do_widget)

      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_container_add (GTK_CONTAINER (box), drawing_area);
-      gtk_widget_add_css_class (drawing_area, GTK_STYLE_CLASS_VIEW);
+      gtk_style_context_add_class (gtk_widget_get_style_context (drawing_area),
+                                   GTK_STYLE_CLASS_VIEW);

      gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area),
                                      rotated_text_draw,
@@ -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,
@@ -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>
@@ -269,7 +269,7 @@ 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");
@@ -78,7 +78,7 @@ do_search_entry2 (GtkWidget *do_widget)
                        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);
@@ -87,7 +87,7 @@ do_search_entry2 (GtkWidget *do_widget)
      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_container_add (GTK_CONTAINER (searchbar), container);
      gtk_container_add (GTK_CONTAINER (vbox), searchbar);

      /* Hook the search bar to key presses */
@@ -65,7 +65,7 @@ do_shortcut_triggers (GtkWidget *do_widget)
      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++)
        {
@@ -63,7 +63,7 @@ do_sidebar (GtkWidget *do_widget)
          if (i == 0)
            {
              widget = gtk_image_new_from_icon_name ("org.gtk.Demo4");
-              gtk_widget_add_css_class (widget, "icon-dropshadow");
+              gtk_style_context_add_class (gtk_widget_get_style_context (widget), "icon-dropshadow");
              gtk_image_set_pixel_size (GTK_IMAGE (widget), 256);
            }
          else
@@ -74,7 +74,7 @@ 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))
@@ -112,7 +112,7 @@ do_sizegroup (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);

      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);
@@ -128,7 +128,7 @@ 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);
@@ -144,7 +144,7 @@ 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);
@@ -267,15 +267,19 @@ 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;
-  gtk_aspect_frame_set_ratio (GTK_ASPECT_FRAME (frame), aspect_ratio);
-  gtk_aspect_frame_set_obey_child (GTK_ASPECT_FRAME (frame), FALSE);
+  gtk_aspect_frame_set (GTK_ASPECT_FRAME (frame), 0.5, 0.5, aspect_ratio, FALSE);

  /* Add shortcuts so people can use the arrow
   * keys to move the puzzle */
@@ -340,7 +344,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 +371,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);
 }

@@ -416,7 +419,7 @@ do_sliding_puzzle (GtkWidget *do_widget)
      gtk_widget_set_margin_bottom (tweaks, 10);

      choices = gtk_flow_box_new ();
-      gtk_widget_add_css_class (choices, GTK_STYLE_CLASS_VIEW);
+      gtk_style_context_add_class (gtk_widget_get_style_context (choices), GTK_STYLE_CLASS_VIEW);
      add_choice (choices, puzzle);
      add_choice (choices, gtk_nuclear_animation_new ());
      media = gtk_media_file_new_for_resource ("/images/gtk-logo.webm");
@@ -425,7 +428,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 +444,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);
@@ -463,8 +466,8 @@ do_sliding_puzzle (GtkWidget *do_widget)
      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);
+      frame = gtk_aspect_frame_new (NULL, 0.5, 0.5, (float) gdk_paintable_get_intrinsic_aspect_ratio (puzzle), FALSE);
+      gtk_container_add (GTK_CONTAINER (window), frame);

      start_puzzle (puzzle);
    }
@@ -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
@@ -2,7 +2,6 @@
 <interface>
  <object class="GtkWindow" id="window1">
    <property name="title" translatable="yes">Stack</property>
-    <property name="resizable">0</property>
    <child>
      <object class="GtkGrid">
        <child>
@@ -26,7 +25,6 @@
                  <object class="GtkImage">
                    <property name="margin-top">20</property>
                    <property name="margin-bottom">20</property>
-                    <property name="pixel-size">100</property>
                    <property name="icon-name">org.gtk.Demo4</property>
                  </object>
                </property>
@@ -46,8 +46,8 @@ do_tabs (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);
    }

  if (!gtk_widget_get_visible (window))
@@ -25,7 +25,7 @@ add_tag (GtkButton *button, DemoTaggedEntry *entry)
  DemoTaggedEntryTag *tag;

  tag = demo_tagged_entry_tag_new ("Blue");
-  gtk_widget_add_css_class (GTK_WIDGET (tag), "blue");
+  gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tag)), "blue");
  demo_tagged_entry_tag_set_has_close_button (tag, TRUE);
  g_signal_connect (tag, "button-clicked", G_CALLBACK (closed_cb), entry);

@@ -67,9 +67,9 @@ do_tagged_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), "A tagged entry");
      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), "A tagged entry");
      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
      gtk_window_set_deletable (GTK_WINDOW (window), FALSE);
      g_signal_connect (window, "destroy",
@@ -80,7 +80,7 @@ do_tagged_entry (GtkWidget *do_widget)
      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 = demo_tagged_entry_new ();
      gtk_container_add (GTK_CONTAINER (box), entry);
@@ -98,7 +98,7 @@ do_tagged_entry (GtkWidget *do_widget)
      gtk_container_add (GTK_CONTAINER (box2), button);
      
      button = gtk_button_new_with_mnemonic ("_Done");
-      gtk_widget_add_css_class (button, "suggested-action");
+      gtk_style_context_add_class (gtk_widget_get_style_context (button), "suggested-action");
      g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
      gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);

@@ -69,7 +69,7 @@ do_textmask (GtkWidget *do_widget)

      da = gtk_drawing_area_new ();

-      gtk_window_set_child (GTK_WINDOW (window), da);
+      gtk_container_add (GTK_CONTAINER (window), da);
      gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), draw_text, NULL, NULL);
    }

@@ -159,7 +159,7 @@ create_text_view (GtkWidget *hbox,
  swindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_container_add (GTK_CONTAINER (hbox), swindow);
  textview = gtk_text_view_new ();
-  gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (swindow), textview);
+  gtk_container_add (GTK_CONTAINER (swindow), textview);

  timeout = setup_scroll (GTK_TEXT_VIEW (textview), to_end);

@@ -188,7 +188,7 @@ do_textscroll (GtkWidget *do_widget)

      hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
      gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
-      gtk_window_set_child (GTK_WINDOW (window), hbox);
+      gtk_container_add (GTK_CONTAINER (window), hbox);

      create_text_view (hbox, TRUE);
      create_text_view (hbox, FALSE);
@@ -53,8 +53,8 @@ do_textundo (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);
    }

  if (!gtk_widget_get_visible (window))
@@ -486,7 +486,7 @@ do_textview (GtkWidget *do_widget)
      gtk_window_set_title (GTK_WINDOW (window), "Multiple Views");

      vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
-      gtk_window_set_child (GTK_WINDOW (window), vpaned);
+      gtk_container_add (GTK_CONTAINER (window), vpaned);

      /* For convenience, we just use the autocreated buffer from
       * the first text view; you could also create the buffer
@@ -503,7 +503,7 @@ do_textview (GtkWidget *do_widget)
                                      GTK_POLICY_AUTOMATIC);
      gtk_paned_add1 (GTK_PANED (vpaned), sw);

-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), view1);
+      gtk_container_add (GTK_CONTAINER (sw), view1);

      sw = gtk_scrolled_window_new (NULL, NULL);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
@@ -511,7 +511,7 @@ do_textview (GtkWidget *do_widget)
                                      GTK_POLICY_AUTOMATIC);
      gtk_paned_add2 (GTK_PANED (vpaned), sw);

-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), view2);
+      gtk_container_add (GTK_CONTAINER (sw), view2);

      create_tags (buffer);
      insert_text (GTK_TEXT_VIEW (view1));
@@ -547,7 +547,7 @@ recursive_attach_view (int                 depth,

  /* Frame is to add a black border around each child view */
  frame = gtk_frame_new (NULL);
-  gtk_frame_set_child (GTK_FRAME (frame), child_view);
+  gtk_container_add (GTK_CONTAINER (frame), child_view);

  gtk_text_view_add_child_at_anchor (view, frame, anchor);

@@ -594,8 +594,8 @@ easter_egg_callback (GtkWidget *button,
                                  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);

  window_ptr = &window;
  g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
@@ -97,6 +97,7 @@ change_theme (GtkWidget *widget,
              gpointer data)
 {
  GtkBuilder *builder = data;
+  GtkWidget *header;
  GtkWidget *label;
  Theme next = themes[theme++ % G_N_ELEMENTS (themes)];
  char *name;
@@ -106,8 +107,9 @@ change_theme (GtkWidget *widget,
                "gtk-application-prefer-dark-theme", next.dark,
                NULL);

+  header = GTK_WIDGET (gtk_builder_get_object (builder, "header"));
  name = g_strconcat (next.name, next.dark ? " (dark)" : NULL, NULL);
-  gtk_window_set_title (GTK_WINDOW (widget), name);
+  gtk_header_bar_set_title (GTK_HEADER_BAR (header), name);
  g_free (name);

  label = GTK_WIDGET (gtk_builder_get_object (builder, "fps"));
@@ -31,7 +31,7 @@ do_theming_style_classes (GtkWidget *do_widget)
      builder = gtk_builder_new_from_resource ("/theming_style_classes/theming.ui");

      grid = (GtkWidget *)gtk_builder_get_object (builder, "grid");
-      gtk_window_set_child (GTK_WINDOW (window), grid);
+      gtk_container_add (GTK_CONTAINER (window), grid);
      g_object_unref (builder);
    }

@@ -29,10 +29,10 @@ do_transparent (GtkWidget *do_widget)
      gtk_window_set_title (GTK_WINDOW (window), "Transparency");

      overlay = blur_overlay_new ();
-      gtk_window_set_child (GTK_WINDOW (window), overlay);
+      gtk_container_add (GTK_CONTAINER (window), overlay);

      button = gtk_button_new_with_label ("Don't click this button!");
-      label = gtk_button_get_child (GTK_BUTTON (button));
+      label = gtk_bin_get_child (GTK_BIN (button));
      gtk_widget_set_margin_start (label, 50);
      gtk_widget_set_margin_end (label, 50);
      gtk_widget_set_margin_top (label, 50);
@@ -45,7 +45,7 @@ do_transparent (GtkWidget *do_widget)
      blur_overlay_add_overlay (BLUR_OVERLAY (overlay), button, 5.0);

      button = gtk_button_new_with_label ("Maybe this one?");
-      label = gtk_button_get_child (GTK_BUTTON (button));
+      label = gtk_bin_get_child (GTK_BIN (button));
      gtk_widget_set_margin_start (label, 50);
      gtk_widget_set_margin_end (label, 50);
      gtk_widget_set_margin_top (label, 50);
@@ -58,7 +58,7 @@ do_transparent (GtkWidget *do_widget)
      blur_overlay_add_overlay (BLUR_OVERLAY (overlay), button, 5.0);

      picture = gtk_picture_new_for_resource ("/transparent/portland-rose.jpg");
-      blur_overlay_set_child (BLUR_OVERLAY (overlay), picture);
+      gtk_container_add (GTK_CONTAINER (overlay), picture);
    }

  if (!gtk_widget_get_visible (window))
@@ -402,13 +402,14 @@ do_tree_store (GtkWidget *do_widget)
      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);

      gtk_container_add (GTK_CONTAINER (vbox),
                          gtk_label_new ("Jonathan's Holiday Card Planning Sheet"));

      sw = gtk_scrolled_window_new (NULL, NULL);
-      gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (sw), TRUE);
+      gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+                                           GTK_SHADOW_ETCHED_IN);
      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                      GTK_POLICY_AUTOMATIC,
                                      GTK_POLICY_AUTOMATIC);
@@ -426,7 +427,7 @@ do_tree_store (GtkWidget *do_widget)

      add_columns (GTK_TREE_VIEW (treeview));

-      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), treeview);
+      gtk_container_add (GTK_CONTAINER (sw), treeview);

      /* expand all rows after the treeview widget has been realized */
      g_signal_connect (treeview, "realize",
@@ -71,10 +71,11 @@ do_video_player (GtkWidget *do_widget)
                        G_CALLBACK (gtk_widget_destroyed), &window);

      video = gtk_video_new ();
-      gtk_window_set_child (GTK_WINDOW (window), video);
+      gtk_container_add (GTK_CONTAINER (window), video);

      title = gtk_header_bar_new ();
      gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (title), TRUE);
+      gtk_header_bar_set_title (GTK_HEADER_BAR (title), "Video Player");
      gtk_window_set_titlebar (GTK_WINDOW (window), title);

      open_button = gtk_button_new_with_mnemonic ("_Open");
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Matthias Clasen	efe16cf4be	entry: Add <attributes> support Make entries support the same <attributes> syntax as labels. Closes: #1335	2020-04-06 22:13:10 -04:00
Matthias Clasen	dc2f65dd2b	Move label attribute parser code We want to reuse the parser for <attributes> in several widgets, so move it to a shared place.	2020-04-06 21:46:12 -04:00