Show the default app for a content type only if recommended

The default application for a content type is selected depending on
whether it matches the given content type or any of its sub-classes.
This means that we might end up showing a text editor for the
`text/calendar` MIME type because it matches the `text/*` super-class.
The recommended applications, on the other hand, match the exact content
type.

Fixes: #377

.gitlab-ci.yml

@@ -1,7 +1,7 @@
 stages:
   - build
   - flatpak
-  - deploy
+#  - deploy
 
 .cache-paths: &cache-paths
   paths:
@@ -13,7 +13,7 @@ stages:
     - subprojects/pango/
 
 fedora-x86_64:
-  image: registry.gitlab.gnome.org/gnome/gtk/master:v6
+  image: registry.gitlab.gnome.org/gnome/gtk/master:v7
   stage: build
   script:
     - bash -x ./.gitlab-ci/test-docker.sh
@@ -40,6 +40,7 @@ fedora-x86_64:
   script:
     - C:\msys64\usr\bin\pacman --noconfirm -Syyuu
     - C:\msys64\usr\bin\bash -lc "bash -x ./.gitlab-ci/test-msys2.sh"
+  allow_failure: true
   cache:
     key: "%CI_JOB_NAME%"
     <<: *cache-paths
@@ -101,20 +102,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

.gitlab-ci/Dockerfile

@@ -1,7 +1,6 @@
-FROM fedora:30
+FROM fedora:31
 
 RUN dnf -y install \
-    hicolor-icon-theme \
     adwaita-icon-theme \
     atk-devel \
     at-spi2-atk-devel \
@@ -14,6 +13,7 @@ RUN dnf -y install \
     dbus-daemon \
     dejavu-sans-mono-fonts \
     desktop-file-utils \
+    diffutils \
     elfutils-libelf-devel \
     fribidi-devel \
     gcc \
@@ -32,6 +32,7 @@ RUN dnf -y install \
     gstreamer1-plugins-bad-free-devel \
     gstreamer1-plugins-base-devel \
     gtk-doc \
+    hicolor-icon-theme \
     iso-codes \
     itstool \
     json-glib-devel \

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

@@ -149,11 +149,11 @@ ul.images li {
   <article>
     <section>
       <div class="summary">
-        <h3>Summary</h3>
+        <h3><a name="summary">Summary</a></h3>
         <ul>
           <li><strong>Total units:</strong> {{ report.total_units }}</li>
-          <li><strong>Passed:</strong> {{ report.total_successes }}</li>
-          <li><strong>Failed:</strong> {{ report.total_failures }}</li>
+          <li><strong>Passed:</strong> <a href="#passed">{{ report.total_successes }}</a></li>
+          <li><strong>Failed:</strong> <a href="#failures">{{ report.total_failures }}</a></li>
         </ul>
       </div>
     </section>
@@ -161,7 +161,7 @@ ul.images li {
     {% for suite_result in report.results_list %}
     <section>
       <div class="result">
-        <h3>Suite: {{ suite_result.suite_name }}</h3>
+        <h3><a name="results">Suite: {{ suite_result.suite_name }}</a></h3>
         <ul>
           <li><strong>Units:</strong> {{ suite_result.n_units }}</li>
           <li><strong>Passed:</strong> {{ suite_result.n_successes }}</li>
@@ -169,7 +169,7 @@ ul.images li {
         </ul>
 
         <div class="successes">
-          <h4>Passed</h4>
+          <h4><a name="passed">Passed</a></h4>
           <ul class="passed">
             {% for success in suite_result.successes if success.result == 'OK' %}
             <li>{{ success.name }} - result: <span class="result pass">{{ success.result }}</li>
@@ -178,7 +178,7 @@ ul.images li {
             {% endfor %}
           </ul>
 
-          <h4>Skipped</h4>
+          <h4><a name="skipped">Skipped</a></h4>
           <ul>
             {% for success in suite_result.successes if success.result == 'SKIP' %}
             <li>{{ success.name }} - result: <span class="result skip">{{ success.result }}</li>
@@ -187,10 +187,10 @@ ul.images li {
             {% endfor %}
           </ul>
 
-          <h4>Expected failures</h4>
+          <h4><a name="expected-fail">Expected failures</a></h4>
           <ul>
           {% for success in suite_result.successes if success.result == 'EXPECTEDFAIL' %}
-            <li>{{ success.name }} - result: <span class="result xfail">{{ success.result }}</span><br/>
+            <li><a name="{{ success.name }}">{{ success.name }}</a> - result: <span class="result xfail">{{ success.result }}</span><br/>
             {% if success.stdout %}
               Output: <pre>{{ success.stdout }}</pre>
             {% endif %}
@@ -209,10 +209,10 @@ ul.images li {
         </div>
 
         <div class="failures">
-          <h4>Failed</h4>
+          <h4><a name="failed">Failed</a></h4>
           <ul class="failed">
             {% for failure in suite_result.failures if failure.result == 'FAIL' %}
-            <li>{{ failure.name }} - result: <span class="result fail">{{ failure.result }}</span><br/>
+            <li><a name="{{ failure.name }}">{{ failure.name }}</a> - result: <span class="result fail">{{ failure.result }}</span><br/>
               {% if failure.stdout %}
               Output: <pre>{{ failure.stdout }}</pre>
               {% endif %}
@@ -229,10 +229,10 @@ ul.images li {
             {% endfor %}
           </ul>
 
-          <h4>Timed out</h4>
+          <h4><a name="timed-out">Timed out</a></h4>
           <ul class="failed">
             {% for failure in suite_result.failures if failure.result == 'TIMEOUT' %}
-            <li>{{ failure.name }} - result: <span class="result fail">{{ failure.result }}</span><br/>
+            <li><a name="{{ failure.name }}">{{ failure.name }}</a> - result: <span class="result fail">{{ failure.result }}</span><br/>
               {% if failure.stdout %}
               Output: <pre>{{ failure.stdout }}</pre>
               {% endif %}

.gitlab-ci/run-docker.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-TAG="registry.gitlab.gnome.org/gnome/gtk/master:v6"
+TAG="registry.gitlab.gnome.org/gnome/gtk/master:v7"
 
 sudo docker build --build-arg HOST_USER_ID="$UID" --tag "${TAG}" \
     --file "Dockerfile" .

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/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

@@ -44,20 +44,21 @@ simple_grid_class_init (SimpleGridClass *klass)
 
 /* Layout:
  *
- *   +-----------------------------+
- *   | +-----------+ +-----------+ |
- *   | |  Child 1  | |  Child 2  | |
- *   | +-----------+ +-----------+ |
- *   | +-------------------------+ |
- *   | |         Child 3         | |
- *   | +-------------------------+ |
- *   +-----------------------------+
+ *   +-------------------------------------+
+ *   | +-----------++-------++-----------+ |
+ *   | |  Child 1  || Space ||  Child 2  | |
+ *   | +-----------++-------++-----------+ |
+ *   | +---------------------------------+ |
+ *   | |             Child 3             | |
+ *   | +---------------------------------+ |
+ *   +-------------------------------------+
  *
  * Constraints:
  *
  *   super.start = child1.start - 8
  *   child1.width = child2.width
- *   child1.end = child2.start - 12
+ *   child1.end = space.start
+ *   space.end = child2.start
  *   child2.end = super.end - 8
  *   super.start = child3.start - 8
  *   child3.end = super.end - 8
@@ -69,6 +70,12 @@ simple_grid_class_init (SimpleGridClass *klass)
  *   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,
@@ -77,9 +84,11 @@ build_constraints (SimpleGrid          *self,
   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,

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

@@ -104,6 +104,9 @@
     <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>
@@ -152,6 +155,7 @@
     <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>
@@ -163,8 +167,8 @@
     <file>drawingarea.c</file>
     <file>dnd.c</file>
     <file>editable_cells.c</file>
-    <file>entry_buffer.c</file>
     <file>entry_completion.c</file>
+    <file>entry_undo.c</file>
     <file>expander.c</file>
     <file>filtermodel.c</file>
     <file>fishbowl.c</file>
@@ -173,10 +177,12 @@
     <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>
@@ -214,6 +220,7 @@
     <file>spinner.c</file>
     <file>tabs.c</file>
     <file>tagged_entry.c</file>
+    <file>textundo.c</file>
     <file>textview.c</file>
     <file>textscroll.c</file>
     <file>theming_style_classes.c</file>
@@ -280,6 +287,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/entry_undo.c

@@ -1,28 +1,29 @@
-/* Entry/Entry Buffer
+/* Entry/Entry Undo
  *
- * GtkEntryBuffer provides the text content in a GtkEntry.
- * Applications can provide their own buffer implementation,
- * e.g. to provide secure handling for passwords in memory.
+ * GtkEntry can provide basic Undo/Redo support using standard keyboard
+ * accelerators such as Primary+z to undo and Primary+Shift+z to redo.
+ * Additionally, Primary+y can be used to redo.
+ *
+ * Use gtk_entry_set_enable_undo() to enable undo/redo support.
  */
 
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 
 GtkWidget *
-do_entry_buffer (GtkWidget *do_widget)
+do_entry_undo (GtkWidget *do_widget)
 {
   static GtkWidget *window = NULL;
   GtkWidget *vbox;
   GtkWidget *label;
   GtkWidget *entry;
-  GtkEntryBuffer *buffer;
 
   if (!window)
     {
       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), "Entry Buffer");
+      gtk_window_set_title (GTK_WINDOW (window), "Entry Undo");
       gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
       g_signal_connect (window, "destroy",
                         G_CALLBACK (gtk_widget_destroyed), &window);
@@ -33,22 +34,13 @@ do_entry_buffer (GtkWidget *do_widget)
 
       label = gtk_label_new (NULL);
       gtk_label_set_markup (GTK_LABEL (label),
-                            "Entries share a buffer. Typing in one is reflected in the other.");
+                            "Use Primary+z or Primary+Shift+z to undo or redo changes");
       gtk_container_add (GTK_CONTAINER (vbox), label);
 
-      /* Create a buffer */
-      buffer = gtk_entry_buffer_new (NULL, 0);
-
-      /* Create our first entry */
-      entry = gtk_entry_new_with_buffer (buffer);
+      /* Create our entry */
+      entry = gtk_entry_new ();
+      gtk_editable_set_enable_undo (GTK_EDITABLE (entry), TRUE);
       gtk_container_add (GTK_CONTAINER (vbox), entry);
-
-      /* Create the second entry */
-      entry = gtk_entry_new_with_buffer (buffer);
-      gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
-      gtk_container_add (GTK_CONTAINER (vbox), entry);
-
-      g_object_unref (buffer);
     }
 
   if (!gtk_widget_get_visible (window))

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/font_features.c

@@ -15,10 +15,6 @@
 #include <pango/pangofc-font.h>
 #include <hb.h>
 #include <hb-ot.h>
-#include <hb-ft.h>
-#include <freetype/ftmm.h>
-#include <freetype/ftsnames.h>
-#include <freetype/ttnameid.h>
 #include <glib/gi18n.h>
 
 #include "open-type-layout.h"
@@ -484,7 +480,6 @@ update_script_combo (void)
   GtkListStore *store;
   hb_font_t *hb_font;
   gint i, j, k;
-  FT_Face ft_face;
   PangoFont *pango_font;
   GHashTable *tags;
   GHashTableIter iter;
@@ -505,8 +500,7 @@ update_script_combo (void)
   store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
 
   pango_font = get_pango_font ();
-  ft_face = pango_fc_font_lock_face (PANGO_FC_FONT (pango_font)),
-  hb_font = hb_ft_font_create (ft_face, NULL);
+  hb_font = pango_font_get_hb_font (pango_font);
 
   tags = g_hash_table_new_full (tag_pair_hash, tag_pair_equal, g_free, NULL);
 
@@ -545,11 +539,8 @@ update_script_combo (void)
                 }
             }
         }
-
-      hb_face_destroy (hb_face);
     }
 
-  pango_fc_font_unlock_face (PANGO_FC_FONT (pango_font));
   g_object_unref (pango_font);
 
   g_hash_table_iter_init (&iter, tags);
@@ -607,7 +598,6 @@ update_features (void)
   GtkTreeIter iter;
   guint script_index, lang_index;
   PangoFont *pango_font;
-  FT_Face ft_face;
   hb_font_t *hb_font;
   GList *l;
 
@@ -632,8 +622,7 @@ update_features (void)
                       -1);
 
   pango_font = get_pango_font ();
