wayland: Rely on server key repeat info

Using gsettings for this information does not work
in sandboxed scenarios, where settings are per-app.
Since the Wayland protocol provides this information
nowadays, just drop the old code for reading
the gsettings.

.gitlab-ci.yml

@@ -1,7 +1,7 @@
 stages:
   - build
   - flatpak
-  - deploy
+#  - deploy
 
 .cache-paths: &cache-paths
   paths:
@@ -101,20 +101,19 @@ flatpak-master:icon-browser:
     APPID: org.gtk.IconBrowser4
   <<: *flatpak-master
 
-pages:
-  image: registry.gitlab.gnome.org/gnome/gtk/master:v6
-  stage: deploy 
-  script:
-    - meson -Ddocumentation=true _build .
-    - ninja -C _build
-    - ninja -C _build gdk4-doc gsk4-doc gtk4-doc
-
-    - mkdir -p public/
-    - mv _build/docs/reference/gtk/html/ public/gtk/
-    - mv _build/docs/reference/gdk/html/ public/gdk/
-    - mv _build/docs/reference/gsk/html/ public/gsk/
-  artifacts:
-    paths:
-      - public
-  only:
-    - master
+#pages:
+#  image: registry.gitlab.gnome.org/gnome/gtk/master:v6
+#  stage: deploy 
+#  script:
+#    - meson -Dgtk_doc=true _build .
+#    - ninja -C _build
+#    - ninja -C _build gdk4-doc gsk4-doc gtk4-doc
+#    - mkdir -p public/
+#    - mv _build/docs/reference/gtk/html/ public/gtk/
+#    - mv _build/docs/reference/gdk/html/ public/gdk/
+#    - mv _build/docs/reference/gsk/html/ public/gsk/
+#  artifacts:
+#    paths:
+#      - public
+#  only:
+#    - master

config.h.meson

@@ -56,12 +56,6 @@
 /* Define if GStreamer support is available */
 #mesondefine HAVE_GSTREAMER
 
-/* Define to 1 if you have the `httpGetAuthString' function. */
-#mesondefine HAVE_HTTPGETAUTHSTRING
-
-/* Define if cups http_t authstring field is accessible */
-#mesondefine HAVE_HTTP_AUTHSTRING
-
 /* Define to 1 if you have the <inttypes.h> header file. */
 #mesondefine HAVE_INTTYPES_H
 
@@ -191,9 +185,6 @@
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 #mesondefine LT_OBJDIR
 
-/* Define if <X11/extensions/XIproto.h> needed for xReply */
-#mesondefine NEED_XIPROTO_H_FOR_XREPLY
-
 /* Define to 1 if your C compiler doesn't accept -c and -o together. */
 #mesondefine NO_MINUS_C_MINUS_O
 

demos/constraint-editor/constraint-editor-application.c

