wayland: Try again to fix the version check

gsk: Don't pass DRM_FORMAT_MOD_INVALID to egl
Pascal pointed out that this may not work with some drivers (specifically, Raspberry Pi was mentioned).
2023-10-09 13:27:27 -04:00 · 2023-10-09 09:25:46 -04:00 · 2023-10-09 08:24:08 -04:00 · 2023-10-09 08:23:12 -04:00 · 2023-10-09 08:22:14 -04:00 · 2023-10-08 11:07:24 -04:00
211 changed files with 20120 additions and 15101 deletions
@@ -23,6 +23,7 @@ case "${backend}" in
                --suite=gtk \
                --no-suite=failing \
                --no-suite=flaky \
+                --no-suite=headless \
                --no-suite=gsk-compare-broadway

    # Store the exit code for the CI run, but always
@@ -45,6 +46,7 @@ case "${backend}" in
                --suite=gtk \
                --no-suite=failing \
                --no-suite=flaky \
+                --no-suite=headless \
                --no-suite=${backend}_failing \
                --no-suite=gsk-compare-broadway
    exit_code=$?
@@ -67,6 +69,7 @@ case "${backend}" in
                --suite=gtk \
                --no-suite=failing \
                --no-suite=flaky \
+                --no-suite=headless \
                --no-suite=gsk-compare-opengl

    kill ${server}
@@ -35,8 +35,7 @@ The issue tracker is meant to be used for actionable issues only.

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

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

 ### Bug reports

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

 0. Ask _first_.

@@ -1,6 +1,95 @@
-Overview of Changes in 4.13.1, xx-xx-xxxx
+Overview of Changes in 4.13.2, xx-xx-xxxx
 =========================================

+Overview of Changes in 4.13.1, 28-09-2023
+=========================================
+
+* GtkTooltip:
+ - Don't cross native boundaries when looking for tooltips
+
+* GtkCenterLayout, GtkEntry, GtkSearchEntry:
+ - Fix some issues with baseline handling
+
+* GtkColorButton, GtkFontButton:
+ - Propagate focus-on-click
+
+* GtkFileChooser:
+ - Make "Visit file" scroll to the file
+
+* GtkSwitch:
+ - Respect text direction
+
+* GtkWindow:
+ - Don't assume titlebars are GtkHeaderBars
+
+* Printing:
+ - Fix some problems with the portal implementation
+ - Add a new simple print API: GtkPrintDialog
+
+* Paths:
+ - GskPathMeasure performance has been improved
+ - Add custom contours for circles, rounded rectangles and rectangles
+ - Simplify GskPathPoint handling
+ - gsk_path_point_get_closest_point now returns the distance as well
+ - Make GskPathBuilder simplify curves
+
+* Input:
+ - Handle (some) single-key compose sequences
+ - Fix active state tracking with sensitivity changes and grabs
+
+* GSK:
+ - Make the repeated gradients match between GL and cairo
+ - Make rounded rect shrinking match between Vulkan, GL and cairo
+ - Fix parsing of text nodes with color glyphs
+ - Restrict an optimization to the cases where it is crrect
+ - Fix rendering of shadows with opacity
+ - The Vulkan renderer now requires Vulkan 1.2
+ - GL: Transition gradients unpremultiplied
+ - GL: Fix clipping of shadows
+ - GL: Some optimizations
+ - Broadway: Fix memory leaks in the renderer
+
+* Wayland:
+ - Make activation more reliable
+
+* macOS:
+ - Clamp damage regions to the surface size
+
+* Tools:
+ - gtk4-path-tool gained restrict and reverse commands
+ - gtk4-path-tool show and render can show control points
+
+* Demos:
+ - Add a demo for hit testing with paths
+
+* Build:
+ - Fix build problems with C++ compilers
+
+* Deprecations:
+ - gtk_window_present_with_time
+
+* Translation updates
+ Brazilian Portuguese
+ British English
+ Catalan
+ Chinese (China)
+ Czech
+ Danish
+ Dutch
+ Esperanto
+ Galician
+ Georgian
+ Italian
+ Korean
+ Latvian
+ Lithuanian
+ Persian
+ Polish
+ Punjabi
+ Slovenian
+ Turkish
+
+
 Overview of Changes in 4.13.0, 25-08-2023
 =========================================

@@ -223,7 +223,7 @@ delete_messages (gpointer data)
 static void
 pop_message (GtkWidget *status)
 {
-  GList *messages = (GList *) g_object_get_data (G_OBJECT (status), "messages");
+  GList *messages = (GList *) g_object_steal_data (G_OBJECT (status), "messages");

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

  gtk_label_set_label (GTK_LABEL (status), message);
  messages = g_list_prepend (messages, g_strdup (message));
@@ -74,14 +74,7 @@ create_blurred_button (void)
 static GtkWidget *
 create_font_button (void)
 {
-  GtkFontDialog *dialog;
-  GtkWidget *button;
-
-  dialog = gtk_font_dialog_new ();
-  button = gtk_font_dialog_button_new (dialog);
-  g_object_unref (dialog);
-
-  return button;
+  return gtk_font_dialog_button_new (gtk_font_dialog_new ());
 }

 static GtkWidget *
@@ -2,10 +2,13 @@
 *
 * This demo shows how to use GskPath to draw shapes that are (a bit)
 * more complex than a rounded rectangle.
+ *
+ * It also demonstrates printing to a stream with GtkPrintDialog.
 */

 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
+#include <cairo-pdf.h>

 #include "paintable.h"

@@ -165,6 +168,89 @@ gtk_logo_paintable_new (void)
  return GDK_PAINTABLE (self);
 }