-  ft_face = pango_fc_font_lock_face (PANGO_FC_FONT (pango_font)),
-  hb_font = hb_ft_font_create (ft_face, NULL);
+  hb_font = pango_font_get_hb_font (pango_font);
 
   if (hb_font)
     {
@@ -715,11 +704,8 @@ update_features (void)
 
           g_free (feat);
         }
-
-      hb_face_destroy (hb_face);
     }
 
-  pango_fc_font_unlock_face (PANGO_FC_FONT (pango_font));
   g_object_unref (pango_font);
 }
 
@@ -800,24 +786,29 @@ axes_equal (gconstpointer v1, gconstpointer v2)
 }
 
 static void
-add_axis (FT_Var_Axis *ax, FT_Fixed value, int i)
+add_axis (hb_face_t             *hb_face,
+          hb_ot_var_axis_info_t *ax,
+          float                  value,
+          int                    i)
 {
   GtkWidget *axis_label;
   GtkWidget *axis_entry;
   GtkWidget *axis_scale;
   GtkAdjustment *adjustment;
   Axis *axis;
+  char name[20];
+  unsigned int name_len = 20;
 
-  axis_label = gtk_label_new (ax->name);
+  hb_ot_name_get_utf8 (hb_face, ax->name_id, HB_LANGUAGE_INVALID, &name_len, name);
+
+  axis_label = gtk_label_new (name);
   gtk_widget_set_halign (axis_label, GTK_ALIGN_START);
   gtk_widget_set_valign (axis_label, GTK_ALIGN_BASELINE);
   gtk_grid_attach (GTK_GRID (variations_grid), axis_label, 0, i, 1, 1);
-  adjustment = gtk_adjustment_new ((double)FixedToFloat(value),
-                                   (double)FixedToFloat(ax->minimum),
-                                   (double)FixedToFloat(ax->maximum),
+  adjustment = gtk_adjustment_new (value, ax->min_value, ax->max_value,
                                    1.0, 10.0, 0.0);
   axis_scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
-  gtk_scale_add_mark (GTK_SCALE (axis_scale), (double)FixedToFloat(ax->def), GTK_POS_TOP, NULL);
+  gtk_scale_add_mark (GTK_SCALE (axis_scale), ax->default_value, GTK_POS_TOP, NULL);
   gtk_widget_set_valign (axis_scale, GTK_ALIGN_BASELINE);
   gtk_widget_set_hexpand (axis_scale, TRUE);
   gtk_widget_set_size_request (axis_scale, 100, -1);
@@ -842,9 +833,7 @@ add_axis (FT_Var_Axis *ax, FT_Fixed value, int i)
 
 typedef struct {
   char *name;
-  int n_axes;
-  guint32 *axes;
-  float   *coords;
+  unsigned int index;
 } Instance;
 
 static guint
@@ -870,559 +859,32 @@ free_instance (gpointer data)
   Instance *instance = data;
 
   g_free (instance->name);
-  g_free (instance->axes);
-  g_free (instance->coords);
   g_free (instance);
 }
 
 static GHashTable *instances;
 
-typedef struct {
-    const FT_UShort     platform_id;
-    const FT_UShort     encoding_id;
-    const char  fromcode[12];
-} FtEncoding;
-
-#define TT_ENCODING_DONT_CARE   0xffff
-
-static const FtEncoding   ftEncoding[] = {
- {  TT_PLATFORM_APPLE_UNICODE,  TT_ENCODING_DONT_CARE,  "UTF-16BE" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_ID_ROMAN,        "MACINTOSH" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_ID_JAPANESE,     "SJIS" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_SYMBOL_CS,     "UTF-16BE" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_UNICODE_CS,    "UTF-16BE" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_SJIS,          "SJIS-WIN" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_GB2312,        "GB2312" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_BIG_5,         "BIG-5" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_WANSUNG,       "Wansung" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_JOHAB,         "Johab" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_ID_UCS_4,         "UTF-16BE" },
- {  TT_PLATFORM_ISO,            TT_ISO_ID_7BIT_ASCII,   "ASCII" },
- {  TT_PLATFORM_ISO,            TT_ISO_ID_10646,        "UTF-16BE" },
- {  TT_PLATFORM_ISO,            TT_ISO_ID_8859_1,       "ISO-8859-1" },
-};
-
-typedef struct {
-    const FT_UShort     platform_id;
-    const FT_UShort     language_id;
-    const char  lang[8];
-} FtLanguage;
-
-#define TT_LANGUAGE_DONT_CARE   0xffff
-
-static const FtLanguage   ftLanguage[] = {
- {  TT_PLATFORM_APPLE_UNICODE,  TT_LANGUAGE_DONT_CARE,              "" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ENGLISH,              "en" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FRENCH,               "fr" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GERMAN,               "de" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ITALIAN,              "it" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_DUTCH,                "nl" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SWEDISH,              "sv" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SPANISH,              "es" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_DANISH,               "da" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_PORTUGUESE,           "pt" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_NORWEGIAN,            "no" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_HEBREW,               "he" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_JAPANESE,             "ja" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ARABIC,               "ar" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FINNISH,              "fi" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GREEK,                "el" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ICELANDIC,            "is" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALTESE,              "mt" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TURKISH,              "tr" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CROATIAN,             "hr" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CHINESE_TRADITIONAL,  "zh-tw" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_URDU,                 "ur" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_HINDI,                "hi" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_THAI,                 "th" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KOREAN,               "ko" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LITHUANIAN,           "lt" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_POLISH,               "pl" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_HUNGARIAN,            "hu" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ESTONIAN,             "et" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LETTISH,              "lv" },
-/* {  TT_PLATFORM_MACINTOSH,    TT_MAC_LANGID_SAAMISK, ??? */
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FAEROESE,             "fo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FARSI,                "fa" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_RUSSIAN,              "ru" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CHINESE_SIMPLIFIED,   "zh-cn" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_FLEMISH,              "nl" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_IRISH,                "ga" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ALBANIAN,             "sq" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ROMANIAN,             "ro" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CZECH,                "cs" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SLOVAK,               "sk" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SLOVENIAN,            "sl" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_YIDDISH,              "yi" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SERBIAN,              "sr" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MACEDONIAN,           "mk" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BULGARIAN,            "bg" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_UKRAINIAN,            "uk" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BYELORUSSIAN,         "be" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_UZBEK,                "uz" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KAZAKH,               "kk" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI,          "az" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT, "az" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT,    "ar" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ARMENIAN,             "hy" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GEORGIAN,             "ka" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MOLDAVIAN,            "mo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KIRGHIZ,              "ky" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TAJIKI,               "tg" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TURKMEN,              "tk" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MONGOLIAN,            "mo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT,"mo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT, "mo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_PASHTO,               "ps" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KURDISH,              "ku" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KASHMIRI,             "ks" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SINDHI,               "sd" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TIBETAN,              "bo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_NEPALI,               "ne" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SANSKRIT,             "sa" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MARATHI,              "mr" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BENGALI,              "bn" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ASSAMESE,             "as" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GUJARATI,             "gu" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_PUNJABI,              "pa" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ORIYA,                "or" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAYALAM,            "ml" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KANNADA,              "kn" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TAMIL,                "ta" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TELUGU,               "te" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SINHALESE,            "si" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BURMESE,              "my" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_KHMER,                "km" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LAO,                  "lo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_VIETNAMESE,           "vi" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_INDONESIAN,           "id" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TAGALOG,              "tl" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAY_ROMAN_SCRIPT,   "ms" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAY_ARABIC_SCRIPT,  "ms" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AMHARIC,              "am" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TIGRINYA,             "ti" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GALLA,                "om" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SOMALI,               "so" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SWAHILI,              "sw" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_RUANDA,               "rw" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_RUNDI,                "rn" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CHEWA,                "ny" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MALAGASY,             "mg" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_ESPERANTO,            "eo" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_WELSH,                "cy" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BASQUE,               "eu" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_CATALAN,              "ca" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_LATIN,                "la" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_QUECHUA,              "qu" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GUARANI,              "gn" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AYMARA,               "ay" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TATAR,                "tt" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_UIGHUR,               "ug" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_DZONGKHA,             "dz" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_JAVANESE,             "jw" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SUNDANESE,            "su" },
-
-#if 0  /* these seem to be errors that have been dropped */
-
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SCOTTISH_GAELIC },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_IRISH_GAELIC },
-
-#endif
-
-  /* The following codes are new as of 2000-03-10 */
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GALICIAN,             "gl" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AFRIKAANS,            "af" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_BRETON,               "br" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_INUKTITUT,            "iu" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_SCOTTISH_GAELIC,      "gd" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_MANX_GAELIC,          "gv" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_IRISH_GAELIC,         "ga" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_TONGAN,               "to" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GREEK_POLYTONIC,      "el" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_GREELANDIC,           "ik" },
- {  TT_PLATFORM_MACINTOSH,      TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT,"az" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_SAUDI_ARABIA,       "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_IRAQ,               "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_EGYPT,              "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_LIBYA,              "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_ALGERIA,            "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_MOROCCO,            "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_TUNISIA,            "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_OMAN,               "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_YEMEN,              "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_SYRIA,              "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_JORDAN,             "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_LEBANON,            "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_KUWAIT,             "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_UAE,                "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_BAHRAIN,            "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_QATAR,              "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BULGARIAN_BULGARIA,        "bg" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CATALAN_SPAIN,             "ca" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_TAIWAN,            "zh-tw" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_PRC,               "zh-cn" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_HONG_KONG,         "zh-hk" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_SINGAPORE,         "zh-sg" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_MACAU,             "zh-mo" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CZECH_CZECH_REPUBLIC,      "cs" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DANISH_DENMARK,            "da" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_GERMANY,            "de" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_SWITZERLAND,        "de" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_AUSTRIA,            "de" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_LUXEMBOURG,         "de" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GERMAN_LIECHTENSTEI,       "de" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GREEK_GREECE,              "el" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_UNITED_STATES,     "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_UNITED_KINGDOM,    "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_AUSTRALIA,         "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_CANADA,            "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_NEW_ZEALAND,       "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_IRELAND,           "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_SOUTH_AFRICA,      "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_JAMAICA,           "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_CARIBBEAN,         "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_BELIZE,            "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_TRINIDAD,          "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_ZIMBABWE,          "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_PHILIPPINES,       "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT,"es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_MEXICO,            "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT,"es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_GUATEMALA,         "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_COSTA_RICA,        "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PANAMA,            "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC,"es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_VENEZUELA,         "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_COLOMBIA,          "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PERU,              "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_ARGENTINA,         "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_ECUADOR,           "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_CHILE,             "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_URUGUAY,           "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PARAGUAY,          "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_BOLIVIA,           "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_EL_SALVADOR,       "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_HONDURAS,          "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_NICARAGUA,         "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_PUERTO_RICO,       "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FINNISH_FINLAND,           "fi" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_FRANCE,             "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_BELGIUM,            "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_CANADA,             "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_SWITZERLAND,        "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_LUXEMBOURG,         "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_MONACO,             "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HEBREW_ISRAEL,             "he" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HUNGARIAN_HUNGARY,         "hu" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ICELANDIC_ICELAND,         "is" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ITALIAN_ITALY,             "it" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ITALIAN_SWITZERLAND,       "it" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_JAPANESE_JAPAN,            "ja" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA,"ko" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KOREAN_JOHAB_KOREA,        "ko" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DUTCH_NETHERLANDS,         "nl" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DUTCH_BELGIUM,             "nl" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL,   "no" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK,  "nn" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_POLISH_POLAND,             "pl" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PORTUGUESE_BRAZIL,         "pt" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PORTUGUESE_PORTUGAL,       "pt" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND,"rm" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ROMANIAN_ROMANIA,          "ro" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MOLDAVIAN_MOLDAVIA,        "mo" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_RUSSIAN_RUSSIA,            "ru" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_RUSSIAN_MOLDAVIA,          "ru" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CROATIAN_CROATIA,          "hr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SERBIAN_SERBIA_LATIN,      "sr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC,   "sr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SLOVAK_SLOVAKIA,           "sk" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ALBANIAN_ALBANIA,          "sq" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SWEDISH_SWEDEN,            "sv" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SWEDISH_FINLAND,           "sv" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_THAI_THAILAND,             "th" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TURKISH_TURKEY,            "tr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_URDU_PAKISTAN,             "ur" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_INDONESIAN_INDONESIA,      "id" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_UKRAINIAN_UKRAINE,         "uk" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BELARUSIAN_BELARUS,        "be" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SLOVENE_SLOVENIA,          "sl" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ESTONIAN_ESTONIA,          "et" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LATVIAN_LATVIA,            "lv" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LITHUANIAN_LITHUANIA,      "lt" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA,"lt" },
-
-#ifdef TT_MS_LANGID_MAORI_NEW_ZELAND
-    /* this seems to be an error that have been dropped */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MAORI_NEW_ZEALAND,         "mi" },
-#endif
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FARSI_IRAN,                "fa" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_VIETNAMESE_VIET_NAM,       "vi" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARMENIAN_ARMENIA,          "hy" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN,    "az" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC, "az" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BASQUE_SPAIN,              "eu" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SORBIAN_GERMANY,           "wen" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MACEDONIAN_MACEDONIA,      "mk" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SUTU_SOUTH_AFRICA,         "st" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TSONGA_SOUTH_AFRICA,       "ts" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TSWANA_SOUTH_AFRICA,       "tn" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_VENDA_SOUTH_AFRICA,        "ven" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_XHOSA_SOUTH_AFRICA,        "xh" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ZULU_SOUTH_AFRICA,         "zu" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA,    "af" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GEORGIAN_GEORGIA,          "ka" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS,   "fo" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HINDI_INDIA,               "hi" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALTESE_MALTA,             "mt" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SAAMI_LAPONIA,             "se" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM,"gd" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_IRISH_GAELIC_IRELAND,      "ga" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALAY_MALAYSIA,            "ms" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM,   "ms" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KAZAK_KAZAKSTAN,           "kk" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SWAHILI_KENYA,             "sw" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN,    "uz" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC, "uz" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TATAR_TATARSTAN,           "tt" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BENGALI_INDIA,             "bn" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PUNJABI_INDIA,             "pa" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GUJARATI_INDIA,            "gu" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ORIYA_INDIA,               "or" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAMIL_INDIA,               "ta" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TELUGU_INDIA,              "te" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KANNADA_INDIA,             "kn" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MALAYALAM_INDIA,           "ml" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ASSAMESE_INDIA,            "as" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MARATHI_INDIA,             "mr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SANSKRIT_INDIA,            "sa" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KONKANI_INDIA,             "kok" },
-
-  /* new as of 2001-01-01 */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ARABIC_GENERAL,            "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHINESE_GENERAL,           "zh" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_GENERAL,           "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_WEST_INDIES,        "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_REUNION,            "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_CONGO,              "fr" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_SENEGAL,            "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_CAMEROON,           "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_COTE_D_IVOIRE,      "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_MALI,               "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA,"bs" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_URDU_INDIA,                "ur" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAJIK_TAJIKISTAN,          "tg" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_YIDDISH_GERMANY,           "yi" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN,       "ky" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TURKMEN_TURKMENISTAN,      "tk" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MONGOLIAN_MONGOLIA,        "mn" },
-
-  /* the following seems to be inconsistent;
-     here is the current "official" way: */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIBETAN_BHUTAN,            "bo" },
-  /* and here is what is used by Passport SDK */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIBETAN_CHINA,             "bo" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DZONGHKA_BHUTAN,           "dz" },
-  /* end of inconsistency */
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_WELSH_WALES,               "cy" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KHMER_CAMBODIA,            "km" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LAO_LAOS,                  "lo" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BURMESE_MYANMAR,           "my" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GALICIAN_SPAIN,            "gl" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MANIPURI_INDIA,            "mni" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SINDHI_INDIA,              "sd" },
-  /* the following one is only encountered in Microsoft RTF specification */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KASHMIRI_PAKISTAN,         "ks" },
-  /* the following one is not in the Passport list, looks like an omission */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KASHMIRI_INDIA,            "ks" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NEPALI_NEPAL,              "ne" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_NEPALI_INDIA,              "ne" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRISIAN_NETHERLANDS,       "fy" },
-
-  /* new as of 2001-03-01 (from Office Xp) */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_HONG_KONG,         "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_INDIA,             "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_MALAYSIA,          "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_ENGLISH_SINGAPORE,         "en" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SYRIAC_SYRIA,              "syr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SINHALESE_SRI_LANKA,       "si" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_CHEROKEE_UNITED_STATES,    "chr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_INUKTITUT_CANADA,          "iu" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_AMHARIC_ETHIOPIA,          "am" },
-#if 0
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAMAZIGHT_MOROCCO },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN },
-#endif
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PASHTO_AFGHANISTAN,        "ps" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FILIPINO_PHILIPPINES,      "phi" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_DHIVEHI_MALDIVES,          "div" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_OROMO_ETHIOPIA,            "om" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIGRIGNA_ETHIOPIA,         "ti" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_TIGRIGNA_ERYTHREA,         "ti" },
-
-  /* New additions from Windows Xp/Passport SDK 2001-11-10. */
-
-  /* don't ask what this one means... It is commented out currently. */
-#if 0
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GREEK_GREECE2 },
-#endif
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_UNITED_STATES,     "es" },
-  /* The following two IDs blatantly violate MS specs by using a */
-  /* sublanguage >,.                                         */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SPANISH_LATIN_AMERICA,     "es" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_NORTH_AFRICA,       "fr" },
-
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_MOROCCO,            "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FRENCH_HAITI,              "fr" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_BENGALI_BANGLADESH,        "bn" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN,   "ar" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN,"mn" },
-#if 0
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_EDO_NIGERIA },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_FULFULDE_NIGERIA },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_IBIBIO_NIGERIA },
-#endif
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HAUSA_NIGERIA,             "ha" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_YORUBA_NIGERIA,            "yo" },
-  /* language codes from, to, are (still) unknown. */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_IGBO_NIGERIA,              "ibo" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_KANURI_NIGERIA,            "kau" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_GUARANI_PARAGUAY,          "gn" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_HAWAIIAN_UNITED_STATES,    "haw" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_LATIN,                     "la" },
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_SOMALI_SOMALIA,            "so" },
-#if 0
-  /* Note: Yi does not have a (proper) ISO 639-2 code, since it is mostly */
-  /*       not written (but OTOH the peculiar writing system is worth     */
-  /*       studying).                                                     */
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_YI_CHINA },
-#endif
- {  TT_PLATFORM_MICROSOFT,      TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES,"pap" },
-};
-
-static const char *
-FcSfntNameLanguage (FT_SfntName *sname)
-{
-    int i;
-    FT_UShort platform_id = sname->platform_id;
-    FT_UShort language_id = sname->language_id;
-
-    for (i = 0; i < G_N_ELEMENTS (ftLanguage); i++)
-        if (ftLanguage[i].platform_id == platform_id &&
-            (ftLanguage[i].language_id == TT_LANGUAGE_DONT_CARE ||
-             ftLanguage[i].language_id == language_id))
-        {
-            if (ftLanguage[i].lang[0] == '\0')
-              return NULL;
-            else
-              return ftLanguage[i].lang;
-        }
-    return NULL;
-}
-
-static char *
-FcSfntNameTranscode (FT_SfntName *name)
-{
-    int        i;
-    const char *fromcode;
-
-    for (i = 0; i < G_N_ELEMENTS (ftEncoding); i++)
-        if (ftEncoding[i].platform_id == name->platform_id &&
-            (ftEncoding[i].encoding_id == TT_ENCODING_DONT_CARE ||
-             ftEncoding[i].encoding_id == name->encoding_id))
-            break;
-    if (i == G_N_ELEMENTS (ftEncoding))
-        return  NULL;
-    fromcode = ftEncoding[i].fromcode;
-
-    return g_convert ((const char *)name->string, name->string_len, "UTF-8", fromcode, NULL, NULL, NULL);
-}
-
-static char *
-get_sfnt_name (FT_Face ft_face,
-               guint   nameid)
-{
-  guint count;
-  guint i, j;
-  const char * const *langs = g_get_language_names ();
-  char *res = NULL;
-  guint pos = G_MAXUINT;
-
-  count = FT_Get_Sfnt_Name_Count (ft_face);
-  for (i = 0; i < count; i++)
-    {
-      FT_SfntName name;
-      const char *lang;
-
-      if (FT_Get_Sfnt_Name (ft_face, i, &name) != 0)
-        continue;
-
-      if (name.name_id != nameid)
-        continue;
-
-      lang = FcSfntNameLanguage (&name);
-      for (j = 0; j < pos && langs[j]; j++)
-        {
-          if (strcmp (lang, langs[j]) == 0)
-            {
-              pos = j;
-              g_free (res);
-              res = FcSfntNameTranscode (&name);
-            }
-        }
-
-      if (pos == 0)
-        break;
-    }
-
-  return res;
-}
-
-static gboolean
-is_valid_subfamily_id (guint id)
-{
-  return id == 2 || id == 17 || (255 < id && id < 32768);
-}
-
 static void