@@ -0,0 +1,115 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "constraint-editor-application.h"
+#include "constraint-editor-window.h"
+
+struct _ConstraintEditorApplication
+{
+  GtkApplication parent_instance;
+};
+
+G_DEFINE_TYPE(ConstraintEditorApplication, constraint_editor_application, GTK_TYPE_APPLICATION);
+
+static void
+constraint_editor_application_init (ConstraintEditorApplication *app)
+{
+}
+
+static void
+quit_activated (GSimpleAction *action,
+                GVariant      *parameter,
+                gpointer       data)
+{
+  g_application_quit (G_APPLICATION (data));
+}
+
+static GActionEntry app_entries[] =
+{
+  { "quit", quit_activated, NULL, NULL, NULL }
+};
+
+static void
+constraint_editor_application_startup (GApplication *app)
+{
+  const char *quit_accels[2] = { "<Ctrl>Q", NULL };
+  const char *open_accels[2] = { "<Ctrl>O", NULL };
+  GtkCssProvider *provider;
+
+  G_APPLICATION_CLASS (constraint_editor_application_parent_class)->startup (app);
+
+  g_action_map_add_action_entries (G_ACTION_MAP (app),
+                                   app_entries, G_N_ELEMENTS (app_entries),
+                                   app);
+  gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.quit", quit_accels);
+  gtk_application_set_accels_for_action (GTK_APPLICATION (app), "win.open", open_accels);
+
+  provider = gtk_css_provider_new ();
+  gtk_css_provider_load_from_resource (provider, "/org/gtk/gtk4/constraint-editor/constraint-editor.css");
+  gtk_style_context_add_provider_for_display (gdk_display_get_default (),
+                                              GTK_STYLE_PROVIDER (provider),
+                                              GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+}
+
+static void
+constraint_editor_application_activate (GApplication *app)
+{
+  ConstraintEditorWindow *win;
+
+  win = constraint_editor_window_new (CONSTRAINT_EDITOR_APPLICATION (app));
+  gtk_window_present (GTK_WINDOW (win));
+}
+
+static void
+constraint_editor_application_open (GApplication  *app,
+                                    GFile        **files,
+                                    gint           n_files,
+                                    const gchar   *hint)
+{
+  ConstraintEditorWindow *win;
+  gint i;
+
+  for (i = 0; i < n_files; i++)
+    {
+      win = constraint_editor_window_new (CONSTRAINT_EDITOR_APPLICATION (app));
+      constraint_editor_window_load (win, files[i]);
+      gtk_window_present (GTK_WINDOW (win));
+    }
+}
+
+static void
+constraint_editor_application_class_init (ConstraintEditorApplicationClass *class)
+{
+  GApplicationClass *application_class = G_APPLICATION_CLASS (class);
+
+  application_class->startup = constraint_editor_application_startup;
+  application_class->activate = constraint_editor_application_activate;
+  application_class->open = constraint_editor_application_open;
+}
+
+ConstraintEditorApplication *
+constraint_editor_application_new (void)
+{
+  return g_object_new (CONSTRAINT_EDITOR_APPLICATION_TYPE,
+                       "application-id", "org.gtk.gtk4.ConstraintEditor",
+                       "flags", G_APPLICATION_HANDLES_OPEN,
+                       NULL);
+}

demos/constraint-editor/constraint-editor-application.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define CONSTRAINT_EDITOR_APPLICATION_TYPE (constraint_editor_application_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintEditorApplication, constraint_editor_application, CONSTRAINT, EDITOR_APPLICATION, GtkApplication)
+
+ConstraintEditorApplication *constraint_editor_application_new (void);

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

@@ -0,0 +1,639 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "constraint-editor-window.h"
+#include "constraint-view.h"
+#include "constraint-editor.h"
+#include "guide-editor.h"
+
+struct _ConstraintEditorWindow
+{
+  GtkApplicationWindow parent_instance;
+
+  GtkWidget *paned;
+  GtkWidget *view;
+  GtkWidget *list;
+};
+
+G_DEFINE_TYPE(ConstraintEditorWindow, constraint_editor_window, GTK_TYPE_APPLICATION_WINDOW);
+
+static GtkConstraintTarget *
+find_target (GListModel *model,
+             GtkConstraintTarget *orig)
+{
+  const char *name;
+  const char *model_name;
+  gpointer item;
+  int i;
+
+  if (orig == NULL)
+    return NULL;
+
+  if (GTK_IS_LABEL (orig))
+    name = gtk_label_get_label (GTK_LABEL (orig));
+  else if (GTK_IS_CONSTRAINT_GUIDE (orig))
+    name = gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (orig));
+  else
+    {
+      g_warning ("Don't know how to handle %s targets", G_OBJECT_TYPE_NAME (orig));
+      return NULL;
+    }
+  for (i = 0; i < g_list_model_get_n_items (model); i++)
+    {
+      item = g_list_model_get_item (model, i);
+      g_object_unref (item);
+      if (GTK_IS_WIDGET (item))
+        model_name = gtk_widget_get_name (GTK_WIDGET (item));
+      else
+        model_name = gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (item));
+
+      if (strcmp (name, model_name) == 0)
+        return GTK_CONSTRAINT_TARGET (item);
+    }
+  g_warning ("Failed to find target '%s'", name);
+
+  return NULL;
+}
+
+gboolean
+constraint_editor_window_load (ConstraintEditorWindow *self,
+                               GFile            *file)
+{
+  char *path;
+  GtkBuilder *builder;
+  GError *error = NULL;
+  GtkWidget *view;
+  GtkLayoutManager *layout;
+  GtkWidget *child;
+  const char *name;
+  gpointer item;
+  int i;
+  GListModel *list;
+
+  path = g_file_get_path (file);
+
+  builder = gtk_builder_new ();
+  if (!gtk_builder_add_from_file (builder, path, &error))
+    {
+      g_print ("Could not load %s: %s", path, error->message);
+      g_error_free (error);
+      g_free (path);
+      g_object_unref (builder);
+      return FALSE;
+    }
+
+  view = GTK_WIDGET (gtk_builder_get_object (builder, "view"));
+  if (!GTK_IS_BOX (view))
+    {
+      g_print ("Could not load %s: No GtkBox named 'view'", path);
+      g_free (path);
+      g_object_unref (builder);
+      return FALSE;
+    }
+  layout = gtk_widget_get_layout_manager (view);
+  if (!GTK_IS_CONSTRAINT_LAYOUT (layout))
+    {
+      g_print ("Could not load %s: Widget 'view' does not use GtkConstraintLayout", path);
+      g_free (path);
+      g_object_unref (builder);
+      return FALSE;
+    }
+
+  for (child = gtk_widget_get_first_child (view);
+       child;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      if (!GTK_IS_LABEL (child))
+        {
+          g_print ("Skipping non-GtkLabel child\n");
+          continue;
+        }
+
+      name = gtk_label_get_label (GTK_LABEL (child));
+      constraint_view_add_child (CONSTRAINT_VIEW (self->view), name);
+    }
+
+  list = gtk_constraint_layout_observe_guides (GTK_CONSTRAINT_LAYOUT (layout));
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      GtkConstraintGuide *guide, *clone;
+      int w, h;
+
+      item = g_list_model_get_item (list, i);
+      guide = GTK_CONSTRAINT_GUIDE (item);
+
+      /* need to clone here, to attach to the right targets */
+      clone = gtk_constraint_guide_new ();
+      gtk_constraint_guide_set_name (clone, gtk_constraint_guide_get_name (guide));
+      gtk_constraint_guide_set_strength (clone, gtk_constraint_guide_get_strength (guide));
+      gtk_constraint_guide_get_min_size (guide, &w, &h);
+      gtk_constraint_guide_set_min_size (clone, w, h);
+      gtk_constraint_guide_get_nat_size (guide, &w, &h);
+      gtk_constraint_guide_set_nat_size (clone, w, h);
+      gtk_constraint_guide_get_max_size (guide, &w, &h);
+      gtk_constraint_guide_set_max_size (clone, w, h);
+      constraint_view_add_guide (CONSTRAINT_VIEW (self->view), clone);
+      g_object_unref (guide);
+      g_object_unref (clone);
+    }
+  g_object_unref (list);
+
+  list = gtk_constraint_layout_observe_constraints (GTK_CONSTRAINT_LAYOUT (layout));
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      GtkConstraint *constraint;
+      GtkConstraint *clone;
+      GtkConstraintTarget *target;
+      GtkConstraintTarget *source;
+
+      item = g_list_model_get_item (list, i);
+      constraint = GTK_CONSTRAINT (item);
+
+      target = gtk_constraint_get_target (constraint);
+      source = gtk_constraint_get_source (constraint);
+      clone = gtk_constraint_new (find_target (constraint_view_get_model (CONSTRAINT_VIEW (self->view)), target),
+                                  gtk_constraint_get_target_attribute (constraint),
+                                  gtk_constraint_get_relation (constraint),
+                                  find_target (constraint_view_get_model (CONSTRAINT_VIEW (self->view)), source),
+                                  gtk_constraint_get_target_attribute (constraint),
+                                  gtk_constraint_get_multiplier (constraint),
+                                  gtk_constraint_get_constant (constraint),
+                                  gtk_constraint_get_strength (constraint));
+
+      constraint_view_add_constraint (CONSTRAINT_VIEW (self->view), clone);
+
+      g_object_unref (constraint);
+      g_object_unref (clone);
+    }
+  g_object_unref (list);
+
+  g_free (path);
+  g_object_unref (builder);
+
+  return TRUE;
+}
+
+static void
+open_response_cb (GtkNativeDialog        *dialog,
+                  gint                    response,
+                  ConstraintEditorWindow *self)
+{
+  gtk_native_dialog_hide (dialog);
+
+  if (response == GTK_RESPONSE_ACCEPT)
+    {
+      GFile *file;
+
+      file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
+      constraint_editor_window_load (self, file);
+      g_object_unref (file);
+    }
+
+  gtk_native_dialog_destroy (dialog);
+}
+
+static void
+open_cb (GtkWidget              *button,
+         ConstraintEditorWindow *self)
+{
+  GtkFileChooserNative *dialog;
+
+  dialog = gtk_file_chooser_native_new ("Open file",
+                                        GTK_WINDOW (self),
+                                        GTK_FILE_CHOOSER_ACTION_OPEN,
+                                        "_Load",
+                                        "_Cancel");
+
+  gtk_native_dialog_set_modal (GTK_NATIVE_DIALOG (dialog), TRUE);
+  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), ".");
+  g_signal_connect (dialog, "response", G_CALLBACK (open_response_cb), self);
+  gtk_native_dialog_show (GTK_NATIVE_DIALOG (dialog));
+}
+
+static void
+serialize_child (GString   *str,
+                 int        indent,
+                 GtkWidget *child)
+{
+  const char *name;
+
+  name = gtk_widget_get_name (child);
+  g_string_append_printf (str, "%*s<child>\n", indent, "");
+  g_string_append_printf (str, "%*s  <object class=\"GtkLabel\" id=\"%s\">\n", indent, "", name);
+  g_string_append_printf (str, "%*s    <property name=\"label\">%s</property>\n", indent, "", name);
+  g_string_append_printf (str, "%*s  </object>\n", indent, "");
+  g_string_append_printf (str, "%*s</child>\n", indent, "");
+}
+
+static char *
+serialize_model (GListModel *list)
+{
+  GString *str = g_string_new ("");
+  int i;
+
+  g_string_append (str, "<interface>\n");
+  g_string_append (str, "  <object class=\"GtkBox\" id=\"view\">\n");
+  g_string_append (str, "    <property name=\"layout-manager\">\n");
+  g_string_append (str, "      <object class=\"GtkConstraintLayout\">\n");
+  g_string_append (str, "        <constraints>\n");
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      gpointer item = g_list_model_get_item (list, i);
+      g_object_unref (item);
+      if (GTK_IS_CONSTRAINT (item))
+        constraint_editor_serialize_constraint (str, 10, GTK_CONSTRAINT (item));
+      else if (GTK_IS_CONSTRAINT_GUIDE (item))
+        guide_editor_serialize_guide (str, 10, GTK_CONSTRAINT_GUIDE (item));
+    }
+  g_string_append (str, "        </constraints>\n");
+  g_string_append (str, "      </object>\n");
+  g_string_append (str, "    </property>\n");
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      gpointer item = g_list_model_get_item (list, i);
+      g_object_unref (item);
+      if (GTK_IS_WIDGET (item))
+        serialize_child (str, 4, GTK_WIDGET (item));
+    }
+  g_string_append (str, "  </object>\n");
+  g_string_append (str, "</interface>\n");
+
+  return g_string_free (str, FALSE);
+}
+
+
+static void
+save_response_cb (GtkNativeDialog        *dialog,
+                  gint                    response,
+                  ConstraintEditorWindow *self)
+{
+  gtk_native_dialog_hide (dialog);
+
+  if (response == GTK_RESPONSE_ACCEPT)
+    {
+      GListModel *model;
+      char *text, *filename;
+      GError *error = NULL;
+
+      model = constraint_view_get_model (CONSTRAINT_VIEW (self->view));
+      text = serialize_model (model);
+
+      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+      if (!g_file_set_contents (filename, text, -1, &error))
+        {
+          GtkWidget *dialog;
+
+          dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (self))),
+                                           GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
+                                           GTK_MESSAGE_INFO,
+                                           GTK_BUTTONS_OK,
+                                           "Saving failed");
+          gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+                                                    "%s", error->message);
+          g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
+          gtk_widget_show (dialog);
+          g_error_free (error);
+        }
+      g_free (filename);
+    }
+
+  gtk_native_dialog_destroy (dialog);
+}
+
+static void
+save_cb (GtkWidget              *button,
+         ConstraintEditorWindow *self)
+{
+  GtkFileChooserNative *dialog;
+
+  dialog = gtk_file_chooser_native_new ("Save constraints",
+                                        GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (button))),
+                                        GTK_FILE_CHOOSER_ACTION_SAVE,
+                                        "_Save",
+                                        "_Cancel");
+
+  gtk_native_dialog_set_modal (GTK_NATIVE_DIALOG (dialog), TRUE);
+  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), ".");
+  g_signal_connect (dialog, "response", G_CALLBACK (save_response_cb), self);
+  gtk_native_dialog_show (GTK_NATIVE_DIALOG (dialog));
+}
+
+static void
+constraint_editor_window_finalize (GObject *object)
+{
+  //ConstraintEditorWindow *self = (ConstraintEditorWindow *)object;
+
+  G_OBJECT_CLASS (constraint_editor_window_parent_class)->finalize (object);
+}
+
+static int child_counter;
+static int guide_counter;
+
+static void
+add_child (ConstraintEditorWindow *win)
+{
+  char *name;
+
+  child_counter++;
+  name = g_strdup_printf ("Child %d", child_counter);
+  constraint_view_add_child (CONSTRAINT_VIEW (win->view), name);
+  g_free (name);
+}
+
+static void
+add_guide (ConstraintEditorWindow *win)
+{
+  char *name;
+  GtkConstraintGuide *guide;
+
+  guide_counter++;
+  name = g_strdup_printf ("Guide %d", guide_counter);
+  guide = gtk_constraint_guide_new ();
+  gtk_constraint_guide_set_name (guide, name);
+  g_free (name);
+
+  constraint_view_add_guide (CONSTRAINT_VIEW (win->view), guide);
+}
+
+static void
+constraint_editor_done (ConstraintEditor *editor,
+                        GtkConstraint    *constraint,
+                        ConstraintEditorWindow *win)
+{
+  GtkConstraint *old_constraint;
+
+  g_object_get (editor, "constraint", &old_constraint, NULL);
+
+  if (old_constraint)
+    constraint_view_remove_constraint (CONSTRAINT_VIEW (win->view), old_constraint);
+
+  constraint_view_add_constraint (CONSTRAINT_VIEW (win->view), constraint);
+
+  g_clear_object (&old_constraint);
+
+  gtk_widget_destroy (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW));
+}
+
+static void
+edit_constraint (ConstraintEditorWindow *win,
+                 GtkConstraint          *constraint)
+{
+  GtkWidget *window;
+  ConstraintEditor *editor;
+  GListModel *model;
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (win));
+  gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+  if (constraint)
+    gtk_window_set_title (GTK_WINDOW (window), "Edit Constraint");
+  else
+    gtk_window_set_title (GTK_WINDOW (window), "Create Constraint");
+
+  model = constraint_view_get_model (CONSTRAINT_VIEW (win->view));
+
+  editor = constraint_editor_new (model, constraint);
+
+  gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (editor));
+
+  g_signal_connect (editor, "done", G_CALLBACK (constraint_editor_done), win);
+
+  gtk_widget_show (window);
+}
+
+static void
+add_constraint (ConstraintEditorWindow *win)
+{
+  edit_constraint (win, NULL);
+}
+
+static void
+guide_editor_done (GuideEditor            *editor,
+                   GtkConstraintGuide     *guide,
+                   ConstraintEditorWindow *win)
+{
+  gtk_widget_destroy (gtk_widget_get_ancestor (GTK_WIDGET (editor), GTK_TYPE_WINDOW));
+}
+
+static void
+edit_guide (ConstraintEditorWindow *win,
+            GtkConstraintGuide     *guide)
+{
+  GtkWidget *window;
+  GuideEditor *editor;
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+  gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (win));
+  gtk_window_set_title (GTK_WINDOW (window), "Edit Guide");
+
+  editor = guide_editor_new (guide);
+  gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (editor));
+
+  g_signal_connect (editor, "done", G_CALLBACK (guide_editor_done), win);
+  gtk_widget_show (window);
+}
+
+static void
+row_activated (GtkListBox *list,
+               GtkListBoxRow *row,
+               ConstraintEditorWindow *win)
+{
+  GObject *item;
+
+  item = G_OBJECT (g_object_get_data (G_OBJECT (row), "item"));
+
+  if (GTK_IS_CONSTRAINT (item))
+    edit_constraint (win, GTK_CONSTRAINT (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    edit_guide (win, GTK_CONSTRAINT_GUIDE (item));
+}
+
+static void
+constraint_editor_window_class_init (ConstraintEditorWindowClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  g_type_ensure (CONSTRAINT_VIEW_TYPE);
+
+  object_class->finalize = constraint_editor_window_finalize;
+
+  gtk_widget_class_set_template_from_resource (widget_class,
+                                               "/org/gtk/gtk4/constraint-editor/constraint-editor-window.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditorWindow, paned);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditorWindow, view);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditorWindow, list);
+
+  gtk_widget_class_bind_template_callback (widget_class, open_cb);
+  gtk_widget_class_bind_template_callback (widget_class, save_cb);
+  gtk_widget_class_bind_template_callback (widget_class, add_child);
+  gtk_widget_class_bind_template_callback (widget_class, add_guide);
+  gtk_widget_class_bind_template_callback (widget_class, add_constraint);
+  gtk_widget_class_bind_template_callback (widget_class, row_activated);
+}
+
+static void
+row_edit (GtkButton *button,
+          ConstraintEditorWindow *win)
+{
+  GtkWidget *row;
+  GObject *item;
+
+  row = gtk_widget_get_ancestor (GTK_WIDGET (button), GTK_TYPE_LIST_BOX_ROW);
+  item = (GObject *)g_object_get_data (G_OBJECT (row), "item");
+  if (GTK_IS_CONSTRAINT (item))
+    edit_constraint (win, GTK_CONSTRAINT (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    edit_guide (win, GTK_CONSTRAINT_GUIDE (item));
+}
+
+static void
+mark_constraints_invalid (ConstraintEditorWindow *win,
+                          gpointer                removed)
+{
+  GtkWidget *child;
+  GObject *item;
+
+  for (child = gtk_widget_get_first_child (win->list);
+       child;
+       child = gtk_widget_get_next_sibling (child))
+    {
+      item = (GObject *)g_object_get_data (G_OBJECT (child), "item");
+      if (GTK_IS_CONSTRAINT (item))
+        {
+          GtkConstraint *constraint = GTK_CONSTRAINT (item);
+
+          if (gtk_constraint_get_target (constraint) == (GtkConstraintTarget *)removed ||
+              gtk_constraint_get_source (constraint) == (GtkConstraintTarget *)removed)
+            {
+              GtkWidget *button;
+              button = (GtkWidget *)g_object_get_data (G_OBJECT (child), "edit");
+              gtk_button_set_icon_name (GTK_BUTTON (button), "dialog-warning-symbolic");
+              gtk_widget_set_tooltip_text (button, "Constraint is invalid");
+            }
+        }
+    }
+}
+
+static void
+row_delete (GtkButton *button,
+            ConstraintEditorWindow *win)
+{
+  GtkWidget *row;
+  GObject *item;
+
+  row = gtk_widget_get_ancestor (GTK_WIDGET (button), GTK_TYPE_LIST_BOX_ROW);
+  item = (GObject *)g_object_get_data (G_OBJECT (row), "item");
+  if (GTK_IS_CONSTRAINT (item))
+    constraint_view_remove_constraint (CONSTRAINT_VIEW (win->view),
+                                       GTK_CONSTRAINT (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    {
+      mark_constraints_invalid (win, item);
+      constraint_view_remove_guide (CONSTRAINT_VIEW (win->view),
+                                    GTK_CONSTRAINT_GUIDE (item));
+    }
+  else if (GTK_IS_WIDGET (item))
+    {
+      mark_constraints_invalid (win, item);
+      constraint_view_remove_child (CONSTRAINT_VIEW (win->view),
+                                    GTK_WIDGET (item));
+    }
+}
+
+static GtkWidget *
+create_widget_func (gpointer item,
+                    gpointer user_data)
+{
+  ConstraintEditorWindow *win = user_data;
+  const char *name;
+  char *freeme = NULL;
+  GtkWidget *row, *box, *label, *button;
+
+  if (GTK_IS_WIDGET (item))
+    name = gtk_widget_get_name (GTK_WIDGET (item));
+  else if (GTK_IS_CONSTRAINT_GUIDE (item))
+    name = gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (item));
+  else if (GTK_IS_CONSTRAINT (item))
+    name = freeme = constraint_editor_constraint_to_string (GTK_CONSTRAINT (item));
+  else
+    name = "";
+
+  row = gtk_list_box_row_new ();
+  g_object_set_data_full (G_OBJECT (row), "item", g_object_ref (item), g_object_unref);
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  label = gtk_label_new (name);
+  if (GTK_IS_WIDGET (item) || GTK_IS_CONSTRAINT_GUIDE (item))
+    g_object_bind_property (item, "name",
+                            label, "label",
+                            G_BINDING_DEFAULT);
+  g_object_set (label, "margin", 10, NULL);
+  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+  gtk_widget_set_hexpand (label, TRUE);
+  gtk_container_add (GTK_CONTAINER (row), box);
+  gtk_container_add (GTK_CONTAINER (box), label);
+
+  if (GTK_IS_CONSTRAINT (item) || GTK_IS_CONSTRAINT_GUIDE (item))
+    {
+      button = gtk_button_new_from_icon_name ("document-edit-symbolic");
+      gtk_button_set_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_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_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+      g_signal_connect (button, "clicked", G_CALLBACK (row_delete), win);
+      gtk_container_add (GTK_CONTAINER (box), button);
+    }
+
+  g_free (freeme);
+
+  return row;
+}
+
+static void
+constraint_editor_window_init (ConstraintEditorWindow *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+
+  gtk_list_box_bind_model (GTK_LIST_BOX (self->list),
+                           constraint_view_get_model (CONSTRAINT_VIEW (self->view)),
+                           create_widget_func,
+                           self,
+                           NULL);
+}
+
+ConstraintEditorWindow *
+constraint_editor_window_new (ConstraintEditorApplication *application)
+{
+  return g_object_new (CONSTRAINT_EDITOR_WINDOW_TYPE,
+                       "application", application,
+                       NULL);
+}

demos/constraint-editor/constraint-editor-window.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#include "constraint-editor-application.h"
+
+
+#define CONSTRAINT_EDITOR_WINDOW_TYPE (constraint_editor_window_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintEditorWindow, constraint_editor_window, CONSTRAINT, EDITOR_WINDOW, GtkApplicationWindow)
+
+ConstraintEditorWindow * constraint_editor_window_new  (ConstraintEditorApplication  *application);
+
+gboolean                 constraint_editor_window_load (ConstraintEditorWindow       *self,
+                                                        GFile                        *file);

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

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="ConstraintEditorWindow" parent="GtkApplicationWindow">
+    <style>
+      <class name="devel"/>
+    </style>
+    <property name="title" translatable="yes">GTK Constraint Editor</property>
+    <property name="default-width">1024</property>
+    <property name="default-height">768</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar" id="header">
+        <property name="title" translatable="yes">GTK Constraint Editor</property>
+        <property name="show-title-buttons">1</property>
+        <child type="start">
+          <object class="GtkButton">
+            <property name="icon-name">document-open-symbolic</property>
+            <property name="tooltip-text">Open ui file</property>
+            <signal name="clicked" handler="open_cb"/>
+          </object>
+        </child>
+        <child type="start">
+          <object class="GtkButton">
+            <property name="icon-name">document-save-symbolic</property>
+            <property name="tooltip-text">Save to ui file</property>
+            <signal name="clicked" handler="save_cb"/>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkPaned" id="paned">
+        <property name="orientation">horizontal</property>
+        <child>
+          <object class="GtkBox">
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkBox">
+                <property name="orientation">horizontal</property>
+                <child>
+                  <object class="GtkButton">
+                    <property name="label">Add Child</property>
+                    <signal name="clicked" handler="add_child" swapped="yes"/>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkButton">
+                    <property name="label">Add Guide</property>
+                    <signal name="clicked" handler="add_guide" swapped="yes"/>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkButton">
+                    <property name="label">Add Constraint</property>
+                    <signal name="clicked" handler="add_constraint" swapped="yes"/>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow">
+                <property name="hscrollbar-policy">never</property>
+                <property name="vscrollbar-policy">automatic</property>
+                <property name="vexpand">1</property>
+                <child>
+                  <object class="GtkListBox" id="list">
+                    <property name="show-separators">1</property>
+                    <property name="selection-mode">none</property>
+                    <signal name="row-activated" handler="row_activated"/>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="ConstraintView" id="view">
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>

demos/constraint-editor/constraint-editor.c

@@ -0,0 +1,656 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "constraint-editor.h"
+
+struct _ConstraintEditor
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *grid;
+  GtkWidget *target;
+  GtkWidget *target_attr;
+  GtkWidget *relation;
+  GtkWidget *source;
+  GtkWidget *source_attr;
+  GtkWidget *multiplier;
+  GtkWidget *constant;
+  GtkWidget *strength;
+  GtkWidget *preview;
+  GtkWidget *button;
+
+  GtkConstraint *constraint;
+  GListModel *model;
+
+  gboolean constructed;
+};
+
+enum {
+  PROP_MODEL = 1,
+  PROP_CONSTRAINT,
+  LAST_PROP
+};
+
+static GParamSpec *pspecs[LAST_PROP];
+
+enum {
+  DONE,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+G_DEFINE_TYPE(ConstraintEditor, constraint_editor, GTK_TYPE_WIDGET);
+
+static const char *
+get_target_name (GtkConstraintTarget *target)
+{
+  if (target == NULL)
+    return "super";
+  else if (GTK_IS_WIDGET (target))
+    return gtk_widget_get_name (GTK_WIDGET (target));
+  else if (GTK_IS_CONSTRAINT_GUIDE (target))
+    return gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (target));
+  else
+    return "";
+}
+
+static void
+constraint_target_combo (GListModel *model,
+                         GtkWidget  *combo,
+                         gboolean    is_source)
+{
+  int i;
+
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "super", "Super");
+
+  if (model)
+    {
+      for (i = 0; i < g_list_model_get_n_items (model); i++)
+        {
+          GObject *item = g_list_model_get_object (model, i);
+          const char *name;
+
+          if (GTK_IS_CONSTRAINT (item))
+            continue;
+
+          name = get_target_name (GTK_CONSTRAINT_TARGET (item));
+
+          gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), name, name);
+          g_object_unref (item);
+        }
+    }
+}
+
+static void
+constraint_attribute_combo (GtkWidget *combo,
+                            gboolean is_source)
+{
+  if (is_source)
+    gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "none", "None");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "left", "Left");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "right", "Right");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "top", "Top");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "bottom", "Bottom");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "width", "Width");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "height", "Height");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center-x", "Center X");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center-y", "Center Y");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "baseline", "Baseline");
+}
+
+static void
+constraint_relation_combo (GtkWidget *combo)
+{
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "le", "≤");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "eq", "=");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "ge", "≥");
+}
+
+static void
+constraint_strength_combo (GtkWidget *combo)
+{
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "weak", "Weak");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "medium", "Medium");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "strong", "Strong");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "required", "Required");
+}
+
+static gpointer
+get_target (GListModel *model,
+            const char *id)
+{
+  int i;
+
+  if (strcmp ("super", id) == 0)
+    return NULL;
+
+  for (i = 0; i < g_list_model_get_n_items (model); i++)
+    {
+      GObject *item = g_list_model_get_object (model, i);
+      g_object_unref (item);
+      if (GTK_IS_CONSTRAINT (item))
+        continue;
+      else if (GTK_IS_WIDGET (item))
+        {
+          if (strcmp (id, gtk_widget_get_name (GTK_WIDGET (item))) == 0)
+            return item;
+        }
+      else if (GTK_IS_CONSTRAINT_GUIDE (item))
+        {
+          if (strcmp (id, gtk_constraint_guide_get_name (GTK_CONSTRAINT_GUIDE (item))) == 0)
+            return item;
+        }
+    }
+
+  return NULL;
+}
+
+static GtkConstraintAttribute
+get_target_attr (const char *id)
+{
+  GtkConstraintAttribute attr;
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_ATTRIBUTE);
+  GEnumValue *value = g_enum_get_value_by_nick (class, id);
+  attr = value->value;
+  g_type_class_unref (class);
+
+  return attr;
+}
+
+static const char *
+get_attr_nick (GtkConstraintAttribute attr)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_ATTRIBUTE);
+  GEnumValue *value = g_enum_get_value (class, attr);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+static GtkConstraintRelation
+get_relation (const char *id)
+{
+  GtkConstraintRelation relation;
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_RELATION);
+  GEnumValue *value = g_enum_get_value_by_nick (class, id);
+  relation = value->value;
+  g_type_class_unref (class);
+
+  return relation;
+}
+
+static const char *
+get_relation_nick (GtkConstraintRelation relation)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_RELATION);
+  GEnumValue *value = g_enum_get_value (class, relation);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+static GtkConstraintStrength
+get_strength (const char *id)
+{
+  GtkConstraintStrength strength;
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_STRENGTH);
+  GEnumValue *value = g_enum_get_value_by_nick (class, id);
+  strength = value->value;
+  g_type_class_unref (class);
+
+  return strength;
+}
+
+static const char *
+get_strength_nick (GtkConstraintStrength strength)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_STRENGTH);
+  GEnumValue *value = g_enum_get_value (class, strength);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+void
+constraint_editor_serialize_constraint (GString       *str,
+                                        int            indent,
+                                        GtkConstraint *constraint)
+{
+  const char *target;
+  const char *target_attr;
+  const char *relation;
+  const char *source;
+  const char *source_attr;
+  double multiplier;
+  double constant;
+  const char *strength;
+
+  target = get_target_name (gtk_constraint_get_target (constraint));
+  target_attr = get_attr_nick (gtk_constraint_get_target_attribute (constraint));
+  relation = get_relation_nick (gtk_constraint_get_relation (constraint));
+  source = get_target_name (gtk_constraint_get_source (constraint));
+  source_attr = get_attr_nick (gtk_constraint_get_source_attribute (constraint));
+  multiplier = gtk_constraint_get_multiplier (constraint);
+  constant = gtk_constraint_get_constant (constraint);
+  strength = get_strength_nick (gtk_constraint_get_strength (constraint));
+
+  g_string_append_printf (str, "%*s<constraint target=\"%s\" target-attribute=\"%s\"\n", indent, "", target, target_attr);
+  g_string_append_printf (str, "%*s            relation=\"%s\"\n", indent, "", relation);
+  if (strcmp (source_attr, "none") != 0)
+    {
+      g_string_append_printf (str, "%*s            source=\"%s\" source-attribute=\"%s\"\n", indent, "", source, source_attr);
+      g_string_append_printf (str, "%*s            multiplier=\"%g\"\n", indent, "", multiplier);
+    }
+  g_string_append_printf (str, "%*s            constant=\"%g\"\n", indent, "", constant);
+  g_string_append_printf (str, "%*s            strength=\"%s\" />\n", indent, "", strength);
+}
+
+static void
+create_constraint (GtkButton        *button,
+                   ConstraintEditor *editor)
+{
+  const char *id;
+  gpointer target;
+  GtkConstraintAttribute target_attr;
+  gpointer source;
+  GtkConstraintAttribute source_attr;
+  GtkConstraintRelation relation;
+  double multiplier;
+  double constant;
+  int strength;
+  GtkConstraint *constraint;
+
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->target));
+  target = get_target (editor->model, id);
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->target_attr));
+  target_attr = get_target_attr (id);
+
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->source));
+  source = get_target (editor->model, id);
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->source_attr));
+  source_attr = get_target_attr (id);
+
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->relation));
+  relation = get_relation (id);
+
+  multiplier = g_ascii_strtod (gtk_editable_get_text (GTK_EDITABLE (editor->multiplier)), NULL);
+
+  constant = g_ascii_strtod (gtk_editable_get_text (GTK_EDITABLE (editor->constant)), NULL);
+
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->strength));
+  strength = get_strength (id);
+
+  constraint = gtk_constraint_new (target, target_attr,
+                                   relation,
+                                   source, source_attr,
+                                   multiplier,
+                                   constant,
+                                   strength);
+  g_signal_emit (editor, signals[DONE], 0, constraint);
+  g_object_unref (constraint);
+}
+
+static void
+source_attr_changed (ConstraintEditor *editor)
+{
+  const char *id;
+
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->source_attr));
+  if (strcmp (id, "none") == 0)
+    {
+      gtk_combo_box_set_active (GTK_COMBO_BOX (editor->source), -1);
+      gtk_editable_set_text (GTK_EDITABLE (editor->multiplier), "");
+      gtk_widget_set_sensitive (editor->source, FALSE);
+      gtk_widget_set_sensitive (editor->multiplier, FALSE);
+    }
+  else
+    {
+      gtk_widget_set_sensitive (editor->source, TRUE);
+      gtk_widget_set_sensitive (editor->multiplier, TRUE);
+    }
+}
+
+char *
+constraint_editor_constraint_to_string (GtkConstraint *constraint)
+{
+  GString *str;
+  const char *name;
+  const char *attr;
+  const char *relation;
+  double c, m;
+
+  str = g_string_new ("");
+
+  name = get_target_name (gtk_constraint_get_target (constraint));
+  attr = get_attr_nick (gtk_constraint_get_target_attribute (constraint));
+  relation = get_relation_nick (gtk_constraint_get_relation (constraint));
+
+  if (name == NULL)
+    name = "[ ]";
+
+  g_string_append_printf (str, "%s.%s %s ", name, attr, relation);
+
+  c = gtk_constraint_get_constant (constraint);
+
+  attr = get_attr_nick (gtk_constraint_get_source_attribute (constraint));
+  if (strcmp (attr, "none") != 0)
+    {
+      name = get_target_name (gtk_constraint_get_source (constraint));
+      m = gtk_constraint_get_multiplier (constraint);
+
+      if (name == NULL)
+        name = "[ ]";
+
+      g_string_append_printf (str, "%s.%s", name, attr);
+
+      if (m != 1.0)
+        g_string_append_printf (str, " × %g", m);
+
+      if (c > 0.0)
+        g_string_append_printf (str, " + %g", c);
+      else if (c < 0.0)
+        g_string_append_printf (str, " - %g", -c);
+    }
+  else
+    g_string_append_printf (str, "%g", c);
+
+  return g_string_free (str, FALSE);
+}
+
+static void
+update_preview (ConstraintEditor *editor)
+{
+  GString *str;
+  const char *name;
+  const char *attr;
+  char *relation;
+  const char *multiplier;
+  const char *constant;
+  double c, m;
+
+  if (!editor->constructed)
+    return;
+
+  str = g_string_new ("");
+
+  name = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->target));
+  attr = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->target_attr));
+  relation = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (editor->relation));
+
+  if (name == NULL)
+    name = "[ ]";
+
+  g_string_append_printf (str, "%s.%s %s ", name, attr, relation);
+  g_free (relation);
+
+  constant = gtk_editable_get_text (GTK_EDITABLE (editor->constant));
+  c = g_ascii_strtod (constant, NULL);
+
+  attr = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->source_attr));
+  if (strcmp (attr, "none") != 0)
+    {
+      name = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->source));
+      multiplier = gtk_editable_get_text (GTK_EDITABLE (editor->multiplier));
+      m = g_ascii_strtod (multiplier, NULL);
+
+      if (name == NULL)
+        name = "[ ]";
+
+      g_string_append_printf (str, "%s.%s", name, attr);
+
+      if (m != 1.0)
+        g_string_append_printf (str, " × %g", m);
+
+      if (c > 0.0)
+        g_string_append_printf (str, " + %g", c);
+      else if (c < 0.0)
+        g_string_append_printf (str, " - %g", -c);
+    }
+  else
+    g_string_append_printf (str, "%g", c);
+
+  gtk_label_set_label (GTK_LABEL (editor->preview), str->str);
+
+  g_string_free (str, TRUE);
+}
+
+static void
+update_button (ConstraintEditor *editor)
+{
+  if (gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->target)) != NULL &&
+      gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->source)) != NULL)
+    gtk_widget_set_sensitive (editor->button, TRUE);
+  else
+    gtk_widget_set_sensitive (editor->button, FALSE);
+}
+
+static void
+constraint_editor_init (ConstraintEditor *editor)
+{
+  gtk_widget_init_template (GTK_WIDGET (editor));
+}
+
+static void
+constraint_editor_constructed (GObject *object)
+{
+  ConstraintEditor *editor = CONSTRAINT_EDITOR (object);
+
+  constraint_target_combo (editor->model, editor->target, FALSE);
+  constraint_attribute_combo (editor->target_attr, FALSE);
+  constraint_relation_combo (editor->relation);
+  constraint_target_combo (editor->model, editor->source, TRUE);
+  constraint_attribute_combo (editor->source_attr, TRUE);
+
+  constraint_strength_combo (editor->strength);
+
+  if (editor->constraint)
+    {
+      GtkConstraintTarget *target;
+      GtkConstraintAttribute attr;
+      GtkConstraintRelation relation;
+      GtkConstraintStrength strength;
+      const char *nick;
+      char *val;
+      double multiplier;
+      double constant;
+
+      target = gtk_constraint_get_target (editor->constraint);
+      nick = get_target_name (target);
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->target), nick);
+
+      attr = gtk_constraint_get_target_attribute (editor->constraint);
+      nick = get_attr_nick (attr);
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->target_attr), nick);
+
+      target = gtk_constraint_get_source (editor->constraint);
+      nick = get_target_name (target);
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->source), nick);
+
+      attr = gtk_constraint_get_source_attribute (editor->constraint);
+      nick = get_attr_nick (attr);
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->source_attr), nick);
+
+      relation = gtk_constraint_get_relation (editor->constraint);
+      nick = get_relation_nick (relation);
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->relation), nick);
+
+      multiplier = gtk_constraint_get_multiplier (editor->constraint);
+      val = g_strdup_printf ("%g", multiplier);
+      gtk_editable_set_text (GTK_EDITABLE (editor->multiplier), val);
+      g_free (val);
+
+      constant = gtk_constraint_get_constant (editor->constraint);
+      val = g_strdup_printf ("%g", constant);
+      gtk_editable_set_text (GTK_EDITABLE (editor->constant), val);
+      g_free (val);
+
+      strength = gtk_constraint_get_strength (editor->constraint);
+      nick = get_strength_nick (strength);
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->strength), nick);
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Apply");
+    }
+  else
+    {
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->target_attr), "left");
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->source_attr), "left");
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->relation), "eq");
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->strength), "required");
+
+      gtk_editable_set_text (GTK_EDITABLE (editor->multiplier), "1.0");
+      gtk_editable_set_text (GTK_EDITABLE (editor->constant), "0.0");
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Create");
+    }
+
+  editor->constructed = TRUE;
+  update_preview (editor);
+  update_button (editor);
+}
+
+static void
+constraint_editor_set_property (GObject      *object,
+                                guint         property_id,
+                                const GValue *value,
+                                GParamSpec   *pspec)
+{
+  ConstraintEditor *self = CONSTRAINT_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_MODEL:
+      self->model = g_value_dup_object (value);
+      break;
+
+    case PROP_CONSTRAINT:
+      self->constraint = g_value_dup_object (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+constraint_editor_get_property (GObject    *object,
+                                guint       property_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
+{
+  ConstraintEditor *self = CONSTRAINT_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_MODEL:
+      g_value_set_object (value, self->model);
+      break;
+
+    case PROP_CONSTRAINT:
+      g_value_set_object (value, self->constraint);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+constraint_editor_dispose (GObject *object)
+{
+  ConstraintEditor *self = (ConstraintEditor *)object;
+
+  g_clear_pointer (&self->grid, gtk_widget_unparent);
+  g_clear_object (&self->model);
+  g_clear_object (&self->constraint);
+
+  G_OBJECT_CLASS (constraint_editor_parent_class)->dispose (object);
+}
+
+static void
+constraint_editor_class_init (ConstraintEditorClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->constructed = constraint_editor_constructed;
+  object_class->dispose = constraint_editor_dispose;
+  object_class->set_property = constraint_editor_set_property;
+  object_class->get_property = constraint_editor_get_property;
+
+  pspecs[PROP_CONSTRAINT] =
+    g_param_spec_object ("constraint", "constraint", "constraint",
+                         GTK_TYPE_CONSTRAINT,
+                         G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
+
+  pspecs[PROP_MODEL] =
+    g_param_spec_object ("model", "model", "model",
+                         G_TYPE_LIST_MODEL,
+                         G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, LAST_PROP, pspecs);
+
+  signals[DONE] =
+    g_signal_new ("done",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE, 1, GTK_TYPE_CONSTRAINT);
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+
+  gtk_widget_class_set_template_from_resource (widget_class,
+                                               "/org/gtk/gtk4/constraint-editor/constraint-editor.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, grid);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, target);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, target_attr);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, relation);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, source);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, source_attr);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, multiplier);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, constant);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, strength);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, preview);
+  gtk_widget_class_bind_template_child (widget_class, ConstraintEditor, button);
+
+  gtk_widget_class_bind_template_callback (widget_class, update_preview);
+  gtk_widget_class_bind_template_callback (widget_class, update_button);
+  gtk_widget_class_bind_template_callback (widget_class, create_constraint);
+  gtk_widget_class_bind_template_callback (widget_class, source_attr_changed);
+}
+
+ConstraintEditor *
+constraint_editor_new (GListModel    *model,
+                       GtkConstraint *constraint)
+{
+  return g_object_new (CONSTRAINT_EDITOR_TYPE,
+                       "model", model,
+                       "constraint", constraint,
+                       NULL);
+}

demos/constraint-editor/constraint-editor.css

@@ -0,0 +1,12 @@
+constraintview {
+  background: black;
+  color: white;
+}
+
+constraintview .child {
+  background: red;
+}
+
+constraintview .guide {
+  background: blue;
+}

demos/constraint-editor/constraint-editor.gresource.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gtk/gtk4/constraint-editor">
+    <file preprocess="xml-stripblanks">constraint-editor-window.ui</file>
+    <file preprocess="xml-stripblanks">constraint-editor.ui</file>
+    <file preprocess="xml-stripblanks">guide-editor.ui</file>
+    <file>constraint-editor.css</file>
+  </gresource>
+</gresources>

demos/constraint-editor/constraint-editor.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define CONSTRAINT_EDITOR_TYPE (constraint_editor_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintEditor, constraint_editor, CONSTRAINT, EDITOR, GtkWidget)
+
+ConstraintEditor * constraint_editor_new (GListModel    *model,
+                                          GtkConstraint *constraint);
+
+void constraint_editor_serialize_constraint (GString       *str,
+                                             int            indent,
+                                             GtkConstraint *constraint);
+char *constraint_editor_constraint_to_string (GtkConstraint *constraint);

demos/constraint-editor/constraint-editor.ui

@@ -0,0 +1,163 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="ConstraintEditor" parent="GtkWidget">
+    <child>
+      <object class="GtkGrid" id="grid">
+        <property name="margin">20</property>
+        <property name="row-spacing">10</property>
+        <property name="column-spacing">10</property>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Target</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="target">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <signal name="changed" handler="update_button" swapped="yes"/>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="target_attr">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <layout>
+              <property name="left-attach">2</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Relation</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="relation">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Source</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="source">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <signal name="changed" handler="update_button" swapped="yes"/>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="source_attr">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <signal name="changed" handler="source_attr_changed" swapped="yes"/>
+            <layout>
+              <property name="left-attach">2</property>
+              <property name="top-attach">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Multiplier</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">4</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkEntry" id="multiplier">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">4</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Constant</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">5</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkEntry" id="constant">
+            <signal name="changed" handler="update_preview" swapped="yes"/>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">5</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Strength</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">6</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="strength">
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">6</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel" id="preview">
+            <property name="xalign">0</property>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">7</property>
+              <property name="column-span">2</property>
+            </layout>
+            <attributes>
+              <attribute name="scale" value="1.44"/>
+            </attributes>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="button">
+            <property name="label">Create</property>
+            <signal name="clicked" handler="create_constraint"/>
+            <layout>
+              <property name="left-attach">2</property>
+              <property name="top-attach">8</property>
+            </layout>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>

demos/constraint-editor/constraint-view-child.c

@@ -0,0 +1,93 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#include "constraint-view-child.h"
+
+struct _ConstraintViewChild
+{
+  GObject parent_instance;
+
+  char *name;
+};
+
+enum {
+  PROP_NAME = 1,
+  LAST_PROP
+};
+
+static GParamSpec props[LAST_PROP];
+
+G_DEFINE_TYPE (ConstraintViewChild, constraint_view_child, G_TYPE_OBJECT)
+
+static void
+constraint_view_child_init (ConstraintViewChild *child)
+{
+}
+
+static void
+constraint_view_child_finalize (GObject *object)
+{
+  ConstraintViewChild *child = CONSTRAINT_VIEW_CHILD (object);
+
+  g_free (child->name);
+
+  G_OBJECT_CLASS (constraint_view_child_parent_class)->finalize (object);
+}
+
+static void
+constraint_view_child_set_property (GObject *object,
+                                    
+static void
+constraint_view_child_class_init (ConstraintViewChildClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = constraint_view_child_finalize;
+  object_class->get_property = constraint_view_child_get_property;
+  object_class->set_property = constraint_view_child_set_property;
+
+  props[PROP_NAME] =
+    g_param_spec_string ("name", "name", "name",
+                         NULL,
+                         G_PARAM_READWRITE);
+
+  g_object_class_install_properties (object_class, LAST_PROP, props);
+}
+
+#define CONSTRAINT_VIEW_CHILD_TYPE (constraint_view_get_type ())
+
+G_DECLARE_TYPE (ConstraintViewChild, constraint_view_child, CONSTRAINT, VIEW_CHILD, GObject)
+
+#define CONSTRAINT_VIEW_WIDGET_TYPE (constraint_view_widget_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewWidget, constraint_view_widget, CONSTRAINT, VIEW_WIDGET, ConstraintViewChild)
+
+ConstraintViewWidget * constraint_view_widget_new (void);
+
+#define CONSTRAINT_VIEW_GUIDE_TYPE (constraint_view_guide_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewGuide, constraint_view_guide, CONSTRAINT, VIEW_GUIDE, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_guide_new (void);
+
+#define CONSTRAINT_VIEW_CONSTRAINT_TYPE (constraint_view_constraint_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewConstraint, constraint_view_constraint, CONSTRAINT, VIEW_CONSTRAINT, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_constraint_new (void);

demos/constraint-editor/constraint-view-child.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define CONSTRAINT_VIEW_CHILD_TYPE (constraint_view_get_type ())
+
+G_DECLARE_TYPE (ConstraintViewChild, constraint_view_child, CONSTRAINT, VIEW_CHILD, GObject)
+
+#define CONSTRAINT_VIEW_WIDGET_TYPE (constraint_view_widget_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewWidget, constraint_view_widget, CONSTRAINT, VIEW_WIDGET, ConstraintViewChild)
+
+ConstraintViewWidget * constraint_view_widget_new (void);
+
+#define CONSTRAINT_VIEW_GUIDE_TYPE (constraint_view_guide_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewGuide, constraint_view_guide, CONSTRAINT, VIEW_GUIDE, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_guide_new (void);
+
+#define CONSTRAINT_VIEW_CONSTRAINT_TYPE (constraint_view_constraint_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintViewConstraint, constraint_view_constraint, CONSTRAINT, VIEW_CONSTRAINT, ConstraintViewChild)
+
+ConstraintViewGuide * constraint_view_constraint_new (void);

demos/constraint-editor/constraint-view.c

@@ -0,0 +1,343 @@
+/* Copyright (C) 2019 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtk/gtk.h>
+#include "constraint-view.h"
+
+struct _ConstraintView
+{
+  GtkWidget parent;
+
+  GListModel *model;
+
+  GtkWidget *drag_widget;
+};
+
+G_DEFINE_TYPE (ConstraintView, constraint_view, GTK_TYPE_WIDGET);
+
+static void
+constraint_view_dispose (GObject *object)
+{
+  ConstraintView *view = CONSTRAINT_VIEW (object);
+  GtkWidget *child;
+
+  while ((child = gtk_widget_get_first_child (GTK_WIDGET (view))) != NULL)
+    gtk_widget_unparent (child);
+
+  g_clear_object (&view->model);
+
+  G_OBJECT_CLASS (constraint_view_parent_class)->dispose (object);
+}
+
+static void
+constraint_view_class_init (ConstraintViewClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  object_class->dispose = constraint_view_dispose;
+
+  gtk_widget_class_set_css_name (widget_class, "constraintview");
+}
+
+static void
+update_weak_position (ConstraintView *self,
+                      GtkWidget      *child,
+                      double          x,
+                      double          y)
+{
+  GtkLayoutManager *manager;
+  GtkConstraint *constraint;
+
+  manager = gtk_widget_get_layout_manager (GTK_WIDGET (self));
+  constraint = (GtkConstraint *)g_object_get_data (G_OBJECT (child), "x-constraint");
+  if (constraint)
+    {
+      gtk_constraint_layout_remove_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                               constraint);
+      g_object_set_data (G_OBJECT (child), "x-constraint", NULL);
+    }
+  if (x != -100)
+    {
+      constraint = gtk_constraint_new_constant (child,
+                                                GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
+                                                GTK_CONSTRAINT_RELATION_EQ,
+                                                x,
+                                                GTK_CONSTRAINT_STRENGTH_WEAK);
+      g_object_set_data (G_OBJECT (constraint), "internal", "yes");
+      gtk_constraint_layout_add_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                            constraint);
+      g_object_set_data (G_OBJECT (child), "x-constraint", constraint);
+    }
+
+  constraint = (GtkConstraint *)g_object_get_data (G_OBJECT (child), "y-constraint");
+  if (constraint)
+    {
+      gtk_constraint_layout_remove_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                                   constraint);
+      g_object_set_data (G_OBJECT (child), "y-constraint", NULL);
+    }
+  if (y != -100)
+    {
+      constraint = gtk_constraint_new_constant (child,
+                                                GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
+                                                GTK_CONSTRAINT_RELATION_EQ,
+                                                y,
+                                                GTK_CONSTRAINT_STRENGTH_WEAK);
+      g_object_set_data (G_OBJECT (constraint), "internal", "yes");
+      gtk_constraint_layout_add_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                            constraint);
+      g_object_set_data (G_OBJECT (child), "y-constraint", constraint);
+    }
+}
+
+static void
+drag_begin (GtkGestureDrag *drag,
+            double          start_x,
+            double          start_y,
+            ConstraintView *self)
+{
+  GtkWidget *widget;
+
+  widget = gtk_widget_pick (GTK_WIDGET (self), start_x, start_y, GTK_PICK_DEFAULT);
+
+  if (GTK_IS_LABEL (widget))
+    {
+      widget = gtk_widget_get_ancestor (widget, GTK_TYPE_FRAME);
+      if (widget &&
+          gtk_widget_get_parent (widget) == (GtkWidget *)self)
+        {
+          self->drag_widget = widget;
+        }
+    }
+}
+
+static void
+drag_update (GtkGestureDrag *drag,
+             double          offset_x,
+             double          offset_y,
+             ConstraintView *self)
+{
+  double x, y;
+
+  if (!self->drag_widget)
+    return;
+
+  gtk_gesture_drag_get_start_point (drag, &x, &y);
+  update_weak_position (self, self->drag_widget, x + offset_x, y + offset_y);
+}
+
+static void
+drag_end (GtkGestureDrag *drag,
+          double          offset_x,
+          double          offset_y,
+          ConstraintView *self)
+{
+  self->drag_widget = NULL;
+}
+
+static gboolean
+omit_internal (gpointer item, gpointer user_data)
+{
+  if (g_object_get_data (G_OBJECT (item), "internal"))
+    return FALSE;
+
+  return TRUE;
+}
+
+static void
+constraint_view_init (ConstraintView *self)
+{
+  GtkLayoutManager *manager;
+  GtkEventController *controller;
+  GListStore *list;
+  GListModel *all_children;
+  GListModel *all_constraints;
+  GListModel *guides;
+  GListModel *children;
+  GListModel *constraints;
+
+  manager = gtk_constraint_layout_new ();
+  gtk_widget_set_layout_manager (GTK_WIDGET (self), manager);
+
+  all_children = gtk_widget_observe_children (GTK_WIDGET (self));
+  all_constraints = gtk_constraint_layout_observe_constraints (GTK_CONSTRAINT_LAYOUT (manager));
+  guides = gtk_constraint_layout_observe_guides (GTK_CONSTRAINT_LAYOUT (manager));
+  constraints = (GListModel *)gtk_filter_list_model_new (all_constraints, omit_internal, NULL, NULL);
+  children = (GListModel *)gtk_filter_list_model_new (all_children, omit_internal, NULL, NULL);
+
+  list = g_list_store_new (G_TYPE_LIST_MODEL);
+  g_list_store_append (list, children);
+  g_list_store_append (list, guides);
+  g_list_store_append (list, constraints);
+  self->model = G_LIST_MODEL (gtk_flatten_list_model_new (G_TYPE_OBJECT, G_LIST_MODEL (list)));
+  g_object_unref (children);
+  g_object_unref (guides);
+  g_object_unref (constraints);
+  g_object_unref (all_children);
+  g_object_unref (all_constraints);
+  g_object_unref (list);
+
+
+  controller = (GtkEventController *)gtk_gesture_drag_new ();
+  g_signal_connect (controller, "drag-begin", G_CALLBACK (drag_begin), self);
+  g_signal_connect (controller, "drag-update", G_CALLBACK (drag_update), self);
+  g_signal_connect (controller, "drag-end", G_CALLBACK (drag_end), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+}
+
+ConstraintView *
+constraint_view_new (void)
+{
+  return g_object_new (CONSTRAINT_VIEW_TYPE, NULL);
+}
+
+void
+constraint_view_add_child (ConstraintView *view,
+                           const char     *name)
+{
+  GtkWidget *frame;
+  GtkWidget *label;
+
+  label = gtk_label_new (name);
+  frame = gtk_frame_new (NULL);
+  gtk_style_context_add_class (gtk_widget_get_style_context (frame), "child");
+  gtk_widget_set_name (frame, name);
+  gtk_container_add (GTK_CONTAINER (frame), label);
+  gtk_widget_set_parent (frame, GTK_WIDGET (view));
+
+  update_weak_position (view, frame, 100, 100);
+}
+
+void
+constraint_view_remove_child (ConstraintView *view,
+                              GtkWidget      *child)
+{
+  update_weak_position (view, child, -100, -100);
+  gtk_widget_unparent (child);
+}
+
+void
+constraint_view_add_guide (ConstraintView *view,
+                           GtkConstraintGuide *guide)
+{
+  GtkConstraintLayout *layout;
+  GtkWidget *frame;
+  GtkWidget *label;
+  const char *name;
+  GtkConstraint *constraint;
+  struct {
+    const char *name;
+    GtkConstraintAttribute attr;
+  } names[] = {
+    { "left-constraint", GTK_CONSTRAINT_ATTRIBUTE_LEFT },
+    { "top-constraint", GTK_CONSTRAINT_ATTRIBUTE_TOP },
+    { "width-constraint", GTK_CONSTRAINT_ATTRIBUTE_WIDTH },
+    { "height-constraint", GTK_CONSTRAINT_ATTRIBUTE_HEIGHT },
+  };
+  int i;
+
+  name = gtk_constraint_guide_get_name (guide);
+  label = gtk_label_new (name);
+  g_object_bind_property (guide, "name",
+                          label, "label",
+                          G_BINDING_DEFAULT);
+
+  frame = gtk_frame_new (NULL);
+  gtk_style_context_add_class (gtk_widget_get_style_context (frame), "guide");
+  g_object_set_data (G_OBJECT (frame), "internal", "yes");
+  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);
+
+  layout = GTK_CONSTRAINT_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (view)));
+  gtk_constraint_layout_add_guide (layout, g_object_ref (guide));
+
+  for (i = 0; i < G_N_ELEMENTS (names); i++)
+    {
+      constraint = gtk_constraint_new (frame,
+                                       names[i].attr,
+                                       GTK_CONSTRAINT_RELATION_EQ,
+                                       guide,
+                                       names[i].attr,
+                                       1.0, 0.0,
+                                       GTK_CONSTRAINT_STRENGTH_REQUIRED);
+      g_object_set_data (G_OBJECT (constraint), "internal", "yes");
+      gtk_constraint_layout_add_constraint (layout, constraint);
+      g_object_set_data (G_OBJECT (guide), names[i].name, constraint);
+    }
+
+  update_weak_position (view, frame, 150, 150);
+}
+
+void
+constraint_view_remove_guide (ConstraintView     *view,
+                              GtkConstraintGuide *guide)
+{
+  GtkConstraintLayout *layout;
+  GtkWidget *frame;
+  GtkConstraint *constraint;
+  const char *names[] = {
+    "left-constraint",
+    "top-constraint",
+    "width-constraint",
+    "height-constraint"
+  };
+  int i;
+
+  layout = GTK_CONSTRAINT_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (view)));
+
+  for (i = 0; i < G_N_ELEMENTS (names); i++)
+    {
+      constraint = (GtkConstraint*)g_object_get_data (G_OBJECT (guide), names[i]);
+      gtk_constraint_layout_remove_constraint (layout, constraint);
+    }
+
+  frame = (GtkWidget *)g_object_get_data (G_OBJECT (guide), "frame");
+  update_weak_position (view, frame, -100, -100);
+  gtk_widget_unparent (frame);
+
+  gtk_constraint_layout_remove_guide (layout, guide);
+}
+
+void
+constraint_view_add_constraint (ConstraintView *view,
+                                GtkConstraint  *constraint)
+{
+  GtkLayoutManager *manager;
+
+  manager = gtk_widget_get_layout_manager (GTK_WIDGET (view));
+  gtk_constraint_layout_add_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                        g_object_ref (constraint));
+}
+
+void
+constraint_view_remove_constraint (ConstraintView *view,
+                                   GtkConstraint  *constraint)
+{
+  GtkLayoutManager *manager;
+
+  manager = gtk_widget_get_layout_manager (GTK_WIDGET (view));
+  gtk_constraint_layout_remove_constraint (GTK_CONSTRAINT_LAYOUT (manager),
+                                           constraint);
+}
+
+GListModel *
+constraint_view_get_model (ConstraintView *view)
+{
+  return view->model;
+}

demos/constraint-editor/constraint-view.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define CONSTRAINT_VIEW_TYPE (constraint_view_get_type ())
+
+G_DECLARE_FINAL_TYPE (ConstraintView, constraint_view, CONSTRAINT, VIEW, GtkWidget)
+
+ConstraintView * constraint_view_new (void);
+
+void             constraint_view_add_child (ConstraintView *view,
+                                            const char     *name);
+void             constraint_view_remove_child (ConstraintView *view,
+                                               GtkWidget      *child);
+void             constraint_view_add_guide (ConstraintView     *view,
+                                            GtkConstraintGuide *guide);
+void             constraint_view_remove_guide (ConstraintView     *view,
+                                               GtkConstraintGuide *guide);
+void             constraint_view_guide_changed (ConstraintView     *view,
+                                                GtkConstraintGuide *guide);
+void             constraint_view_add_constraint (ConstraintView *view,
+                                                 GtkConstraint  *constraint);
+void             constraint_view_remove_constraint (ConstraintView *view,
+                                                    GtkConstraint  *constraint);
+GListModel *     constraint_view_get_model (ConstraintView *view);

demos/constraint-editor/guide-editor.c

@@ -0,0 +1,411 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#include "config.h"
+
+#include "guide-editor.h"
+
+struct _GuideEditor
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *grid;
+  GtkWidget *name;
+  GtkWidget *min_width;
+  GtkWidget *min_height;
+  GtkWidget *nat_width;
+  GtkWidget *nat_height;
+  GtkWidget *max_width;
+  GtkWidget *max_height;
+  GtkWidget *strength;
+  GtkWidget *button;
+
+  GtkConstraintGuide *guide;
+
+  gboolean constructed;
+};
+
+enum {
+  PROP_GUIDE = 1,
+  LAST_PROP
+};
+
+static GParamSpec *pspecs[LAST_PROP];
+
+enum {
+  DONE,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+G_DEFINE_TYPE(GuideEditor, guide_editor, GTK_TYPE_WIDGET);
+
+static void
+guide_strength_combo (GtkWidget *combo)
+{
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "weak", "Weak");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "medium", "Medium");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "strong", "Strong");
+  gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "required", "Required");
+}
+
+static GtkConstraintStrength
+get_strength (const char *id)
+{
+  GtkConstraintStrength strength;
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_STRENGTH);
+  GEnumValue *value = g_enum_get_value_by_nick (class, id);
+  strength = value->value;
+  g_type_class_unref (class);
+
+  return strength;
+}
+
+const char *
+get_strength_nick (GtkConstraintStrength strength)
+{
+  GEnumClass *class = g_type_class_ref (GTK_TYPE_CONSTRAINT_STRENGTH);
+  GEnumValue *value = g_enum_get_value (class, strength);
+  const char *nick = value->value_nick;
+  g_type_class_unref (class);
+
+  return nick;
+}
+
+void
+guide_editor_serialize_guide (GString *str,
+                              int      indent,
+                              GtkConstraintGuide *guide)
+{
+  int min_width, min_height;
+  int nat_width, nat_height;
+  int max_width, max_height;
+  const char *name;
+  const char *strength;
+
+  gtk_constraint_guide_get_min_size (guide, &min_width, &min_height);
+  gtk_constraint_guide_get_nat_size (guide, &nat_width, &nat_height);
+  gtk_constraint_guide_get_max_size (guide, &max_width, &max_height);
+  name = gtk_constraint_guide_get_name (guide);
+  strength = get_strength_nick (gtk_constraint_guide_get_strength (guide));
+
+  g_string_append_printf (str, "%*s<guide min-width=\"%d\" min-height=\"%d\"\n", indent, "", min_width, min_height);
+  g_string_append_printf (str, "%*s       nat-width=\"%d\" nat-height=\"%d\"\n", indent, "", nat_width, nat_height);
+  g_string_append_printf (str, "%*s       max-width=\"%d\" max-height=\"%d\"\n", indent, "", max_width, max_height);
+  g_string_append_printf (str, "%*s       name=\"%s\" strength=\"%s\" />\n", indent, "", name, strength);
+}
+
+static void
+create_guide (GtkButton   *button,
+              GuideEditor *editor)
+{
+  const char *id;
+  int strength;
+  const char *name;
+  int w, h;
+  GtkConstraintGuide *guide;
+
+  if (editor->guide)
+    guide = g_object_ref (editor->guide);
+  else
+    guide = gtk_constraint_guide_new ();
+
+  name = gtk_editable_get_text (GTK_EDITABLE (editor->name));
+  gtk_constraint_guide_set_name (guide, name);
+
+  w = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->min_width));
+  h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->min_height));
+  gtk_constraint_guide_set_min_size (guide, w, h);
+
+  w = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->nat_width));
+  h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->nat_height));
+  gtk_constraint_guide_set_nat_size (guide, w, h);
+
+  w = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->max_width));
+  h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (editor->max_height));
+  gtk_constraint_guide_set_max_size (guide, w, h);
+
+  id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (editor->strength));
+  strength = get_strength (id);
+  gtk_constraint_guide_set_strength (guide, strength);
+
+  g_signal_emit (editor, signals[DONE], 0, guide);
+  g_object_unref (guide);
+}
+
+static void
+guide_editor_init (GuideEditor *editor)
+{
+  gtk_widget_init_template (GTK_WIDGET (editor));
+}
+
+static int guide_counter;
+
+static int
+min_input (GtkSpinButton *spin_button,
+           double        *new_val)
+{
+  if (strcmp (gtk_editable_get_text (GTK_EDITABLE (spin_button)), "") == 0)
+    {
+      *new_val = 0.0;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static int
+max_input (GtkSpinButton *spin_button,
+           double        *new_val)
+{
+  if (strcmp (gtk_editable_get_text (GTK_EDITABLE (spin_button)), "") == 0)
+    {
+      *new_val = G_MAXINT;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+min_output (GtkSpinButton *spin_button)
+{
+  GtkAdjustment *adjustment;
+  double value;
+  GtkWidget *box, *text;
+
+  adjustment = gtk_spin_button_get_adjustment (spin_button);
+  value = gtk_adjustment_get_value (adjustment);
+
+  box = gtk_widget_get_first_child (GTK_WIDGET (spin_button));
+  text = gtk_widget_get_first_child (box);
+
+  if (value == 0.0)
+    {
+      gtk_editable_set_text (GTK_EDITABLE (spin_button), "");
+      gtk_text_set_placeholder_text (GTK_TEXT (text), "unset");
+      return TRUE;
+    }
+  else
+    {
+      gtk_text_set_placeholder_text (GTK_TEXT (text), "");
+      return FALSE;
+    }
+}
+
+static gboolean
+max_output (GtkSpinButton *spin_button)
+{
+  GtkAdjustment *adjustment;
+  double value;
+  GtkWidget *box, *text;
+
+  adjustment = gtk_spin_button_get_adjustment (spin_button);
+  value = gtk_adjustment_get_value (adjustment);
+
+  box = gtk_widget_get_first_child (GTK_WIDGET (spin_button));
+  text = gtk_widget_get_first_child (box);
+
+  if (value == (double)G_MAXINT)
+    {
+      gtk_editable_set_text (GTK_EDITABLE (spin_button), "");
+      gtk_text_set_placeholder_text (GTK_TEXT (text), "unset");
+      return TRUE;
+    }
+  else
+    {
+      gtk_text_set_placeholder_text (GTK_TEXT (text), "");
+      return FALSE;
+    }
+}
+
+static void
+guide_editor_constructed (GObject *object)
+{
+  GuideEditor *editor = GUIDE_EDITOR (object);
+
+  guide_strength_combo (editor->strength);
+
+  g_signal_connect (editor->min_width, "input", G_CALLBACK (min_input), NULL);
+  g_signal_connect (editor->min_width, "output", G_CALLBACK (min_output), NULL);
+
+  g_signal_connect (editor->min_height, "input", G_CALLBACK (min_input), NULL);
+  g_signal_connect (editor->min_height, "output", G_CALLBACK (min_output), NULL);
+
+  g_signal_connect (editor->max_width, "input", G_CALLBACK (max_input), NULL);
+  g_signal_connect (editor->max_width, "output", G_CALLBACK (max_output), NULL);
+
+  g_signal_connect (editor->max_height, "input", G_CALLBACK (max_input), NULL);
+  g_signal_connect (editor->max_height, "output", G_CALLBACK (max_output), NULL);
+
+  if (editor->guide)
+    {
+      GtkConstraintStrength strength;
+      const char *nick;
+      int w, h;
+
+      nick = gtk_constraint_guide_get_name (editor->guide);
+      if (nick)
+        gtk_editable_set_text (GTK_EDITABLE (editor->name), nick);
+
+      gtk_constraint_guide_get_min_size (editor->guide, &w, &h);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_width), w);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_height), h);
+
+      gtk_constraint_guide_get_nat_size (editor->guide, &w, &h);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_width), w);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_height), h);
+
+      gtk_constraint_guide_get_max_size (editor->guide, &w, &h);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_width), w);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_height), h);
+
+      strength = gtk_constraint_guide_get_strength (editor->guide);
+      nick = get_strength_nick (strength);
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->strength), nick);
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Apply");
+    }
+  else
+    {
+      char *name;
+
+      guide_counter++;
+      name = g_strdup_printf ("Guide %d", guide_counter);
+      gtk_editable_set_text (GTK_EDITABLE (editor->name), name);
+      g_free (name);
+
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_width), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->min_height), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_width), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->nat_height), 0.0);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_width), G_MAXINT);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (editor->max_height), G_MAXINT);
+
+      gtk_combo_box_set_active_id (GTK_COMBO_BOX (editor->strength), "medium");
+
+      gtk_button_set_label (GTK_BUTTON (editor->button), "Create");
+    }
+
+  editor->constructed = TRUE;
+}
+
+static void
+guide_editor_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  GuideEditor *self = GUIDE_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_GUIDE:
+      self->guide = g_value_dup_object (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+guide_editor_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  GuideEditor *self = GUIDE_EDITOR (object);
+
+  switch (property_id)
+    {
+    case PROP_GUIDE:
+      g_value_set_object (value, self->guide);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+guide_editor_dispose (GObject *object)
+{
+  GuideEditor *self = (GuideEditor *)object;
+
+  g_clear_pointer (&self->grid, gtk_widget_unparent);
+  g_clear_object (&self->guide);
+
+  G_OBJECT_CLASS (guide_editor_parent_class)->dispose (object);
+}
+
+static void
+guide_editor_class_init (GuideEditorClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->constructed = guide_editor_constructed;
+  object_class->dispose = guide_editor_dispose;
+  object_class->set_property = guide_editor_set_property;
+  object_class->get_property = guide_editor_get_property;
+
+  pspecs[PROP_GUIDE] =
+    g_param_spec_object ("guide", "guide", "guide",
+                         GTK_TYPE_CONSTRAINT_GUIDE,
+                         G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
+
+  g_object_class_install_properties (object_class, LAST_PROP, pspecs);
+
+  signals[DONE] =
+    g_signal_new ("done",
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST,
+                  0,
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE, 1, GTK_TYPE_CONSTRAINT_GUIDE);
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT);
+
+  gtk_widget_class_set_template_from_resource (widget_class,
+                                               "/org/gtk/gtk4/constraint-editor/guide-editor.ui");
+
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, grid);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, name);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, min_width);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, min_height);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, nat_width);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, nat_height);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, max_width);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, max_height);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, strength);
+  gtk_widget_class_bind_template_child (widget_class, GuideEditor, button);
+
+  gtk_widget_class_bind_template_callback (widget_class, create_guide);
+}
+
+GuideEditor *
+guide_editor_new (GtkConstraintGuide *guide)
+{
+  return g_object_new (GUIDE_EDITOR_TYPE,
+                       "guide", guide,
+                       NULL);
+}

demos/constraint-editor/guide-editor.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2019 Red Hat, Inc
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen
+ */
+
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define GUIDE_EDITOR_TYPE (guide_editor_get_type ())
+
+G_DECLARE_FINAL_TYPE (GuideEditor, guide_editor, GUIDE, EDITOR, GtkWidget)
+
+GuideEditor * guide_editor_new (GtkConstraintGuide  *guide);
+
+void guide_editor_serialize_guide (GString            *str,
+                                   int                 indent,
+                                   GtkConstraintGuide *guide);

demos/constraint-editor/guide-editor.ui

@@ -0,0 +1,188 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkAdjustment" id="min_width_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="min_height_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="nat_width_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="nat_height_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="max_width_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <object class="GtkAdjustment" id="max_height_adj">
+    <property name="lower">0</property>
+    <property name="upper">2147483647</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+    <property name="page-size">0</property>
+  </object>
+  <template class="GuideEditor" parent="GtkWidget">
+    <child>
+      <object class="GtkGrid" id="grid">
+        <property name="margin">20</property>
+        <property name="row-spacing">10</property>
+        <property name="column-spacing">10</property>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Name</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">0</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkEntry" id="name">
+            <property name="max-width-chars">20</property>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">0</property>
+              <property name="column-span">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Min Size</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="min_width">
+            <property name="adjustment">min_width_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="min_height">
+            <property name="adjustment">min_height_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="left-attach">2</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Nat Size</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="nat_width">
+            <property name="adjustment">nat_width_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="nat_height">
+            <property name="adjustment">nat_height_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="left-attach">2</property>
+              <property name="top-attach">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Max Size</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="max_width">
+            <property name="adjustment">max_width_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkSpinButton" id="max_height">
+            <property name="adjustment">max_height_adj</property>
+            <property name="max-width-chars">5</property>
+            <layout>
+              <property name="left-attach">2</property>
+              <property name="top-attach">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Strength</property>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">4</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="strength">
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">4</property>
+              <property name="column-span">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="button">
+            <property name="label">Create</property>
+            <signal name="clicked" handler="create_guide"/>
+            <layout>
+              <property name="left-attach">2</property>
+              <property name="top-attach">5</property>
+            </layout>
+          </object>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>

demos/constraint-editor/main.c

@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Matthias Clasen <mclasen@redhat.com>
+ */
+
+#include "config.h"
+
+#include <constraint-editor-application.h>
+
+int
+main (int argc, char *argv[])
+{
+  return g_application_run (G_APPLICATION (constraint_editor_application_new ()), argc, argv);
+}

demos/constraint-editor/meson.build

@@ -0,0 +1,20 @@
+constraint_editor_sources = [
+  'main.c',
+  'constraint-editor-application.c',
+  'constraint-editor-window.c',
+  'constraint-view.c',
+  'constraint-editor.c',
+  'guide-editor.c',
+]
+
+constraint_editor_resources = gnome.compile_resources('constraint_editor_resources',
+                                                      'constraint-editor.gresource.xml',
+                                                      source_dir: '.')
+
+executable('gtk4-constraint-editor',
+           constraint_editor_sources, constraint_editor_resources,
+           dependencies: libgtk_dep,
+           include_directories: confinc,
+           gui_app: true,
+           link_args: extra_demo_ldflags,
+           install: false)

demos/gtk-demo/award.c

@@ -0,0 +1,248 @@
+/*
+ * Copyright © 2018 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#include "award.h"
+
+struct _GtkAward
+{
+  GObject parent;
+
+  char *explanation;
+  char *name;
+  char *title;
+  GDateTime *granted; /* or NULL if not granted */
+};
+
+enum {
+  PROP_0,
+  PROP_EXPLANATION,
+  PROP_NAME,
+  PROP_TITLE,
+  PROP_GRANTED,
+
+  N_PROPS,
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+G_DEFINE_TYPE (GtkAward, gtk_award, G_TYPE_OBJECT)
+
+static void
+gtk_award_set_property (GObject      *object,
+                        guint         prop_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+
+{
+  GtkAward *self = GTK_AWARD (object);
+
+  switch (prop_id)
+    {
+    case PROP_EXPLANATION:
+      self->explanation = g_value_dup_string (value);
+      break;
+
+    case PROP_NAME:
+      self->name = g_value_dup_string (value);
+      break;
+
+    case PROP_TITLE:
+      self->title = g_value_dup_string (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_award_get_property (GObject    *object,
+                        guint       prop_id,
+                        GValue     *value,
+                        GParamSpec *pspec)
+{
+  GtkAward *self = GTK_AWARD (object);
+
+  switch (prop_id)
+    {
+    case PROP_EXPLANATION:
+      g_value_set_string (value, self->explanation);
+      break;
+
+    case PROP_NAME:
+      g_value_set_string (value, self->name);
+      break;
+
+    case PROP_TITLE:
+      g_value_set_string (value, self->title);
+      break;
+
+    case PROP_GRANTED:
+      g_value_set_boxed (value, self->granted);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_award_dispose (GObject *object)
+{
+  GtkAward *self = GTK_AWARD (object);
+
+  g_clear_pointer (&self->name, g_free);
+  g_clear_pointer (&self->title, g_free);
+  g_clear_pointer (&self->granted, g_date_time_unref);
+
+  G_OBJECT_CLASS (gtk_award_parent_class)->dispose (object);
+}
+
+static void
+gtk_award_class_init (GtkAwardClass *class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+  gobject_class->set_property = gtk_award_set_property;
+  gobject_class->get_property = gtk_award_get_property;
+  gobject_class->dispose = gtk_award_dispose;
+
+  properties[PROP_EXPLANATION] =
+    g_param_spec_string ("explanation",
+                         "Explanation",
+                         "How to get the title",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_NAME] =
+    g_param_spec_string ("name",
+                         "Name",
+                         "internal name of the award",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_TITLE] =
+    g_param_spec_string ("title",
+                         "Title",
+                         "user-visible title",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_GRANTED] =
+    g_param_spec_boxed ("granted",
+                        "Granted",
+                        "Timestamp the award was granted or NULL if not granted yet",
+                        G_TYPE_DATE_TIME,
+                        G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gtk_award_init (GtkAward *self)
+{
+}
+
+GListModel *
+gtk_award_get_list (void)
+{
+  static GListModel *list = NULL;
+
+  if (list == NULL)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (GTK_TYPE_AWARD);
+      builder = gtk_builder_new_from_resource ("/awards.ui");
+      gtk_builder_connect_signals (builder, NULL);
+      list = G_LIST_MODEL (gtk_builder_get_object (builder, "list"));
+      g_object_ref (list);
+      g_object_unref (builder);
+    }
+
+  return g_object_ref (list);
+}
+
+const char *
+gtk_award_get_name (GtkAward *award)
+{
+  return award->name;
+}
+
+const char *
+gtk_award_get_title (GtkAward *award)
+{
+  return award->title;
+}
+
+GDateTime *
+gtk_award_get_granted (GtkAward *award)
+{
+  return award->granted;
+}
+
+GtkAward *
+award_find (const char *name)
+{
+  GListModel *list;
+  GtkAward *self;
+  guint i;
+
+  list = gtk_award_get_list ();
+  g_object_unref (list);
+
+  for (i = 0; i < g_list_model_get_n_items (list); i++)
+    {
+      self = g_list_model_get_item (list, i);
+      g_object_unref (self);
+
+      if (g_ascii_strcasecmp (name, self->name) == 0)
+        return self;
+    }
+
+  return NULL;
+}
+
+void
+award (const char *name)
+{
+  GtkAward *self;
+  GNotification *notification;
+
+  self = award_find (name);
+  if (self == NULL)
+    {
+      g_warning ("Did not find award \"%s\"", name);
+      return;
+    }
+
+  if (self->granted)
+    return;
+
+  self->granted = g_date_time_new_now_utc ();
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_GRANTED]);
+
+  notification = g_notification_new ("You won an award!");
+  g_notification_set_body (notification, self->title);
+  g_application_send_notification (g_application_get_default (), NULL, notification);
+  g_object_unref (notification);
+}
+

demos/gtk-demo/award.h

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

demos/gtk-demo/awardlistitem.ui

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

demos/gtk-demo/awards.ui

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

demos/gtk-demo/awardview.c

@@ -0,0 +1,79 @@
+/* Awards
+ *
+ * This demo demonstrates how to use lists to show the awards you have collected
+ * while exploring this demo.
+ *
+ */
+
+#include <gtk/gtk.h>
+
+/* Include the header for accessing the awards */
+#include "award.h"
+
+static GtkWidget *window = NULL;
+
+#if 0
+static void
+create_listitem (GtkListItem *item, gpointer user_data)
+{
+  GtkWidget *label;
+
+  label = gtk_label_new (NULL);
+  g_object_set (label, "margin", 6, NULL); /* omg, why do we need to do this?! */
+  gtk_label_set_xalign (GTK_LABEL (label), 0);
+  gtk_container_add (GTK_CONTAINER (item), label);
+}
+
+static void
+bind_listitem (GtkListItem *item, gpointer user_data)
+{
+  GtkAward *award = gtk_list_item_get_item (item);
+
+  gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (item))),
+                      gtk_award_get_title (award));
+}
+#endif
+
+GtkWidget *
+do_awardview (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkWidget *sw, *listview;
+      GListModel *list;
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Awards");
+      gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_container_add (GTK_CONTAINER (window), sw);
+
+#if 0
+      listview = gtk_list_view_new ();
+      gtk_list_view_set_functions (GTK_LIST_VIEW (listview),
+                                   create_listitem,
+                                   bind_listitem,
+                                   NULL, NULL);
+#else
+      listview = gtk_list_view_new_with_factory (
+          gtk_builder_list_item_factory_new_from_resource ("/awardview/awardlistitem.ui"));
+#endif
+      list = gtk_award_get_list ();
+      gtk_list_view_set_model (GTK_LIST_VIEW (listview), list);
+      g_object_unref (list);
+      gtk_list_view_set_show_separators (GTK_LIST_VIEW (listview), TRUE);
+      gtk_container_add (GTK_CONTAINER (sw), listview);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

demos/gtk-demo/clipboard.c

@@ -110,7 +110,7 @@ get_image_paintable (GtkImage *image)
       icon_info = gtk_icon_theme_lookup_icon (icon_theme, icon_name, 48, GTK_ICON_LOOKUP_GENERIC_FALLBACK);
       if (icon_info == NULL)
         return NULL;
-      return GDK_PAINTABLE (gtk_icon_info_load_texture (icon_info));
+      return gtk_icon_info_load_icon (icon_info, NULL);
     default:
       g_warning ("Image storage type %d not handled",
                  gtk_image_get_storage_type (image));

demos/gtk-demo/constraints.c

@@ -0,0 +1,289 @@
+/* Constraints/Simple
+ *
+ * GtkConstraintLayout provides a layout manager that uses relations
+ * between widgets (also known as "constraints") to compute the position
+ * and size of each child.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+G_DECLARE_FINAL_TYPE (SimpleGrid, simple_grid, SIMPLE, GRID, GtkWidget)
+
+struct _SimpleGrid
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *button1, *button2;
+  GtkWidget *button3;
+};
+
+G_DEFINE_TYPE (SimpleGrid, simple_grid, GTK_TYPE_WIDGET)
+
+static void
+simple_grid_destroy (GtkWidget *widget)
+{
+  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);
+
+  GTK_WIDGET_CLASS (simple_grid_parent_class)->destroy (widget);
+}
+
+static void
+simple_grid_class_init (SimpleGridClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  widget_class->destroy = simple_grid_destroy;
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_CONSTRAINT_LAYOUT);
+}
+
+/* Layout:
+ *
+ *   +-------------------------------------+
+ *   | +-----------++-------++-----------+ |
+ *   | |  Child 1  || Space ||  Child 2  | |
+ *   | +-----------++-------++-----------+ |
+ *   | +---------------------------------+ |
+ *   | |             Child 3             | |
+ *   | +---------------------------------+ |
+ *   +-------------------------------------+
+ *
+ * Constraints:
+ *
+ *   super.start = child1.start - 8
+ *   child1.width = child2.width
+ *   child1.end = space.start
+ *   space.end = child2.start
+ *   child2.end = super.end - 8
+ *   super.start = child3.start - 8
+ *   child3.end = super.end - 8
+ *   super.top = child1.top - 8
+ *   super.top = child2.top - 8
+ *   child1.bottom = child3.top - 12
+ *   child2.bottom = child3.top - 12
+ *   child3.height = child1.height
+ *   child3.height = child2.height
+ *   child3.bottom = super.bottom - 8
+ *
+ * To add some flexibility, we make the space
+ * stretchable:
+ *
+ *   space.width >= 10
+ *   space.width = 100
+ *   space.width <= 200
+ */
+static void
+build_constraints (SimpleGrid          *self,
+                   GtkConstraintLayout *manager)
+{
+  GtkConstraintGuide *guide;
+
+  guide = gtk_constraint_guide_new ();
+  gtk_constraint_guide_set_name (guide, "space");
+  gtk_constraint_guide_set_min_size (guide, 10, 10);
+  gtk_constraint_guide_set_nat_size (guide, 100, 10);
+  gtk_constraint_guide_set_max_size (guide, 200, 20);
+  gtk_constraint_guide_set_strength (guide, GTK_CONSTRAINT_STRENGTH_STRONG);
+  gtk_constraint_layout_add_guide (manager, guide);
+
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new_constant (GTK_CONSTRAINT_TARGET (self->button1),
+                        GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
+                        GTK_CONSTRAINT_RELATION_LE,
+                        200.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button1,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button1,
+                        GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button2,
+                        GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button1,
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        guide,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (guide,
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button2,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button2,
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button3,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button3,
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button1,
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button2,
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button1,
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button3,
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        1.0,
+                        -12.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button2,
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button3,
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        1.0,
+                        -12.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button3,
+                        GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button1,
+                        GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button3,
+                        GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        self->button2,
+                        GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (self->button3,
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+}
+
+static void
+simple_grid_init (SimpleGrid *self)
+{
+  GtkWidget *widget = GTK_WIDGET (self);
+
+  self->button1 = gtk_button_new_with_label ("Child 1");
+  gtk_widget_set_parent (self->button1, widget);
+  gtk_widget_set_name (self->button1, "button1");
+
+  self->button2 = gtk_button_new_with_label ("Child 2");
+  gtk_widget_set_parent (self->button2, widget);
+  gtk_widget_set_name (self->button2, "button2");
+
+  self->button3 = gtk_button_new_with_label ("Child 3");
+  gtk_widget_set_parent (self->button3, widget);
+  gtk_widget_set_name (self->button3, "button3");
+
+  GtkLayoutManager *manager = gtk_widget_get_layout_manager (GTK_WIDGET (self));
+  build_constraints (self, GTK_CONSTRAINT_LAYOUT (manager));
+}
+
+GtkWidget *
+do_constraints (GtkWidget *do_widget)
+{
+ static GtkWidget *window;
+
+ if (!window)
+   {
+     GtkWidget *header, *box, *grid, *button;
+
+     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+     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), "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_container_add (GTK_CONTAINER (window), box);
+
+     grid = g_object_new (simple_grid_get_type (), NULL);
+     gtk_widget_set_hexpand (grid, TRUE);
+     gtk_widget_set_vexpand (grid, TRUE);
+     gtk_container_add (GTK_CONTAINER (box), grid);
+
+     button = gtk_button_new_with_label ("Close");
+     gtk_container_add (GTK_CONTAINER (box), button);
+     gtk_widget_set_hexpand (grid, TRUE);
+     g_signal_connect_swapped (button, "clicked",
+                               G_CALLBACK (gtk_widget_destroy), window);
+   }
+
+ if (!gtk_widget_get_visible (window))
+   gtk_widget_show (window);
+ else
+   gtk_widget_destroy (window);
+
+ return window;
+}

demos/gtk-demo/constraints2.c

@@ -0,0 +1,245 @@
+/* Constraints/Interactive
+ *
+ * Demonstrate how constraints can be updates during
+ * user interaction.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+G_DECLARE_FINAL_TYPE (InteractiveGrid, interactive_grid, INTERACTIVE, GRID, GtkWidget)
+
+struct _InteractiveGrid
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *button1, *button2;
+  GtkWidget *button3;
+  GtkConstraintGuide *guide;
+  GtkConstraint *constraint;
+};
+
+G_DEFINE_TYPE (InteractiveGrid, interactive_grid, GTK_TYPE_WIDGET)
+
+static void
+interactive_grid_destroy (GtkWidget *widget)
+{
+  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);
+
+  GTK_WIDGET_CLASS (interactive_grid_parent_class)->destroy (widget);
+}
+
+static void
+interactive_grid_class_init (InteractiveGridClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  widget_class->destroy = interactive_grid_destroy;
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_CONSTRAINT_LAYOUT);
+}
+
+static void
+build_constraints (InteractiveGrid          *self,
+                   GtkConstraintLayout *manager)
+{
+  self->guide = g_object_new (GTK_TYPE_CONSTRAINT_GUIDE, NULL);
+  gtk_constraint_layout_add_guide (manager, self->guide);
+
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new_constant (GTK_CONSTRAINT_TARGET (self->guide),
+                        GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->button1),
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (GTK_CONSTRAINT_TARGET (self->button1),
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->guide),
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (GTK_CONSTRAINT_TARGET (self->button2),
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->guide),
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (GTK_CONSTRAINT_TARGET (self->button2),
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->button3),
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (GTK_CONSTRAINT_TARGET (self->button3),
+                        GTK_CONSTRAINT_ATTRIBUTE_END,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->guide),
+                        GTK_CONSTRAINT_ATTRIBUTE_START,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->button1),
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (GTK_CONSTRAINT_TARGET (self->button2),
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->button1),
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (GTK_CONSTRAINT_TARGET (self->button3),
+                        GTK_CONSTRAINT_ATTRIBUTE_TOP,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        GTK_CONSTRAINT_TARGET (self->button2),
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        1.0,
+                        0.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+  gtk_constraint_layout_add_constraint (manager,
+    gtk_constraint_new (GTK_CONSTRAINT_TARGET (self->button3),
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        GTK_CONSTRAINT_RELATION_EQ,
+                        NULL,
+                        GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
+                        1.0,
+                        -8.0,
+                        GTK_CONSTRAINT_STRENGTH_REQUIRED));
+}
+
+static void
+drag_cb (GtkGestureDrag  *drag,
+         double           offset_x,
+         double           offset_y,
+         InteractiveGrid *self)
+{
+  GtkConstraintLayout *layout = GTK_CONSTRAINT_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (self)));
+  double x, y;
+
+  if (self->constraint)
+    {
+      gtk_constraint_layout_remove_constraint (layout, self->constraint);
+      g_clear_object (&self->constraint);
+    }
+
+  gtk_gesture_drag_get_start_point (drag, &x, &y);
+  self->constraint = gtk_constraint_new_constant (GTK_CONSTRAINT_TARGET (self->guide),
+                                                  GTK_CONSTRAINT_ATTRIBUTE_LEFT,
+                                                  GTK_CONSTRAINT_RELATION_EQ,
+                                                  x + offset_x,
+                                                  GTK_CONSTRAINT_STRENGTH_REQUIRED);
+  gtk_constraint_layout_add_constraint (layout, g_object_ref (self->constraint));
+  gtk_widget_queue_allocate (GTK_WIDGET (self));
+}
+
+static void
+interactive_grid_init (InteractiveGrid *self)
+{
+  GtkWidget *widget = GTK_WIDGET (self);
+  GtkGesture *drag;
+
+  self->button1 = gtk_button_new_with_label ("Child 1");
+  gtk_widget_set_parent (self->button1, widget);
+  gtk_widget_set_name (self->button1, "button1");
+
+  self->button2 = gtk_button_new_with_label ("Child 2");
+  gtk_widget_set_parent (self->button2, widget);
+  gtk_widget_set_name (self->button2, "button2");
+
+  self->button3 = gtk_button_new_with_label ("Child 3");
+  gtk_widget_set_parent (self->button3, widget);
+  gtk_widget_set_name (self->button3, "button3");
+
+  GtkLayoutManager *manager = gtk_widget_get_layout_manager (GTK_WIDGET (self));
+  build_constraints (self, GTK_CONSTRAINT_LAYOUT (manager));
+
+  drag = gtk_gesture_drag_new ();
+  g_signal_connect (drag, "drag-update", G_CALLBACK (drag_cb), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag));
+}
+
+GtkWidget *
+do_constraints2 (GtkWidget *do_widget)
+{
+ static GtkWidget *window;
+
+ if (!window)
+   {
+     GtkWidget *header, *box, *grid, *button;
+
+     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+     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), "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_container_add (GTK_CONTAINER (window), box);
+
+     grid = g_object_new (interactive_grid_get_type (), NULL);
+     gtk_widget_set_hexpand (grid, TRUE);
+     gtk_widget_set_vexpand (grid, TRUE);
+     gtk_container_add (GTK_CONTAINER (box), grid);
+
+     button = gtk_button_new_with_label ("Close");
+     gtk_container_add (GTK_CONTAINER (box), button);
+     gtk_widget_set_hexpand (grid, TRUE);
+     g_signal_connect_swapped (button, "clicked",
+                               G_CALLBACK (gtk_widget_destroy), window);
+   }
+
+ if (!gtk_widget_get_visible (window))
+   gtk_widget_show (window);
+ else
+   gtk_widget_destroy (window);
+
+ return window;
+}

demos/gtk-demo/constraints3.c

@@ -0,0 +1,165 @@
+/* Constraints/VFL
+ *
+ * GtkConstraintLayout allows defining constraints using a
+ * compact syntax called Visual Format Language, or VFL.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+G_DECLARE_FINAL_TYPE (VflGrid, vfl_grid, VFL, GRID, GtkWidget)
+
+struct _VflGrid
+{
+  GtkWidget parent_instance;
+
+  GtkWidget *button1, *button2;
+  GtkWidget *button3;
+};
+
+G_DEFINE_TYPE (VflGrid, vfl_grid, GTK_TYPE_WIDGET)
+
+static void
+vfl_grid_destroy (GtkWidget *widget)
+{
+  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);
+
+  GTK_WIDGET_CLASS (vfl_grid_parent_class)->destroy (widget);
+}
+
+static void
+vfl_grid_class_init (VflGridClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  widget_class->destroy = vfl_grid_destroy;
+
+  gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_CONSTRAINT_LAYOUT);
+}
+
+/* Layout:
+ *
+ *   +-----------------------------+
+ *   | +-----------+ +-----------+ |
+ *   | |  Child 1  | |  Child 2  | |
+ *   | +-----------+ +-----------+ |
+ *   | +-------------------------+ |
+ *   | |         Child 3         | |
+ *   | +-------------------------+ |
+ *   +-----------------------------+
+ *
+ * Constraints:
+ *
+ *   super.start = child1.start - 8
+ *   child1.width = child2.width
+ *   child1.end = child2.start - 12
+ *   child2.end = super.end - 8
+ *   super.start = child3.start - 8
+ *   child3.end = super.end - 8
+ *   super.top = child1.top - 8
+ *   super.top = child2.top - 8
+ *   child1.bottom = child3.top - 12
+ *   child2.bottom = child3.top - 12
+ *   child3.height = child1.height
+ *   child3.height = child2.height
+ *   child3.bottom = super.bottom - 8
+ *
+ * Visual format:
+ *
+ *   H:|-8-[view1(==view2)-12-[view2]-8-|
+ *   H:|-8-[view3]-8-|
+ *   V:|-8-[view1]-12-[view3(==view1)]-8-|
+ *   V:|-8-[view2]-12-[view3(==view2)]-8-|
+ */
+static void
+build_constraints (VflGrid          *self,
+                   GtkConstraintLayout *manager)
+{
+  const char * const vfl[] = {
+    "H:|-[button1(==button2)]-12-[button2]-|",
+    "H:|-[button3]-|",
+    "V:|-[button1]-12-[button3(==button1)]-|",
+    "V:|-[button2]-12-[button3(==button2)]-|",
+  };
+  GError *error = NULL;
+
+  gtk_constraint_layout_add_constraints_from_description (manager, vfl, G_N_ELEMENTS (vfl),
+                                                          8, 8,
+                                                          &error,
+                                                          "button1", self->button1,
+                                                          "button2", self->button2,
+                                                          "button3", self->button3,
+                                                          NULL);
+  if (error != NULL)
+    {
+      g_printerr ("VFL parsing error:\n%s", error->message);
+      g_error_free (error);
+    }
+}
+
+static void
+vfl_grid_init (VflGrid *self)
+{
+  GtkWidget *widget = GTK_WIDGET (self);
+
+  self->button1 = gtk_button_new_with_label ("Child 1");
+  gtk_widget_set_parent (self->button1, widget);
+  gtk_widget_set_name (self->button1, "button1");
+
+  self->button2 = gtk_button_new_with_label ("Child 2");
+  gtk_widget_set_parent (self->button2, widget);
+  gtk_widget_set_name (self->button2, "button2");
+
+  self->button3 = gtk_button_new_with_label ("Child 3");
+  gtk_widget_set_parent (self->button3, widget);
+  gtk_widget_set_name (self->button3, "button3");
+
+  GtkLayoutManager *manager = gtk_widget_get_layout_manager (GTK_WIDGET (self));
+  build_constraints (self, GTK_CONSTRAINT_LAYOUT (manager));
+}
+
+GtkWidget *
+do_constraints3 (GtkWidget *do_widget)
+{
+ static GtkWidget *window;
+
+ if (!window)
+   {
+     GtkWidget *header, *box, *grid, *button;
+
+     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+     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), "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_container_add (GTK_CONTAINER (window), box);
+
+     grid = g_object_new (vfl_grid_get_type (), NULL);
+     gtk_widget_set_hexpand (grid, TRUE);
+     gtk_widget_set_vexpand (grid, TRUE);
+     gtk_container_add (GTK_CONTAINER (box), grid);
+
+     button = gtk_button_new_with_label ("Close");
+     gtk_container_add (GTK_CONTAINER (box), button);
+     gtk_widget_set_hexpand (grid, TRUE);
+     g_signal_connect_swapped (button, "clicked",
+                               G_CALLBACK (gtk_widget_destroy), window);
+   }
+
+ if (!gtk_widget_get_visible (window))
+   gtk_widget_show (window);
+ else
+   gtk_widget_destroy (window);
+
+ return window;
+}

demos/gtk-demo/demo.gresource.xml

@@ -1,7 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <gresources>
+  <gresource prefix="/">
+    <file>awards.ui</file>
+  </gresource>
   <gresource prefix="/ui">
     <file preprocess="xml-stripblanks">main.ui</file>
+    <file preprocess="xml-stripblanks">main-listitem.ui</file>
     <file preprocess="xml-stripblanks">appmenu.ui</file>
   </gresource>
   <gresource prefix="/application_demo">
@@ -9,6 +13,9 @@
     <file>application.ui</file>
     <file>menus.ui</file>
   </gresource>
+  <gresource prefix="/awardview">
+    <file>awardlistitem.ui</file>
+  </gresource>
   <gresource prefix="/builder">
     <file>demo.ui</file>
   </gresource>
@@ -104,10 +111,23 @@
     <file>gtkfishbowl.c</file>
     <file>gtkfishbowl.h</file>
   </gresource>
+  <gresource prefix="/iconscroll">
+    <file>iconscroll.ui</file>
+  </gresource>
   <gresource prefix="/iconview">
     <file>gnome-fs-directory.png</file>
     <file>gnome-fs-regular.png</file>
   </gresource>
+  <gresource prefix="/listview_filebrowser">
+    <file>listview_filebrowser.ui</file>
+  </gresource>
+  <gresource prefix="/listview_minesweeper">
+    <file>listview_minesweeper.ui</file>
+    <file>listview_minesweeper_cell.ui</file>
+  </gresource>
+  <gresource prefix="/listview_weather">
+    <file compressed="true">listview_weather.txt</file>
+  </gresource>
   <gresource prefix="/shortcuts">
     <file>shortcuts.ui</file>
     <file>shortcuts-builder.ui</file>
@@ -144,12 +164,16 @@
   </gresource>
   <gresource prefix="/sources">
     <file>application_demo.c</file>
+    <file>awardview.c</file>
     <file>assistant.c</file>
     <file>builder.c</file>
     <file>changedisplay.c</file>
     <file>clipboard.c</file>
     <file>colorsel.c</file>
     <file>combobox.c</file>
+    <file>constraints.c</file>
+    <file>constraints2.c</file>
+    <file>constraints3.c</file>
     <file>css_accordion.c</file>
     <file>css_basics.c</file>
     <file>css_blendmodes.c</file>
@@ -171,16 +195,21 @@
     <file>foreigndrawing.c</file>
     <file>font_features.c</file>
     <file>fontplane.c</file>
+    <file>fontrendering.c</file>
     <file>gestures.c</file>
     <file>glarea.c</file>
     <file>headerbar.c</file>
     <file>hypertext.c</file>
+    <file>iconscroll.c</file>
     <file>iconview.c</file>
     <file>iconview_edit.c</file>
     <file>images.c</file>
     <file>infobar.c</file>
     <file>links.c</file>
     <file>listbox.c</file>
+    <file>listview_filebrowser.c</file>
+    <file>listview_settings.c</file>
+    <file>listview_weather.c</file>
     <file>list_store.c</file>
     <file>markup.c</file>
     <file>menus.c</file>
@@ -278,6 +307,9 @@
   <gresource prefix="/fixed">
     <file>fixed.css</file>
   </gresource>
+  <gresource prefix="/fontrendering">
+    <file>fontrendering.ui</file>
+  </gresource>
   <gresource prefix="/org/gtk/Demo4">
     <file>icons/16x16/actions/application-exit.png</file>
     <file>icons/16x16/actions/document-new.png</file>

demos/gtk-demo/demotaggedentry.c

@@ -129,13 +129,13 @@ demo_tagged_entry_size_allocate (GtkWidget *widget,
                             baseline);
 }
 
-static void
+static gboolean
 demo_tagged_entry_grab_focus (GtkWidget *widget)
 {
   DemoTaggedEntry *entry = DEMO_TAGGED_ENTRY (widget);
   DemoTaggedEntryPrivate *priv = demo_tagged_entry_get_instance_private (entry);
 
-  gtk_widget_grab_focus (priv->entry);
+  return gtk_widget_grab_focus (priv->entry);
 }
 
 static void

demos/gtk-demo/expander.c

@@ -52,7 +52,7 @@ do_expander (GtkWidget *do_widget)
       area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (window));
 
       label = gtk_widget_get_last_child (area);
-      gtk_label_set_line_wrap (GTK_LABEL (label), FALSE);
+      gtk_label_set_wrap (GTK_LABEL (label), FALSE);
       gtk_widget_set_vexpand (label, FALSE);
 
       expander = gtk_expander_new ("Details:");

demos/gtk-demo/fishbowl.c

@@ -124,7 +124,7 @@ create_label (void)
 {
   GtkWidget *w = gtk_label_new ("pLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.");
 
-  gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
+  gtk_label_set_wrap (GTK_LABEL (w), TRUE);
   gtk_label_set_max_width_chars (GTK_LABEL (w), 100);
 
   return w;
@@ -306,6 +306,7 @@ do_fishbowl (GtkWidget *do_widget)
                         G_CALLBACK (gtk_widget_destroyed), &window);
 
       gtk_widget_realize (window);
+      g_object_unref (builder);
     }
 
   if (!gtk_widget_get_visible (window))

demos/gtk-demo/fishbowl.ui

@@ -28,22 +28,7 @@
         </child>
         <child type="end">
           <object class="GtkLabel">
-            <property name="label">fps</property>
-          </object>
-        </child>
-        <child type="end">
-          <object class="GtkLabel">
-            <property name="label" bind-source="bowl" bind-property="framerate-string"/>
-          </object>
-        </child>
-        <child type="end">
-          <object class="GtkLabel">
-            <property name="label">Icons, </property>
-          </object>
-        </child>
-        <child type="end">
-          <object class="GtkLabel">
-            <property name="label" bind-source="bowl" bind-property="count"/>
+            <binding name="label">bowl.count + " Icons, " + bowl.framerate + "fps"</binding>
           </object>
         </child>
         <child type="end">

demos/gtk-demo/fontrendering.c

@@ -0,0 +1,288 @@
+/* Pango/Font rendering
+ *
+ * Demonstrates various aspects of font rendering.
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+static GtkWidget *font_button = NULL;
+static GtkWidget *entry = NULL;
+static GtkWidget *image = NULL;
+static GtkWidget *hinting = NULL;
+static GtkWidget *hint_metrics = NULL;
+static GtkWidget *up_button = NULL;
+static GtkWidget *down_button = NULL;
+static GtkWidget *text_radio = NULL;
+static GtkWidget *show_grid = NULL;
+static GtkWidget *show_extents = NULL;
+
+static PangoContext *context;
+
+static int scale = 10;
+
+static void
+on_destroy (gpointer data)
+{
+  window = NULL;
+}
+
+static void
+update_image (void)
+{
+  const char *text;
+  PangoFontDescription *desc;
+  PangoLayout *layout;
+  PangoRectangle ink, pink, logical;
+  int baseline;
+  cairo_surface_t *surface;
+  cairo_t *cr;
+  GdkPixbuf *pixbuf;
+  GdkPixbuf *pixbuf2;
+  const char *hint;
+  cairo_font_options_t *fopt;
+  cairo_hint_style_t hintstyle;
+  cairo_hint_metrics_t hintmetrics;
+  int i;
+
+  if (!context)
+    context = gtk_widget_create_pango_context (image);
+
+  text = gtk_editable_get_text (GTK_EDITABLE (entry));
+  desc = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (font_button));
+
+  fopt = cairo_font_options_copy (pango_cairo_context_get_font_options (context));
+
+  hint = gtk_combo_box_get_active_id (GTK_COMBO_BOX (hinting));
+  if (strcmp (hint, "none") == 0)
+    hintstyle = CAIRO_HINT_STYLE_NONE;
+  else if (strcmp (hint, "slight") == 0)
+    hintstyle = CAIRO_HINT_STYLE_SLIGHT;
+  else if (strcmp (hint, "medium") == 0)
+    hintstyle = CAIRO_HINT_STYLE_MEDIUM;
+  else if (strcmp (hint, "full") == 0)
+    hintstyle = CAIRO_HINT_STYLE_FULL;
+  else
+    hintstyle = CAIRO_HINT_STYLE_DEFAULT;
+  cairo_font_options_set_hint_style (fopt, hintstyle);
+
+  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (hint_metrics)))
+    hintmetrics = CAIRO_HINT_METRICS_ON;
+  else
+    hintmetrics = CAIRO_HINT_METRICS_OFF;
+  cairo_font_options_set_hint_metrics (fopt, hintmetrics);
+
+  pango_cairo_context_set_font_options (context, fopt);
+  cairo_font_options_destroy (fopt);
+  pango_context_changed (context);
+
+  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (text_radio)))
+    {
+      layout = pango_layout_new (context);
+      pango_layout_set_font_description (layout, desc);
+      pango_layout_set_text (layout, text, -1);
+      pango_layout_get_extents (layout, &ink, &logical);
+      pink = ink;
+      baseline = pango_layout_get_baseline (layout);
+
+      pango_extents_to_pixels (&ink, NULL);
+
+      surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, ink.width + 20, ink.height + 20);
+      cr = cairo_create (surface);
+      cairo_set_source_rgb (cr, 1, 1, 1);
+      cairo_paint (cr);
+
+      cairo_set_source_rgb (cr, 0, 0, 0);
+      cairo_move_to (cr, 10, 10);
+      pango_cairo_show_layout (cr, layout);
+
+      cairo_destroy (cr);
+      g_object_unref (layout);
+
+      pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, cairo_image_surface_get_width (surface), cairo_image_surface_get_height (surface));
+      pixbuf2 = gdk_pixbuf_scale_simple (pixbuf, gdk_pixbuf_get_width (pixbuf) * scale, gdk_pixbuf_get_height (pixbuf) * scale, GDK_INTERP_NEAREST);
+
+      g_object_unref (pixbuf);
+      cairo_surface_destroy (surface);
+
+      surface = cairo_image_surface_create_for_data (gdk_pixbuf_get_pixels (pixbuf2),
+                                                     CAIRO_FORMAT_ARGB32,
+                                                     gdk_pixbuf_get_width (pixbuf2),
+                                                     gdk_pixbuf_get_height (pixbuf2),
+                                                     gdk_pixbuf_get_rowstride (pixbuf2));
+
+      cr = cairo_create (surface);
+      cairo_set_line_width (cr, 1);
+
+      if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_grid)))
+        {
+          cairo_set_source_rgba (cr, 0.2, 0, 0, 0.2);
+          for (i = 1; i < ink.height + 20; i++)
+            {
+              cairo_move_to (cr, 0, scale * i - 0.5);
+              cairo_line_to (cr, scale * (ink.width + 20), scale * i - 0.5);
+              cairo_stroke (cr);
+            }
+          for (i = 1; i < ink.width + 20; i++)
+            {
+              cairo_move_to (cr, scale * i - 0.5, 0);
+              cairo_line_to (cr, scale * i - 0.5, scale * (ink.height + 20));
+              cairo_stroke (cr);
+            }
+        }
+
+      if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_extents)))
+        {
+          cairo_set_source_rgba (cr, 0, 0, 1, 1);
+
+          cairo_rectangle (cr,
+                           scale * (10 + pango_units_to_double (logical.x)) - 0.5,
+                           scale * (10 + pango_units_to_double (logical.y)) - 0.5,
+                           scale * pango_units_to_double (logical.width) + 1,
+                           scale * pango_units_to_double (logical.height) + 1);
+          cairo_stroke (cr);
+          cairo_move_to (cr, scale * (10 + pango_units_to_double (logical.x)) - 0.5,
+                             scale * (10 + pango_units_to_double (baseline)) - 0.5);
+          cairo_line_to (cr, scale * (10 + pango_units_to_double (logical.x + logical.width)) + 1,
+                             scale * (10 + pango_units_to_double (baseline)) - 0.5);
+          cairo_stroke (cr);
+          cairo_set_source_rgba (cr, 1, 0, 0, 1);
+          cairo_rectangle (cr,
+                           scale * (10 + pango_units_to_double (pink.x)) + 0.5,
+                           scale * (10 + pango_units_to_double (pink.y)) + 0.5,
+                           scale * pango_units_to_double (pink.width) - 1,
+                           scale * pango_units_to_double (pink.height) - 1);
+          cairo_stroke (cr);
+        }
+
+      cairo_surface_destroy (surface);
+      cairo_destroy (cr);
+    }
+  else
+    {
+      PangoLayoutIter *iter;
+      PangoLayoutRun *run;
+      PangoGlyphInfo *g;
+      int i, j;
+
+      layout = pango_layout_new (context);
+      pango_layout_set_font_description (layout, desc);
+      pango_layout_set_text (layout, "aaaa", -1);
+      pango_layout_get_extents (layout, &ink, &logical);
+      pango_extents_to_pixels (&logical, NULL);
+
+      surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, logical.width * 3 / 2, 4*logical.height);
+      cr = cairo_create (surface);
+      cairo_set_source_rgb (cr, 1, 1, 1);
+      cairo_paint (cr);
+
+      iter = pango_layout_get_iter (layout);
+      run = pango_layout_iter_get_run (iter);
+
+      cairo_set_source_rgb (cr, 0, 0, 0);
+      for (i = 0; i < 4; i++)
+        {
+          g = &(run->glyphs->glyphs[i]);
+          g->geometry.width = PANGO_UNITS_ROUND (g->geometry.width * 3 / 2);
+        }
+
+      for (j = 0; j < 4; j++)
+        {
+          for (i = 0; i < 4; i++)
+            {
+              g = &(run->glyphs->glyphs[i]);
+              g->geometry.x_offset = i * (PANGO_SCALE / 4);
+              g->geometry.y_offset = j * (PANGO_SCALE / 4);
+            }
+
+          cairo_move_to (cr, 0, j * logical.height);
+          pango_cairo_show_layout (cr, layout);
+        }
+
+      cairo_destroy (cr);
+      pango_layout_iter_free (iter);
+      g_object_unref (layout);
+
+      pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, cairo_image_surface_get_width (surface), cairo_image_surface_get_height (surface));
+      pixbuf2 = gdk_pixbuf_scale_simple (pixbuf, gdk_pixbuf_get_width (pixbuf) * scale, gdk_pixbuf_get_height (pixbuf) * scale, GDK_INTERP_NEAREST);
+      g_object_unref (pixbuf);
+      cairo_surface_destroy (surface);
+    }
+
+
+  gtk_picture_set_pixbuf (GTK_PICTURE (image), pixbuf2);
+
+  g_object_unref (pixbuf2);
+
+  pango_font_description_free (desc);
+}
+
+static void
+update_buttons (void)
+{
+  gtk_widget_set_sensitive (up_button, scale < 32);
+  gtk_widget_set_sensitive (down_button, scale > 1);
+}
+
+static void
+scale_up (void)
+{
+  scale += 1;
+  update_buttons ();
+  update_image ();
+}
+
+static void
+scale_down (void)
+{
+  scale -= 1;
+  update_buttons ();
+  update_image ();
+}
+
+GtkWidget *
+do_fontrendering (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkBuilder *builder;
+
+      builder = gtk_builder_new_from_resource ("/fontrendering/fontrendering.ui");
+      gtk_builder_connect_signals (builder, NULL);
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (on_destroy), NULL);
+      g_object_set_data_full (G_OBJECT (window), "builder", builder, g_object_unref);
+      font_button = GTK_WIDGET (gtk_builder_get_object (builder, "font_button"));
+      up_button = GTK_WIDGET (gtk_builder_get_object (builder, "up_button"));
+      down_button = GTK_WIDGET (gtk_builder_get_object (builder, "down_button"));
+      entry = GTK_WIDGET (gtk_builder_get_object (builder, "entry"));
+      image = GTK_WIDGET (gtk_builder_get_object (builder, "image"));
+      hinting = GTK_WIDGET (gtk_builder_get_object (builder, "hinting"));
+      hint_metrics = GTK_WIDGET (gtk_builder_get_object (builder, "hint_metrics"));
+      text_radio = GTK_WIDGET (gtk_builder_get_object (builder, "text_radio"));
+      show_grid = GTK_WIDGET (gtk_builder_get_object (builder, "show_grid"));
+      show_extents = GTK_WIDGET (gtk_builder_get_object (builder, "show_extents"));
+
+      g_signal_connect (up_button, "clicked", G_CALLBACK (scale_up), NULL);
+      g_signal_connect (down_button, "clicked", G_CALLBACK (scale_down), NULL);
+      g_signal_connect (entry, "notify::text", G_CALLBACK (update_image), NULL);
+      g_signal_connect (font_button, "notify::font-desc", G_CALLBACK (update_image), NULL);
+      g_signal_connect (hinting, "notify::active", G_CALLBACK (update_image), NULL);
+      g_signal_connect (hint_metrics, "notify::active", G_CALLBACK (update_image), NULL);
+      g_signal_connect (text_radio, "notify::active", G_CALLBACK (update_image), NULL);
+      g_signal_connect (show_grid, "notify::active", G_CALLBACK (update_image), NULL);
+      g_signal_connect (show_extents, "notify::active", G_CALLBACK (update_image), NULL);
+
+      update_image ();
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

demos/gtk-demo/fontrendering.ui

@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkAdjustment" id="scale_adj">
+    <property name="upper">24</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">4</property>
+  </object>
+  <object class="GtkWindow" id="window">
+    <property name="default-width">600</property>
+    <property name="default-height">300</property>
+    <property name="title">Font rendering</property>
+    <child>
+      <object class="GtkGrid">
+        <property name="margin-top">10</property>
+        <property name="row-spacing">10</property>
+        <property name="column-spacing">10</property>
+        <child>
+          <object class="GtkLabel">
+            <property name="margin-start">10</property>
+            <property name="label">Text</property>
+            <property name="xalign">1</property>
+            <style>
+              <class name="dim-label"/>
+            </style>
+          </object>
+        </child>
+        <child>
+          <object class="GtkEntry" id="entry">
+            <property name="text">Fonts render</property>
+            <layout>
+              <property name="left-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="margin-start">10</property>
+            <property name="label">Font</property>
+            <property name="xalign">1</property>
+            <style>
+              <class name="dim-label"/>
+            </style>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkFontButton" id="font_button">
+            <layout>
+              <property name="left-attach">1</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="label">Hinting</property>
+            <property name="xalign">1</property>
+            <style>
+              <class name="dim-label"/>
+            </style>
+            <layout>
+              <property name="left-attach">2</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkComboBoxText" id="hinting">
+            <property name="active">0</property>
+            <property name="valign">center</property>
+            <items>
+              <item translatable="yes" id="none">None</item>
+              <item translatable="yes" id="slight">Slight</item>
+              <item translatable="yes" id="medium">Medium</item>
+              <item translatable="yes" id="full">Full</item>
+            </items>
+            <layout>
+              <property name="left-attach">3</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkCheckButton" id="hint_metrics">
+            <child>
+              <object class="GtkLabel">
+                <property name="label">Hint Metrics</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <layout>
+              <property name="left-attach">3</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkCheckButton" id="show_extents">
+            <property name="active">1</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="label">Show Extents</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <layout>
+              <property name="left-attach">4</property>
+              <property name="top-attach">0</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkCheckButton" id="show_grid">
+            <property name="active">1</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="label">Show Grid</property>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+            <layout>
+              <property name="left-attach">4</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="up_button">
+            <property name="icon-name">list-add-symbolic</property>
+            <style>
+              <class name="circular"/>
+            </style>
+            <layout>
+              <property name="left-attach">5</property>
+              <property name="top-attach">0</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="down_button">
+            <property name="icon-name">list-remove-symbolic</property>
+            <style>
+              <class name="circular"/>
+            </style>
+            <layout>
+              <property name="left-attach">5</property>
+              <property name="top-attach">1</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkLabel">
+            <property name="hexpand">1</property>
+            <layout>
+              <property name="left-attach">6</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="orientation">horizontal</property>
+            <property name="halign">center</property>
+            <property name="valign">center</property>
+            <style><class name="linked"/></style>
+            <child>
+              <object class="GtkRadioButton" id="text_radio">
+                <property name="draw-indicator">0</property>
+                <property name="label">Text</property>
+              </object>
+            </child>
+            <child>
+              <object class="GtkRadioButton" id="grid_radio">
+                <property name="draw-indicator">0</property>
+                <property name="label">Grid</property>
+                <property name="group">text_radio</property>
+              </object>
+            </child>
+            <layout>
+             <property name="left-attach">0</property>
+              <property name="top-attach">3</property>
+              <property name="column-span">7</property>
+            </layout>
+          </object>
+        </child>
+        <child>
+          <object class="GtkScrolledWindow">
+            <property name="propagate-natural-height">1</property>
+            <property name="shadow-type">in</property>
+            <property name="hexpand">1</property>
+            <property name="vexpand">1</property>
+            <child>
+              <object class="GtkPicture" id="image">
+                <property name="halign">center</property>
+                <property name="valign">center</property>
+                <property name="can-shrink">0</property>
+              </object>
+            </child>
+            <layout>
+              <property name="left-attach">0</property>
+              <property name="top-attach">4</property>
+              <property name="column-span">7</property>
+            </layout>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

demos/gtk-demo/foreigndrawing.c

@@ -829,7 +829,6 @@ draw_spinbutton (GtkWidget *widget,
   GtkStyleContext *down_context;
   GtkIconTheme *icon_theme;
   GtkIconInfo *icon_info;
-  GdkPixbuf *pixbuf;
   GdkTexture *texture;
   gint icon_width, icon_height, icon_size;
   gint button_width;
@@ -857,26 +856,22 @@ draw_spinbutton (GtkWidget *widget,
                          "min-width", &icon_width, "min-height", &icon_height, NULL);
   icon_size = MIN (icon_width, icon_height);
   icon_info = gtk_icon_theme_lookup_icon (icon_theme, "list-add-symbolic", icon_size, 0);
-  pixbuf = gtk_icon_info_load_symbolic_for_context (icon_info, up_context, NULL, NULL);
-  texture = gdk_texture_new_for_pixbuf (pixbuf);
+  texture = GDK_TEXTURE (gtk_icon_info_load_symbolic_for_context (icon_info, up_context, NULL, NULL));
   g_object_unref (icon_info);
   draw_style_common (up_context, cr, x + width - button_width, y, button_width, *height,
                      &contents_x, &contents_y, &contents_width, &contents_height);
   gtk_render_icon (up_context, cr, texture, contents_x, contents_y + (contents_height - icon_size) / 2);
-  g_object_unref (pixbuf);
   g_object_unref (texture);
 
   gtk_style_context_get (down_context,
                          "min-width", &icon_width, "min-height", &icon_height, NULL);
   icon_size = MIN (icon_width, icon_height);
   icon_info = gtk_icon_theme_lookup_icon (icon_theme, "list-remove-symbolic", icon_size, 0);
-  pixbuf = gtk_icon_info_load_symbolic_for_context (icon_info, down_context, NULL, NULL);
-  texture = gdk_texture_new_for_pixbuf (pixbuf);
+  texture = GDK_TEXTURE (gtk_icon_info_load_symbolic_for_context (icon_info, down_context, NULL, NULL));
   g_object_unref (icon_info);
   draw_style_common (down_context, cr, x + width - 2 * button_width, y, button_width, *height,
                      &contents_x, &contents_y, &contents_width, &contents_height);
   gtk_render_icon (down_context, cr, texture, contents_x, contents_y + (contents_height - icon_size) / 2);
-  g_object_unref (pixbuf);
   g_object_unref (texture);
 
   g_object_unref (down_context);

demos/gtk-demo/geninclude.py

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

demos/gtk-demo/glarea.c

@@ -241,7 +241,7 @@ realize (GtkWidget *widget)
       fragment_path = "/glarea/glarea-gl.fs.glsl";
     }
 
-  init_buffers (&position_buffer, NULL);
+  init_buffers (NULL, &position_buffer);
   init_shaders (vertex_path, fragment_path, &program, &mvp_location);
 }
 

demos/gtk-demo/iconscroll.c

@@ -0,0 +1,185 @@
+/* Benchmark/Scrolling
+ *
+ * This demo scrolls a view with various content.
+ */
+
+#include <gtk/gtk.h>
+
+static guint tick_cb;
+static GtkAdjustment *adjustment;
+static GtkWidget *window = NULL;
+static GtkWidget *scrolledwindow;
+static int selected;
+
+#define N_WIDGET_TYPES 3
+
+
+int increment = 5;
+
+static gboolean
+scroll_cb (GtkWidget *widget,
+           GdkFrameClock *frame_clock,
+           gpointer data)
+{
+  double value;
+
+  value = gtk_adjustment_get_value (adjustment);
+  if (value + increment <= gtk_adjustment_get_lower (adjustment) ||
+     (value + increment >= gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_page_size (adjustment)))
+    increment = - increment;
+
+  gtk_adjustment_set_value (adjustment, value + increment);
+
+  return G_SOURCE_CONTINUE;
+}
+
+extern GtkWidget *create_icon (void);
+
+static void
+populate_icons (void)
+{
+  GtkWidget *grid;
+  int top, left;
+
+  grid = gtk_grid_new ();
+  gtk_widget_set_halign (grid, GTK_ALIGN_CENTER);
+  g_object_set (grid, "margin", 10, NULL);
+  gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
+  gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
+
+  for (top = 0; top < 100; top++)
+    for (left = 0; left < 15; left++)
+      gtk_grid_attach (GTK_GRID (grid), create_icon (), left, top, 1, 1);
+
+  gtk_container_add (GTK_CONTAINER (scrolledwindow), grid);
+}
+
+static char *content;
+static gsize content_len;
+
+extern void fontify (GtkTextBuffer *buffer);
+
+static void
+populate_text (gboolean hilight)
+{
+  GtkWidget *textview;
+  GtkTextBuffer *buffer;
+
+  if (!content)
+    {
+      GBytes *bytes;
+
+      bytes = g_resources_lookup_data ("/sources/font_features.c", 0, NULL);
+      content = g_bytes_unref_to_data (bytes, &content_len);
+    }
+
+  buffer = gtk_text_buffer_new (NULL);
+  gtk_text_buffer_set_text (buffer, content, (int)content_len);
+
+  if (hilight)
+    fontify (buffer);
+
+  textview = gtk_text_view_new ();
+  gtk_text_view_set_buffer (GTK_TEXT_VIEW (textview), buffer);
+
+  gtk_container_add (GTK_CONTAINER (scrolledwindow), textview);
+}
+
+static void
+set_widget_type (int type)
+{
+  if (tick_cb)
+    gtk_widget_remove_tick_callback (window, tick_cb);
+
+  if (gtk_bin_get_child (GTK_BIN (scrolledwindow)))
+    gtk_container_remove (GTK_CONTAINER (scrolledwindow),
+                          gtk_bin_get_child (GTK_BIN (scrolledwindow)));
+
+  selected = type;
+
+  switch (selected)
+    {
+    case 0:
+      gtk_window_set_title (GTK_WINDOW (window), "Scrolling icons");
+      populate_icons ();
+      break;
+
+    case 1:
+      gtk_window_set_title (GTK_WINDOW (window), "Scrolling plain text");
+      populate_text (FALSE);
+      break;
+
+    case 2:
+      gtk_window_set_title (GTK_WINDOW (window), "Scrolling complex text");
+      populate_text (TRUE);
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+
+  tick_cb = gtk_widget_add_tick_callback (window, scroll_cb, NULL, NULL);
+}
+
+static void
+next_clicked_cb (GtkButton *source,
+                 gpointer   user_data)
+{
+  int new_index;
+
+  if (selected + 1 >= N_WIDGET_TYPES)
+    new_index = 0;
+  else
+    new_index = selected + 1;
+ 
+
+  set_widget_type (new_index);
+}
+
+static void
+prev_clicked_cb (GtkButton *source,
+                 gpointer   user_data)
+{
+  int new_index;
+
+  if (selected - 1 < 0)
+    new_index = N_WIDGET_TYPES - 1;
+  else
+    new_index = selected - 1;
+
+  set_widget_type (new_index);
+}
+
+GtkWidget *
+do_iconscroll (GtkWidget *do_widget)
+{
+  if (!window)
+    {
+      GtkBuilder *builder;
+
+      builder = gtk_builder_new_from_resource ("/iconscroll/iconscroll.ui");
+      gtk_builder_add_callback_symbols (builder,
+                                        "next_clicked_cb", G_CALLBACK (next_clicked_cb),
+                                        "prev_clicked_cb", G_CALLBACK (prev_clicked_cb),
+                                        NULL);
+      gtk_builder_connect_signals (builder, NULL);
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+      scrolledwindow = GTK_WIDGET (gtk_builder_get_object (builder, "scrolledwindow"));
+      gtk_widget_realize (window);
+      adjustment = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment"));
+      set_widget_type (0);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

demos/gtk-demo/iconscroll.ui

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="resizable">0</property>
+    <property name="default-width">500</property>
+    <property name="default-height">500</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <property name="show-title-buttons">1</property>
+        <child>
+          <object class="GtkBox">
+            <style>
+              <class name="linked"/>
+            </style>
+            <child>
+              <object class="GtkButton">
+                <property name="icon-name">pan-start-symbolic</property>
+                <signal name="clicked" handler="prev_clicked_cb"/>
+              </object>
+            </child>
+            <child>
+              <object class="GtkButton">
+                <property name="icon-name">pan-end-symbolic</property>
+                <signal name="clicked" handler="next_clicked_cb"/>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkScrolledWindow" id="scrolledwindow">
+        <property name="hscrollbar-policy">never</property>
+        <property name="vscrollbar-policy">automatic</property>
+        <property name="vadjustment"><object class="GtkAdjustment" id="adjustment"/></property> 
+      </object>
+    </child>
+  </object>
+</interface>

demos/gtk-demo/infobar.c

@@ -68,7 +68,7 @@ do_infobar (GtkWidget *do_widget)
       gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_INFO);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_INFO");
-      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+      gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
       gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label);
 
@@ -80,7 +80,7 @@ do_infobar (GtkWidget *do_widget)
       gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_WARNING);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_WARNING");
-      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+      gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
       gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label);
 
@@ -94,7 +94,7 @@ do_infobar (GtkWidget *do_widget)
       gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_QUESTION);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_QUESTION");
-      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+      gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
       gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label);
 
@@ -106,7 +106,7 @@ do_infobar (GtkWidget *do_widget)
       gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_ERROR);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_ERROR");
-      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+      gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
       gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label);
 
@@ -119,7 +119,7 @@ do_infobar (GtkWidget *do_widget)
       gtk_container_add (GTK_CONTAINER (vbox), bar);
       gtk_info_bar_set_message_type (GTK_INFO_BAR (bar), GTK_MESSAGE_OTHER);
       label = gtk_label_new ("This is an info bar with message type GTK_MESSAGE_OTHER");
-      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+      gtk_label_set_wrap (GTK_LABEL (label), TRUE);
       gtk_label_set_xalign (GTK_LABEL (label), 0);
       gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (bar))), label);
 