+static cairo_status_t
+write_cairo (void                *closure,
+             const unsigned char *data,
+             unsigned int         length)
+{
+  GOutputStream *stream = closure;
+  gsize written;
+  GError *error = NULL;
+
+  if (!g_output_stream_write_all (stream, data, length, &written, NULL, &error))
+    {
+      g_print ("Error writing pdf stream: %s\n", error->message);
+      g_error_free (error);
+      return CAIRO_STATUS_WRITE_ERROR;
+    }
+
+  return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+print_ready (GObject      *source,
+             GAsyncResult *result,
+             gpointer      data)
+{
+  GtkPrintDialog *dialog = GTK_PRINT_DIALOG (source);
+  GError *error = NULL;
+  GOutputStream *stream;
+  GtkSnapshot *snapshot;
+  GdkPaintable *paintable;
+  GskRenderNode *node;
+  cairo_surface_t *surface;
+  cairo_t *cr;
+
+  stream = gtk_print_dialog_print_finish (dialog, result, &error);
+  if (stream == NULL)
+    {
+      g_print ("Failed to get output stream: %s\n", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  snapshot = gtk_snapshot_new ();
+  paintable = gtk_picture_get_paintable (GTK_PICTURE (data));
+  gdk_paintable_snapshot (paintable, snapshot, 100, 100);
+  node = gtk_snapshot_free_to_node (snapshot);
+
+  surface = cairo_pdf_surface_create_for_stream (write_cairo, stream, 100, 100);
+  cr = cairo_create (surface);
+
+  gsk_render_node_draw (node, cr);
+
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+  gsk_render_node_unref (node);
+
+  if (!g_output_stream_close (stream, NULL, &error))
+    {
+      g_print ("Error from close: %s\n", error->message);
+      g_error_free (error);
+    }
+
+  g_object_unref (stream);
+}
+
+static void
+print (GtkButton *button,
+       gpointer   data)
+{
+  GtkWidget *picture = data;
+  GtkPrintDialog *dialog;
+
+  dialog = gtk_print_dialog_new ();
+
+  gtk_print_dialog_print (dialog,
+                          GTK_WINDOW (gtk_widget_get_root (picture)),
+                          NULL,
+                          NULL,
+                          print_ready,
+                          picture);
+
+  g_object_unref (dialog);
+}
+
 GtkWidget *
 do_path_fill (GtkWidget *do_widget)
 {
@@ -172,12 +258,21 @@ do_path_fill (GtkWidget *do_widget)

  if (!window)
    {
+      GtkWidget *header, *button, *label;
      GtkWidget *picture;
      GdkPaintable *paintable;

      window = gtk_window_new ();
-      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+      gtk_window_set_default_size (GTK_WINDOW (window), 100, 100);
      gtk_window_set_title (GTK_WINDOW (window), "Fill and Stroke");
+      header = gtk_header_bar_new ();
+      button = gtk_button_new_from_icon_name ("printer-symbolic");
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);
+      label = gtk_label_new ("Fill and Stroke");
+      gtk_widget_add_css_class (label, "title");
+      gtk_header_bar_set_title_widget (GTK_HEADER_BAR (header), label);
+      gtk_window_set_titlebar (GTK_WINDOW (window), header);
      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);

      paintable = gtk_logo_paintable_new ();
@@ -186,6 +281,8 @@ do_path_fill (GtkWidget *do_widget)
      gtk_picture_set_can_shrink (GTK_PICTURE (picture), FALSE);
      g_object_unref (paintable);

+      g_signal_connect (button, "clicked", G_CALLBACK (print), picture);
+
      gtk_window_set_child (GTK_WINDOW (window), picture);
    }

@@ -8,6 +8,7 @@
 * is a rather complex path.
 */

+#include "config.h"
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>

@@ -131,6 +132,24 @@ gtk_maze_class_init (GtkMazeClass *klass)
  widget_class->snapshot = gtk_maze_snapshot;
 }

+static void
+celebrate (gboolean win)
+{
+  char *path;
+  GtkMediaStream *stream;
+
+  if (win)
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "complete.oga", NULL);
+  else
+    path = g_build_filename (GTK_DATADIR, "sounds", "freedesktop", "stereo", "suspend-error.oga", NULL);
+  stream = gtk_media_file_new_for_filename (path);
+  gtk_media_stream_set_volume (stream, 1.0);
+  gtk_media_stream_play (stream);
+
+  g_signal_connect (stream, "notify::ended", G_CALLBACK (g_object_unref), NULL);
+  g_free (path);
+}
+
 static void
 pointer_motion (GtkEventControllerMotion *controller,
                double                    x,
@@ -153,6 +172,8 @@ pointer_motion (GtkEventControllerMotion *controller,
        return;
    }

+  celebrate (FALSE);
+
  self->active = FALSE;
  gtk_widget_queue_draw (GTK_WIDGET (self));
 }
@@ -9,6 +9,8 @@

 #include "paintable.h"

+#undef SHOW_CONTROLS
+
 #define GTK_TYPE_SPINNER_PAINTABLE (gtk_spinner_paintable_get_type ())
 G_DECLARE_FINAL_TYPE (GtkSpinnerPaintable, gtk_spinner_paintable, GTK, SPINNER_PAINTABLE, GObject)