-add_instance (FT_Face             ft_face,
-              FT_MM_Var          *ft_mm_var,
-              FT_Var_Named_Style *ns,
-              GtkWidget          *combo,
-              int                 pos)
+add_instance (hb_face_t    *face,
+              unsigned int  index,
+              GtkWidget    *combo,
+              int           pos)
 {
   Instance *instance;
-  int i;
+  hb_ot_name_id_t name_id;
+  char name[20];
+  unsigned int name_len = 20;
 
   instance = g_new0 (Instance, 1);
 
-  if (is_valid_subfamily_id (ns->strid))
-    instance->name = get_sfnt_name (ft_face, ns->strid);
-  if (!instance->name)
-    instance->name = g_strdup_printf ("Instance %d", pos);
+  name_id = hb_ot_var_named_instance_get_subfamily_name_id (face, index);
+  hb_ot_name_get_utf8 (face, name_id, HB_LANGUAGE_INVALID, &name_len, name);
+
+  instance->name = g_strdup_printf (name);
+  instance->index = index;
 
   g_hash_table_add (instances, instance);
   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), instance->name);
-
-  instance->n_axes = ft_mm_var->num_axis;
-  instance->axes = g_new (guint32, ft_mm_var->num_axis);
-  instance->coords = g_new (float, ft_mm_var->num_axis);
-
-  for (i = 0; i < ft_mm_var->num_axis; i++)
-    {
-      instance->axes[i] = ft_mm_var->axis[i].tag;
-      instance->coords[i] = FixedToFloat(ns->coords[i]);
-    }
 }
 
 static void