demos/gtk-demo/language-names.c

@@ -202,7 +202,7 @@ languages_variant_init (const char *variant)
   else
     g_warning ("Failed to load '%s': %s\n", filename, error->message);
 
-  g_free (error);
+  g_clear_error (&error);
   g_free (filename);
   g_free (buf);
 }

demos/gtk-demo/listbox.c

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

demos/gtk-demo/listview_filebrowser.c

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

demos/gtk-demo/listview_filebrowser.ui

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

demos/gtk-demo/listview_minesweeper.c

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

demos/gtk-demo/listview_minesweeper.ui

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

demos/gtk-demo/listview_minesweeper_cell.ui

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

demos/gtk-demo/listview_settings.c

@@ -0,0 +1,147 @@
+/* Lists/Settings
+ *
+ * This demo shows a settings viwer for GSettings.
+ *
+ * It demonstrates how to implement support for trees with listview.
+ */
+
+#include <gtk/gtk.h>
+
+static int
+strvcmp (gconstpointer p1,
+         gconstpointer p2)
+{
+  const char * const *s1 = p1;
+  const char * const *s2 = p2;
+
+  return strcmp (*s1, *s2);
+}
+
+static GListModel *
+create_settings_model (gpointer item,
+                       gpointer unused)
+{
+  GSettings *settings = item;
+  char **schemas;
+  GListStore *result;
+  guint i;
+
+  if (settings == NULL)
+    {
+      g_settings_schema_source_list_schemas (g_settings_schema_source_get_default (),
+                                             TRUE,
+                                             &schemas,
+                                             NULL);
+    }
+  else
+    {
+      schemas = g_settings_list_children (settings);
+    }
+
+  if (schemas == NULL || schemas[0] == NULL)
+    {
+      g_free (schemas);
+      return NULL;
+    }
+
+  qsort (schemas, g_strv_length (schemas), sizeof (char *), strvcmp);
+
+  result = g_list_store_new (G_TYPE_SETTINGS);
+  for (i = 0;  schemas[i] != NULL; i++)
+    {
+      GSettings *child;
+
+      if (settings == NULL)
+        child = g_settings_new (schemas[i]);
+      else
+        child = g_settings_get_child (settings, schemas[i]);
+
+      g_list_store_append (result, child);
+      g_object_unref (child);
+    }
+
+  return G_LIST_MODEL (result);
+}
+
+static void
+setup_widget (GtkListItem *list_item,
+              gpointer     unused)
+{
+  GtkWidget *label, *expander;
+
+  expander = gtk_tree_expander_new ();
+  gtk_container_add (GTK_CONTAINER (list_item), expander);
+
+  label = gtk_label_new (NULL);
+  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+  gtk_tree_expander_set_child (GTK_TREE_EXPANDER (expander), label);
+}
+
+static void
+bind_widget (GtkListItem *list_item,
+             gpointer     unused)
+{
+  GSettings *settings;
+  GtkWidget *label, *expander;
+  GSettingsSchema *schema;
+
+  expander = gtk_bin_get_child (GTK_BIN (list_item));
+  gtk_tree_expander_set_list_row (GTK_TREE_EXPANDER (expander), gtk_list_item_get_item (list_item));
+  label = gtk_tree_expander_get_child (GTK_TREE_EXPANDER (expander));
+  settings = gtk_tree_expander_get_item (GTK_TREE_EXPANDER (expander));
+
+  g_object_get (settings, "settings-schema", &schema, NULL);
+
+  gtk_label_set_label (GTK_LABEL (label), g_settings_schema_get_id (schema));
+
+  g_settings_schema_unref (schema);
+}
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_listview_settings (GtkWidget *do_widget)
+{
+  if (window == NULL)
+    {
+      GtkWidget *listview, *sw;;
+      GListModel *model;
+      GtkTreeListModel *treemodel;
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_default_size (GTK_WINDOW (window), 400, 600);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_title (GTK_WINDOW (window), "Settings");
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK(gtk_widget_destroyed), &window);
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_container_add (GTK_CONTAINER (window), sw);
+    
+      listview = gtk_list_view_new_with_factory (
+        gtk_functions_list_item_factory_new (setup_widget,
+                                             bind_widget,
+                                             NULL, NULL));
+
+      model = create_settings_model (NULL, NULL);
+      treemodel = gtk_tree_list_model_new (FALSE,
+                                           model,
+                                           TRUE,
+                                           create_settings_model,
+                                           NULL,
+                                           NULL);
+      gtk_list_view_set_model (GTK_LIST_VIEW (listview), G_LIST_MODEL (treemodel));
+      g_object_unref (treemodel);
+      g_object_unref (model);
+
+      gtk_container_add (GTK_CONTAINER (sw), listview);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

demos/gtk-demo/listview_weather.c

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

demos/gtk-demo/main-listitem.ui

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GtkListItem">
+    <child>
+      <object class="GtkTreeExpander" id="expander">
+        <binding name="list-row">GtkListItem.item</binding>
+        <property name="child">
+          <object class="GtkBox">
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkLabel">
+                <property name="halign">start</property>
+                <binding name="label">expander.item:GtkDemo.title</binding>
+              </object>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <binding name="visible">!expander.list-row.expandable</binding>
+                <property name="halign">start</property>
+                <property name="use-markup">1</property>
+                <binding name="label">"&lt;small&gt;" + expander.item:GtkDemo.filename + "&lt;/small&gt;"</binding>
+                <style>
+                  <class name="dim-label"/>
+                </style>
+              </object>
+            </child>
+          </object>
+        </property>
+      </object>
+    </child>
+  </template>
+</interface>

demos/gtk-demo/main.c

@@ -8,6 +8,7 @@
 #include <gtk/gtk.h>
 #include <glib/gstdio.h>
 
+#include "award.h"
 #include "demos.h"
 
 static GtkWidget *info_view;
@@ -15,19 +16,99 @@ static GtkWidget *source_view;
 
 static gchar *current_file = NULL;
 
+static GtkWidget *window;
 static GtkWidget *notebook;
-static GtkWidget *treeview;
+static GtkWidget *listview;
+static GtkSingleSelection *selection;
 static GtkWidget *headerbar;
 
-enum {
-  NAME_COLUMN,
-  TITLE_COLUMN,
-  FILENAME_COLUMN,
-  FUNC_COLUMN,
-  STYLE_COLUMN,
-  NUM_COLUMNS
+typedef struct _GtkDemo GtkDemo;
+struct _GtkDemo
+{
+  GObject parent_instance;
+
+  const char *name;
+  const char *title;
+  const char *filename;
+  GDoDemoFunc func;
+  GListModel *children_model;
 };
 
+enum {
+  PROP_0,
+  PROP_FILENAME,
+  PROP_NAME,
+  PROP_TITLE,
+
+  N_PROPS
+};
+
+# define GTK_TYPE_DEMO (gtk_demo_get_type ())
+G_DECLARE_FINAL_TYPE (GtkDemo, gtk_demo, GTK, DEMO, GObject);
+
+G_DEFINE_TYPE (GtkDemo, gtk_demo, G_TYPE_OBJECT);
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gtk_demo_get_property (GObject    *object,
+                       guint       property_id,
+                       GValue     *value,
+                       GParamSpec *pspec)
+{
+  GtkDemo *self = GTK_DEMO (object);
+
+  switch (property_id)
+    {
+    case PROP_FILENAME:
+      g_value_set_string (value, self->filename);
+      break;
+
+    case PROP_NAME:
+      g_value_set_string (value, self->name);
+      break;
+
+    case PROP_TITLE:
+      g_value_set_string (value, self->title);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void gtk_demo_class_init (GtkDemoClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = gtk_demo_get_property;
+
+  properties[PROP_FILENAME] =
+    g_param_spec_string ("filename",
+                         "filename",
+                         "filename",
+                         NULL,
+                         G_PARAM_READABLE);
+  properties[PROP_NAME] =
+    g_param_spec_string ("name",
+                         "name",
+                         "name",
+                         NULL,
+                         G_PARAM_READABLE);
+  properties[PROP_TITLE] =
+    g_param_spec_string ("title",
+                         "title",
+                         "title",
+                         NULL,
+                         G_PARAM_READABLE);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void gtk_demo_init (GtkDemo *self)
+{
+}
+
 typedef struct _CallbackData CallbackData;
 struct _CallbackData
 {
@@ -35,6 +116,27 @@ struct _CallbackData
   GtkTreePath *path;
 };
 
+static gboolean
+gtk_demo_run (GtkDemo   *self,
+              GtkWidget *window)
+{
+  GtkWidget *result;
+
+  if (!self->func)
+    return FALSE;
+
+  result = self->func (window);
+  if (result == NULL)
+    return FALSE;
+
+  if (GTK_IS_WINDOW (result))
+    {
+      gtk_window_set_transient_for (GTK_WINDOW (result), GTK_WINDOW (window));
+      gtk_window_set_modal (GTK_WINDOW (result), TRUE);
+    }
+  return TRUE;
+}
+              
 static void
 activate_about (GSimpleAction *action,
                 GVariant      *parameter,
@@ -111,69 +213,7 @@ activate_inspector (GSimpleAction *action,
                     gpointer       user_data)
 {
   gtk_window_set_interactive_debugging (TRUE);
-}
-
-static void
-window_closed_cb (GtkWidget *window, gpointer data)
-{
-  CallbackData *cbdata = data;
-  GtkTreeIter iter;
-  PangoStyle style;
-
-  gtk_tree_model_get_iter (cbdata->model, &iter, cbdata->path);
-  gtk_tree_model_get (GTK_TREE_MODEL (cbdata->model), &iter,
-                      STYLE_COLUMN, &style,
-                      -1);
-  if (style == PANGO_STYLE_ITALIC)
-    gtk_tree_store_set (GTK_TREE_STORE (cbdata->model), &iter,
-                        STYLE_COLUMN, PANGO_STYLE_NORMAL,
-                        -1);
-
-  gtk_tree_path_free (cbdata->path);
-  g_free (cbdata);
-}
-
-static void
-run_example_for_row (GtkWidget    *window,
-                     GtkTreeModel *model,
-                     GtkTreeIter  *iter)
-{
-  PangoStyle style;
-  GDoDemoFunc func;
-  GtkWidget *demo;
-
-  gtk_tree_model_get (GTK_TREE_MODEL (model),
-                      iter,
-                      FUNC_COLUMN, &func,
-                      STYLE_COLUMN, &style,
-                      -1);
-
-  if (func)
-    {
-      gtk_tree_store_set (GTK_TREE_STORE (model),
-                          iter,
-                          STYLE_COLUMN, (style == PANGO_STYLE_ITALIC ? PANGO_STYLE_NORMAL : PANGO_STYLE_ITALIC),
-                          -1);
-      demo = (func) (window);
-
-      if (demo != NULL)
-        {
-          CallbackData *cbdata;
-
-          cbdata = g_new (CallbackData, 1);
-          cbdata->model = model;
-          cbdata->path = gtk_tree_model_get_path (model, iter);
-
-          if (GTK_IS_WINDOW (demo))
-            {
-              gtk_window_set_transient_for (GTK_WINDOW (demo), GTK_WINDOW (window));
-              gtk_window_set_modal (GTK_WINDOW (demo), TRUE);
-            }
-
-          g_signal_connect (demo, "destroy",
-                            G_CALLBACK (window_closed_cb), cbdata);
-        }
-    }
+  award ("demo-inspector");
 }
 
 static void
@@ -181,14 +221,10 @@ activate_run (GSimpleAction *action,
               GVariant      *parameter,
               gpointer       user_data)
 {
-  GtkWidget *window = user_data;
-  GtkTreeSelection *selection;
-  GtkTreeModel *model;
-  GtkTreeIter iter;
+  GtkTreeListRow *row = gtk_single_selection_get_selected_item (selection);
+  GtkDemo *demo = gtk_tree_list_row_get_item (row);
 
-  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
-  if (gtk_tree_selection_get_selected (selection, &model, &iter))
-    run_example_for_row (window, model, &iter);
+  gtk_demo_run (demo, window);
 }
 
 /* Stupid syntax highlighting.
@@ -487,7 +523,7 @@ parse_chars (gchar     *text,
 }
 
 /* While not as cool as c-mode, this will do as a quick attempt at highlighting */
-static void
+void
 fontify (GtkTextBuffer *source_buffer)
 {
   GtkTextIter start_iter, next_iter, tmp_iter;
@@ -639,7 +675,7 @@ display_nothing (const char *resource)
 
   str = g_strdup_printf ("The lazy GTK developers forgot to add a way to display the resource '%s'", resource);
   widget = gtk_label_new (str);
-  gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
+  gtk_label_set_wrap (GTK_LABEL (widget), TRUE);
 
   g_free (str);
 
@@ -888,81 +924,72 @@ load_file (const gchar *demoname,
 }
 
 static void
-selection_cb (GtkTreeSelection *selection,
-              GtkTreeModel     *model)
+
+selection_cb (GtkSingleSelection *selection,
+              GParamSpec         *pspec,
+              gpointer            user_data)
 {
-  GtkTreeIter iter;
-  char *name;
-  char *filename;
-  char *title;
+  GtkTreeListRow *row = gtk_single_selection_get_selected_item (selection);
+  GtkDemo *demo = gtk_tree_list_row_get_item (row);
 
-  if (! gtk_tree_selection_get_selected (selection, NULL, &iter))
-    return;
+  if (demo->filename)
+    load_file (demo->name, demo->filename);
 
-  gtk_tree_model_get (model, &iter,
-                      NAME_COLUMN, &name,
-                      TITLE_COLUMN, &title,
-                      FILENAME_COLUMN, &filename,
-                      -1);
-
-  if (filename)
-    load_file (name, filename);
-
-  gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), title);
-
-  g_free (name);
-  g_free (title);
-  g_free (filename);
+  gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), demo->title);
 }
 
-static void
-populate_model (GtkTreeModel *model)
+static GListModel *
+create_demo_model (void)
 {
-  Demo *d = gtk_demos;
+  GListStore *store = g_list_store_new (GTK_TYPE_DEMO);
+  DemoData *demo = gtk_demos;
 
-  /* this code only supports 1 level of children. If we
-   * want more we probably have to use a recursing function.
-   */
-  while (d->title)
+  while (demo->title)
     {
-      Demo *children = d->children;
-      GtkTreeIter iter;
+      GtkDemo *d = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
+      DemoData *children = demo->children;
 
-      gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
+      d->name = demo->name;
+      d->title = demo->title;
+      d->filename = demo->filename;
+      d->func = demo->func;
 
-      gtk_tree_store_set (GTK_TREE_STORE (model),
-                          &iter,
-                          NAME_COLUMN, d->name,
-                          TITLE_COLUMN, d->title,
-                          FILENAME_COLUMN, d->filename,
-                          FUNC_COLUMN, d->func,
-                          STYLE_COLUMN, PANGO_STYLE_NORMAL,
-                          -1);
+      g_list_store_append (store, d);
 
-      d++;
-
-      if (!children)
-        continue;
-
-      while (children->title)
+      if (children)
         {
-          GtkTreeIter child_iter;
+          d->children_model = G_LIST_MODEL (g_list_store_new (GTK_TYPE_DEMO));
 
-          gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter);
+          while (children->title)
+            {
+              GtkDemo *child = GTK_DEMO (g_object_new (GTK_TYPE_DEMO, NULL));
 
-          gtk_tree_store_set (GTK_TREE_STORE (model),
-                              &child_iter,
-                              NAME_COLUMN, children->name,
-                              TITLE_COLUMN, children->title,
-                              FILENAME_COLUMN, children->filename,
-                              FUNC_COLUMN, children->func,
-                              STYLE_COLUMN, PANGO_STYLE_NORMAL,
-                              -1);
+              child->name = children->name;
+              child->title = children->title;
+              child->filename = children->filename;
+              child->func = children->func;
 
-          children++;
+              g_list_store_append (G_LIST_STORE (d->children_model), child);
+              children++;
+            }
         }
+
+      demo++;
     }
 
+  return G_LIST_MODEL (store);
+}
+
+static GListModel *
+get_child_model (gpointer item,
+                 gpointer user_data)
+{
+  GtkDemo *demo = item;
+
+  if (demo->children_model)
+    return g_object_ref (G_LIST_MODEL (demo->children_model));
+
+  return NULL;
 }
 
 static void
@@ -982,22 +1009,6 @@ startup (GApplication *app)
   g_object_unref (builder);
 }
 
-static void
-row_activated_cb (GtkWidget         *tree_view,
-                  GtkTreePath       *path,
-                  GtkTreeViewColumn *column)
-{
-  GtkTreeIter iter;
-  GtkWidget *window;
-  GtkTreeModel *model;
-
-  window = GTK_WIDGET (gtk_widget_get_root (tree_view));
-  model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
-  gtk_tree_model_get_iter (model, &iter, path);
-
-  run_example_for_row (window, model, &iter);
-}
-
 static void
 start_cb (GtkMenuItem *item, GtkWidget *scrollbar)
 {
@@ -1024,34 +1035,45 @@ scrollbar_popup (GtkWidget *scrollbar, GtkWidget *menu)
   return TRUE;
 }
 
+static void
+listview_activate_cb (GtkCoverFlow *listview,
+                      guint         position,
+                      gpointer      user_data)
+{
+  GtkTreeListRow *row = g_list_model_get_item (gtk_cover_flow_get_model (listview), position);
+  GtkDemo *demo = gtk_tree_list_row_get_item (row);
+
+  gtk_demo_run (demo, window);
+}
+
 static void
 activate (GApplication *app)
 {
   GtkBuilder *builder;
-  GtkWindow *window;
-  GtkWidget *widget;
-  GtkTreeModel *model;
-  GtkTreeIter iter;
   GError *error = NULL;
   GtkWidget *sw;
   GtkWidget *scrollbar;
   GtkWidget *menu;
   GtkWidget *item;
+  GListModel *listmodel;
+  GtkTreeListModel *treemodel;
 
   static GActionEntry win_entries[] = {
     { "run", activate_run, NULL, NULL, NULL }
   };
 
   builder = gtk_builder_new ();
+  gtk_builder_add_callback_symbol (builder, "listview_activate_cb", G_CALLBACK (listview_activate_cb));
   gtk_builder_add_from_resource (builder, "/ui/main.ui", &error);
   if (error != NULL)
     {
       g_critical ("%s", error->message);
       exit (1);
     }
+  gtk_builder_connect_signals (builder, NULL);
 
-  window = (GtkWindow *)gtk_builder_get_object (builder, "window");
-  gtk_application_add_window (GTK_APPLICATION (app), window);
+  window = (GtkWidget *)gtk_builder_get_object (builder, "window");
+  gtk_application_add_window (GTK_APPLICATION (app), GTK_WINDOW (window));
   g_action_map_add_action_entries (G_ACTION_MAP (window),
                                    win_entries, G_N_ELEMENTS (win_entries),
                                    window);
@@ -1061,8 +1083,7 @@ 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));
+  listview = (GtkWidget *)gtk_builder_get_object (builder, "listview");
 
   sw = (GtkWidget *)gtk_builder_get_object (builder, "source-scrolledwindow");
   scrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (sw));