@@ -150,6 +152,7 @@ static gboolean
 add_controls (GskPathOperation        op,
              const graphene_point_t *pts,
              gsize                   n_pts,
+              float                   weight,
              gpointer                data)
 {
  GskPathBuilder *builder = data;
@@ -166,7 +169,7 @@ add_controls (GskPathOperation        op,
      break;

    case GSK_PATH_QUAD:
-    case GSK_PATH_ARC:
+    case GSK_PATH_CONIC:
      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
      gsk_path_builder_line_to (builder, pts[2].x, pts[2].y);
      break;
@@ -11,6 +11,8 @@
                <property name="lower">0</property>
                <property name="upper">5000</property>
                <property name="value">500</property>
+                <property name="step-increment">1</property>
+                <property name="page-increment">10</property>
              </object>
            </property>
          </object>
@@ -1,8 +1,9 @@
 /* Pickers and Launchers
- * #Keywords: GtkColorDialog, GtkFontDialog, GtkFileDialog, GtkFileLauncher, GtkUriLauncher
+ * #Keywords: GtkColorDialog, GtkFontDialog, GtkFileDialog, GtkPrintDialog, GtkFileLauncher, GtkUriLauncher
 *
 * The dialogs are mainly intended for use in preference dialogs.
- * They allow to select colors, fonts and applications.
+ * They allow to select colors, fonts and files. There is also a
+ * print dialog.
 *
 * The launchers let you open files or URIs in applications that
 * can handle them.
@@ -11,11 +12,13 @@
 #include <gtk/gtk.h>

 static GtkWidget *app_picker;
+static GtkWidget *print_button;

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

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

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

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

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

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

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

    label = gtk_label_new ("URI:");
    gtk_widget_set_halign (label, GTK_ALIGN_START);
@@ -263,7 +263,7 @@ gdk_parse_debug_var (const char        *variable,
        if (debug_enabled || keys[i].always_enabled)
          fprintf (stderr, "  %s%*s%s\n", keys[i].key, (int)(max_width - strlen (keys[i].key)), " ", keys[i].help);
      }
-      fprintf (stderr, "  %s%*s%s\n", "all", max_width - 3, " ", "Enable all values");
+      fprintf (stderr, "  %s%*s%s\n", "all", max_width - 3, " ", "Enable all values. Other given values are subtracted");
      fprintf (stderr, "  %s%*s%s\n", "help", max_width - 4, " ", "Print this help");
      fprintf (stderr, "\nMultiple values can be given, separated by : or space.\n");
    }
@@ -42,6 +42,8 @@
 #include <gdk/gdkdevicetool.h>
 #include <gdk/gdkdisplay.h>
 #include <gdk/gdkdisplaymanager.h>
+#include <gdk/gdkdmabuftexture.h>
+#include <gdk/gdkdmabuftexturebuilder.h>
 #include <gdk/gdkdrag.h>
 #include <gdk/gdkdragsurface.h>
 #include <gdk/gdkdragsurfacesize.h>
@@ -82,6 +82,18 @@ gdk_array(init) (GdkArray *self)
 #endif
 }

+G_GNUC_UNUSED static inline gsize
+gdk_array(get_capacity) (const GdkArray *self)
+{
+  return self->end_allocation - self->start;
+}
+
+G_GNUC_UNUSED static inline gsize
+gdk_array(get_size) (const GdkArray *self)
+{
+  return self->end - self->start;
+}
+
 static inline void
 gdk_array(free_elements) (_T_ *start,
                          _T_ *end)
@@ -110,6 +122,38 @@ gdk_array(clear) (GdkArray *self)
  gdk_array(init) (self);
 }

+/*
+ * gdk_array_steal:
+ * @self: the array
+ *
+ * Steals all data in the array and clears the array.
+ *
+ * If you need to know the size of the data, you should query it
+ * beforehand.
+ *
+ * Returns: The array's data
+ **/
+G_GNUC_UNUSED static inline _T_ *
+gdk_array(steal) (GdkArray *self)
+{
+  _T_ *result;
+
+#ifdef GDK_ARRAY_PREALLOC
+  if (self->start == self->preallocated)
+    {
+      gsize size = GDK_ARRAY_REAL_SIZE (gdk_array(get_size) (self));
+      result = g_new (_T_, size);
+      memcpy (result, self->preallocated, sizeof (_T_) * size);
+    }
+  else
+#endif
+    result = self->start;
+
+  gdk_array(init) (self);
+
+  return result;
+}
+
 G_GNUC_UNUSED static inline _T_ *
 gdk_array(get_data) (const GdkArray *self)
 {
@@ -123,18 +167,6 @@ gdk_array(index) (const GdkArray *self,
  return self->start + pos;
 }

-G_GNUC_UNUSED static inline gsize
-gdk_array(get_capacity) (const GdkArray *self)
-{
-  return self->end_allocation - self->start;
-}
-
-G_GNUC_UNUSED static inline gsize
-gdk_array(get_size) (const GdkArray *self)
-{
-  return self->end - self->start;
-}
-
 G_GNUC_UNUSED static inline gboolean
 gdk_array(is_empty) (const GdkArray *self)
 {
@@ -151,7 +183,7 @@ gdk_array(reserve) (GdkArray *self,
    return;

  size = gdk_array(get_size) (self);
-  new_size = 1 << g_bit_storage (MAX (GDK_ARRAY_REAL_SIZE (n), 16) - 1);
+  new_size = ((gsize) 1) << g_bit_storage (MAX (GDK_ARRAY_REAL_SIZE (n), 16) - 1);

 #ifdef GDK_ARRAY_PREALLOC
  if (self->start == self->preallocated)
@@ -286,3 +318,5 @@ gdk_array(get) (const GdkArray *self,
 #undef GDK_ARRAY_TYPE_NAME
 #undef GDK_ARRAY_NO_MEMSET
 #endif
+
+G_END_DECLS
@@ -37,6 +37,7 @@
 #include "gdkmonitorprivate.h"
 #include "gdkrectangle.h"
 #include "gdkvulkancontext.h"
+#include "gdkdmabuftextureprivate.h"

 #ifdef HAVE_EGL
 #include <epoxy/egl.h>
@@ -404,6 +405,8 @@ gdk_display_finalize (GObject *object)

  g_list_free_full (display->seats, g_object_unref);

+  g_free (display->egl_dmabuf_formats);
+
  G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object);
 }

@@ -473,8 +476,7 @@ gdk_display_get_event (GdkDisplay *display)
 * @display: a `GdkDisplay`
 * @event: (transfer none): a `GdkEvent`
 *
- * Appends the given event onto the front of the event
- * queue for @display.
+ * Adds the given event to the event queue for @display.
 *
 * Deprecated: 4.10: This function is only useful in very
 * special situations and should not be used by applications.
@@ -1260,6 +1262,68 @@ gdk_display_create_vulkan_context (GdkDisplay  *self,
                         NULL);
 }

+/* To support a drm format, we must be able to import it into GL
+ * using the relevant EGL extensions, and download it into a memory
+ * texture, possibly doing format conversion with shaders (in GSK).
+ */
+static void
+init_dmabuf_formats (GdkDisplay *self)
+{
+  GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
+
+  if (priv->egl_display != EGL_NO_DISPLAY)
+    {
+      int num_formats;
+      int *formats;
+      GArray *array;
+
+      eglQueryDmaBufFormatsEXT (priv->egl_display, 0, NULL, &num_formats);
+      formats = g_new (int, num_formats);
+      eglQueryDmaBufFormatsEXT (priv->egl_display, num_formats, formats, &num_formats);
+
+      array = g_array_new (FALSE, FALSE, sizeof (GdkDmabufFormat));
+
+      for (int i = 0; i < num_formats; i++)
+        {
+          int num_modifiers;
+          uint64_t *modifiers;
+          unsigned int *external_only;
+
+          if (!gdk_dmabuf_texture_may_support ((unsigned int)formats[i]))
+            continue;
+
+          eglQueryDmaBufModifiersEXT (priv->egl_display, formats[i], 0, NULL, NULL, &num_modifiers);
+          modifiers = g_new (uint64_t, num_modifiers);
+          external_only = g_new (unsigned int, num_modifiers);
+          eglQueryDmaBufModifiersEXT (priv->egl_display, formats[i], num_modifiers, modifiers, external_only, &num_modifiers);
+
+          if (num_modifiers == 0)
+            g_array_append_val (array, ((GdkDmabufFormat){ formats[i], 0 }));
+          else
+            {
+              for (int j = 0; j < num_modifiers; j++)
+                g_array_append_val (array, ((GdkDmabufFormat){ formats[i], modifiers[j] }));
+            }
+
+          g_free (modifiers);
+        }
+
+      g_free (formats);
+
+      self->egl_dmabuf_n_formats = array->len;
+      self->egl_dmabuf_formats = (GdkDmabufFormat *) g_array_free (array, FALSE);
+    }
+
+  GDK_DEBUG (MISC, "Supported EGL dmabuf formats: (%lu)", self->egl_dmabuf_n_formats);
+  for (gsize i = 0; i < self->egl_dmabuf_n_formats; i++)
+    {
+      uint32_t f = self->egl_dmabuf_formats[i].fourcc;
+      uint64_t m = self->egl_dmabuf_formats[i].modifier;
+
+      GDK_DEBUG (MISC, "  %c%c%c%c:%#lx", f & 0xff, (f >> 8) & 0xff, (f >> 16) & 0xff, (f >> 24) & 0xff, m);
+    }
+}
+
 static void
 gdk_display_init_gl (GdkDisplay *self)
 {
@@ -1301,6 +1365,10 @@ gdk_display_init_gl (GdkDisplay *self)
  gdk_gl_backend_use (GDK_GL_CONTEXT_GET_CLASS (context)->backend_type);

  gdk_profiler_end_mark (before, "initialize OpenGL", NULL);
+
+  gdk_gl_context_make_current (context);
+
+  init_dmabuf_formats (self);
 }

 /**
@@ -1825,6 +1893,43 @@ gdk_display_get_egl_display (GdkDisplay *self)
 #endif
 }

+/**
+ * GdkDmabufFormat:
+ * @fourcc: the format code
+ * @modifiers: the format modifier
+ *
+ * The `GdkDmabufFormat` struct represents a dma-buf format
+ * as defined in the `drm_fourcc.h` header.
+ *
+ * Since: 4.14
+ */
+
+/**
+ * gdk_display_get_dmabuf_formats:
+ * @display: a `GdkDisplay`
+ * @n_formats: return location for the number of formats
+ *
+ * Returns the dma-buf formats that are supported on this display.
+ *
+ * Note that GTK uses EGL to convert some formats, so the list
+ * of supported formats depends on the GL API that is used on
+ * the display.
+ *
+ * Returns: (transfer none): an array of `GdkDmabufFormat` structs.
+ *   The length of the array is returned in @n_formats
+ *
+ * Since: 4.14
+ */
+const GdkDmabufFormat *
+gdk_display_get_dmabuf_formats (GdkDisplay *display,
+                                gsize      *n_formats)
+{
+  gdk_display_prepare_gl (display, NULL);
+
+  *n_formats = display->egl_dmabuf_n_formats;
+  return display->egl_dmabuf_formats;
+}
+
 GdkDebugFlags
 gdk_display_get_debug_flags (GdkDisplay *display)
 {
@@ -134,6 +134,17 @@ gboolean     gdk_display_get_setting (GdkDisplay *display,
                                      const char *name,
                                      GValue     *value);

+typedef struct
+{
+  uint32_t fourcc;
+  uint64_t modifier;
+} GdkDmabufFormat;
+
+GDK_AVAILABLE_IN_4_14
+const GdkDmabufFormat *
+             gdk_display_get_dmabuf_formats (GdkDisplay *display,
+                                             gsize      *n_formats);
+
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDisplay, g_object_unref)

 G_END_DECLS
@@ -113,6 +113,9 @@ struct _GdkDisplay
  guint have_egl_buffer_age : 1;
  guint have_egl_no_config_context : 1;
  guint have_egl_pixel_format_float : 1;
+
+  GdkDmabufFormat *egl_dmabuf_formats;
+  gsize egl_dmabuf_n_formats;
 };

 struct _GdkDisplayClass
@@ -0,0 +1,397 @@
+/* gdkdmabuftexture.c
+ *
+ * Copyright 2023  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 "config.h"
+
+#include "gdkdmabuftextureprivate.h"
+
+#ifndef __linux__
+
+GType
+gdk_dmabuf_texture_get_type (void)
+{
+  return G_TYPE_INVALID;
+}
+
+#else
+
+#include "gdkdisplayprivate.h"
+#include "gdkmemoryformatprivate.h"
+#include "gdkmemorytextureprivate.h"
+#include <gdk/gdkglcontext.h>
+#include <gdk/gdkgltexturebuilder.h>
+#include <gdk/gdktexturedownloader.h>
+#include <gsk/gsk.h>
+#include <gsk/gl/gskglrenderer.h>
+
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <linux/dma-buf.h>
+#include <drm/drm_fourcc.h>
+#include <epoxy/egl.h>
+
+/**
+ * GdkDmabufTexture:
+ *
+ * A `GdkTexture` representing a dma-buf object.
+ *
+ * To create a `GdkDmabufTexture`, use the auxiliary
+ * [class@Gdk.DmabufTextureBuilder] object.
+ *
+ * Dma-buf textures can only be created on Linux.
+ */
+
+struct _GdkDmabufTexture
+{
+  GdkTexture parent_instance;
+
+  GdkDisplay *display;
+
+  unsigned int fourcc;
+  guint64 modifier;
+
+  unsigned int n_planes;
+
+  /* Per-plane properties */
+  int fds[4];
+  unsigned int strides[4];
+  unsigned int offsets[4];
+
+  GDestroyNotify destroy;
+  gpointer data;
+};
+
+struct _GdkDmabufTextureClass
+{
+  GdkTextureClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkDmabufTexture, gdk_dmabuf_texture, GDK_TYPE_TEXTURE)
+
+static void
+gdk_dmabuf_texture_dispose (GObject *object)
+{
+  GdkDmabufTexture *self = GDK_DMABUF_TEXTURE (object);
+
+  if (self->destroy)
+    self->destroy (self->data);
+
+  G_OBJECT_CLASS (gdk_dmabuf_texture_parent_class)->dispose (object);
+}
+
+typedef struct _GdkDrmFormatInfo GdkDrmFormatInfo;
+struct _GdkDrmFormatInfo
+{
+  unsigned int fourcc;
+  GdkMemoryFormat memory_format;
+  gboolean requires_gl;
+};
+
+static GdkDrmFormatInfo supported_formats[] = {
+  { DRM_FORMAT_RGB888, GDK_MEMORY_R8G8B8, FALSE },
+  { DRM_FORMAT_BGR888, GDK_MEMORY_B8G8R8, FALSE },
+  { DRM_FORMAT_ARGB8888, GDK_MEMORY_A8R8G8B8_PREMULTIPLIED, FALSE },
+  { DRM_FORMAT_RGBA8888, GDK_MEMORY_R8G8B8A8_PREMULTIPLIED, FALSE },
+  { DRM_FORMAT_BGRA8888, GDK_MEMORY_B8G8R8A8_PREMULTIPLIED, FALSE },
+  { DRM_FORMAT_ABGR16161616F, GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED, FALSE },
+  { DRM_FORMAT_YUYV, GDK_MEMORY_DEFAULT, TRUE },
+  { DRM_FORMAT_NV12, GDK_MEMORY_DEFAULT, TRUE },
+  { DRM_FORMAT_P010, GDK_MEMORY_R16G16B16A16_PREMULTIPLIED, TRUE },
+  { DRM_FORMAT_YUV420, GDK_MEMORY_DEFAULT, TRUE },
+};
+
+static GdkDrmFormatInfo *
+get_drm_format_info (unsigned int fourcc)
+{
+  for (int i = 0; i < G_N_ELEMENTS (supported_formats); i++)
+    {
+      if (supported_formats[i].fourcc == fourcc)
+        return &supported_formats[i];
+    }
+
+  return NULL;
+}
+
+gboolean
+gdk_dmabuf_texture_may_support (unsigned int fourcc)
+{
+  return get_drm_format_info (fourcc) != NULL;
+}
+
+static void
+do_indirect_download (GdkDmabufTexture *self,
+                      GdkMemoryFormat  format,
+                      guchar          *data,
+                      gsize            stride)
+{
+  GskRenderer *renderer;
+  int width, height;
+  GskRenderNode *node;
+  GdkTexture *gl_texture;
+  GdkTextureDownloader *downloader;
+  GError *error = NULL;
+
+  GDK_DEBUG (MISC, "Using gsk_renderer_render_texture import for downloading a dmabuf");
+
+  g_assert (GDK_IS_DISPLAY (self->display));
+  g_assert (GDK_IS_GL_CONTEXT (gdk_display_get_gl_context (self->display)));
+
+  renderer = gsk_gl_renderer_new ();
+  if (!gsk_renderer_realize (renderer,  NULL, &error))
+    {
+      g_warning ("Failed to realize GL renderer: %s", error->message);
+      g_error_free (error);
+      g_object_unref (renderer);
+      return;
+    }
+
+  width = gdk_texture_get_width (GDK_TEXTURE (self));
+  height = gdk_texture_get_height (GDK_TEXTURE (self));
+
+  node = gsk_texture_node_new (GDK_TEXTURE (self), &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gl_texture = gsk_renderer_render_texture (renderer, node, &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gsk_render_node_unref (node);
+
+  gsk_renderer_unrealize (renderer);
+  g_object_unref (renderer);
+
+  downloader = gdk_texture_downloader_new (gl_texture);
+
+  gdk_texture_downloader_set_format (downloader, format);
+
+  gdk_texture_downloader_download_into (downloader, data, stride);
+
+  gdk_texture_downloader_free (downloader);
+  g_object_unref (gl_texture);
+}
+
+static void
+do_direct_download (GdkDmabufTexture *self,
+                    guchar           *data,
+                    gsize             stride)
+{
+  gsize size;
+  unsigned int height;
+  gsize src_stride;
+  guchar *src_data;
+  int bpp;
+
+  GDK_DEBUG (MISC, "Using mmap() and memcpy() for downloading a dmabuf");
+
+  height = gdk_texture_get_height (GDK_TEXTURE (self));
+  bpp = gdk_memory_format_bytes_per_pixel (gdk_texture_get_format (GDK_TEXTURE (self)));
+
+  src_stride = self->strides[0];
+  size = self->strides[0] * height;
+
+  if (ioctl (self->fds[0], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_START|DMA_BUF_SYNC_READ }) < 0)
+    g_warning ("Failed to sync dma-buf: %s", g_strerror (errno));
+
+  src_data = mmap (NULL, size, PROT_READ, MAP_SHARED, self->fds[0], self->offsets[0]);
+
+  if (stride == src_stride)
+    memcpy (data, src_data, size);
+  else
+    {
+      for (unsigned int i = 0; i < height; i++)
+        memcpy (data + i * stride, src_data + i * src_stride, height * bpp);
+    }
+
+  if (ioctl (self->fds[0], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync) { DMA_BUF_SYNC_END|DMA_BUF_SYNC_READ }) < 0)
+    g_warning ("Failed to sync dma-buf: %s", g_strerror (errno));
+
+  munmap (src_data, size);
+}
+
+static void
+gdk_dmabuf_texture_download (GdkTexture      *texture,
+                             GdkMemoryFormat  format,
+                             guchar          *data,
+                             gsize            stride)
+{
+  GdkDmabufTexture *self = GDK_DMABUF_TEXTURE (texture);
+  GdkMemoryFormat src_format = gdk_texture_get_format (texture);
+  GdkDrmFormatInfo *info;
+
+  info = get_drm_format_info (self->fourcc);
+
+  if (info->requires_gl || self->n_planes > 1)
+    do_indirect_download (self, format, data, stride);
+  else if (format == src_format)
+    do_direct_download (self, data, stride);
+  else
+    {
+      unsigned int width, height;
+      guchar *src_data;
+      gsize src_stride;
+
+      width = gdk_texture_get_width (texture);
+      height = gdk_texture_get_height (texture);
+
+      src_stride = self->strides[0];
+      src_data = g_new (guchar, src_stride * height);
+
+      do_direct_download (self, src_data, src_stride);
+
+      gdk_memory_convert (data, stride, format,
+                          src_data, src_stride, src_format,
+                          width, height);
+
+      g_free (src_data);
+    }
+}
+
+static void
+gdk_dmabuf_texture_class_init (GdkDmabufTextureClass *klass)
+{
+  GdkTextureClass *texture_class = GDK_TEXTURE_CLASS (klass);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  texture_class->download = gdk_dmabuf_texture_download;
+
+  gobject_class->dispose = gdk_dmabuf_texture_dispose;
+}
+
+static void
+gdk_dmabuf_texture_init (GdkDmabufTexture *self)
+{
+  self->fds[0] = self->fds[1] = self->fds[2] = self->fds[3] = -1;
+}
+
+static gboolean
+display_supports_format (GdkDisplay   *display,
+                         unsigned int  fourcc,
+                         guint64       modifier)
+{
+  const GdkDmabufFormat *formats;
+  gsize n_formats;
+
+  if (!display)
+    return FALSE;
+
+  formats = gdk_display_get_dmabuf_formats (display, &n_formats);
+
+  for (gsize i = 0; i < n_formats; i++)
+    {
+      if (formats[i].fourcc == fourcc &&
+          formats[i].modifier == modifier)
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+GdkTexture *
+gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
+                                     GDestroyNotify           destroy,
+                                     gpointer                 data)
+{
+  GdkDmabufTexture *self;
+  GdkTexture *update_texture;
+  GdkDisplay *display = gdk_dmabuf_texture_builder_get_display (builder);
+  uint32_t fourcc = gdk_dmabuf_texture_builder_get_fourcc (builder);
+  uint64_t modifier = gdk_dmabuf_texture_builder_get_modifier (builder);
+  unsigned int n_planes = gdk_dmabuf_texture_builder_get_n_planes (builder);
+  GdkDrmFormatInfo *info;
+
+  info = get_drm_format_info (fourcc);
+
+  if (!info ||
+      ((info->requires_gl || n_planes > 1) && !display_supports_format (display, fourcc, modifier)))
+    {
+      g_warning ("Unsupported dmabuf format %c%c%c%c:%#lx",
+                 fourcc & 0xff, (fourcc >> 8) & 0xff, (fourcc >> 16) & 0xff, (fourcc >> 24) & 0xff, modifier);
+      return NULL;
+    }
+
+  GDK_DEBUG (MISC, "Dmabuf texture in format %c%c%c%c:%#lx",
+             fourcc & 0xff, (fourcc >> 8) & 0xff, (fourcc >> 16) & 0xff, (fourcc >> 24) & 0xff, modifier);
+
+  self = g_object_new (GDK_TYPE_DMABUF_TEXTURE,
+                       "width", gdk_dmabuf_texture_builder_get_width (builder),
+                       "height", gdk_dmabuf_texture_builder_get_height (builder),
+                       NULL);
+
+  GDK_TEXTURE (self)->format = info->memory_format;
+
+  g_set_object (&self->display, display);
+
+  self->fourcc = fourcc;
+  self->modifier = modifier;
+  self->n_planes = n_planes;
+
+  memcpy (self->fds, gdk_dmabuf_texture_builder_get_fds (builder), sizeof (int) * 4);
+  memcpy (self->strides, gdk_dmabuf_texture_builder_get_strides (builder), sizeof (unsigned int) * 4);
+  memcpy (self->offsets, gdk_dmabuf_texture_builder_get_offsets (builder), sizeof (unsigned int) * 4);
+
+  update_texture = gdk_dmabuf_texture_builder_get_update_texture (builder);
+  if (update_texture)
+    {
+      cairo_region_t *update_region = gdk_dmabuf_texture_builder_get_update_region (builder);
+      if (update_region)
+        {
+          update_region = cairo_region_copy (update_region);
+          cairo_region_intersect_rectangle (update_region,
+                                            &(cairo_rectangle_int_t) {
+                                              0, 0,
+                                              update_texture->width, update_texture->height
+                                            });
+          gdk_texture_set_diff (GDK_TEXTURE (self), update_texture, update_region);
+        }
+    }
+
+  return GDK_TEXTURE (self);
+}
+
+unsigned int
+gdk_dmabuf_texture_get_fourcc (GdkDmabufTexture *texture)
+{
+  return texture->fourcc;
+}
+
+guint64
+gdk_dmabuf_texture_get_modifier (GdkDmabufTexture *texture)
+{
+  return texture->modifier;
+}
+
+unsigned int
+gdk_dmabuf_texture_get_n_planes (GdkDmabufTexture *texture)
+{
+  return texture->n_planes;
+}
+
+int *
+gdk_dmabuf_texture_get_fds (GdkDmabufTexture *texture)
+{
+  return texture->fds;
+}
+
+unsigned int *
+gdk_dmabuf_texture_get_strides (GdkDmabufTexture *texture)
+{
+  return texture->strides;
+}
+
+unsigned int *
+gdk_dmabuf_texture_get_offsets (GdkDmabufTexture *texture)
+{
+  return texture->offsets;
+}
+
+#endif /* __linux__ */
@@ -0,0 +1,43 @@
+/* gdkdmabuftexture.h
+ *
+ * Copyright 2023 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/>.
+ */
+
+#pragma once
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#include <gdk/gdktypes.h>
+#include <gdk/gdktexture.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_DMABUF_TEXTURE (gdk_dmabuf_texture_get_type ())
+
+#define GDK_DMABUF_TEXTURE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_DMABUF_TEXTURE, GdkDmabufTexture))
+#define GDK_IS_DMABUF_TEXTURE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_DMABUF_TEXTURE))
+
+typedef struct _GdkDmabufTexture            GdkDmabufTexture;
+typedef struct _GdkDmabufTextureClass       GdkDmabufTextureClass;
+
+GDK_AVAILABLE_IN_4_14
+GType                   gdk_dmabuf_texture_get_type                (void) G_GNUC_CONST;
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDmabufTexture, g_object_unref)
+
+G_END_DECLS
@@ -0,0 +1,115 @@
+/*
+ * Copyright © 2023 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>
+ */
+
+#pragma once
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#include <gdk/gdktypes.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_DMABUF_TEXTURE_BUILDER (gdk_dmabuf_texture_builder_get_type ())
+GDK_AVAILABLE_IN_4_14
+GDK_DECLARE_INTERNAL_TYPE (GdkDmabufTextureBuilder, gdk_dmabuf_texture_builder, GDK, DMABUF_TEXTURE_BUILDER, GObject)
+
+GDK_AVAILABLE_IN_4_14
+GdkDmabufTextureBuilder *gdk_dmabuf_texture_builder_new              (void);
+
+GDK_AVAILABLE_IN_4_14
+GdkDisplay *             gdk_dmabuf_texture_builder_get_display      (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_display      (GdkDmabufTextureBuilder    *self,
+                                                                      GdkDisplay                 *display);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_width        (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_width        (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                width);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_height       (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_height       (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                height);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_fourcc       (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_fourcc       (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                fourcc);
+
+GDK_AVAILABLE_IN_4_14
+guint64                  gdk_dmabuf_texture_builder_get_modifier     (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_modifier     (GdkDmabufTextureBuilder    *self,
+                                                                      guint64                     modifier);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_n_planes     (GdkDmabufTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_n_planes     (GdkDmabufTextureBuilder    *self,
+                                                                      unsigned int                n_planes);
+
+GDK_AVAILABLE_IN_4_14
+int                      gdk_dmabuf_texture_builder_get_fd           (GdkDmabufTextureBuilder    *self,
+                                                                      int                         plane) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_fd           (GdkDmabufTextureBuilder    *self,
+                                                                      int                         plane,
+                                                                      int                         fd);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_stride       (GdkDmabufTextureBuilder    *self,
+                                                                      int                         plane) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_stride       (GdkDmabufTextureBuilder    *self,
+                                                                      int                         plane,
+                                                                      unsigned int                stride);
+
+GDK_AVAILABLE_IN_4_14
+unsigned int             gdk_dmabuf_texture_builder_get_offset       (GdkDmabufTextureBuilder    *self,
+                                                                      int                         plane) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_offset       (GdkDmabufTextureBuilder    *self,
+                                                                      int                         plane,
+                                                                      unsigned int                offset);
+
+GDK_AVAILABLE_IN_4_14
+GdkTexture *             gdk_dmabuf_texture_builder_get_update_texture (GdkDmabufTextureBuilder  *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_update_texture (GdkDmabufTextureBuilder  *self,
+                                                                        GdkTexture               *texture);
+
+GDK_AVAILABLE_IN_4_14
+cairo_region_t *         gdk_dmabuf_texture_builder_get_update_region (GdkDmabufTextureBuilder   *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_14
+void                     gdk_dmabuf_texture_builder_set_update_region (GdkDmabufTextureBuilder   *self,
+                                                                       cairo_region_t            *region);
+
+GDK_AVAILABLE_IN_4_14
+GdkTexture *             gdk_dmabuf_texture_builder_build            (GdkDmabufTextureBuilder    *self,
+                                                                      GDestroyNotify              destroy,
+                                                                      gpointer                    data);
+
+G_END_DECLS
+
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "gdkdmabuftexture.h"
+
+#include "gdkdmabuftexturebuilder.h"
+#include "gdktextureprivate.h"
+
+G_BEGIN_DECLS
+
+int *                   gdk_dmabuf_texture_builder_get_fds      (GdkDmabufTextureBuilder *builder);
+unsigned int *          gdk_dmabuf_texture_builder_get_offsets  (GdkDmabufTextureBuilder *builder);
+unsigned int *          gdk_dmabuf_texture_builder_get_strides  (GdkDmabufTextureBuilder *builder);
+
+GdkTexture *            gdk_dmabuf_texture_new_from_builder (GdkDmabufTextureBuilder *builder,
+                                                             GDestroyNotify           destroy,
+                                                             gpointer                 data);
+
+unsigned int            gdk_dmabuf_texture_get_fourcc   (GdkDmabufTexture *texture);
+guint64                 gdk_dmabuf_texture_get_modifier (GdkDmabufTexture *texture);
+unsigned int            gdk_dmabuf_texture_get_n_planes (GdkDmabufTexture *texture);
+int *                   gdk_dmabuf_texture_get_fds      (GdkDmabufTexture *texture);
+unsigned int *          gdk_dmabuf_texture_get_offsets  (GdkDmabufTexture *texture);
+unsigned int *          gdk_dmabuf_texture_get_strides  (GdkDmabufTexture *texture);
+
+gboolean                gdk_dmabuf_texture_may_support  (unsigned int      fourcc);
+
+
+G_END_DECLS
+
@@ -1715,6 +1715,56 @@ gdk_gl_context_get_version (GdkGLContext *context,
    *minor = gdk_gl_version_get_minor (&priv->gl_version);
 }

+const char *
+gdk_gl_context_get_glsl_version_string (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  if (priv->api == GDK_GL_API_GL)
+    {
+      if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 6)))
+        return "#version 460";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 5)))
+        return "#version 450";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 4)))
+        return "#version 440";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 3)))
+        return "#version 430";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 2)))
+        return "#version 420";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 1)))
+        return "#version 410";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 0)))
+        return "#version 400";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 3)))
+        return "#version 330";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
+        return "#version 150";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 1)))
+        return "#version 140";
+      else
+        return "#version 130";
+    }
+  else if (priv->api == GDK_GL_API_GLES)
+    {
+      if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
+        return "#version 320 es";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 1)))
+        return "#version 310 es";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
+        return "#version 300 es";
+      else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
+        return "#version 300 es";
+      else
+        return "#version 100";
+    }
+  else
+    {
+      /* must be realized to be called */
+      g_assert_not_reached ();
+    }
+}
+
 /**
 * gdk_gl_context_clear_current:
 *
@@ -147,6 +147,8 @@ void                    gdk_gl_context_label_object_printf      (GdkGLContext
                                                                 const char      *format,
                                                                ...)  G_GNUC_PRINTF (4, 5);

+const char *            gdk_gl_context_get_glsl_version_string  (GdkGLContext    *self);
+
 gboolean                gdk_gl_context_has_debug                (GdkGLContext    *self) G_GNUC_PURE;

 gboolean                gdk_gl_context_use_es_bgra              (GdkGLContext    *context);
@@ -24,13 +24,16 @@
 #include "gdksnapshotprivate.h"
 #include "gdkprivate.h"

+#include <graphene.h>
+
 /* HACK: So we don't need to include any (not-yet-created) GSK or GTK headers */
 GdkSnapshot *   gtk_snapshot_new                        (void);
 void            gtk_snapshot_push_debug                 (GdkSnapshot            *snapshot,
                                                         const char             *message,
                                                         ...) G_GNUC_PRINTF (2, 3);
 void            gtk_snapshot_pop                        (GdkSnapshot            *snapshot);