@@ -1439,6 +901,13 @@ instance_changed (GtkComboBox *combo)
   Instance *instance;
   Instance ikey;
   int i;
+  unsigned int coords_length;
+  float *coords = NULL;
+  hb_ot_var_axis_info_t *ai = NULL;
+  unsigned int n_axes;
+  PangoFont *pango_font = NULL;
+  hb_font_t *hb_font;
+  hb_face_t *hb_face;
 
   text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (combo));
   if (text[0] == '\0')
@@ -1452,17 +921,29 @@ instance_changed (GtkComboBox *combo)
       goto out;
     }
 
-  for (i = 0; i < instance->n_axes; i++)
+  pango_font = get_pango_font ();
+  hb_font = pango_font_get_hb_font (pango_font);
+  hb_face = hb_font_get_face (hb_font);
+
+  n_axes = hb_ot_var_get_axis_infos (hb_face, 0, NULL, NULL);
+  ai = g_new (hb_ot_var_axis_info_t, n_axes);
+  hb_ot_var_get_axis_infos (hb_face, 0, &n_axes, ai);
+
+  coords = g_new (float, n_axes);
+  hb_ot_var_named_instance_get_design_coords (hb_face,
+                                              instance->index,
+                                              &coords_length,
+                                              coords);
+
+  for (i = 0; i < n_axes; i++)
     {
       Axis *axis;
       Axis akey;
-      guint32 tag;
       gdouble value;
 
-      tag = instance->axes[i];
-      value = instance->coords[i];
+      value = coords[ai[i].axis_index];
 
-      akey.tag = tag;
+      akey.tag = ai[i].tag;
       axis = g_hash_table_lookup (axes, &akey);
       if (axis)
         {
@@ -1474,17 +955,31 @@ instance_changed (GtkComboBox *combo)
 
 out:
   g_free (text);
+  g_clear_object (&pango_font);
+  g_free (ai);
+  g_free (coords);
 }
 
 static gboolean
-matches_instance (FT_Var_Named_Style *instance,
-                  FT_Fixed           *coords,
-                  FT_UInt             num_coords)
+matches_instance (hb_face_t             *hb_face,
+                  unsigned int           index,
+                  unsigned int           n_axes,
+                  float                 *coords)
 {
-  FT_UInt i;
+  float *instance_coords;
+  unsigned int coords_length;
+  int i;
 
-  for (i = 0; i < num_coords; i++)
-    if (coords[i] != instance->coords[i])
+  instance_coords = g_new (float, n_axes);
+  coords_length = n_axes;
+
+  hb_ot_var_named_instance_get_design_coords (hb_face,
+                                              index,
+                                              &coords_length,
+                                              instance_coords);
+
+  for (i = 0; i < n_axes; i++)
+    if (instance_coords[i] != coords[i])
       return FALSE;
 
   return TRUE;
@@ -1515,14 +1010,31 @@ add_font_plane (int i)
     }
 }
 
+/* FIXME: This doesn't work if the font has an avar table */
+static float
+denorm_coord (hb_ot_var_axis_info_t *axis, int coord)
+{
+  float r = coord / 16384.0;
+
+  if (coord < 0)
+    return axis->default_value + r * (axis->default_value - axis->min_value);
+  else
+    return axis->default_value + r * (axis->max_value - axis->default_value);
+}
+
 static void
 update_font_variations (void)
 {
   GtkWidget *child, *next;
-  PangoFont *pango_font;
-  FT_Face ft_face;
-  FT_MM_Var *ft_mm_var;
-  FT_Error ret;
+  PangoFont *pango_font = NULL;
+  hb_font_t *hb_font;
+  hb_face_t *hb_face;
+  unsigned int n_axes;
+  hb_ot_var_axis_info_t *ai = NULL;
+  float *design_coords = NULL;
+  const int *coords;
+  unsigned int length;
+  int i;
 
   child = gtk_widget_get_first_child (variations_grid);
   while (child != NULL)
@@ -1538,62 +1050,63 @@ update_font_variations (void)
   g_hash_table_remove_all (instances);
 
   pango_font = get_pango_font ();
-  ft_face = pango_fc_font_lock_face (PANGO_FC_FONT (pango_font)),
+  hb_font = pango_font_get_hb_font (pango_font);
+  hb_face = hb_font_get_face (hb_font);
 
-  ret = FT_Get_MM_Var (ft_face, &ft_mm_var);
-  if (ret == 0)
+  n_axes = hb_ot_var_get_axis_infos (hb_face, 0, NULL, NULL);
+  if (n_axes == 0)
+    goto done;
+
+  ai = g_new0 (hb_ot_var_axis_info_t, n_axes);
+  design_coords = g_new (float, n_axes);
+
+  hb_ot_var_get_axis_infos (hb_face, 0, &n_axes, ai);
+  coords = hb_font_get_var_coords_normalized (hb_font, &length);
+  for (i = 0; i < length; i++)
+    design_coords[i] = denorm_coord (&ai[i], coords[i]);
+
+  if (hb_ot_var_get_named_instance_count (hb_face) > 0)
     {
-      unsigned int i;
-      FT_Fixed *coords;
+      GtkWidget *label;
+      GtkWidget *combo;
 
-      coords = g_new (FT_Fixed, ft_mm_var->num_axis);
-      ret = FT_Get_Var_Design_Coordinates (ft_face, ft_mm_var->num_axis, coords);
+      label = gtk_label_new ("Instance");
+      gtk_label_set_xalign (GTK_LABEL (label), 0);
+      gtk_widget_set_halign (label, GTK_ALIGN_START);
+      gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
+      gtk_grid_attach (GTK_GRID (variations_grid), label, 0, -1, 2, 1);
 
-      if (ft_mm_var->num_namedstyles > 0)
+      combo = gtk_combo_box_text_new ();
+      gtk_widget_set_valign (combo, GTK_ALIGN_BASELINE);
+
+      gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "");
+
+      for (i = 0; i < hb_ot_var_get_named_instance_count (hb_face); i++)
+        add_instance (hb_face, i, combo, i);
+
+      for (i = 0; i < hb_ot_var_get_named_instance_count (hb_face); i++)
         {
-           GtkWidget *label;
-           GtkWidget *combo;
-
-           label = gtk_label_new ("Instance");
-           gtk_label_set_xalign (GTK_LABEL (label), 0);
-           gtk_widget_set_halign (label, GTK_ALIGN_START);
-           gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
-           gtk_grid_attach (GTK_GRID (variations_grid), label, 0, -1, 2, 1);
-
-           combo = gtk_combo_box_text_new ();
-           gtk_widget_set_valign (combo, GTK_ALIGN_BASELINE);
-           g_signal_connect (combo, "changed", G_CALLBACK (instance_changed), NULL);
-           gtk_grid_attach (GTK_GRID (variations_grid), combo, 1, -1, 2, 1);
-
-           gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "");
-
-           for (i = 0; i < ft_mm_var->num_namedstyles; i++)
-             add_instance (ft_face, ft_mm_var, &ft_mm_var->namedstyle[i], combo, i);
-           for (i = 0; i < ft_mm_var->num_namedstyles; i++)
-             {
-               if (matches_instance (&ft_mm_var->namedstyle[i], coords, ft_mm_var->num_axis))
-                 {
-                   gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i + 1);
-                   break;
-                 }
-             }
-
-           instance_combo = combo;
+          if (matches_instance (hb_face, i, n_axes, design_coords))
+            {
+              gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i + 1);
+              break;
+            }
         }
 
-      if (ret == 0)
-        {
-          for (i = 0; i < ft_mm_var->num_axis; i++)
-            add_axis (&ft_mm_var->axis[i], coords[i], i);
+      gtk_grid_attach (GTK_GRID (variations_grid), combo, 1, -1, 2, 1);
+      g_signal_connect (combo, "changed", G_CALLBACK (instance_changed), NULL);
+      instance_combo = combo;
+   }
 
-          add_font_plane (ft_mm_var->num_axis);
-        }
-      g_free (coords);
-      free (ft_mm_var);
-    }
+  for (i = 0; i < n_axes; i++)
+    add_axis (hb_face, &ai[i], design_coords[i], i);
 
-  pango_fc_font_unlock_face (PANGO_FC_FONT (pango_font));
-  g_object_unref (pango_font);
+  add_font_plane (n_axes);
+
+done:
+  g_clear_object (&pango_font);
+  g_free (ai);
+  g_free (design_coords);
 }
 
 static void

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/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/hypertext.c