@@ -1081,17 +1102,19 @@ activate (GApplication *app)
 
   load_file (gtk_demos[0].name, gtk_demos[0].filename);
 
-  populate_model (model);
+  listmodel = create_demo_model ();
+  treemodel = gtk_tree_list_model_new (FALSE,
+                                       G_LIST_MODEL (listmodel),
+                                       FALSE,
+                                       get_child_model,
+                                       NULL,
+                                       NULL);
+  selection = gtk_single_selection_new (G_LIST_MODEL (treemodel));
+  g_signal_connect (selection, "notify::selected-item", G_CALLBACK (selection_cb), NULL);
+  gtk_cover_flow_set_model (GTK_COVER_FLOW (listview),
+                            G_LIST_MODEL (selection));
 
-  g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model);
-
-  widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection");
-  g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model);
-
-  gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter);
-  gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter);
-
-  gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview));
+  award ("demo-start");
 
   gtk_widget_show (GTK_WIDGET (window));
 
@@ -1108,7 +1131,7 @@ auto_quit (gpointer data)
 static void
 list_demos (void)
 {
-  Demo *d, *c;
+  DemoData *d, *c;
 
   d = gtk_demos;
 
@@ -1135,7 +1158,7 @@ command_line (GApplication            *app,
   const gchar *name = NULL;
   gboolean autoquit = FALSE;
   gboolean list = FALSE;
-  Demo *d, *c;
+  DemoData *d, *c;
   GDoDemoFunc func = 0;
   GtkWidget *window, *demo;
 

demos/gtk-demo/main.ui

@@ -28,7 +28,6 @@
     <property name="default-width">800</property>
     <property name="default-height">600</property>
     <property name="title">GTK Demo</property>
-    <signal name="destroy" handler="gtk_main_quit" swapped="no"/>
     <child type="titlebar">
       <object class="GtkHeaderBar" id="headerbar">
         <property name="show-title-buttons">1</property>
@@ -66,32 +65,15 @@
                 <property name="can-focus">1</property>
                 <property name="hscrollbar-policy">never</property>
                 <property name="min-content-width">150</property>
+
                 <child>
-                  <object class="GtkTreeView" id="treeview">
-                    <property name="can-focus">1</property>
-                    <property name="model">treestore</property>
-                    <property name="headers-visible">0</property>
-                    <child internal-child="selection">
-                      <object class="GtkTreeSelection" id="treeview-selection">
-                        <property name="mode">browse</property>
+                  <object class="GtkCoverFlow" id="listview">
+                    <signal name="activate" handler="listview_activate_cb" swapped="no" />
+                    <property name="factory">
+                      <object class="GtkBuilderListItemFactory">
+                        <property name="resource">/ui/main-listitem.ui</property>
                       </object>
-                    </child>
-                    <child>
-                      <object class="GtkTreeViewColumn">
-                        <child>
-                          <object class="GtkCellRendererText"/>
-                          <attributes>
-                            <attribute name="style">4</attribute>
-                            <attribute name="text">1</attribute>
-                          </attributes>
-                        </child>
-                        <child>
-                          <object class="GtkCellRendererText">
-                            <property name="text">  </property>
-                          </object>
-                        </child>
-                      </object>
-                    </child>
+                    </property>
                   </object>
                 </child>
               </object>

demos/gtk-demo/meson.build

@@ -3,11 +3,15 @@
 demos = files([
   'application_demo.c',
   'assistant.c',
+  'awardview.c',
   'builder.c',
   'changedisplay.c',
   'clipboard.c',
   'colorsel.c',
   'combobox.c',
+  'constraints.c',
+  'constraints2.c',
+  'constraints3.c',
   'css_accordion.c',
   'css_basics.c',
   'css_blendmodes.c',
@@ -25,11 +29,13 @@ demos = files([
   'filtermodel.c',
   'fishbowl.c',
   'fixed.c',
+  'fontrendering.c',
   'foreigndrawing.c',
   'gestures.c',
   'glarea.c',
   'headerbar.c',
   'hypertext.c',
+  'iconscroll.c',
   'iconview.c',
   'iconview_edit.c',
   'images.c',
@@ -38,6 +44,10 @@ demos = files([
   'listbox.c',
   'flowbox.c',
   'list_store.c',
+  'listview_filebrowser.c',
+  'listview_minesweeper.c',
+  'listview_settings.c',
+  'listview_weather.c',
   'markup.c',
   'menus.c',
   'modelbutton.c',
@@ -80,6 +90,7 @@ demos = files([
 gtkdemo_deps = [ libgtk_dep, ]
 
 extra_demo_sources = files(['main.c',
+                            'award.c',
                             'gtkfishbowl.c',
                             'fontplane.c',
                             'gtkgears.c',

demos/gtk-demo/messages.txt

@@ -378,7 +378,7 @@
 378|GTK+ and friends|GTKtoolkit|#GNUStep gets #GTK+ theming http://is.gd/95vHl more at http://is.gd/95wt8|1267029498|0||0|1
 379|GTK+ and friends|GTKtoolkit|GTK+ 2.19.6 released: http://mail.gnome.org/archives/gtk-devel-list/2010-February/msg00050.html #gtk|1266966985|0||0|0
 380|GTK+ and friends|GTKtoolkit|Did you know that #GTK+ is the official toolkit for the #LiMo software stack? http://bit.ly/cuEdHx|1266925406|0||0|0
-381|GTK+ and friends|GTKtoolkit|@lmedinas publishes a #javascript #example on how to put an status icon with #Gtk+ http://bit.ly/9py1uC Thanks a lot Luis!|1266886644|0||1|1
+381|GTK+ and friends|GTKtoolkit|@lmedinas publishes a #javascript #example on how to put a status icon with #Gtk+ http://bit.ly/9py1uC Thanks a lot Luis!|1266886644|0||1|1
 382|GTK+ and friends|GTKtoolkit|♺ @ebassi: I should really finish up the GDom API as well|1266880653|0||0|0
 383|GTK+ and friends|GTKtoolkit|♺ @ebassi: I hope to work on this for the next GIO release, and the GTK+ side for 3.0|1266880641|0||0|0
 384|GTK+ and friends|GTKtoolkit|♺ @ebassi: just updated the ApplicationClass design wiki page with the stuff @Cwiiis did for Mx - http://bit.ly/cfAOJk|1266880559|0||0|0

demos/gtk-demo/modelbutton.ui

@@ -14,34 +14,19 @@
         <child>
           <object class="GtkMenuButton">
             <property name="popover">thing_a</property>
-            <child>
-              <object class="GtkLabel">
-                <property name="label">Color</property>
-                <property name="hexpand">1</property>
-              </object>
-            </child>
+            <property name="label">Color</property>
           </object>
         </child>
         <child>
           <object class="GtkMenuButton">
             <property name="popover">thing_b</property>
-            <child>
-              <object class="GtkLabel">
-                <property name="label">Flavors</property>
-                <property name="hexpand">1</property>
-              </object>
-            </child>
+            <property name="label">Flavors</property>
           </object>
         </child>
         <child>
           <object class="GtkMenuButton">
             <property name="popover">thing_c</property>
-            <child>
-              <object class="GtkLabel">
-                <property name="label">Tools</property>
-                <property name="hexpand">1</property>
-              </object>
-            </child>
+            <property name="label">Tools</property>
           </object>
         </child>
       </object>
@@ -57,7 +42,6 @@
             <property name="action-name">win.color</property>
             <property name="action-target">&apos;red&apos;</property>
             <property name="text">Red</property>
-            <property name="inverted">1</property>
           </object>
         </child>
         <child>
@@ -65,7 +49,6 @@
             <property name="action-name">win.color</property>
             <property name="action-target">&apos;green&apos;</property>
             <property name="text">Green</property>
-            <property name="inverted">1</property>
           </object>
         </child>
         <child>
@@ -73,7 +56,6 @@
             <property name="action-name">win.color</property>
             <property name="action-target">&apos;blue&apos;</property>
             <property name="text">Blue</property>
-            <property name="inverted">1</property>
           </object>
         </child>
       </object>

demos/gtk-demo/paintable_mediastream.c

@@ -6,7 +6,7 @@
  * GTK uses for videos. This allows treating the icon like a
  * regular video, so we can for example attach controls to it.
  *
- * After all, what good is an media_stream if one cannot pause
+ * After all, what good is a media_stream if one cannot pause
  * it.
  */
 

demos/gtk-demo/password_entry.c

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

demos/gtk-demo/sidebar.c

@@ -54,10 +54,7 @@ do_sidebar (GtkWidget *do_widget)
       stack = gtk_stack_new ();
       gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
       gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
-
-      /* Separator between sidebar and stack */
-      widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
-      gtk_container_add (GTK_CONTAINER(box), widget);
+      gtk_widget_set_hexpand (stack, TRUE);
 
       gtk_container_add (GTK_CONTAINER (box), stack);
 
@@ -66,6 +63,7 @@ do_sidebar (GtkWidget *do_widget)
           if (i == 0)
             {
               widget = gtk_image_new_from_icon_name ("org.gtk.Demo4");
+              gtk_style_context_add_class (gtk_widget_get_style_context (widget), "icon-dropshadow");
               gtk_image_set_pixel_size (GTK_IMAGE (widget), 256);
             }
           else

demos/gtk-demo/sliding_puzzle.c

@@ -11,6 +11,9 @@
 #include "puzzlepiece.h"
 #include "paintable.h"
 
+/* Give out awards */
+#include "award.h"
+
 static GtkWidget *window = NULL;
 static GtkWidget *frame = NULL;
 static GtkWidget *choices = NULL;
@@ -156,6 +159,14 @@ check_solved (GtkWidget *grid)
   picture = gtk_grid_get_child_at (GTK_GRID (grid), pos_x, pos_y);
   gtk_picture_set_paintable (GTK_PICTURE (picture), piece);
 
+  /* Hand out a bunch of awards
+   */
+  award ("puzzle-solve");
+  if ((gdk_paintable_get_flags (piece) & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
+    award ("puzzle-solve-animated");
+  if (height * width > 20)
+    award ("puzzle-solve-large");
+
   return TRUE;
 }
 
@@ -401,6 +412,18 @@ add_choice (GtkWidget    *choices,
   gtk_container_add (GTK_CONTAINER (choices), icon);
 }
 
+static void
+widget_destroyed (GtkWidget      *widget,
+		  GtkWidget     **widget_pointer)
+{
+  if (widget_pointer)
+    *widget_pointer = NULL;
+
+  if (!solved)
+    award ("puzzle-give-up");
+}
+
+
 GtkWidget *
 do_sliding_puzzle (GtkWidget *do_widget)
 {
@@ -469,7 +492,7 @@ do_sliding_puzzle (GtkWidget *do_widget)
       gtk_window_set_titlebar (GTK_WINDOW (window), header);
       gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
       g_signal_connect (window, "destroy",
-                        G_CALLBACK (gtk_widget_destroyed), &window);
+                        G_CALLBACK (widget_destroyed), &window);
 
       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);

demos/gtk-demo/textview.c

@@ -128,18 +128,16 @@ insert_text (GtkTextBuffer *buffer)
 {
   GtkTextIter iter;
   GtkTextIter start, end;
-  GdkPixbuf *pixbuf;
   GdkTexture *texture;
   GtkIconTheme *icon_theme;
 
   icon_theme = gtk_icon_theme_get_default ();
-  pixbuf = gtk_icon_theme_load_icon (icon_theme,
-                                     "gtk3-demo",
-                                     32,
-                                     GTK_ICON_LOOKUP_GENERIC_FALLBACK,
-                                     NULL);
-  g_assert (pixbuf);
-  texture = gdk_texture_new_for_pixbuf (pixbuf);
+  texture = GDK_TEXTURE (gtk_icon_theme_load_icon (icon_theme,
+                                                   "gtk3-demo",
+                                                   32,
+                                                   GTK_ICON_LOOKUP_GENERIC_FALLBACK,
+                                                   NULL));
+  g_assert (texture);
 
   /* get start of buffer; each insertion will revalidate the
    * iterator to point to just after the inserted text.
@@ -379,7 +377,6 @@ insert_text (GtkTextBuffer *buffer)
   gtk_text_buffer_get_bounds (buffer, &start, &end);
   gtk_text_buffer_apply_tag_by_name (buffer, "word_wrap", &start, &end);
 
-  g_object_unref (pixbuf);
   g_object_unref (texture);
 }
 

demos/icon-browser/icon.list

@@ -285,7 +285,7 @@ user-trash=The icon for the user's “Trash” place in the file system
 user-trash-full=The icon for the user's “Trash” in the file system, when there are items in the “Trash” waiting for disposal or recovery
 emblem-system=The icon used as an emblem for directories that contain system libraries, settings, and data
 avatar-default=The generic avatar icon, which is used to represent a user that doesn't have a personalized avatar
-emblem-synchronizing=The icon used as an emblem to indicate that a a synchronizing operation is in process
+emblem-synchronizing=The icon used as an emblem to indicate that a synchronizing operation is in process
 emblem-shared=The icon used as an emblem for files and directories that are shared to other users
 help-browser=The icon used for the desktop's help browsing application
 

demos/icon-browser/iconbrowserwin.c

@@ -81,11 +81,14 @@ get_icon (GtkWidget *image, const gchar *name, gint size)
 {
   GtkIconInfo *info;
   GtkStyleContext *context;
+  GdkTexture *texture;
   GdkPixbuf *pixbuf;
 
   context = gtk_widget_get_style_context (image);
   info = gtk_icon_theme_lookup_icon (gtk_icon_theme_get_default (), name, size, 0);
-  pixbuf = gtk_icon_info_load_symbolic_for_context (info, context, NULL, NULL);
+  texture = GDK_TEXTURE (gtk_icon_info_load_symbolic_for_context (info, context, NULL, NULL));
+  pixbuf = gdk_pixbuf_get_from_texture (texture);
+  g_object_unref (texture);
   g_object_unref (info);
 
   return pixbuf;

demos/meson.build

@@ -1,3 +1,4 @@
+subdir('constraint-editor')
 subdir('gtk-demo')
 subdir('icon-browser')
 subdir('node-editor')

demos/node-editor/node-editor-application.c

@@ -26,9 +26,9 @@
 static const char *css =
 "textview.editor {"
 "  color: rgb(192, 197, 206);"
-"  caret-color: white;"
+"  caret-color: currentColor;"
 "}"
-"textview.editor text {"
+"textview.editor > text {"
 "  background-color: rgb(43, 48, 59);"
 "}"
 ;

demos/node-editor/node-editor-window.c

@@ -707,6 +707,14 @@ static void
 node_editor_window_unrealize (GtkWidget *widget)
 {
   NodeEditorWindow *self = NODE_EDITOR_WINDOW (widget);
+  guint i;
+
+  for (i = 0; i < g_list_model_get_n_items (G_LIST_MODEL (self->renderers)); i ++)
+    {
+      gpointer item = g_list_model_get_item (G_LIST_MODEL (self->renderers), i);
+      gsk_renderer_unrealize (gtk_renderer_paintable_get_renderer (item));
+      g_object_unref (item);
+    }
 
   g_list_store_remove_all (self->renderers);
 

demos/widget-factory/widget-factory.c

@@ -1003,6 +1003,9 @@ populate_flowbox (GtkWidget *flowbox)
 
   while ((name = g_dir_read_name (dir)) != NULL)
     {
+      if (g_str_has_suffix (name, ".xml"))
+        continue;
+
       filename = g_build_filename (location, name, NULL);
       file = g_file_new_for_path (filename);
       stream = G_INPUT_STREAM (g_file_read (file, NULL, &error));
@@ -1017,7 +1020,7 @@ populate_flowbox (GtkWidget *flowbox)
           bd = g_new (BackgroundData, 1);
           bd->flowbox = flowbox;
           bd->filename = filename;
-          gdk_pixbuf_new_from_stream_at_scale_async (stream, 110, 110, TRUE, NULL, 
+          gdk_pixbuf_new_from_stream_at_scale_async (stream, 110, 110, TRUE, NULL,
                                                      background_loaded_cb, bd);
         }
 
@@ -1405,8 +1408,10 @@ text_view_add_to_context_menu (GtkTextView *text_view)
   item = g_menu_item_new (_("Underline"), "format.underline");
   g_menu_item_set_attribute (item, "touch-icon", "s", "format-text-underline-symbolic");
   g_menu_append_item (G_MENU (menu), item);
+  g_object_unref (item);
 
   gtk_text_view_set_extra_menu (text_view, G_MENU_MODEL (menu));
+  g_object_unref (menu);
 
   g_signal_connect (gtk_text_view_get_buffer (text_view), "changed", G_CALLBACK (text_changed), NULL);
   g_signal_connect (gtk_text_view_get_buffer (text_view), "mark-set", G_CALLBACK (text_changed), NULL);
@@ -1601,14 +1606,14 @@ reset_icon_size (GtkWidget *iv)
   gtk_widget_queue_resize (iv);
 }
 
-static gchar *
-scale_format_value_blank (GtkScale *scale, gdouble value)
+static char *
+scale_format_value_blank (GtkScale *scale, double value, gpointer user_data)
 {
   return g_strdup (" ");
 }
 
-static gchar *
-scale_format_value (GtkScale *scale, gdouble value)
+static char *
+scale_format_value (GtkScale *scale, double value, gpointer user_data)
 {
   return g_strdup_printf ("%0.*f", 1, value);
 }
@@ -1647,7 +1652,7 @@ set_up_context_popover (GtkWidget *widget,
   GtkWidget *popover = gtk_popover_menu_new_from_model (widget, model);
   GtkGesture *gesture;
 
-  g_object_set (popover, "has-arrow", FALSE, NULL);
+  gtk_popover_set_has_arrow (GTK_POPOVER (popover), FALSE);
   gesture = gtk_gesture_click_new ();
   gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
   g_signal_connect (gesture, "pressed", G_CALLBACK (clicked_cb), popover);
@@ -1707,7 +1712,7 @@ activate (GApplication *app)
   gtk_css_provider_load_from_resource (provider, "/org/gtk/WidgetFactory4/widget-factory.css");
   gtk_style_context_add_provider_for_display (gdk_display_get_default (),
                                               GTK_STYLE_PROVIDER (provider),
-                                              GTK_STYLE_PROVIDER_PRIORITY_USER);
+                                              GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
   g_object_unref (provider);
 
   builder = gtk_builder_new_from_resource ("/org/gtk/WidgetFactory4/widget-factory.ui");
@@ -1722,8 +1727,6 @@ activate (GApplication *app)
   gtk_builder_add_callback_symbol (builder, "increase_icon_size", (GCallback)increase_icon_size);
   gtk_builder_add_callback_symbol (builder, "decrease_icon_size", (GCallback)decrease_icon_size);
   gtk_builder_add_callback_symbol (builder, "reset_icon_size", (GCallback)reset_icon_size);
-  gtk_builder_add_callback_symbol (builder, "scale_format_value", (GCallback)scale_format_value);
-  gtk_builder_add_callback_symbol (builder, "scale_format_value_blank", (GCallback)scale_format_value_blank);
   gtk_builder_add_callback_symbol (builder, "osd_frame_pressed", (GCallback)osd_frame_pressed);
 
   gtk_builder_connect_signals (builder, NULL);
@@ -1943,6 +1946,12 @@ activate (GApplication *app)
   widget = (GtkWidget *)gtk_builder_get_object (builder, "extra_info_entry");
   g_timeout_add (100, (GSourceFunc)pulse_it, widget);
 
+  widget = (GtkWidget *)gtk_builder_get_object (builder, "scale3");
+  gtk_scale_set_format_value_func (GTK_SCALE (widget), scale_format_value, NULL, NULL);
+
+  widget = (GtkWidget *)gtk_builder_get_object (builder, "scale4");
+  gtk_scale_set_format_value_func (GTK_SCALE (widget), scale_format_value_blank, NULL, NULL);
+
   widget = (GtkWidget *)gtk_builder_get_object (builder, "box_for_context");
   model = (GMenuModel *)gtk_builder_get_object (builder, "new_style_context_menu_model");
   set_up_context_popover (widget, model);

demos/widget-factory/widget-factory.ui

@@ -1019,7 +1019,6 @@ Suspendisse feugiat quam quis dolor accumsan cursus.</property>
                                         <property name="fill-level">75</property>
                                         <property name="digits">-1</property>
                                         <property name="halign">end</property>
-                                        <signal name="format-value" handler="scale_format_value"/>
                                       </object>
                                     </child>
                                     <child>
@@ -1033,7 +1032,6 @@ Suspendisse feugiat quam quis dolor accumsan cursus.</property>
                                         <property name="fill-level">75</property>
                                         <property name="digits">-1</property>
                                         <property name="halign">start</property>
-                                        <signal name="format-value" handler="scale_format_value_blank"/>
                                       </object>
                                     </child>
                                   </object>
@@ -1728,15 +1726,11 @@ microphone-sensitivity-medium-symbolic</property>
                                               </object>
                                             </child>
                                             <child>
-                                              <object class="GtkImage">
-                                                <property name="icon-name">object-select-symbolic</property>
+                                              <object class="GtkSpinButton">
+                                                <property name="adjustment">adjustment1</property>
+                                                <property name="hexpand">1</property>
                                                 <property name="halign">end</property>
                                                 <property name="valign">center</property>
-                                                <property name="margin-top">6</property>
-                                                <property name="margin-bottom">6</property>
-                                                <property name="margin-start">12</property>
-                                                <property name="margin-end">12</property>
-                                                <property name="opacity">0</property>
                                               </object>
                                             </child>
                                           </object>
@@ -1911,11 +1905,11 @@ microphone-sensitivity-medium-symbolic</property>
                                                   </object>
                                                 </child>
                                                 <child>
-                                                  <object class="GtkMenuItem" id="togglesmenuitem">
-                                                    <property name="label">Checks &amp; Radios</property>
+                                                  <object class="GtkMenuItem" id="checksmenuitem">
+                                                    <property name="label">_Checks</property>
                                                     <property name="use-underline">1</property>
                                                     <child type="submenu">
-                                                      <object class="GtkMenu" id="togglessubmenu">
+                                                      <object class="GtkMenu" id="checkssubmenu">
                                                         <child>
                                                           <object class="GtkCheckMenuItem" id="checkmenuitem1">
                                                             <property name="label">_Check</property>
@@ -1959,9 +1953,16 @@ microphone-sensitivity-medium-symbolic</property>
                                                             <property name="use-underline">1</property>
                                                           </object>
                                                         </child>
-                                                        <child>
-                                                          <object class="GtkSeparatorMenuItem" id="separatormenuitem"/>
-                                                        </child>
+                                                      </object>
+                                                    </child>
+                                                  </object>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkMenuItem" id="radiosmenuitem">
+                                                    <property name="label">_Radios</property>
+                                                    <property name="use-underline">1</property>
+                                                    <child type="submenu">
+                                                      <object class="GtkMenu" id="radiossubmenu">
                                                         <child>
                                                           <object class="GtkRadioMenuItem" id="radiomenuitem1">
                                                             <property name="label">_Radio</property>
@@ -2013,6 +2014,7 @@ microphone-sensitivity-medium-symbolic</property>
                                             </child>
                                           </object>
                                         </child>
+FOO
                                         <child>
                                           <object class="GtkMenuItem" id="menuitem3">
                                             <property name="label" translatable="yes">View</property>
@@ -2120,7 +2122,7 @@ microphone-sensitivity-medium-symbolic</property>
                                       <object class="GtkInfoBar" id="infobar">
                                         <property name="visible">0</property>
                                         <property name="show-close-button">1</property>
-                                        <child internal-child="content_area">
+                                        <child>
                                           <object class="GtkBox">
                                             <child>
                                               <object class="GtkLabel">
@@ -2131,9 +2133,14 @@ microphone-sensitivity-medium-symbolic</property>
                                         </child>
                                       </object>
                                     </child>
+                                    <child>
+                                      <object class="GtkSeparator">
+                                        <property name="orientation">horizontal</property>
+                                      </object>
+                                    </child>
                                     <child>
                                       <object class="GtkScrolledWindow">
-                                        <property name="shadow-type">in</property>
+                                        <property name="shadow-type">none</property>
                                         <property name="vexpand">1</property>
                                         <child>
                                           <object class="MyTextView" id="text3">
@@ -2147,6 +2154,11 @@ microphone-sensitivity-medium-symbolic</property>
                                         </child>
                                       </object>
                                     </child>
+                                    <child>
+                                      <object class="GtkSeparator">
+                                        <property name="orientation">horizontal</property>
+                                      </object>
+                                    </child>
                                     <child>
                                       <object class="GtkStatusbar" id="statusbar"/>
                                     </child>
@@ -3435,6 +3447,7 @@ bad things might happen.</property>
             <property name="halign">end</property>
             <property name="icon-name">emblem-system-symbolic</property>
             <property name="menu-model">gear_menu</property>
+            <property name="tooltip-text">This is a menu button</property>
             <layout>
               <property name="left-attach">1</property>
               <property name="top-attach">3</property>
@@ -3593,21 +3606,18 @@ bad things might happen.</property>
               <object class="GtkModelButton">
                 <property name="icon"><object class="GThemedIcon"><property name="name">edit-cut-symbolic</property></object></property>
                 <property name="iconic">1</property>
-                <property name="relief">none</property>
               </object>
             </child>
             <child>
               <object class="GtkModelButton">
                 <property name="icon"><object class="GThemedIcon"><property name="name">edit-copy-symbolic</property></object></property>
                 <property name="iconic">1</property>
-                <property name="relief">none</property>
               </object>
             </child>
             <child>
               <object class="GtkModelButton">
                 <property name="icon"><object class="GThemedIcon"><property name="name">edit-paste-symbolic</property></object></property>
                 <property name="iconic">1</property>
-                <property name="relief">none</property>
               </object>
             </child>
           </object>
@@ -3945,7 +3955,7 @@ bad things might happen.</property>
       </section>
       <section>
         <submenu>
-          <attribute name="label" translatable="yes">Checks &amp; Radios</attribute>
+          <attribute name="label" translatable="yes">C_hecks</attribute>
           <section>
             <item>
               <attribute name="label" translatable="yes">Check</attribute>
@@ -3969,6 +3979,9 @@ bad things might happen.</property>
               <attribute name="hidden-when">action-missing</attribute>
             </item>
           </section>
+        </submenu>
+        <submenu>
+          <attribute name="label" translatable="yes">_Radios</attribute>
           <section>
             <item>
               <attribute name="label" translatable="yes">Radio</attribute>

docs/reference/gdk/gdk4-sections.txt

@@ -1128,6 +1128,7 @@ gdk_monitor_get_width_mm
 gdk_monitor_get_height_mm
 gdk_monitor_get_manufacturer
 gdk_monitor_get_model
+gdk_monitor_get_connector
 gdk_monitor_get_scale_factor
 gdk_monitor_get_refresh_rate
 GdkSubpixelLayout

docs/reference/gdk/meson.build

@@ -99,7 +99,7 @@ if wayland_enabled
   src_dir += [ gdkwayland_inc ]
 endif
 
-if get_option('documentation')
+if get_option('gtk_doc')
   configure_file(input: 'version.xml.in', output: 'version.xml', configuration: version_conf)
 
   gnome.gtkdoc('gdk4',

docs/reference/gsk/meson.build

@@ -34,7 +34,7 @@ private_headers = [
 images = [
 ]
 
-if get_option('documentation')
+if get_option('gtk_doc')
   configure_file(input: 'version.xml.in', output: 'version.xml', configuration: version_conf)
 
   gnome.gtkdoc('gsk4',

docs/reference/gtk/actions.xml

@@ -258,9 +258,11 @@
      </para>
 
      <para>
-       Actions are added to their relevant scope (application or
-       window) either using the GActionMap interface, or by using
-       gtk_widget_insert_action_group().
+       Actions are added to their relevant scope (application,
+       window or widget) either using the GActionMap interface,
+       or by using gtk_widget_insert_action_group(). Actions that
+       will be the same for all instances of a widget class can
+       be added globally using gtk_widget_class_install_action().
      </para>
 
   </refsect2>
@@ -317,8 +319,8 @@
     </para>
 
     <para>
-      Another of obtaining widgets that are connected to actions is
-      to create a menu using a GMenu menu model. GMenu provides an
+      Another way of obtaining widgets that are connected to actions
+      is to create a menu using a GMenu menu model. GMenu provides an
       abstract way to describe typical menus: nested groups of items
       where each item can have a label, and icon, and an action.
     </para>
@@ -364,6 +366,25 @@
              (typically a GtkWindow, GtkDialog or GtkPopover)
           </para></listitem>
         </varlistentry>
+        <varlistentry>
+          <term>clipboard.cut, clipboard.copy, clipboard.paste</term>
+          <listitem><para>Clipboard operations on entries, text view
+            and labels, typically used in the context menu
+          </para></listitem>
+        </varlistentry>
+        <varlistentry>
+          <term>selection.delete, selection.select-all</term>
+          <listitem><para>Selection operations on entries, text view
+            and labels
+          </para></listitem>
+        </varlistentry>
+        <varlistentry>
+          <term>color.select, color.customize</term>
+          <listitem><para>Operations on colors in GtkColorChooserWidget.
+            These actions are unusual in that they have the non-trivial
+            parameter type (dddd).
+          </para></listitem>
+        </varlistentry>
       </variablelist>
     </para>
 

docs/reference/gtk/building.sgml

@@ -355,8 +355,8 @@ How to compile GTK itself
           </group>
           <sbr/>
           <group>
-            <arg choice="plain">-Ddocumentation=true</arg>
-            <arg choice="plain">-Ddocumentation=false</arg>
+            <arg choice="plain">-Dgtk_doc=true</arg>
+            <arg choice="plain">-Dgtk_doc=false</arg>
           </group>
           <sbr/>
           <group>
@@ -382,7 +382,7 @@ How to compile GTK itself
       </formalpara>
 
       <formalpara>
-        <title><systemitem>documentation</systemitem> and
+        <title><systemitem>gtk_doc</systemitem> and
           <systemitem>man-pages</systemitem></title>
 
         <para>
@@ -394,7 +394,7 @@ How to compile GTK itself
           <application>gtk-doc</application> installed and
           are modifying GTK, you may want to enable
           <application>gtk-doc</application> support by passing
-          in <systemitem>documentation</systemitem>.
+          in <systemitem>gtk_doc</systemitem>.
         </para>
         <para>
           Additionally, some tools provided by GTK have their own

docs/reference/gtk/gtk4-docs.xml

@@ -51,7 +51,9 @@
       <xi:include href="xml/gtksortlistmodel.xml" />
       <xi:include href="xml/gtktreelistmodel.xml" />
       <xi:include href="xml/gtkselectionmodel.xml" />
+      <xi:include href="xml/gtknoselection.xml" />
       <xi:include href="xml/gtksingleselection.xml" />
+      <xi:include href="xml/gtkdirectorylist.xml" />
     </chapter>
 
     <chapter id="Application">
@@ -86,6 +88,9 @@
       <xi:include href="xml/gtkrevealer.xml" />
       <xi:include href="xml/gtklistbox.xml" />
       <xi:include href="xml/gtkflowbox.xml" />
+      <xi:include href="xml/gtklistview.xml" />
+      <xi:include href="xml/gtkgridview.xml" />
+      <xi:include href="xml/gtktreeexpander.xml" />
       <xi:include href="xml/gtkstack.xml" />
       <xi:include href="xml/gtkstackswitcher.xml" />
       <xi:include href="xml/gtkstacksidebar.xml" />
@@ -109,6 +114,9 @@
       <xi:include href="xml/gtkcustomlayout.xml" />
       <xi:include href="xml/gtkfixedlayout.xml" />
       <xi:include href="xml/gtkgridlayout.xml" />
+      <xi:include href="xml/gtkconstraintlayout.xml" />
+      <xi:include href="xml/gtkconstraint.xml" />
+      <xi:include href="xml/gtkconstraintguide.xml" />
     </chapter>
 
     <chapter id="DisplayWidgets">

docs/reference/gtk/gtk4-sections.txt

@@ -136,6 +136,7 @@ gtk_accel_map_get_type
 GtkAccelLabel
 gtk_accel_label_new
 gtk_accel_label_set_accel_closure
+gtk_accel_label_get_accel_closure
 gtk_accel_label_get_accel_widget
 gtk_accel_label_set_accel_widget
 gtk_accel_label_get_accel_width
@@ -340,6 +341,30 @@ GTK_CENTER_BOX_GET_CLASS
 gtk_center_box_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtkcenterlayout</FILE>
+<TITLE>GtkCenterLayout</TITLE>
+GtkCenterLayout
+gtk_center_layout_new
+gtk_center_layout_set_start_widget
+gtk_center_layout_set_center_widget
+gtk_center_layout_set_end_widget
+gtk_center_layout_get_start_widget
+gtk_center_layout_get_center_widget
+gtk_center_layout_get_end_widget
+gtk_center_layout_set_baseline_position
+gtk_center_layout_get_baseline_position
+<SUBSECTION Private>
+GTK_TYPE_CENTER_layout
+GTK_CENTER_LAYOUT
+GTK_CENTER_LAYOUT_CLASS
+GTK_IS_CENTER_LAYOUT
+GTK_IS_CENTER_LAYOUT_CLASS
+GTK_CENTER_LAYOUT_GET_CLASS
+<SUBSECTION Private>
+gtk_center_layout_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtklistbox</FILE>
 <TITLE>GtkListBox</TITLE>
@@ -440,12 +465,23 @@ GTK_TYPE_SELECTION_MODEL
 gtk_selection_model_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtknoselection</FILE>
+<TITLE>GtkNoSelection</TITLE>
+GtkNoSelection
+gtk_no_selection_new
+gtk_no_selection_get_model
+<SUBSECTION Private>
+gtk_no_selection_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtksingleselection</FILE>
 <TITLE>GtkSingleSelection</TITLE>
 GtkSingleSelection
 GTK_INVALID_LIST_POSITION
 gtk_single_selection_new
+gtk_single_selection_get_model
 gtk_single_selection_get_selected
 gtk_single_selection_set_selected
 gtk_single_selection_get_selected_item
@@ -457,6 +493,114 @@ gtk_single_selection_set_can_unselect
 gtk_single_selection_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtklistitem</FILE>
+<TITLE>GtkListItem</TITLE>
+GtkListItem
+gtk_list_item_get_item
+gtk_list_item_get_position
+gtk_list_item_get_selected
+gtk_list_item_get_selectable
+gtk_list_item_set_selectable
+<SUBSECTION Standard>
+GTK_LIST_ITEM
+GTK_LIST_ITEM_CLASS
+GTK_LIST_ITEM_GET_CLASS
+GTK_IS_LIST_ITEM
+GTK_IS_LIST_ITEM_CLASS
+GTK_TYPE_LIST_ITEM
+<SUBSECTION Private>
+gtk_list_item_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtklistview</FILE>
+<TITLE>GtkListView</TITLE>
+GtkListView
+gtk_list_view_new
+gtk_list_view_new_with_factory
+gtk_list_view_set_factory
+gtk_list_view_get_factory
+gtk_list_view_set_model
+gtk_list_view_get_model
+gtk_list_view_set_show_separators
+gtk_list_view_get_show_separators
+<SUBSECTION Standard>
+GTK_LIST_VIEW
+GTK_LIST_VIEW_CLASS
+GTK_LIST_VIEW_GET_CLASS
+GTK_IS_LIST_VIEW
+GTK_IS_LIST_VIEW_CLASS
+GTK_TYPE_LIST_VIEW
+<SUBSECTION Private>
+gtk_list_view_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkcolumnview</FILE>
+<TITLE>GtkColumnView</TITLE>
+GtkColumnView
+gtk_column_view_new
+gtk_column_view_get_columns
+gtk_column_view_get_model
+gtk_column_view_set_model
+gtk_column_view_get_show_separators
+gtk_column_view_set_show_separators
+<SUBSECTION Standard>
+GTK_COLUMN_VIEW
+GTK_COLUMN_VIEW_CLASS
+GTK_COLUMN_VIEW_GET_CLASS
+GTK_IS_COLUMN_VIEW
+GTK_IS_COLUMN_VIEW_CLASS
+GTK_TYPE_COLUMN_VIEW
+<SUBSECTION Private>
+gtk_column_view_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkcolumnviewcolumn</FILE>
+<TITLE>GtkColumnViewColumn</TITLE>
+GtkColumnViewColumn
+gtk_column_view_column_new
+gtk_column_view_column_new_with_factory
+gtk_column_view_column_get_column_view
+gtk_column_view_column_set_factory
+gtk_column_view_column_get_factory
+gtk_column_view_column_set_title
+gtk_column_view_column_get_title
+<SUBSECTION Standard>
+GTK_COLUMN_VIEW_COLUMN
+GTK_COLUMN_VIEW_COLUMN_CLASS
+GTK_COLUMN_VIEW_COLUMN_GET_CLASS
+GTK_IS_COLUMN_VIEW_COLUMN
+GTK_IS_COLUMN_VIEW_COLUMN_CLASS
+GTK_TYPE_COLUMN_VIEW_COLUMN
+<SUBSECTION Private>
+gtk_column_view_column_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkgridview</FILE>
+<TITLE>GtkGridView</TITLE>
+GtkGridView
+gtk_grid_view_new
+gtk_grid_view_set_model
+gtk_grid_view_get_model
+gtk_grid_view_set_max_columns
+gtk_grid_view_get_max_columns
+gtk_grid_view_set_min_columns
+gtk_grid_view_get_min_columns
+<SUBSECTION Standard>
+GTK_GRID_VIEW
+GTK_GRID_VIEW_CLASS
+GTK_GRID_VIEW_GET_CLASS
+GTK_IS_GRID_VIEW
+GTK_IS_GRID_VIEW_CLASS
+GTK_TYPE_GRID_VIEW
+<SUBSECTION Private>
+gtk_grid_view_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtkbuildable</FILE>
 GtkBuildable
@@ -1286,6 +1430,32 @@ GTK_TYPE_FILE_FILTER
 gtk_file_filter_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtkdirectorylist</FILE>
+<TITLE>GtkDirectoryList</TITLE>
+GtkDirectoryList
+gtk_directory_list_new
+gtk_directory_list_get_attributes
+gtk_directory_list_set_attributes
+gtk_directory_list_get_file
+gtk_directory_list_set_file
+gtk_directory_list_get_io_priority
+gtk_directory_list_set_io_priority
+gtk_directory_list_is_loading
+gtk_directory_list_get_error
+<SUBSECTION Standard>
+GTK_DIRECTORY_LIST
+GTK_IS_DIRECTORY_LIST
+GTK_TYPE_DIRECTORY_LIST
+GTK_DIRECTORY_LIST_CLASS
+GTK_IS_DIRECTORY_LIST_CLASS
+GTK_DIRECTORY_LIST_GET_CLASS
+<SUBSECTION Private>
+gtk_directory_list_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkspinbutton</FILE>
 <SECTION>
 <FILE>gtkfilterlistmodel</FILE>
 <TITLE>GtkFilterListModel</TITLE>
@@ -1683,8 +1853,8 @@ gtk_label_set_yalign
 gtk_label_set_ellipsize
 gtk_label_set_width_chars
 gtk_label_set_max_width_chars
-gtk_label_set_line_wrap
-gtk_label_set_line_wrap_mode
+gtk_label_set_wrap
+gtk_label_set_wrap_mode
 gtk_label_set_lines
 gtk_label_get_layout_offsets
 gtk_label_get_mnemonic_keyval
@@ -1704,8 +1874,8 @@ gtk_label_get_width_chars
 gtk_label_get_max_width_chars
 gtk_label_get_label
 gtk_label_get_layout
-gtk_label_get_line_wrap
-gtk_label_get_line_wrap_mode
+gtk_label_get_wrap
+gtk_label_get_wrap_mode
 gtk_label_get_lines
 gtk_label_get_mnemonic_widget
 gtk_label_get_selection_bounds
@@ -1786,6 +1956,8 @@ gtk_map_list_model_get_type
 GtkMenu
 gtk_menu_new
 gtk_menu_new_from_model
+GtkPopoverMenuFlags
+gtk_menu_new_from_model_full
 gtk_menu_reorder_child
 gtk_menu_popup_at_rect
 gtk_menu_popup_at_widget
@@ -1865,6 +2037,7 @@ gtk_menu_button_set_relief
 gtk_menu_button_get_relief
 gtk_menu_button_popup
 gtk_menu_button_popdown
+gtk_menu_button_set_create_popup_func
 <SUBSECTION Standard>
 GTK_TYPE_MENU_BUTTON
 GTK_MENU_BUTTON
@@ -3042,7 +3215,7 @@ gtk_text_view_get_line_at_y
 gtk_text_view_get_line_yrange
 gtk_text_view_get_iter_at_location
 gtk_text_view_get_iter_at_position
-gtk_text_view_buffer_to_surface_coords
+gtk_text_view_buffer_to_window_coords
 gtk_text_view_window_to_buffer_coords
 gtk_text_view_set_border_window_size
 gtk_text_view_get_border_window_size
@@ -3057,8 +3230,10 @@ GtkTextChildAnchor
 gtk_text_child_anchor_new
 gtk_text_child_anchor_get_widgets
 gtk_text_child_anchor_get_deleted
-gtk_text_view_add_child_in_window
-gtk_text_view_move_child
+gtk_text_view_get_gutter
+gtk_text_view_set_gutter
+gtk_text_view_add_overlay
+gtk_text_view_move_overlay
 gtk_text_view_set_wrap_mode
 gtk_text_view_get_wrap_mode
 gtk_text_view_set_editable
@@ -3423,6 +3598,26 @@ gtk_tree_list_model_get_type
 gtk_tree_list_row_get_type
 </SECTION>
 
+<SECTION>
+<FILE>gtktreeexpander</FILE>
+<TITLE>GtkTreeExpander</TITLE>
+gtk_tree_expander_new
+gtk_tree_expander_get_child
+gtk_tree_expander_set_child
+gtk_tree_expander_get_item
+gtk_tree_expander_get_list_row
+gtk_tree_expander_set_list_row
+<SUBSECTION Standard>
+GTK_TREE_EXPANDER
+GTK_IS_TREE_EXPANDER
+GTK_TYPE_TREE_EXPANDER
+GTK_TREE_EXPANDER_CLASS
+GTK_IS_TREE_EXPANDER_CLASS
+GTK_TREE_EXPANDER_GET_CLASS
+<SUBSECTION Private>
+gtk_tree_expander_get_type
+</SECTION>
+
 <SECTION>
 <FILE>gtktreemodel</FILE>
 <TITLE>GtkTreeModel</TITLE>
@@ -4432,7 +4627,6 @@ gtk_widget_realize
 gtk_widget_unrealize
 gtk_widget_queue_draw
 gtk_widget_queue_resize
-gtk_widget_queue_resize_no_redraw
 gtk_widget_queue_allocate
 gtk_widget_get_frame_clock
 gtk_widget_get_scale_factor
@@ -4511,6 +4705,7 @@ gtk_widget_get_allocation
 gtk_widget_get_allocated_baseline
 gtk_widget_get_width
 gtk_widget_get_height
+gtk_widget_get_size
 gtk_widget_compute_bounds
 gtk_widget_compute_transform
 gtk_widget_compute_point
@@ -4549,11 +4744,6 @@ gtk_widget_get_opacity
 gtk_widget_set_opacity
 gtk_widget_get_overflow
 gtk_widget_set_overflow
-gtk_widget_insert_action_group
-gtk_widget_list_action_prefixes
-gtk_widget_get_action_group
-gtk_widget_activate_action
-gtk_widget_activate_default
 gtk_widget_measure
 gtk_widget_snapshot_child
 gtk_widget_get_next_sibling
@@ -4609,7 +4799,6 @@ gtk_widget_get_vexpand
 gtk_widget_set_vexpand
 gtk_widget_get_vexpand_set
 gtk_widget_set_vexpand_set
-gtk_widget_queue_compute_expand
 gtk_widget_compute_expand
 
 <SUBSECTION Templates>
@@ -4630,6 +4819,17 @@ gtk_widget_class_set_connect_func
 gtk_widget_observe_children
 gtk_widget_observe_controllers
 
+<SUBSECTION Actions>
+gtk_widget_insert_action_group
+gtk_widget_activate_action
+gtk_widget_activate_action_variant
+gtk_widget_activate_default
+GtkWidgetActionActivateFunc
+gtk_widget_class_install_action
+gtk_widget_class_install_property_action
+gtk_widget_class_query_action
+gtk_widget_action_set_enabled
+
 <SUBSECTION Standard>
 GTK_WIDGET
 GTK_IS_WIDGET
@@ -5196,13 +5396,16 @@ GtkBindingSet
 GtkBindingEntry
 GtkBindingSignal
 GtkBindingArg
-gtk_binding_entry_add_signall
 gtk_binding_set_new
 gtk_binding_set_by_class
 gtk_binding_set_find
 gtk_bindings_activate
 gtk_bindings_activate_event
 gtk_binding_set_activate
+gtk_binding_entry_add_action
+gtk_binding_entry_add_action_variant
+GtkBindingCallback
+gtk_binding_entry_add_callback
 gtk_binding_entry_add_signal
 gtk_binding_entry_add_signal_from_string
 gtk_binding_entry_skip
@@ -6696,6 +6899,8 @@ gtk_event_controller_key_forward
 gtk_event_controller_key_get_group
 gtk_event_controller_key_get_focus_origin
 gtk_event_controller_key_get_focus_target
+gtk_event_controller_key_contains_focus
+gtk_event_controller_key_is_focus
 
 <SUBSECTION Standard>
 GTK_TYPE_EVENT_CONTROLLER_KEY
@@ -6734,6 +6939,8 @@ gtk_gesture_drag_get_type
 <TITLE>GtkGestureLongPress</TITLE>
 GtkGestureLongPress
 gtk_gesture_long_press_new
+gtk_gesture_long_press_set_delay_factor
+gtk_gesture_long_press_get_delay_factor
 
 <SUBSECTION Standard>
 GTK_TYPE_GESTURE_LONG_PRESS
@@ -7282,3 +7489,87 @@ gtk_grid_layout_get_type
 GTK_TYPE_GRID_LAYOUT_CHILD
 gtk_grid_layout_child_get_type
 </SECTION>
+
+<SECTION>
+<FILE>gtkconstraint</FILE>
+GtkConstraint
+GtkConstraintTarget
+
+gtk_constraint_new
+gtk_constraint_new_constant
+gtk_constraint_get_target
+GtkConstraintAttribute
+gtk_constraint_get_target_attribute
+GtkConstraintRelation
+gtk_constraint_get_relation
+gtk_constraint_get_source
+gtk_constraint_get_source_attribute
+gtk_constraint_get_multiplier
+gtk_constraint_get_constant
+GtkConstraintStrength
+gtk_constraint_get_strength
+gtk_constraint_is_required
+gtk_constraint_is_attached
+gtk_constraint_is_constant
+
+<SUBSECTION Standard>
+GTK_TYPE_CONSTRAINT
+gtk_constraint_get_type
+GTK_TYPE_CONSTRAINT_TARGET
+gtk_constraint_target_get_type
+</SECTION>
+
+<SECTION>
+<FILE>gtkconstraintlayout</FILE>
+GtkConstraintLayout
+GtkConstraintLayoutChild
+GtkConstraintVflParserError
+
+gtk_constraint_layout_new
+
+<SUBSECTION Constraints>
+gtk_constraint_layout_add_constraint
+gtk_constraint_layout_remove_constraint
+gtk_constraint_layout_remove_all_constraints
+
+<SUBSECTION Guides>
+gtk_constraint_layout_add_guide
+gtk_constraint_layout_remove_guide
+
+<SUBSECTION VFL>
+gtk_constraint_layout_add_constraints_from_description
+gtk_constraint_layout_add_constraints_from_descriptionv
+
+<SUBSECTION>
+gtk_constraint_layout_observe_constraints
+gtk_constraint_layout_observe_guides
+
+<SUBSECTION Standard>
+GTK_TYPE_CONSTRAINT_LAYOUT
+gtk_constraint_layout_get_type
+GTK_TYPE_CONSTRAINT_LAYOUT_CHILD
+gtk_constraint_layout_child_get_type
+GTK_CONSTRAINT_VFL_PARSER_ERROR
+gtk_constraint_vfl_parser_error_quark
+</SECTION>
+
+<SECTION>
+<FILE>gtkconstraintguide</FILE>
+GtkConstraintGuide
+
+gtk_constraint_guide_new
+gtk_constraint_guide_set_name
+gtk_constraint_guide_get_name
+gtk_constraint_guide_set_strength
+gtk_constraint_guide_get_strength
+gtk_constraint_guide_set_min_size
+gtk_constraint_guide_get_min_size
+gtk_constraint_guide_set_nat_size
+gtk_constraint_guide_get_nat_size
+gtk_constraint_guide_set_max_size
+gtk_constraint_guide_get_max_size
+
+<SUBSECTION Standard>
+GTK_TYPE_CONSTRAINT_GUIDE
+gtk_constraint_guide_get_tyoe
+</SECTION>

docs/reference/gtk/gtk4-update-icon-cache.xml

@@ -49,7 +49,7 @@
   files for icon themes.
 </para>
 <para>
-  It expects to be given the <replaceable>PATH</replaceable> to a icon theme
+  It expects to be given the <replaceable>PATH</replaceable> to an icon theme
   directory containing an <filename>index.theme</filename>, e.g.
   <filename>/usr/share/icons/hicolor</filename>, and writes a
   <filename>icon-theme.cache</filename> containing cached information about

docs/reference/gtk/gtk4.types.in

@@ -1,3 +1,6 @@
+#include <gtk/gtk.h>
+#include <gtk/gtkunixprint.h>
+
 gtk_about_dialog_get_type
 gtk_accel_group_get_type
 gtk_accel_label_get_type
@@ -46,6 +49,10 @@ gtk_color_chooser_dialog_get_type
 gtk_color_chooser_widget_get_type
 gtk_combo_box_get_type
 gtk_combo_box_text_get_type
+gtk_constraint_get_type
+gtk_constraint_guide_get_type
+gtk_constraint_layout_get_type
+gtk_constraint_target_get_type
 gtk_container_get_type
 gtk_css_provider_get_type
 gtk_dialog_get_type
@@ -116,6 +123,7 @@ gtk_menu_tool_button_get_type
 gtk_message_dialog_get_type
 gtk_model_button_get_type
 gtk_mount_operation_get_type
+gtk_native_get_type
 gtk_notebook_get_type
 gtk_notebook_page_get_type
 gtk_orientable_get_type

docs/reference/gtk/meson.build

@@ -23,6 +23,13 @@ private_headers = [
   'gtkcolorswatchprivate.h',
   'gtkcomboboxprivate.h',
   'gtkcontainerprivate.h',
+  'gtkconstraintexpressionprivate.h',
+  'gtkconstraintguideprivate.h',
+  'gtkconstraintlayoutprivate.h',
+  'gtkconstraintprivate.h',
+  'gtkconstraintsolverprivate.h',
+  'gtkconstrainttypesprivate.h',
+  'gtkconstraintvflparserprivate.h',
   'gtkcssanimatedstyleprivate.h',
   'gtkcssanimationprivate.h',
   'gtkcssarrayvalueprivate.h',
@@ -394,7 +401,7 @@ else
   types_conf.set('DISABLE_ON_QUARTZ', '')
 endif
 
-if get_option('documentation')
+if get_option('gtk_doc')
   configure_file(input: 'version.xml.in', output: 'version.xml', configuration: version_conf)
   configure_file(input: 'getting_started.xml.in', output: 'getting_started.xml', configuration: src_dir_conf)
 

docs/reference/gtk/overview.xml

@@ -11,7 +11,10 @@ GTK is released under the GNU Library General Public License
 applications. GTK has a C-based object-oriented architecture that
 allows for maximum flexibility.  Bindings for many other languages have
 been written, including C++, Objective-C, Guile/Scheme, Perl, Python,
-TOM, Ada95, Free Pascal, and Eiffel.
+TOM, Ada95, Free Pascal, and Eiffel.  The GTK library itself contains
+<firstterm>widgets</firstterm>, that is, GUI components such as GtkButton
+or GtkTextView.
+
 </para>
 <para>
 GTK depends on the following libraries:
@@ -105,14 +108,6 @@ and rendering it using different rendering APIs. GSK provides renderers
 for OpenGL, Vulkan and cairo.
 </para></listitem>
 </varlistentry>
-
-<varlistentry>
-<term>GTK</term>
-<listitem><para>
-The GTK library itself contains <firstterm>widgets</firstterm>,
-that is, GUI components such as GtkButton or GtkTextView.
-</para></listitem>
-</varlistentry>
 </variablelist>
 </para>
 </partintro>

docs/reference/meson.build

@@ -1,4 +1,4 @@
-if get_option('documentation')
+if get_option('gtk_doc')
   glib_prefix = dependency('glib-2.0').get_pkgconfig_variable('prefix')
   glib_docpath = join_paths(glib_prefix, 'share', 'gtk-doc', 'html')
 

docs/styles.txt

@@ -1,97 +0,0 @@
-HANDLING WIDGET STYLES
-======================
-
-
-A widget gets created with a default style.
-The global default style can be affected by gtk_widget_set_default_style()
-and can be queried by gtk_widget_get_default_style().
-The initial style that is assigned to a widget as default style upon
-creation can be affected by wrapping the widget's creation as follows:
-gtk_widget_push_style (my_style);
-widget = gtk_type_new (gtk_button_get_type ());
-gtk_widget_pop_style ();
-
-There are certain functions to affect widget styles after a widget's
-creation:
-
-gtk_widget_set_style ()
-  Save the default style and set a user style.
-  This will override a previously set user style or
-  previously set rc styles.
-
-gtk_widget_reset_rc_styles ()
-  Descends through a widget hierarchy and sets the rc style
-  on all widgets that don't have a user style set.
-
-gtk_widget_ensure_style ()
-  Ensure that the widget either has a user style set, or an rc lookup
-  has been performed.
-
-gtk_rc_get_style ()
-  Return an rc style for a widget if there is one.
-
-gtk_widget_set_name ()
-  Change widget name, and perform a new rc lookup if no user style
-  is set.
-
-gtk_widget_realize ()
-  Besides realizing the widget this function will:
-  - perform an rc lookup if necessary,
-  - attach a widget's style.
-
-gtk_widget_get_style ()
-  Return a widgets style, this function will perform an rc lookup
-  if necessary.
-
-gtk_widget_set_parent ()
-  This function will perform rc lookups recursively for all widgets
-  that do not have a user style set.
-
-gtk_style_copy ()
-  This function can be used to copy a widget's style.
-  The style can subsequently be changed (e.g., by modifications to the
-  red/green/blue values of a certain color) and then be applied to the
-  widget via gtk_widget_set_style().
-
-
-GtkWidget::style_set
-  This signal will be emitted for a widget once its style changes with
-  an additional argument previous_style which will hold the widget->style
-  value from a previous emission.
-  The initial emission of this signal is guaranteed to happen prior
-  to any GtkWidget::size_request emission, and will have the previous_style
-  argument set to NULL.
-  The GtkWidgetClass implements a default handler for this signal that
-  will set the widget's window's background of widgets that provide their
-  own windows according to the new style.
-  Derived widgets need to override this default handler, if:
-  - their size requisition depends on the current style.
-    (e.g., on the style's fonts)
-  - they set the background of widget->window to something other than.
-    style->bg. (e.g., GtkListItem)
-  - the widget provides windows other than widget->window.
-  - the widget has any other stored dependencies on the style.
-                   
-
-
-Flag indications:
-
-!GTK_RC_STYLE && !GTK_USER_STYLE:
-  The widget has its default style set, no rc lookup has been
-  performed, the widget has not been size requested yet and is
-  therefore not yet realized.
-
-GTK_USER_STYLE:
-  GTK_RC_STYLE is not set.
-  The widget has a user style assigned, and its default style has been
-  saved.
-
-GTK_RC_STYLE:
-  GTK_USER_STYLE is not set.
-  If the widget has a saved default style, it has been assigned an
-  rc style. If the widget does not have a saved default style, it still
-  has its default style but an rc lookup has already been performed.
-
-
-	- Tim Janik <timj@gimp.org>
-	  1998/02/27

docs/tools/meson.build

@@ -1,4 +1,4 @@
-if x11_enabled and get_option('documentation')
+if x11_enabled and get_option('gtk_doc')
   doc_shooter_sources = [
     'shadow.c',
     'shooter.c',

docs/tree-column-sizing.txt

@@ -6,7 +6,7 @@ anyone who hopes to work with the code in the future.
 HOW THE GTKTREEVIEW CALCULATES SIZE:
 ====================================
  When the view is given a new model, the first thing it does is walk
-through the model at the top level, creating an GtkRBNode for each
+through the model at the top level, creating a GtkRBNode for each
 element of the model.  Each node has a height of 0.  The RBTree is kept
 updated as the models structure changes.  Additionally, the user can
 expand, collapse, and select rows at this stage.  The RBTree is accurate

docs/widget_geometry.txt

@@ -1,836 +0,0 @@
-This file is some notes about how different widgets are drawn.
-
-=============
-
-GtkMenu
-
-=============
-+----------------------------------------------------------------------------+
-|                                A                                           |
-| +------------------------------------------------------------------------+ |
-| |############################# C ########################################| |
-| |#                             D                                        #| |
-| |# +-------------------------------------------------------------------+#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                      Item 1                                       |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# +-------------------------------------------------------------------+#| |
-| |# +-------------------------------------------------------------------+#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-|A|B |                                                                   |B|A|
-| |# |                      Item 2                                       |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# +-------------------------------------------------------------------+#| |
-| |#                        [...]                                         #| |
-| |# +-------------------------------------------------------------------+#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                      Item n                                       |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# |                                                                   |#| |
-| |# +-------------------------------------------------------------------+#| |
-| |#                             D                                        #| |
-| |############################# C ########################################| |
-| +------------------------------------------------------------------------| |
-|                                A                                           |
-+----------------------------------------------------------------------------+
-
-A: GtkContainer::border_width
-B: xthickness
-C: ythickness
-D: vertical_padding
-
-=============
-
-GtkMenuItem
-
-=============
-
-+----------------------------------------------------------------------------+
-|                                A                                           |
-| +------------------------------------------------------------------------+ |
-| |############################# C ########################################| |
-| |#+-+------------+--+-------------------------------+--+-------------+-+#| |
-| |#| |\\\\\\\\\\\\|  |                  /|\          |**|             | |#| |
-| |#| |<------E------>|                   |           |**|      G      | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|             | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|   >>        | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|   >>>>      | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|   >>>>>>    | |#| |
-|A|B|D|\\\\\\\\\\\\| F|      Child        G           |*H|   >>>>>>>>  |D|B|A|
-| |#| |\\\\\\\\\\\\|  |                   |           |**|   >>>>>>    | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|   >>>>      | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|   >>        | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|             | |#| |
-| |#| |\\\\\\\\\\\\|  |                   |           |**|             | |#| |
-| |#| |\\\\\\\\\\\\|  |                  \|/          |**|             | |#| |
-| |#+-+------------+--+-------------------------------+--+-------------+-+#| |
-| |############################# C ########################################| |
-| +------------------------------------------------------------------------+ |
-|                                A                                           |
-+----------------------------------------------------------------------------+
-
-A: GtkContainer:border_width
-B: xthickness
-C: ythickness
-D: horizontal_padding
-E: toggle_size
-F: toggle_spacing
-G: Requested height of child (also used for width of arrow
-H: arrow_spacing spacing (when the item has a non-vertical submenu)
-
-
-=============
-
-GtkOptionMenu:
-
-=============
-
-Geometry parameters
-
- Style properties
-
-   GtkWidget::interior_focus = TRUE
-   GtkWidget::focus_width = 1
-   GtkWidget::focus_padding = 0
-   GtkOptionMenu::indicator_size = { 7, 13 }
-   GtkOptionMenu::indicator_spacing = { 7, 5, 2, 2 }
-
- Properties
-
-   GtkContainer::border_width = 0
-
- #defines
-
-   CHILD_LEFT_SPACING = 5
-   CHILD_RIGHT_SPACING = 1
-   CHILD_TOP_SPACING = 1
-   CHILD_BOTTOM_SPACING = 1
-
-
-I) interior_focus = TRUE
-
-+--------------------------------------------------+
-+                       A                          |
-| +----------------------------------------------+ |
-| |\\\\\\\\\\\\\\\\\\\\ H ///////////////////////| |
-| |\+------------------------------------------+/| |
-| |\|                   C                      |/| |
-| |\| +------------------------------+         |/| |
-| |\| |################ D ###########|    L    |/| |
-| |\| |#+--------------------------+#|         |/| |
-| |\| |#|         K                |#|         |/| |
-| |\| |#| +----------------------+ |#| +-----+ |/| |
-| |\| |#| |                      | |#| | /#\ | |/| |
-| |\| |#| |                      | |#| | === | |/| |
-|A|B|C|D|E|    	 Child        	 |F|D|G| IxJ |O|B|A|
-| |/| |#| |                      | |#| | === | |\| |
-| |/| |#| |                      | |#| | \#/ | |\| |
-| |/| |#| +----------------------+ |#| +-----+ |\| |
-| |/| |#|         M                |#|         |\| |
-| |/| |#+---------------------------#|         |\| |
-| |/| |################ D ###########|    N    |\| |
-| |/| +------------------------------+         |\| |
-| |/|                   C                      |\| |
-| |/+------------------------------------------+\| |
-| |////////////////////	H \\\\\\\\\\\\\\\\\\\\\\\| |
-| +----------------------------------------------+ |
-|                      	A 		      	   |
-+--------------------------------------------------+
-
-  A: GtkContainer::border_width
-  B: xthickness
-  C: GtkWidget::focus_pad
-  D: GtkWidget::focus_width
-  E: CHILD_LEFT_SPACING
-  F: CHILD_RIGHT_SPACING
-  G: GtkOptionMenu::indicator_spacing::left
-  H: ythickness
-  I: GtkOptionMenu::indicator_size::width
-  J: GtkOptionMenu::indicator_size::height
-  K: CHILD_TOP_SPACING
-  L: GtkOptionMenu::indicator_spacing::top + GtkWidget::focus_width + GtkWidget::focus_pad + CHILD_TOP_SPACING
-  M: CHILD_BOTTOM_SPACING
-  N: GtkOptionMenu::indicator_spacing::bottom + GtkWidget::focus_width + GtkWidget::focus_pad + CHILD_BOTTOM_SPACING
-  O: GtkOptionMenu::indicator_spacing::right
-
-
-II) interior_focus = FALSE
-
-+--------------------------------------------------+
-+                       A                          |
-| +----------------------------------------------+ |
-| |#################### B #######################| |
-| |#+------------------------------------------+#| |
-| |#|                   C                      |#| |
-| |#| +--------------------------------------+ |#| |
-| |#| |\\\\\\\\\\\\\\\\ H ///////////////////| |#| |
-| |#| |\+----------------------------------+/| |#| |
-| |#| |\|         K                   L    |/| |#| |
-| |#| |\| +----------------------+ +-----+ |/| |#| |
-| |#| |\| |                      | | /#\ | |/| |#| |
-| |#| |\| |                      | | === | |/| |#| |
-|A|B|C|D|E|    	 Child         	 |F| IxJ |G|D|C|B|A|
-| |#| |/| |                      | | === | |\| |#| |
-| |#| |/| |                      | | \#/ | |\| |#| |
-| |#| |/| +----------------------+ +-----+ |\| |#| |
-| |#| |/|         M                   N    |\| |#| |
-| |#| |/+----------------------------------+\| |#| |
-| |#| |////////////////	H \\\\\\\\\\\\\\\\\\\| |#| |
-| |#| +--------------------------------------+ |#| |
-| |#|                   C                      |#| |
-| |#+------------------------------------------+#| |
-| |#################### B #######################| |
-| +----------------------------------------------+ |
-|                      	A 	       	      	   |
-+--------------------------------------------------+
-
-
- A: GtkContainer::border_width
- B: GtkWidget::focus_width
- C: GtkWidget::focus_padding
- D: xthickness
- E: CHILD_LEFT_SPACING
- F: CHILD_RIGHT_SPACING + GtkOptionMenu::indicator_spacing::left
- G: GtkOptionMenu::indicator_spacing::right
- H: ythickness
- I: GtkOptionMenu::indicator_size::width
- J: GtkOptionMenu::indicator_size::height
- K: CHILD_TOP_SPACING
- L: CHILD_TOP_SPACING + GtkOptionMenu::indicator_spacing::top
- M: CHILD_BOTTOM_SPACING
- N: CHILD_BOTTOM_SPACING + GtkOptionMenu::indicator_spacing::bottom
-
-
-III) interior_focus = FALSE, !HAVE_FOCUS
-
-+--------------------------------------------------+
-+                       A                          |
-| +----------------------------------------------+ |
-| |\\\\\\\\\\\\\\\\\\\\ H ///////////////////////| |
-| |\+------------------------------------------+/| |
-| |\|                                          |/| |
-| |\|                                          |/| |
-| |\|                                          |/| |
-| |\|                                          |/| |
-| |\|             K                   L        |/| |
-| |\|     +----------------------+ +-----+     |/| |
-| |\|     |                      | | /#\ |     |/| |
-| |\|     |                      | | === |     |/| |
-|A|D|    E|    	 Child         	 |F| IxJ |G    |D|A|
-| |/|     |                      | | === |     |\| |
-| |/|     |                      | | \#/ |     |\| |
-| |/|     +----------------------+ +-----+     |\| |
-| |/|             M                   N        |\| |
-| |/|                                          |\| |
-| |/|                                          |\| |
-| |/|                                          |\| |
-| |/|                                          |\| |
-| |/+------------------------------------------+\| |
-| |//////////////////// H \\\\\\\\\\\\\\\\\\\\\\\| |
-| +----------------------------------------------+ |
-|                      	A 	       	      	   |
-+--------------------------------------------------+
-
-
- A: GtkContainer::border_width
- B: GtkWidget::focus_width
- C: GtkWidget::focus_padding
- D: xthickness
- E: CHILD_LEFT_SPACING + GtkWidget::focus_width + GtkWidget::focus_padding
- F: CHILD_RIGHT_SPACING + GtkOptionMenu::in+icator_spacing::left
- G: GtkOptionMenu::indicator_spacing::right + GtkWidget::focus_width + GtkWidget::focus_padding
- H: ythickness
- I: GtkOptionMenu::indicator_size::width
- J: GtkOptionMenu::indicator_size::height
- K: CHILD_TOP_SPACING + GtkWidget::focus_width + GtkWidget::focus_padding
- L: CHILD_TOP_SPACING + GtkOptionMenu::indicator_spacing::top + GtkWidget::focus_width + GtkWidget::focus_padding
- M: CHILD_BOTTOM_SPACING + GtkWidget::focus_width + GtkWidget::focus_padding
- N: CHILD_BOTTOM_SPACING + GtkOptionMenu::indicator_spacing::bottom + GtkWidget::focus_width + GtkWidget::focus_padding
-
-
-
-=====================
-
-GtkButton
-
-=====================
-
-NOTE: Due to a bug that is basically unfixable in a sufficiently compatible
-NOTE: way, the button gives the space requested for focus_width and 
-NOTE: focus_padding to the child (in addition to the space requested by
-NOTE: the child), if the button is !CAN_FOCUS.
-
- Style properties
-
-   GtkWidget::interior_focus = TRUE
-   GtkWidget::focus_width = 1
-   GtkWidget::focus_padding = 0
-   GtkButton::default_border = { 1, 1, 1, 1 };
-   GtkButton::default_outside_border = { 0, 0, 0, 0 };
-   GtkButton::child_displacement_x = 0;
-   GtkButton::child_displacement_y = 0;
-
- Properties
-
-   GtkContainer::border_width = 0
-
- #defines
-
-   CHILD_SPACING 1
-
-I) HAS_DEFAULT && (!GtkWidget::interior-focus || !HAVE_FOCUS)
-
-+----------------------------------------------+
-|    		       A 		       |
-| +------------------------------------------+ |
-| |@@@@@@@@@@@@@@@@@@@ I @@@@@@@@@@@@@@@@@@@@| |
-| |@+--------------------------------------+@| |
-| |@|\\\\\\\\\\\\\\\\\ J //////////////////|@| |
-| |@|\+----------------------------------+/|@| |
-| |@|\|                E                 |/|@| |
-| |@|\| +------------------------------+ |/|@| |
-| |@|\| |############# F ##############| |/|@| |
-| |@|\| |#+--------------------------+#| |/|@| |
-| |@|\| |#|            L             |#| |/|@| |
-| |@|\| |#| +----------------------+ |#| |/|@| |
-| |@|\| |#| |                      | |#| |/|@| |
-| |@|\| |#| |                      | |#| |/|@| |
-|A|B|D|E|F|G|        Child         |M|F|E|D|C|A|
-| |@|/| |#| |                      | |#| |\|@| |
-| |@|/| |#| |                      | |#| |\|@| |
-| |@|/| |#| +----------------------+ |#| |\|@| |
-| |@|/| |#|            N             |#| |\|@| |
-| |@|/| |#+--------------------------+#| |\|@| |
-| |@|/| |############# F ##############| |\|@| |
-| |@|/| +------------------------------+ |\|@| |
-| |@|/|                E                 |\|@| |
-| |@|/+----------------------------------+\|@| |
-| |@|///////////////// J \\\\\\\\\\\\\\\\\\|@| |
-| |@+--------------------------------------+@| |
-| |@@@@@@@@@@@@@@@@@@@ K @@@@@@@@@@@@@@@@@@@@| |
-| +------------------------------------------+ |
-|                      A                       |
-+----------------------------------------------+
-
-A: GtkContainer::border-width
-B: GtkButton::default-border::left
-C: GtkButton::default-border::right
-D: xthickness
-E: GtkWidget::focus-padding
-F: GtkWidget::focus-line-width
-G: CHILD_SPACING + (depressed ? GtkButton::child-displacement-x : 0)
-I: GtkButton::default-border::top
-J: ythickness
-K: GtkButton::default-border::bottom
-L: CHILD_SPACING + (depressed ? GtkButton::child-displacement-y : 0)
-M: CHILD_SPACING - (depressed ? GtkButton::child-displacement-x : 0)
-N: CHILD_SPACING - (depressed ? GtkButton::child-displacement-y : 0)
-
-
-II) !HAS_DEFAULT && (!GtkWidget::interior-focus || !HAVE_FOCUS)
-
-+----------------------------------------------+
-|    		         		       |
-|                      I                       |
-|                                              |
-|   +--------------------------------------+   |
-|   |\\\\\\\\\\\\\\\\\ J //////////////////|   |
-|   |\+----------------------------------+/|   |
-|   |\|                E                 |/|   |
-|   |\| +------------------------------+ |/|   |
-|   |\| |############# F ##############| |/|   |
-|   |\| |#+--------------------------+#| |/|   |
-|   |\| |#|            L             |#| |/|   |
-|   |\| |#| +----------------------+ |#| |/|   |
-|   |\| |#| |                      | |#| |/|   |
-|   |\| |#| |                      | |#| |/|   |
-| B |D|E|F|G|        Child         |M|F|E|D| C |
-|   |/| |#| |                      | |#| |\|   |
-|   |/| |#| |                      | |#| |\|   |
-|   |/| |#| +----------------------+ |#| |\|   |
-|   |/| |#|            N             |#| |\|   |
-|   |/| |#+--------------------------+#| |\|   |
-|   |/| |############# F ##############| |\|   |
-|   |/| +------------------------------+ |\|   |
-|   |/|                E                 |\|   |
-|   |/+----------------------------------+\|   |
-|   |///////////////// J \\\\\\\\\\\\\\\\\\|   |
-|   +--------------------------------------+   |
-|                                              |
-|                      K                       |
-|                                              |
-+----------------------------------------------+
-
-
-a) CAN_DEFAULT
-
-B: GtkContainer::border-width + GtkButton::default-outside-border::left
-C: GtkContainer::border-width + GtkButton::default-outside-border::right
-D: xthickness
-E: GtkWidget::focus-padding
-F: GtkWidget::focus-line-width
-G: CHILD_SPACING + (depressed ? GtkButton::child-displacement-x : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::left
-I: GtkContainer::border-width + GtkButton::default-outside-border::top
-J: ythickness
-K: GtkContainer::border-width + GtkButton::default-outside-border::bottom
-L: CHILD_SPACING + (depressed ? GtkButton::child-displacement-y : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::top
-M: CHILD_SPACING - (depressed ? GtkButton::child-displacement-x : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::right
-N: CHILD_SPACING - (depressed ? GtkButton::child-displacement-y : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::bottom
-
-
-b) !CAN_DEFAULT
-
-B: GtkContainer::border-width
-C: GtkContainer::border-width
-D: xthickness
-E: GtkWidget::focus-padding
-F: GtkWidget::focus-line-width
-G: CHILD_SPACING + (depressed ? GtkButton::child-displacement-x : 0)
-I: GtkContainer::border-width
-J: ythickness
-K: GtkContainer::border-width
-L: CHILD_SPACING + (depressed ? GtkButton::child-displacement-y : 0)
-M: CHILD_SPACING - (depressed ? GtkButton::child-displacement-x : 0)
-N: CHILD_SPACING - (depressed ? GtkButton::child-displacement-y : 0)
-
-
-
-
-III) HAS_DEFAULT && (GtkWidget::interior-focus && HAVE_FOCUS)
-
-+----------------------------------------------+
-|    		       A 		       |
-| +------------------------------------------+ |
-| |@@@@@@@@@@@@@@@@@@@ I @@@@@@@@@@@@@@@@@@@@| |
-| |@+--------------------------------------+@| |
-| |@|################# F ##################|@| |
-| |@|#+----------------------------------+#|@| |
-| |@|#|                E                 |#|@| |
-| |@|#| +------------------------------+ |#|@| |
-| |@|#| |\\\\\\\\\\\\\ J //////////////| |#|@| |
-| |@|#| |\+--------------------------+/| |#|@| |
-| |@|#| |\|            L             |/| |#|@| |
-| |@|#| |\| +----------------------+ |/| |#|@| |
-| |@|#| |\| |                      | |/| |#|@| |
-| |@|#| |\| |                      | |/| |#|@| |
-|A|B|F|E|D|G|        Child         |M|D|E|F|C|A|
-| |@|#| |/| |                      | |\| |#|@| |
-| |@|#| |/| |                      | |\| |#|@| |
-| |@|#| |/| +----------------------+ |\| |#|@| |
-| |@|#| |/|            N             |\| |#|@| |
-| |@|#| |/+--------------------------+\| |#|@| |
-| |@|#| |///////////// J \\\\\\\\\\\\\\| |#|@| |
-| |@|#| +------------------------------+ |#|@| |
-| |@|#|                E                 |#|@| |
-| |@|#+----------------------------------+#|@| |
-| |@|################# F ##################|@| |
-| |@+--------------------------------------+@| |
-| |@@@@@@@@@@@@@@@@@@@ K @@@@@@@@@@@@@@@@@@@@| |
-| +------------------------------------------+ |
-|                      A                       |
-+----------------------------------------------+
-
-A: GtkContainer::border-width
-B: GtkButton::default-border::left
-C: GtkButton::default-border::right
-D: xthickness
-E: GtkWidget::focus-padding
-F: GtkWidget::focus-line-width
-G: CHILD_SPACING + (depressed ? GtkButton::child-displacement-x : 0)
-I: GtkButton::default-border::top
-J: ythickness
-K: GtkButton::default-border::bottom
-L: CHILD_SPACING + (depressed ? GtkButton::child-displacement-y : 0)
-M: CHILD_SPACING - (depressed ? GtkButton::child-displacement-x : 0)
-N: CHILD_SPACING - (depressed ? GtkButton::child-displacement-y : 0)
-
-
-IV) !HAS_DEFAULT && (GtkWidget::interior-focus && HAVE_FOCUS)
-
-+----------------------------------------------+
-|    		         		       |
-|                      I                       |
-|                                              |
-|   +--------------------------------------+   |
-|   |################# J ##################|   |
-|   |#+----------------------------------+#|   |
-|   |#|                E                 |#|   |
-|   |#| +------------------------------+ |#|   |
-|   |#| |\\\\\\\\\\\\\ F //////////////| |#|   |
-|   |#| |\+--------------------------+/| |#|   |
-|   |#| |\|            L             |/| |#|   |
-|   |#| |\| +----------------------+ |/| |#|   |
-|   |#| |\| |                      | |/| |#|   |
-|   |#| |\| |                      | |/| |#|   |
-| B |D|E|F|G|        Child         |M|F|E|D| C |
-|   |#| |/| |                      | |\| |#|   |
-|   |#| |/| |                      | |\| |#|   |
-|   |#| |/| +----------------------+ |\| |#|   |
-|   |#| |/|            N             |\| |#|   |
-|   |#| |/+--------------------------+\| |#|   |
-|   |#| |///////////// F \\\\\\\\\\\\\\| |#|   |
-|   |#| +------------------------------+ |#|   |
-|   |#|                E                 |#|   |
-|   |#+----------------------------------+#|   |
-|   |################# J ##################|   |
-|   +--------------------------------------+   |
-|                                              |
-|                      K                       |
-|                                              |
-+----------------------------------------------+
-
-
-a) CAN_DEFAULT
-
-B: GtkContainer::border-width + GtkButton::default-outside-border::left
-C: GtkContainer::border-width + GtkButton::default-outside-border::right
-D: xthickness
-E: GtkWidget::focus-padding
-F: GtkWidget::focus-line-width
-G: CHILD_SPACING + (depressed ? GtkButton::child-displacement-x : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::left
-I: GtkContainer::border-width + GtkButton::default-outside-border::top
-J: ythickness
-K: GtkContainer::border-width + GtkButton::default-outside-border::bottom
-L: CHILD_SPACING + (depressed ? GtkButton::child-displacement-y : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::top
-M: CHILD_SPACING - (depressed ? GtkButton::child-displacement-x : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::right
-N: CHILD_SPACING - (depressed ? GtkButton::child-displacement-y : 0) +
-   (GtkButton::default-outside-border - GtkButton::default-outside-border)::bottom
-
-
-b) !CAN_DEFAULT
-
-B: GtkContainer::border-width
-C: GtkContainer::border-width
-D: xthickness
-E: GtkWidget::focus-padding
-F: GtkWidget::focus-line-width
-G: CHILD_SPACING + (depressed ? GtkButton::child-displacement-x : 0)
-I: GtkContainer::border-width
-J: ythickness
-K: GtkContainer::border-width
-L: CHILD_SPACING + (depressed ? GtkButton::child-displacement-y : 0)
-M: CHILD_SPACING - (depressed ? GtkButton::child-displacement-x : 0)
-N: CHILD_SPACING - (depressed ? GtkButton::child-displacement-y : 0)
-
-
-======================
-
-GtkCheckButton
-
-======================
-
-Note: This is the draw_indicator=TRUE case; draw_indicator=FALSE
-      is like GtkButton)
-
- Style properties
-
-   GtkWidget::interior_focus = TRUE
-   GtkWidget::focus_width = 1
-   GtkWidget::focus_padding = 0
-   GtkButton::indicator-size = 13
-   GtkButton::indicator-spacing = 2
-
- Properties
-
-   GtkContainer::border_width = 0
-
- #defines
-
-   CHILD_SPACING 1
-
-interior_focus
-
- +-------------------------------------------+
- |		               F             |
- |	 G	  +------------------------+ |
- |		  |########### D ##########| |
- | +------------+ |#+--------------------+#| |
- | |            | |#|	       E	 |#| |
- | |            | |#| +----------------+ |#| |
- | |            | |#| |		       | |#| |
- |A|    BxB     |C|D|E|      Child     |E|#|F|
- | |            | |#| |		       | |#| |
- | |            | |#| +----------------+ |#| |
- | |            | |#|	       E       	 |#| |
- | +------------+ |#+--------------------+#| |
- |		  |########### D ##########| |
- |	G	  +------------------------+ |
- |		               F             |
- +-------------------------------------------+
-
-A: GtkContainer::border-width + GtkCheckButton::indicator-spacing
-B: GtkCheckButton::indicator-size
-C: 2 * GtkCheckButton::indicator-spacing
-D: GtkWidget::focus-line-width
-E: GtkWidget::focus-padding
-F: GtkContainer::border-width
-G: GtkConainer::border-width + GtkCheckButton::indicator-spacing
-
-!interior_focus
-
- +-------------------------------------------+
- |		     A                       |
- | +---------------------------------------+ |
- | |################ D ####################| |
- | |#+-----------------------------------+#| |
- | |#|       G                E          |#| |
- | |#| +------------+  +---------------+ |#| |
- | |#| |            |  |               | |#| |
- | |#| |            |  |	       | |#| |
- |A|D|F|    BxB     |C |      Child    |E|D|A|
- | |#| |            |  |	       | |#| |
- | |#| |            |  |               | |#| |
- | |#| +------------+  +---------------+ |#| |
- | |#|       G                E          |#| |
- | |#+-----------------------------------+#| |
- | |################ D ####################| |
- | +---------------------------------------+ |
- |		     A                       |
- +-------------------------------------------+
-
-A: GtkContainer::border-width
-B: GtkCheckButton::indicator-size
-C: 2 * GtkCheckButton::indicator-spacing
-D: GtkWidget::focus-line-width
-E: GtkWidget::focus-padding
-F: GtkWidget::focus-padding + GtkCheckButton::indicator-spacing
-G: GtkWidget::focus-padding + GtkCheckButton::indicator-spacing
-
-===============
-
-GtkEntry
-
-===============
-
- Style properties
-
-   GtkWidget::interior_focus = TRUE
-   GtkWidget::focus_width = 1
-   GtkWidget::focus_padding = 0
-
- Properties
-
-   GtkContainer::border_width = 0
-
- #defines
-
-   INNER_BORDER 2
-
-
-
-interior_focus
-
-+--------------------------------------+
-|\\\\\\\\\\\\\\\\\ B //////////////////|
-|\+----------------------------------+/|
-|\|		   D 	       	     |/|
-|\| +------------------------------+ |/|
-|\| |		    	       	   | |/|
-|\| |  	       	       	       	   | |/|
-|A|D|  	       	    	       	   |D|A|
-|\| |		    		   | |/|
-|\| |		    		   | |/|
-|\| +------------------------------+ |/|
-|\| 		   D   		     |/|
-|\+----------------------------------+/|
-|///////////////// B \\\\\\\\\\\\\\\\\/|
-+--------------------------------------+
-
-A: xthickness
-B: ythickness
-D: INNER_BORDER
-
-!interior_focus
-
-+------------------------------------------+
-|####################C#####################|
-|#+--------------------------------------+#|
-|#|\\\\\\\\\\\\\\\\\ B //////////////////|#|
-|#|\+----------------------------------+/|#|
-|#|\|  	       	     D	       	       |/|#|
-|#|\| +------------------------------+ |/|#|
-|#|\| |		     	       	     | |/|#|
-|#|\| |  	       	       	     | |/|#|
-|C|A|D|  	       	    	     |D|A|C|
-|#|\| |		     		     | |/|#|
-|#|\| |		     		     | |/|#|
-|#|\| +------------------------------+ |/|#|
-|#|\| 		     D 	       	       |/|#|
-|#|\+----------------------------------+/|#|
-|#|///////////////// B \\\\\\\\\\\\\\\\\/|#|
-|#+--------------------------------------+#|
-|####################C#####################|
-+------------------------------------------+
-
-A: xthickness
-B: ythickness
-C: GtkWidget::focus-line-width
-D: INNER_BORDER + (HAVE_FOCUS ? 0 : GtkWidget::focus-line-width
-
-Note - effect here for !interior_focus is that bevel moves in
-by focus-line-width when entry gains focus
-
-===============
-
-GtkExpander
-
-===============
-
- Style properties
-  GtkWidget::focus_line_width
-  GtkWidget::focus_padding
-  GtkExpander::expander_size
-  GtkExpander::expander_spacing
-
- Properties
-  GtkContainer::border_width
-  GtkExpander::spacing
-
-if (GTK_WIDGET_VISIBLE (bin->child) && interior_focus)
-
-+-------------------------------------+
-|                  A                  |
-| +---------+-----------------------+ |
-| |    C    |##########E############| |
-| | +-----+ |#+-------------------+#| |
-| | |     | |#|        F          |#| |
-| | |     | |#| +---------------+ |#| |
-|A|C| BxB |C|E|F| label_widget  |F|E|A|
-| | |     | |#| +---------------+ |#| |
-| | |     | |#|        F          |#| |
-| | +-----+ |#+-------------------+#| |
-| |    C    |##########E############| |
-| +---------+-----------------------+ |
-| |                D                | |
-| +---------------------------------+ |
-| |                                 | |
-| |                                 | |
-| |                                 | |
-|A|             bin->child          |A|
-| |                                 | |
-| |                                 | |
-| |                                 | |
-| +---------------------------------+ |
-|                  A                  |
-+-------------------------------------+
-
- A: GtkContainer::border_width
- B: GtkExpander::expander_size
- C: GtkExpander::expander_spacing
- D: GtkExpander::spacing
- E: GtkWidget::focus_line_width
- F: GtkWidget::focus_padding
-
-if (GTK_WIDGET_VISIBLE (bin->child) && !interior_focus)
-
-+-------------------------------------------+
-|                    A                      |
-| +---------------------------------------+ |
-| |##################E####################| |
-| |#+-----------------------------------+#| |
-| |#|                F                  |#| |
-| |#| +---------+---------------------+ |#| |
-| |#| |    C    |                     | |#| |
-| |#| | +-----+ |                     | |#| |
-|A|E|F|C| BxB |C|    label_widget     |F|E|A|
-| |#| | +-----+ |                     | |#| |
-| |#| |    C    |                     | |#| |
-| |#| +---------+---------------------+ |#| |
-| |#|                F                  |#| |
-| |#+-----------------------------------+#| |
-| |##################E####################| |
-| +---------------------------------------+ |
-| |                  D                    | |
-| +---------------------------------------+ |
-| |                                       | |
-| |                                       | |
-| |                                       | |
-|A|               bin->child              |A|
-| |                                       | |
-| |                                       | |
-| |                                       | |
-| +---------------------------------------+ |
-|                     A                     |
-+-------------------------------------------+
-
- A: GtkContainer::border_width
- B: GtkExpander::expander_size
- C: GtkExpander::expander_spacing
- D: GtkExpander::spacing
- E: GtkWidget::focus_line_width
- F: GtkWidget::focus_padding
-
-if (!GTK_WIDGET_VISIBLE (bin->child) && interior_focus)
-
-+-------------------------------------+
-|                  A                  |
-| +---------+-----------------------+ |
-| |    C    |##########E############| |
-| | +-----+ |#+-------------------+#| |
-| | |     | |#|        F          |#| |
-| | |     | |#| +---------------+ |#| |
-|A|C| BxB |C|E|F| label_widget  |F|E|A|
-| | |     | |#| +---------------+ |#| |
-| | |     | |#|        F          |#| |
-| | +-----+ |#+-------------------+#| |
-| |    C    |##########E############| |
-| +---------+-----------------------+ |
-|                  A                  |
-+-------------------------------------+
-
- A: GtkContainer::border_width
- B: GtkExpander::expander_size
- C: GtkExpander::expander_spacing
- E: GtkWidget::focus_line_width
- F: GtkWidget::focus_padding
-
-if (!GTK_WIDGET_VISIBLE (bin->child) && !interior_focus)
-
-+-------------------------------------------+
-|                    A                      |
-| +---------------------------------------+ |
-| |##################E####################| |
-| |#+-----------------------------------+#| |
-| |#|                F                  |#| |
-| |#| +---------+---------------------+ |#| |
-| |#| |    C    |                     | |#| |
-| |#| | +-----+ |                     | |#| |
-|A|E|F|C| BxB |C|     label_widget    |F|E|A|
-| |#| | +-----+ |                     | |#| |
-| |#| |    C    |                     | |#| |
-| |#| +---------+---------------------+ |#| |
-| |#|                F                  |#| |
-| |#+-----------------------------------+#| |
-| |##################E####################| |
-| +---------------------------------------+ |
-|                    A                      |
-+-------------------------------------------+
-
- A: GtkContainer::border_width
- B: GtkExpander::expander_size
- C: GtkExpander::expander_spacing
- E: GtkWidget::focus_line_width
- F: GtkWidget::focus_padding

docs/widget_system.txt

@@ -1,500 +0,0 @@
-Notes about the inner workings of the widget system of GTK
-==========================================================
-
-This file contains some notes as to how the widget system does
-and should work. It consists of three parts:
-
- I) A description of the meaning of the various flags
-
- II) A list of invariants about the states of the widgets. 
-    (Throughout this document, we refer to the states of the
-     widgets by referring to the flags for GtkWidget)
-
- III) Some notes about the ways that a widget changes states
-
- IV) A list of responsibilities of various widget signals when
-    the states change.
-
-Any action necessary to maintain the invariants in II which is not
-explicitly mentioned in IV), is the responsibility of the core GTK
-code, which is roughly defined as:
-
-  gtkobject.c
-  gtkwidget.c
-  gtkcontainer.c
-  gtkmain.c
-  gtksignal.c
-
-Section II is mostly of interest to those maintaining GTK, the
-other sections may also be interesting to people writing
-new widgets.
-
-Main outline:
-	- Owen Taylor <owt1@cornell.edu>
-	  1998/02/03
-
-Flag descriptions:
-	- Tim Janik <timj@gimp.org>
-	  1998/02/04
-
-I. Flags
---------
-
-GtkObject:
-
-GTK_DESTROYED:
-	This flagged is set for a GtkObject right before its
-	destruction code is executed. Its main use is the
-	prevention of multiple destruction invocations.
-	
-GTK_FLOATING:
-	This flag reflects the fact that the holder of the
-	initial reference count is unknown. Refer to refcounting.txt
-	for further details.
-
-GTK_RESERVED_1:
-GTK_RESERVED_2:
-	Reserved flags.
-
-
-GtkWidget, public flags:
-
-GTK_TOPLEVEL:
-	Widgets without a real parent, as there are GtkWindows and
-	GtkMenus have this flag set throughout their lifetime.
-	Toplevel widgets always contain their own GdkSurface.
-	
-GTK_NO_WINDOW:
-	This flag is indicative for a widget that does not provide
-	its own GdkSurface. Visible action (e.g. drawing) is performed
-	on the parent's GdkSurface.
-
-GTK_REALIZED:
-	Set by gtk_widget_realize, unset by gtk_widget_unrealize.
-	Relies on ((widget->parent && widget->parent->window)
-	           || GTK_WIDGET_TOPLEVEL (widget));
-	Means: widget has an associated GdkSurface (XWindow).
-
-GTK_MAPPED:
-	Set by gtk_widget_map, unset by gtk_widget_unmap.
-	May only be set if GTK_WIDGET_REALIZED (widget).
-	Means: gdk_surface_show() has been called on the widgets window(s).
-
-GTK_VISIBLE:
-	Set by gtk_widget_show.
-	Implies that a widget will be flagged GTK_MAPPED as soon as its
-	parent is mapped.
-!GTK_VISIBLE:
-	Set by gtk_widget_hide.
-	Implies that a widget is not onscreen, therefore !GTK_MAPPED.
-
-GTK_CHILD_VISIBLE
-        Set by gtk_widget_set_child_visible, and if FALSE indicates that 
-        the widget should not be mapped even if the parent is mapped
-        and visible. Containers like GtkNotebook use this flag.
-        A private flag, not a public flag, so if you need to check
-        this flag, you should call gtk_widget_get_child_visible().
-        (Should be very rarely necessary.)
-
-GTK_SENSITIVE:
-	Set and unset by gtk_widget_set_sensitive.
-	The sensitivity of a widget determines whether it will receive
-	certain events (e.g. button or key presses). One premise for
-	the widgets sensitivity is to have GTK_SENSITIVE set.
-
-GTK_PARENT_SENSITIVE:
-	Set and unset by gtk_widget_set_sensitive operations on the
-	parents of the widget.
-	This is the second premise for the widgets sensitivity. Once
-	it has GTK_SENSITIVE and GTK_PARENT_SENSITIVE set, its state is
-	effectively sensitive. This is expressed (and can be examined) by
-	the GTK_WIDGET_IS_SENSITIVE macro.
-
-GTK_CAN_FOCUS:
-	There are no directly corresponding functions for setting/unsetting
-	this flag, but it can be affected by the GtkWidget::has_focus argument
-	via gtk_widget_set_arg.
-	This flag determines whether a widget is able to handle focus grabs.
-
-GTK_HAS_FOCUS:
-	This flag will be set by gtk_widget_grab_focus for widgets that also
-	have GTK_CAN_FOCUS set. The flag will be unset once another widget
-	grabs the focus.
-	
-GTK_CAN_DEFAULT:
-GTK_HAS_DEFAULT:
-	These two flags are mostly equal in functionality to their *_FOCUS
-	counterparts, but for the default widget.
-
-GTK_HAS_GRAB:
-	Set by gtk_grab_add, unset by gtk_grab_remove.
-	Means: widget is in the grab_widgets stack, and will be the preferred
-	one for receiving events other than ones of cosmetic value.
-
-GTK_BASIC:
-	The GTK_BASIC flag is an attempt at making a distinction
-	between widgets that handle user input e.g. key/button presses
-	and those that don't. Subsequent parent<->child relation ships
-	of non `basic' widgets should be avoided. The checking for
-	this is currently not properly enforced in the code. For
-	example GtkButton is a non `basic' widget, that will therefore
-	disallow to act as a container for another GtkButton. Now the
-	gnit is, one can add a GtkHBox (which is a `basic' widget) to
-	the first button, and put the second into the box.
-
-GTK_RESERVED_3:
-
-GTK_RC_STYLE:
-	This flag indicates that its style has been looked up through
-	the rc mechanism. It does not imply that the widget actually
-	had a style defined through the rc mechanism.
-
-
-GtkWidget, private flags:
-
-GTK_USER_STYLE:
-	A widget is flagged to have a user style, once gtk_widget_set_style
-	has been invoked for it. The use of this flag is to tell widgets
-	which share a global user style from the ones which got a certain
-	style assign from outside the toolkit.
-	
-GTK_RESIZE_PENDING:
-	First, this is only valid for GtkContainers.
-	[some of the code should move to gtkcontainer.c therefore]
-	Relies on GTK_WIDGET_REALIZED(widget)
-	[this is not really enforced throughout the code, but should
-	 be. it only requires a few checks for GTK_WIDGET_REALIZED and
-	 minor changes to gtk_widget_unrealize, we can then remove the check
-	 in gtk_widget_real_destroy]
-	Means: there is an idle handler waiting for the container to
-	resize it.
-
-GTK_RESIZE_NEEDED:
-	Relies on GTK_WIDGET_REALIZED(widget)
-	[this is not really enforced throughout the code, but should
-	 be. once this is done special checking in gtk_widget_real_destroy
-	 can be avoided]
-	Means: a widget has been added to the resize_widgets list of
-	its _toplevel_ container (keep this in mind for GtkViewport).
-	Remark: this flag is also used internally by gtkwindow.c during
-	the evaluation of resizing worthy widgets.
-
-GTK_LEAVE_PENDING:
-	A widget is flagged as such if there is a leave_notify event
-	pending for it. It will receive this event regardless of a grab
-	through another widget or its current sensitivity.
-	[this should be made relying on GTK_REALIZED]
-
-GTK_HAS_SHAPE_MASK:
-	Set by gtk_widget_shape_combine_mask if a widget got a shape mask
-	assigned (making use of the X11 shaped window extension).
-
-GTK_IN_REPARENT:
-	During the act of reparentation widgets which are already
-	realized and will be added to an already realized parent need
-	to have this flag set to prevent natural unrealization on the
-	process of getting unparented.
-
-GTK_NEED_REQUEST:
-	This flag is set if the widget doesn't have an up to date 
-	requisition. If this flag is set, we must actually emit ::size-request
-        when gtk_widget_size_request() is called. Otherwise, we can
-        simply widget->requisition. We keep track of this all the time
-        however, widgets with this flag set are only added to the resize 
-	queue if they are viewable.
-
-GTK_NEED_ALLOCATION:
-	This flag is set if the widget doesn't have an up to date 
-	allocation. If this flag is set, we must actually emit ::size-allocate
-        when gtk_widget_size_allocate() is called, even if the new allocation
-        is the same as the current allocation.
- 
-Related Macros:
-
-GTK_WIDGET_DRAWABLE:
-	This macro examines whether a widget is flagged as GTK_WIDGET_VISIBLE
-	and GTK_WIDGET_MAPPED.
-	Means: it _makes sense_ to draw in a widgets window.
-
-GTK_WIDGET_IS_SENSITIVE:
-	This macro tells the real sensitivity state of a widget. It returns
-	whether both the widget and all its parents are in sensitive state.
-
-
-II. Invariants:
----------------
-
-This section describes various constraints on the states of 
-the widget:
-
-In the following
-
-  A => B     means  if A is true, than B is true
-  A <=> B    means  A is true, if and only if B is true
-                    (equivalent to A => B and A <= B)
-
-
-1)  GTK_WIDGET_DESTROYED (widget) => !GTK_WIDGET_REALIZED (widget)
-                                  => !GTK_WIDGET_VISIBLE (widget)
-[ The latter is not currently in place, but it should be ] 
- 
-2) GTK_WIDGET_MAPPED (widget) => GTK_WIDGET_REALIZED (widget)
-
-3) if GTK_WIDGET_TOPLEVEL (widget):
-   GTK_WIDGET_VISIBLE (widget) <=> GTK_WIDGET_MAPPED (widget)
-
-4) if !GTK_WIDGET_TOPLEVEL (widget):
-  widget->parent && GTK_WIDGET_REALIZED (widget->parent) <=>
-     GTK_WIDGET_REALIZED (widget)
-
-5) if !GTK_WIDGET_TOPLEVEL (widget):
-
-   GTK_WIDGET_MAPPED (widget) => GTK_WIDGET_VISIBLE (widget)
-                              => GTK_WIDGET_CHILD_VISIBLE (widget)
-                              => GTK_WIDGET_REALIZED (widget)
-
-   widget->parent && GTK_WIDGET_MAPPED (widget->parent) && 
-     GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_CHILD_VISIBLE 
-       <=> GTK_WIDGET_MAPPED (widget)
-
-Note:, the definition
-
-[  GTK_WIDGET_DRAWABLE = GTK_WIDGET_VISIBLE && GTK_WIDGET_MAPPED
-   is made in gtkwidget.h, but by 3) and 5), 
-     
-      GTK_WIDGET_MAPPED => GTK_WIDGET_VISIBLE
-]
-
-6) GTK_REDRAW_PENDING => GTK_WIDGET_REALIZED
-   GTK_RESIZE_PENDING =>         "
-   GTK_LEAVE_PENDING  =>         "
-   GTK_RESIZE_NEEDED  =>         "
-
-III. How states are changed:
-----------------------------
-
-How can the user control the state of a widget:
------------------------------------------------
-
-(In the following, set flag means set the flag, do appropriate
-actions, and enforce above invariants) 
-
-gtk_widget_show: 
- if !GTK_DESTROYED sets GTK_VISIBLE
-
-gtk_widget_hide:
- if !GTK_VISIBLE for widget
-
-gtk_widget_destroy:
- sets GTK_DESTROYED
- For a top-level widget
-
-gtk_widget_realize:
- if !GTK_DESTROYED sets GTK_REALIZED
-- Calling gtk_widget_realize when the widget is not a descendant
-  of a toplevel is an ERROR.
-
-gtk_container_add (container, widget) [ and container-specific variants ]
- Sets widget->parent 
-
-gtk_container_remove (container, widget)
- unsets widget->parent
-
-gtk_widget_reparent (widget, new_parent)
- Equivalent to removing widget from old parent and adding it to
- the new parent, except that the widget will not be temporarily 
- unrealized if both the old parent and the new parent are realized.
-
-
-gtk_widget_unrealize
-gtk_widget_map
-gtk_widget_unmap
-
-These functions are not meant to be used by applications - they
-are used only by GTK and widgets to enforce invariants on the
-state.
-
-When The X window corresponding to a GTK window is destroyed:
--------------------------------------------------------------
-
-gtk_widget_destroy is called (as above).
-
-
-
-IV. Responsibilities of widgets
---------------------------------
-
-Adding to a container
----------------------
-
-When a widget is added to a container, the container:
-
-  1) calls gtk_widget_set_parent_surface (widget, window) if 
-     the widget is being added to something other than container->window
-  2) calls gtk_widget_set_parent (widget, container)
-
-Removing from a container
--------------------------
-
-When a widget is removed to a container, the container:
-
-  1) Calls gtk_widget_unparent (widget)
-  2) Queues a resize.
-
-Notes:
-
- gtk_widget_unparent unrealizes the widget except in the 
-   special case GTK_IN_REPARENT is set.
-
-
-At widget creation
-------------------
-
-Widgets are created in an unrealized state. 
-
- 1) The widget should allocate and initialize needed data structures
-
-
-The Realize signal
-------------------
-
-When a widget receives the "realize" signal it should:
-
- NO_WINDOW widgets: (probably OK to use default handler)
-
-  1) set the realized flag
-  2) set widget->window
-      widget->window = gtk_widget_get_parent_surface (widget);
-      g_object_ref (widget->window);
-  3) attach the widget's style
-
-  widget->style = gtk_style_attach (widget->style, widget->window);
-
- widget with window(s)
-
-  1) set the REALIZED flag
-  2) create windows with the parent obtained from
-      gtk_widget_get_parent_surface (widget);
-  3) attach the widget's style
-  4) set the background color for the new window based on the style
-
-The Map signal
---------------
-
-  1) Set the MAPPED flag
-  2) If the widget has any windows, gdk_surface_show those windows
-  3) call gtk_widget_map for all child widgets that are 
-     VISIBLE, CHILD_VISIBLE and !MAPPED. (A widget will only
-     be !CHILD_VISIBLE if the container set it that way, so
-     most containers will not have to check this.)
-  3) Do any other functions related to putting the widget onscreen.
-     (for instance, showing extra popup windows...)
-
-The Unmap signal
-----------------
-
-When a widget receives the unmap signal, it must:
-
- 1) If the widget has a window, gdk_surface_hide that window, 
- 2) If the widget does not have a window, unmap all child widgets
- 3) Do any other functions related to taking the widget offscreen
-     (for instance, removing popup windows...)
- 4) Unset GTK_MAPPED
-
-
-The Unrealize signal
---------------------
-
-When a widget receives the unrealize signal, it must
-
- 1) For any windows other than widget->window do:
-
-    gdk_surface_set_user_data (window, NULL);
-    gdk_surface_destroy (window);
-
- 2) Call the parent's unrealize handler
-
-
-The Widget class unrealize handler will take care of unrealizing
-all children if necessary. [should this be made consistent with
-unmap???]
-
-
-The Destroy Signal
-------------------
-
-Commentary:
-
-  The destroy signal probably shouldn't exist at all. A widget
-  should merely be unrealized and removed from its parent
-  when the user calls gtk_widget_destroy or a GDK_DESTROY event
-  is received. However, a large body of code depends on
-  getting a definitive signal when a widget goes away.
-
-  That could be put in the finalization step, but, especially
-  with language bindings, the cleanup step may need to refer
-  back to the widget. (To use gtk_widget_get_data, for instance)
-  If it does so via a pointer in a closure (natural for
-  Scheme, or Perl), then the finalization procedure will never
-  be called. 
-
-  Also, if we made that the finalization step, we would have
-  to propagate the GDK_DESTROY event in any case, since it is
-  at that point at which user-visible actions need to be taken.
-
-
-When a widget receives the destroy signal, it must:
-
-  1) If the widget "owns" any widgets other than its child
-     widgets, (for instance popup windows) it should
-     call gtk_widget_destroy () for them.
-
-  2) Call the parent class's destroy handler.
-
-
-The "destroy" signal will only be received once. A widget
-will never receive any other signals after the destroy
-signal (but see the section on "Finalize" below)
-
-The widget must handle calls to all publically accessible
-functions in an innocuous manner even after a "destroy"
-signal. (A widget can assume that it will not be realized 
-after a "destroy" signal is received, which may simplify
-handling this requirement)
-
-
-The Finalize Pseudo-signal
---------------------------
-
-The finalize pseudo-signal is received after all references
-to the widget have been removed. The finalize callback
-cannot make any GTK calls with the widget as a parameter.
-
-1) Free any memory allocated by the widget. (But _not_
-   the widget structure itself.
-
-2) Call the parent class's finalize signal
-
-
-A note on chaining "destroy" signals and finalize signals:
----------------------------------------------------------
-
-This is done by code like:
-
-  if (GTK_OBJECT_CLASS (parent_class)->destroy)
-    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
-
-It may not be completely obvious why this works. Note
-that parent_class is a static variable on a per-class
-basis. So say: we have
-
-  GtkFoo <- GtkBar <- GtkWidget <-GtkObject
-
-And that Foo, Widget, and Object all have destructors, but
-not Bar.
-
-Then gtk_foo_destroy will call gtk_widget_destroy (because
-it was not overridden in the Bar class structure) and
-gtk_widget_destroy will call gtk_object_destroy because
-the parent_class variable referenced by gtk_foo_destroy is the 
-static variable in gtkwidget.c: GtkObjectClass.

gdk/broadway/gdkdisplay-broadway.c

@@ -98,7 +98,9 @@ _gdk_broadway_display_size_changed (GdkDisplay                      *display,
       GdkBroadwaySurface *toplevel = l->data;
 
       if (toplevel->maximized)
-        gdk_surface_move_resize (GDK_SURFACE (toplevel), 0, 0, msg->width, msg->height);
+        gdk_broadway_surface_move_resize (GDK_SURFACE (toplevel),
+                                          0, 0,
+                                          msg->width, msg->height);
     }
 }
 

gdk/broadway/gdkprivate-broadway.h

@@ -70,6 +70,12 @@ void     _gdk_broadway_surface_grab_check_unmap   (GdkSurface *surface,
                                                    gulong     serial);
 void     gdk_broadway_surface_update_popups       (GdkSurface *surface);
 
+void gdk_broadway_surface_move_resize (GdkSurface *surface,
+                                       gint        x,
+                                       gint        y,
+                                       gint        width,
+                                       gint        height);
+
 void _gdk_keymap_keys_changed     (GdkDisplay      *display);
 gint _gdk_broadway_get_group_for_state (GdkDisplay      *display,
                                         GdkModifierType  state);

gdk/broadway/gdksurface-broadway.c

@@ -88,10 +88,10 @@ gdk_broadway_surface_finalize (GObject *object)
 }
 
 static gboolean
-thaw_clock_cb (GdkFrameClock *clock)
+thaw_updates_cb (GdkSurface *surface)
 {
-  _gdk_frame_clock_thaw (clock);
-  g_object_unref (clock);
+  gdk_surface_thaw_updates (surface);
+  g_object_unref (surface);
   return G_SOURCE_REMOVE;
 }
 
@@ -109,9 +109,9 @@ _gdk_broadway_roundtrip_notify (GdkSurface  *surface,
 
   /* If there is no remote web client, rate limit update to once a second */
   if (local_reply)
-    g_timeout_add_seconds (1, (GSourceFunc)thaw_clock_cb, g_object_ref (clock));
+    g_timeout_add_seconds (1, (GSourceFunc)thaw_updates_cb, g_object_ref (surface));
   else
-    _gdk_frame_clock_thaw (clock);
+    gdk_surface_thaw_updates (surface);
 
   if (timings)
     {
@@ -140,7 +140,7 @@ on_frame_clock_after_paint (GdkFrameClock *clock,
   GdkBroadwayDisplay *broadway_display;
 
   impl->pending_frame_counter = gdk_frame_clock_get_frame_counter (clock);
-  _gdk_frame_clock_freeze (gdk_surface_get_frame_clock (surface));
+  gdk_surface_freeze_updates (surface);
 
   broadway_display = GDK_BROADWAY_DISPLAY (display);
 
@@ -368,12 +368,12 @@ gdk_broadway_surface_withdraw (GdkSurface *surface)
 }
 
 static void
-gdk_broadway_surface_move_resize (GdkSurface *surface,
-                                  gboolean   with_move,
-                                  gint       x,
-                                  gint       y,
-                                  gint       width,
-                                  gint       height)
+gdk_broadway_surface_move_resize_internal (GdkSurface *surface,
+                                           gboolean    with_move,
+                                           gint        x,
+                                           gint        y,
+                                           gint        width,
+                                           gint        height)
 {
   GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
   GdkBroadwayDisplay *broadway_display;
@@ -424,6 +424,84 @@ gdk_broadway_surface_move_resize (GdkSurface *surface,
     }
 }
 
+void
+gdk_broadway_surface_move_resize (GdkSurface *surface,
+                                  gint        x,
+                                  gint        y,
+                                  gint        width,
+                                  gint        height)
+{
+  gdk_broadway_surface_move_resize_internal (surface, TRUE,
+                                             x, y,
+                                             width, height);
+}
+
+static void
+gdk_broadway_surface_toplevel_resize (GdkSurface *surface,
+                                      gint        width,
+                                      gint        height)
+{
+  gdk_broadway_surface_move_resize_internal (surface, FALSE,
+                                             0, 0,
+                                             width, height);
+}
+
+static void
+gdk_broadway_surface_move (GdkSurface *surface,
+                           gint        x,
+                           gint        y)
+{
+  gdk_broadway_surface_move_resize_internal (surface, TRUE, x, y, -1, -1);
+}
+
+static void
+gdk_broadway_surface_moved_to_rect (GdkSurface   *surface,
+                                    GdkRectangle  final_rect)
+{
+  GdkSurface *toplevel;
+  int x, y;
+
+  if (surface->surface_type == GDK_SURFACE_POPUP)
+    toplevel = surface->parent;
+  else
+    toplevel = surface->transient_for;
+
+  gdk_surface_get_origin (toplevel, &x, &y);
+  x += final_rect.x;
+  y += final_rect.y;
+
+  if (final_rect.width != surface->width ||
+      final_rect.height != surface->height)
+    {
+      gdk_broadway_surface_move_resize (surface,
+                                        x, y,
+                                        final_rect.width, final_rect.height);
+    }
+  else
+    {
+      gdk_broadway_surface_move (surface, x, y);
+    }
+}
+
+static void
+gdk_broadway_surface_move_to_rect (GdkSurface         *surface,
+                                   const GdkRectangle *rect,
+                                   GdkGravity          rect_anchor,
+                                   GdkGravity          surface_anchor,
+                                   GdkAnchorHints      anchor_hints,
+                                   gint                rect_anchor_dx,
+                                   gint                rect_anchor_dy)
+{
+  gdk_surface_move_to_rect_helper (surface,
+                                   rect,
+                                   rect_anchor,
+                                   surface_anchor,
+                                   anchor_hints,
+                                   rect_anchor_dx,
+                                   rect_anchor_dy,
+                                   gdk_broadway_surface_moved_to_rect);
+}
+
 static void
 gdk_broadway_surface_raise (GdkSurface *surface)
 {
@@ -695,9 +773,9 @@ gdk_broadway_surface_maximize (GdkSurface *surface)
   monitor = gdk_display_get_primary_monitor (display);
   gdk_monitor_get_geometry (monitor, &geom);
 
-  gdk_surface_move_resize (surface,
-                          geom.x, geom.y,
-                          geom.width, geom.height);
+  gdk_broadway_surface_move_resize (surface,
+                                    geom.x, geom.y,
+                                    geom.width, geom.height);
 }
 
 static void
@@ -718,11 +796,11 @@ gdk_broadway_surface_unmaximize (GdkSurface *surface)
 
   gdk_synthesize_surface_state (surface, GDK_SURFACE_STATE_MAXIMIZED, 0);
 
-  gdk_surface_move_resize (surface,
-                          impl->pre_maximize_x,
-                          impl->pre_maximize_y,
-                          impl->pre_maximize_width,
-                          impl->pre_maximize_height);
+  gdk_broadway_surface_move_resize (surface,
+                                    impl->pre_maximize_x,
+                                    impl->pre_maximize_y,
+                                    impl->pre_maximize_width,
+                                    impl->pre_maximize_height);
 }
 
 static void
@@ -813,7 +891,9 @@ gdk_broadway_surface_update_popups (GdkSurface *parent)
       int new_y = parent->y + popup_impl->offset_y;
 
       if (new_x != popup->x || new_y != popup->y)
-        gdk_broadway_surface_move_resize (popup, TRUE, new_x, new_y, popup->width, popup->height);
+        gdk_broadway_surface_move_resize (popup,
+                                          new_x, new_y,
+                                          popup->width, popup->height);
       gdk_broadway_surface_restack_toplevel (popup, parent, TRUE);
     }
 }
@@ -935,7 +1015,8 @@ update_pos (MoveResizeData *mv_resize,
                                      w, h, &w, &h);
         }
 
-      gdk_surface_move_resize (mv_resize->moveresize_surface, x, y, w, h);
+      gdk_broadway_surface_move_resize (mv_resize->moveresize_surface,
+                                        x, y, w, h);
     }
   else
     {
@@ -944,7 +1025,7 @@ update_pos (MoveResizeData *mv_resize,
       x = mv_resize->moveresize_orig_x + dx;
       y = mv_resize->moveresize_orig_y + dy;
 
-      gdk_surface_move (mv_resize->moveresize_surface, x, y);
+      gdk_broadway_surface_move (mv_resize->moveresize_surface, x, y);
     }
 }
 
@@ -1311,7 +1392,8 @@ gdk_broadway_surface_class_init (GdkBroadwaySurfaceClass *klass)
   impl_class->raise = gdk_broadway_surface_raise;
   impl_class->lower = gdk_broadway_surface_lower;
   impl_class->restack_toplevel = gdk_broadway_surface_restack_toplevel;
-  impl_class->move_resize = gdk_broadway_surface_move_resize;
+  impl_class->toplevel_resize = gdk_broadway_surface_toplevel_resize;
+  impl_class->move_to_rect = gdk_broadway_surface_move_to_rect;
   impl_class->get_geometry = gdk_broadway_surface_get_geometry;
   impl_class->get_root_coords = gdk_broadway_surface_get_root_coords;
   impl_class->get_device_state = gdk_broadway_surface_get_device_state;

gdk/gdkcontentformats.c

@@ -234,7 +234,7 @@ gdk_content_formats_unref (GdkContentFormats *formats)
  * This is meant for debugging and logging.
  *
  * The form of the representation may change at any time and is
- * not guranteed to stay identical.
+ * not guaranteed to stay identical.
  **/
 void
 gdk_content_formats_print (GdkContentFormats *formats,

gdk/gdkevents.c

@@ -1312,7 +1312,7 @@ gdk_event_get_scroll_deltas (const GdkEvent *event,
  * stop scroll event is the signal that a widget may trigger kinetic
  * scrolling based on the current velocity.
  *
- * Stop scroll events always have a a delta of 0/0.
+ * Stop scroll events always have a delta of 0/0.
  *
  * Returns: %TRUE if the event is a scroll stop event
  */

gdk/gdkframeclock.c

@@ -97,10 +97,14 @@ struct _GdkFrameClockPrivate
   gint n_timings;
   gint current;
   GdkFrameTimings *timings[FRAME_HISTORY_MAX_LENGTH];
+  gint n_freeze_inhibitors;
 };
 
 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkFrameClock, gdk_frame_clock, G_TYPE_OBJECT)
 
+static void
+_gdk_frame_clock_freeze (GdkFrameClock *clock);
+
 static void
 gdk_frame_clock_finalize (GObject *object)
 {
@@ -114,12 +118,21 @@ gdk_frame_clock_finalize (GObject *object)
   G_OBJECT_CLASS (gdk_frame_clock_parent_class)->finalize (object);
 }
 
+static void
+gdk_frame_clock_constructed (GObject *object)
+{
+  G_OBJECT_CLASS (gdk_frame_clock_parent_class)->constructed (object);
+
+  _gdk_frame_clock_freeze (GDK_FRAME_CLOCK (object));
+}
+
 static void
 gdk_frame_clock_class_init (GdkFrameClockClass *klass)
 {
   GObjectClass *gobject_class = (GObjectClass*) klass;
 
   gobject_class->finalize     = gdk_frame_clock_finalize;
+  gobject_class->constructed  = gdk_frame_clock_constructed;
 
   /**
    * GdkFrameClock::flush-events:
@@ -335,7 +348,7 @@ gdk_frame_clock_end_updating (GdkFrameClock *frame_clock)
   GDK_FRAME_CLOCK_GET_CLASS (frame_clock)->end_updating (frame_clock);
 }
 
-void
+static void
 _gdk_frame_clock_freeze (GdkFrameClock *clock)
 {
   g_return_if_fail (GDK_IS_FRAME_CLOCK (clock));
@@ -344,7 +357,7 @@ _gdk_frame_clock_freeze (GdkFrameClock *clock)
 }
 
 
-void
+static void
 _gdk_frame_clock_thaw (GdkFrameClock *clock)
 {
   g_return_if_fail (GDK_IS_FRAME_CLOCK (clock));
@@ -352,6 +365,35 @@ _gdk_frame_clock_thaw (GdkFrameClock *clock)
   GDK_FRAME_CLOCK_GET_CLASS (clock)->thaw (clock);
 }
 
+void
+_gdk_frame_clock_inhibit_freeze (GdkFrameClock *clock)
+{
+  GdkFrameClockPrivate *priv;
+
+  g_return_if_fail (GDK_IS_FRAME_CLOCK (clock));
+
+  priv = clock->priv;
+
+  priv->n_freeze_inhibitors++;
+  if (priv->n_freeze_inhibitors == 1)
+    _gdk_frame_clock_thaw (clock);
+}
+
+
+void
+_gdk_frame_clock_uninhibit_freeze (GdkFrameClock *clock)
+{
+  GdkFrameClockPrivate *priv;
+
+  g_return_if_fail (GDK_IS_FRAME_CLOCK (clock));
+
+  priv = clock->priv;
+
+  priv->n_freeze_inhibitors--;
+  if (priv->n_freeze_inhibitors == 0)
+    _gdk_frame_clock_freeze (clock);
+}
+
 /**
  * gdk_frame_clock_get_frame_counter:
  * @frame_clock: a #GdkFrameClock

gdk/gdkframeclockprivate.h

@@ -105,8 +105,8 @@ struct _GdkFrameTimings
   guint slept_before : 1;
 };
 
-void _gdk_frame_clock_freeze (GdkFrameClock *clock);
-void _gdk_frame_clock_thaw   (GdkFrameClock *clock);
+void _gdk_frame_clock_inhibit_freeze (GdkFrameClock *clock);
+void _gdk_frame_clock_uninhibit_freeze (GdkFrameClock *clock);
 
 void _gdk_frame_clock_begin_frame         (GdkFrameClock   *clock);
 void _gdk_frame_clock_debug_print_timings (GdkFrameClock   *clock,

gdk/gdkglcontext.c

@@ -770,7 +770,7 @@ gdk_gl_context_set_is_legacy (GdkGLContext *context,
  * @use_es: whether the context should use OpenGL ES instead of OpenGL,
  *   or -1 to allow auto-detection
  *
- * Requests that GDK create a OpenGL ES context instead of an OpenGL one,
+ * Requests that GDK create an OpenGL ES context instead of an OpenGL one,
  * if the platform and windowing system allows it.
  *
  * The @context must not have been realized.

gdk/gdkinternals.h

@@ -264,16 +264,6 @@ void gdk_surface_get_geometry (GdkSurface *surface,
                                gint       *width,
                                gint       *height);
 
-void gdk_surface_move         (GdkSurface *surface,
-                               gint           x,
-                               gint           y);
-
-void gdk_surface_move_resize  (GdkSurface     *surface,
-                               gint           x,
-                               gint           y,
-                               gint           width,
-                               gint           height);
-
 GdkGLContext *gdk_surface_get_shared_data_gl_context (GdkSurface *surface);
 
 G_END_DECLS

gdk/gdkmonitor.c

@@ -49,6 +49,7 @@ enum {
   PROP_DISPLAY,
   PROP_MANUFACTURER,
   PROP_MODEL,
+  PROP_CONNECTOR,
   PROP_SCALE_FACTOR,
   PROP_GEOMETRY,
   PROP_WORKAREA,
@@ -100,6 +101,10 @@ gdk_monitor_get_property (GObject    *object,
       g_value_set_string (value, monitor->model);
       break;
 
+    case PROP_CONNECTOR:
+      g_value_set_string (value, monitor->connector);
+      break;
+
     case PROP_SCALE_FACTOR:
       g_value_set_int (value, monitor->scale_factor);
       break;
@@ -165,6 +170,7 @@ gdk_monitor_finalize (GObject *object)
 {
   GdkMonitor *monitor = GDK_MONITOR (object);
 
+  g_free (monitor->connector);
   g_free (monitor->manufacturer);
   g_free (monitor->model);
 
@@ -198,6 +204,12 @@ gdk_monitor_class_init (GdkMonitorClass *class)
                          "The model name",
                          NULL,
                          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+  props[PROP_CONNECTOR] =
+    g_param_spec_string ("connector",
+                         "Connector",
+                         "The connector name",
+                         NULL,
+                         G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
   props[PROP_SCALE_FACTOR] =
     g_param_spec_int ("scale-factor",
                       "Scale factor",
@@ -369,11 +381,32 @@ gdk_monitor_get_height_mm (GdkMonitor *monitor)
   return monitor->height_mm;
 }
 
+/**
+ * gdk_monitor_get_connector:
+ * @monitor: a #GdkMonitor
+ *
+ * Gets the name of the monitor's connector, if available.
+ *
+ * Returns: (transfer none) (nullable): the name of the connector
+ */
+const char *
+gdk_monitor_get_connector (GdkMonitor *monitor)
+{
+  g_return_val_if_fail (GDK_IS_MONITOR (monitor), NULL);
+
+  return monitor->connector;
+}
+
 /**
  * gdk_monitor_get_manufacturer:
  * @monitor: a #GdkMonitor
  *
- * Gets the name of the monitor's manufacturer, if available.
+ * Gets the name or PNP ID of the monitor's manufacturer, if available.
+ *
+ * Note that this value might also vary depending on actual
+ * display backend.
+ *
+ * PNP ID registry is located at https://uefi.org/pnp_id_list
  *
  * Returns: (transfer none) (nullable): the name of the manufacturer, or %NULL
  */
@@ -504,6 +537,16 @@ gdk_monitor_set_model (GdkMonitor *monitor,
   g_object_notify (G_OBJECT (monitor), "model");
 }
 
+void
+gdk_monitor_set_connector (GdkMonitor *monitor,
+                           const char *connector)
+{
+  g_free (monitor->connector);
+  monitor->connector = g_strdup (connector);
+
+  g_object_notify (G_OBJECT (monitor), "connector");
+}
+
 void
 gdk_monitor_set_position (GdkMonitor *monitor,
                           int         x,

gdk/gdkmonitor.h

@@ -80,6 +80,8 @@ const char *      gdk_monitor_get_manufacturer    (GdkMonitor   *monitor);
 GDK_AVAILABLE_IN_ALL
 const char *      gdk_monitor_get_model           (GdkMonitor   *monitor);
 GDK_AVAILABLE_IN_ALL
+const char *      gdk_monitor_get_connector       (GdkMonitor   *monitor);
+GDK_AVAILABLE_IN_ALL
 int               gdk_monitor_get_scale_factor    (GdkMonitor   *monitor);
 GDK_AVAILABLE_IN_ALL
 int               gdk_monitor_get_refresh_rate    (GdkMonitor   *monitor);

gdk/gdkmonitorprivate.h

@@ -36,6 +36,7 @@ struct _GdkMonitor {
   GdkDisplay *display;
   char *manufacturer;
   char *model;
+  char *connector;
   GdkRectangle geometry;
   int width_mm;
   int height_mm;
@@ -58,6 +59,8 @@ void            gdk_monitor_set_manufacturer    (GdkMonitor *monitor,
                                                  const char *manufacturer);
 void            gdk_monitor_set_model           (GdkMonitor *monitor,
                                                  const char *model);
+void            gdk_monitor_set_connector       (GdkMonitor *monitor,
+                                                 const char *connector);
 void            gdk_monitor_set_position        (GdkMonitor *monitor,
                                                  int         x,
                                                  int         y);