-GdkPaintable *  gtk_snapshot_free_to_paintable          (GdkSnapshot            *snapshot);
+GdkPaintable *  gtk_snapshot_free_to_paintable          (GdkSnapshot            *snapshot,
+                                                         const graphene_size_t  *size);

 /**
 * GdkPaintable:
@@ -118,7 +121,7 @@ gdk_paintable_default_get_current_image (GdkPaintable *paintable)

  snapshot = gtk_snapshot_new ();
  gdk_paintable_snapshot (paintable, snapshot, width, height);
-  return gtk_snapshot_free_to_paintable (snapshot);
+  return gtk_snapshot_free_to_paintable (snapshot, NULL);
 }

 static GdkPaintableFlags
@@ -254,7 +254,7 @@ maybe_flip_position (int       bounds_pos,
  *flipped = TRUE;
  secondary = rect_pos + (1 - rect_sign) * rect_size / 2 - offset - (1 - surface_sign) * surface_size / 2;

-  if (secondary >= bounds_pos && secondary + surface_size <= bounds_pos + bounds_size)
+  if ((secondary >= bounds_pos && secondary + surface_size <= bounds_pos + bounds_size) || primary > bounds_pos + bounds_size)
    return secondary;

  *flipped = FALSE;
@@ -345,7 +345,9 @@ gdk_texture_init (GdkTexture *self)
 *
 * Creates a new texture object representing the surface.
 *
- * @surface must be an image surface with format `CAIRO_FORMAT_ARGB32`.
+ * The @surface must be an image surface with format `CAIRO_FORMAT_ARGB32`.
+ *
+ * The newly created texture will acquire a reference on the @surface.
 *
 * Returns: a new `GdkTexture`
 */