@@ -41,6 +41,7 @@ show_page (GtkTextBuffer *buffer,
 
   gtk_text_buffer_set_text (buffer, "", 0);
   gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
+  gtk_text_buffer_begin_irreversible_action (buffer);
   if (page == 1)
     {
       gtk_text_buffer_insert (buffer, &iter, "Some text to show that simple ", -1);
@@ -73,6 +74,7 @@ show_page (GtkTextBuffer *buffer,
                               "so that related items of information are connected.\n", -1);
       insert_link (buffer, &iter, "Go back", 1);
     }
+  gtk_text_buffer_end_irreversible_action (buffer);
 }
 
 /* Looks at all tags covering the position of iter in the text view,
@@ -258,6 +260,7 @@ do_hypertext (GtkWidget *do_widget)
       gtk_widget_add_controller (view, controller);
 
       buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+      gtk_text_buffer_set_enable_undo (buffer, TRUE);
 
       sw = gtk_scrolled_window_new (NULL, NULL);
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),

demos/gtk-demo/iconscroll.c

@@ -0,0 +1,234 @@
+/* Benchmark/Scrolling
+ *
+ * This demo scrolls a view with various content.
+ */
+
+#include <gtk/gtk.h>
+
+static guint tick_cb;
+static GtkAdjustment *hadjustment;
+static GtkAdjustment *vadjustment;
+static GtkWidget *window = NULL;
+static GtkWidget *scrolledwindow;
+static int selected;
+
+#define N_WIDGET_TYPES 4
+
+
+static int hincrement = 5;
+static int vincrement = 5;
+
+static gboolean
+scroll_cb (GtkWidget *widget,
+           GdkFrameClock *frame_clock,
+           gpointer data)
+{
+  double value;
+
+  value = gtk_adjustment_get_value (vadjustment);
+  if (value + vincrement <= gtk_adjustment_get_lower (vadjustment) ||
+     (value + vincrement >= gtk_adjustment_get_upper (vadjustment) - gtk_adjustment_get_page_size (vadjustment)))
+    vincrement = - vincrement;
+
+  gtk_adjustment_set_value (vadjustment, value + vincrement);
+
+  value = gtk_adjustment_get_value (hadjustment);
+  if (value + hincrement <= gtk_adjustment_get_lower (hadjustment) ||
+     (value + hincrement >= gtk_adjustment_get_upper (hadjustment) - gtk_adjustment_get_page_size (hadjustment)))
+    hincrement = - hincrement;
+
+  gtk_adjustment_set_value (hadjustment, value + hincrement);
+
+  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);
+
+  hincrement = 0;
+
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
+		                  GTK_POLICY_NEVER,
+		                  GTK_POLICY_AUTOMATIC);
+  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);
+
+  hincrement = 0;
+
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
+		                  GTK_POLICY_NEVER,
+		                  GTK_POLICY_AUTOMATIC);
+  gtk_container_add (GTK_CONTAINER (scrolledwindow), textview);
+}
+
+static void
+populate_image (void)
+{
+  GtkWidget *image;
+
+  if (!content)
+    {
+      GBytes *bytes;
+
+      bytes = g_resources_lookup_data ("/sources/font_features.c", 0, NULL);
+      content = g_bytes_unref_to_data (bytes, &content_len);
+    }
+
+  image = gtk_picture_new_for_resource ("/sliding_puzzle/portland-rose.jpg");
+  gtk_picture_set_can_shrink (GTK_PICTURE (image), FALSE);
+
+  hincrement = 5;
+
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
+		                  GTK_POLICY_AUTOMATIC,
+		                  GTK_POLICY_AUTOMATIC);
+  gtk_container_add (GTK_CONTAINER (scrolledwindow), image);
+}
+
+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;
+
+    case 3:
+      gtk_window_set_title (GTK_WINDOW (window), "Scrolling a big image");
+      populate_image ();
+      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);
+      hadjustment = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "hadjustment"));
+      vadjustment = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "vadjustment"));
+      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,40 @@
+<?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="hadjustment"><object class="GtkAdjustment" id="hadjustment"/></property> 
+        <property name="vadjustment"><object class="GtkAdjustment" id="vadjustment"/></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

@@ -18,6 +18,10 @@
 
 #include "language-names.h"
 
+#ifndef ISO_CODES_PREFIX
+#define ISO_CODES_PREFIX "/usr"
+#endif
+
 #define ISO_CODES_DATADIR ISO_CODES_PREFIX "/share/xml/iso-codes"
 #define ISO_CODES_LOCALESDIR ISO_CODES_PREFIX "/share/locale"
 
@@ -202,7 +206,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/main.c

@@ -487,7 +487,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 +639,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);
 
@@ -748,6 +748,9 @@ load_file (const gchar *demoname,
 
   source_buffer = gtk_text_buffer_new (NULL);
 
+  gtk_text_buffer_begin_irreversible_action (info_buffer);
+  gtk_text_buffer_begin_irreversible_action (source_buffer);
+
   resource_filename = g_strconcat ("/sources/", filename, NULL);
   bytes = g_resources_lookup_data (resource_filename, 0, &err);
   g_free (resource_filename);
@@ -880,9 +883,11 @@ load_file (const gchar *demoname,
 
   fontify (source_buffer);
 
+  gtk_text_buffer_end_irreversible_action (source_buffer);
   gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), source_buffer);
   g_object_unref (source_buffer);
 
+  gtk_text_buffer_end_irreversible_action (info_buffer);
   gtk_text_view_set_buffer (GTK_TEXT_VIEW (info_view), info_buffer);
   g_object_unref (info_buffer);
 }

demos/gtk-demo/markup.c

@@ -29,8 +29,10 @@ source_toggled (GtkToggleButton *button)
 
       buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
       gtk_text_buffer_get_bounds (buffer, &start, &end);
+      gtk_text_buffer_begin_irreversible_action (buffer);
       gtk_text_buffer_delete (buffer, &start, &end);
       gtk_text_buffer_insert_markup (buffer, &start, markup, -1);
+      gtk_text_buffer_end_irreversible_action (buffer);
       g_free (markup);
 
       gtk_stack_set_visible_child_name (GTK_STACK (stack), "formatted");
@@ -106,11 +108,15 @@ do_markup (GtkWidget *do_widget)
 
       buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
       gtk_text_buffer_get_start_iter (buffer, &iter);
+      gtk_text_buffer_begin_irreversible_action (buffer);
       gtk_text_buffer_insert_markup (buffer, &iter, markup, -1);
+      gtk_text_buffer_end_irreversible_action (buffer);
 
       buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view2));
       gtk_text_buffer_get_start_iter (buffer, &iter);
+      gtk_text_buffer_begin_irreversible_action (buffer);
       gtk_text_buffer_insert (buffer, &iter, markup, -1);
+      gtk_text_buffer_end_irreversible_action (buffer);
 
       g_bytes_unref (bytes);
 

demos/gtk-demo/meson.build