@@ -364,7 +366,7 @@ gdk_texture_new_for_surface (cairo_surface_t *surface)
                                      * cairo_image_surface_get_stride (surface),
                                      (GDestroyNotify) cairo_surface_destroy,
                                      cairo_surface_reference (surface));
-  
+
  texture = gdk_memory_texture_new (cairo_image_surface_get_width (surface),
                                    cairo_image_surface_get_height (surface),
                                    GDK_MEMORY_DEFAULT,
@@ -819,7 +821,7 @@ gdk_texture_set_render_data (GdkTexture     *self,
                             GDestroyNotify  notify)
 {
  g_return_val_if_fail (data != NULL, FALSE);
- 
+
  if (self->render_key != NULL)
    return FALSE;

@@ -1408,8 +1408,11 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
                                                    },
                                                    .enabledExtensionCount = device_extensions->len,
                                                    .ppEnabledExtensionNames = (const char * const *) device_extensions->pdata,
-                                                    .pNext = &(VkPhysicalDeviceDescriptorIndexingFeatures) {
-                                                      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
+                                                    .pNext = &(VkPhysicalDeviceVulkan12Features) {
+                                                      .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
+                                                      .shaderSampledImageArrayNonUniformIndexing = VK_TRUE,
+                                                      .shaderStorageBufferArrayNonUniformIndexing = VK_TRUE,
+                                                      .descriptorIndexing = VK_TRUE,
                                                      .descriptorBindingPartiallyBound = VK_TRUE,
                                                      .descriptorBindingVariableDescriptorCount = VK_TRUE,
                                                      .descriptorBindingSampledImageUpdateAfterBind = VK_TRUE,
@@ -1553,7 +1556,7 @@ gdk_display_create_vulkan_instance (GdkDisplay  *display,
                                                 .applicationVersion = 0,
                                                 .pEngineName = "GTK",
                                                 .engineVersion = VK_MAKE_VERSION (GDK_MAJOR_VERSION, GDK_MINOR_VERSION, GDK_MICRO_VERSION),
-                                                 .apiVersion = VK_API_VERSION_1_0
+                                                 .apiVersion = VK_API_VERSION_1_2
                                             },
                                             .enabledLayerCount = used_layers->len,
                                             .ppEnabledLayerNames = (const char * const *) used_layers->pdata,
@@ -188,6 +188,14 @@ copy_surface_data (GdkMacosBuffer       *from,
    }
 }

+static void
+clamp_region_to_surface (cairo_region_t *region,
+                         GdkSurface     *surface)
+{
+  cairo_rectangle_int_t rectangle = {0, 0, surface->width, surface->height};
+  cairo_region_intersect_rectangle (region, &rectangle);
+}
+
 static void
 _gdk_macos_cairo_context_begin_frame (GdkDrawContext *draw_context,
                                      GdkMemoryDepth  depth,
@@ -205,6 +213,8 @@ _gdk_macos_cairo_context_begin_frame (GdkDrawContext *draw_context,
  surface = GDK_MACOS_SURFACE (gdk_draw_context_get_surface (draw_context));
  buffer = _gdk_macos_surface_get_buffer (surface);

+  clamp_region_to_surface (region, GDK_SURFACE (surface));
+
  _gdk_macos_buffer_set_damage (buffer, region);
  _gdk_macos_buffer_set_flipped (buffer, FALSE);

@@ -90,7 +90,7 @@ struct _GdkMacosDisplay
  /* Note if we have a key window that is not a GdkMacosWindow
   * such as a NSPanel used for native dialogs.
   */
-  guint key_window_is_foregin : 1;
+  guint key_window_is_foreign : 1;
 };

 struct _GdkMacosDisplayClass
@@ -424,7 +424,7 @@ select_key_in_idle_cb (gpointer data)
  self->select_key_in_idle = 0;

  /* Don't steal focus from NSPanel, etc */
-  if (self->key_window_is_foregin)
+  if (self->key_window_is_foreign)
    return G_SOURCE_REMOVE;

  if (self->keyboard_surface == NULL)
@@ -941,7 +941,7 @@ _gdk_macos_display_get_surfaces (GdkMacosDisplay *self)
      NSArray *array = [NSApp orderedWindows];
      GQueue sorted = G_QUEUE_INIT;

-      self->key_window_is_foregin = FALSE;
+      self->key_window_is_foreign = FALSE;

      for (id obj in array)
        {
@@ -949,7 +949,7 @@ _gdk_macos_display_get_surfaces (GdkMacosDisplay *self)
          GdkMacosSurface *surface;

          if ([nswindow isKeyWindow])
-            self->key_window_is_foregin = !GDK_IS_MACOS_WINDOW (nswindow);
+            self->key_window_is_foreign = !GDK_IS_MACOS_WINDOW (nswindow);

          if (!GDK_IS_MACOS_WINDOW (nswindow))
            continue;
--- a/Show More
+++ b/Show More