@@ -10,6 +10,7 @@ demos = files([
   'combobox.c',
   'constraints.c',
   'constraints2.c',
+  'constraints3.c',
   'css_accordion.c',
   'css_basics.c',
   'css_blendmodes.c',
@@ -21,17 +22,19 @@ demos = files([
   'drawingarea.c',
   'dnd.c',
   'editable_cells.c',
-  'entry_buffer.c',
   'entry_completion.c',
+  'entry_undo.c',
   'expander.c',
   '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',
@@ -70,6 +73,7 @@ demos = files([
   'tabs.c',
   'tagged_entry.c',
   'textmask.c',
+  'textundo.c',
   'textview.c',
   'textscroll.c',
   'themes.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/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/textundo.c

@@ -0,0 +1,71 @@
+/* Text View/Undo and Redo
+ *
+ * The GtkTextView supports undo and redo through the use of a
+ * GtkTextBuffer. You can enable or disable undo support using
+ * gtk_text_buffer_set_enable_undo().
+ *
+ * Use Primary+Z to undo and Primary+Shift+Z or Primary+Y to
+ * redo previously undone operations.
+ */
+
+#include <gtk/gtk.h>
+#include <stdlib.h> /* for exit() */
+
+GtkWidget *
+do_textundo (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *view;
+      GtkWidget *sw;
+      GtkTextBuffer *buffer;
+      GtkTextIter iter;
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      gtk_window_set_default_size (GTK_WINDOW (window),
+                                   450, 450);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      gtk_window_set_title (GTK_WINDOW (window), "TextView Undo");
+
+      view = gtk_text_view_new ();
+      gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
+      buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+      gtk_text_buffer_set_enable_undo (buffer, TRUE);
+
+      /* this text cannot be undone */
+      gtk_text_buffer_begin_irreversible_action (buffer);
+      gtk_text_buffer_get_start_iter (buffer, &iter);
+      gtk_text_buffer_insert (buffer, &iter,
+                              "Type to add more text.\n"
+                              "Use Primary+Z to undo and Primary+Shift+Z to redo a previously undone action.\n"
+                              "\n",
+                              -1);
+      gtk_text_buffer_end_irreversible_action (buffer);
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                      GTK_POLICY_AUTOMATIC,
+                                      GTK_POLICY_AUTOMATIC);
+      gtk_container_add (GTK_CONTAINER (window), sw);
+      gtk_container_add (GTK_CONTAINER (sw), view);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    {
+      gtk_widget_show (window);
+    }
+  else
+    {
+      gtk_widget_destroy (window);
+      window = NULL;
+    }
+
+  return window;
+}

demos/gtk-demo/textview.c

@@ -128,24 +128,23 @@ 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.
    */
   gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
 
+  gtk_text_buffer_begin_irreversible_action (buffer);
   gtk_text_buffer_insert (buffer, &iter,
       "The text widget can display text with all kinds of nifty attributes. "
       "It also supports multiple views of the same buffer; this demo is "
@@ -379,7 +378,8 @@ 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);
+  gtk_text_buffer_end_irreversible_action (buffer);
+
   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/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/building.xml

@@ -76,10 +76,10 @@ How to compile GTK itself
     </para>
     <para>
       Several environment variables are useful to pass to set before
-      running configure. <envar>CPPFLAGS</envar> contains options to
-      pass to the C compiler, and is used to tell the compiler where
-      to look for include files. The <envar>LDFLAGS</envar> variable
-      is used in a similar fashion for the linker. Finally the
+      running <application>meson</application>. <envar>CPPFLAGS</envar>
+      contains options to pass to the C compiler, and is used to tell
+      the compiler where to look for include files. The <envar>LDFLAGS</envar>
+      variable is used in a similar fashion for the linker. Finally the
       <envar>PKG_CONFIG_PATH</envar> environment variable contains
       a search path that <command>pkg-config</command> (see below)
       uses when looking for files describing how to compile
@@ -106,6 +106,61 @@ How to compile GTK itself
       export LD_LIBRARY_PATH PATH
     </programlisting>
   </refsect1>
+
+  <refsect1 id="build-types">
+    <title>Build types</title>
+
+    <para>Meson has different build types, exposed by the <literal>buildtype</literal>
+    configuration option. GTK enables and disables functionality depending on
+    the build type used when calling <application>meson</application> to
+    configure the build.</para>
+
+    <formalpara>
+      <title><systemitem>debug</systemitem> and <systemitem>debugoptimized</systemitem></title>
+
+      <para>
+        GTK will enable debugging code paths in both the
+        <literal>debug</literal> and <literal>debugoptimized</literal>
+        build types. Builds with <literal>buildtype</literal> set
+        to <literal>debug</literal> will additionally enable
+        consistency checks on the internal state of the toolkit.
+      </para>
+
+      <para>
+        It is recommended to use the <literal>debug</literal> or
+        <literal>debugoptimized</literal> build types when developing
+        GTK itself. Additionally, <literal>debug</literal> builds of
+        GTK are recommended for profiling and debugging GTK applications,
+        as they include additional validation of the internal state.
+      </para>
+
+      <para>
+        The <literal>debugoptimized</literal> build type is the
+        default for GTK if no build type is specified when calling
+        <application>meson</application>
+      </para>
+    </formalpara>
+
+    <formalpara>
+      <title><systemitem>release</systemitem></title>
+
+      <para>
+        The <literal>release</literal> build type will disable
+        debugging code paths and additional run time safeties, like
+        checked casts for object instances.
+      </para>
+    </formalpara>
+
+    <para>
+      The <literal>plain</literal> build type provided by Meson
+      should only be used when packaging GTK, and it's expected
+      that packagers will provide their own compiler flags when
+      building GTK. See the previous section for the list of
+      environment variables to be used to define compiler and
+      linker flags.
+    </para>
+  </refsect1>
+
   <refsect1 id="dependencies">
     <title>Dependencies</title>
     <para>
@@ -283,184 +338,181 @@ How to compile GTK itself
       See <xref linkend="gtk-resources"/> for more information.
     </para>
   </refsect1>
-      <refsect1 id="extra-configuration-options">
-      <title>Extra Configuration Options</title>
+
+  <refsect1 id="extra-configuration-options">
+    <title>Extra Configuration Options</title>
+
+    <para>
+      In addition to the normal options provided by Meson, GTK defines
+      various arguments that modify what should be built.
+
+      <cmdsynopsis>
+        <command>meson</command>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dx11-backend=true</arg>
+          <arg choice="plain">-Dx11-backend=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dwayland-backend=true</arg>
+          <arg choice="plain">-Dwayland-backend=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dbroadway-backend=true</arg>
+          <arg choice="plain">-Dbroadway-backend=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dwin32-backend=true</arg>
+          <arg choice="plain">-Dwin32-backend=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dquartz-backend=true</arg>
+          <arg choice="plain">-Dquartz-backend=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dmedia=gstreamer</arg>
+          <arg choice="plain">-Dmedia=ffmpeg</arg>
+          <arg choice="plain">-Dmedia=all</arg>
+          <arg choice="plain">-Dmedia=none</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dvulkan=yes</arg>
+          <arg choice="plain">-Dvulkan=no</arg>
+          <arg choice="plain">-Dvulkan=auto</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dxinerama=yes</arg>
+          <arg choice="plain">-Dxinerama=no</arg>
+          <arg choice="plain">-Dxinerama=auto</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dcloudproviders=true</arg>
+          <arg choice="plain">-Dcloudproviders=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dprint-backends=all</arg>
+          <arg choice="plain">-Dprint-backends=none</arg>
+          <arg choice="plain">-Dprint-backends=cups,lpr,...</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dcolord=yes</arg>
+          <arg choice="plain">-Dcolord=no</arg>
+          <arg choice="plain">-Dcolord=auto</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dgtk_doc=true</arg>
+          <arg choice="plain">-Dgtk_doc=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dman-pages=true</arg>
+          <arg choice="plain">-Dman-pages=false</arg>
+        </group>
+        <sbr/>
+        <group>
+          <arg choice="plain">-Dintrospection=true</arg>
+          <arg choice="plain">-Dintrospection=false</arg>
+        </group>
+      </cmdsynopsis>
+    </para>
+
+    <formalpara>
+      <title><systemitem>xinerama</systemitem></title>
 
       <para>
-        In addition to the normal options provided by Meson, GTK defines
-        various arguments that modify what should be built.
-
-        <cmdsynopsis>
-          <command>meson</command>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dx11-backend=true</arg>
-            <arg choice="plain">-Dx11-backend=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dwayland-backend=true</arg>
-            <arg choice="plain">-Dwayland-backend=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dbroadway-backend=true</arg>
-            <arg choice="plain">-Dbroadway-backend=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dwin32-backend=true</arg>
-            <arg choice="plain">-Dwin32-backend=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dquartz-backend=true</arg>
-            <arg choice="plain">-Dquartz-backend=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dmedia=gstreamer</arg>
-            <arg choice="plain">-Dmedia=ffmpeg</arg>
-            <arg choice="plain">-Dmedia=all</arg>
-            <arg choice="plain">-Dmedia=none</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dvulkan=yes</arg>
-            <arg choice="plain">-Dvulkan=no</arg>
-            <arg choice="plain">-Dvulkan=auto</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dxinerama=yes</arg>
-            <arg choice="plain">-Dxinerama=no</arg>
-            <arg choice="plain">-Dxinerama=auto</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dcloudproviders=true</arg>
-            <arg choice="plain">-Dcloudproviders=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dprint-backends=all</arg>
-            <arg choice="plain">-Dprint-backends=none</arg>
-            <arg choice="plain">-Dprint-backends=cups,lpr,...</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dcolord=yes</arg>
-            <arg choice="plain">-Dcolord=no</arg>
-            <arg choice="plain">-Dcolord=auto</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Ddocumentation=true</arg>
-            <arg choice="plain">-Ddocumentation=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dman-pages=true</arg>
-            <arg choice="plain">-Dman-pages=false</arg>
-          </group>
-          <sbr/>
-          <group>
-            <arg choice="plain">-Dintrospection=true</arg>
-            <arg choice="plain">-Dintrospection=false</arg>
-          </group>
-        </cmdsynopsis>
+        By default GTK will try to link against the Xinerama libraries
+        if they are found. This options can be used to explicitly control
+        whether Xinerama should be used.
       </para>
+    </formalpara>
 
-      <formalpara>
-        <title><systemitem>xinerama</systemitem></title>
+    <formalpara>
+      <title><systemitem>gtk_doc</systemitem> and
+        <systemitem>man-pages</systemitem></title>
 
-        <para>
-          By default GTK will try to link against the Xinerama libraries
-          if they are found. This options can be used to explicitly control
-          whether Xinerama should be used.
-        </para>
-      </formalpara>
+      <para>
+        The <application>gtk-doc</application> package is
+        used to generate the reference documentation included
+        with GTK. By default support for <application>gtk-doc</application>
+        is disabled because it requires various extra dependencies
+        to be installed. If you have
+        <application>gtk-doc</application> installed and
+        are modifying GTK, you may want to enable
+        <application>gtk-doc</application> support by passing
+        in <systemitem>gtk_doc</systemitem>.
+      </para>
+      <para>
+        Additionally, some tools provided by GTK have their own
+        manual pages generated using a similar set of dependencies;
+        if you have <application>xsltproc</application> then you
+        can generate manual pages by passing <systemitem>man-pages</systemitem>
+        when configuring the build.
+      </para>
+    </formalpara>
 
-      <formalpara>
-        <title><systemitem>documentation</systemitem> and
-          <systemitem>man-pages</systemitem></title>
+    <formalpara>
+      <title><systemitem>print-backends</systemitem></title>
 
-        <para>
-          The <application>gtk-doc</application> package is
-          used to generate the reference documentation included
-          with GTK. By default support for <application>gtk-doc</application>
-          is disabled because it requires various extra dependencies
-          to be installed. If you have
-          <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>.
-        </para>
-        <para>
-          Additionally, some tools provided by GTK have their own
-          manual pages generated using a similar set of dependencies;
-          if you have <application>xsltproc</application> then you
-          can generate manual pages by passing <systemitem>man-pages</systemitem>
-          when configuring the build.
-        </para>
-      </formalpara>
+      <para>
+        By default, GTK will try to build various print backends if
+        their dependencies are found. This option can be used to
+        explicitly control which print backends should be built.
+      </para>
+    </formalpara>
 
-      <formalpara>
-        <title><systemitem>print-backends</systemitem></title>
+    <formalpara>
+      <title><systemitem>x11-backend</systemitem>,
+        <systemitem>win32-backend</systemitem>,
+        <systemitem>quartz-backend</systemitem>,
+        <systemitem>broadway-backend</systemitem> and
+        <systemitem>wayland-backend</systemitem></title>
 
-        <para>
-          By default, GTK will try to build various print backends if
-          their dependencies are found. This option can be used to
-          explicitly control which print backends should be built.
-        </para>
-      </formalpara>
+      <para>
+        Enable specific backends for GDK.  If none of these options
+        are given, the Wayland backend will be enabled by default,
+        if the platform is Linux; the X11 backend will also be enabled
+        by default, unless the platform is Windows, in which case the
+        default is win32, or the platform is macOS, in which case the
+        default is quartz. If any backend is explicitly enabled or disabled,
+        no other platform will be enabled automatically.
+      </para>
+    </formalpara>
 
-      <formalpara>
-        <title><systemitem>x11-backend</systemitem>,
-          <systemitem>win32-backend</systemitem>,
-          <systemitem>quartz-backend</systemitem>,
-          <systemitem>broadway-backend</systemitem> and
-          <systemitem>wayland-backend</systemitem></title>
+    <formalpara>
+      <title><systemitem>introspection</systemitem></title>
 
-        <para>
-          Enable specific backends for GDK.  If none of these options
-          are given, the Wayland backend will be enabled by default,
-          if the platform is Linux; the X11 backend will also be enabled
-          by default, unless the platform is Windows, in which case the
-          default is win32, or the platform is macOS, in which case the
-          default is quartz. If any backend is explicitly enabled or disabled,
-          no other platform will be enabled automatically.
-        </para>
-      </formalpara>
+      <para>
+        Allows to disable building introspection support. This is option
+        is mainly useful for shortening turnaround times on developer
+        systems. Installed builds of GTK should always have introspection
+        support.
+      </para>
+    </formalpara>
 
-      <formalpara>
-        <title><systemitem>introspection</systemitem></title>
+    <formalpara>
+      <title><systemitem>build-tests</systemitem>,
+             <systemitem>install-tests</systemitem>,
+             <systemitem>demos</systemitem></title>
 
-        <para>
-          Allows to disable building introspection support. This is option
-          is mainly useful for shortening turnaround times on developer
-          systems. Installed builds of GTK should always have introspection
-          support.
-        </para>
-      </formalpara>
+      <para>
+        By default, GTK will build quite a few tests and demos.
+        While these are useful on a developer system, they are not
+        needed when GTK is built e.g. for a flatpak runtime. These
+        options allow to disable building tests and demos.
+      </para>
+    </formalpara>
 
-      <formalpara>
-        <title><systemitem>build-tests</systemitem>,
-               <systemitem>install-tests</systemitem>,
-               <systemitem>demos</systemitem></title>
-
-        <para>
-          By default, GTK will build quite a few tests and demos.
-          While these are useful on a developer system, they are not
-          needed when GTK is built e.g. for a flatpak runtime. These
-          options allow to disable building tests and demos.
-        </para>
-      </formalpara>
-
-    </refsect1>
+  </refsect1>
 
 </refentry>
-
-<!-- Local Variables: -->
-<!-- sgml-parent-document: ("gtk-docs.sgml" "chapter" "refentry")  -->
-<!-- End: -->

docs/reference/gtk/drawing-model.xml

@@ -224,10 +224,3 @@
   </refsect1>
 
 </refentry>
-
-<!--
-Local variables:
-mode: xml
-sgml-parent-document: ("gtk-docs.sgml" "book" "part" "refentry")
-End:
--->

docs/reference/gtk/glossary.xml

@@ -364,10 +364,3 @@
     </glossdef>
   </glossentry>
 </glossary>
-
-<!--
-Local variables:
-mode: sgml
-sgml-parent-document: ("gtk-docs.sgml" "book" "glossary")
-End:
--->

docs/reference/gtk/gtk4-docs.xml

@@ -22,8 +22,8 @@
     <title>GTK Overview</title>
     <xi:include href="overview.xml"/>
     <xi:include href="xml/getting_started.xml"/>
-    <xi:include href="resources.sgml" />
-    <xi:include href="xml/question_index.sgml" />
+    <xi:include href="resources.xml" />
+    <xi:include href="xml/question_index.xml" />
     <xi:include href="xml/drawing-model.xml" />
     <xi:include href="xml/input-handling.xml" />
     <xi:include href="xml/actions.xml" />
@@ -51,6 +51,7 @@
       <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" />
     </chapter>
 
@@ -109,6 +110,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">
@@ -164,7 +168,7 @@
 
     <chapter id="TextWidgetObjects">
       <title>Multiline Text Editor</title>
-      <xi:include href="xml/text_widget.sgml" />
+      <xi:include href="xml/text_widget.xml" />
       <xi:include href="xml/gtktextiter.xml" />
       <xi:include href="xml/gtktextmark.xml" />
       <xi:include href="xml/gtktextbuffer.xml" />
@@ -175,7 +179,7 @@
 
     <chapter id="TreeWidgetObjects">
       <title>Tree, List and Icon Grid Widgets</title>
-      <xi:include href="xml/tree_widget.sgml" />
+      <xi:include href="xml/tree_widget.xml" />
       <xi:include href="xml/gtktreemodel.xml" />
       <xi:include href="xml/gtktreeselection.xml" />
       <xi:include href="xml/gtktreeviewcolumn.xml" />
@@ -403,12 +407,12 @@
 
   <part id="platform-support">
     <title>GTK Platform Support</title>
-    <xi:include href="building.sgml" />
-    <xi:include href="xml/compiling.sgml" />
-    <xi:include href="running.sgml" />
-    <xi:include href="x11.sgml" />
-    <xi:include href="windows.sgml" />
-    <xi:include href="osx.sgml" />
+    <xi:include href="building.xml" />
+    <xi:include href="xml/compiling.xml" />
+    <xi:include href="running.xml" />
+    <xi:include href="x11.xml" />
+    <xi:include href="windows.xml" />
+    <xi:include href="osx.xml" />
     <xi:include href="broadway.xml" />
     <xi:include href="wayland.xml" />
   </part>

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
@@ -846,6 +882,8 @@ gtk_editable_get_width_chars
 gtk_editable_set_width_chars
 gtk_editable_get_max_width_chars
 gtk_editable_set_max_width_chars
+gtk_editable_get_enable_undo
+gtk_editable_set_enable_undo
 <SUBSECTION>
 gtk_editable_install_properties
 gtk_editable_init_delegate
@@ -1683,8 +1721,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 +1742,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 +1824,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 +1905,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
@@ -2837,6 +2878,18 @@ gtk_text_buffer_begin_user_action
 gtk_text_buffer_end_user_action
 gtk_text_buffer_add_selection_clipboard
 gtk_text_buffer_remove_selection_clipboard
+gtk_text_buffer_get_can_undo
+gtk_text_buffer_get_can_redo
+gtk_text_buffer_get_enable_undo
+gtk_text_buffer_set_enable_undo
+gtk_text_buffer_get_max_undo_levels
+gtk_text_buffer_set_max_undo_levels
+gtk_text_buffer_undo
+gtk_text_buffer_redo
+gtk_text_buffer_begin_irreversible_action
+gtk_text_buffer_end_irreversible_action
+gtk_text_buffer_begin_user_action
+gtk_text_buffer_end_user_action
 
 <SUBSECTION Standard>
 GTK_TEXT_BUFFER
@@ -3042,7 +3095,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 +3110,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
@@ -4432,7 +4487,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
@@ -4604,7 +4658,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>
@@ -5208,6 +5261,10 @@ 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
@@ -5265,12 +5322,9 @@ gtk_icon_theme_lookup_by_gicon
 gtk_icon_theme_lookup_by_gicon_for_scale
 gtk_icon_theme_load_icon
 gtk_icon_theme_load_icon_for_scale
-gtk_icon_theme_list_contexts
 gtk_icon_theme_list_icons
 gtk_icon_theme_get_icon_sizes
-gtk_icon_theme_get_example_icon_name
 gtk_icon_theme_rescan_if_needed
-gtk_icon_info_new_for_pixbuf
 gtk_icon_info_get_base_size
 gtk_icon_info_get_base_scale
 gtk_icon_info_get_filename
@@ -6701,6 +6755,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
@@ -6739,6 +6795,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
@@ -7287,3 +7345,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

@@ -49,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
@@ -119,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',
@@ -335,8 +342,8 @@ images = [
 content_files = [
   'actions.xml',
   'broadway.xml',
-  'building.sgml',
-  'compiling.sgml',
+  'building.xml',
+  'compiling.xml',
   'css-overview.xml',
   'css-properties.xml',
   'drawing-model.xml',
@@ -354,31 +361,31 @@ content_files = [
   'input-handling.xml',
   'migrating-2to4.xml',
   'migrating-3to4.xml',
-  'osx.sgml',
-  'other_software.sgml',
+  'osx.xml',
+  'other_software.xml',
   'overview.xml',
-  'question_index.sgml',
-  'resources.sgml',
-  'running.sgml',
-  'text_widget.sgml',
-  'tree_widget.sgml',
+  'question_index.xml',
+  'resources.xml',
+  'running.xml',
+  'text_widget.xml',
+  'tree_widget.xml',
   'visual_index.xml',
   'wayland.xml',
-  'windows.sgml',
-  'x11.sgml',
+  'windows.xml',
+  'x11.xml',
 ]
 
 expand_content_files = [
   'actions.xml',
-  'compiling.sgml',
+  'compiling.xml',
   'drawing-model.xml',
   'glossary.xml',
   'input-handling.xml',
   'migrating-2to4.xml',
   'migrating-3to4.xml',
-  'question_index.sgml',
-  'text_widget.sgml',
-  'tree_widget.sgml',
+  'question_index.xml',
+  'text_widget.xml',
+  'tree_widget.xml',
 ]
 
 types_conf = configuration_data()
@@ -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/migrating-3to4.xml

@@ -813,6 +813,21 @@
       </para>
     </section>
 
+    <section>
+      <title>GtkEntryBuffer ::deleted-text has changed</title>
+      <para>
+        To allow signal handlers to access the deleted text before it
+        has been deleted #GtkEntryBuffer::deleted-text has changed from
+        %G_SIGNAL_RUN_FIRST to %G_SIGNAL_RUN_LAST. The default handler
+        removes the text from the #GtkEntryBuffer.
+      </para>
+      <para>
+        To adapt existing code, use g_signal_connect_after() or
+        %G_CONNECT_AFTER when using g_signal_connect_data() or
+        g_signal_connect_object().
+      </para>
+    </section>
+
   </section>
 
 </chapter>

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/gtk/text_widget.xml

@@ -112,6 +112,16 @@ multiple bytes in UTF-8, and the two-character sequence "\r\n" is also
 considered a line separator.
 </para>
 
+<para>
+Text buffers support undo and redo if gtk_text_buffer_set_undo_enabled()
+has been set to %TRUE. Use gtk_text_buffer_undo() or gtk_text_buffer_redo()
+to perform the necessary action. Note that these operations are ignored if
+the buffer is not editable. Developers may want some operations to not be
+undoable. To do this, wrap your changes in
+gtk_text_buffer_begin_irreversible_action() and
+gtk_text_buffer_end_irreversible_action().
+</para>
+
 </refsect1>
 
 

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/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

@@ -401,7 +401,12 @@ gdk_monitor_get_connector (GdkMonitor *monitor)
  * 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
  */

gdk/gdkpixbuf-drawable.c

@@ -26,6 +26,7 @@
 
 #include "gdksurface.h"
 #include "gdkinternals.h"
+#include "gdktextureprivate.h"
 
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
@@ -222,3 +223,32 @@ gdk_pixbuf_get_from_surface  (cairo_surface_t *surface,
   cairo_surface_destroy (surface);
   return dest;
 }
+
+/**
+ * gdk_pixbuf_get_from_texture:
+ * @texture: a #GdkTexture
+ *
+ * Creates a new pixbuf from @texture. This should generally not be used
+ * in newly written code as later stages will almost certainly convert
+ * the pixbuf back into a texture to draw it on screen.
+ *
+ * Returns: (transfer full) (nullable): a new #GdkPixbuf or %NULL
+ *   in case of an error
+ */
+GdkPixbuf *
+gdk_pixbuf_get_from_texture (GdkTexture *texture)
+{
+  GdkPixbuf *pixbuf;
+  cairo_surface_t *surface;
+  int width, height;
+
+  g_return_val_if_fail (GDK_IS_TEXTURE (texture), NULL);
+
+  width = gdk_texture_get_width (texture);
+  height = gdk_texture_get_height (texture);
+  surface = gdk_texture_download_surface (texture);
+  pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, width, height);
+  cairo_surface_destroy (surface);
+
+  return pixbuf;
+}

gdk/gdkpixbuf.h

@@ -33,6 +33,8 @@
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gdk/gdktypes.h>
 #include <gdk/gdkversionmacros.h>
+#include <gdk/gdktexture.h>
+
 
 G_BEGIN_DECLS
 
@@ -42,6 +44,8 @@ GdkPixbuf *gdk_pixbuf_get_from_surface (cairo_surface_t *surface,
                                         gint             src_y,
                                         gint             width,
                                         gint             height);
+GDK_AVAILABLE_IN_ALL
+GdkPixbuf *gdk_pixbuf_get_from_texture (GdkTexture      *texture);
 
 G_END_DECLS
 

gdk/gdkseat.c

@@ -28,7 +28,7 @@
 
 /**
  * SECTION:gdkseat
- * @Short_description: Object representing an user seat
+ * @Short_description: Object representing a user seat
  * @Title: GdkSeat
  * @See_also: #GdkDisplay, #GdkDevice
  *

gdk/gdkselection.c

@@ -65,7 +65,7 @@ gdk_text_property_to_utf8_list_for_display (GdkDisplay     *display,
  * gdk_utf8_to_string_target:
  * @str: a UTF-8 string
  *
- * Converts an UTF-8 string into the best possible representation
+ * Converts a UTF-8 string into the best possible representation
  * as a STRING. The representation of characters not in STRING
  * is not specified; it may be as pseudo-escape sequences
  * \x{ABCD}, or it may be in some other form of approximation.

gdk/gdksurface.c

@@ -246,14 +246,15 @@ maybe_flip_position (gint      bounds_pos,
   return primary;
 }
 
-static void
-gdk_surface_real_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)
+void
+gdk_surface_move_to_rect_helper (GdkSurface            *surface,
+                                 const GdkRectangle    *rect,
+                                 GdkGravity             rect_anchor,
+                                 GdkGravity             surface_anchor,
+                                 GdkAnchorHints         anchor_hints,
+                                 gint                   rect_anchor_dx,
+                                 gint                   rect_anchor_dy,
+                                 GdkSurfaceMovedToRect  moved_to_rect)
 {
   GdkSurface *toplevel;
   GdkDisplay *display;
@@ -362,17 +363,14 @@ gdk_surface_real_move_to_rect (GdkSurface         *surface,
   final_rect.width += surface->shadow_left + surface->shadow_right;
   final_rect.height += surface->shadow_top + surface->shadow_bottom;
 
-  if (final_rect.width != surface->width || final_rect.height != surface->height)
-    gdk_surface_move_resize (surface, final_rect.x, final_rect.y, final_rect.width, final_rect.height);
-  else
-    gdk_surface_move (surface, final_rect.x, final_rect.y);
-
   gdk_surface_get_origin (toplevel, &x, &y);
   final_rect.x -= x;
   final_rect.y -= y;
   flipped_rect.x -= x;
   flipped_rect.y -= y;
 
+  moved_to_rect (surface, final_rect);
+
   g_signal_emit_by_name (surface,
                          "moved-to-rect",
                          &flipped_rect,
@@ -411,7 +409,6 @@ gdk_surface_class_init (GdkSurfaceClass *klass)
   object_class->get_property = gdk_surface_get_property;
 
   klass->beep = gdk_surface_real_beep;
-  klass->move_to_rect = gdk_surface_real_move_to_rect;
 
   /**
    * GdkSurface:cursor:
@@ -1341,10 +1338,14 @@ gdk_surface_schedule_update (GdkSurface *surface)
 {
   GdkFrameClock *frame_clock;
 
-  if (surface &&
-      (surface->update_freeze_count ||
-       gdk_surface_is_toplevel_frozen (surface)))
-    return;
+  g_return_if_fail (surface);
+
+  if (surface->update_freeze_count ||
+      gdk_surface_is_toplevel_frozen (surface))
+    {
+      surface->pending_schedule_update = TRUE;
+      return;
+    }
 
   /* If there's no frame clock (a foreign surface), then the invalid
    * region will just stick around unless gdk_surface_process_updates()
@@ -1400,7 +1401,6 @@ gdk_surface_paint_on_clock (GdkFrameClock *clock,
                             void          *data)
 {
   GdkSurface *surface = GDK_SURFACE (data);
-  GList *l;
 
   g_return_if_fail (GDK_IS_SURFACE (surface));
 
@@ -1421,9 +1421,6 @@ gdk_surface_paint_on_clock (GdkFrameClock *clock,
       gdk_surface_remove_update_surface (surface);
     }
 
-  for (l = surface->children; l; l = l->next)
-    gdk_surface_paint_on_clock (clock, l->data);
-
   g_object_unref (surface);
 }
 
@@ -1581,13 +1578,17 @@ gdk_surface_freeze_updates (GdkSurface *surface)
   g_return_if_fail (GDK_IS_SURFACE (surface));
 
   surface->update_freeze_count++;
+  if (surface->update_freeze_count == 1)
+    _gdk_frame_clock_uninhibit_freeze (surface->frame_clock);
 }
 
 /**
  * gdk_surface_thaw_updates:
  * @surface: a #GdkSurface
  *
- * Thaws a surface frozen with gdk_surface_freeze_updates().
+ * Thaws a surface frozen with gdk_surface_freeze_updates(). Note that this
+ * will not necessarily schedule updates if the surface freeze count reaches
+ * zero.
  **/
 void
 gdk_surface_thaw_updates (GdkSurface *surface)
@@ -1597,7 +1598,15 @@ gdk_surface_thaw_updates (GdkSurface *surface)
   g_return_if_fail (surface->update_freeze_count > 0);
 
   if (--surface->update_freeze_count == 0)
-    gdk_surface_schedule_update (surface);
+    {
+      _gdk_frame_clock_inhibit_freeze (surface->frame_clock);
+
+      if (surface->pending_schedule_update)
+        {
+          surface->pending_schedule_update = FALSE;
+          gdk_surface_schedule_update (surface);
+        }
+    }
 }
 
 void
@@ -1606,7 +1615,7 @@ gdk_surface_freeze_toplevel_updates (GdkSurface *surface)
   g_return_if_fail (GDK_IS_SURFACE (surface));
 
   surface->update_and_descendants_freeze_count++;
-  _gdk_frame_clock_freeze (gdk_surface_get_frame_clock (surface));
+  gdk_surface_freeze_updates (surface);
 }
 
 void
@@ -1616,9 +1625,9 @@ gdk_surface_thaw_toplevel_updates (GdkSurface *surface)
   g_return_if_fail (surface->update_and_descendants_freeze_count > 0);
 
   surface->update_and_descendants_freeze_count--;
-  _gdk_frame_clock_thaw (gdk_surface_get_frame_clock (surface));
-
   gdk_surface_schedule_update (surface);
+  gdk_surface_thaw_updates (surface);
+
 }
 
 /**
@@ -2060,59 +2069,6 @@ G_GNUC_END_IGNORE_DEPRECATIONS
   GDK_SURFACE_GET_CLASS (surface)->hide (surface);
 }
 
-static void
-gdk_surface_move_resize_toplevel (GdkSurface *surface,
-                                  gboolean   with_move,
-                                  gint       x,
-                                  gint       y,
-                                  gint       width,
-                                  gint       height)
-{
-  GDK_SURFACE_GET_CLASS (surface)->move_resize (surface, with_move, x, y, width, height);
-}
-
-
-static void
-gdk_surface_move_resize_internal (GdkSurface *surface,
-                                  gboolean   with_move,
-                                  gint       x,
-                                  gint       y,
-                                  gint       width,
-                                  gint       height)
-{
-  g_return_if_fail (GDK_IS_SURFACE (surface));
-
-  if (surface->destroyed)
-    return;
-
-  gdk_surface_move_resize_toplevel (surface, with_move, x, y, width, height);
-}
-
-
-
-/*
- * gdk_surface_move:
- * @surface: a #GdkSurface
- * @x: X coordinate relative to surface’s parent
- * @y: Y coordinate relative to surface’s parent
- *
- * Repositions a surface relative to its parent surface.
- * For toplevel surfaces, window managers may ignore or modify the move;
- * you should probably use gtk_window_move() on a #GtkWindow widget
- * anyway, instead of using GDK functions. For child surfaces,
- * the move will reliably succeed.
- *
- * If you’re also planning to resize the surface, use gdk_surface_move_resize()
- * to both move and resize simultaneously, for a nicer visual effect.
- **/
-void
-gdk_surface_move (GdkSurface *surface,
-                  gint       x,
-                  gint       y)
-{
-  gdk_surface_move_resize_internal (surface, TRUE, x, y, -1, -1);
-}
-
 /**
  * gdk_surface_resize:
  * @surface: a #GdkSurface
@@ -2130,31 +2086,7 @@ gdk_surface_resize (GdkSurface *surface,
                     gint       width,
                     gint       height)
 {
-  gdk_surface_move_resize_internal (surface, FALSE, 0, 0, width, height);
-}
-
-
-/*
- * gdk_surface_move_resize:
- * @surface: a #GdkSurface
- * @x: new X position relative to surface’s parent
- * @y: new Y position relative to surface’s parent
- * @width: new width
- * @height: new height
- *
- * Equivalent to calling gdk_surface_move() and gdk_surface_resize(),
- * except that both operations are performed at once, avoiding strange
- * visual effects. (i.e. the user may be able to see the surface first
- * move, then resize, if you don’t use gdk_surface_move_resize().)
- **/
-void
-gdk_surface_move_resize (GdkSurface *surface,
-                         gint       x,
-                         gint       y,
-                         gint       width,
-                         gint       height)
-{
-  gdk_surface_move_resize_internal (surface, TRUE, x, y, width, height);
+  GDK_SURFACE_GET_CLASS (surface)->toplevel_resize (surface, width, height);
 }
 
 /**
@@ -2951,8 +2883,7 @@ gdk_surface_set_modal_hint (GdkSurface *surface,
  * this is to constrain user resizing, but the windowing system
  * will typically  (but is not required to) also constrain the
  * current size of the surface to the provided values and
- * constrain programatic resizing via gdk_surface_resize() or
- * gdk_surface_move_resize().
+ * constrain programatic resizing via gdk_surface_resize().
  *
  * Note that on X11, this effect has no effect on surfaces
  * of type %GDK_SURFACE_TEMP since these surfaces are not resizable
@@ -3703,40 +3634,42 @@ gdk_surface_set_frame_clock (GdkSurface     *surface,
   if (clock)
     {
       g_object_ref (clock);
-      if (surface->parent == NULL)
-        {
-          g_signal_connect (G_OBJECT (clock),
-                            "flush-events",
-                            G_CALLBACK (gdk_surface_flush_events),
-                            surface);
-          g_signal_connect (G_OBJECT (clock),
-                            "resume-events",
-                            G_CALLBACK (gdk_surface_resume_events),
-                            surface);
-          g_signal_connect (G_OBJECT (clock),
-                            "paint",
-                            G_CALLBACK (gdk_surface_paint_on_clock),
-                            surface);
-        }
+
+      g_signal_connect (G_OBJECT (clock),
+                        "flush-events",
+                        G_CALLBACK (gdk_surface_flush_events),
+                        surface);
+      g_signal_connect (G_OBJECT (clock),
+                        "resume-events",
+                        G_CALLBACK (gdk_surface_resume_events),
+                        surface);
+      g_signal_connect (G_OBJECT (clock),
+                        "paint",
+                        G_CALLBACK (gdk_surface_paint_on_clock),
+                        surface);
+
+      if (surface->update_freeze_count == 0)
+        _gdk_frame_clock_inhibit_freeze (clock);
     }
 
   if (surface->frame_clock)
     {
-      if (surface->parent == NULL)
-        {
-          if (surface->frame_clock_events_paused)
-            gdk_surface_resume_events (surface->frame_clock, G_OBJECT (surface));
+      if (surface->frame_clock_events_paused)
+        gdk_surface_resume_events (surface->frame_clock, G_OBJECT (surface));
+
+      g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
+                                            G_CALLBACK (gdk_surface_flush_events),
+                                            surface);
+      g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
+                                            G_CALLBACK (gdk_surface_resume_events),
+                                            surface);
+      g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
+                                            G_CALLBACK (gdk_surface_paint_on_clock),
+                                            surface);
+
+      if (surface->update_freeze_count == 0)
+        _gdk_frame_clock_uninhibit_freeze (surface->frame_clock);
 
-          g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
-                                                G_CALLBACK (gdk_surface_flush_events),
-                                                surface);
-          g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
-                                                G_CALLBACK (gdk_surface_resume_events),
-                                                surface);
-          g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
-                                                G_CALLBACK (gdk_surface_paint_on_clock),
-                                                surface);
-        }
       g_object_unref (surface->frame_clock);
     }