Add a test for changing content

This is meant to produce lots of widget that all share the
same CSS and size, and frequently change content.

NEWS

@@ -1,6 +1,74 @@
 Overview of Changes in 4.11.2, xx-xx-xxxx
 =========================================
 
+* GtkGLArea:
+ - Add an allowed-apis property
+
+* GtkListBox:
+ - Fix a problem with gtk_list_box_remove_all
+
+* GtkCenterBox:
+ - Add a shrink-center-last property
+
+* GtkButton, GtkMenuButton:
+ - Add a can-shrink property
+
+* GtkPopover:
+ - Fix problems with grabs
+
+* GtkFileChooser:
+ - Fix a problem with removing files
+ - Make the date, time and location columns work
+ - Fix filtering in the save entry popup
+ - A few memory leak fixes
+ - Handle webdav in the pathbar
+
+* Dialogs:
+ - Destroy windows promptly when the async callback finishes
+ - Detect absence of the OpenURI portal and fall back
+
+* Theme:
+ - Add explicit style classes to a number of widgets
+ - Fix some contrast issues in the dark theme
+
+* Accessibility:
+ - Fix alert dialogs in the a11y tree
+
+* Layout:
+ - Some fixes to baseline alignment
+
+* GL:
+ - Add GdkGLTextureBuilder, a more flexible api for creating textures
+ - Ensure that we work with GLES 2
+
+* Vulkan:
+ - More fixes to the experimental Vulkan renderer
+ - Rework glyph caching
+
+* Wayland:
+ - Don't destroy wl_surfaces on hide
+ - Plug leaks of compositor-side resources
+
+* Inspector:
+ - Improve the action list
+ - Fix a crash
+
+* Tools:
+ - gtk4-node-editor: Improve scaling
+ - gtk4-node-editor: Preserve aspect ratio of textures
+ - gtk4-demo: Make the stylus demo work with mice
+
+* Translation updates
+ Bulgarian
+ Chinese (China)
+ Galician
+ Hebrew
+ Polish
+ Portuguese
+ Russian
+ Turkish
+
+
 Overview of Changes in 4.11.1, 03-04-2023
 =========================================
 

README.md

@@ -116,19 +116,12 @@ docs/reference/gtk/html/gtk-building.html
 
 Or [online](https://docs.gtk.org/gtk4/building.html)
 
-Default branch renamed to `main`
---------------------------------
+Building from git
+-----------------
 
-The default development branch of GTK has been renamed to `main`.
-To update your local checkout, use:
-```sh
-git checkout master
-git branch -m master main
-git fetch
-git branch --unset-upstream
-git branch -u origin/main
-git symbolic-ref refs/remotes/origin/HEAD refs/remotes/origin/main
-```
+The GTK sources are hosted on [gitlab.gnome.org](http://gitlab.gnome.org). The main
+development branch is called `main`, and stable branches are named after their minor
+version, for example `gtk-4-10`.
 
 How to report bugs
 ------------------

demos/gtk-demo/dnd.c

@@ -109,15 +109,21 @@ static void
 apply_transform (CanvasItem *item)
 {
   GskTransform *transform;
+  graphene_rect_t bounds;
   double x, y;
 
-  x = gtk_widget_get_allocated_width (item->label) / 2.0;
-  y = gtk_widget_get_allocated_height (item->label) / 2.0;
-  item->r = sqrt (x*x + y*y);
+  /* Add css padding and margin */
+  if (!gtk_widget_compute_bounds (item->label, item->label, &bounds))
+    return;
+
+  x = bounds.size.width / 2.;
+  y = bounds.size.height / 2.;
+
+  item->r = sqrt (x * x + y * y);
 
   transform = gsk_transform_translate (NULL, &(graphene_point_t) { item->r, item->r });
   transform = gsk_transform_rotate (transform, item->angle + item->delta);
-  transform = gsk_transform_translate (transform, &(graphene_point_t) { -x, -y });
+  transform = gsk_transform_translate (transform, &GRAPHENE_POINT_INIT (-x, -y));
 
   gtk_fixed_set_child_transform (GTK_FIXED (item->fixed), item->label, transform);
   gsk_transform_unref (transform);

demos/gtk-demo/fontplane.c

@@ -42,8 +42,8 @@ val_to_xy (GtkFontPlane *plane,
   double u, v;
   int width, height;
 
-  width = gtk_widget_get_allocated_width (GTK_WIDGET (plane));
-  height = gtk_widget_get_allocated_height (GTK_WIDGET (plane));
+  width = gtk_widget_get_width (GTK_WIDGET (plane));
+  height = gtk_widget_get_height (GTK_WIDGET (plane));
 
   u = adjustment_get_normalized_value (plane->width_adj);
   v = adjustment_get_normalized_value (plane->weight_adj);
@@ -62,8 +62,8 @@ plane_snapshot (GtkWidget   *widget,
   cairo_t *cr;
 
   val_to_xy (plane, &x, &y);
-  width = gtk_widget_get_allocated_width (widget);
-  height = gtk_widget_get_allocated_height (widget);
+  width = gtk_widget_get_width (widget);
+  height = gtk_widget_get_height (widget);
 
   cr = gtk_snapshot_append_cairo (snapshot,
                                   &GRAPHENE_RECT_INIT (0, 0, width, height));
@@ -131,8 +131,8 @@ update_value (GtkFontPlane *plane,
   GtkWidget *widget = GTK_WIDGET (plane);
   double u, v;
 
-  u = CLAMP (x * (1.0 / gtk_widget_get_allocated_width (widget)), 0, 1);
-  v = CLAMP (1 - y * (1.0 / gtk_widget_get_allocated_height (widget)), 0, 1);
+  u = CLAMP (x * (1.0 / gtk_widget_get_width (widget)), 0, 1);
+  v = CLAMP (1 - y * (1.0 / gtk_widget_get_height (widget)), 0, 1);
 
   adjustment_set_normalized_value (plane->width_adj, u);
   adjustment_set_normalized_value (plane->weight_adj, v);

demos/gtk-demo/paint.c

@@ -24,6 +24,7 @@ typedef struct
   GdkRGBA draw_color;
   GtkPadController *pad_controller;
   double brush_size;
+  GtkGesture *gesture;
 } DrawingArea;
 
 typedef struct
@@ -260,7 +261,7 @@ drawing_area_apply_stroke (DrawingArea   *area,
                            double         y,
                            double         pressure)
 {
-  if (gdk_device_tool_get_tool_type (tool) == GDK_DEVICE_TOOL_TYPE_ERASER)
+  if (tool && gdk_device_tool_get_tool_type (tool) == GDK_DEVICE_TOOL_TYPE_ERASER)
     {
       cairo_set_line_width (area->cr, 10 * pressure * area->brush_size);
       cairo_set_operator (area->cr, CAIRO_OPERATOR_DEST_OUT);
@@ -311,7 +312,9 @@ stylus_gesture_motion (GtkGestureStylus *gesture,
           drawing_area_apply_stroke (area, tool,
                                      backlog[i].axes[GDK_AXIS_X],
                                      backlog[i].axes[GDK_AXIS_Y],
-                                     backlog[i].axes[GDK_AXIS_PRESSURE]);
+                                     backlog[i].flags & GDK_AXIS_FLAG_PRESSURE
+                                        ? backlog[i].axes[GDK_AXIS_PRESSURE]
+                                        : 1);
         }
 
       g_free (backlog);
@@ -341,6 +344,8 @@ drawing_area_init (DrawingArea *area)
 
   area->draw_color = (GdkRGBA) { 0, 0, 0, 1 };
   area->brush_size = 1;
+
+  area->gesture = gesture;
 }
 
 static GtkWidget *
@@ -379,6 +384,12 @@ drawing_area_color_set (DrawingArea          *area,
   gtk_color_dialog_button_set_rgba (button, color);
 }
 
+static GtkGesture *
+drawing_area_get_gesture (DrawingArea *area)
+{
+  return area->gesture;
+}
+
 GtkWidget *
 do_paint (GtkWidget *toplevel)
 {
@@ -386,7 +397,7 @@ do_paint (GtkWidget *toplevel)
 
   if (!window)
     {
-      GtkWidget *draw_area, *headerbar, *colorbutton;
+      GtkWidget *draw_area, *headerbar, *button;
 
       window = gtk_window_new ();
 
@@ -395,15 +406,22 @@ do_paint (GtkWidget *toplevel)
 
       headerbar = gtk_header_bar_new ();
 
-      colorbutton = gtk_color_dialog_button_new (gtk_color_dialog_new ());
-      g_signal_connect (colorbutton, "notify::rgba",
+      button = gtk_color_dialog_button_new (gtk_color_dialog_new ());
+      g_signal_connect (button, "notify::rgba",
                         G_CALLBACK (color_button_color_set), draw_area);
       g_signal_connect (draw_area, "color-set",
-                        G_CALLBACK (drawing_area_color_set), colorbutton);
-      gtk_color_dialog_button_set_rgba (GTK_COLOR_DIALOG_BUTTON (colorbutton),
+                        G_CALLBACK (drawing_area_color_set), button);
+      gtk_color_dialog_button_set_rgba (GTK_COLOR_DIALOG_BUTTON (button),
                                         &(GdkRGBA) { 0, 0, 0, 1 });
 
-      gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), colorbutton);
+      gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), button);
+
+      button = gtk_check_button_new_with_label ("Stylus only");
+      g_object_bind_property (button, "active",
+                              drawing_area_get_gesture ((DrawingArea *)draw_area), "stylus-only",
+                              G_BINDING_SYNC_CREATE);
+      gtk_header_bar_pack_start (GTK_HEADER_BAR (headerbar), button);
+
       gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
       gtk_window_set_title (GTK_WINDOW (window), "Paint");
       g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);

demos/gtk-demo/suggestionentry.c

@@ -471,7 +471,7 @@ suggestion_entry_size_allocate (GtkWidget *widget,
                               &(GtkAllocation) { width - arrow_nat, 0, arrow_nat, height },
                               baseline);
 
-  gtk_widget_set_size_request (self->popup, gtk_widget_get_allocated_width (GTK_WIDGET (self)), -1);
+  gtk_widget_set_size_request (self->popup, gtk_widget_get_width (GTK_WIDGET (self)), -1);
   gtk_widget_queue_resize (self->popup);
 
   gtk_popover_present (GTK_POPOVER (self->popup));

demos/node-editor/gtkrendererpaintable.c

@@ -78,6 +78,8 @@ gtk_renderer_paintable_paintable_snapshot (GdkPaintable *paintable,
 
   gdk_paintable_snapshot (GDK_PAINTABLE (texture), snapshot, width, height);
   g_object_unref (texture);
+
+  gsk_render_node_unref (node);
 }
 
 static int

demos/node-editor/node-format.md

@@ -2,7 +2,7 @@
 
 GSK render nodes can be serialized and deserialized using APIs such as `gsk_render_node_serialize()` and `gsk_render_node_deserialize()`. The intended use for this is development - primarily the development of GTK - by allowing things such as creating testsuites and benchmarks, exchanging nodes in bug reports. GTK includes the `gtk4-node-editor` application for creating such test files.
 
-The format is a text format that follows the [CSS syntax rules](https://drafts.csswg.org/css-syntax-3/). In particular, this means that every array of bytes will produce a render node when parsed, as there is a defined error recovery method. For more details on error handling, please refer to the documentation of the aprsing APIs.
+The format is a text format that follows the [CSS syntax rules](https://drafts.csswg.org/css-syntax-3/). In particular, this means that every array of bytes will produce a render node when parsed, as there is a defined error recovery method. For more details on error handling, please refer to the documentation of the parsing APIs.
 
 The grammar of a node text representation using [the CSS value definition syntax](https://drafts.csswg.org/css-values-3/#value-defs) looks like this:
 **document**: `<node>\*`
@@ -23,7 +23,7 @@ Nodes can be given a name by adding a string after the `<node-type>` in their de
 
 ### Textures
 
-Just like nodes, textures can be referenced by name. When definining the named texture, the name has to be placed in front of the URL.
+Just like nodes, textures can be referenced by name. When defining a named texture, the name has to be placed in front of the URL.
 
 # Nodes
 

docs/reference/gtk/coordinates.md

@@ -44,6 +44,10 @@ widgets (although most of the time, the transformation will be a simple 2D trans
 The transform to go from one widgets coordinate system to another one can be obtained
 with [method@Gtk.Widget.compute_transform].
 
+In addition to a size, widgets can optionally have a **_baseline_** to position text on.
+Containers such as [class@Gtk.Box] may position their children to match up their baselines.
+[method@Gtk.Widget.get_baseline] returns the y position of the baseline in widget coordinates.
+
 When widget APIs expect positions or areas, they need to be expressed in this coordinate
 system, typically called **_widget coordinates_**. GTK provides a number of APIs to translate
 between different widgets' coordinate systems, such as [method@Gtk.Widget.compute_point]

docs/reference/gtk/migrating-3to4.md

@@ -258,7 +258,7 @@ Instead of implementing GtkWidget.destroy, you can implement GObject.dispose.
 GTK 4 removes `gtk_container_add()` and `gtk_container_remove()`. While there
 is not always a replacement for `gtk_container_remove()` in GTK 3, you can
 replace many uses of `gtk_container_add()` with equivalent container-specific
-APIs such as `gtk_box_pack_start()` or `gtk_grid_attach()`, and thereby reduce
+APIs such as `gtk_grid_attach()`, and thereby reduce
 the amount of work you have to do at the time of the switch.
 
 ### Review your use of icon resources
@@ -402,9 +402,9 @@ is open, use the [property@Gtk.Window:modal] property of the dialog.
 
 ### Adapt to coordinate API changes
 
-A number of coordinate APIs in GTK 3 had `double` variants:
+A number of coordinate APIs in GTK 3 had variants taking `int` arguments:
 `gdk_device_get_surface_at_position()`, `gdk_surface_get_device_position()`.
-These have been changed to use doubles, and the `double` variants
+These have been changed to use `double` arguments, and the `int` variants
 have been removed. Update your code accordingly.
 
 Any APIs that deal with global (or root) coordinates have been

docs/reference/gtk/migrating-4to5.md

@@ -119,3 +119,19 @@ it no longer has a resize handle for the window.
 
 These are very specialized widgets that should better live with the application
 where they are used.
+
+## Widget size api changes
+
+The functions gtk_widget_get_allocated_width() and gtk_widget_get_allocated_height()
+are going away. In most cases, [method@Gtk.Widget.get_width] and [method@Gtk.Widget.get_height]
+are suitable replacements. Note that the semantics are slightly different though:
+the old functions return the size of the CSS border area, while the new functions return
+the size of the widgets content area. In places where this difference matters, you can
+use `gtk_widget_compute_bounds (widget, widget, &bounds)` instead.
+
+The function gtk_widget_get_allocation() is also going away. It does not have a direct
+replacement, but the previously mentioned alternatives can be used for it too.
+
+gtk_widget_translate_coordinates90 has been replaced by [method@Gtk.Widget.compute_point].
+
+The function gtk_widget_get_allocated_baseline() has been renamed to [method@Gtk.Widget.get_baseline].

gdk/broadway/gdkdisplay-broadway.c

@@ -477,6 +477,8 @@ gdk_broadway_display_class_init (GdkBroadwayDisplayClass * class)
   object_class->dispose = gdk_broadway_display_dispose;
   object_class->finalize = gdk_broadway_display_finalize;
 
+  display_class->toplevel_type = GDK_TYPE_BROADWAY_TOPLEVEL;
+  display_class->popup_type = GDK_TYPE_BROADWAY_POPUP;
   display_class->cairo_context_type = GDK_TYPE_BROADWAY_CAIRO_CONTEXT;
 
   display_class->get_name = gdk_broadway_display_get_name;
@@ -488,7 +490,6 @@ gdk_broadway_display_class_init (GdkBroadwayDisplayClass * class)
 
   display_class->get_next_serial = gdk_broadway_display_get_next_serial;
   display_class->notify_startup_complete = gdk_broadway_display_notify_startup_complete;
-  display_class->create_surface = _gdk_broadway_display_create_surface;
   display_class->get_keymap = _gdk_broadway_display_get_keymap;
 
   display_class->get_monitors = gdk_broadway_display_get_monitors;

gdk/broadway/gdkprivate-broadway.h

@@ -103,13 +103,6 @@ void _gdk_broadway_display_get_default_cursor_size (GdkDisplay *display,
 void _gdk_broadway_display_get_maximal_cursor_size (GdkDisplay *display,
                                                     guint       *width,
                                                     guint       *height);
-GdkSurface * _gdk_broadway_display_create_surface (GdkDisplay     *display,
-                                                   GdkSurfaceType  surface_type,
-                                                   GdkSurface     *parent,
-                                                   int             x,
-                                                   int             y,
-                                                   int             width,
-                                                   int             height);
 GdkKeymap* _gdk_broadway_display_get_keymap (GdkDisplay *display);
 void _gdk_broadway_display_consume_all_input (GdkDisplay *display);
 BroadwayInputMsg * _gdk_broadway_display_block_for_input (GdkDisplay *display,

gdk/broadway/gdksurface-broadway.c

@@ -47,19 +47,8 @@
 #include <stdio.h>
 #include <string.h>
 
-/* Forward declarations */
-static void        gdk_broadway_surface_finalize   (GObject            *object);
-
 G_DEFINE_TYPE (GdkBroadwaySurface, gdk_broadway_surface, GDK_TYPE_SURFACE)
 
-GType gdk_broadway_toplevel_get_type (void) G_GNUC_CONST;
-GType gdk_broadway_popup_get_type (void) G_GNUC_CONST;
-GType gdk_broadway_drag_surface_get_type (void) G_GNUC_CONST;
-
-#define GDK_TYPE_BROADWAY_TOPLEVEL (gdk_broadway_toplevel_get_type ())
-#define GDK_TYPE_BROADWAY_POPUP (gdk_broadway_popup_get_type ())
-#define GDK_TYPE_BROADWAY_DRAG_SURFACE (gdk_broadway_drag_surface_get_type ())
-
 /* We need to flush in an idle rather than AFTER_PAINT, as the clock
    is frozen during e.g. surface resizes so the paint will not happen
    and the surface resize request is never flushed. */
@@ -74,6 +63,93 @@ gdk_broadway_surface_init (GdkBroadwaySurface *impl)
 {
 }
 
+static void
+on_frame_clock_after_paint (GdkFrameClock *clock,
+                            GdkSurface    *surface)
+{
+  GdkDisplay *display = gdk_surface_get_display (surface);
+  GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
+  GdkBroadwayDisplay *broadway_display;
+
+  impl->pending_frame_counter = gdk_frame_clock_get_frame_counter (clock);
+  gdk_surface_freeze_updates (surface);
+
+  broadway_display = GDK_BROADWAY_DISPLAY (display);
+
+  _gdk_broadway_server_roundtrip (broadway_display->server, impl->id, _gdk_display_get_next_serial (display));
+
+  gdk_display_flush (display);
+}
+
+static void
+on_frame_clock_before_paint (GdkFrameClock *clock,
+                             GdkSurface    *surface)
+{
+  GdkFrameTimings *timings = gdk_frame_clock_get_current_timings (clock);
+  gint64 presentation_time;
+  gint64 refresh_interval;
+
+  if (surface->update_freeze_count > 0)
+    return;
+
+  gdk_frame_clock_get_refresh_info (clock,
+                                    timings->frame_time,
+                                    &refresh_interval, &presentation_time);
+  if (presentation_time != 0)
+    {
+      timings->predicted_presentation_time = presentation_time + refresh_interval;
+    }
+  else
+    {
+      timings->predicted_presentation_time = timings->frame_time + refresh_interval / 2 + refresh_interval;
+    }
+}
+
+static void
+connect_frame_clock (GdkSurface *surface)
+{
+  GdkFrameClock *frame_clock = gdk_surface_get_frame_clock (surface);
+
+  g_signal_connect (frame_clock, "before-paint",
+                    G_CALLBACK (on_frame_clock_before_paint), surface);
+  g_signal_connect (frame_clock, "after-paint",
+                    G_CALLBACK (on_frame_clock_after_paint), surface);
+}
+
+static void
+disconnect_frame_clock (GdkSurface *surface)
+{
+  GdkFrameClock *frame_clock = gdk_surface_get_frame_clock (surface);
+
+  g_signal_handlers_disconnect_by_func (frame_clock,
+                                        on_frame_clock_before_paint, surface);
+  g_signal_handlers_disconnect_by_func (frame_clock,
+                                        on_frame_clock_after_paint, surface);
+}
+
+static void
+gdk_broadway_surface_constructed (GObject *object)
+{
+  GdkBroadwaySurface *self = GDK_BROADWAY_SURFACE (object);
+  GdkSurface *surface = GDK_SURFACE (object);
+  GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (gdk_surface_get_display (surface));
+
+  if (!surface->parent)
+    broadway_display->toplevels = g_list_prepend (broadway_display->toplevels, self);
+
+  self->id = _gdk_broadway_server_new_surface (broadway_display->server,
+                                               self->root_x,
+                                               self->root_y,
+                                               1, 1);
+  g_hash_table_insert (broadway_display->id_ht, GINT_TO_POINTER (self->id), surface);
+
+  g_object_ref (self);
+
+  G_OBJECT_CLASS (gdk_broadway_surface_parent_class)->constructed (object);
+
+  connect_frame_clock (surface);
+}
+
 static void
 gdk_broadway_surface_finalize (GObject *object)
 {
@@ -143,164 +219,6 @@ _gdk_broadway_roundtrip_notify (GdkSurface  *surface,
     }
 }
 
-static void
-on_frame_clock_after_paint (GdkFrameClock *clock,
-                            GdkSurface    *surface)
-{
-  GdkDisplay *display = gdk_surface_get_display (surface);
-  GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
-  GdkBroadwayDisplay *broadway_display;
-
-  impl->pending_frame_counter = gdk_frame_clock_get_frame_counter (clock);
-  gdk_surface_freeze_updates (surface);
-
-  broadway_display = GDK_BROADWAY_DISPLAY (display);
-
-  _gdk_broadway_server_roundtrip (broadway_display->server, impl->id, _gdk_display_get_next_serial (display));
-
-  gdk_display_flush (display);
-}
-
-static void
-on_frame_clock_before_paint (GdkFrameClock *clock,
-                             GdkSurface    *surface)
-{
-  GdkFrameTimings *timings = gdk_frame_clock_get_current_timings (clock);
-  gint64 presentation_time;
-  gint64 refresh_interval;
-
-  if (surface->update_freeze_count > 0)
-    return;
-
-  gdk_frame_clock_get_refresh_info (clock,
-                                    timings->frame_time,
-                                    &refresh_interval, &presentation_time);
-  if (presentation_time != 0)
-    {
-      timings->predicted_presentation_time = presentation_time + refresh_interval;
-    }
-  else
-    {
-      timings->predicted_presentation_time = timings->frame_time + refresh_interval / 2 + refresh_interval;
-    }
-}
-
-static void
-connect_frame_clock (GdkSurface *surface)
-{
-  GdkFrameClock *frame_clock = gdk_surface_get_frame_clock (surface);
-
-  g_signal_connect (frame_clock, "before-paint",
-                    G_CALLBACK (on_frame_clock_before_paint), surface);
-  g_signal_connect (frame_clock, "after-paint",
-                    G_CALLBACK (on_frame_clock_after_paint), surface);
-}
-
-static void
-disconnect_frame_clock (GdkSurface *surface)
-{
-  GdkFrameClock *frame_clock = gdk_surface_get_frame_clock (surface);
-
-  g_signal_handlers_disconnect_by_func (frame_clock,
-                                        on_frame_clock_before_paint, surface);
-  g_signal_handlers_disconnect_by_func (frame_clock,
-                                        on_frame_clock_after_paint, surface);
-}
-
-GdkSurface *
-_gdk_broadway_display_create_surface (GdkDisplay     *display,
-                                      GdkSurfaceType  surface_type,
-                                      GdkSurface     *parent,
-                                      int             x,
-                                      int             y,
-                                      int             width,
-                                      int             height)
-{
-  GdkBroadwayDisplay *broadway_display;
-  GdkFrameClock *frame_clock;
-  GdkSurface *surface;
-  GdkBroadwaySurface *impl;
-  GType type;
-
-  if (parent)
-    frame_clock = g_object_ref (gdk_surface_get_frame_clock (parent));
-  else
-    frame_clock = _gdk_frame_clock_idle_new ();
-
-  switch (surface_type)
-    {
-    case GDK_SURFACE_TOPLEVEL:
-      type = GDK_TYPE_BROADWAY_TOPLEVEL;
-      break;
-    case GDK_SURFACE_POPUP:
-      type = GDK_TYPE_BROADWAY_POPUP;
-      break;
-    case GDK_SURFACE_DRAG:
-      type = GDK_TYPE_BROADWAY_DRAG_SURFACE;
-      break;
-    default:
-      g_assert_not_reached ();
-      break;
-    }
-
-  surface = g_object_new (type,
-                          "display", display,
-                          "frame-clock", frame_clock,
-                          NULL);
-
-  g_object_unref (frame_clock);
-
-  surface->parent = parent;
-  surface->x = x;
-  surface->y = y;
-  surface->width = width;
-  surface->height = height;
-
-  broadway_display = GDK_BROADWAY_DISPLAY (display);
-
-  impl = GDK_BROADWAY_SURFACE (surface);
-  impl->root_x = x;
-  impl->root_y = y;
-  if (parent)
-    {
-      impl->root_x += GDK_BROADWAY_SURFACE (parent)->root_x;
-      impl->root_y += GDK_BROADWAY_SURFACE (parent)->root_y;
-    }
-
-  impl->id = _gdk_broadway_server_new_surface (broadway_display->server,
-                                               impl->root_x,
-                                               impl->root_y,
-                                               surface->width,
-                                               surface->height);
-  g_hash_table_insert (broadway_display->id_ht, GINT_TO_POINTER(impl->id), surface);
-
-  g_object_ref (surface);
-
-  if (!surface->parent)
-    broadway_display->toplevels = g_list_prepend (broadway_display->toplevels, impl);
-
-  connect_frame_clock (surface);
-
-  /* We treat the real parent as a default transient for to get stacking right */
-  if (parent)
-    {
-      impl->transient_for = GDK_BROADWAY_SURFACE (parent)->id;
-      _gdk_broadway_server_surface_set_transient_for (broadway_display->server, impl->id, impl->transient_for);
-    }
-
-  return surface;
-}
-
-static cairo_surface_t *
-gdk_broadway_surface_ref_cairo_surface (GdkSurface *surface)
-{
-  if (GDK_IS_BROADWAY_SURFACE (surface) &&
-      GDK_SURFACE_DESTROYED (surface))
-    return NULL;
-
-  return cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);
-}
-
 static void
 _gdk_broadway_surface_destroy (GdkSurface *surface,
                                gboolean    foreign_destroy)
@@ -1107,6 +1025,14 @@ _gdk_broadway_moveresize_configure_done (GdkDisplay *display,
   return TRUE;
 }
 
+static GdkSurface *
+gdk_broadway_drag_surface_new (GdkDisplay *display)
+{
+  return g_object_new (GDK_TYPE_BROADWAY_DRAG_SURFACE,
+                       "display", display,
+                       NULL);
+}
+
 static void
 create_moveresize_surface (MoveResizeData *mv_resize,
                            guint32         timestamp)
@@ -1118,11 +1044,9 @@ create_moveresize_surface (MoveResizeData *mv_resize,
   g_assert (mv_resize->moveresize_emulation_surface == NULL);
 
   mv_resize->moveresize_emulation_surface =
-      _gdk_broadway_display_create_surface (mv_resize->display,
-                                            GDK_SURFACE_DRAG,
-                                            NULL,
-                                            -100, -100, 1, 1);
+      gdk_broadway_drag_surface_new (mv_resize->display);
 
+  gdk_broadway_surface_move_resize_internal (mv_resize->moveresize_emulation_surface, TRUE, -100, -100, 1, 1);
   gdk_broadway_surface_show (mv_resize->moveresize_emulation_surface, FALSE);
 
   seat = gdk_display_get_default_seat (mv_resize->display);
@@ -1252,9 +1176,9 @@ gdk_broadway_surface_class_init (GdkBroadwaySurfaceClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GdkSurfaceClass *impl_class = GDK_SURFACE_CLASS (klass);
 
+  object_class->constructed = gdk_broadway_surface_constructed;
   object_class->finalize = gdk_broadway_surface_finalize;
 
-  impl_class->ref_cairo_surface = gdk_broadway_surface_ref_cairo_surface;
   impl_class->hide = gdk_broadway_surface_hide;
   impl_class->get_geometry = gdk_broadway_surface_get_geometry;
   impl_class->get_root_coords = gdk_broadway_surface_get_root_coords;
@@ -1290,6 +1214,25 @@ gdk_broadway_popup_init (GdkBroadwayPopup *popup)
 {
 }
 
+static void
+gdk_broadway_popup_constructed (GObject *object)
+{
+  GdkBroadwaySurface *self = GDK_BROADWAY_SURFACE (object);
+  GdkSurface *surface = GDK_SURFACE (self);
+  GdkBroadwayDisplay *broadway_display = GDK_BROADWAY_DISPLAY (gdk_surface_get_display (surface));
+
+  self->root_x = GDK_BROADWAY_SURFACE (surface->parent)->root_x;
+  self->root_y = GDK_BROADWAY_SURFACE (surface->parent)->root_y;
+
+  gdk_surface_set_frame_clock (surface, gdk_surface_get_frame_clock (surface->parent));
+
+  G_OBJECT_CLASS (gdk_broadway_popup_parent_class)->constructed (object);
+
+  /* We treat the real parent as a default transient for to get stacking right */
+  self->transient_for = GDK_BROADWAY_SURFACE (surface->parent)->id;
+  _gdk_broadway_server_surface_set_transient_for (broadway_display->server, self->id, self->transient_for);
+}
+
 static void
 gdk_broadway_popup_get_property (GObject    *object,
                                  guint       prop_id,
@@ -1345,6 +1288,7 @@ gdk_broadway_popup_class_init (GdkBroadwayPopupClass *class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (class);
 
+  object_class->constructed = gdk_broadway_popup_constructed;
   object_class->get_property = gdk_broadway_popup_get_property;
   object_class->set_property = gdk_broadway_popup_set_property;
 
@@ -1415,6 +1359,19 @@ gdk_broadway_toplevel_init (GdkBroadwayToplevel *toplevel)
 {
 }
 
+static void
+gdk_broadway_toplevel_constructed (GObject *object)
+{
+  GdkSurface *surface = GDK_SURFACE (object);
+  GdkFrameClock *frame_clock;
+
+  frame_clock = _gdk_frame_clock_idle_new ();
+  gdk_surface_set_frame_clock (surface, frame_clock);
+  g_object_unref (frame_clock);
+
+  G_OBJECT_CLASS (gdk_broadway_toplevel_parent_class)->constructed (object);
+}
+
 static void
 gdk_broadway_toplevel_set_property (GObject      *object,
                                     guint         prop_id,
@@ -1518,6 +1475,7 @@ gdk_broadway_toplevel_class_init (GdkBroadwayToplevelClass *class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (class);
 
+  object_class->constructed = gdk_broadway_toplevel_constructed;
   object_class->get_property = gdk_broadway_toplevel_get_property;
   object_class->set_property = gdk_broadway_toplevel_set_property;
 
@@ -1678,9 +1636,25 @@ gdk_broadway_drag_surface_init (GdkBroadwayDragSurface *surface)
 {
 }
 
+static void
+gdk_broadway_drag_surface_constructed (GObject *object)
+{
+  GdkSurface *surface = GDK_SURFACE (object);
+  GdkFrameClock *frame_clock;
+
+  frame_clock = _gdk_frame_clock_idle_new ();
+  gdk_surface_set_frame_clock (surface, frame_clock);
+  g_object_unref (frame_clock);
+
+  G_OBJECT_CLASS (gdk_broadway_drag_surface_parent_class)->constructed (object);
+}
+
 static void
 gdk_broadway_drag_surface_class_init (GdkBroadwayDragSurfaceClass *class)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->constructed = gdk_broadway_drag_surface_constructed;
 }
 
 static gboolean

gdk/broadway/gdksurface-broadway.h

@@ -32,6 +32,14 @@ G_BEGIN_DECLS
 /* Surface implementation for Broadway
  */
 
+GType gdk_broadway_toplevel_get_type (void) G_GNUC_CONST;
+GType gdk_broadway_popup_get_type (void) G_GNUC_CONST;
+GType gdk_broadway_drag_surface_get_type (void) G_GNUC_CONST;
+
+#define GDK_TYPE_BROADWAY_TOPLEVEL (gdk_broadway_toplevel_get_type ())
+#define GDK_TYPE_BROADWAY_POPUP (gdk_broadway_popup_get_type ())
+#define GDK_TYPE_BROADWAY_DRAG_SURFACE (gdk_broadway_drag_surface_get_type ())
+
 struct _GdkBroadwaySurface
 {
   GdkSurface parent_instance;

gdk/gdk.h

@@ -54,6 +54,7 @@
 #include <gdk/gdkframetimings.h>
 #include <gdk/gdkglcontext.h>
 #include <gdk/gdkgltexture.h>
+#include <gdk/gdkgltexturebuilder.h>
 #include <gdk/gdkkeys.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkmemorytexture.h>

gdk/gdkdisplay.c

@@ -1196,21 +1196,6 @@ _gdk_display_unpause_events (GdkDisplay *display)
   display->event_pause_count--;
 }
 
-GdkSurface *
-gdk_display_create_surface (GdkDisplay     *display,
-                            GdkSurfaceType  surface_type,
-                            GdkSurface     *parent,
-                            int             x,
-                            int             y,
-                            int             width,
-                            int             height)
-{
-  return GDK_DISPLAY_GET_CLASS (display)->create_surface (display,
-                                                          surface_type,
-                                                          parent,
-                                                          x, y, width, height);
-}
-
 /*< private >
  * gdk_display_get_keymap:
  * @display: the `GdkDisplay`
@@ -1723,8 +1708,6 @@ gdk_display_init_egl (GdkDisplay  *self,
     epoxy_has_egl_extension (priv->egl_display, "EGL_KHR_no_config_context");
   self->have_egl_pixel_format_float =
     epoxy_has_egl_extension (priv->egl_display, "EGL_EXT_pixel_format_float");
-  self->have_egl_win32_libangle =
-    epoxy_has_egl_extension (priv->egl_display, "EGL_ANGLE_d3d_share_handle_client_buffer");
 
   if (self->have_egl_no_config_context)
     priv->egl_config_high_depth = gdk_display_create_egl_config (self,

gdk/gdkdisplaymanager.c

@@ -369,7 +369,7 @@ gdk_display_manager_list_displays (GdkDisplayManager *manager)
 /**
  * gdk_display_manager_open_display:
  * @manager: a `GdkDisplayManager`
- * @name: the name of the display to open
+ * @name: (nullable): the name of the display to open
  *
  * Opens a display.
  *

gdk/gdkdisplayprivate.h

@@ -108,13 +108,14 @@ struct _GdkDisplay
   guint have_egl_buffer_age : 1;
   guint have_egl_no_config_context : 1;
   guint have_egl_pixel_format_float : 1;
-  guint have_egl_win32_libangle : 1;
 };
 
 struct _GdkDisplayClass
 {
   GObjectClass parent_class;
 
+  GType toplevel_type;        /* Type for GdkToplevel, must be set */
+  GType popup_type;           /* Type for GdkPopup, must be set */
   GType cairo_context_type;   /* type for GdkCairoContext, must be set */
   GType vk_context_type;      /* type for GdkVulkanContext, must be set if vk_extension_name != NULL */
   const char *vk_extension_name; /* Name of required windowing vulkan extension or %NULL (default) if Vulkan isn't supported */
@@ -135,15 +136,7 @@ struct _GdkDisplayClass
                                                          const char *startup_id);
   const char *              (*get_startup_notification_id) (GdkDisplay  *display);
 
-  GdkSurface *               (*create_surface) (GdkDisplay     *display,
-                                                GdkSurfaceType  surface_type,
-                                                GdkSurface     *parent,
-                                                int             x,
-                                                int             y,
-                                                int             width,
-                                                int             height);
-
-  GdkKeymap *                (*get_keymap)         (GdkDisplay    *display);
+  GdkKeymap *            (*get_keymap)                 (GdkDisplay        *display);
 
   GdkGLContext *         (* init_gl)                   (GdkDisplay        *display,
                                                         GError           **error);
@@ -208,13 +201,6 @@ void                _gdk_display_pointer_info_foreach (GdkDisplay       *display
 gulong              _gdk_display_get_next_serial      (GdkDisplay       *display);
 void                _gdk_display_pause_events         (GdkDisplay       *display);
 void                _gdk_display_unpause_events       (GdkDisplay       *display);
-GdkSurface *        gdk_display_create_surface        (GdkDisplay       *display,
-                                                       GdkSurfaceType    surface_type,
-                                                       GdkSurface       *parent,
-                                                       int               x,
-                                                       int               y,
-                                                       int               width,
-                                                       int               height);
 
 GdkGLContext *      gdk_display_get_gl_context        (GdkDisplay       *display);
 

gdk/gdkenums.h

@@ -32,6 +32,20 @@
 
 G_BEGIN_DECLS
 
+/**
+ * GdkGLAPI:
+ * @GDK_GL_API_GL: The OpenGL API
+ * @GDK_GL_API_GLES: The OpenGL ES API
+ *
+ * The list of the different APIs that GdkGLContext can potentially support.
+ *
+ * Since: 4.6
+ */
+typedef enum { /*< underscore_name=GDK_GL_API >*/
+  GDK_GL_API_GL   = 1 << 0,
+  GDK_GL_API_GLES = 1 << 1
+} GdkGLAPI;
+
 /* Currently, these are the same values numerically as in the
  * X protocol. If you change that, gdksurface-x11.c/gdk_surface_set_geometry_hints()
  * will need fixing.

gdk/gdkglcontext.c

@@ -82,6 +82,7 @@
 #include "gdkmemoryformatprivate.h"
 #include "gdkmemorytextureprivate.h"
 #include "gdkprofilerprivate.h"
+#include "gdkglversionprivate.h"
 
 #include "gdkprivate.h"
 
@@ -99,13 +100,13 @@
 #define DEFAULT_ALLOWED_APIS GDK_GL_API_GL | GDK_GL_API_GLES
 
 typedef struct {
-  int major;
-  int minor;
-  int gl_version;
+  GdkGLVersion required;
+  GdkGLVersion gl_version;
 
   guint has_khr_debug : 1;
   guint use_khr_debug : 1;
   guint has_half_float : 1;
+  guint has_sync : 1;
   guint has_unpack_subimage : 1;
   guint has_debug_output : 1;
   guint extensions_checked : 1;
@@ -287,8 +288,11 @@ gdk_gl_context_create_egl_context (GdkGLContext *context,
   EGLConfig egl_config;
   EGLContext ctx;
   EGLint context_attribs[N_EGL_ATTRS], i = 0, flags = 0;
+  gsize major_idx, minor_idx;
   gboolean debug_bit, forward_bit;
-  int min_major, min_minor, major = 0, minor = 0;
+  GdkGLVersion version;
+  const GdkGLVersion* supported_versions;
+  gsize j;
   G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
 
   if (!gdk_gl_context_is_api_allowed (context, api, NULL))
@@ -296,12 +300,7 @@ gdk_gl_context_create_egl_context (GdkGLContext *context,
 
   /* We will use the default version matching the context status
    * unless the user requested a version which makes sense */
-  gdk_gl_context_get_matching_version (api, legacy,
-                                       display->have_egl_win32_libangle,
-                                       &min_major, &min_minor);
-  gdk_gl_context_get_clipped_version (context,
-                                      min_major, min_minor,
-                                      &major, &minor);
+  gdk_gl_context_get_matching_version (context, api, legacy, &version);
 
   if (!eglBindAPI (gdk_api_to_egl_api (api)))
     return 0;
@@ -332,9 +331,9 @@ gdk_gl_context_create_egl_context (GdkGLContext *context,
     flags &= ~EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
 
   context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION;
-  context_attribs[i++] = major;
+  major_idx = i++;
   context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION;
-  context_attribs[i++] = minor;
+  minor_idx = i++;
   context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
   context_attribs[i++] = flags;
 
@@ -343,23 +342,33 @@ gdk_gl_context_create_egl_context (GdkGLContext *context,
 
   GDK_DISPLAY_DEBUG (display, OPENGL,
                      "Creating EGL context version %d.%d (debug:%s, forward:%s, legacy:%s, es:%s)",
-                     major, minor,
+                     gdk_gl_version_get_major (&version), gdk_gl_version_get_minor (&version),
                      debug_bit ? "yes" : "no",
                      forward_bit ? "yes" : "no",
                      legacy ? "yes" : "no",
                      api == GDK_GL_API_GLES ? "yes" : "no");
 
-  ctx = eglCreateContext (egl_display,
-                          egl_config,
-                          share ? share_priv->egl_context : EGL_NO_CONTEXT,
-                          context_attribs);
+  supported_versions = gdk_gl_versions_get_for_api (api);
+  for (j = 0; gdk_gl_version_greater_equal (&supported_versions[j], &version); j++)
+    {
+      context_attribs [major_idx] = gdk_gl_version_get_major (&supported_versions[j]);
+      context_attribs [minor_idx] = gdk_gl_version_get_minor (&supported_versions[j]);
+
+      ctx = eglCreateContext (egl_display,
+                              egl_config,
+                              share ? share_priv->egl_context : EGL_NO_CONTEXT,
+                              context_attribs);
+      if (ctx != NULL)
+        break;
+    }
 
   if (ctx == NULL)
-      return 0;
+    return 0;
 
   GDK_DISPLAY_DEBUG (display, OPENGL, "Created EGL context[%p]", ctx);
 
   priv->egl_context = ctx;
+  gdk_gl_context_set_version (context, &supported_versions[j]);
   gdk_gl_context_set_is_legacy (context, legacy);
 
   if (epoxy_has_egl_extension (egl_display, "EGL_KHR_swap_buffers_with_damage"))
@@ -621,7 +630,7 @@ gdk_gl_context_real_begin_frame (GdkDrawContext *draw_context,
   glViewport (0, 0, ww, wh);
 
 #ifdef HAVE_EGL
-  if (priv->egl_context && gdk_gl_context_check_version (context, 0, 0, 3, 0))
+  if (priv->egl_context && gdk_gl_context_check_version (context, NULL, "3.0"))
     glDrawBuffers (1, (GLenum[1]) { gdk_gl_context_get_use_es (context) ? GL_BACK : GL_BACK_LEFT });
 #endif
 }
@@ -987,45 +996,33 @@ gdk_gl_context_get_forward_compatible (GdkGLContext *context)
 }
 
 void
-gdk_gl_context_get_matching_version (GdkGLAPI  api,
-                                     gboolean  legacy,
-                                     gboolean  win32_libangle,
-                                     int      *major,
-                                     int      *minor)
+gdk_gl_context_get_matching_version (GdkGLContext *context,
+                                     GdkGLAPI      api,
+                                     gboolean      legacy,
+                                     GdkGLVersion *out_version)
 {
-  int maj, min;
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
+  GdkGLVersion min_version;
+
+  g_return_if_fail (GDK_IS_GL_CONTEXT (context));
 
   if (api == GDK_GL_API_GL)
     {
       if (legacy)
-        {
-          maj = GDK_GL_MIN_GL_LEGACY_VERSION_MAJOR;
-          min = GDK_GL_MIN_GL_LEGACY_VERSION_MINOR;
-        }
+        min_version = GDK_GL_MIN_GL_LEGACY_VERSION;
       else
-        {
-          maj = GDK_GL_MIN_GL_VERSION_MAJOR;
-          min = GDK_GL_MIN_GL_VERSION_MINOR;
-        }
+        min_version = GDK_GL_MIN_GL_VERSION;
     }
   else
     {
-      if (win32_libangle)
-        {
-          maj = GDK_GL_MIN_GLES_WIN32_ANGLE_VERSION_MAJOR;
-          min = GDK_GL_MIN_GLES_WIN32_ANGLE_VERSION_MINOR;
-        }
-      else
-        {
-          maj = GDK_GL_MIN_GLES_VERSION_MAJOR;
-          min = GDK_GL_MIN_GLES_VERSION_MINOR;
-        }
+      min_version = GDK_GL_MIN_GLES_VERSION;
     }
 
-  if (major != NULL)
-    *major = maj;
-  if (minor != NULL)
-    *minor = min;
+  if (gdk_gl_version_greater_equal (&priv->required, &min_version))
+    *out_version = priv->required;
+  else
+    *out_version = min_version;
+
 }
 
 /**
@@ -1054,22 +1051,17 @@ gdk_gl_context_set_required_version (GdkGLContext *context,
   g_return_if_fail (GDK_IS_GL_CONTEXT (context));
   g_return_if_fail (!gdk_gl_context_is_realized (context));
 
-  priv->major = major;
-  priv->minor = minor;
+  priv->required = GDK_GL_VERSION_INIT (major, minor);
 }
 
 gboolean
-gdk_gl_context_check_version (GdkGLContext *self,
-                              int           required_gl_major,
-                              int           required_gl_minor,
-                              int           required_gles_major,
-                              int           required_gles_minor)
+gdk_gl_context_check_gl_version (GdkGLContext       *self,
+                                 const GdkGLVersion *required_gl,
+                                 const GdkGLVersion *required_gles)
 {
   GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
 
   g_return_val_if_fail (GDK_IS_GL_CONTEXT (self), FALSE);
-  g_return_val_if_fail (required_gl_minor < 10, FALSE);
-  g_return_val_if_fail (required_gles_minor < 10, FALSE);
 
   if (!gdk_gl_context_is_realized (self))
     return FALSE;
@@ -1077,10 +1069,10 @@ gdk_gl_context_check_version (GdkGLContext *self,
   switch (priv->api)
     {
     case GDK_GL_API_GL:
-      return priv->gl_version >= required_gl_major * 10 + required_gl_minor;
+      return required_gl == NULL || gdk_gl_version_greater_equal (&priv->gl_version, required_gl);
 
     case GDK_GL_API_GLES:
-      return priv->gl_version >= required_gles_major * 10 + required_gles_minor;
+      return required_gles == NULL || gdk_gl_version_greater_equal (&priv->gl_version, required_gles);
 
     default:
       g_return_val_if_reached (FALSE);
@@ -1111,33 +1103,9 @@ gdk_gl_context_get_required_version (GdkGLContext *context,
   g_return_if_fail (GDK_IS_GL_CONTEXT (context));
 
   if (major != NULL)
-    *major = priv->major;
+    *major = gdk_gl_version_get_major (&priv->required);
   if (minor != NULL)
-    *minor = priv->minor;
-}
-
-void
-gdk_gl_context_get_clipped_version (GdkGLContext *context,
-                                    int           min_major,
-                                    int           min_minor,
-                                    int          *major,
-                                    int          *minor)
-{
-  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
-  int maj = min_major, min = min_minor;
-
-  g_return_if_fail (GDK_IS_GL_CONTEXT (context));
-
-  if (priv->major > maj || (priv->major == maj && priv->minor > min))
-    {
-      maj = priv->major;
-      min = priv->minor;
-    }
-
-  if (major != NULL)
-    *major = maj;
-  if (minor != NULL)
-    *minor = min;
+    *minor = gdk_gl_version_get_minor (&priv->required);
 }
 
 /**
@@ -1174,6 +1142,15 @@ gdk_gl_context_is_legacy (GdkGLContext *context)
   return priv->is_legacy;
 }
 
+void
+gdk_gl_context_set_version (GdkGLContext       *context,
+                            const GdkGLVersion *version)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
+
+  priv->gl_version = *version;
+}
+
 void
 gdk_gl_context_set_is_legacy (GdkGLContext *context,
                               gboolean      is_legacy)
@@ -1509,11 +1486,23 @@ gdk_gl_context_realize (GdkGLContext  *context,
   priv->api = GDK_GL_CONTEXT_GET_CLASS (context)->realize (context, error);
 
   if (priv->api)
-    g_object_notify_by_pspec (G_OBJECT (context), properties[PROP_API]);
+    {
+      g_assert (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (0, 0)));
+
+      g_object_notify_by_pspec (G_OBJECT (context), properties[PROP_API]);
+    }
 
   return priv->api;
 }
 
+void
+gdk_gl_version_init_epoxy (GdkGLVersion *version)
+{
+  int epoxy_version = epoxy_gl_version ();
+
+  *version = GDK_GL_VERSION_INIT (epoxy_version / 10, epoxy_version % 10);
+}
+
 static void
 gdk_gl_context_check_extensions (GdkGLContext *context)
 {
@@ -1527,8 +1516,6 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
   if (priv->extensions_checked)
     return;
 
-  priv->gl_version = epoxy_gl_version ();
-
   priv->has_debug_output = epoxy_has_gl_extension ("GL_ARB_debug_output") ||
                            epoxy_has_gl_extension ("GL_KHR_debug");
 
@@ -1554,7 +1541,7 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
       priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
 
       /* We asked for a core profile, but we didn't get one, so we're in legacy mode */
-      if (priv->gl_version < 32)
+      if (!gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
         priv->is_legacy = TRUE;
     }
 
@@ -1564,9 +1551,13 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
       glGetIntegerv (GL_MAX_LABEL_LENGTH, &priv->max_debug_label_length);
     }
 
-  priv->has_half_float = gdk_gl_context_check_version (context, 3, 0, 3, 0) ||
+  priv->has_half_float = gdk_gl_context_check_version (context, "3.0", "3.0") ||
                          epoxy_has_gl_extension ("OES_vertex_half_float");
 
+  priv->has_sync = gdk_gl_context_check_version (context, "3.2", "3.0") ||
+                   epoxy_has_gl_extension ("GL_ARB_sync") ||
+                   epoxy_has_gl_extension ("GK_APPLE_sync");
+
 #ifdef G_ENABLE_DEBUG
   {
     int max_texture_size;
@@ -1578,15 +1569,17 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
                        "* Extensions checked:\n"
                        " - GL_KHR_debug: %s\n"
                        " - GL_EXT_unpack_subimage: %s\n"
-                       " - OES_vertex_half_float: %s",
+                       " - half float: %s\n"
+                       " - sync: %s",
                        gdk_gl_context_get_use_es (context) ? "OpenGL ES" : "OpenGL",
-                       priv->gl_version / 10, priv->gl_version % 10,
+                       gdk_gl_version_get_major (&priv->gl_version), gdk_gl_version_get_minor (&priv->gl_version),
                        priv->is_legacy ? "legacy" : "core",
                        glGetString (GL_SHADING_LANGUAGE_VERSION),
                        max_texture_size,
                        priv->has_khr_debug ? "yes" : "no",
                        priv->has_unpack_subimage ? "yes" : "no",
-                       priv->has_half_float ? "yes" : "no");
+                       priv->has_half_float ? "yes" : "no",
+                       priv->has_sync ? "yes" : "no");
   }
 #endif
 
@@ -1708,10 +1701,6 @@ gdk_gl_context_get_shared_context (GdkGLContext *context)
  * Retrieves the OpenGL version of the @context.
  *
  * The @context must be realized prior to calling this function.
- *
- * If the @context has never been made current, the version cannot
- * be known and it will return 0 for both @major and @minor.
- *
  */
 void
 gdk_gl_context_get_version (GdkGLContext *context,
@@ -1724,9 +1713,9 @@ gdk_gl_context_get_version (GdkGLContext *context,
   g_return_if_fail (gdk_gl_context_is_realized (context));
 
   if (major != NULL)
-    *major = priv->gl_version / 10;
+    *major = gdk_gl_version_get_major (&priv->gl_version);
   if (minor != NULL)
-    *minor = priv->gl_version % 10;
+    *minor = gdk_gl_version_get_minor (&priv->gl_version);
 }
 
 /**
@@ -1818,6 +1807,14 @@ gdk_gl_context_has_vertex_half_float (GdkGLContext *self)
   return priv->has_half_float;
 }
 
+gboolean
+gdk_gl_context_has_sync (GdkGLContext *self)
+{
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
+
+  return priv->has_sync;
+}
+
 /* This is currently private! */
 /* When using GL/ES, don't flip the 'R' and 'B' bits on Windows/ANGLE for glReadPixels() */
 gboolean

gdk/gdkglcontext.h

@@ -24,25 +24,12 @@
 #error "Only <gdk/gdk.h> can be included directly."
 #endif
 
-#include <gdk/gdkversionmacros.h>
+#include <gdk/gdkenums.h>
 #include <gdk/gdktypes.h>
+#include <gdk/gdkversionmacros.h>
 
 G_BEGIN_DECLS
 
-/**
- * GdkGLAPI:
- * @GDK_GL_API_GL: The OpenGL API
- * @GDK_GL_API_GLES: The OpenGL ES API
- *
- * The list of the different APIs that GdkGLContext can potentially support.
- *
- * Since: 4.6
- */
-typedef enum { /*< underscore_name=GDK_GL_API >*/
-  GDK_GL_API_GL   = 1 << 0,
-  GDK_GL_API_GLES = 1 << 1
-} GdkGLAPI;
-
 #define GDK_TYPE_GL_CONTEXT             (gdk_gl_context_get_type ())
 #define GDK_GL_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_CONTEXT, GdkGLContext))
 #define GDK_IS_GL_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_CONTEXT))

gdk/gdkglcontextprivate.h

@@ -22,32 +22,10 @@
 
 #include "gdkglcontext.h"
 #include "gdkdrawcontextprivate.h"
+#include "gdkglversionprivate.h"
 
 G_BEGIN_DECLS
 
-/* Version requirements for EGL contexts.
- *
- * If you add support for EGL to your backend, please require this.
- */
-#define GDK_EGL_MIN_VERSION_MAJOR (1)
-#define GDK_EGL_MIN_VERSION_MINOR (4)
-
-/* Minimum OpenGL versions supported by GTK.
- * Backends should make sure to never create a context of a previous version.
- *
- * The macros refer to OpenGL; OpenGL with OPENGL_COMPATIBILITY_PROFILE_BIT as
- * OPENGL_PROFILE_MASK; OpenGL ES; and OpenGL ES win32 Angle implementation,
- * respectively
- */
-#define GDK_GL_MIN_GL_VERSION_MAJOR (3)
-#define GDK_GL_MIN_GL_VERSION_MINOR (2)
-#define GDK_GL_MIN_GL_LEGACY_VERSION_MAJOR (3)
-#define GDK_GL_MIN_GL_LEGACY_VERSION_MINOR (0)
-#define GDK_GL_MIN_GLES_VERSION_MAJOR (2)
-#define GDK_GL_MIN_GLES_VERSION_MINOR (0)
-#define GDK_GL_MIN_GLES_WIN32_ANGLE_VERSION_MAJOR (3)
-#define GDK_GL_MIN_GLES_WIN32_ANGLE_VERSION_MINOR (0)
-
 typedef enum {
   GDK_GL_NONE = 0,
   GDK_GL_EGL,
@@ -100,7 +78,6 @@ typedef struct {
 } GdkGLContextProgram;
 
 typedef struct {
-  guint vertex_array_object;
   guint tmp_framebuffer;
   guint tmp_vertex_buffer;
 
@@ -122,27 +99,31 @@ void                    gdk_gl_context_clear_current_if_surface (GdkSurface
 GdkGLContext *          gdk_gl_context_new                      (GdkDisplay      *display,
                                                                  GdkSurface      *surface);
 
-gboolean                gdk_gl_context_is_api_allowed           (GdkGLContext    *self,
-                                                                 GdkGLAPI         api,
-                                                                 GError         **error);
-void                    gdk_gl_context_set_is_legacy            (GdkGLContext    *context,
-                                                                 gboolean         is_legacy);
+gboolean                gdk_gl_context_is_api_allowed           (GdkGLContext           *self,
+                                                                 GdkGLAPI                api,
+                                                                 GError                **error);
+void                    gdk_gl_context_set_version              (GdkGLContext           *context,
+                                                                 const GdkGLVersion     *version);
+void                    gdk_gl_context_set_is_legacy            (GdkGLContext           *context,
+                                                                 gboolean                is_legacy);
+gboolean                gdk_gl_context_check_gl_version         (GdkGLContext           *context,
+                                                                 const GdkGLVersion     *gl_version,
+                                                                 const GdkGLVersion     *gles_version);
 
-gboolean                gdk_gl_context_check_version            (GdkGLContext    *context,
-                                                                 int              required_gl_major,
-                                                                 int              required_gl_minor,
-                                                                 int              required_gles_major,
-                                                                 int              required_gles_minor);
-void                    gdk_gl_context_get_clipped_version      (GdkGLContext    *context,
-                                                                 int              min_major,
-                                                                 int              min_minor,
-                                                                 int             *major,
-                                                                 int             *minor);
-void                    gdk_gl_context_get_matching_version     (GdkGLAPI         api,
-                                                                 gboolean         legacy,
-                                                                 gboolean         win32_libangle,
-                                                                 int             *major,
-                                                                 int             *minor);
+static inline gboolean
+gdk_gl_context_check_version (GdkGLContext *context,
+                              const char   *gl_version,
+                              const char   *gles_version)
+{
+  return gdk_gl_context_check_gl_version (context,
+                                          gl_version ? &GDK_GL_VERSION_STRING (gl_version) : NULL,
+                                          gles_version ? &GDK_GL_VERSION_STRING (gles_version) : NULL);
+}
+
+void                    gdk_gl_context_get_matching_version     (GdkGLContext           *context,
+                                                                 GdkGLAPI                api,
+                                                                 gboolean                legacy,
+                                                                 GdkGLVersion           *out_version);
 
 gboolean                gdk_gl_context_has_unpack_subimage      (GdkGLContext    *context);
 void                    gdk_gl_context_push_debug_group         (GdkGLContext    *context,
@@ -167,6 +148,8 @@ gboolean                gdk_gl_context_use_es_bgra              (GdkGLContext
 
 gboolean                gdk_gl_context_has_vertex_half_float    (GdkGLContext    *self) G_GNUC_PURE;
 
+gboolean                gdk_gl_context_has_sync                 (GdkGLContext    *self) G_GNUC_PURE;
+
 double                  gdk_gl_context_get_scale                (GdkGLContext    *self);
 
 G_END_DECLS

gdk/gdkgltexture.c

@@ -39,6 +39,7 @@ struct _GdkGLTexture {
   GdkGLContext *context;
   guint id;
   gboolean has_mipmap;
+  gpointer sync;
 
   GdkTexture *saved;
 
@@ -99,6 +100,10 @@ gdk_gl_texture_invoke_callback (gpointer data)
   context = gdk_display_get_gl_context (gdk_gl_context_get_display (invoke->self->context));
 
   gdk_gl_context_make_current (context);
+
+  if (invoke->self->sync && context != invoke->self->context)
+    glWaitSync (invoke->self->sync, 0, GL_TIMEOUT_IGNORED);
+
   glBindTexture (GL_TEXTURE_2D, invoke->self->id);
 
   invoke->func (invoke->self, context, invoke->data);
@@ -131,6 +136,8 @@ struct _Download
 
 static gboolean
 gdk_gl_texture_find_format (gboolean         use_es,
+                            guint            gl_major,
+                            guint            gl_minor,
                             GLint            gl_format,
                             GLint            gl_type,
                             GdkMemoryFormat *out_format)
@@ -141,7 +148,7 @@ gdk_gl_texture_find_format (gboolean         use_es,
     {
       GLenum q_internal_format, q_format, q_type;
 
-      if (!gdk_memory_format_gl_format (format, use_es, &q_internal_format, &q_format, &q_type))
+      if (!gdk_memory_format_gl_format (format, use_es, gl_major, gl_minor, &q_internal_format, &q_format, &q_type))
         continue;
 
       if (q_format != gl_format || q_type != gl_type)
@@ -163,12 +170,14 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
   gsize expected_stride;
   Download *download = download_;
   GLenum gl_internal_format, gl_format, gl_type;
+  int major, minor;
 
   expected_stride = texture->width * gdk_memory_format_bytes_per_pixel (download->format);
+  gdk_gl_context_get_version (context, &major, &minor);
 
   if (download->stride == expected_stride &&
       !gdk_gl_context_get_use_es (context) &&
-      gdk_memory_format_gl_format (download->format, TRUE, &gl_internal_format, &gl_format, &gl_type))
+      gdk_memory_format_gl_format (download->format, TRUE, major, minor, &gl_internal_format, &gl_format, &gl_type))
     {
       glGetTexImage (GL_TEXTURE_2D,
                      0,
@@ -185,11 +194,12 @@ gdk_gl_texture_do_download (GdkGLTexture *self,
       glGenFramebuffers (1, &fbo);
       glBindFramebuffer (GL_FRAMEBUFFER, fbo);
       glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->id, 0);
-      if (gdk_gl_context_check_version (context, 4, 3, 3, 1))
+      if (gdk_gl_context_check_version (context, "4.3", "3.1"))
         {
+          gdk_gl_context_get_version (context, &major, &minor);
           glGetFramebufferParameteriv (GL_FRAMEBUFFER, GL_IMPLEMENTATION_COLOR_READ_FORMAT, &gl_read_format);
           glGetFramebufferParameteriv (GL_FRAMEBUFFER, GL_IMPLEMENTATION_COLOR_READ_TYPE, &gl_read_type);
-          if (!gdk_gl_texture_find_format (gdk_gl_context_get_use_es (context), gl_read_format, gl_read_type, &actual_format))
+          if (!gdk_gl_texture_find_format (gdk_gl_context_get_use_es (context), major, minor, gl_read_format, gl_read_type, &actual_format))
             actual_format = GDK_MEMORY_R8G8B8A8_PREMULTIPLIED; /* pray */
         }
       else
@@ -291,6 +301,12 @@ gdk_gl_texture_has_mipmap (GdkGLTexture *self)
   return self->has_mipmap;
 }
 
+gpointer
+gdk_gl_texture_get_sync (GdkGLTexture *self)
+{
+  return self->sync;
+}
+
 /**
  * gdk_gl_texture_release:
  * @self: a `GdkTexture` wrapping a GL texture
@@ -316,6 +332,30 @@ gdk_gl_texture_release (GdkGLTexture *self)
   drop_gl_resources (self);
 }
 
+GdkTexture *
+gdk_gl_texture_new_from_builder (GdkGLTextureBuilder *builder,
+                                 GDestroyNotify       destroy,
+                                 gpointer             data)
+{
+  GdkGLTexture *self;
+
+  self = g_object_new (GDK_TYPE_GL_TEXTURE,
+                       "width", gdk_gl_texture_builder_get_width (builder),
+                       "height", gdk_gl_texture_builder_get_height (builder),
+                       NULL);
+
+  self->context = g_object_ref (gdk_gl_texture_builder_get_context (builder));
+  self->id = gdk_gl_texture_builder_get_id (builder);
+  GDK_TEXTURE (self)->format = gdk_gl_texture_builder_get_format (builder);
+  self->has_mipmap = gdk_gl_texture_builder_get_has_mipmap (builder);
+  if (gdk_gl_context_has_sync (self->context))
+    self->sync = gdk_gl_texture_builder_get_sync (builder);
+  self->destroy = destroy;
+  self->data = data;
+
+  return GDK_TEXTURE (self);
+}
+
 static void
 gdk_gl_texture_determine_format (GdkGLTexture *self)
 {
@@ -330,7 +370,7 @@ gdk_gl_texture_determine_format (GdkGLTexture *self)
   if (context == NULL ||
       !gdk_gl_context_is_shared (self->context, context) ||
       /* ... or glGetTexLevelParameter() isn't supported */
-      !gdk_gl_context_check_version (context, 0, 0, 3, 1))
+      !gdk_gl_context_check_version (context, NULL, "3.1"))
     {
       texture->format = GDK_MEMORY_DEFAULT;
       self->has_mipmap = FALSE;
@@ -458,6 +498,9 @@ gdk_gl_texture_determine_format (GdkGLTexture *self)
  *
  * Return value: (transfer full) (type GdkGLTexture): A newly-created
  *   `GdkTexture`
+ *
+ * Deprecated: 4.12: [class@Gdk.GLTextureBuilder] supercedes this function
+ *   and provides extended functionality for creating GL textures.
  */
 GdkTexture *
 gdk_gl_texture_new (GdkGLContext   *context,

gdk/gdkgltexture.h

@@ -38,7 +38,7 @@ typedef struct _GdkGLTextureClass       GdkGLTextureClass;
 GDK_AVAILABLE_IN_ALL
 GType                   gdk_gl_texture_get_type                (void) G_GNUC_CONST;
 
-GDK_AVAILABLE_IN_ALL
+GDK_DEPRECATED_IN_4_12_FOR(GdkGLTextureBuilder)
 GdkTexture *            gdk_gl_texture_new                     (GdkGLContext    *context,
                                                                 guint            id,
                                                                 int              width,

gdk/gdkgltexturebuilder.c

@@ -0,0 +1,655 @@
+/*
+ * Copyright © 2023 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gdkgltexturebuilder.h"
+
+#include "gdkenumtypes.h"
+#include "gdkglcontext.h"
+#include "gdkgltextureprivate.h"
+
+struct _GdkGLTextureBuilder
+{
+  GObject parent_instance;
+
+  GdkGLContext *context;
+  guint id;
+  int width;
+  int height;
+  GdkMemoryFormat format;
+  gboolean has_mipmap;
+  gpointer sync;
+};
+
+struct _GdkGLTextureBuilderClass
+{
+  GObjectClass parent_class;
+};
+
+/**
+ * GdkGLTextureBuilder:
+ *
+ * `GdkGLTextureBuilder` is a buider used to construct [class@Gdk.Texture] objects from
+ * GL textures.
+ *
+ * The operation is quite simple: Create a texture builder, set all the necessary
+ * properties - keep in mind that the properties [property@Gdk.GLTextureBuilder:context],
+ * [property@Gdk.GLTextureBuilder:id], [property@Gdk.GLTextureBuilder:width], and 
+ * [property@Gdk.GLTextureBuilder:height] are mandatory - and then call
+ * [method@Gdk.GLTextureBuilder.build] to create the new texture.
+ *
+ * `GdkGLTextureBuilder` can be used for quick one-shot construction of
+ * textures as well as kept around and reused to construct multiple textures.
+ *
+ * Since: 4.12
+ */
+
+enum
+{
+  PROP_0,
+  PROP_CONTEXT,
+  PROP_FORMAT,
+  PROP_HAS_MIPMAP,
+  PROP_HEIGHT,
+  PROP_ID,
+  PROP_SYNC,
+  PROP_WIDTH,
+
+  N_PROPS
+};
+
+G_DEFINE_TYPE (GdkGLTextureBuilder, gdk_gl_texture_builder, G_TYPE_OBJECT)
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gdk_gl_texture_builder_dispose (GObject *object)
+{
+  GdkGLTextureBuilder *self = GDK_GL_TEXTURE_BUILDER (object);
+
+  g_clear_object (&self->context);
+
+  G_OBJECT_CLASS (gdk_gl_texture_builder_parent_class)->dispose (object);
+}
+
+static void
+gdk_gl_texture_builder_get_property (GObject    *object,
+                                     guint       property_id,
+                                     GValue     *value,
+                                     GParamSpec *pspec)
+{
+  GdkGLTextureBuilder *self = GDK_GL_TEXTURE_BUILDER (object);
+
+  switch (property_id)
+    {
+    case PROP_CONTEXT:
+      g_value_set_object (value, self->context);
+      break;
+
+    case PROP_FORMAT:
+      g_value_set_enum (value, self->format);
+      break;
+
+    case PROP_HAS_MIPMAP:
+      g_value_set_boolean (value, self->has_mipmap);
+      break;
+
+    case PROP_HEIGHT:
+      g_value_set_int (value, self->height);
+      break;
+
+    case PROP_ID:
+      g_value_set_uint (value, self->id);
+      break;
+
+    case PROP_SYNC:
+      g_value_set_pointer (value, self->sync);
+      break;
+
+    case PROP_WIDTH:
+      g_value_set_int (value, self->width);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gdk_gl_texture_builder_set_property (GObject      *object,
+                                     guint         property_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec)
+{
+  GdkGLTextureBuilder *self = GDK_GL_TEXTURE_BUILDER (object);
+
+  switch (property_id)
+    {
+    case PROP_CONTEXT:
+      gdk_gl_texture_builder_set_context (self, g_value_get_object (value));
+      break;
+
+    case PROP_FORMAT:
+      gdk_gl_texture_builder_set_format (self, g_value_get_enum (value));
+      break;
+
+    case PROP_HAS_MIPMAP:
+      gdk_gl_texture_builder_set_has_mipmap (self, g_value_get_boolean (value));
+      break;
+
+    case PROP_HEIGHT:
+      gdk_gl_texture_builder_set_height (self, g_value_get_int (value));
+      break;
+
+    case PROP_ID:
+      gdk_gl_texture_builder_set_id (self, g_value_get_uint (value));
+      break;
+
+    case PROP_SYNC:
+      gdk_gl_texture_builder_set_sync (self, g_value_get_pointer (value));
+      break;
+
+    case PROP_WIDTH:
+      gdk_gl_texture_builder_set_width (self, g_value_get_int (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gdk_gl_texture_builder_class_init (GdkGLTextureBuilderClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->dispose = gdk_gl_texture_builder_dispose;
+  gobject_class->get_property = gdk_gl_texture_builder_get_property;
+  gobject_class->set_property = gdk_gl_texture_builder_set_property;
+
+  /**
+   * GdkGLTextureBuilder:context: (attributes org.gdk.Property.get=gdk_gl_texture_builder_get_context org.gdk.Property.set=gdk_gl_texture_builder_set_context)
+   *
+   * The context owning the texture.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_CONTEXT] =
+    g_param_spec_object ("context", NULL, NULL,
+                         GDK_TYPE_GL_CONTEXT,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkGLTextureBuilder:format: (attributes org.gdk.Property.get=gdk_gl_texture_builder_get_format org.gdk.Property.set=gdk_gl_texture_builder_set_format)
+   *
+   * The format when downloading the texture.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_FORMAT] =
+    g_param_spec_enum ("format", NULL, NULL,
+                       GDK_TYPE_MEMORY_FORMAT,
+                       GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkGLTextureBuilder:has-mipmap: (attributes org.gdk.Property.get=gdk_gl_texture_builder_get_has_mipmap org.gdk.Property.set=gdk_gl_texture_builder_set_has_mipmap)
+   *
+   * If the texture has a mipmap.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_HAS_MIPMAP] =
+    g_param_spec_boolean ("has-mipmap", NULL, NULL,
+                          FALSE,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkGLTextureBuilder:height: (attributes org.gdk.Property.get=gdk_gl_texture_builder_get_height org.gdk.Property.set=gdk_gl_texture_builder_set_height)
+   *
+   * The height of the texture.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_HEIGHT] =
+    g_param_spec_int ("height", NULL, NULL,
+                      G_MININT, G_MAXINT, 0,
+                      G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkGLTextureBuilder:id: (attributes org.gdk.Property.get=gdk_gl_texture_builder_get_id org.gdk.Property.set=gdk_gl_texture_builder_set_id)
+   *
+   * The texture ID to use.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_ID] =
+    g_param_spec_uint ("id", NULL, NULL,
+                       0, G_MAXUINT, 0,
+                       G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkGLTextureBuilder:sync: (attributes org.gdk.Property.get=gdk_gl_texture_builder_get_sync org.gdk.Property.set=gdk_gl_texture_builder_set_sync)
+   *
+   * An optional `GLSync` object.
+   *
+   * If this is set, GTK will wait on it before using the texture.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_SYNC] =
+    g_param_spec_pointer ("sync", NULL, NULL,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  /**
+   * GdkGLTextureBuilder:width: (attributes org.gdk.Property.get=gdk_gl_texture_builder_get_width org.gdk.Property.set=gdk_gl_texture_builder_set_width)
+   *
+   * The width of the texture.
+   *
+   * Since: 4.12
+   */
+  properties[PROP_WIDTH] =
+    g_param_spec_int ("width", NULL, NULL,
+                      G_MININT, G_MAXINT, 0,
+                      G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gdk_gl_texture_builder_init (GdkGLTextureBuilder *self)
+{
+  self->format = GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
+}
+
+/**
+ * gdk_gl_texture_builder_new: (constructor):
+ *
+ * Creates a new texture builder.
+ *
+ * Returns: the new `GdkTextureBuilder`
+ *
+ * Since: 4.12
+ **/
+GdkGLTextureBuilder *
+gdk_gl_texture_builder_new (void)
+{
+  return g_object_new (GDK_TYPE_GL_TEXTURE_BUILDER, NULL);
+}
+
+/**
+ * gdk_gl_texture_builder_get_context: (attributes org.gdk.Method.get_property=context)
+ * @self: a `GdkGLTextureBuilder`
+ *
+ * Gets the context previously set via gdk_gl_texture_builder_set_context() or
+ * %NULL if none was set.
+ *
+ * Returns: (transfer none) (nullable): The context
+ *
+ * Since: 4.12
+ */
+GdkGLContext *
+gdk_gl_texture_builder_get_context (GdkGLTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), NULL);
+
+  return self->context;
+}
+
+/**
+ * gdk_gl_texture_builder_set_context: (attributes org.gdk.Method.set_property=context)
+ * @self: a `GdkGLTextureBuilder`
+ * @context: (nullable): The context the texture beongs to or %NULL to unset
+ *
+ * Sets the context to be used for the texture. This is the context that owns
+ * the texture.
+ *
+ * The context must be set before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.12
+ */
+void
+gdk_gl_texture_builder_set_context (GdkGLTextureBuilder *self,
+                                    GdkGLContext        *context)
+{
+  g_return_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self));
+  g_return_if_fail (context == NULL || GDK_IS_GL_CONTEXT (context));
+
+  if (!g_set_object (&self->context, context))
+    return;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_CONTEXT]);
+}
+
+/**
+ * gdk_gl_texture_builder_get_height: (attributes org.gdk.Method.get_property=height)
+ * @self: a `GdkGLTextureBuilder`
+ *
+ * Gets the height previously set via gdk_gl_texture_builder_set_height() or
+ * 0 if the height wasn't set.
+ *
+ * Returns: The height
+ *
+ * Since: 4.12
+ */
+int
+gdk_gl_texture_builder_get_height (GdkGLTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), 0);
+
+  return self->height;
+}
+
+/**
+ * gdk_gl_texture_builder_set_height: (attributes org.gdk.Method.set_property=height)
+ * @self: a `GdkGLTextureBuilder`
+ * @height: The texture's height or 0 to unset
+ *
+ * Sets the height of the texture.
+ *
+ * The height must be set before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.12
+ */
+void
+gdk_gl_texture_builder_set_height (GdkGLTextureBuilder *self,
+                                   int                  height)
+{
+  g_return_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self));
+
+  if (self->height == height)
+    return;
+
+  self->height = height;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HEIGHT]);
+}
+
+/**
+ * gdk_gl_texture_builder_get_id: (attributes org.gdk.Method.get_property=id)
+ * @self: a `GdkGLTextureBuilder`
+ *
+ * Gets the texture id previously set via gdk_gl_texture_builder_set_id() or
+ * 0 if the id wasn't set.
+ *
+ * Returns: The id
+ *
+ * Since: 4.12
+ */
+guint
+gdk_gl_texture_builder_get_id (GdkGLTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), 0);
+
+  return self->id;
+}
+
+/**
+ * gdk_gl_texture_builder_set_id: (attributes org.gdk.Method.set_property=id)
+ * @self: a `GdkGLTextureBuilder`
+ * @id: The texture id to be used for creating the texture
+ *
+ * Sets the texture id of the texture. The texture id must remain unmodified
+ * until the texture was finalized. See [method@Gdk.GLTextureBuilder.build]
+ * for a longer discussion.
+ *
+ * The id must be set before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.12
+ */
+void
+gdk_gl_texture_builder_set_id (GdkGLTextureBuilder *self,
+                               guint                id)
+{
+  g_return_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self));
+
+  if (self->id == id)
+    return;
+
+  self->id = id;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ID]);
+}
+
+/**
+ * gdk_gl_texture_builder_get_width: (attributes org.gdk.Method.get_property=width)
+ * @self: a `GdkGLTextureBuilder`
+ *
+ * Gets the width previously set via gdk_gl_texture_builder_set_width() or
+ * 0 if the width wasn't set.
+ *
+ * Returns: The width
+ *
+ * Since: 4.12
+ */
+int
+gdk_gl_texture_builder_get_width (GdkGLTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), 0);
+
+  return self->width;
+}
+
+/**
+ * gdk_gl_texture_builder_set_width: (attributes org.gdk.Method.set_property=width)
+ * @self: a `GdkGLTextureBuilder`
+ * @width: The texture's width or 0 to unset
+ *
+ * Sets the width of the texture.
+ *
+ * The width must be set before calling [method@Gdk.GLTextureBuilder.build].
+ *
+ * Since: 4.12
+ */
+void
+gdk_gl_texture_builder_set_width (GdkGLTextureBuilder *self,
+                                  int                  width)
+{
+  g_return_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self));
+
+  if (self->width == width)
+    return;
+
+  self->width = width;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_WIDTH]);
+}
+
+/**
+ * gdk_gl_texture_builder_get_has_mipmap: (attributes org.gdk.Method.get_property=has-mipmap)
+ * @self: a `GdkGLTextureBuilder`
+ *
+ * Gets whether the texture has a mipmap.
+ *
+ * Returns: Whether the texture has a mipmap
+ *
+ * Since: 4.12
+ */
+gboolean
+gdk_gl_texture_builder_get_has_mipmap (GdkGLTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), FALSE);
+
+  return self->has_mipmap;
+}
+
+/**
+ * gdk_gl_texture_builder_set_has_mipmap: (attributes org.gdk.Method.set_property=has-mipmap)
+ * @self: a `GdkGLTextureBuilder`
+ * @has_mipmap: Whether the texture has a mipmap
+ *
+ * Sets whether the texture has a mipmap. This allows the renderer and other users of the
+ * generated texture to use a higher quality downscaling.
+ *
+ * Typically, the `glGenerateMipmap` function is used to generate a mimap.
+ *
+ * Since: 4.12
+ */
+void
+gdk_gl_texture_builder_set_has_mipmap (GdkGLTextureBuilder *self,
+                                       gboolean             has_mipmap)
+{
+  g_return_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self));
+
+  if (self->has_mipmap == has_mipmap)
+    return;
+
+  self->has_mipmap = has_mipmap;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HAS_MIPMAP]);
+}
+
+/**
+ * gdk_gl_texture_builder_get_sync: (attributes org.gdk.Method.get_property=sync)
+ * @self: a `GdkGLTextureBuilder`
+ *
+ * Gets the `GLsync` previously set via gdk_gl_texture_builder_set_sync().
+ *
+ * Returns: (nullable): the `GLSync`
+ *
+ * Since: 4.12
+ */
+gpointer
+gdk_gl_texture_builder_get_sync (GdkGLTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), NULL);
+
+  return self->sync;
+}
+
+/**
+ * gdk_gl_texture_builder_set_sync: (attributes org.gdk.Method.set_property=sync)
+ * @self: a `GdkGLTextureBuilder`
+ * @sync: (nullable): the GLSync object
+ *
+ * Sets the GLSync object to use for the texture.
+ *
+ * GTK will wait on this object before using the created `GdkTexture`.
+ *
+ * The `destroy` function that is passed to [method@Gdk.GLTextureBuilder.build]
+ * is responsible for freeing the sync object when it is no longer needed.
+ * The texture builder does not destroy it and it is the callers
+ * responsibility to make sure it doesn't leak.
+ *
+ * Since: 4.12
+ */
+void
+gdk_gl_texture_builder_set_sync (GdkGLTextureBuilder *self,
+                                 gpointer             sync)
+{
+  g_return_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self));
+
+  if (self->sync == sync)
+    return;
+
+  self->sync = sync;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SYNC]);
+}
+
+/**
+ * gdk_gl_texture_builder_get_format: (attributes org.gdk.Method.get_property=format)
+ * @self: a `GdkGLTextureBuilder`
+ *
+ * Gets the format previously set via gdk_gl_texture_builder_set_format().
+ *
+ * Returns: The format
+ *
+ * Since: 4.12
+ */
+GdkMemoryFormat
+gdk_gl_texture_builder_get_format (GdkGLTextureBuilder *self)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), GDK_MEMORY_R8G8B8A8_PREMULTIPLIED);
+
+  return self->format;
+}
+
+/**
+ * gdk_gl_texture_builder_set_format: (attributes org.gdk.Method.set_property=format)
+ * @self: a `GdkGLTextureBuilder`
+ * @format: The texture's format
+ *
+ * Sets the format of the texture. The default is `GDK_MEMORY_R8G8B8A8_PREMULTIPLIED`.
+ *
+ * The format is the preferred format the texture data should be downloaded to. The
+ * format must be supported by the GL version of [property@Gdk.GLTextureBuilder:context].
+ *
+ * Setting the right format is particularly useful when using high bit depth textures
+ * to preserve the bit depth, to set the correct value for unpremultiplied textures
+ * and to make sure opaque textures are treated as such.
+ *
+ * Since: 4.12
+ */
+void
+gdk_gl_texture_builder_set_format (GdkGLTextureBuilder *self,
+                                   GdkMemoryFormat      format)
+{
+  g_return_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self));
+
+  if (self->format == format)
+    return;
+
+  self->format = format;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FORMAT]);
+}
+
+/**
+ * gdk_gl_texture_builder_build:
+ * @self: a `GdkGLTextureBuilder`
+ * @destroy: (nullable): destroy function to be called when the texture is
+ *   released
+ * @data: user data to pass to the destroy function
+ *
+ * Builds a new `GdkTexture` with the values set up in the builder.
+ *
+ * The `destroy` function gets called when the returned texture gets released;
+ * either when the texture is finalized or by an explicit call to
+ * [method@Gdk.GLTexture.release]. It should release all GL resources associated
+ * with the texture, such as the [property@Gdk.GLTextureBuilder:id] and the
+ * [property@Gdk.GLTextureBuilder:sync].
+ *
+ * Note that it is a programming error to call this function if any mandatory
+ * property has not been set.
+ *
+ * It is possible to call this function multiple times to create multiple textures,
+ * possibly with changing properties in between.
+ *
+ * Returns: (transfer full): a newly built `GdkTexture`
+ *
+ * Since: 4.12
+ */
+GdkTexture *
+gdk_gl_texture_builder_build (GdkGLTextureBuilder *self,
+                              GDestroyNotify       destroy,
+                              gpointer             data)
+{
+  g_return_val_if_fail (GDK_IS_GL_TEXTURE_BUILDER (self), NULL);
+  g_return_val_if_fail (destroy == NULL || data != NULL, NULL);
+  g_return_val_if_fail (self->context != NULL, NULL);
+  g_return_val_if_fail (self->id != 0, NULL);
+  g_return_val_if_fail (self->width > 0, NULL);
+  g_return_val_if_fail (self->height > 0, NULL);
+
+  return gdk_gl_texture_new_from_builder (self, destroy, data);
+}
+

gdk/gdkgltexturebuilder.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2023 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#pragma once
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#include <gdk/gdkenums.h>
+#include <gdk/gdktypes.h>
+#include <gdk/gdkversionmacros.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_GL_TEXTURE_BUILDER (gdk_gl_texture_builder_get_type ())
+GDK_AVAILABLE_IN_4_12
+GDK_DECLARE_INTERNAL_TYPE (GdkGLTextureBuilder, gdk_gl_texture_builder, GDK, GL_TEXTURE_BUILDER, GObject)
+
+GDK_AVAILABLE_IN_4_12
+GdkGLTextureBuilder *   gdk_gl_texture_builder_new              (void);
+
+GDK_AVAILABLE_IN_4_12
+GdkGLContext *          gdk_gl_texture_builder_get_context      (GdkGLTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void                    gdk_gl_texture_builder_set_context      (GdkGLTextureBuilder    *self,
+                                                                 GdkGLContext           *context);
+
+GDK_AVAILABLE_IN_4_12
+guint                   gdk_gl_texture_builder_get_id           (GdkGLTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void                    gdk_gl_texture_builder_set_id           (GdkGLTextureBuilder    *self,
+                                                                 guint                   id);
+
+GDK_AVAILABLE_IN_4_12
+int                     gdk_gl_texture_builder_get_width        (GdkGLTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void                    gdk_gl_texture_builder_set_width        (GdkGLTextureBuilder    *self,
+                                                                 int                     width);
+
+GDK_AVAILABLE_IN_4_12
+int                     gdk_gl_texture_builder_get_height       (GdkGLTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void                    gdk_gl_texture_builder_set_height       (GdkGLTextureBuilder    *self,
+                                                                 int                     height);
+
+GDK_AVAILABLE_IN_4_12
+GdkMemoryFormat         gdk_gl_texture_builder_get_format       (GdkGLTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void                    gdk_gl_texture_builder_set_format       (GdkGLTextureBuilder    *self,
+                                                                 GdkMemoryFormat         format);
+
+GDK_AVAILABLE_IN_4_12
+gboolean                gdk_gl_texture_builder_get_has_mipmap   (GdkGLTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void                    gdk_gl_texture_builder_set_has_mipmap   (GdkGLTextureBuilder    *self,
+                                                                 gboolean                has_mipmap);
+
+GDK_AVAILABLE_IN_4_12
+gpointer                gdk_gl_texture_builder_get_sync         (GdkGLTextureBuilder    *self) G_GNUC_PURE;
+GDK_AVAILABLE_IN_4_12
+void                    gdk_gl_texture_builder_set_sync         (GdkGLTextureBuilder    *self,
+                                                                 gpointer                sync);
+
+GDK_AVAILABLE_IN_4_12
+GdkTexture *            gdk_gl_texture_builder_build            (GdkGLTextureBuilder    *self,
+                                                                 GDestroyNotify          destroy,
+                                                                 gpointer                data);
+
+G_END_DECLS
+

gdk/gdkgltextureprivate.h

@@ -2,13 +2,20 @@
 
 #include "gdkgltexture.h"
 
+#include "gdkgltexturebuilder.h"
 #include "gdktextureprivate.h"
 
 G_BEGIN_DECLS
 
+GdkTexture *            gdk_gl_texture_new_from_builder (GdkGLTextureBuilder    *builder,
+                                                         GDestroyNotify          destroy,
+                                                         gpointer                data);
+
+
 GdkGLContext *          gdk_gl_texture_get_context      (GdkGLTexture           *self);
 guint                   gdk_gl_texture_get_id           (GdkGLTexture           *self);
 gboolean                gdk_gl_texture_has_mipmap       (GdkGLTexture           *self);
+gpointer                gdk_gl_texture_get_sync         (GdkGLTexture           *self);
 
 G_END_DECLS
 

gdk/gdkglversionprivate.h

@@ -0,0 +1,138 @@
+/* GDK - The GIMP Drawing Kit
+ *
+ * gdkglcontextprivate.h: GL context abstraction
+ *
+ * Copyright © 2014  Emmanuele Bassi
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <gdkenums.h>
+
+G_BEGIN_DECLS
+
+/* Version requirements for EGL contexts.
+ *
+ * If you add support for EGL to your backend, please require this.
+ */
+#define GDK_EGL_MIN_VERSION_MAJOR (1)
+#define GDK_EGL_MIN_VERSION_MINOR (4)
+
+/* Minimum OpenGL versions supported by GTK.
+ * Backends should make sure to never create a context of a previous version.
+ *
+ * The macros refer to OpenGL; OpenGL with OPENGL_COMPATIBILITY_PROFILE_BIT as
+ * OPENGL_PROFILE_MASK; and OpenGL ES respectively
+ */
+#define GDK_GL_MIN_GL_VERSION GDK_GL_VERSION_INIT (3, 2)
+#define GDK_GL_MIN_GL_LEGACY_VERSION GDK_GL_VERSION_INIT (3, 0)
+#define GDK_GL_MIN_GLES_VERSION GDK_GL_VERSION_INIT (2, 0)
+
+typedef struct _GdkGLVersion GdkGLVersion;
+
+struct _GdkGLVersion
+{
+  int major;
+  int minor;
+};
+
+#define GDK_GL_VERSION_INIT(maj,min) { maj, min }
+
+static const GdkGLVersion supported_gl_versions[] = {
+  GDK_GL_VERSION_INIT (4, 6),
+  GDK_GL_VERSION_INIT (4, 5),
+  GDK_GL_VERSION_INIT (4, 4),
+  GDK_GL_VERSION_INIT (4, 3),
+  GDK_GL_VERSION_INIT (4, 2),
+  GDK_GL_VERSION_INIT (4, 1),
+  GDK_GL_VERSION_INIT (4, 0),
+  GDK_GL_VERSION_INIT (3, 3),
+  GDK_GL_VERSION_INIT (3, 2),
+  GDK_GL_VERSION_INIT (3, 1),
+  GDK_GL_VERSION_INIT (3, 0),
+
+  GDK_GL_VERSION_INIT (0, 0)
+};
+
+static const GdkGLVersion supported_gles_versions[] = {
+  GDK_GL_VERSION_INIT (3, 2),
+  GDK_GL_VERSION_INIT (3, 1),
+  GDK_GL_VERSION_INIT (3, 0),
+  GDK_GL_VERSION_INIT (2, 0),
+
+  GDK_GL_VERSION_INIT (0, 0)
+};
+
+#undef GDK_GL_VERSION_INIT
+#define GDK_GL_VERSION_INIT(maj,min) (GdkGLVersion) { maj, min }
+#define GDK_GL_VERSION_STRING(str) GDK_GL_VERSION_INIT(str[0] - '0', str[2] - '0')
+
+static inline const GdkGLVersion *
+gdk_gl_versions_get_for_api (GdkGLAPI api)
+{
+  switch (api)
+    {
+      case GDK_GL_API_GL:
+        return supported_gl_versions;
+      case GDK_GL_API_GLES:
+        return supported_gles_versions;
+      default:
+        g_assert_not_reached ();
+        return NULL;
+    }
+}
+
+static inline int
+gdk_gl_version_get_major (const GdkGLVersion *self)
+{
+  return self->major;
+}
+
+static inline int
+gdk_gl_version_get_minor (const GdkGLVersion *self)
+{
+  return self->minor;
+}
+
+static inline int
+gdk_gl_version_compare (const GdkGLVersion *a,
+                        const GdkGLVersion *b)
+{
+  if (a->major > b->major)
+    return 1;
+  if (a->major < b->major)
+    return -1;
+
+  if (a->minor > b->minor)
+    return 1;
+  if (a->minor < b->minor)
+    return -1;
+
+  return 0;
+}
+
+static inline gboolean
+gdk_gl_version_greater_equal (const GdkGLVersion *a,
+                              const GdkGLVersion *b)
+{
+  return gdk_gl_version_compare (a, b) >= 0;
+}
+
+/* in gdkglcontext.c */
+void            gdk_gl_version_init_epoxy                       (GdkGLVersion           *version);
+
+G_END_DECLS
+

gdk/gdkmemoryformat.c

@@ -220,7 +220,12 @@ struct _GdkMemoryFormatDescription
   gsize bytes_per_pixel;
   gsize alignment;
   gboolean prefers_high_depth;
-  gboolean supports_gles;
+  struct {
+    guint gl_major;
+    guint gl_minor;
+    guint gles_major;
+    guint gles_minor;
+  } min_gl_version;
   struct {
     guint internal_format;
     guint format;
@@ -245,7 +250,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     4,
     G_ALIGNOF (guchar),
     FALSE,
-    FALSE,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
     { GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE },
     b8g8r8a8_premultiplied_to_float,
     b8g8r8a8_premultiplied_from_float,
@@ -255,7 +260,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     4,
     G_ALIGNOF (guchar),
     FALSE,
-    FALSE,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
     { GL_RGBA8, GL_BGRA, GDK_GL_UNSIGNED_BYTE_FLIPPED },
     a8r8g8b8_premultiplied_to_float,
     a8r8g8b8_premultiplied_from_float,
@@ -265,7 +270,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     4,
     G_ALIGNOF (guchar),
     FALSE,
-    TRUE,
+    { 0, 0, 0, 0 },
     { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE },
     r8g8b8a8_premultiplied_to_float,
     r8g8b8a8_premultiplied_from_float,
@@ -275,7 +280,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     4,
     G_ALIGNOF (guchar),
     FALSE,
-    FALSE,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
     { GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE },
     b8g8r8a8_to_float,
     b8g8r8a8_from_float,
@@ -285,7 +290,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     4,
     G_ALIGNOF (guchar),
     FALSE,
-    FALSE,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
     { GL_RGBA8, GL_RGBA, GDK_GL_UNSIGNED_BYTE_FLIPPED },
     a8r8g8b8_to_float,
     a8r8g8b8_from_float,
@@ -295,7 +300,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     4,
     G_ALIGNOF (guchar),
     FALSE,
-    TRUE,
+    { 0, 0, 0, 0 },
     { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE },
     r8g8b8a8_to_float,
     r8g8b8a8_from_float,
@@ -305,7 +310,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     4,
     G_ALIGNOF (guchar),
     FALSE,
-    FALSE,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
     { GL_RGBA8, GL_BGRA, GDK_GL_UNSIGNED_BYTE_FLIPPED },
     a8b8g8r8_to_float,
     a8b8g8r8_from_float,
@@ -315,7 +320,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     3,
     G_ALIGNOF (guchar),
     FALSE,
-    TRUE,
+    { 0, 0, 0, 0 },
     { GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE },
     r8g8b8_to_float,
     r8g8b8_from_float,
@@ -325,7 +330,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     3,
     G_ALIGNOF (guchar),
     FALSE,
-    FALSE,
+    { 0, 0, G_MAXUINT, G_MAXUINT },
     { GL_RGB8, GL_BGR, GL_UNSIGNED_BYTE },
     b8g8r8_to_float,
     b8g8r8_from_float,
@@ -335,7 +340,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     6,
     G_ALIGNOF (guint16),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGB16, GL_RGB, GL_UNSIGNED_SHORT },
     r16g16b16_to_float,
     r16g16b16_from_float,
@@ -345,7 +350,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     8,
     G_ALIGNOF (guint16),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT },
     r16g16b16a16_to_float,
     r16g16b16a16_from_float,
@@ -355,7 +360,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     8,
     G_ALIGNOF (guint16),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT },
     r16g16b16a16_to_float,
     r16g16b16a16_from_float,
@@ -365,7 +370,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     6,
     G_ALIGNOF (guint16),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGB16F, GL_RGB, GL_HALF_FLOAT },
     r16g16b16_float_to_float,
     r16g16b16_float_from_float,
@@ -375,7 +380,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     8,
     G_ALIGNOF (guint16),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT },
     r16g16b16a16_float_to_float,
     r16g16b16a16_float_from_float,
@@ -385,7 +390,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     8,
     G_ALIGNOF (guint16),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT },
     r16g16b16a16_float_to_float,
     r16g16b16a16_float_from_float,
@@ -395,7 +400,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     12,
     G_ALIGNOF (float),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGB32F, GL_RGB, GL_FLOAT },
     r32g32b32_float_to_float,
     r32g32b32_float_from_float,
@@ -405,7 +410,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     16,
     G_ALIGNOF (float),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGBA32F, GL_RGBA, GL_FLOAT },
     r32g32b32a32_float_to_float,
     r32g32b32a32_float_from_float,
@@ -415,7 +420,7 @@ static const GdkMemoryFormatDescription memory_formats[GDK_MEMORY_N_FORMATS] = {
     16,
     G_ALIGNOF (float),
     TRUE,
-    TRUE,
+    { 0, 0, 3, 0 },
     { GL_RGBA32F, GL_RGBA, GL_FLOAT },
     r32g32b32a32_float_to_float,
     r32g32b32a32_float_from_float,
@@ -463,6 +468,8 @@ gdk_memory_format_prefers_high_depth (GdkMemoryFormat format)
 gboolean
 gdk_memory_format_gl_format (GdkMemoryFormat  format,
                              gboolean         gles,
+                             guint            gl_major,
+                             guint            gl_minor,
                              guint           *out_internal_format,
                              guint           *out_format,
                              guint           *out_type)
@@ -474,8 +481,20 @@ gdk_memory_format_gl_format (GdkMemoryFormat  format,
   if (memory_formats[format].alpha == GDK_MEMORY_ALPHA_STRAIGHT)
     return FALSE;
 
-  if (gles && !memory_formats[format].supports_gles)
-    return FALSE;
+  if (gles)
+    {
+      if (memory_formats[format].min_gl_version.gles_major > gl_major ||
+          (memory_formats[format].min_gl_version.gles_major == gl_major &&
+           memory_formats[format].min_gl_version.gles_minor > gl_minor))
+        return FALSE;
+    }
+  else
+    {
+      if (memory_formats[format].min_gl_version.gl_major > gl_major ||
+          (memory_formats[format].min_gl_version.gl_major == gl_major &&
+           memory_formats[format].min_gl_version.gl_minor > gl_minor))
+        return FALSE;
+    }
 
   return TRUE;
 }

gdk/gdkmemoryformatprivate.h

@@ -35,6 +35,8 @@ gsize                   gdk_memory_format_bytes_per_pixel   (GdkMemoryFormat
 gboolean                gdk_memory_format_prefers_high_depth(GdkMemoryFormat             format) G_GNUC_CONST;
 gboolean                gdk_memory_format_gl_format         (GdkMemoryFormat             format,
                                                              gboolean                    gles,
+                                                             guint                       gl_major,
+                                                             guint                       gl_minor,
                                                              guint                      *out_internal_format,
                                                              guint                      *out_format,
                                                              guint                      *out_type);

gdk/gdkrectangleprivate.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "gdkrectangle.h"
+
+#include <math.h>
+
+G_BEGIN_DECLS
+
+/*
+ * gdk_rectangle_transform_affine:
+ * @src: the rectangle to transform
+ * @scale_x: scale factor in the X direction. The scale factor
+ *   may be negative or 0.
+ * @scale_y: scale factor in the Y direction. The scale factor
+ *   may be negative or 0.
+ * @offset_x: offset of result in X direction.
+ * @offset_y: offset of result in Y direction.
+ * @dest: (out caller-allocates): destination rectangle, may be
+ *   identical to @src
+ *
+ * Does an affine transform of the source rectangle and stores the
+ * result in the dest rectangle. If the destination rectangle does
+ * not fit on integer bounds, the result will be enlarged to make it
+ * fit.
+ * (Fun fact: This means with a scale of 0 and an offset of 0.5,
+ * the resulting rect will have a width of 1.)
+ * 
+ * The width and height of the result will be positive, even if the
+ * src rectangle or the scale were negative.
+ *
+ * This function can be used with the output of
+ * gsk_transform_to_affine().
+ **/
+static inline void
+gdk_rectangle_transform_affine (const GdkRectangle *src,
+                                float               scale_x,
+                                float               scale_y,
+                                float               offset_x,
+                                float               offset_y,
+                                GdkRectangle       *dest)
+{
+  float x1, x2, y1, y2;
+
+  x1 = offset_x + src->x * scale_x;
+  x2 = offset_x + (src->x + src->width) * scale_x;
+  y1 = offset_y + src->y * scale_y;
+  y2 = offset_y + (src->y + src->height) * scale_y;
+
+  dest->x = floorf (MIN (x1, x2));
+  dest->y = floorf (MIN (y1, y2));
+  dest->width = ceilf (MAX (x1, x2)) - dest->x;
+  dest->height = ceilf (MAX (y1, y2)) - dest->y;
+}
+
+
+G_END_DECLS
+

gdk/gdksurface.c

@@ -115,9 +115,6 @@ static void gdk_surface_get_property (GObject      *object,
 static void update_cursor               (GdkDisplay *display,
                                          GdkDevice  *device);
 
-static void gdk_surface_set_frame_clock (GdkSurface      *surface,
-                                         GdkFrameClock  *clock);
-
 static void gdk_surface_queue_set_is_mapped (GdkSurface *surface,
                                              gboolean    is_mapped);
 
@@ -496,11 +493,22 @@ gdk_surface_real_get_scale (GdkSurface *surface)
   return 1.0;
 }
 
+static void
+gdk_surface_constructed (GObject *object)
+{
+  G_GNUC_UNUSED GdkSurface *surface = GDK_SURFACE (object);
+
+  g_assert (surface->frame_clock != NULL);
+
+  G_OBJECT_CLASS (gdk_surface_parent_class)->constructed (object);
+}
+
 static void
 gdk_surface_class_init (GdkSurfaceClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
+  object_class->constructed = gdk_surface_constructed;
   object_class->finalize = gdk_surface_finalize;
   object_class->set_property = gdk_surface_set_property;
   object_class->get_property = gdk_surface_get_property;
@@ -845,21 +853,6 @@ _gdk_surface_update_size (GdkSurface *surface)
   g_object_notify (G_OBJECT (surface), "height");
 }
 
-static GdkSurface *
-gdk_surface_new (GdkDisplay     *display,
-                 GdkSurfaceType  surface_type,
-                 GdkSurface     *parent,
-                 int             x,
-                 int             y,
-                 int             width,
-                 int             height)
-{
-  return gdk_display_create_surface (display,
-                                     surface_type,
-                                     parent,
-                                     x, y, width, height);
-}
-
 /**
  * gdk_surface_new_toplevel: (constructor)
  * @display: the display to create the surface on
@@ -873,8 +866,9 @@ gdk_surface_new_toplevel (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
-  return gdk_surface_new (display, GDK_SURFACE_TOPLEVEL,
-                          NULL, 0, 0, 1, 1);
+  return g_object_new (GDK_DISPLAY_GET_CLASS (display)->toplevel_type,
+                       "display", display,
+                       NULL);
 }
 
 /**
@@ -894,11 +888,16 @@ gdk_surface_new_popup (GdkSurface *parent,
                        gboolean    autohide)
 {
   GdkSurface *surface;
+  GdkDisplay *display;
 
   g_return_val_if_fail (GDK_IS_SURFACE (parent), NULL);
 
-  surface = gdk_surface_new (parent->display, GDK_SURFACE_POPUP,
-                             parent, 0, 0, 100, 100);
+  display = gdk_surface_get_display (parent);
+
+  surface = g_object_new (GDK_DISPLAY_GET_CLASS (display)->popup_type,
+                         "display", display,
+                         "parent", parent,
+                         NULL);
 
   surface->autohide = autohide;
 
@@ -1270,40 +1269,6 @@ gdk_surface_create_vulkan_context (GdkSurface  *surface,
                          NULL);
 }
 
-/* Code for dirty-region queueing
- */
-static GSList *update_surfaces = NULL;
-
-static void
-gdk_surface_add_update_surface (GdkSurface *surface)
-{
-  GSList *tmp;
-
-  /*  Check whether "surface" is already in "update_surfaces" list.
-   *  It could be added during execution of gtk_widget_destroy() when
-   *  setting focus widget to NULL and redrawing old focus widget.
-   *  See bug 711552.
-   */
-  tmp = g_slist_find (update_surfaces, surface);
-  if (tmp != NULL)
-    return;
-
-  update_surfaces = g_slist_prepend (update_surfaces, g_object_ref (surface));
-}
-
-static void
-gdk_surface_remove_update_surface (GdkSurface *surface)
-{
-  GSList *link;
-
-  link = g_slist_find (update_surfaces, surface);
-  if (link != NULL)
-    {
-      update_surfaces = g_slist_delete_link (update_surfaces, link);
-      g_object_unref (surface);
-    }
-}
-
 static gboolean
 gdk_surface_is_toplevel_frozen (GdkSurface *surface)
 {
@@ -1332,46 +1297,6 @@ gdk_surface_schedule_update (GdkSurface *surface)
                                    GDK_FRAME_CLOCK_PHASE_PAINT);
 }
 
-static void
-gdk_surface_process_updates_internal (GdkSurface *surface)
-{
-  /* Ensure the surface lives while updating it */
-  g_object_ref (surface);
-
-  surface->in_update = TRUE;
-
-  /* If an update got queued during update processing, we can get a
-   * surface in the update queue that has an empty update_area.
-   * just ignore it.
-   */
-  if (surface->update_area)
-    {
-      g_assert (surface->active_update_area == NULL); /* No reentrancy */
-
-      surface->active_update_area = surface->update_area;
-      surface->update_area = NULL;
-
-      if (GDK_SURFACE_IS_MAPPED (surface))
-        {
-          cairo_region_t *expose_region;
-          gboolean handled;
-
-          expose_region = cairo_region_copy (surface->active_update_area);
-
-          g_signal_emit (surface, signals[RENDER], 0, expose_region, &handled);
-
-          cairo_region_destroy (expose_region);
-        }
-
-      cairo_region_destroy (surface->active_update_area);
-      surface->active_update_area = NULL;
-    }
-
-  surface->in_update = FALSE;
-
-  g_object_unref (surface);
-}
-
 static void
 gdk_surface_layout_on_clock (GdkFrameClock *clock,
                              void          *data)
@@ -1429,28 +1354,32 @@ gdk_surface_paint_on_clock (GdkFrameClock *clock,
                             void          *data)
 {
   GdkSurface *surface = GDK_SURFACE (data);
+  cairo_region_t *expose_region;
 
   g_return_if_fail (GDK_IS_SURFACE (surface));
 
-  if (GDK_SURFACE_DESTROYED (surface))
+  if (GDK_SURFACE_DESTROYED (surface) ||
+      !surface->update_area ||
+      surface->update_freeze_count ||
+      gdk_surface_is_toplevel_frozen (surface))
     return;
 
-  g_object_ref (surface);
+  surface->pending_phases &= ~GDK_FRAME_CLOCK_PHASE_PAINT;
+  expose_region = surface->update_area;
+  surface->update_area = NULL;
 
-  if (surface->update_area &&
-      !surface->update_freeze_count &&
-      !gdk_surface_is_toplevel_frozen (surface) &&
-
-      /* Don't recurse into process_updates_internal, we'll
-       * do the update later when idle instead. */
-      !surface->in_update)
+  if (GDK_SURFACE_IS_MAPPED (surface))
     {
-      surface->pending_phases &= ~GDK_FRAME_CLOCK_PHASE_PAINT;
-      gdk_surface_process_updates_internal (surface);
-      gdk_surface_remove_update_surface (surface);
+      gboolean handled;
+
+      g_object_ref (surface);
+
+      g_signal_emit (surface, signals[RENDER], 0, expose_region, &handled);
+
+      g_object_unref (surface);
     }
 
-  g_object_unref (surface);
+  cairo_region_destroy (expose_region);
 }
 
 /*
@@ -1498,7 +1427,6 @@ impl_surface_add_update_area (GdkSurface     *impl_surface,
     cairo_region_union (impl_surface->update_area, region);
   else
     {
-      gdk_surface_add_update_surface (impl_surface);
       impl_surface->update_area = cairo_region_copy (region);
       gdk_surface_schedule_update (impl_surface);
     }
@@ -1582,8 +1510,6 @@ _gdk_surface_clear_update_area (GdkSurface *surface)
 
   if (surface->update_area)
     {
-      gdk_surface_remove_update_surface (surface);
-
       cairo_region_destroy (surface->update_area);
       surface->update_area = NULL;
     }
@@ -2530,7 +2456,7 @@ gdk_surface_resume_events (GdkFrameClock *clock,
     }
 }
 
-static void
+void
 gdk_surface_set_frame_clock (GdkSurface     *surface,
                              GdkFrameClock *clock)
 {

gdk/gdksurfaceprivate.h

@@ -26,13 +26,6 @@
 
 G_BEGIN_DECLS
 
-typedef enum
-{
-  GDK_SURFACE_TOPLEVEL,
-  GDK_SURFACE_POPUP,
-  GDK_SURFACE_DRAG
-} GdkSurfaceType;
-
 struct _GdkSurface
 {
   GObject parent_instance;
@@ -55,10 +48,6 @@ struct _GdkSurface
   cairo_region_t *update_area;
   guint update_freeze_count;
   GdkFrameClockPhase pending_phases;
-  /* This is the update_area that was in effect when the current expose
-     started. It may be smaller than the expose area if we'e painting
-     more than we have to, but it represents the "true" damage. */
-  cairo_region_t *active_update_area;
 
   GdkToplevelState pending_set_flags;
   GdkToplevelState pending_unset_flags;
@@ -71,7 +60,6 @@ struct _GdkSurface
 
   guint modal_hint : 1;
   guint destroyed : 2;
-  guint in_update : 1;
   guint frame_clock_events_paused : 1;
   guint autohide : 1;
   guint shortcuts_inhibited : 1;
@@ -110,8 +98,6 @@ struct _GdkSurfaceClass
 {
   GObjectClass parent_class;
 
-  cairo_surface_t *
-               (* ref_cairo_surface)    (GdkSurface      *surface);
   void         (* hide)                 (GdkSurface      *surface);
   void         (* get_geometry)         (GdkSurface      *surface,
                                          int             *x,
@@ -292,6 +278,8 @@ void gdk_surface_get_geometry (GdkSurface *surface,
                                int        *width,
                                int        *height);
 
+void                    gdk_surface_set_frame_clock             (GdkSurface             *surface,
+                                                                 GdkFrameClock          *clock);
 void                    gdk_surface_set_egl_native_window       (GdkSurface             *self,
                                                                  gpointer                native_window);
 void                    gdk_surface_ensure_egl_surface          (GdkSurface             *self,

gdk/gdkvulkancontext.c

@@ -243,6 +243,74 @@ gdk_vulkan_strerror (VkResult result)
   }
 }
 
+#ifdef G_ENABLE_DEBUG
+static const char *
+surface_present_mode_to_string (VkPresentModeKHR present_mode)
+{
+  switch (present_mode)
+    {
+    case VK_PRESENT_MODE_MAILBOX_KHR:
+      return "VK_PRESENT_MODE_MAILBOX_KHR";
+    case VK_PRESENT_MODE_IMMEDIATE_KHR:
+      return "VK_PRESENT_MODE_IMMEDIATE_KHR";
+    case VK_PRESENT_MODE_FIFO_KHR:
+      return "VK_PRESENT_MODE_FIFO_KHR";
+    case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
+      return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
+    case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
+    case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
+    case VK_PRESENT_MODE_MAX_ENUM_KHR:
+    default:
+      return "(invalid)";
+    }
+
+  return "(unknown)";
+}
+#endif
+
+static const VkPresentModeKHR preferred_present_modes[] = {
+  VK_PRESENT_MODE_MAILBOX_KHR,
+  VK_PRESENT_MODE_IMMEDIATE_KHR,
+};
+
+static VkPresentModeKHR
+find_best_surface_present_mode (GdkVulkanContext *context)
+{
+  GdkVulkanContextPrivate *priv = gdk_vulkan_context_get_instance_private (context);
+  VkPresentModeKHR *available_present_modes;
+  uint32_t n_present_modes;
+  VkResult res;
+
+  res = GDK_VK_CHECK (vkGetPhysicalDeviceSurfacePresentModesKHR, gdk_vulkan_context_get_physical_device (context),
+                                                                 priv->surface,
+                                                                 &n_present_modes,
+                                                                 NULL);
+
+  if (res != VK_SUCCESS)
+    goto fallback_present_mode;
+
+  available_present_modes = g_alloca (sizeof (VkPresentModeKHR) * n_present_modes);
+  res = GDK_VK_CHECK (vkGetPhysicalDeviceSurfacePresentModesKHR, gdk_vulkan_context_get_physical_device (context),
+                                                                 priv->surface,
+                                                                 &n_present_modes,
+                                                                 available_present_modes);
+
+  if (res != VK_SUCCESS)
+    goto fallback_present_mode;
+
+  for (uint32_t i = 0; i < G_N_ELEMENTS (preferred_present_modes); i++)
+    {
+      for (uint32_t j = 0; j < n_present_modes; j++)
+        {
+          if (preferred_present_modes[i] == available_present_modes[j])
+            return available_present_modes[j];
+        }
+    }
+
+fallback_present_mode:
+  return VK_PRESENT_MODE_FIFO_KHR;
+}
+
 static void
 gdk_vulkan_context_dispose (GObject *gobject)
 {
@@ -302,6 +370,7 @@ gdk_vulkan_context_check_swapchain (GdkVulkanContext  *context,
   GdkSurface *surface = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
   VkSurfaceCapabilitiesKHR capabilities;
   VkCompositeAlphaFlagBitsKHR composite_alpha;
+  VkPresentModeKHR present_mode;
   VkSwapchainKHR new_swapchain;
   VkResult res;
   VkDevice device;
@@ -333,6 +402,11 @@ gdk_vulkan_context_check_swapchain (GdkVulkanContext  *context,
       composite_alpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
     }
 
+  present_mode = find_best_surface_present_mode (context);
+
+  GDK_DEBUG (VULKAN, "Using surface present mode %s",
+             surface_present_mode_to_string (present_mode));
+
   /*
    * Per https://www.khronos.org/registry/vulkan/specs/1.0-wsi_extensions/xhtml/vkspec.html#VkSurfaceCapabilitiesKHR
    * the current extent may assume a special value, meaning that the extent should assume whatever
@@ -367,7 +441,7 @@ gdk_vulkan_context_check_swapchain (GdkVulkanContext  *context,
                                                 },
                                                 .preTransform = capabilities.currentTransform,
                                                 .compositeAlpha = composite_alpha,
-                                                .presentMode = VK_PRESENT_MODE_FIFO_KHR,
+                                                .presentMode = present_mode,
                                                 .clipped = VK_FALSE,
                                                 .oldSwapchain = priv->swapchain
                                             },

gdk/macos/gdkmacosdisplay-private.h

@@ -121,6 +121,8 @@ GdkMonitor      *_gdk_macos_display_get_monitor_at_coords          (GdkMacosDisp
 GdkMonitor      *_gdk_macos_display_get_monitor_at_display_coords  (GdkMacosDisplay *self,
                                                                     int              x,
                                                                     int              y);
+void             _gdk_macos_display_surface_added                  (GdkMacosDisplay *self,
+                                                                    GdkMacosSurface *surface);
 GdkEvent        *_gdk_macos_display_translate                      (GdkMacosDisplay *self,
                                                                     NSEvent         *event);
 void             _gdk_macos_display_feedback_init                  (GdkMacosDisplay *self);

gdk/macos/gdkmacosdisplay.c

@@ -36,8 +36,10 @@
 #include "gdkmacosglcontext-private.h"
 #include "gdkmacoskeymap-private.h"
 #include "gdkmacosmonitor-private.h"
+#include "gdkmacospopupsurface-private.h"
 #include "gdkmacosseat-private.h"
 #include "gdkmacossurface-private.h"
+#include "gdkmacostoplevelsurface-private.h"
 #include "gdkmacosutils-private.h"
 
 G_DEFINE_TYPE (GdkMacosDisplay, gdk_macos_display, GDK_TYPE_DISPLAY)
@@ -333,7 +335,7 @@ gdk_macos_display_queue_events (GdkDisplay *display)
     }
 }
 
-static void
+void
 _gdk_macos_display_surface_added (GdkMacosDisplay *self,
                                   GdkMacosSurface *surface)
 {
@@ -539,29 +541,6 @@ _gdk_macos_display_surface_resigned_main (GdkMacosDisplay *self,
   _gdk_macos_display_clear_sorting (self);
 }
 
-static GdkSurface *
-gdk_macos_display_create_surface (GdkDisplay     *display,
-                                  GdkSurfaceType  surface_type,
-                                  GdkSurface     *parent,
-                                  int             x,
-                                  int             y,
-                                  int             width,
-                                  int             height)
-{
-  GdkMacosDisplay *self = (GdkMacosDisplay *)display;
-  GdkMacosSurface *surface;
-
-  g_assert (GDK_IS_MACOS_DISPLAY (self));
-  g_assert (!parent || GDK_IS_MACOS_SURFACE (parent));
-
-  surface = _gdk_macos_surface_new (self, surface_type, parent, x, y, width, height);
-
-  if (surface != NULL)
-    _gdk_macos_display_surface_added (self, surface);
-
-  return GDK_SURFACE (surface);
-}
-
 static GdkKeymap *
 gdk_macos_display_get_keymap (GdkDisplay *display)
 {
@@ -617,10 +596,11 @@ gdk_macos_display_class_init (GdkMacosDisplayClass *klass)
 
   object_class->finalize = gdk_macos_display_finalize;
 
+  display_class->toplevel_type = GDK_TYPE_MACOS_TOPLEVEL_SURFACE;
+  display_class->popup_type = GDK_TYPE_MACOS_POPUP_SURFACE;
   display_class->cairo_context_type = GDK_TYPE_MACOS_CAIRO_CONTEXT;
 
   display_class->beep = gdk_macos_display_beep;
-  display_class->create_surface = gdk_macos_display_create_surface;
   display_class->flush = gdk_macos_display_flush;
   display_class->get_keymap = gdk_macos_display_get_keymap;
   display_class->get_monitors = gdk_macos_display_get_monitors;

gdk/macos/gdkmacosdragsurface-private.h

@@ -31,12 +31,7 @@ typedef struct _GdkMacosDragSurfaceClass GdkMacosDragSurfaceClass;
 #define GDK_IS_MACOS_DRAG_SURFACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_DRAG_SURFACE))
 
 GType            _gdk_macos_drag_surface_get_type (void);
-GdkMacosSurface *_gdk_macos_drag_surface_new      (GdkMacosDisplay *display,
-                                                   GdkFrameClock   *frame_clock,
-                                                   int              x,
-                                                   int              y,
-                                                   int              width,
-                                                   int              height);
+GdkMacosSurface *_gdk_macos_drag_surface_new      (GdkMacosDisplay *display);
 
 G_END_DECLS
 

gdk/macos/gdkmacosdragsurface.c

@@ -25,6 +25,8 @@
 #include "gdkmacosdisplay-private.h"
 #include "gdkmacosutils-private.h"
 
+#include "gdk/gdkframeclockidleprivate.h"
+
 struct _GdkMacosDragSurface
 {
   GdkMacosSurface parent_instance;
@@ -62,27 +64,15 @@ G_DEFINE_TYPE_WITH_CODE (GdkMacosDragSurface, _gdk_macos_drag_surface, GDK_TYPE_
                          G_IMPLEMENT_INTERFACE (GDK_TYPE_DRAG_SURFACE, drag_surface_iface_init))
 
 static void
-_gdk_macos_drag_surface_class_init (GdkMacosDragSurfaceClass *klass)
-{
-}
-
-static void
-_gdk_macos_drag_surface_init (GdkMacosDragSurface *self)
-{
-}
-
-GdkMacosSurface *
-_gdk_macos_drag_surface_new (GdkMacosDisplay *display,
-                             GdkFrameClock   *frame_clock,
-                             int              x,
-                             int              y,
-                             int              width,
-                             int              height)
+_gdk_macos_drag_surface_constructed (GObject *object)
 {
   GDK_BEGIN_MACOS_ALLOC_POOL;
 
   GdkMacosWindow *window;
-  GdkMacosSurface *self;
+  GdkMacosSurface *self = GDK_MACOS_SURFACE (object);
+  GdkSurface *surface = GDK_SURFACE (self);
+  GdkMacosDisplay *display = GDK_MACOS_DISPLAY (gdk_surface_get_display (GDK_SURFACE (self)));
+  GdkFrameClock *frame_clock;
   NSScreen *screen;
   NSUInteger style_mask;
   NSRect content_rect;
@@ -90,18 +80,15 @@ _gdk_macos_drag_surface_new (GdkMacosDisplay *display,
   int nx;
   int ny;
 
-  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (display), NULL);
-  g_return_val_if_fail (!frame_clock || GDK_IS_FRAME_CLOCK (frame_clock), NULL);
-
   style_mask = NSWindowStyleMaskBorderless;
 
-  _gdk_macos_display_to_display_coords (display, x, y, &nx, &ny);
+  _gdk_macos_display_to_display_coords (display, 0, 0, &nx, &ny);
 
   screen = _gdk_macos_display_get_screen_at_display_coords (display, nx, ny);
   screen_rect = [screen frame];
   nx -= screen_rect.origin.x;
   ny -= screen_rect.origin.y;
-  content_rect = NSMakeRect (nx, ny - height, width, height);
+  content_rect = NSMakeRect (nx, ny - 1, 1, 1);
 
   window = [[GdkMacosWindow alloc] initWithContentRect:content_rect
                                              styleMask:style_mask
@@ -113,13 +100,36 @@ _gdk_macos_drag_surface_new (GdkMacosDisplay *display,
   [window setBackgroundColor:[NSColor clearColor]];
   [window setDecorated:NO];
 
-  self = g_object_new (GDK_TYPE_MACOS_DRAG_SURFACE,
-                       "display", display,
-                       "frame-clock", frame_clock,
-                       "native", window,
-                       NULL);
+  _gdk_macos_surface_set_native (self, window);
+
+  frame_clock = _gdk_frame_clock_idle_new ();
+  gdk_surface_set_frame_clock (surface, frame_clock);
+  g_object_unref (frame_clock);
 
   GDK_END_MACOS_ALLOC_POOL;
 
-  return g_steal_pointer (&self);
+  G_OBJECT_CLASS (_gdk_macos_drag_surface_parent_class)->constructed (object);
+}
+
+static void
+_gdk_macos_drag_surface_class_init (GdkMacosDragSurfaceClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->constructed = _gdk_macos_drag_surface_constructed;
+}
+
+static void
+_gdk_macos_drag_surface_init (GdkMacosDragSurface *self)
+{
+}
+
+GdkMacosSurface *
+_gdk_macos_drag_surface_new (GdkMacosDisplay *display)
+{
+  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (display), NULL);
+
+  return g_object_new (GDK_TYPE_MACOS_DRAG_SURFACE,
+                       "display", display,
+                       NULL);
 }

gdk/macos/gdkmacosglcontext.c

@@ -323,12 +323,12 @@ gdk_macos_gl_context_release (GdkMacosGLContext *self)
 }
 
 static CGLPixelFormatObj
-create_pixel_format (int      major,
-                     int      minor,
-                     GError **error)
+create_pixel_format (GdkGLVersion  *version,
+                     gboolean      *out_legacy,
+                     GError       **error)
 {
   CGLPixelFormatAttribute attrs[] = {
-    kCGLPFAOpenGLProfile, (CGLPixelFormatAttribute)kCGLOGLPVersion_Legacy,
+    kCGLPFAOpenGLProfile, 0,
     kCGLPFAAllowOfflineRenderers, /* allow sharing across GPUs */
     kCGLPFADepthSize, 0,
     kCGLPFAStencilSize, 0,
@@ -339,14 +339,28 @@ create_pixel_format (int      major,
   CGLPixelFormatObj format = NULL;
   GLint n_format = 1;
 
-  if (major == 3 && minor == 2)
-    attrs[1] = (CGLPixelFormatAttribute)kCGLOGLPVersion_GL3_Core;
-  else if (major == 4 && minor == 1)
-    attrs[1] = (CGLPixelFormatAttribute)kCGLOGLPVersion_GL4_Core;
+  *out_legacy = FALSE;
 
+  if (gdk_gl_version_get_major (version) >= 4)
+    {
+      attrs[1] = (CGLPixelFormatAttribute)kCGLOGLPVersion_GL4_Core;
+      if (CGLChoosePixelFormat (attrs, &format, &n_format))
+        return g_steal_pointer (&format);
+    }
+
+  if (gdk_gl_version_greater_equal (version, &GDK_GL_MIN_GL_VERSION))
+    {
+      attrs[1] = (CGLPixelFormatAttribute)kCGLOGLPVersion_GL3_Core;
+      if (CGLChoosePixelFormat (attrs, &format, &n_format))
+        return g_steal_pointer (&format);
+    }
+
+  attrs[1] = (CGLPixelFormatAttribute) kCGLOGLPVersion_Legacy;
   if (!CHECK (error, CGLChoosePixelFormat (attrs, &format, &n_format)))
     return NULL;
 
+  *out_legacy = TRUE;
+
   return g_steal_pointer (&format);
 }
 
@@ -366,7 +380,8 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,
   GLint validate = 0;
   GLint renderer_id = 0;
   GLint swapRect[4];
-  int major, minor;
+  GdkGLVersion min_version, version;
+  gboolean legacy;
 
   g_assert (GDK_IS_MACOS_GL_CONTEXT (self));
 
@@ -378,10 +393,10 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,
 
   existing = CGLGetCurrentContext ();
 
-  gdk_gl_context_get_clipped_version (context,
-                                      GDK_GL_MIN_GL_VERSION_MAJOR,
-                                      GDK_GL_MIN_GL_VERSION_MINOR,
-                                      &major, &minor);
+  gdk_gl_context_get_matching_version (context,
+                                       GDK_GL_API_GL,
+                                       FALSE,
+                                       &version);
 
   display = gdk_gl_context_get_display (context);
   shared = gdk_display_get_gl_context (display);
@@ -400,9 +415,9 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,
 
   GDK_DISPLAY_DEBUG (display, OPENGL,
                      "Creating CGLContextObj (version %d.%d)",
-                     major, minor);
+                     gdk_gl_version_get_major (&min_version), gdk_gl_version_get_minor (&min_version));
 
-  if (!(pixelFormat = create_pixel_format (major, minor, error)))
+  if (!(pixelFormat = create_pixel_format (&min_version, &legacy, error)))
     return 0;
 
   if (!CHECK (error, CGLCreateContext (pixelFormat, shared_gl_context, &cgl_context)))
@@ -414,6 +429,13 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,
   CGLSetCurrentContext (cgl_context);
   CGLReleasePixelFormat (pixelFormat);
 
+  gdk_gl_version_init_epoxy (&version);
+  if (!gdk_gl_version_greater_equal (&version, &min_version))
+    {
+      CGLReleaseContext (cgl_context);
+      return 0;
+    }
+
   if (validate)
     CHECK (NULL, CGLEnable (cgl_context, kCGLCEStateValidation));
 
@@ -445,6 +467,9 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,
                      cgl_context,
                      get_renderer_name (renderer_id));
 
+  gdk_gl_context_set_version (context, &version);
+  gdk_gl_context_set_is_legacy (context, legacy);
+
   self->cgl_context = g_steal_pointer (&cgl_context);
 
   if (existing != NULL)

gdk/macos/gdkmacospopupsurface-private.h

@@ -33,11 +33,7 @@ typedef struct _GdkMacosPopupSurfaceClass GdkMacosPopupSurfaceClass;
 GType            _gdk_macos_popup_surface_get_type           (void);
 GdkMacosSurface *_gdk_macos_popup_surface_new                (GdkMacosDisplay      *display,
                                                               GdkSurface           *parent,
-                                                              GdkFrameClock        *frame_clock,
-                                                              int                   x,
-                                                              int                   y,
-                                                              int                   width,
-                                                              int                   height);
+                                                              GdkFrameClock        *frame_clock);
 void             _gdk_macos_popup_surface_attach_to_parent   (GdkMacosPopupSurface *self);
 void             _gdk_macos_popup_surface_detach_from_parent (GdkMacosPopupSurface *self);
 void             _gdk_macos_popup_surface_reposition         (GdkMacosPopupSurface *self);

gdk/macos/gdkmacospopupsurface.c

@@ -284,38 +284,14 @@ _gdk_macos_popup_surface_set_property (GObject      *object,
 }
 
 static void
-_gdk_macos_popup_surface_class_init (GdkMacosPopupSurfaceClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  GdkSurfaceClass *surface_class = GDK_SURFACE_CLASS (klass);
-
-  object_class->finalize = _gdk_macos_popup_surface_finalize;
-  object_class->get_property = _gdk_macos_popup_surface_get_property;
-  object_class->set_property = _gdk_macos_popup_surface_set_property;
-
-  surface_class->hide = _gdk_macos_popup_surface_hide;
-
-  gdk_popup_install_properties (object_class, LAST_PROP);
-}
-
-static void
-_gdk_macos_popup_surface_init (GdkMacosPopupSurface *self)
-{
-}
-
-GdkMacosSurface *
-_gdk_macos_popup_surface_new (GdkMacosDisplay *display,
-                              GdkSurface      *parent,
-                              GdkFrameClock   *frame_clock,
-                              int              x,
-                              int              y,
-                              int              width,
-                              int              height)
+_gdk_macos_popup_surface_constructed (GObject *object)
 {
   GDK_BEGIN_MACOS_ALLOC_POOL;
 
   GdkMacosWindow *window;
-  GdkMacosSurface *self;
+  GdkMacosPopupSurface *self = GDK_MACOS_POPUP_SURFACE (object);
+  GdkSurface *surface = GDK_SURFACE (self);
+  GdkMacosDisplay *display = GDK_MACOS_DISPLAY (gdk_surface_get_display (GDK_SURFACE (self)));
   NSScreen *screen;
   NSUInteger style_mask;
   NSRect content_rect;
@@ -323,19 +299,15 @@ _gdk_macos_popup_surface_new (GdkMacosDisplay *display,
   int nx;
   int ny;
 
-  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (display), NULL);
-  g_return_val_if_fail (!frame_clock || GDK_IS_FRAME_CLOCK (frame_clock), NULL);
-  g_return_val_if_fail (!parent || GDK_IS_MACOS_SURFACE (parent), NULL);
-
   style_mask = NSWindowStyleMaskBorderless;
 
-  _gdk_macos_display_to_display_coords (display, x, y, &nx, &ny);
+  _gdk_macos_display_to_display_coords (display, 0, 0, &nx, &ny);
 
   screen = _gdk_macos_display_get_screen_at_display_coords (display, nx, ny);
   screen_rect = [screen frame];
   nx -= screen_rect.origin.x;
   ny -= screen_rect.origin.y;
-  content_rect = NSMakeRect (nx, ny - height, width, height);
+  content_rect = NSMakeRect (nx, ny - 100, 100, 100);
 
   window = [[GdkMacosWindow alloc] initWithContentRect:content_rect
                                              styleMask:style_mask
@@ -349,16 +321,34 @@ _gdk_macos_popup_surface_new (GdkMacosDisplay *display,
   [window setExcludedFromWindowsMenu:YES];
   [window setLevel:NSPopUpMenuWindowLevel];
 
-  self = g_object_new (GDK_TYPE_MACOS_POPUP_SURFACE,
-                       "display", display,
-                       "frame-clock", frame_clock,
-                       "native", window,
-                       "parent", parent,
-                       NULL);
+  _gdk_macos_surface_set_native (GDK_MACOS_SURFACE (self), window);
+
+  gdk_surface_set_frame_clock (surface, gdk_surface_get_frame_clock (surface->parent));
 
   GDK_END_MACOS_ALLOC_POOL;
 
-  return g_steal_pointer (&self);
+  G_OBJECT_CLASS (_gdk_macos_popup_surface_parent_class)->constructed (object);
+}
+
+static void
+_gdk_macos_popup_surface_class_init (GdkMacosPopupSurfaceClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkSurfaceClass *surface_class = GDK_SURFACE_CLASS (klass);
+
+  object_class->constructed = _gdk_macos_popup_surface_constructed;
+  object_class->finalize = _gdk_macos_popup_surface_finalize;
+  object_class->get_property = _gdk_macos_popup_surface_get_property;
+  object_class->set_property = _gdk_macos_popup_surface_set_property;
+
+  surface_class->hide = _gdk_macos_popup_surface_hide;
+
+  gdk_popup_install_properties (object_class, LAST_PROP);
+}
+
+static void
+_gdk_macos_popup_surface_init (GdkMacosPopupSurface *self)
+{
 }
 
 void

gdk/macos/gdkmacossurface-private.h

@@ -84,14 +84,9 @@ struct _GdkMacosSurfaceClass
   GdkSurfaceClass parent_class;
 };
 
-GdkMacosSurface   *_gdk_macos_surface_new                     (GdkMacosDisplay      *display,
-                                                               GdkSurfaceType        surface_type,
-                                                               GdkSurface           *parent,
-                                                               int                   x,
-                                                               int                   y,
-                                                               int                   width,
-                                                               int                   height);
 NSWindow          *_gdk_macos_surface_get_native              (GdkMacosSurface      *self);
+void               _gdk_macos_surface_set_native              (GdkMacosSurface      *self,
+                                                               GdkMacosWindow       *window);
 CGDirectDisplayID  _gdk_macos_surface_get_screen_id           (GdkMacosSurface      *self);
 const char        *_gdk_macos_surface_get_title               (GdkMacosSurface      *self);
 void               _gdk_macos_surface_set_title               (GdkMacosSurface      *self,

gdk/macos/gdkmacossurface.c

@@ -31,7 +31,7 @@
 #include "gdkdeviceprivate.h"
 #include "gdkdisplay.h"
 #include "gdkeventsprivate.h"
-#include "gdkframeclockidleprivate.h"
+#include "gdkframeclockprivate.h"
 #include "gdkseatprivate.h"
 #include "gdksurfaceprivate.h"
 
@@ -43,8 +43,8 @@
 #include "gdkmacosglcontext-private.h"
 #include "gdkmacosmonitor-private.h"
 #include "gdkmacospopupsurface-private.h"
-#include "gdkmacostoplevelsurface-private.h"
 #include "gdkmacosutils-private.h"
+#include "gdkmacostoplevelsurface-private.h"
 
 G_DEFINE_ABSTRACT_TYPE (GdkMacosSurface, gdk_macos_surface, GDK_TYPE_SURFACE)
 
@@ -416,10 +416,6 @@ gdk_macos_surface_drag_begin (GdkSurface         *surface,
   GdkMacosSurface *drag_surface;
   GdkMacosDrag *drag;
   GdkCursor *cursor;
-  double px;
-  double py;
-  int sx;
-  int sy;
 
   g_assert (GDK_IS_MACOS_SURFACE (self));
   g_assert (GDK_IS_MACOS_TOPLEVEL_SURFACE (self) ||
@@ -427,12 +423,7 @@ gdk_macos_surface_drag_begin (GdkSurface         *surface,
   g_assert (GDK_IS_MACOS_DEVICE (device));
   g_assert (GDK_IS_CONTENT_PROVIDER (content));
 
-  gdk_macos_device_query_state (device, surface, NULL, &px, &py, NULL);
-  _gdk_macos_surface_get_root_coords (GDK_MACOS_SURFACE (surface), &sx, &sy);
-  drag_surface = _gdk_macos_surface_new (GDK_MACOS_DISPLAY (surface->display),
-                                         GDK_SURFACE_DRAG,
-                                         NULL,
-                                         sx, sy, 1, 1);
+  drag_surface = _gdk_macos_drag_surface_new (GDK_MACOS_DISPLAY (surface->display));
   drag = g_object_new (GDK_TYPE_MACOS_DRAG,
                        "drag-surface", drag_surface,
                        "surface", surface,
@@ -527,8 +518,14 @@ gdk_macos_surface_constructed (GObject *object)
                                G_CONNECT_SWAPPED);
     }
 
+  gdk_surface_freeze_updates (GDK_SURFACE (self));
+  _gdk_macos_surface_monitor_changed (self);
+
   if (self->window != NULL)
     _gdk_macos_surface_configure (self);
+
+  _gdk_macos_display_surface_added (GDK_MACOS_DISPLAY (gdk_surface_get_display (GDK_SURFACE (self))),
+                                    self);
 }
 
 static void
@@ -550,26 +547,6 @@ gdk_macos_surface_get_property (GObject    *object,
     }
 }
 
-static void
-gdk_macos_surface_set_property (GObject      *object,
-                                guint         prop_id,
-                                const GValue *value,
-                                GParamSpec   *pspec)
-{
-  GdkMacosSurface *self = GDK_MACOS_SURFACE (object);
-
-  switch (prop_id)
-    {
-    case PROP_NATIVE:
-      self->window = g_value_get_pointer (value);
-      [self->window setGdkSurface:self];
-      break;
-
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-    }
-}
-
 static void
 gdk_macos_surface_class_init (GdkMacosSurfaceClass *klass)
 {
@@ -578,7 +555,6 @@ gdk_macos_surface_class_init (GdkMacosSurfaceClass *klass)
 
   object_class->constructed = gdk_macos_surface_constructed;
   object_class->get_property = gdk_macos_surface_get_property;
-  object_class->set_property = gdk_macos_surface_set_property;
 
   surface_class->destroy = gdk_macos_surface_destroy;
   surface_class->drag_begin = gdk_macos_surface_drag_begin;
@@ -597,7 +573,7 @@ gdk_macos_surface_class_init (GdkMacosSurfaceClass *klass)
    */
   properties [PROP_NATIVE] =
     g_param_spec_pointer ("native", NULL, NULL,
-                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+                          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 
   g_object_class_install_properties (object_class, LAST_PROP, properties);
 }
@@ -611,55 +587,6 @@ gdk_macos_surface_init (GdkMacosSurface *self)
   self->monitors = g_ptr_array_new_with_free_func (g_object_unref);
 }
 
-GdkMacosSurface *
-_gdk_macos_surface_new (GdkMacosDisplay   *display,
-                        GdkSurfaceType     surface_type,
-                        GdkSurface        *parent,
-                        int                x,
-                        int                y,
-                        int                width,
-                        int                height)
-{
-  GdkFrameClock *frame_clock;
-  GdkMacosSurface *ret;
-
-  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (display), NULL);
-
-  if (parent != NULL)
-    frame_clock = g_object_ref (parent->frame_clock);
-  else
-    frame_clock = _gdk_frame_clock_idle_new ();
-
-  switch (surface_type)
-    {
-    case GDK_SURFACE_TOPLEVEL:
-      ret = _gdk_macos_toplevel_surface_new (display, parent, frame_clock, x, y, width, height);
-      break;
-
-    case GDK_SURFACE_POPUP:
-      ret = _gdk_macos_popup_surface_new (display, parent, frame_clock, x, y, width, height);
-      break;
-
-    case GDK_SURFACE_DRAG:
-      ret = _gdk_macos_drag_surface_new (display, frame_clock, x, y, width, height);
-      break;
-
-    default:
-      g_warn_if_reached ();
-      ret = NULL;
-    }
-
-  if (ret != NULL)
-    {
-      gdk_surface_freeze_updates (GDK_SURFACE (ret));
-      _gdk_macos_surface_monitor_changed (ret);
-    }
-
-  g_object_unref (frame_clock);
-
-  return g_steal_pointer (&ret);
-}
-
 void
 _gdk_macos_surface_get_shadow (GdkMacosSurface *self,
                                int             *top,
@@ -755,6 +682,16 @@ _gdk_macos_surface_get_native (GdkMacosSurface *self)
   return (NSWindow *)self->window;
 }
 
+void
+_gdk_macos_surface_set_native (GdkMacosSurface *self,
+                               GdkMacosWindow  *window)
+{
+  g_assert (self->window == NULL);
+
+  self->window = window;
+  [self->window setGdkSurface:self];
+}
+
 /**
  * gdk_macos_surface_get_native_window: (attributes org.gtk.Method.get_property=native)
  * @self: a #GdkMacosSurface

gdk/macos/gdkmacostoplevelsurface-private.h

@@ -45,13 +45,6 @@ struct _GdkMacosToplevelSurfaceClass
 };
 
 GType            _gdk_macos_toplevel_surface_get_type           (void);
-GdkMacosSurface *_gdk_macos_toplevel_surface_new                (GdkMacosDisplay *display,
-                                                                 GdkSurface      *parent,
-                                                                 GdkFrameClock   *frame_clock,
-                                                                 int              x,
-                                                                 int              y,
-                                                                 int              width,
-                                                                 int              height);
 void             _gdk_macos_toplevel_surface_attach_to_parent   (GdkMacosToplevelSurface *self);
 void             _gdk_macos_toplevel_surface_detach_from_parent (GdkMacosToplevelSurface *self);
 

gdk/macos/gdkmacostoplevelsurface.c

@@ -23,6 +23,7 @@
 
 #include "gdkmacostoplevelsurface-private.h"
 
+#include "gdkframeclockidleprivate.h"
 #include "gdkseatprivate.h"
 #include "gdktoplevelprivate.h"
 
@@ -625,12 +626,60 @@ _gdk_macos_toplevel_surface_set_property (GObject      *object,
     }
 }
 
+static void
+_gdk_macos_toplevel_surface_constructed (GObject *object)
+{
+  GDK_BEGIN_MACOS_ALLOC_POOL;
+
+  GdkMacosWindow *window;
+  GdkMacosToplevelSurface *self = GDK_MACOS_TOPLEVEL_SURFACE (object);
+  GdkSurface *surface = GDK_SURFACE (self);
+  GdkMacosDisplay *display = GDK_MACOS_DISPLAY (gdk_surface_get_display (surface));
+  GdkFrameClock *frame_clock;
+  NSUInteger style_mask;
+  NSRect content_rect;
+  NSRect visible_frame;
+  NSScreen *screen;
+  int nx;
+  int ny;
+
+  style_mask = (NSWindowStyleMaskTitled |
+                NSWindowStyleMaskClosable |
+                NSWindowStyleMaskMiniaturizable |
+                NSWindowStyleMaskResizable);
+
+  _gdk_macos_display_to_display_coords (display, 0, 100, &nx, &ny);
+
+  screen = _gdk_macos_display_get_screen_at_display_coords (display, nx, ny);
+  visible_frame = [screen visibleFrame];
+  content_rect = NSMakeRect (nx - visible_frame.origin.x, ny - visible_frame.origin.y, 100, 100);
+  window = [[GdkMacosWindow alloc] initWithContentRect:content_rect
+                                             styleMask:style_mask
+                                               backing:NSBackingStoreBuffered
+                                                 defer:NO
+                                                screen:screen];
+
+  /* Allow NSWindow to go fullscreen */
+  [window setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
+
+  _gdk_macos_surface_set_native (GDK_MACOS_SURFACE (self), window);
+
+  frame_clock = _gdk_frame_clock_idle_new ();
+  gdk_surface_set_frame_clock (surface, frame_clock);
+  g_object_unref (frame_clock);
+
+  GDK_END_MACOS_ALLOC_POOL;
+
+  G_OBJECT_CLASS (_gdk_macos_toplevel_surface_parent_class)->constructed (object);
+}
+
 static void
 _gdk_macos_toplevel_surface_class_init (GdkMacosToplevelSurfaceClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GdkSurfaceClass *surface_class = GDK_SURFACE_CLASS (klass);
 
+  object_class->constructed = _gdk_macos_toplevel_surface_constructed;
   object_class->get_property = _gdk_macos_toplevel_surface_get_property;
   object_class->set_property = _gdk_macos_toplevel_surface_set_property;
 
@@ -648,66 +697,6 @@ _gdk_macos_toplevel_surface_init (GdkMacosToplevelSurface *self)
   self->decorated = TRUE;
 }
 
-GdkMacosSurface *
-_gdk_macos_toplevel_surface_new (GdkMacosDisplay *display,
-                                 GdkSurface      *parent,
-                                 GdkFrameClock   *frame_clock,
-                                 int              x,
-                                 int              y,
-                                 int              width,
-                                 int              height)
-{
-  GDK_BEGIN_MACOS_ALLOC_POOL;
-
-  GdkMacosWindow *window;
-  GdkMacosSurface *self;
-  NSUInteger style_mask;
-  NSRect content_rect;
-  NSRect visible_frame;
-  NSScreen *screen;
-  int nx;
-  int ny;
-
-  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (display), NULL);
-  g_return_val_if_fail (!frame_clock || GDK_IS_FRAME_CLOCK (frame_clock), NULL);
-  g_return_val_if_fail (!parent || GDK_IS_MACOS_SURFACE (parent), NULL);
-
-  style_mask = (NSWindowStyleMaskTitled |
-                NSWindowStyleMaskClosable |
-                NSWindowStyleMaskMiniaturizable |
-                NSWindowStyleMaskResizable);
-
-  if (parent != NULL)
-    {
-      x += GDK_MACOS_SURFACE (parent)->root_x;
-      y += GDK_MACOS_SURFACE (parent)->root_y;
-    }
-
-  _gdk_macos_display_to_display_coords (display, x, y + height, &nx, &ny);
-
-  screen = _gdk_macos_display_get_screen_at_display_coords (display, nx, ny);
-  visible_frame = [screen visibleFrame];
-  content_rect = NSMakeRect (nx - visible_frame.origin.x, ny - visible_frame.origin.y, width, height);
-  window = [[GdkMacosWindow alloc] initWithContentRect:content_rect
-                                             styleMask:style_mask
-                                               backing:NSBackingStoreBuffered
-                                                 defer:NO
-                                                screen:screen];
-
-  /* Allow NSWindow to go fullscreen */
-  [window setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
-
-  self = g_object_new (GDK_TYPE_MACOS_TOPLEVEL_SURFACE,
-                       "display", display,
-                       "frame-clock", frame_clock,
-                       "native", window,
-                       NULL);
-
-  GDK_END_MACOS_ALLOC_POOL;
-
-  return g_steal_pointer (&self);
-}
-
 void
 _gdk_macos_toplevel_surface_attach_to_parent (GdkMacosToplevelSurface *self)
 {

gdk/meson.build

@@ -29,6 +29,7 @@ gdk_public_sources = files([
   'gdkglcontext.c',
   'gdkglobals.c',
   'gdkgltexture.c',
+  'gdkgltexturebuilder.c',
   'gdkhsla.c',
   'gdkkeys.c',
   'gdkkeyuni.c',
@@ -86,6 +87,7 @@ gdk_public_headers = files([
   'gdkframetimings.h',
   'gdkglcontext.h',
   'gdkgltexture.h',
+  'gdkgltexturebuilder.h',
   'gdkkeys.h',
   'gdkkeysyms.h',
   'gdkmemorytexture.h',

gdk/wayland/gdkdisplay-wayland.c

@@ -967,6 +967,8 @@ gdk_wayland_display_class_init (GdkWaylandDisplayClass *class)
   object_class->dispose = gdk_wayland_display_dispose;
   object_class->finalize = gdk_wayland_display_finalize;
 
+  display_class->toplevel_type = GDK_TYPE_WAYLAND_TOPLEVEL;
+  display_class->popup_type = GDK_TYPE_WAYLAND_POPUP;
   display_class->cairo_context_type = GDK_TYPE_WAYLAND_CAIRO_CONTEXT;
 
 #ifdef GDK_RENDERING_VULKAN
@@ -987,7 +989,6 @@ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
   display_class->get_startup_notification_id = gdk_wayland_display_get_startup_notification_id;
 G_GNUC_END_IGNORE_DEPRECATIONS
   display_class->notify_startup_complete = gdk_wayland_display_notify_startup_complete;
-  display_class->create_surface = _gdk_wayland_display_create_surface;
   display_class->get_keymap = _gdk_wayland_display_get_keymap;
 
   display_class->init_gl = gdk_wayland_display_init_gl;

gdk/wayland/gdkdrag-wayland.c

@@ -24,6 +24,7 @@
 #include "gdkdisplay-wayland.h"
 #include <glib/gi18n-lib.h>
 #include "gdkseat-wayland.h"
+#include "gdksurface-wayland-private.h"
 
 #include "gdkdeviceprivate.h"
 
@@ -46,7 +47,6 @@ struct _GdkWaylandDrag
 {
   GdkDrag drag;
   GdkSurface *dnd_surface;
-  struct wl_surface *dnd_wl_surface;
   struct wl_data_source *data_source;
   struct wl_data_offer *offer;
   uint32_t serial;
@@ -382,8 +382,9 @@ _gdk_wayland_surface_drag_begin (GdkSurface         *surface,
 
   drag = GDK_DRAG (drag_wayland);
 
-  drag_wayland->dnd_surface = _gdk_wayland_display_create_surface (display, GDK_SURFACE_DRAG, NULL, 0, 0, 100, 100);
-  drag_wayland->dnd_wl_surface = gdk_wayland_surface_get_wl_surface (drag_wayland->dnd_surface);
+  drag_wayland->dnd_surface = g_object_new (GDK_TYPE_WAYLAND_DRAG_SURFACE,
+                                            "display", display,
+                                            NULL);
 
   gdk_wayland_drag_create_data_source (drag);
 
@@ -395,7 +396,7 @@ _gdk_wayland_surface_drag_begin (GdkSurface         *surface,
   wl_data_device_start_drag (gdk_wayland_device_get_data_device (device),
                              drag_wayland->data_source,
                              gdk_wayland_surface_get_wl_surface (surface),
-                             drag_wayland->dnd_wl_surface,
+                             gdk_wayland_surface_get_wl_surface (drag_wayland->dnd_surface),
                              _gdk_wayland_seat_get_implicit_grab_serial (seat, NULL));
 
   cursor = gdk_drag_get_cursor (drag, gdk_drag_get_selected_action (drag));

gdk/wayland/gdkdragsurface-wayland.c

@@ -101,11 +101,27 @@ gdk_wayland_drag_surface_compute_size (GdkSurface *surface)
   return FALSE;
 }
 
+static void
+gdk_wayland_drag_surface_constructed (GObject *object)
+{
+  GdkSurface *surface = GDK_SURFACE (object);
+  GdkFrameClock *frame_clock;
+
+  frame_clock = _gdk_frame_clock_idle_new ();
+  gdk_surface_set_frame_clock (surface, frame_clock);
+  g_object_unref (frame_clock);
+
+  G_OBJECT_CLASS (gdk_wayland_drag_surface_parent_class)->constructed (object);
+}
+
 static void
 gdk_wayland_drag_surface_class_init (GdkWaylandDragSurfaceClass *class)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
   GdkSurfaceClass *surface_class = GDK_SURFACE_CLASS (class);
 
+  object_class->constructed = gdk_wayland_drag_surface_constructed;
+
   surface_class->compute_size = gdk_wayland_drag_surface_compute_size;
 }
 
@@ -127,9 +143,6 @@ gdk_wayland_drag_surface_present (GdkDragSurface *drag_surface,
   GdkSurface *surface = GDK_SURFACE (drag_surface);
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
 
-  if (!impl->display_server.wl_surface)
-    gdk_wayland_surface_create_wl_surface (surface);
-
   impl->next_layout.configured_width = width;
   impl->next_layout.configured_height = height;
   impl->next_layout.surface_geometry_dirty = TRUE;

gdk/wayland/gdkglcontext-wayland.c

@@ -75,6 +75,9 @@ gdk_wayland_gl_context_end_frame (GdkDrawContext *draw_context,
       WL_SURFACE_OFFSET_SINCE_VERSION)
     wl_surface_offset (impl->display_server.wl_surface, dx, dy);
 
+  /* We should do ths when setting up the EGLSurface, but we don't make_current then */
+  eglSwapInterval (gdk_display_get_egl_display (gdk_draw_context_get_display (draw_context)), 0);
+
   GDK_DRAW_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->end_frame (draw_context, painted);
 
   gdk_wayland_surface_notify_committed (surface);

gdk/wayland/gdkpopup-wayland.c

@@ -1040,6 +1040,17 @@ gdk_wayland_popup_init (GdkWaylandPopup *popup)
 {
 }
 
+static void
+gdk_wayland_popup_constructed (GObject *object)
+{
+  GdkWaylandPopup *self = GDK_WAYLAND_POPUP (object);
+  GdkSurface *surface = GDK_SURFACE (self);
+
+  gdk_surface_set_frame_clock (surface, gdk_surface_get_frame_clock (gdk_popup_get_parent (GDK_POPUP (self))));
+
+  G_OBJECT_CLASS (gdk_wayland_popup_parent_class)->constructed (object);
+}
+
 static void
 gdk_wayland_popup_get_property (GObject    *object,
                                 guint       prop_id,
@@ -1097,6 +1108,7 @@ gdk_wayland_popup_class_init (GdkWaylandPopupClass *class)
   GdkSurfaceClass *surface_class = GDK_SURFACE_CLASS (class);
   GdkWaylandSurfaceClass *wayland_surface_class = GDK_WAYLAND_SURFACE_CLASS (class);
 
+  object_class->constructed = gdk_wayland_popup_constructed;
   object_class->get_property = gdk_wayland_popup_get_property;
   object_class->set_property = gdk_wayland_popup_set_property;
 
@@ -1289,11 +1301,6 @@ show_popup (GdkWaylandPopup *wayland_popup,
             int              height,
             GdkPopupLayout  *layout)
 {
-  GdkWaylandSurface *wayland_surface = GDK_WAYLAND_SURFACE (wayland_popup);
-
-  if (!wayland_surface->display_server.wl_surface)
-    gdk_wayland_surface_create_wl_surface (GDK_SURFACE (wayland_popup));
-
   if (wayland_popup->thaw_upon_show)
     {
       wayland_popup->thaw_upon_show = FALSE;

gdk/wayland/gdkprimary-wayland.c

@@ -99,7 +99,7 @@ gdk_wayland_primary_claim_remote (GdkWaylandPrimary                     *cb,
 
   if (cb->source)
     {
-      GDK_DISPLAY_DEBUG (gdk_clipboard_get_display (GDK_CLIPBOARD (cb)), CLIPBOARD, "%p: Ignoring clipboard offer for self", cb);
+      GDK_DISPLAY_DEBUG (gdk_clipboard_get_display (GDK_CLIPBOARD (cb)), CLIPBOARD, "%p: Ignoring primary offer for self", cb);
       gdk_content_formats_unref (formats);
       g_clear_pointer (&offer, zwp_primary_selection_offer_v1_destroy);
       return;
@@ -111,7 +111,7 @@ gdk_wayland_primary_claim_remote (GdkWaylandPrimary                     *cb,
   if (GDK_DISPLAY_DEBUG_CHECK (gdk_clipboard_get_display (GDK_CLIPBOARD (cb)), CLIPBOARD))
     {
       char *s = gdk_content_formats_to_string (formats);
-      gdk_debug_message ("%p: remote clipboard claim for %s", cb, s);
+      gdk_debug_message ("%p: remote primary claim for %s", cb, s);
       g_free (s);
     }
 #endif
@@ -119,8 +119,7 @@ gdk_wayland_primary_claim_remote (GdkWaylandPrimary                     *cb,
   cb->offer_formats = formats;
   cb->offer = offer;
 
-  gdk_clipboard_claim_remote (GDK_CLIPBOARD (cb),
-                              cb->offer_formats);
+  gdk_clipboard_claim_remote (GDK_CLIPBOARD (cb), cb->offer_formats);
 }
 
 static void
@@ -271,6 +270,14 @@ gdk_wayland_primary_claim (GdkClipboard       *clipboard,
 {
   GdkWaylandPrimary *cb = GDK_WAYLAND_PRIMARY (clipboard);
 
+#ifdef G_ENABLE_DEBUG
+  if (GDK_DISPLAY_DEBUG_CHECK (gdk_clipboard_get_display (clipboard), CLIPBOARD))
+    {
+      char *s = gdk_content_formats_to_string (formats);
+      gdk_debug_message ("%p: claim primary (%s) for %s", cb, local ? "local" : "remote", s);
+      g_free (s);
+    }
+#endif
   if (local)
     {
       GdkWaylandDisplay *wdisplay = GDK_WAYLAND_DISPLAY (gdk_clipboard_get_display (clipboard));

gdk/wayland/gdkprivate-wayland.h

@@ -157,14 +157,6 @@ void             gdk_wayland_drop_set_source_actions       (GdkDrop
 void             gdk_wayland_drop_set_action               (GdkDrop               *drop,
                                                             uint32_t               action);
 
-GdkSurface * _gdk_wayland_display_create_surface (GdkDisplay *display,
-                                                  GdkSurfaceType surface_type,
-                                                  GdkSurface *parent,
-                                                  int         x,
-                                                  int         y,
-                                                  int         width,
-                                                  int         height);
-
 void        _gdk_wayland_display_create_seat    (GdkWaylandDisplay *display,
                                                  guint32                  id,
                                                  struct wl_seat          *seat);

gdk/wayland/gdksurface-wayland-private.h

@@ -42,11 +42,11 @@ struct _GdkWaylandSurface
   } display_server;
 
   struct wl_event_queue *event_queue;
+  struct wl_callback *frame_callback;
 
   unsigned int initial_configure_received : 1;
   unsigned int has_uncommitted_ack_configure : 1;
   unsigned int mapped : 1;
-  unsigned int awaiting_frame : 1;
   unsigned int awaiting_frame_frozen : 1;
 
   int pending_buffer_offset_x;
@@ -104,7 +104,6 @@ struct _GdkWaylandSurfaceClass
 
 #define GDK_WAYLAND_SURFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_SURFACE, GdkWaylandSurfaceClass))
 
-void gdk_wayland_surface_create_wl_surface (GdkSurface               *surface);
 void gdk_wayland_surface_update_size       (GdkSurface               *surface,
                                             int32_t                   width,
                                             int32_t                   height,

gdk/wayland/gdksurface-wayland.c

@@ -28,6 +28,7 @@
 #include "gdkmonitor-wayland.h"
 #include "gdkpopupprivate.h"
 #include "gdkprivate-wayland.h"
+#include "gdkrectangleprivate.h"
 #include "gdkseat-wayland.h"
 #include "gdksurfaceprivate.h"
 #include "gdktoplevelprivate.h"
@@ -107,20 +108,6 @@ fill_presentation_time_from_frame_time (GdkFrameTimings *timings,
     }
 }
 
-static const char *
-get_default_title (void)
-{
-  const char *title;
-
-  title = g_get_application_name ();
-  if (!title)
-    title = g_get_prgname ();
-  if (!title)
-    title = "";
-
-  return title;
-}
-
 static gboolean
 is_realized_shell_surface (GdkWaylandSurface *impl)
 {
@@ -198,38 +185,6 @@ gdk_wayland_surface_thaw_state (GdkSurface *surface)
     gdk_wayland_surface_configure (surface);
 }
 
-static void
-gdk_wayland_surface_maybe_resize (GdkSurface               *surface,
-                                  int                       width,
-                                  int                       height,
-                                  const GdkFractionalScale *scale)
-{
-  GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
-  gboolean hide_temporarily;
-
-  if (surface->width == width &&
-      surface->height == height &&
-      gdk_fractional_scale_equal (&impl->scale, scale))
-    return;
-
-  /* For xdg_popup using an xdg_positioner, there is a race condition if
-   * the application tries to change the size after it's mapped, but before
-   * the initial configure is received, so hide and show the surface again
-   * force the new size onto the compositor. See bug #772505.
-   */
-  hide_temporarily = GDK_IS_WAYLAND_POPUP (surface) &&
-                     gdk_surface_get_mapped (surface) &&
-                     !impl->initial_configure_received;
-
-  if (hide_temporarily)
-    gdk_surface_hide (surface);
-
-  gdk_wayland_surface_update_size (surface, width, height, scale);
-
-  if (hide_temporarily)
-    gdk_wayland_surface_create_wl_surface (surface);
-}
-
 static inline void
 get_egl_window_size (GdkSurface *surface,
                      int        *width,
@@ -318,17 +273,13 @@ frame_callback (void               *data,
   gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "frame event");
   GDK_DISPLAY_DEBUG (GDK_DISPLAY (display_wayland), EVENTS, "frame %p", surface);
 
-  wl_callback_destroy (callback);
+  g_assert (impl->frame_callback == callback);
+  g_assert (!GDK_SURFACE_DESTROYED (surface));
 
-  if (GDK_SURFACE_DESTROYED (surface))
-    return;
-
-  if (!impl->awaiting_frame)
-    return;
+  g_clear_pointer (&impl->frame_callback, wl_callback_destroy);
 
   GDK_WAYLAND_SURFACE_GET_CLASS (impl)->handle_frame (impl);
 
-  impl->awaiting_frame = FALSE;
   if (impl->awaiting_frame_frozen)
     {
       impl->awaiting_frame_frozen = FALSE;
@@ -416,20 +367,17 @@ gdk_wayland_surface_request_layout (GdkSurface *surface)
 void
 gdk_wayland_surface_request_frame (GdkSurface *surface)
 {
-  GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
-  struct wl_callback *callback;
+  GdkWaylandSurface *self = GDK_WAYLAND_SURFACE (surface);
   GdkFrameClock *clock;
 
-  if (impl->awaiting_frame)
-    return;
+  g_assert (self->frame_callback == NULL);
 
   clock = gdk_surface_get_frame_clock (surface);
 
-  callback = wl_surface_frame (impl->display_server.wl_surface);
-  wl_proxy_set_queue ((struct wl_proxy *) callback, NULL);
-  wl_callback_add_listener (callback, &frame_listener, surface);
-  impl->pending_frame_counter = gdk_frame_clock_get_frame_counter (clock);
-  impl->awaiting_frame = TRUE;
+  self->frame_callback = wl_surface_frame (self->display_server.wl_surface);
+  wl_proxy_set_queue ((struct wl_proxy *) self->frame_callback, NULL);
+  wl_callback_add_listener (self->frame_callback, &frame_listener, surface);
+  self->pending_frame_counter = gdk_frame_clock_get_frame_counter (clock);
 }
 
 gboolean
@@ -468,9 +416,10 @@ on_frame_clock_after_paint (GdkFrameClock *clock,
       gdk_wayland_surface_notify_committed (surface);
     }
 
-  if (impl->awaiting_frame &&
+  if (impl->frame_callback &&
       impl->pending_frame_counter == gdk_frame_clock_get_frame_counter (clock))
     {
+      g_assert (!impl->awaiting_frame_frozen);
       impl->awaiting_frame_frozen = TRUE;
       gdk_surface_freeze_updates (surface);
     }
@@ -508,105 +457,9 @@ gdk_wayland_surface_update_scale (GdkSurface *surface)
     }
 
   /* Notify app that scale changed */
-  gdk_wayland_surface_maybe_resize (surface,
-                                    surface->width, surface->height,
-                                    &GDK_FRACTIONAL_SCALE_INIT_INT (scale));
-}
-
-GdkSurface *
-_gdk_wayland_display_create_surface (GdkDisplay     *display,
-                                     GdkSurfaceType  surface_type,
-                                     GdkSurface     *parent,
-                                     int             x,
-                                     int             y,
-                                     int             width,
-                                     int             height)
-{
-  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
-  GdkSurface *surface;
-  GdkFrameClock *frame_clock;
-
-  if (parent)
-    frame_clock = g_object_ref (gdk_surface_get_frame_clock (parent));
-  else
-    frame_clock = _gdk_frame_clock_idle_new ();
-
-  switch (surface_type)
-    {
-    case GDK_SURFACE_TOPLEVEL:
-      g_warn_if_fail (parent == NULL);
-      surface = g_object_new (GDK_TYPE_WAYLAND_TOPLEVEL,
-                              "display", display,
-                              "frame-clock", frame_clock,
-                              "title", get_default_title (),
-                              NULL);
-      display_wayland->toplevels = g_list_prepend (display_wayland->toplevels, surface);
-      break;
-    case GDK_SURFACE_POPUP:
-      g_warn_if_fail (parent != NULL);
-      surface = g_object_new (GDK_TYPE_WAYLAND_POPUP,
-                              "parent", parent,
-                              "display", display,
-                              "frame-clock", frame_clock,
-                              NULL);
-      break;
-    case GDK_SURFACE_DRAG:
-      g_warn_if_fail (parent == NULL);
-      surface = g_object_new (GDK_TYPE_WAYLAND_DRAG_SURFACE,
-                              "display", display,
-                              "frame-clock", frame_clock,
-                              NULL);
-      break;
-    default:
-      g_assert_not_reached ();
-      break;
-    }
-
-  if (width > 65535)
-    {
-      g_warning ("Native Surfaces wider than 65535 pixels are not supported");
-      width = 65535;
-    }
-  if (height > 65535)
-    {
-      g_warning ("Native Surfaces taller than 65535 pixels are not supported");
-      height = 65535;
-    }
-
-  surface->x = x;
-  surface->y = y;
-  surface->width = width;
-  surface->height = height;
-
-  g_object_ref (surface);
-
-  /* More likely to be right than just assuming 1 */
-  if (wl_compositor_get_version (display_wayland->compositor) >= WL_SURFACE_SET_BUFFER_SCALE_SINCE_VERSION)
-    {
-      GdkMonitor *monitor = g_list_model_get_item (gdk_display_get_monitors (display), 0);
-      if (monitor)
-        {
-          GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
-          guint32 monitor_scale = gdk_monitor_get_scale_factor (monitor);
-
-          if (monitor_scale != 1)
-            {
-              impl->scale = GDK_FRACTIONAL_SCALE_INIT_INT (monitor_scale);
-              impl->buffer_scale_dirty = TRUE;
-            }
-
-          g_object_unref (monitor);
-        }
-    }
-
-  gdk_wayland_surface_create_wl_surface (surface);
-
-  g_signal_connect (frame_clock, "before-paint", G_CALLBACK (on_frame_clock_before_paint), surface);
-  g_signal_connect (frame_clock, "after-paint", G_CALLBACK (on_frame_clock_after_paint), surface);
-
-  g_object_unref (frame_clock);
-
-  return surface;
+  gdk_wayland_surface_update_size (surface,
+                                   surface->width, surface->height,
+                                   &GDK_FRACTIONAL_SCALE_INIT_INT (scale));
 }
 
 void
@@ -616,6 +469,7 @@ gdk_wayland_surface_attach_image (GdkSurface           *surface,
 {
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
   cairo_rectangle_int_t rect;
+  uint32_t wl_surface_version;
   int i, n;
 
   if (GDK_SURFACE_DESTROYED (surface))
@@ -623,14 +477,15 @@ gdk_wayland_surface_attach_image (GdkSurface           *surface,
 
   g_assert (_gdk_wayland_is_shm_surface (cairo_surface));
 
+  wl_surface_version = wl_surface_get_version (impl->display_server.wl_surface);
+
   /* Attach this new buffer to the surface */
   wl_surface_attach (impl->display_server.wl_surface,
                      _gdk_wayland_shm_surface_get_wl_buffer (cairo_surface),
                      0, 0);
 
   if ((impl->pending_buffer_offset_x || impl->pending_buffer_offset_y) &&
-      wl_surface_get_version (impl->display_server.wl_surface) >=
-      WL_SURFACE_OFFSET_SINCE_VERSION)
+      wl_surface_version >= WL_SURFACE_OFFSET_SINCE_VERSION)
     wl_surface_offset (impl->display_server.wl_surface,
                        impl->pending_buffer_offset_x,
                        impl->pending_buffer_offset_y);
@@ -641,7 +496,16 @@ gdk_wayland_surface_attach_image (GdkSurface           *surface,
   for (i = 0; i < n; i++)
     {
       cairo_region_get_rectangle (damage, i, &rect);
-      wl_surface_damage (impl->display_server.wl_surface, rect.x, rect.y, rect.width, rect.height);
+      if (wl_surface_version >= WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION)
+        {
+          float scale = gdk_surface_get_scale (surface);
+          gdk_rectangle_transform_affine (&rect, scale, scale, 0, 0, &rect);
+          wl_surface_damage_buffer (impl->display_server.wl_surface, rect.x, rect.y, rect.width, rect.height);
+        }
+      else
+        {
+          wl_surface_damage (impl->display_server.wl_surface, rect.x, rect.y, rect.width, rect.height);
+        }
     }
 }
 
@@ -653,21 +517,6 @@ gdk_wayland_surface_beep (GdkSurface *surface)
   return TRUE;
 }
 
-static void
-gdk_wayland_surface_constructed (GObject *object)
-{
-  GdkSurface *surface = GDK_SURFACE (object);
-  GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
-  GdkWaylandDisplay *display_wayland =
-    GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
-
-  G_OBJECT_CLASS (gdk_wayland_surface_parent_class)->constructed (object);
-
-  impl->event_queue = wl_display_create_queue (display_wayland->wl_display);
-  display_wayland->event_queues = g_list_prepend (display_wayland->event_queues,
-                                                  impl->event_queue);
-}
-
 static void
 gdk_wayland_surface_dispose (GObject *object)
 {
@@ -684,7 +533,7 @@ gdk_wayland_surface_dispose (GObject *object)
         GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
 
       display_wayland->event_queues =
-        g_list_remove (display_wayland->event_queues, surface);
+        g_list_remove (display_wayland->event_queues, impl->event_queue);
       g_clear_pointer (&impl->event_queue, wl_event_queue_destroy);
     }
 
@@ -858,9 +707,9 @@ gdk_wayland_surface_fractional_scale_preferred_scale_cb (void *data,
   GdkSurface *surface = GDK_SURFACE (self);
   
   /* Notify app that scale changed */
-  gdk_wayland_surface_maybe_resize (surface,
-                                    surface->width, surface->height,
-                                    &GDK_FRACTIONAL_SCALE_INIT (scale));
+  gdk_wayland_surface_update_size (surface,
+                                   surface->width, surface->height,
+                                   &GDK_FRACTIONAL_SCALE_INIT (scale));
 }
 
 static const struct wp_fractional_scale_v1_listener fractional_scale_listener = {
@@ -915,7 +764,7 @@ static const struct wl_surface_listener surface_listener = {
   surface_leave
 };
 
-void
+static void
 gdk_wayland_surface_create_wl_surface (GdkSurface *surface)
 {
   GdkWaylandSurface *self = GDK_WAYLAND_SURFACE (surface);
@@ -942,6 +791,62 @@ gdk_wayland_surface_create_wl_surface (GdkSurface *surface)
   self->display_server.wl_surface = wl_surface;
 }
 
+static void
+gdk_wayland_surface_constructed (GObject *object)
+{
+  GdkSurface *surface = GDK_SURFACE (object);
+  GdkWaylandSurface *self = GDK_WAYLAND_SURFACE (surface);
+  GdkDisplay *display = gdk_surface_get_display (surface);
+  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
+  GdkFrameClock *frame_clock = gdk_surface_get_frame_clock (surface);
+
+  self->event_queue = wl_display_create_queue (display_wayland->wl_display);
+  display_wayland->event_queues = g_list_prepend (display_wayland->event_queues,
+                                                  self->event_queue);
+
+  /* More likely to be right than just assuming 1 */
+  if (wl_compositor_get_version (display_wayland->compositor) >= WL_SURFACE_SET_BUFFER_SCALE_SINCE_VERSION)
+    {
+      GdkMonitor *monitor = g_list_model_get_item (gdk_display_get_monitors (display), 0);
+      if (monitor)
+        {
+          guint32 monitor_scale = gdk_monitor_get_scale_factor (monitor);
+
+          if (monitor_scale != 1)
+            {
+              self->scale = GDK_FRACTIONAL_SCALE_INIT_INT (monitor_scale);
+              self->buffer_scale_dirty = TRUE;
+            }
+
+          g_object_unref (monitor);
+        }
+    }
+
+  gdk_wayland_surface_create_wl_surface (surface);
+
+  g_signal_connect (frame_clock, "before-paint", G_CALLBACK (on_frame_clock_before_paint), surface);
+  g_signal_connect (frame_clock, "after-paint", G_CALLBACK (on_frame_clock_after_paint), surface);
+
+  G_OBJECT_CLASS (gdk_wayland_surface_parent_class)->constructed (object);
+}
+
+static void
+gdk_wayland_surface_destroy_wl_surface (GdkWaylandSurface *self)
+{
+  if (self->display_server.egl_window)
+    {
+      gdk_surface_set_egl_native_window (GDK_SURFACE (self), NULL);
+      g_clear_pointer (&self->display_server.egl_window, wl_egl_window_destroy);
+    }
+
+  g_clear_pointer (&self->display_server.viewport, wp_viewport_destroy);
+  g_clear_pointer (&self->display_server.fractional_scale, wp_fractional_scale_v1_destroy);
+
+  g_clear_pointer (&self->display_server.wl_surface, wl_surface_destroy);
+
+  g_clear_pointer (&self->display_server.outputs, g_slist_free);
+}
+
 static void
 maybe_notify_mapped (GdkSurface *surface)
 {
@@ -1069,59 +974,42 @@ gdk_wayland_surface_hide_surface (GdkSurface *surface)
 {
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
 
+  if (!impl->mapped)
+    return;
+
   unmap_popups_for_surface (surface);
 
-  if (impl->display_server.wl_surface)
+  g_clear_pointer (&impl->frame_callback, wl_callback_destroy);
+  if (impl->awaiting_frame_frozen)
     {
-      if (impl->display_server.egl_window)
-        {
-          gdk_surface_set_egl_native_window (surface, NULL);
-          wl_egl_window_destroy (impl->display_server.egl_window);
-          impl->display_server.egl_window = NULL;
-        }
-
-      impl->awaiting_frame = FALSE;
-      if (impl->awaiting_frame_frozen)
-        {
-          impl->awaiting_frame_frozen = FALSE;
-          gdk_surface_thaw_updates (surface);
-        }
-
-      GDK_WAYLAND_SURFACE_GET_CLASS (impl)->hide_surface (impl);
-
-      if (impl->display_server.xdg_surface)
-        {
-          xdg_surface_destroy (impl->display_server.xdg_surface);
-          impl->display_server.xdg_surface = NULL;
-          if (!impl->initial_configure_received)
-            gdk_surface_thaw_updates (surface);
-          else
-            impl->initial_configure_received = FALSE;
-        }
-      if (impl->display_server.zxdg_surface_v6)
-        {
-          g_clear_pointer (&impl->display_server.zxdg_surface_v6, zxdg_surface_v6_destroy);
-          if (!impl->initial_configure_received)
-            gdk_surface_thaw_updates (surface);
-          else
-            impl->initial_configure_received = FALSE;
-        }
-
-      g_clear_pointer (&impl->display_server.fractional_scale, wp_fractional_scale_v1_destroy);
-      g_clear_pointer (&impl->display_server.viewport, wp_viewport_destroy);
-
-      g_clear_pointer (&impl->display_server.wl_surface, wl_surface_destroy);
-
-      g_slist_free (impl->display_server.outputs);
-      impl->display_server.outputs = NULL;
+      impl->awaiting_frame_frozen = FALSE;
+      gdk_surface_thaw_updates (surface);
     }
 
+  GDK_WAYLAND_SURFACE_GET_CLASS (impl)->hide_surface (impl);
+
+  if (impl->display_server.xdg_surface)
+    {
+      xdg_surface_destroy (impl->display_server.xdg_surface);
+      impl->display_server.xdg_surface = NULL;
+      if (!impl->initial_configure_received)
+        gdk_surface_thaw_updates (surface);
+      else
+        impl->initial_configure_received = FALSE;
+    }
+  if (impl->display_server.zxdg_surface_v6)
+    {
+      g_clear_pointer (&impl->display_server.zxdg_surface_v6, zxdg_surface_v6_destroy);
+      if (!impl->initial_configure_received)
+        gdk_surface_thaw_updates (surface);
+      else
+        impl->initial_configure_received = FALSE;
+    }
+
+  wl_surface_attach (impl->display_server.wl_surface, NULL, 0, 0);
+  wl_surface_commit (impl->display_server.wl_surface);
+
   impl->has_uncommitted_ack_configure = FALSE;
-  impl->input_region_dirty = TRUE;
-  impl->opaque_region_dirty = TRUE;
-  impl->viewport_dirty = TRUE;
-  if (!gdk_fractional_scale_equal (&impl->scale, &GDK_FRACTIONAL_SCALE_INIT_INT (1)))
-    impl->buffer_scale_dirty = TRUE;
 
   impl->last_sent_window_geometry = (GdkRectangle) { 0 };
   impl->mapped = FALSE;
@@ -1155,7 +1043,7 @@ gdk_wayland_surface_move_resize (GdkSurface *surface,
 
   surface->x = x;
   surface->y = y;
-  gdk_wayland_surface_maybe_resize (surface, width, height, &impl->scale);
+  gdk_wayland_surface_update_size (surface, width, height, &impl->scale);
 }
 
 static void
@@ -1250,11 +1138,8 @@ static void
 gdk_wayland_surface_destroy (GdkSurface *surface,
                              gboolean    foreign_destroy)
 {
-  GdkWaylandDisplay *display;
   GdkFrameClock *frame_clock;
 
-  g_return_if_fail (GDK_IS_SURFACE (surface));
-
   /* Wayland surfaces can't be externally destroyed; we may possibly
    * eventually want to use this path at display close-down
    */
@@ -1262,12 +1147,11 @@ gdk_wayland_surface_destroy (GdkSurface *surface,
 
   gdk_wayland_surface_hide_surface (surface);
 
+  gdk_wayland_surface_destroy_wl_surface (GDK_WAYLAND_SURFACE(surface));
+
   frame_clock = gdk_surface_get_frame_clock (surface);
   g_signal_handlers_disconnect_by_func (frame_clock, on_frame_clock_before_paint, surface);
   g_signal_handlers_disconnect_by_func (frame_clock, on_frame_clock_after_paint, surface);
-
-  display = GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
-  display->toplevels = g_list_remove (display->toplevels, surface);
 }
 
 static void

gdk/wayland/gdktoplevel-wayland.c

@@ -823,6 +823,20 @@ gdk_wayland_surface_create_xdg_toplevel (GdkWaylandToplevel *wayland_toplevel)
   wl_surface_commit (wayland_surface->display_server.wl_surface);
 }
 
+static const char *
+get_default_title (void)
+{
+  const char *title;
+
+  title = g_get_application_name ();
+  if (!title)
+    title = g_get_prgname ();
+  if (!title)
+    title = "";
+
+  return title;
+}
+
 static void
 gdk_wayland_toplevel_init (GdkWaylandToplevel *toplevel)
 {
@@ -830,6 +844,8 @@ gdk_wayland_toplevel_init (GdkWaylandToplevel *toplevel)
   toplevel->shortcuts_inhibitors = g_hash_table_new (NULL, NULL);
   toplevel->saved_width = -1;
   toplevel->saved_height = -1;
+
+  toplevel->title = g_strdup (get_default_title ());
 }
 
 static void
@@ -1259,28 +1275,43 @@ gdk_wayland_toplevel_get_property (GObject    *object,
 static void
 gdk_wayland_toplevel_finalize (GObject *object)
 {
-  GdkWaylandToplevel *wayland_toplevel;
+  GdkWaylandToplevel *self = GDK_WAYLAND_TOPLEVEL (object);
+  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (gdk_surface_get_display (GDK_SURFACE (object)));
 
-  g_return_if_fail (GDK_IS_WAYLAND_TOPLEVEL (object));
+  display_wayland->toplevels = g_list_remove (display_wayland->toplevels, self);
 
-  wayland_toplevel = GDK_WAYLAND_TOPLEVEL (object);
+  if (gdk_wayland_toplevel_is_exported (self))
+    gdk_wayland_toplevel_unexport_handle (GDK_TOPLEVEL (self));
 
-  if (gdk_wayland_toplevel_is_exported (wayland_toplevel))
-    gdk_wayland_toplevel_unexport_handle (GDK_TOPLEVEL (wayland_toplevel));
+  g_free (self->application.application_id);
+  g_free (self->application.app_menu_path);
+  g_free (self->application.menubar_path);
+  g_free (self->application.window_object_path);
+  g_free (self->application.application_object_path);
+  g_free (self->application.unique_bus_name);
 
-  g_free (wayland_toplevel->application.application_id);
-  g_free (wayland_toplevel->application.app_menu_path);
-  g_free (wayland_toplevel->application.menubar_path);
-  g_free (wayland_toplevel->application.window_object_path);
-  g_free (wayland_toplevel->application.application_object_path);
-  g_free (wayland_toplevel->application.unique_bus_name);
-
-  g_free (wayland_toplevel->title);
-  g_clear_pointer (&wayland_toplevel->shortcuts_inhibitors, g_hash_table_unref);
+  g_free (self->title);
+  g_clear_pointer (&self->shortcuts_inhibitors, g_hash_table_unref);
 
   G_OBJECT_CLASS (gdk_wayland_toplevel_parent_class)->finalize (object);
 }
 
+static void
+gdk_wayland_toplevel_constructed (GObject *object)
+{
+  GdkSurface *surface = GDK_SURFACE (object);
+  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
+  GdkFrameClock *frame_clock;
+
+  frame_clock = _gdk_frame_clock_idle_new ();
+  gdk_surface_set_frame_clock (surface, frame_clock);
+  g_object_unref (frame_clock);
+
+  display_wayland->toplevels = g_list_prepend (display_wayland->toplevels, object);
+
+  G_OBJECT_CLASS (gdk_wayland_toplevel_parent_class)->constructed (object);
+}
+
 static void
 gdk_wayland_toplevel_class_init (GdkWaylandToplevelClass *class)
 {
@@ -1291,6 +1322,7 @@ gdk_wayland_toplevel_class_init (GdkWaylandToplevelClass *class)
   object_class->get_property = gdk_wayland_toplevel_get_property;
   object_class->set_property = gdk_wayland_toplevel_set_property;
   object_class->finalize = gdk_wayland_toplevel_finalize;
+  object_class->constructed = gdk_wayland_toplevel_constructed;
 
   surface_class->compute_size = gdk_wayland_toplevel_compute_size;
 
@@ -1526,9 +1558,6 @@ gdk_wayland_toplevel_show (GdkWaylandToplevel *toplevel)
 {
   GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (toplevel);
 
-  if (!impl->display_server.wl_surface)
-    gdk_wayland_surface_create_wl_surface (GDK_SURFACE (impl));
-
   if (impl->mapped)
     return;
 

gdk/win32/gdkclipdrop-win32.c

@@ -2546,13 +2546,11 @@ transmute_cf_shell_id_list_to_text_uri_list (const guchar    *data,
       ILFree (file_id_full);
     }
 
-  *set_data = (guchar *) result->str;
   if (set_data_length)
     *set_data_length = result->len;
+  *set_data = (guchar *) g_string_free (result, FALSE);
   if (set_data_destroy)
     *set_data_destroy = g_free;
-
-  g_string_free (result, FALSE);
 }
 
 void

gdk/win32/gdkdevicemanager-win32.c

@@ -427,11 +427,7 @@ wintab_init_check (GdkDeviceManagerWin32 *device_manager)
 			    ndevices, ncursors));
 #endif
   /* Create a dummy window to receive wintab events */
-  wintab_window =
-      _gdk_win32_display_create_surface (display,
-                                         GDK_SURFACE_DRAG,
-                                         NULL,
-                                         -100, -100, 2, 2);
+  wintab_window = gdk_win32_drag_surface_new (display);
 
   g_object_ref (wintab_window);
 

gdk/win32/gdkdisplay-win32.c

@@ -28,6 +28,7 @@
 #include "gdkdisplay-win32.h"
 #include "gdkdevicemanager-win32.h"
 #include "gdkglcontext-win32.h"
+#include "gdksurface-win32.h"
 #include "gdkwin32display.h"
 #include "gdkwin32screen.h"
 #include "gdkwin32surface.h"
@@ -1181,6 +1182,7 @@ gdk_win32_display_init_gl (GdkDisplay  *display,
 {
   GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
   HDC init_gl_hdc = NULL;
+  GdkGLContext *context;
 
   if (display_win32->dummy_context_wgl.hdc == NULL)
     display_win32->dummy_context_wgl.hdc = GetDC (display_win32->hwnd);
@@ -1207,6 +1209,7 @@ gdk_win32_display_init_gl (GdkDisplay  *display,
         {
           return g_object_new (GDK_TYPE_WIN32_GL_CONTEXT_EGL,
                                "display", display,
+                               "allowed-apis", GDK_GL_API_GLES,
                                NULL);
         }
       else
@@ -1214,12 +1217,9 @@ gdk_win32_display_init_gl (GdkDisplay  *display,
     }
 #endif
 
-  if (gdk_win32_display_init_wgl (display, error))
-    {
-      return g_object_new (GDK_TYPE_WIN32_GL_CONTEXT_WGL,
-                           "display", display,
-                           NULL);
-    }
+  context = gdk_win32_display_init_wgl (display, error);
+  if (context)
+    return context;
 
 #ifdef HAVE_EGL
   g_clear_error (error);
@@ -1267,6 +1267,8 @@ gdk_win32_display_class_init (GdkWin32DisplayClass *klass)
   object_class->dispose = gdk_win32_display_dispose;
   object_class->finalize = gdk_win32_display_finalize;
 
+  display_class->toplevel_type = GDK_TYPE_WIN32_TOPLEVEL;
+  display_class->popup_type = GDK_TYPE_WIN32_POPUP;
   display_class->cairo_context_type = GDK_TYPE_WIN32_CAIRO_CONTEXT;
 
   display_class->get_name = gdk_win32_display_get_name;
@@ -1280,7 +1282,6 @@ gdk_win32_display_class_init (GdkWin32DisplayClass *klass)
 
   display_class->get_next_serial = gdk_win32_display_get_next_serial;
   display_class->notify_startup_complete = gdk_win32_display_notify_startup_complete;
-  display_class->create_surface = _gdk_win32_display_create_surface;
 
   display_class->get_keymap = _gdk_win32_display_get_keymap;
 

gdk/win32/gdkdisplay-win32.h

@@ -24,6 +24,8 @@
 #include "gdkwin32screen.h"
 #include "gdkwin32cursor.h"
  
+#include "gdkglversionprivate.h"
+
 #ifdef HAVE_EGL
 # include <epoxy/egl.h>
 #endif
@@ -124,7 +126,6 @@ struct _GdkWin32Display
 
   /* WGL/OpenGL Items */
   GdkWin32GLDummyContextWGL dummy_context_wgl;
-  guint gl_version;
 
   GListModel *monitors;
 

gdk/win32/gdkdrag-win32.c

@@ -37,8 +37,6 @@
 #include <math.h>
 #include <string.h>
 
-#define GDK_NOTE(a,b)
-
 /*
  * Support for OLE-2 drag and drop added at Archaeopteryx Software, 2001
  * For more information, do not contact Stephan R.A. Deibel (sdeibel@archaeopteryx.com),
@@ -1646,19 +1644,6 @@ _gdk_win32_dnd_exit (void)
   CoUninitialize ();
 }
 
-static GdkSurface *
-create_drag_surface (GdkDisplay *display)
-{
-  GdkSurface *surface;
-
-  surface = _gdk_win32_display_create_surface (display,
-                                               GDK_SURFACE_DRAG,
-                                               NULL,
-                                               0, 0, 100, 100);
-
-  return surface;
-}
-
 GdkDrag *
 _gdk_win32_surface_drag_begin (GdkSurface         *surface,
                                GdkDevice          *device,
@@ -1698,7 +1683,7 @@ _gdk_win32_surface_drag_begin (GdkSurface         *surface,
 
   g_set_object (&drag_win32->grab_surface, surface);
 
-  drag_win32->drag_surface = create_drag_surface (gdk_surface_get_display (surface));
+  drag_win32->drag_surface = gdk_win32_drag_surface_new (gdk_surface_get_display (surface));
 
   if (!drag_context_grab (drag))
     {
@@ -1882,11 +1867,6 @@ gdk_win32_drag_drop_done (GdkDrag  *drag,
   GdkDragAnim *anim;
   GdkWin32Clipdrop *clipdrop;
   gpointer ddd;
-/*
-  cairo_surface_t *win_surface;
-  cairo_surface_t *surface;
-  cairo_t *cr;
-*/
   guint id;
 
   GDK_NOTE (DND, g_print ("gdk_win32_drag_drop_done: 0x%p %s\n",
@@ -1916,26 +1896,6 @@ gdk_win32_drag_drop_done (GdkDrag  *drag,
       return;
     }
 
-/*
-  win_surface = _gdk_surface_ref_cairo_surface (drag_win32->drag_surface);
-  surface = gdk_surface_create_similar_surface (drag_win32->drag_surface,
-                                                cairo_surface_get_content (win_surface),
-                                                gdk_surface_get_width (drag_win32->drag_surface),
-                                                gdk_surface_get_height (drag_win32->drag_surface));
-  cr = cairo_create (surface);
-  cairo_set_source_surface (cr, win_surface, 0, 0);
-  cairo_paint (cr);
-  cairo_destroy (cr);
-  cairo_surface_destroy (win_surface);
-
-  pattern = cairo_pattern_create_for_surface (surface);
-
-  gdk_surface_set_background_pattern (drag_win32->drag_surface, pattern);
-
-  cairo_pattern_destroy (pattern);
-  cairo_surface_destroy (surface);
-*/
-
   anim = g_new0 (GdkDragAnim, 1);
   g_set_object (&anim->drag, drag_win32);
   anim->frame_clock = gdk_surface_get_frame_clock (drag_win32->drag_surface);

gdk/win32/gdkglcontext-win32-egl.c

@@ -83,20 +83,13 @@ gdk_win32_gl_context_egl_end_frame (GdkDrawContext *draw_context,
                                     cairo_region_t *painted)
 {
   GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
-  GdkWin32GLContextEGL *context_egl = GDK_WIN32_GL_CONTEXT_EGL (context);
   GdkSurface *surface = gdk_gl_context_get_surface (context);
   GdkDisplay *display = gdk_gl_context_get_display (context);
-  cairo_rectangle_int_t whole_window;
   EGLSurface egl_surface;
 
   GDK_DRAW_CONTEXT_CLASS (gdk_win32_gl_context_egl_parent_class)->end_frame (draw_context, painted);
 
   gdk_gl_context_make_current (context);
-  whole_window =
-    (GdkRectangle) { 0, 0,
-	                 gdk_surface_get_width (surface),
-					 gdk_surface_get_height (surface)
-                   };
 
   egl_surface = gdk_surface_get_egl_surface (surface);
 

gdk/win32/gdkglcontext-win32-wgl.c

@@ -247,16 +247,17 @@ gdk_init_dummy_wgl_context (GdkWin32Display *display_win32)
   return best_idx;
 }
 
-gboolean
+GdkGLContext *
 gdk_win32_display_init_wgl (GdkDisplay  *display,
                             GError     **error)
 {
   int best_idx = 0;
   GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
+  GdkGLContext *context;
   HDC hdc;
 
   if (!gdk_gl_backend_can_be_used (GDK_GL_WGL, error))
-    return FALSE;
+    return NULL;
 
   /* acquire and cache dummy Window (HWND & HDC) and
    * dummy GL Context, it is used to query functions
@@ -275,25 +276,7 @@ gdk_win32_display_init_wgl (GdkDisplay  *display,
                            GDK_GL_ERROR_NOT_AVAILABLE,
                            _("No GL implementation is available"));
 
-      return FALSE;
-    }
-
-  display_win32->gl_version = epoxy_gl_version ();
-
-  /* We must have OpenGL/WGL 2.0 or later, or have the GL_ARB_shader_objects extension */
-  if (display_win32->gl_version < 20)
-    {
-      if (!epoxy_has_gl_extension ("GL_ARB_shader_objects"))
-        {
-          wglMakeCurrent (NULL, NULL);
-          wglDeleteContext (display_win32->dummy_context_wgl.hglrc);
-
-          g_set_error_literal (error, GDK_GL_ERROR,
-                               GDK_GL_ERROR_NOT_AVAILABLE,
-                               _("No GL implementation is available"));
-
-          return FALSE;
-        }
+      return NULL;
     }
 
   display_win32->hasWglARBCreateContext =
@@ -307,45 +290,92 @@ gdk_win32_display_init_wgl (GdkDisplay  *display,
   display_win32->hasWglARBmultisample =
     epoxy_has_wgl_extension (hdc, "WGL_ARB_multisample");
 
-  GDK_NOTE (OPENGL,
-            g_print ("WGL API version %d.%d found\n"
-                     " - Vendor: %s\n"
-                     " - Checked extensions:\n"
-                     "\t* WGL_ARB_pixel_format: %s\n"
-                     "\t* WGL_ARB_create_context: %s\n"
-                     "\t* WGL_EXT_swap_control: %s\n"
-                     "\t* WGL_OML_sync_control: %s\n"
-                     "\t* WGL_ARB_multisample: %s\n",
-                     display_win32->gl_version / 10,
-                     display_win32->gl_version % 10,
-                     glGetString (GL_VENDOR),
-                     display_win32->hasWglARBPixelFormat ? "yes" : "no",
-                     display_win32->hasWglARBCreateContext ? "yes" : "no",
-                     display_win32->hasWglEXTSwapControl ? "yes" : "no",
-                     display_win32->hasWglOMLSyncControl ? "yes" : "no",
-                     display_win32->hasWglARBmultisample ? "yes" : "no"));
+  context = g_object_new (GDK_TYPE_WIN32_GL_CONTEXT_WGL,
+                          "display", display,
+                          NULL);
+  if (!gdk_gl_context_realize (context, error))
+    {
+      g_object_unref (context);
+      return NULL;
+    }
+
+#if G_ENABLE_DEBUG
+  {
+    int major, minor;
+    gdk_gl_context_get_version (context, &major, &minor);
+    GDK_NOTE (OPENGL, g_print ("WGL API version %d.%d found\n"
+                         " - Vendor: %s\n"
+                         " - Checked extensions:\n"
+                         "\t* WGL_ARB_pixel_format: %s\n"
+                         "\t* WGL_ARB_create_context: %s\n"
+                         "\t* WGL_EXT_swap_control: %s\n"
+                         "\t* WGL_OML_sync_control: %s\n"
+                         "\t* WGL_ARB_multisample: %s\n",
+                         major, minor,
+                         glGetString (GL_VENDOR),
+                         display_win32->hasWglARBPixelFormat ? "yes" : "no",
+                         display_win32->hasWglARBCreateContext ? "yes" : "no",
+                         display_win32->hasWglEXTSwapControl ? "yes" : "no",
+                         display_win32->hasWglOMLSyncControl ? "yes" : "no",
+                         display_win32->hasWglARBmultisample ? "yes" : "no"));
+  }
+#endif
 
   wglMakeCurrent (NULL, NULL);
 
-  return TRUE;
+  return context;
 }
 
 /* Setup the legacy context after creating it */
 static gboolean
-ensure_legacy_wgl_context (HDC           hdc,
-                           HGLRC         hglrc_legacy,
-                           GdkGLContext *share)
+ensure_legacy_wgl_context (HDC            hdc,
+                           HGLRC          hglrc_legacy,
+                           GdkGLContext  *share,
+                           GdkGLVersion  *version,
+                           GError       **error)
 {
   GdkWin32GLContextWGL *context_wgl;
+  GdkGLVersion legacy_version;
+
+  GDK_NOTE (OPENGL,
+            g_print ("Creating legacy WGL context (version:%d.%d)\n",
+                      gdk_gl_version_get_major (version),
+                      gdk_gl_version_get_minor (version)));
 
   if (!wglMakeCurrent (hdc, hglrc_legacy))
-    return FALSE;
+    {
+      g_set_error_literal (error, GDK_GL_ERROR,
+                           GDK_GL_ERROR_NOT_AVAILABLE,
+                           _("Unable to create a GL context"));
+      return FALSE;
+    }
+
+  gdk_gl_version_init_epoxy (&legacy_version);
+  if (!gdk_gl_version_greater_equal (&legacy_version, version))
+    {
+      g_set_error (error, GDK_GL_ERROR,
+                   GDK_GL_ERROR_NOT_AVAILABLE,
+                   _("WGL version %d.%d is too low, need at least %d.%d"),
+                   gdk_gl_version_get_major (&legacy_version),
+                   gdk_gl_version_get_minor (&legacy_version),
+                   gdk_gl_version_get_major (version),
+                   gdk_gl_version_get_minor (version));
+      return FALSE;
+    }
+
+  *version = legacy_version;
 
   if (share != NULL)
     {
       context_wgl = GDK_WIN32_GL_CONTEXT_WGL (share);
 
-      return wglShareLists (hglrc_legacy, context_wgl->wgl_context);
+      if (!wglShareLists (hglrc_legacy, context_wgl->wgl_context))
+        {
+          g_set_error (error, GDK_GL_ERROR,
+                       GDK_GL_ERROR_UNSUPPORTED_PROFILE,
+                       _("GL implementation cannot share GL contexts"));
+          return FALSE;
+        }
     }
 
   return TRUE;
@@ -356,130 +386,138 @@ create_wgl_context_with_attribs (HDC           hdc,
                                  HGLRC         hglrc_base,
                                  GdkGLContext *share,
                                  int           flags,
-                                 int           major,
-                                 int           minor,
-                                 gboolean     *is_legacy)
+                                 gboolean      is_legacy,
+                                 GdkGLVersion *version)
 {
   HGLRC hglrc;
   GdkWin32GLContextWGL *context_wgl;
+  const GdkGLVersion *supported_versions = gdk_gl_versions_get_for_api (GDK_GL_API_GL);
+  guint i;
 
-  /* if we have wglCreateContextAttribsARB(), create a
-  * context with the compatibility profile if a legacy
-  * context is requested, or when we go into fallback mode
-  */
-  int profile = *is_legacy ? WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :
-                             WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
+  GDK_NOTE (OPENGL,
+            g_print ("Creating %s WGL context (version:%d.%d, debug:%s, forward:%s)\n",
+                      is_legacy ? "core" : "compat",
+                      gdk_gl_version_get_major (version),
+                      gdk_gl_version_get_minor (version),
+                      (flags & WGL_CONTEXT_DEBUG_BIT_ARB) ? "yes" : "no",
+                      (flags & WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB) ? "yes" : "no"));
 
-  int attribs[] = {
-    WGL_CONTEXT_PROFILE_MASK_ARB,   profile,
-    WGL_CONTEXT_MAJOR_VERSION_ARB, *is_legacy ? 3 : major,
-    WGL_CONTEXT_MINOR_VERSION_ARB, *is_legacy ? 0 : minor,
-    WGL_CONTEXT_FLAGS_ARB,          flags,
-    0
-  };
+  for (i = 0; gdk_gl_version_greater_equal (&supported_versions[i], version); i++)
+    {
+      /* if we have wglCreateContextAttribsARB(), create a
+      * context with the compatibility profile if a legacy
+      * context is requested, or when we go into fallback mode
+      */
+      int profile = is_legacy ? WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :
+                                WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
 
-  if (share != NULL)
-    context_wgl = GDK_WIN32_GL_CONTEXT_WGL (share);
+      int attribs[] = {
+        WGL_CONTEXT_PROFILE_MASK_ARB,   profile,
+        WGL_CONTEXT_MAJOR_VERSION_ARB,  gdk_gl_version_get_major (&supported_versions[i]),
+        WGL_CONTEXT_MINOR_VERSION_ARB,  gdk_gl_version_get_minor (&supported_versions[i]),
+        WGL_CONTEXT_FLAGS_ARB,          flags,
+        0
+      };
 
-  hglrc = wglCreateContextAttribsARB (hdc,
-                                      share != NULL ? context_wgl->wgl_context : NULL,
-                                      attribs);
+      if (share != NULL)
+        context_wgl = GDK_WIN32_GL_CONTEXT_WGL (share);
 
-  return hglrc;
+      hglrc = wglCreateContextAttribsARB (hdc,
+                                          share != NULL ? context_wgl->wgl_context : NULL,
+                                          attribs);
+
+      if (hglrc)
+        {
+          *version = supported_versions[i];
+          return hglrc;
+        }
+    }
+
+  return NULL;
 }
 
 static HGLRC
-create_wgl_context (HDC           hdc,
-                    GdkGLContext *share,
-                    int           flags,
-                    int           major,
-                    int           minor,
-                    gboolean     *is_legacy,
-                    gboolean      hasWglARBCreateContext)
+create_wgl_context (GdkGLContext  *context,
+                    HDC            hdc,
+                    gboolean       hasWglARBCreateContext,
+                    GdkGLContext  *share,
+                    int            flags,
+                    gboolean       legacy,
+                    GError       **error)
 {
   /* We need a legacy context for *all* cases */
-  HGLRC hglrc_base = wglCreateContext (hdc);
-  gboolean success = TRUE;
-
+  HGLRC hglrc_base, hglrc;
+  GdkGLVersion version;
   /* Save up the HDC and HGLRC that we are currently using, to restore back to it when we are done here  */
   HDC hdc_current = wglGetCurrentDC ();
   HGLRC hglrc_current = wglGetCurrentContext ();
 
-  /* if we have no wglCreateContextAttribsARB(), return the legacy context when all is set */
-  if (*is_legacy && !hasWglARBCreateContext)
+  hglrc_base = wglCreateContext (hdc);
+  if (hglrc_base == NULL ||
+      !wglMakeCurrent (hdc, hglrc_base))
     {
-      if (ensure_legacy_wgl_context (hdc, hglrc_base, share))
-        {
-          wglMakeCurrent (hdc_current, hglrc_current);
-          return hglrc_base;
-        }
-
-      success = FALSE;
-      goto gl_fail;
+      g_clear_pointer (&hglrc_base, wglDeleteContext);
+      g_set_error_literal (error, GDK_GL_ERROR,
+                           GDK_GL_ERROR_NOT_AVAILABLE,
+                           _("Unable to create a GL context"));
+      return 0;
     }
-  else
+
+  hglrc = NULL;
+
+  if (hasWglARBCreateContext)
     {
-      HGLRC hglrc = NULL;
-
-      if (!wglMakeCurrent (hdc, hglrc_base))
+      if (!legacy)
         {
-          success = FALSE;
-          goto gl_fail;
+          gdk_gl_context_get_matching_version (context,
+                                               GDK_GL_API_GL,
+                                               FALSE,
+                                               &version);
+          hglrc = create_wgl_context_with_attribs (hdc,
+                                                   hglrc_base,
+                                                   share,
+                                                   flags,
+                                                   FALSE,
+                                                   &version);
         }
-
-      hglrc = create_wgl_context_with_attribs (hdc,
-                                               hglrc_base,
-                                               share,
-                                               flags,
-                                               major,
-                                               minor,
-                                               is_legacy);
-
-      /* return the legacy context we have if it could be setup properly, in case the 3.0+ context creation failed */
       if (hglrc == NULL)
         {
-          if (!(*is_legacy))
-            {
-              /* If we aren't using a legacy context in the beginning, try again with a compatibility profile 3.0 context */
-              hglrc = create_wgl_context_with_attribs (hdc,
-                                                       hglrc_base,
-                                                       share,
-                                                       flags,
-                                                       0, 0,
-                                                       is_legacy);
-
-              *is_legacy = TRUE;
-            }
-
-          if (hglrc == NULL)
-            {
-              if (!ensure_legacy_wgl_context (hdc, hglrc_base, share))
-                success = FALSE;
-            }
-
-          if (success)
-            GDK_NOTE (OPENGL, g_print ("Using legacy context as fallback\n"));
+          legacy = TRUE;
+          gdk_gl_context_get_matching_version (context,
+                                               GDK_GL_API_GL,
+                                               TRUE,
+                                               &version);
+          hglrc = create_wgl_context_with_attribs (hdc,
+                                                   hglrc_base,
+                                                   share,
+                                                   flags,
+                                                   TRUE,
+                                                   &version);
         }
+    }
 
-gl_fail:
+  if (hglrc == NULL)
+    {
+      legacy = TRUE;
+      gdk_gl_context_get_matching_version (context,
+                                           GDK_GL_API_GL,
+                                           TRUE,
+                                           &version);
+      if (ensure_legacy_wgl_context (hdc, hglrc_base, share, &version, error))
+        hglrc = g_steal_pointer (&hglrc_base);
+    }
 
-      if (!success)
-        {
-          wglMakeCurrent (NULL, NULL);
-          wglDeleteContext (hglrc_base);
-          return NULL;
-        }
+  if (hglrc)
+    {
+      gdk_gl_context_set_version (context, &version);
+      gdk_gl_context_set_is_legacy (context, legacy);
+    }
 
-      wglMakeCurrent (hdc_current, hglrc_current);
+  g_clear_pointer (&hglrc_base, wglDeleteContext);
 
-      if (hglrc != NULL)
-        {
-          wglDeleteContext (hglrc_base);
-          return hglrc;
-        }
+  wglMakeCurrent (hdc_current, hglrc_current);
 
-      return hglrc_base;
-  }
+  return hglrc;
 }
 
 static gboolean
@@ -525,8 +563,6 @@ gdk_win32_gl_context_wgl_realize (GdkGLContext *context,
 
   /* request flags and specific versions for core (3.2+) WGL context */
   int flags = 0;
-  int major = 0;
-  int minor = 0;
   HGLRC hglrc;
   int pixel_format;
   HDC hdc;
@@ -542,24 +578,6 @@ gdk_win32_gl_context_wgl_realize (GdkGLContext *context,
   debug_bit = gdk_gl_context_get_debug_enabled (context);
   compat_bit = gdk_gl_context_get_forward_compatible (context);
 
-  /*
-   * We may need a Core GL 4.1+ context in order to use the GL support in
-   * the GStreamer media widget backend (such as on Intel drivers), but
-   * wglCreateContextAttribsARB() may only give us the GL context version
-   * that we ask for here, and nothing more.  So, improve things here by
-   * asking for the GL version that is reported to us via epoxy_gl_version(),
-   * rather than the default GL core 3.2 context.
-   */
-  gdk_gl_context_get_clipped_version (context,
-                                      display_win32->gl_version / 10,
-                                      display_win32->gl_version % 10,
-                                      &major, &minor);
-
-  if (surface != NULL)
-    hdc = GDK_WIN32_SURFACE (surface)->hdc;
-  else
-    hdc = display_win32->dummy_context_wgl.hdc;
-
   /*
    * A legacy context cannot be shared with core profile ones, so this means we
    * must stick to a legacy context if the shared context is a legacy context
@@ -568,6 +586,11 @@ gdk_win32_gl_context_wgl_realize (GdkGLContext *context,
                  ? TRUE
                  : share != NULL && gdk_gl_context_is_legacy (share);
 
+  if (surface != NULL)
+    hdc = GDK_WIN32_SURFACE (surface)->hdc;
+  else
+    hdc = display_win32->dummy_context_wgl.hdc;
+
   if (!set_wgl_pixformat_for_hdc (hdc,
                                  &pixel_format,
                                   display_win32))
@@ -587,30 +610,15 @@ gdk_win32_gl_context_wgl_realize (GdkGLContext *context,
   if (compat_bit)
     flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
 
-  GDK_NOTE (OPENGL,
-            g_print ("Creating %s WGL context (version:%d.%d, debug:%s, forward:%s, legacy: %s)\n",
-                      compat_bit ? "core" : "compat",
-                      major,
-                      minor,
-                      debug_bit ? "yes" : "no",
-                      compat_bit ? "yes" : "no",
-                      legacy_bit ? "yes" : "no"));
-
-  hglrc = create_wgl_context (hdc,
+  hglrc = create_wgl_context (context,
+                              hdc,
+                              display_win32->hasWglARBCreateContext,
                               share,
                               flags,
-                              major,
-                              minor,
-                             &legacy_bit,
-                              display_win32->hasWglARBCreateContext);
-
+                              legacy_bit,
+                              error);
   if (hglrc == NULL)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Unable to create a GL context"));
-      return 0;
-    }
+    return 0;
 
   GDK_NOTE (OPENGL,
             g_print ("Created WGL context[%p], pixel_format=%d\n",
@@ -619,9 +627,6 @@ gdk_win32_gl_context_wgl_realize (GdkGLContext *context,
 
   context_wgl->wgl_context = hglrc;
 
-  /* Ensure that any other context is created with a legacy bit set */
-  gdk_gl_context_set_is_legacy (context, legacy_bit);
-
   return GDK_GL_API_GL;
 }
 
@@ -715,10 +720,11 @@ gdk_win32_gl_context_wgl_init (GdkWin32GLContextWGL *wgl_context)
  */
 gboolean
 gdk_win32_display_get_wgl_version (GdkDisplay *display,
-                                   int *major,
-                                   int *minor)
+                                   int         *major,
+                                   int         *minor)
 {
-  GdkWin32Display *display_win32;
+  GdkGLContext *context;
+
   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 
   if (!GDK_IS_WIN32_DISPLAY (display))
@@ -727,12 +733,11 @@ gdk_win32_display_get_wgl_version (GdkDisplay *display,
   if (!gdk_gl_backend_can_be_used (GDK_GL_WGL, NULL))
     return FALSE;
 
-  display_win32 = GDK_WIN32_DISPLAY (display);
+  context = gdk_display_get_gl_context (display);
+  if (context == NULL)
+    return FALSE;
 
-  if (major != NULL)
-    *major = display_win32->gl_version / 10;
-  if (minor != NULL)
-    *minor = display_win32->gl_version % 10;
+  gdk_gl_context_get_version (context, major, minor);
 
   return TRUE;
 }

gdk/win32/gdkglcontext-win32.h

@@ -64,10 +64,10 @@ struct _GdkWin32GLContextClass
 
 typedef struct _GdkWin32GLContextWGL      GdkWin32GLContextWGL;
 
-gboolean  gdk_win32_display_init_wgl                (GdkDisplay *display,
-                                                     GError    **error);
-void      gdk_win32_gl_context_wgl_bind_surface     (GdkWin32GLContextWGL *ctx,
-                                                     GdkWin32Surface      *win32_surface);
+GdkGLContext *  gdk_win32_display_init_wgl              (GdkDisplay             *display,
+                                                         GError                **error);
+void            gdk_win32_gl_context_wgl_bind_surface   (GdkWin32GLContextWGL   *ctx,
+                                                         GdkWin32Surface        *win32_surface);
 
 GType     gdk_win32_gl_context_wgl_get_type         (void) G_GNUC_CONST;
 

gdk/win32/gdkinput-dmanipulation.c

@@ -354,12 +354,13 @@ reset_viewport (IDirectManipulationViewport *viewport)
   HRESULT hr;
 
   hr = IDirectManipulationViewport_GetPrimaryContent (viewport, iid, (void**)&content);
-  HR_CHECK (hr);
+  HR_CHECK_GOTO (hr, failed);
 
   hr = IDirectManipulationContent_SyncContentTransform (content, identity,
                                                         G_N_ELEMENTS (identity));
-  HR_CHECK (hr);
+  HR_CHECK_GOTO (hr, failed);
 
+failed:
   IUnknown_Release (content);
 }
 
@@ -384,7 +385,7 @@ create_viewport (GdkSurface *surface,
 {
   DIRECTMANIPULATION_CONFIGURATION configuration = 0;
   HWND hwnd = GDK_SURFACE_HWND (surface);
-  IDirectManipulationViewportEventHandler *handler;
+  IDirectManipulationViewportEventHandler *handler = NULL;
   DWORD cookie = 0;
   HRESULT hr;
 
@@ -500,7 +501,7 @@ void gdk_dmanipulation_initialize_surface (GdkSurface *surface)
 
   hr = IDirectManipulationManager_Activate (dmanipulation_manager,
                                             GDK_SURFACE_HWND (surface));
-  HR_CHECK (hr);
+  HR_CHECK_RETURN (hr);
 }
 
 void gdk_dmanipulation_finalize_surface (GdkSurface *surface)
@@ -536,11 +537,11 @@ void gdk_dmanipulation_maybe_add_contact (GdkSurface *surface,
 
       hr = IDirectManipulationViewport_SetContact (surface_win32->dmanipulation_viewport_pan,
                                                    pointer_id);
-      HR_CHECK (hr);
+      HR_CHECK_RETURN (hr);
 
       hr = IDirectManipulationViewport_SetContact (surface_win32->dmanipulation_viewport_zoom,
                                                    pointer_id);
-      HR_CHECK (hr);
+      HR_CHECK_RETURN (hr);
     }
 }
 

gdk/win32/gdkmain-win32.c

@@ -109,16 +109,6 @@ gdk_win32_ensure_com (void)
   return co_initialized;
 }
 
-static void
-gdk_win32_finalize_com (void)
-{
-  if (co_initialized)
-    {
-      CoUninitialize ();
-      co_initialized = FALSE;
-    }
-}
-
 gboolean
 gdk_win32_ensure_ole (void)
 {
@@ -142,16 +132,6 @@ gdk_win32_ensure_ole (void)
   return ole_initialized;
 }
 
-static void
-gdk_win32_finalize_ole (void)
-{
-  if (ole_initialized)
-    {
-      OleUninitialize ();
-      ole_initialized = FALSE;
-    }
-}
-
 void
 _gdk_win32_api_failed (const char *where,
                        const char *api)

gdk/win32/gdkprivate-win32.h

@@ -276,7 +276,6 @@ void    _gdk_other_api_failed        (const char *where,
 
 #define HR_CHECK_RETURN(hr) { if G_UNLIKELY (FAILED (hr)) return; }
 #define HR_CHECK_RETURN_VAL(hr, val) { if G_UNLIKELY (FAILED (hr)) return val; }
-#define HR_CHECK(hr)
 #define HR_CHECK_GOTO(hr, label) { if G_UNLIKELY (FAILED (hr)) goto label; }
 
 extern LRESULT CALLBACK _gdk_win32_surface_procedure (HWND, UINT, WPARAM, LPARAM);
@@ -382,14 +381,6 @@ GdkModifierType _gdk_win32_keymap_get_mod_mask   (GdkWin32Keymap *keymap);
 
 GdkKeymap *_gdk_win32_display_get_keymap (GdkDisplay *display);
 
-GdkSurface *_gdk_win32_display_create_surface  (GdkDisplay    *display,
-                                                GdkSurfaceType surface_type,
-                                                GdkSurface     *parent,
-                                                int             x,
-                                                int             y,
-                                                int             width,
-                                                int             height);
-
 /* stray GdkSurfaceImplWin32 members */
 void _gdk_win32_surface_register_dnd (GdkSurface *window);
 void _gdk_win32_surface_unregister_dnd (GdkSurface *window);

gdk/win32/gdksurface-win32.c

@@ -135,14 +135,6 @@ static void     gdk_win32_impl_frame_clock_after_paint (GdkFrameClock *clock,
 
 G_DEFINE_TYPE (GdkWin32Surface, gdk_win32_surface, GDK_TYPE_SURFACE)
 
-GType gdk_win32_toplevel_get_type (void) G_GNUC_CONST;
-GType gdk_win32_popup_get_type (void) G_GNUC_CONST;
-GType gdk_win32_drag_surface_get_type (void) G_GNUC_CONST;
-
-#define GDK_TYPE_WIN32_TOPLEVEL (gdk_win32_toplevel_get_type ())
-#define GDK_TYPE_WIN32_POPUP (gdk_win32_popup_get_type ())
-#define GDK_TYPE_WIN32_DRAG_SURFACE (gdk_win32_drag_surface_get_type ())
-
 static void
 gdk_win32_surface_init (GdkWin32Surface *impl)
 {
@@ -212,10 +204,6 @@ gdk_surface_win32_finalize (GObject *object)
   g_assert (surface->transient_owner == NULL);
   g_assert (surface->transient_children == NULL);
 
-  g_signal_handlers_disconnect_by_func (GDK_SURFACE (object),
-                                        gdk_win32_toplevel_state_callback,
-                                        NULL);
-
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
@@ -334,7 +322,7 @@ get_default_title (void)
  *   get its own class
  */
 static ATOM
-RegisterGdkClass (GdkSurfaceType wtype)
+RegisterGdkClass (GType wtype)
 {
   static ATOM klassTOPLEVEL = 0;
   static ATOM klassTEMP     = 0;
@@ -407,10 +395,8 @@ RegisterGdkClass (GdkSurfaceType wtype)
   /* MSDN: CS_OWNDC is needed for OpenGL contexts */
   wcl.style |= CS_OWNDC;
 
-  switch (wtype)
+  if (wtype != GDK_TYPE_WIN32_DRAG_SURFACE)
     {
-    case GDK_SURFACE_TOPLEVEL:
-    case GDK_SURFACE_POPUP:
       if (0 == klassTOPLEVEL)
         {
           wcl.lpszClassName = L"gdkSurfaceToplevel";
@@ -419,9 +405,9 @@ RegisterGdkClass (GdkSurfaceType wtype)
           klassTOPLEVEL = RegisterClassExW (&wcl);
         }
       klass = klassTOPLEVEL;
-      break;
-
-    case GDK_SURFACE_DRAG:
+    }
+  else
+    {
       if (klassTEMP == 0)
         {
           wcl.lpszClassName = L"gdkSurfaceTemp";
@@ -431,12 +417,6 @@ RegisterGdkClass (GdkSurfaceType wtype)
         }
 
       klass = klassTEMP;
-
-      break;
-
-    default:
-      g_assert_not_reached ();
-      break;
     }
 
   if (klass == 0)
@@ -447,86 +427,20 @@ RegisterGdkClass (GdkSurfaceType wtype)
   return klass;
 }
 
-/*
- * Create native windows.
- *
- * With the default Gdk the created windows are mostly toplevel windows.
- *
- * Placement of the window is derived from the passed in window,
- * except for toplevel window where OS/Window Manager placement
- * is used.
- *
- * [1] http://mail.gnome.org/archives/gtk-devel-list/2010-August/msg00214.html
- */
-GdkSurface *
-_gdk_win32_display_create_surface (GdkDisplay     *display,
-                                   GdkSurfaceType  surface_type,
-                                   GdkSurface     *parent,
-                                   int             x,
-                                   int             y,
-                                   int             width,
-                                   int             height)
+static void
+gdk_win32_surface_constructed (GObject *object)
 {
-  HWND hwndNew;
+  GdkWin32Surface *impl = GDK_WIN32_SURFACE (object);
+  GdkSurface *surface = GDK_SURFACE (impl);
+  GdkDisplay *display = gdk_surface_get_display (surface);
+  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
+  GdkFrameClock *frame_clock;
   HANDLE owner;
   ATOM klass = 0;
   DWORD dwStyle = 0, dwExStyle;
   RECT rect;
-  GdkWin32Surface *impl;
-  GdkWin32Display *display_win32;
-  GdkSurface *surface;
   const char *title;
   wchar_t *wtitle;
-  int window_width, window_height;
-  int window_x, window_y;
-  int real_x = 0, real_y = 0;
-  GdkFrameClock *frame_clock;
-
-  g_return_val_if_fail (display == _gdk_display, NULL);
-
-  GDK_NOTE (MISC,
-            g_print ("_gdk_surface_new: %s\n", (surface_type == GDK_SURFACE_TOPLEVEL ? "TOPLEVEL" :
-                                                       (surface_type == GDK_SURFACE_DRAG? "TEMP" :
-                                                      (surface_type == GDK_SURFACE_DRAG ? "POPUP" : "???")))));
-
-  display_win32 = GDK_WIN32_DISPLAY (display);
-
-  if (parent)
-    frame_clock = g_object_ref (gdk_surface_get_frame_clock (parent));
-  else
-    frame_clock = _gdk_frame_clock_idle_new ();
-
-  switch (surface_type)
-    {
-    case GDK_SURFACE_TOPLEVEL:
-      impl = g_object_new (GDK_TYPE_WIN32_TOPLEVEL,
-                           "display", display,
-                           "frame-clock", frame_clock,
-                           NULL);
-      break;
-    case GDK_SURFACE_POPUP:
-      impl = g_object_new (GDK_TYPE_WIN32_POPUP,
-                           "parent", parent,
-                           "display", display,
-                           "frame-clock", frame_clock,
-                           NULL);
-      break;
-    case GDK_SURFACE_DRAG:
-      impl = g_object_new (GDK_TYPE_WIN32_DRAG_SURFACE,
-                           "display", display,
-                           "frame-clock", frame_clock,
-                           NULL);
-      break;
-    default:
-      g_assert_not_reached ();
-      break;
-    }
-
-  surface = GDK_SURFACE (impl);
-  surface->x = x;
-  surface->y = y;
-  surface->width = width;
-  surface->height = height;
 
   impl->surface_scale = gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL);
 
@@ -536,86 +450,60 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
   /* MSDN: We need WS_CLIPCHILDREN and WS_CLIPSIBLINGS for GL Context Creation */
   dwStyle = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
 
-  switch (surface_type)
+  if (G_OBJECT_TYPE (impl) == GDK_TYPE_WIN32_TOPLEVEL)
     {
-    case GDK_SURFACE_TOPLEVEL:
       dwStyle |= WS_OVERLAPPEDWINDOW;
-      break;
-
-    case GDK_SURFACE_DRAG:
-      dwExStyle |= WS_EX_TOOLWINDOW | WS_EX_TOPMOST;
-      /* fall through */
-    case GDK_SURFACE_POPUP:
-      dwStyle |= WS_POPUP;
-
-      /* Only popup and temp windows are fit to use the Owner Window mechanism */
-      if (parent != NULL)
-        owner = GDK_SURFACE_HWND (parent);
-      break;
-
-    default:
-      g_assert_not_reached ();
+      frame_clock = _gdk_frame_clock_idle_new ();
     }
-
-  rect.left = x * impl->surface_scale;
-  rect.top = y * impl->surface_scale;
-  rect.right = rect.left + width * impl->surface_scale;
-  rect.bottom = rect.top + height * impl->surface_scale;
-
-  AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
-
-  real_x = x * impl->surface_scale;
-  real_y = y * impl->surface_scale;
-
-  if (surface_type == GDK_SURFACE_TOPLEVEL)
+  else if (G_OBJECT_TYPE (impl) == GDK_TYPE_WIN32_DRAG_SURFACE)
     {
-      /* We initially place it at default so that we can get the
-         default window positioning if we want */
-      window_x = window_y = CW_USEDEFAULT;
+      dwExStyle |= WS_EX_TOOLWINDOW | WS_EX_TOPMOST;
+      dwStyle |= WS_POPUP;
+      frame_clock = _gdk_frame_clock_idle_new ();
+    }
+  else if (G_OBJECT_TYPE (impl) == GDK_TYPE_WIN32_POPUP)
+    {
+      GdkSurface *parent = gdk_popup_get_parent (GDK_POPUP (impl));
+      dwStyle |= WS_POPUP;
+      owner = GDK_SURFACE_HWND (parent);
+      frame_clock = g_object_ref (gdk_surface_get_frame_clock (parent));
     }
   else
     {
-      /* TEMP: Put these where requested */
-      window_x = real_x;
-      window_y = real_y;
+      g_assert_not_reached ();
     }
 
-  window_width = rect.right - rect.left;
-  window_height = rect.bottom - rect.top;
+  gdk_surface_set_frame_clock (surface, frame_clock);
+  g_object_unref (frame_clock);
 
   title = get_default_title ();
   if (!title || !*title)
     title = "";
 
-  klass = RegisterGdkClass (surface_type);
+  klass = RegisterGdkClass (G_OBJECT_TYPE (impl));
 
   wtitle = g_utf8_to_utf16 (title, -1, NULL, NULL, NULL);
 
-  hwndNew = CreateWindowExW (dwExStyle,
-			     MAKEINTRESOURCEW (klass),
-			     wtitle,
-			     dwStyle,
-			     window_x, window_y,
-			     window_width, window_height,
-			     owner,
-			     NULL,
-			     _gdk_dll_hinstance,
-			     surface);
-  impl->handle = hwndNew;
+  impl->handle = CreateWindowExW (dwExStyle,
+                                  MAKEINTRESOURCEW (klass),
+                                  wtitle,
+                                  dwStyle,
+                                  CW_USEDEFAULT, CW_USEDEFAULT,
+                                  CW_USEDEFAULT, CW_USEDEFAULT,
+                                  owner,
+                                  NULL,
+                                  _gdk_dll_hinstance,
+                                  surface);
+  if (impl->handle == NULL)
+    {
+      WIN32_API_FAILED ("CreateWindowExW");
+      g_error ("Fatal error: CreateWindowExW failed.");
+    }
 
-  GetWindowRect (hwndNew, &rect);
+  GetWindowRect (impl->handle, &rect);
   impl->initial_x = rect.left;
   impl->initial_y = rect.top;
 
-  /* Now we know the initial position, move to actually specified position */
-  if (real_x != window_x || real_y != window_y)
-    {
-      API_CALL (SetWindowPos, (hwndNew,
-                SWP_NOZORDER_SPECIFIED,
-                real_x, real_y, 0, 0,
-                SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER));
-    }
-
   g_object_ref (impl);
   /* Take note: we're inserting a pointer into a heap-allocated
    * object (impl). Inserting a pointer to a stack variable
@@ -627,26 +515,11 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
    */
   gdk_win32_handle_table_insert (&GDK_SURFACE_HWND (impl), impl);
 
-  GDK_NOTE (MISC, g_print ("... \"%s\" %dx%d@%+d%+d %p = %p\n",
-			   title,
-			   window_width, window_height,
-			   surface->x,
-			   surface->y,
-			   owner,
-			   hwndNew));
-
   g_free (wtitle);
 
-  if (impl->handle == NULL)
-    {
-      WIN32_API_FAILED ("CreateWindowExW");
-      g_object_unref (impl);
-      return NULL;
-    }
-
   gdk_surface_set_egl_native_window (surface, (void *) impl->handle);
 
-  if (surface_type != GDK_SURFACE_DRAG)
+  if (G_OBJECT_TYPE (impl) != GDK_TYPE_WIN32_DRAG_SURFACE)
     {
       if (display_win32->tablet_input_api == GDK_WIN32_TABLET_INPUT_API_WINPOINTER)
         gdk_winpointer_initialize_surface (surface);
@@ -663,18 +536,10 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
                     G_CALLBACK (gdk_win32_impl_frame_clock_after_paint),
                     impl);
 
-  g_object_unref (frame_clock);
   impl->hdc = GetDC (impl->handle);
   impl->inhibit_configure = TRUE;
 
-  if (surface_type == GDK_SURFACE_TOPLEVEL)
-    {
-      g_signal_connect (surface, "notify::state",
-                        G_CALLBACK (gdk_win32_toplevel_state_callback),
-                        NULL);
-    }
-
-  return surface;
+  G_OBJECT_CLASS (parent_class)->constructed (object);
 }
 
 static void
@@ -4636,6 +4501,7 @@ gdk_win32_surface_class_init (GdkWin32SurfaceClass *klass)
 
   parent_class = g_type_class_peek_parent (klass);
 
+  object_class->constructed = gdk_win32_surface_constructed;
   object_class->dispose = gdk_surface_win32_dispose;
   object_class->finalize = gdk_surface_win32_finalize;
 
@@ -4824,15 +4690,20 @@ G_DEFINE_TYPE_WITH_CODE (GdkWin32Toplevel, gdk_win32_toplevel, GDK_TYPE_WIN32_SU
                                                 gdk_win32_toplevel_iface_init))
 
 static void
-gdk_win32_toplevel_init (GdkWin32Toplevel *toplevel)
+gdk_win32_toplevel_constructed (GObject *object)
 {
+  g_signal_connect (object, "notify::state",
+                    G_CALLBACK (gdk_win32_toplevel_state_callback),
+                    NULL);
+
+  G_OBJECT_CLASS (gdk_win32_toplevel_parent_class)->constructed (object);
 }
 
 static void
 gdk_win32_toplevel_set_property (GObject      *object,
-                                   guint         prop_id,
-                                   const GValue *value,
-                                   GParamSpec   *pspec)
+                                 guint         prop_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
 {
   GdkSurface *surface = GDK_SURFACE (object);
 
@@ -4891,9 +4762,9 @@ gdk_win32_toplevel_set_property (GObject      *object,
 
 static void
 gdk_win32_toplevel_get_property (GObject    *object,
-                                   guint       prop_id,
-                                   GValue     *value,
-                                   GParamSpec *pspec)
+                                 guint       prop_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
 {
   GdkSurface *surface = GDK_SURFACE (object);
 
@@ -4942,17 +4813,36 @@ gdk_win32_toplevel_get_property (GObject    *object,
     }
 }
 
+static void
+gdk_win32_toplevel_finalize (GObject *object)
+{
+  GdkWin32Surface *self = GDK_WIN32_SURFACE (object);
+
+  g_signal_handlers_disconnect_by_func (self,
+                                        gdk_win32_toplevel_state_callback,
+                                        NULL);
+
+  G_OBJECT_CLASS (gdk_win32_toplevel_parent_class)->finalize (object);
+}
+
 static void
 gdk_win32_toplevel_class_init (GdkWin32ToplevelClass *class)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (class);
 
+  object_class->constructed = gdk_win32_toplevel_constructed;
+  object_class->finalize = gdk_win32_toplevel_finalize;
   object_class->get_property = gdk_win32_toplevel_get_property;
   object_class->set_property = gdk_win32_toplevel_set_property;
 
   gdk_toplevel_install_properties (object_class, 1);
 }
 
+static void
+gdk_win32_toplevel_init (GdkWin32Toplevel *toplevel)
+{
+}
+
 static void
 gdk_win32_toplevel_present (GdkToplevel       *toplevel,
                             GdkToplevelLayout *layout)
@@ -5228,3 +5118,11 @@ _gdk_win32_surface_invalidate_egl_framebuffer (GdkSurface *surface)
     }
 #endif
 }
+
+GdkSurface *
+gdk_win32_drag_surface_new (GdkDisplay *display)
+{
+  return g_object_new (GDK_TYPE_WIN32_DRAG_SURFACE,
+                       "display", display,
+                       NULL);
+}

gdk/win32/gdksurface-win32.h

@@ -39,6 +39,14 @@
 
 G_BEGIN_DECLS
 
+GType gdk_win32_toplevel_get_type (void) G_GNUC_CONST;
+GType gdk_win32_popup_get_type (void) G_GNUC_CONST;
+GType gdk_win32_drag_surface_get_type (void) G_GNUC_CONST;
+
+#define GDK_TYPE_WIN32_TOPLEVEL (gdk_win32_toplevel_get_type ())
+#define GDK_TYPE_WIN32_POPUP (gdk_win32_popup_get_type ())
+#define GDK_TYPE_WIN32_DRAG_SURFACE (gdk_win32_drag_surface_get_type ())
+
 typedef enum
 {
   GDK_DECOR_ALL         = 1 << 0,
@@ -364,6 +372,8 @@ void gdk_win32_surface_move_resize (GdkSurface *window,
                                     int         width,
                                     int         height);
 
+GdkSurface *gdk_win32_drag_surface_new       (GdkDisplay *display);
+
 RECT
 gdk_win32_surface_handle_queued_move_resize (GdkDrawContext *draw_context);
 

gdk/x11/gdkdisplay-x11.c

@@ -1391,11 +1391,7 @@ gdk_x11_display_init_leader_surface (GdkX11Display *self)
 
   gdk_event_init (display);
 
-  self->leader_gdk_surface =
-      _gdk_x11_display_create_surface (display,
-                                       GDK_SURFACE_DRAG,
-                                       NULL,
-                                       -100, -100, 1, 1);
+  self->leader_gdk_surface = gdk_x11_drag_surface_new (display);
 
   (_gdk_x11_surface_get_toplevel (self->leader_gdk_surface))->is_leader = TRUE;
   self->leader_window = GDK_SURFACE_XID (self->leader_gdk_surface);
@@ -3032,6 +3028,8 @@ gdk_x11_display_class_init (GdkX11DisplayClass * class)
   object_class->dispose = gdk_x11_display_dispose;
   object_class->finalize = gdk_x11_display_finalize;
 
+  display_class->toplevel_type = GDK_TYPE_X11_TOPLEVEL;
+  display_class->popup_type = GDK_TYPE_X11_POPUP;
   display_class->cairo_context_type = GDK_TYPE_X11_CAIRO_CONTEXT;
 #ifdef GDK_RENDERING_VULKAN
   display_class->vk_context_type = GDK_TYPE_X11_VULKAN_CONTEXT;
@@ -3052,7 +3050,6 @@ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
   display_class->get_startup_notification_id = gdk_x11_display_get_startup_notification_id;
 G_GNUC_END_IGNORE_DEPRECATIONS
   display_class->notify_startup_complete = gdk_x11_display_notify_startup_complete;
-  display_class->create_surface = _gdk_x11_display_create_surface;
   display_class->get_keymap = gdk_x11_display_get_keymap;
 
   display_class->init_gl = gdk_x11_display_init_gl;

gdk/x11/gdkdrag-x11.c

@@ -1255,19 +1255,6 @@ gdk_drag_do_leave (GdkX11Drag *drag_x11)
     }
 }
 
-static GdkSurface *
-create_drag_surface (GdkDisplay *display)
-{
-  GdkSurface *surface;
-
-  surface = _gdk_x11_display_create_surface (display,
-                                             GDK_SURFACE_DRAG,
-                                             NULL,
-                                             0, 0, 100, 100);
-
-  return surface;
-}
-
 static Window
 _gdk_x11_display_get_drag_protocol (GdkDisplay      *display,
                                     Window           xid,
@@ -1843,11 +1830,6 @@ gdk_x11_drag_drop_done (GdkDrag  *drag,
 {
   GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
   GdkDragAnim *anim;
-/*
-  cairo_surface_t *win_surface;
-  cairo_surface_t *surface;
-  cairo_t *cr;
-*/
   guint id;
 
   gdk_x11_drag_release_selection (drag);
@@ -1862,26 +1844,6 @@ gdk_x11_drag_drop_done (GdkDrag  *drag,
       return;
     }
 
-/*
-  win_surface = _gdk_surface_ref_cairo_surface (x11_drag->drag_surface);
-  surface = gdk_surface_create_similar_surface (x11_drag->drag_surface,
-                                               cairo_surface_get_content (win_surface),
-                                               gdk_surface_get_width (x11_drag->drag_surface),
-                                               gdk_surface_get_height (x11_drag->drag_surface));
-  cr = cairo_create (surface);
-  cairo_set_source_surface (cr, win_surface, 0, 0);
-  cairo_paint (cr);
-  cairo_destroy (cr);
-  cairo_surface_destroy (win_surface);
-
-  pattern = cairo_pattern_create_for_surface (surface);
-
-  gdk_surface_set_background_pattern (x11_drag->drag_surface, pattern);
-
-  cairo_pattern_destroy (pattern);
-  cairo_surface_destroy (surface);
-*/
-
   anim = g_new0 (GdkDragAnim, 1);
   anim->drag = g_object_ref (x11_drag);
   anim->frame_clock = gdk_surface_get_frame_clock (x11_drag->drag_surface);
@@ -2026,10 +1988,7 @@ _gdk_x11_surface_drag_begin (GdkSurface         *surface,
 
   display = gdk_surface_get_display (surface);
 
-  ipc_surface = _gdk_x11_display_create_surface (display,
-                                                 GDK_SURFACE_DRAG,
-                                                 NULL,
-                                                 -99, -99, 1, 1);
+  ipc_surface = gdk_x11_drag_surface_new (display);
 
   drag = (GdkDrag *) g_object_new (GDK_TYPE_X11_DRAG,
                                    "surface", ipc_surface,
@@ -2063,7 +2022,7 @@ _gdk_x11_surface_drag_begin (GdkSurface         *surface,
   gdk_surface_set_is_mapped (x11_drag->ipc_surface, TRUE);
   gdk_x11_surface_show (x11_drag->ipc_surface, FALSE);
 
-  x11_drag->drag_surface = create_drag_surface (display);
+  x11_drag->drag_surface = gdk_x11_drag_surface_new (display);
 
   if (!drag_grab (drag))
     {

gdk/x11/gdkglcontext-glx.c

@@ -477,8 +477,11 @@ gdk_x11_context_create_glx_context (GdkGLContext *context,
   GdkSurface *surface = gdk_gl_context_get_surface (context);
   GLXContext ctx;
   int context_attribs[N_GLX_ATTRS], i = 0, flags = 0;
-  int min_major, min_minor, major, minor;
+  gsize major_idx, minor_idx;
+  GdkGLVersion version;
+  const GdkGLVersion* supported_versions;
   gboolean debug_bit, compat_bit;
+  gsize j;
 
   if (!gdk_gl_context_is_api_allowed (context, api, NULL))
     return 0;
@@ -488,10 +491,7 @@ gdk_x11_context_create_glx_context (GdkGLContext *context,
 
   /* We will use the default version matching the context status
    * unless the user requested a version which makes sense */
-  gdk_gl_context_get_matching_version (api, legacy, 0,
-                                       &min_major, &min_minor);
-  gdk_gl_context_get_clipped_version (context, min_major, min_minor,
-                                      &major, &minor);
+  gdk_gl_context_get_matching_version (context, api, legacy, &version);
 
   debug_bit = gdk_gl_context_get_debug_enabled (context);
   compat_bit = gdk_gl_context_get_forward_compatible (context);
@@ -511,9 +511,9 @@ gdk_x11_context_create_glx_context (GdkGLContext *context,
     context_attribs[i++] = GLX_CONTEXT_ES2_PROFILE_BIT_EXT;
 
   context_attribs[i++] = GLX_CONTEXT_MAJOR_VERSION_ARB;
-  context_attribs[i++] = major;
+  major_idx = i++;
   context_attribs[i++] = GLX_CONTEXT_MINOR_VERSION_ARB;
-  context_attribs[i++] = minor;
+  minor_idx = i++;
   context_attribs[i++] = GLX_CONTEXT_FLAGS_ARB;
   context_attribs[i++] = flags;
 
@@ -522,7 +522,7 @@ gdk_x11_context_create_glx_context (GdkGLContext *context,
 
   GDK_DISPLAY_DEBUG (display, OPENGL,
                      "Creating GLX context version %d.%d (debug:%s, forward:%s, legacy:%s, es:%s)",
-                     major, minor,
+                     gdk_gl_version_get_major (&version), gdk_gl_version_get_minor (&version),
                      debug_bit ? "yes" : "no",
                      compat_bit ? "yes" : "no",
                      legacy ? "yes" : "no",
@@ -533,25 +533,44 @@ gdk_x11_context_create_glx_context (GdkGLContext *context,
 
   gdk_x11_display_error_trap_push (display);
 
-  /* If we don't have access to GLX_ARB_create_context_profile, then
-   * we have to fall back to the old GLX 1.3 API.
-   */
-  if (legacy && !display_x11->has_glx_create_context)
-    ctx = glXCreateNewContext (gdk_x11_display_get_xdisplay (display),
-                               display_x11->glx_config,
-                               GLX_RGBA_TYPE,
-                               share_glx != NULL ? share_glx->glx_context : NULL,
-                               TRUE);
+  supported_versions = gdk_gl_versions_get_for_api (api);
+  for (j = 0; gdk_gl_version_greater_equal (&supported_versions[j], &version); j++)
+    {
+      context_attribs [major_idx] = gdk_gl_version_get_major (&supported_versions[j]);
+      context_attribs [minor_idx] = gdk_gl_version_get_minor (&supported_versions[j]);
 
-  else
-    ctx = glXCreateContextAttribsARB (gdk_x11_display_get_xdisplay (display),
-                                      display_x11->glx_config,
-                                      share_glx != NULL ? share_glx->glx_context : NULL,
-                                      True,
-                                      context_attribs);
+      /* If we don't have access to GLX_ARB_create_context_profile, then
+       * we have to fall back to the old GLX 1.3 API.
+       */
+      if (legacy && !display_x11->has_glx_create_context)
+        ctx = glXCreateNewContext (gdk_x11_display_get_xdisplay (display),
+                                   display_x11->glx_config,
+                                   GLX_RGBA_TYPE,
+                                   share_glx != NULL ? share_glx->glx_context : NULL,
+                                   TRUE);
 
-  if (gdk_x11_display_error_trap_pop (display) || ctx == NULL)
-    return 0;
+      else
+        ctx = glXCreateContextAttribsARB (gdk_x11_display_get_xdisplay (display),
+                                          display_x11->glx_config,
+                                          share_glx != NULL ? share_glx->glx_context : NULL,
+                                          True,
+                                          context_attribs);
+
+      if (ctx)
+        break;
+    }
+
+  if (ctx == NULL)
+    {
+      gdk_x11_display_error_trap_pop_ignored (display);
+      return 0;
+    }
+
+  if (gdk_x11_display_error_trap_pop (display))
+    {
+      glXDestroyContext (dpy, ctx);
+      return 0;
+    }
 
   GDK_DISPLAY_DEBUG (display, OPENGL,
                      "Realized GLX context[%p], %s, version: %d.%d",
@@ -561,6 +580,7 @@ gdk_x11_context_create_glx_context (GdkGLContext *context,
                      display_x11->glx_version % 10);
 
   context_glx->glx_context = ctx;
+  gdk_gl_context_set_version (context, &supported_versions[j]);
   gdk_gl_context_set_is_legacy (context, legacy);
 
 #ifdef HAVE_XDAMAGE

gdk/x11/gdkprivate-x11.h

@@ -173,13 +173,6 @@ void       _gdk_x11_display_get_maximal_cursor_size (GdkDisplay *display,
                                                      guint      *width,
                                                      guint      *height);
 
-GdkSurface * _gdk_x11_display_create_surface (GdkDisplay     *display,
-                                              GdkSurfaceType  surface_type,
-                                              GdkSurface     *parent,
-                                              int             x,
-                                              int             y,
-                                              int             width,
-                                              int             height);
 GList *    gdk_x11_display_get_toplevel_windows     (GdkDisplay *display);
 
 void _gdk_x11_precache_atoms (GdkDisplay          *display,

gdk/x11/gdksurface-x11.h

@@ -36,6 +36,14 @@
 
 G_BEGIN_DECLS
 
+GType gdk_x11_toplevel_get_type (void) G_GNUC_CONST;
+GType gdk_x11_popup_get_type (void) G_GNUC_CONST;
+GType gdk_x11_drag_surface_get_type (void) G_GNUC_CONST;
+
+#define GDK_TYPE_X11_TOPLEVEL (gdk_x11_toplevel_get_type ())
+#define GDK_TYPE_X11_POPUP (gdk_x11_popup_get_type ())
+#define GDK_TYPE_X11_DRAG_SURFACE (gdk_x11_drag_surface_get_type ())
+
 typedef struct _GdkToplevelX11 GdkToplevelX11;
 typedef struct _GdkXPositionInfo GdkXPositionInfo;
 
@@ -191,6 +199,8 @@ struct _GdkToplevelX11
 #endif
 };
 
+GdkSurface     *gdk_x11_drag_surface_new             (GdkDisplay *display);
+
 GdkToplevelX11 *_gdk_x11_surface_get_toplevel        (GdkSurface *window);
 
 GdkCursor      *_gdk_x11_surface_get_cursor          (GdkSurface *window);

gsk/gl/gskglcommandqueue.c

@@ -427,6 +427,7 @@ gsk_gl_command_queue_dispose (GObject *object)
   gsk_gl_command_batches_clear (&self->batches);
   gsk_gl_command_binds_clear (&self->batch_binds);
   gsk_gl_command_uniforms_clear (&self->batch_uniforms);
+  gsk_gl_syncs_clear (&self->syncs);
 
   gsk_gl_buffer_destroy (&self->vertices);
 
@@ -449,6 +450,7 @@ gsk_gl_command_queue_init (GskGLCommandQueue *self)
   gsk_gl_command_batches_init (&self->batches, 128);
   gsk_gl_command_binds_init (&self->batch_binds, 1024);
   gsk_gl_command_uniforms_init (&self->batch_uniforms, 2048);
+  gsk_gl_syncs_init (&self->syncs, 10);
 
   gsk_gl_buffer_init (&self->vertices, GL_ARRAY_BUFFER, sizeof (GskGLDrawVertex));
 }
@@ -491,7 +493,7 @@ gsk_gl_command_queue_new (GdkGLContext      *context,
         }
     }
 
-  self->has_samplers = gdk_gl_context_check_version (context, 3, 3, 3, 0);
+  self->has_samplers = gdk_gl_context_check_version (context, "3.3", "3.0");
 
   /* create the samplers */
   if (self->has_samplers)
@@ -1020,10 +1022,10 @@ gsk_gl_command_queue_execute (GskGLCommandQueue    *self,
   guint program = 0;
   guint width = 0;
   guint height = 0;
-  G_GNUC_UNUSED guint n_binds = 0;
-  guint n_fbos = 0;
-  G_GNUC_UNUSED guint n_uniforms = 0;
-  guint n_programs = 0;
+  G_GNUC_UNUSED unsigned int n_binds = 0;
+  G_GNUC_UNUSED unsigned int n_fbos = 0;
+  G_GNUC_UNUSED unsigned int n_uniforms = 0;
+  G_GNUC_UNUSED unsigned int n_programs = 0;
   guint vao_id;
   guint vbo_id;
   int textures[4];
@@ -1060,8 +1062,11 @@ gsk_gl_command_queue_execute (GskGLCommandQueue    *self,
   glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
   glBlendEquation (GL_FUNC_ADD);
 
-  glGenVertexArrays (1, &vao_id);
-  glBindVertexArray (vao_id);
+  if (!gdk_gl_context_get_use_es (self->context))
+    {
+      glGenVertexArrays (1, &vao_id);
+      glBindVertexArray (vao_id);
+    }
 
   vbo_id = gsk_gl_buffer_submit (&self->vertices);
 
@@ -1156,17 +1161,25 @@ gsk_gl_command_queue_execute (GskGLCommandQueue    *self,
           if G_UNLIKELY (batch->draw.bind_count > 0)
             {
               const GskGLCommandBind *bind = &self->batch_binds.items[batch->draw.bind_offset];
-
               for (guint i = 0; i < batch->draw.bind_count; i++)
                 {
                   if (textures[bind->texture] != bind->id)
                     {
+                      GskGLSync *s;
+
                       if (active != bind->texture)
                         {
                           active = bind->texture;
                           glActiveTexture (GL_TEXTURE0 + bind->texture);
                         }
 
+                      s = gsk_gl_syncs_get_sync (&self->syncs, bind->id);
+                      if (s && s->sync)
+                        {
+                          glWaitSync ((GLsync) s->sync, 0, GL_TIMEOUT_IGNORED);
+                          s->sync = NULL;
+                        }
+
                       glBindTexture (GL_TEXTURE_2D, bind->id);
                       textures[bind->texture] = bind->id;
                       if (!self->has_samplers)
@@ -1234,7 +1247,8 @@ gsk_gl_command_queue_execute (GskGLCommandQueue    *self,
     }
 
   glDeleteBuffers (1, &vbo_id);
-  glDeleteVertexArrays (1, &vao_id);
+  if (!gdk_gl_context_get_use_es (self->context))
+    glDeleteVertexArrays (1, &vao_id);
 
   gdk_profiler_set_int_counter (self->metrics.n_binds, n_binds);
   gdk_profiler_set_int_counter (self->metrics.n_uniforms, n_uniforms);
@@ -1311,6 +1325,7 @@ gsk_gl_command_queue_end_frame (GskGLCommandQueue *self)
   self->batches.len = 0;
   self->batch_binds.len = 0;
   self->batch_uniforms.len = 0;
+  self->syncs.len = 0;
   self->n_uploads = 0;
   self->tail_batch_index = -1;
   self->in_frame = FALSE;
@@ -1425,28 +1440,44 @@ gsk_gl_command_queue_create_framebuffer (GskGLCommandQueue *self)
 static GdkMemoryFormat
 memory_format_gl_format (GdkMemoryFormat  data_format,
                          gboolean         use_es,
+                         guint            major,
+                         guint            minor,
                          guint           *gl_internalformat,
                          guint           *gl_format,
                          guint           *gl_type)
 {
+  if (gdk_memory_format_gl_format (data_format,
+                                   use_es,
+                                   major,
+                                   minor,
+                                   gl_internalformat,
+                                   gl_format,
+                                   gl_type))
+    return data_format;
+
+  if (gdk_memory_format_prefers_high_depth (data_format))
+    {
+      data_format = GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED;
+      if (gdk_memory_format_gl_format (data_format,
+                                       use_es,
+                                       major,
+                                       minor,
+                                       gl_internalformat,
+                                       gl_format,
+                                       gl_type))
+        return data_format;
+    }
+
+  data_format = GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
   if (!gdk_memory_format_gl_format (data_format,
                                     use_es,
+                                    major,
+                                    minor,
                                     gl_internalformat,
                                     gl_format,
                                     gl_type))
     {
-      if (gdk_memory_format_prefers_high_depth (data_format))
-        data_format = GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED;
-      else
-        data_format = GDK_MEMORY_R8G8B8A8_PREMULTIPLIED;
-      if (!gdk_memory_format_gl_format (data_format,
-                                        use_es,
-                                        gl_internalformat,
-                                        gl_format,
-                                        gl_type))
-        {
-          g_assert_not_reached ();
-        }
+      g_assert_not_reached ();
     }
 
   return data_format;
@@ -1458,7 +1489,6 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
                                               int                x,
                                               int                y)
 {
-  GdkGLContext *context;
   const guchar *data;
   gsize stride;
   GBytes *bytes;
@@ -1470,15 +1500,18 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
   GLenum gl_type;
   gsize bpp;
   gboolean use_es;
+  int major, minor;
 
-  context = gdk_gl_context_get_current ();
-  use_es = gdk_gl_context_get_use_es (context);
+  use_es = gdk_gl_context_get_use_es (self->context);
+  gdk_gl_context_get_version (self->context, &major, &minor);
   data_format = gdk_texture_get_format (texture);
   width = gdk_texture_get_width (texture);
   height = gdk_texture_get_height (texture);
 
   data_format = memory_format_gl_format (data_format,
                                          use_es,
+                                         major,
+                                         minor,
                                          &gl_internalformat,
                                          &gl_format,
                                          &gl_type);
@@ -1500,7 +1533,7 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
       glTexSubImage2D (GL_TEXTURE_2D, 0, x, y, width, height, gl_format, gl_type, data);
     }
   else if (stride % bpp == 0 &&
-           (gdk_gl_context_check_version (context, 0, 0, 3, 0) || gdk_gl_context_has_unpack_subimage (context)))
+           (gdk_gl_context_check_version (self->context, NULL, "3.0") || gdk_gl_context_has_unpack_subimage (self->context)))
     {
       glPixelStorei (GL_UNPACK_ROW_LENGTH, stride / bpp);
 
@@ -1532,6 +1565,7 @@ gsk_gl_command_queue_upload_texture_chunks (GskGLCommandQueue    *self,
   GLenum gl_type;
   gboolean use_es;
   int texture_id;
+  int major, minor;
 
   g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
 
@@ -1564,10 +1598,13 @@ gsk_gl_command_queue_upload_texture_chunks (GskGLCommandQueue    *self,
   glBindTexture (GL_TEXTURE_2D, texture_id);
 
   /* Initialize the texture */
-  use_es = gdk_gl_context_get_use_es (gdk_gl_context_get_current ());
+  use_es = gdk_gl_context_get_use_es (self->context);
+  gdk_gl_context_get_version (self->context, &major, &minor);
   data_format = gdk_texture_get_format (chunks[0].texture);
   memory_format_gl_format (data_format,
                            use_es,
+                           major,
+                           minor,
                            &gl_internalformat,
                            &gl_format,
                            &gl_type);

gsk/gl/gskglcommandqueueprivate.h

@@ -168,9 +168,15 @@ typedef union _GskGLCommandBatch
 
 G_STATIC_ASSERT (sizeof (GskGLCommandBatch) == 32);
 
+typedef struct _GskGLSync {
+  guint id;
+  gpointer sync;
+} GskGLSync;
+
 DEFINE_INLINE_ARRAY (GskGLCommandBatches, gsk_gl_command_batches, GskGLCommandBatch)
 DEFINE_INLINE_ARRAY (GskGLCommandBinds, gsk_gl_command_binds, GskGLCommandBind)
 DEFINE_INLINE_ARRAY (GskGLCommandUniforms, gsk_gl_command_uniforms, GskGLCommandUniform)
+DEFINE_INLINE_ARRAY (GskGLSyncs, gsk_gl_syncs, GskGLSync)
 
 struct _GskGLCommandQueue
 {
@@ -233,6 +239,10 @@ struct _GskGLCommandQueue
    */
   GLuint samplers[GSK_GL_N_FILTERS * GSK_GL_N_FILTERS];
 
+  /* Array of sync objects to wait on.
+   */
+  GskGLSyncs syncs;
+
   /* Discovered max texture size when loading the command queue so that we
    * can either scale down or slice textures to fit within this size. Assumed
    * to be both height and width.
@@ -371,5 +381,36 @@ gsk_gl_command_queue_bind_framebuffer (GskGLCommandQueue *self,
   return ret;
 }
 
+static inline GskGLSync *
+gsk_gl_syncs_get_sync (GskGLSyncs *syncs,
+                       guint       id)
+{
+  for (unsigned int i = 0; i < syncs->len; i++)
+    {
+      GskGLSync *sync = &syncs->items[i];
+      if (sync->id == id)
+        return sync;
+    }
+  return NULL;
+}
+
+static inline void
+gsk_gl_syncs_add_sync (GskGLSyncs *syncs,
+                       guint       id,
+                       gpointer    sync)
+{
+  GskGLSync *s;
+
+  s = gsk_gl_syncs_get_sync (syncs, id);
+  if (s)
+    g_assert (s->sync == sync);
+  else
+    {
+      s = gsk_gl_syncs_append (syncs);
+      s->id = id;
+      s->sync = sync;
+    }
+}
+
 G_END_DECLS
 

gsk/gl/gskgldriver.c

@@ -1126,14 +1126,20 @@ write_atlas_to_png (GskGLDriver       *driver,
                     GskGLTextureAtlas *atlas,
                     const char        *filename)
 {
+  GdkGLTextureBuilder *builder;
   GdkTexture *texture;
 
-  texture = gdk_gl_texture_new (gsk_gl_driver_get_context (driver),
-                                atlas->texture_id,
-                                atlas->width, atlas->height,
-                                NULL, NULL);
+  builder = gdk_gl_texture_builder_new ();
+  gdk_gl_texture_builder_set_context (builder, gsk_gl_driver_get_context (driver));
+  gdk_gl_texture_builder_set_id (builder, atlas->texture_id);
+  gdk_gl_texture_builder_set_width (builder, atlas->width);
+  gdk_gl_texture_builder_set_height (builder, atlas->height);
+
+  texture = gdk_gl_texture_builder_build (builder, NULL, NULL);
   gdk_texture_save_to_png (texture, filename);
+
   g_object_unref (texture);
+  g_object_unref (builder);
 }
 
 void
@@ -1557,6 +1563,7 @@ typedef struct _GskGLTextureState
 {
   GdkGLContext *context;
   GLuint        texture_id;
+  GLsync        sync;
 } GskGLTextureState;
 
 static void
@@ -1569,6 +1576,8 @@ create_texture_from_texture_destroy (gpointer data)
 
   gdk_gl_context_make_current (state->context);
   glDeleteTextures (1, &state->texture_id);
+  if (state->sync)
+    glDeleteSync (state->sync);
   g_clear_object (&state->context);
   g_free (state);
 }
@@ -1578,8 +1587,9 @@ gsk_gl_driver_create_gdk_texture (GskGLDriver *self,
                                   guint        texture_id)
 {
   GskGLTextureState *state;
+  GdkGLTextureBuilder *builder;
   GskGLTexture *texture;
-  int width, height;
+  GdkTexture *result;
 
   g_return_val_if_fail (GSK_IS_GL_DRIVER (self), NULL);
   g_return_val_if_fail (self->command_queue != NULL, NULL);
@@ -1594,19 +1604,25 @@ gsk_gl_driver_create_gdk_texture (GskGLDriver *self,
   state = g_new0 (GskGLTextureState, 1);
   state->texture_id = texture_id;
   state->context = g_object_ref (self->command_queue->context);
+  if (gdk_gl_context_has_sync (self->command_queue->context))
+    state->sync = glFenceSync (GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
 
   g_hash_table_steal (self->textures, GUINT_TO_POINTER (texture_id));
 
-  width = texture->width;
-  height = texture->height;
+  builder = gdk_gl_texture_builder_new ();
+  gdk_gl_texture_builder_set_context (builder, self->command_queue->context);
+  gdk_gl_texture_builder_set_id (builder, texture_id);
+  gdk_gl_texture_builder_set_width (builder, texture->width);
+  gdk_gl_texture_builder_set_height (builder, texture->height);
+  gdk_gl_texture_builder_set_sync (builder, state->sync);
+
+  result = gdk_gl_texture_builder_build (builder,
+                                         create_texture_from_texture_destroy,
+                                         state);
 
   texture->texture_id = 0;
   gsk_gl_texture_free (texture);
+  g_object_unref (builder);
 
-  return gdk_gl_texture_new (self->command_queue->context,
-                             texture_id,
-                             width,
-                             height,
-                             create_texture_from_texture_destroy,
-                             state);
+  return result;
 }

gsk/gl/gskglprofiler.c

@@ -18,9 +18,9 @@ struct _GskGLProfiler
   GLuint gl_queries[N_QUERIES];
   GLuint active_query;
 
-  gboolean has_queries : 1;
-  gboolean has_timer : 1;
-  gboolean first_frame : 1;
+  unsigned int has_queries : 1;
+  unsigned int has_timer : 1;
+  unsigned int first_frame : 1;
 };
 
 enum {

gsk/gl/gskglprogramprivate.h

@@ -285,6 +285,22 @@ gsk_gl_program_set_uniform_texture (GskGLProgram *self,
                                                   GL_LINEAR);
 }
 
+static inline void
+gsk_gl_program_set_uniform_texture_with_sync (GskGLProgram *self,
+                                              guint         key,
+                                              guint         stamp,
+                                              GLenum        texture_target,
+                                              GLenum        texture_slot,
+                                              guint         texture_id,
+                                              GLint         min_filter,
+                                              GLint         max_filter,
+                                              gpointer      sync)
+{
+  gsk_gl_program_set_uniform_texture_with_filter (self, key, stamp, texture_target, texture_slot, texture_id,
+                                                  min_filter, max_filter);
+  gsk_gl_syncs_add_sync (&self->driver->command_queue->syncs, texture_id, sync);
+}
+
 static inline void
 gsk_gl_program_set_uniform_matrix (GskGLProgram            *self,
                                    guint                    key,

gsk/gl/gskglrenderer.c

@@ -372,7 +372,11 @@ gsk_gl_renderer_render_texture (GskRenderer           *renderer,
       return texture;
     }
 
-  format = gsk_render_node_prefers_high_depth (root) ? GL_RGBA32F : GL_RGBA8;
+  if (gsk_render_node_prefers_high_depth (root) &&
+      gdk_gl_context_check_version (self->context, "3.0", "3.0"))
+    format = GL_RGBA32F;
+  else 
+    format = GL_RGBA8;
 
   gdk_gl_context_make_current (self->context);
 

gsk/gl/gskglrenderjob.c

@@ -191,6 +191,7 @@ typedef struct _GskGLRenderOffscreen
 
   /* Return location for texture ID */
   guint texture_id;
+  gpointer sync;
 
   /* Whether to force creating a new texture, even if the
    * input already is a texture
@@ -255,7 +256,7 @@ gsk_rounded_rect_shrink_to_minimum (GskRoundedRect *self)
 static inline gboolean G_GNUC_PURE
 node_supports_2d_transform (const GskRenderNode *node)
 {
-  switch ((int)gsk_render_node_get_node_type (node))
+  switch (gsk_render_node_get_node_type (node))
     {
     case GSK_COLOR_NODE:
     case GSK_OPACITY_NODE:
@@ -273,6 +274,7 @@ node_supports_2d_transform (const GskRenderNode *node)
     case GSK_CAIRO_NODE:
     case GSK_BLEND_NODE:
     case GSK_BLUR_NODE:
+    case GSK_MASK_NODE:
       return TRUE;
 
     case GSK_SHADOW_NODE:
@@ -289,8 +291,18 @@ node_supports_2d_transform (const GskRenderNode *node)
         }
       return TRUE;
 
-    default:
+    case GSK_BORDER_NODE:
+    case GSK_INSET_SHADOW_NODE:
+    case GSK_OUTSET_SHADOW_NODE:
+    case GSK_REPEAT_NODE:
+    case GSK_CLIP_NODE:
+    case GSK_ROUNDED_CLIP_NODE:
+    case GSK_GL_SHADER_NODE:
       return FALSE;
+
+    case GSK_NOT_A_RENDER_NODE:
+    default:
+      g_assert_not_reached ();
     }
 }
 
@@ -304,7 +316,7 @@ node_supports_transform (const GskRenderNode *node)
    * opacity or color matrix.
    */
 
-  switch ((int)gsk_render_node_get_node_type (node))
+  switch (gsk_render_node_get_node_type (node))
     {
     case GSK_COLOR_NODE:
     case GSK_OPACITY_NODE:
@@ -325,8 +337,25 @@ node_supports_transform (const GskRenderNode *node)
     case GSK_TRANSFORM_NODE:
       return node_supports_transform (gsk_transform_node_get_child (node));
 
-    default:
+    case GSK_CONTAINER_NODE:
+    case GSK_LINEAR_GRADIENT_NODE:
+    case GSK_REPEATING_LINEAR_GRADIENT_NODE:
+    case GSK_RADIAL_GRADIENT_NODE:
+    case GSK_REPEATING_RADIAL_GRADIENT_NODE:
+    case GSK_CONIC_GRADIENT_NODE:
+    case GSK_BORDER_NODE:
+    case GSK_INSET_SHADOW_NODE:
+    case GSK_OUTSET_SHADOW_NODE:
+    case GSK_REPEAT_NODE:
+    case GSK_CLIP_NODE:
+    case GSK_ROUNDED_CLIP_NODE:
+    case GSK_GL_SHADER_NODE:
+    case GSK_TEXTURE_SCALE_NODE:
       return FALSE;
+
+    case GSK_NOT_A_RENDER_NODE:
+    default:
+      g_assert_not_reached ();
     }
 }
 
@@ -3542,6 +3571,9 @@ gsk_gl_render_job_upload_texture (GskGLRenderJob       *job,
       offscreen->texture_id = gsk_gl_driver_load_texture (job->driver, texture, ensure_mipmap);
       init_full_texture_region (offscreen);
       offscreen->has_mipmap = ensure_mipmap;
+
+      if (gl_texture && offscreen->texture_id == gdk_gl_texture_get_id (gl_texture))
+        offscreen->sync = gdk_gl_texture_get_sync (gl_texture);
     }
 }
 
@@ -3569,13 +3601,15 @@ gsk_gl_render_job_visit_texture (GskGLRenderJob        *job,
       g_assert (offscreen.was_offscreen == FALSE);
 
       gsk_gl_render_job_begin_draw (job, CHOOSE_PROGRAM (job, blit));
-      gsk_gl_program_set_uniform_texture_with_filter (job->current_program,
-                                                      UNIFORM_SHARED_SOURCE, 0,
-                                                      GL_TEXTURE_2D,
-                                                      GL_TEXTURE0,
-                                                      offscreen.texture_id,
-                                                      offscreen.has_mipmap ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR,
-                                                      GL_LINEAR);
+
+      gsk_gl_program_set_uniform_texture_with_sync (job->current_program,
+                                                    UNIFORM_SHARED_SOURCE, 0,
+                                                    GL_TEXTURE_2D,
+                                                    GL_TEXTURE0,
+                                                    offscreen.texture_id,
+                                                    offscreen.has_mipmap ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR,
+                                                    GL_LINEAR,
+                                                    offscreen.sync);
       gsk_gl_render_job_draw_offscreen (job, bounds, &offscreen);
       gsk_gl_render_job_end_draw (job);
     }
@@ -3705,21 +3739,29 @@ gsk_gl_render_job_visit_texture_scale_node (GskGLRenderJob      *job,
   if G_LIKELY (texture->width <= max_texture_size &&
                texture->height <= max_texture_size)
     {
+      gpointer sync;
+
       texture_id = gsk_gl_driver_load_texture (job->driver, texture, filter == GSK_SCALING_FILTER_TRILINEAR);
 
+      if (GDK_IS_GL_TEXTURE (texture) && texture_id == gdk_gl_texture_get_id (GDK_GL_TEXTURE (texture)))
+        sync = gdk_gl_texture_get_sync (GDK_GL_TEXTURE (texture));
+      else
+        sync = NULL;
+
       u0 = (clip_rect.origin.x - bounds->origin.x) / bounds->size.width;
       v0 = (clip_rect.origin.y - bounds->origin.y) / bounds->size.height;
       u1 = (clip_rect.origin.x + clip_rect.size.width - bounds->origin.x) / bounds->size.width;
       v1 = (clip_rect.origin.y + clip_rect.size.height - bounds->origin.y) / bounds->size.height;
 
       gsk_gl_render_job_begin_draw (job, CHOOSE_PROGRAM (job, blit));
-      gsk_gl_program_set_uniform_texture_with_filter (job->current_program,
-                                                      UNIFORM_SHARED_SOURCE, 0,
-                                                      GL_TEXTURE_2D,
-                                                      GL_TEXTURE0,
-                                                      texture_id,
-                                                      min_filter,
-                                                      mag_filter);
+      gsk_gl_program_set_uniform_texture_with_sync (job->current_program,
+                                                    UNIFORM_SHARED_SOURCE, 0,
+                                                    GL_TEXTURE_2D,
+                                                    GL_TEXTURE0,
+                                                    texture_id,
+                                                    min_filter,
+                                                    mag_filter,
+                                                    sync);
       gsk_gl_render_job_draw_coords (job,
                                      0, 0, clip_rect.size.width, clip_rect.size.height,
                                      u0, v0, u1, v1,
@@ -4380,7 +4422,7 @@ get_framebuffer_format (GdkGLContext *context,
 {
   int size;
 
-  if (!gdk_gl_context_check_version (context, 0, 0, 3, 0))
+  if (!gdk_gl_context_check_version (context, NULL, "3.0"))
     return GL_RGBA8;
 
   glBindFramebuffer (GL_FRAMEBUFFER, framebuffer);

gsk/gskprofiler.c

@@ -9,7 +9,7 @@ typedef struct {
   char *description;
   gint64 value;
   gint64 n_samples;
-  gboolean can_reset : 1;
+  unsigned int can_reset : 1;
 } NamedCounter;
 
 typedef struct {
@@ -21,9 +21,9 @@ typedef struct {
   gint64 max_value;
   gint64 avg_value;
   gint64 n_samples;
-  gboolean in_flight : 1;
-  gboolean can_reset : 1;
-  gboolean invert : 1;
+  unsigned int in_flight : 1;
+  unsigned int can_reset : 1;
+  unsigned int invert : 1;
 } NamedTimer;
 
 typedef struct {

gsk/gskrenderer.c

@@ -83,7 +83,7 @@ typedef struct
 
   GskDebugFlags debug_flags;
 
-  gboolean is_realized : 1;
+  unsigned int is_realized : 1;
 } GskRendererPrivate;
 
 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GskRenderer, gsk_renderer, G_TYPE_OBJECT)

gsk/gskrendernodeimpl.c

@@ -32,6 +32,7 @@
 #include "gdk/gdktextureprivate.h"
 #include "gdk/gdkmemoryformatprivate.h"
 #include "gdk/gdkprivate.h"
+#include "gdk/gdkrectangleprivate.h"
 
 #include <cairo.h>
 #ifdef CAIRO_HAS_SVG_SURFACE
@@ -74,6 +75,25 @@ _graphene_rect_init_from_clip_extents (graphene_rect_t *rect,
   graphene_rect_init (rect, x1c, y1c, x2c - x1c, y2c - y1c);
 }
 
+static void
+region_union_region_affine (cairo_region_t       *region,
+                            const cairo_region_t *sub,
+                            float                 scale_x,
+                            float                 scale_y,
+                            float                 offset_x,
+                            float                 offset_y)
+{
+  cairo_rectangle_int_t rect;
+  int i;
+
+  for (i = 0; i < cairo_region_num_rectangles (sub); i++)
+    {
+      cairo_region_get_rectangle (sub, i, &rect);
+      gdk_rectangle_transform_affine (&rect, scale_x, scale_y, offset_x, offset_y, &rect);
+      cairo_region_union_rectangle (region, &rect);
+    }
+}
+
 /* {{{ GSK_COLOR_NODE */
 
 /**
@@ -3146,14 +3166,14 @@ gsk_container_node_new (GskRenderNode **children,
       for (guint i = 1; i < n_children; i++)
         {
           self->children[i] = gsk_render_node_ref (children[i]);
-          self->disjoint &= !graphene_rect_intersection (&bounds, &(children[i]->bounds), NULL);
+          self->disjoint = self->disjoint && !graphene_rect_intersection (&bounds, &(children[i]->bounds), NULL);
           graphene_rect_union (&bounds, &(children[i]->bounds), &bounds);
-          node->prefers_high_depth |= gsk_render_node_prefers_high_depth (children[i]);
-          node->offscreen_for_opacity |= children[i]->offscreen_for_opacity;
+          node->prefers_high_depth = node->prefers_high_depth || gsk_render_node_prefers_high_depth (children[i]);
+          node->offscreen_for_opacity = node->offscreen_for_opacity || children[i]->offscreen_for_opacity;
         }
 
       graphene_rect_init_from_rect (&node->bounds, &bounds);
-      node->offscreen_for_opacity |= !self->disjoint;
+      node->offscreen_for_opacity = node->offscreen_for_opacity || !self->disjoint;
     }
 
   return node;
@@ -3354,11 +3374,22 @@ gsk_transform_node_diff (GskRenderNode  *node1,
       }
       break;
 
+    case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
+      {
+        cairo_region_t *sub;
+        float scale_x, scale_y, dx, dy;
+        gsk_transform_to_affine (self1->transform, &scale_x, &scale_y, &dx, &dy);
+        sub = cairo_region_create ();
+        gsk_render_node_diff (self1->child, self2->child, sub);
+        region_union_region_affine (region, sub, scale_x, scale_y, dx, dy);
+        cairo_region_destroy (sub);
+      }
+      break;
+
     case GSK_TRANSFORM_CATEGORY_UNKNOWN:
     case GSK_TRANSFORM_CATEGORY_ANY:
     case GSK_TRANSFORM_CATEGORY_3D:
     case GSK_TRANSFORM_CATEGORY_2D:
-    case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
     default:
       gsk_render_node_diff_impossible (node1, node2, region);
       break;
@@ -6034,7 +6065,7 @@ gsk_gl_shader_node_new (GskGLShader           *shader,
       for (guint i = 0; i < n_children; i++)
         {
           self->children[i] = gsk_render_node_ref (children[i]);
-          node->prefers_high_depth |= gsk_render_node_prefers_high_depth (children[i]);
+          node->prefers_high_depth = node->prefers_high_depth || gsk_render_node_prefers_high_depth (children[i]);
         }
     }
 

gsk/vulkan/gskvulkanrender.c

@@ -647,9 +647,12 @@ gsk_vulkan_render_draw (GskVulkanRender *self)
 GdkTexture *
 gsk_vulkan_render_download_target (GskVulkanRender *self)
 {
+  GdkTexture *texture;
+
+  texture = gsk_vulkan_image_download (self->target, self->uploader);
   gsk_vulkan_uploader_reset (self->uploader);
 
-  return gsk_vulkan_image_download (self->target, self->uploader);
+  return texture;
 }
 
 static void

gtk.supp

@@ -293,6 +293,30 @@
   ...
   fun:g_intern_string
 }
+{
+  xdg-mime init
+  Memcheck:Leak
+  match-leak-kinds: definite
+  fun:malloc
+  ...
+  fun:xdg_mime_init*
+}
+{
+  xdg-mime init
+  Memcheck:Leak
+  match-leak-kinds: definite
+  fun:calloc
+  ...
+  fun:xdg_mime_init*
+}
+{
+  glib init
+  Memcheck:Leak
+  match-leak-kinds: definite
+  fun:malloc
+  ...
+  fun:glib_init_ctor
+}
 
 # Threads
 {

gtk/gskpango.c

@@ -460,6 +460,9 @@ gsk_pango_renderer_release (GskPangoRenderer *renderer)
  * Creates render nodes for rendering @layout in the given foregound @color
  * and appends them to the current node of @snapshot without changing the
  * current node.
+ *
+ * Note that if the layout does not produce any visible output, then nodes
+ * may not be added to the @snapshot.
  **/
 void
 gtk_snapshot_append_layout (GtkSnapshot   *snapshot,

gtk/gtkadjustment.c

@@ -352,6 +352,21 @@ gtk_adjustment_dispatch_properties_changed (GObject     *object,
     }
 }
 
+static double
+gtk_adjustment_sanitize_value (GtkAdjustment *self,
+                               double         value)
+{
+  GtkAdjustmentPrivate *priv = gtk_adjustment_get_instance_private (self);
+
+  /* don't use CLAMP() so we don't end up below lower if upper - page_size
+   * is smaller than lower
+   */
+  value = MIN (value, priv->upper - priv->page_size);
+  value = MAX (value, priv->lower);
+
+  return value;
+}
+
 /**
  * gtk_adjustment_new:
  * @value: the initial value
@@ -419,6 +434,8 @@ adjustment_set_value (GtkAdjustment *adjustment,
 {
   GtkAdjustmentPrivate *priv = gtk_adjustment_get_instance_private (adjustment);
 
+  value = gtk_adjustment_sanitize_value (adjustment, value);
+
   if (priv->value != value)
     {
       priv->value = value;
@@ -497,11 +514,7 @@ gtk_adjustment_set_value_internal (GtkAdjustment *adjustment,
 {
   GtkAdjustmentPrivate *priv = gtk_adjustment_get_instance_private (adjustment);
 
-  /* don't use CLAMP() so we don't end up below lower if upper - page_size
-   * is smaller than lower
-   */
-  value = MIN (value, priv->upper - priv->page_size);
-  value = MAX (value, priv->lower);
+  value = gtk_adjustment_sanitize_value (adjustment, value);
 
   if (animate && priv->duration != 0 && priv->clock != NULL)
     {
@@ -825,11 +838,7 @@ gtk_adjustment_configure (GtkAdjustment *adjustment,
   gtk_adjustment_set_page_increment (adjustment, page_increment);
   gtk_adjustment_set_page_size (adjustment, page_size);
 
-  /* don't use CLAMP() so we don't end up below lower if upper - page_size
-   * is smaller than lower
-   */
-  value = MIN (value, upper - page_size);
-  value = MAX (value, lower);
+  value = gtk_adjustment_sanitize_value (adjustment, value);
 
   if (value != priv->value)
     {

gtk/gtkalertdialog.c

@@ -747,6 +747,9 @@ gtk_alert_dialog_choose_finish (GtkAlertDialog  *self,
   g_return_val_if_fail (g_task_is_valid (result, self), -1);
   g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == gtk_alert_dialog_choose, -1);
 
+  /* Destroy the dialog window not to be bound to GTask lifecycle */
+  g_task_set_task_data (G_TASK (result), NULL, NULL);
+
   return (int) g_task_propagate_int (G_TASK (result), error);
 }
 

gtk/gtkapplication-dbus.c

@@ -46,6 +46,12 @@ G_DEFINE_TYPE (GtkApplicationImplDBus, gtk_application_impl_dbus, GTK_TYPE_APPLI
 #define GNOME_SCREENSAVER_DBUS_OBJECT_PATH      "/org/gnome/ScreenSaver"
 #define GNOME_SCREENSAVER_DBUS_INTERFACE        "org.gnome.ScreenSaver"
 
+static void client_proxy_signal (GDBusProxy  *proxy,
+                                 const gchar *sender_name,
+                                 const gchar *signal_name,
+                                 GVariant    *parameters,
+                                 gpointer     user_data);
+
 static void
 unregister_client (GtkApplicationImplDBus *dbus)
 {
@@ -67,6 +73,7 @@ unregister_client (GtkApplicationImplDBus *dbus)
       g_error_free (error);
     }
 
+  g_signal_handlers_disconnect_by_func (dbus->client_proxy, client_proxy_signal, dbus);
   g_clear_object (&dbus->client_proxy);
 
   g_free (dbus->client_path);
@@ -888,6 +895,8 @@ gtk_application_impl_dbus_finalize (GObject *object)
   g_free (dbus->app_menu_path);
   g_free (dbus->menubar_path);
   g_clear_object (&dbus->sm_proxy);
+  if (dbus->ss_proxy)
+    g_signal_handlers_disconnect_by_func (dbus->ss_proxy, screensaver_signal_session, dbus->impl.application);
   g_clear_object (&dbus->ss_proxy);
 
   G_OBJECT_CLASS (gtk_application_impl_dbus_parent_class)->finalize (object);

gtk/gtkbox.c

@@ -74,6 +74,7 @@ enum {
   PROP_0,
   PROP_SPACING,
   PROP_HOMOGENEOUS,
+  PROP_BASELINE_CHILD,
   PROP_BASELINE_POSITION,
 
   /* orientable */
@@ -125,6 +126,9 @@ gtk_box_set_property (GObject      *object,
     case PROP_SPACING:
       gtk_box_set_spacing (box, g_value_get_int (value));
       break;
+    case PROP_BASELINE_CHILD:
+      gtk_box_set_baseline_child (box, g_value_get_int (value));
+      break;
     case PROP_BASELINE_POSITION:
       gtk_box_set_baseline_position (box, g_value_get_enum (value));
       break;
@@ -154,6 +158,9 @@ gtk_box_get_property (GObject    *object,
     case PROP_SPACING:
       g_value_set_int (value, gtk_box_layout_get_spacing (box_layout));
       break;
+    case PROP_BASELINE_CHILD:
+      g_value_set_int (value, gtk_box_layout_get_baseline_child (box_layout));
+      break;
     case PROP_BASELINE_POSITION:
       g_value_set_enum (value, gtk_box_layout_get_baseline_position (box_layout));
       break;
@@ -270,6 +277,18 @@ gtk_box_class_init (GtkBoxClass *class)
                           FALSE,
                           GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
 
+  /**
+   * GtkBox:baseline-child: (attributes org.gtk.Property.get=gtk_box_get_baseline_child org.gtk.Property.set=gtk_box_set_baseline_child)
+   *
+   * The child that determines the baseline, in vertical orientation.
+   *
+   * Since: 4.12
+   */
+  props[PROP_BASELINE_CHILD] =
+    g_param_spec_int ("baseline-child", NULL, NULL,
+                      -1, G_MAXINT, -1,
+                      GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
+
   /**
    * GtkBox:baseline-position: (attributes org.gtk.Property.get=gtk_box_get_baseline_position org.gtk.Property.set=gtk_box_set_baseline_position)
    *
@@ -425,6 +444,57 @@ gtk_box_get_spacing (GtkBox *box)
   return gtk_box_layout_get_spacing (GTK_BOX_LAYOUT (box_layout));
 }
 
+/**
+ * gtk_box_set_baseline_child: (attributes org.gtk.Method.set_property=baseline-child)
+ * @box: a `GtkBox`
+ * @child: a child, or -1
+ *
+ * Sets the baseline child of a box.
+ *
+ * This affects only vertical boxes.
+ *
+ * Since: 4.12
+ */
+void
+gtk_box_set_baseline_child (GtkBox *box,
+                            int     child)
+{
+  GtkBoxLayout *box_layout;
+
+  g_return_if_fail (GTK_IS_BOX (box));
+  g_return_if_fail (child >= -1);
+
+  box_layout = GTK_BOX_LAYOUT (gtk_widget_get_layout_manager (GTK_WIDGET (box)));
+  if (child == gtk_box_layout_get_baseline_child (box_layout))
+    return;
+
+  gtk_box_layout_set_baseline_child  (box_layout, child);
+  g_object_notify_by_pspec (G_OBJECT (box), props[PROP_BASELINE_CHILD]);
+  gtk_widget_queue_resize (GTK_WIDGET (box));
+}
+
+/**
+ * gtk_box_get_baseline_child: (attributes org.gtk.Method.get_property=baseline-child)
+ * @box: a `GtkBox`
+ *
+ * Gets the value set by gtk_box_set_baseline_child().
+ *
+ * Returns: the baseline child
+ *
+ * Since: 4.12
+ */
+int
+gtk_box_get_baseline_child (GtkBox *box)
+{
+  GtkLayoutManager *box_layout;
+
+  g_return_val_if_fail (GTK_IS_BOX (box), -1);
+
+  box_layout = gtk_widget_get_layout_manager (GTK_WIDGET (box));
+
+  return gtk_box_layout_get_baseline_child (GTK_BOX_LAYOUT (box_layout));
+}
+
 /**
  * gtk_box_set_baseline_position: (attributes org.gtk.Method.set_property=baseline-position)
  * @box: a `GtkBox`

gtk/gtkbox.h

@@ -86,6 +86,12 @@ void        gtk_box_set_baseline_position (GtkBox             *box,
 GDK_AVAILABLE_IN_ALL
 GtkBaselinePosition gtk_box_get_baseline_position (GtkBox         *box);
 
+GDK_AVAILABLE_IN_4_12
+void        gtk_box_set_baseline_child (GtkBox         *box,
+                                        int             child);
+GDK_AVAILABLE_IN_4_12
+int         gtk_box_get_baseline_child (GtkBox         *box);
+
 GDK_AVAILABLE_IN_ALL
 void        gtk_box_append             (GtkBox         *box,
                                         GtkWidget      *child);

gtk/gtkboxlayout.c

@@ -55,6 +55,7 @@ struct _GtkBoxLayout
   guint spacing;
   GtkOrientation orientation;
   GtkBaselinePosition baseline_position;
+  int baseline_child;
 };
 
 G_DEFINE_TYPE_WITH_CODE (GtkBoxLayout, gtk_box_layout, GTK_TYPE_LAYOUT_MANAGER,
@@ -63,6 +64,7 @@ G_DEFINE_TYPE_WITH_CODE (GtkBoxLayout, gtk_box_layout, GTK_TYPE_LAYOUT_MANAGER,
 enum {
   PROP_HOMOGENEOUS = 1,
   PROP_SPACING,
+  PROP_BASELINE_CHILD,
   PROP_BASELINE_POSITION,
 
   /* From GtkOrientable */
@@ -112,6 +114,10 @@ gtk_box_layout_set_property (GObject      *gobject,
       gtk_box_layout_set_spacing (self, g_value_get_int (value));
       break;
 
+    case PROP_BASELINE_CHILD:
+      gtk_box_layout_set_baseline_child (self, g_value_get_int (value));
+      break;
+
     case PROP_BASELINE_POSITION:
       gtk_box_layout_set_baseline_position (self, g_value_get_enum (value));
       break;
@@ -144,6 +150,10 @@ gtk_box_layout_get_property (GObject    *gobject,
       g_value_set_int (value, box_layout->spacing);
       break;
 
+    case PROP_BASELINE_CHILD:
+      g_value_set_int (value, box_layout->baseline_child);
+      break;
+
     case PROP_BASELINE_POSITION:
       g_value_set_enum (value, box_layout->baseline_position);
       break;
@@ -204,20 +214,28 @@ gtk_box_layout_compute_size (GtkBoxLayout *self,
                              GtkWidget    *widget,
                              int           for_size,
                              int          *minimum,
-                             int          *natural)
+                             int          *natural,
+                             int          *minimum_baseline,
+                             int          *natural_baseline)
 {
   GtkWidget *child;
   int n_visible_children = 0;
   int required_min = 0, required_nat = 0;
   int largest_min = 0, largest_nat = 0;
   int spacing = get_spacing (self, gtk_widget_get_css_node (widget));
+  int child_above_min = 0, child_above_nat = 0;
+  int above_min = 0, above_nat = 0;
+  gboolean have_baseline = FALSE;
+  int pos;
 
-  for (child = gtk_widget_get_first_child (widget);
+  for (child = gtk_widget_get_first_child (widget), pos = 0;
        child != NULL;
-       child = gtk_widget_get_next_sibling (child))
+       child = gtk_widget_get_next_sibling (child), pos++)
     {
       int child_min = 0;
       int child_nat = 0;
+      int child_min_baseline = -1;
+      int child_nat_baseline = -1;
 
       if (!gtk_widget_should_layout (child))
         continue;
@@ -225,7 +243,7 @@ gtk_box_layout_compute_size (GtkBoxLayout *self,
       gtk_widget_measure (child, self->orientation,
                           for_size,
                           &child_min, &child_nat,
-                          NULL, NULL);
+                          &child_min_baseline, &child_nat_baseline);
 
       largest_min = MAX (largest_min, child_min);
       largest_nat = MAX (largest_nat, child_nat);
@@ -233,6 +251,29 @@ gtk_box_layout_compute_size (GtkBoxLayout *self,
       required_min += child_min;
       required_nat += child_nat;
 
+      if (self->orientation == GTK_ORIENTATION_VERTICAL)
+        {
+          if (pos < self->baseline_child)
+            {
+              above_min += child_min;
+              above_nat += child_nat;
+            }
+          else if (pos == self->baseline_child)
+            {
+              have_baseline = TRUE;
+              if (child_min_baseline > -1)
+                {
+                  child_above_min = child_min_baseline;
+                  child_above_nat = child_nat_baseline;
+                }
+              else
+                {
+                  child_above_min = child_min;
+                  child_above_nat = child_nat;
+                }
+            }
+        }
+
       n_visible_children += 1;
     }
 
@@ -242,14 +283,31 @@ gtk_box_layout_compute_size (GtkBoxLayout *self,
         {
           required_min = largest_min * n_visible_children;
           required_nat = largest_nat * n_visible_children;
+
+          above_min = largest_min * MAX (self->baseline_child, 0);
+          above_nat = largest_nat * MAX (self->baseline_child, 0);
         }
 
       required_min += (n_visible_children - 1) * spacing;
       required_nat += (n_visible_children - 1) * spacing;
+
+      above_min += MAX (self->baseline_child, 0) * spacing;
+      above_nat += MAX (self->baseline_child, 0) * spacing;
     }
 
   *minimum = required_min;
   *natural = required_nat;
+
+  if (have_baseline)
+    {
+      *minimum_baseline = above_min + child_above_min;
+      *natural_baseline = above_nat + child_above_nat;
+    }
+  else
+    {
+      *minimum_baseline = -1;
+      *natural_baseline = -1;
+    }
 }
 
 static void
@@ -262,6 +320,9 @@ gtk_box_layout_compute_opposite_size (GtkBoxLayout *self,
 {
   GtkWidget *child;
   int largest_min = 0, largest_nat = 0;
+  int largest_min_above = -1, largest_min_below = -1;
+  int largest_nat_above = -1, largest_nat_below = -1;
+  gboolean have_baseline = FALSE;
 
   for (child = gtk_widget_get_first_child (widget);
        child != NULL;
@@ -269,6 +330,8 @@ gtk_box_layout_compute_opposite_size (GtkBoxLayout *self,
     {
       int child_min = 0;
       int child_nat = 0;
+      int child_min_baseline = -1;
+      int child_nat_baseline = -1;
 
       if (!gtk_widget_should_layout (child))
         continue;
@@ -277,14 +340,43 @@ gtk_box_layout_compute_opposite_size (GtkBoxLayout *self,
                           OPPOSITE_ORIENTATION (self->orientation),
                           -1,
                           &child_min, &child_nat,
-                          NULL, NULL);
+                          &child_min_baseline, &child_nat_baseline);
 
       largest_min = MAX (largest_min, child_min);
       largest_nat = MAX (largest_nat, child_nat);
+
+      if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
+        {
+          if (child_min_baseline > -1)
+            {
+              have_baseline = TRUE;
+              largest_min_above = MAX (largest_min_above, child_min_baseline);
+              largest_min_below = MAX (largest_min_below, child_min - child_min_baseline);
+              largest_nat_above = MAX (largest_nat_above, child_nat_baseline);
+              largest_nat_below = MAX (largest_nat_below, child_nat - child_nat_baseline);
+            }
+        }
+    }
+
+  if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
+    {
+      largest_min = MAX (largest_min, largest_min_above + largest_min_below);
+      largest_nat = MAX (largest_nat, largest_nat_above + largest_nat_below);
     }
 
   *minimum = largest_min;
   *natural = largest_nat;
+
+  if (have_baseline)
+    {
+      *min_baseline = largest_min_above;
+      *nat_baseline = largest_nat_above;
+    }
+  else
+    {
+      *min_baseline = -1;
+      *nat_baseline = -1;
+    }
 }
 
 /* if widgets haven't reached their min opposite size at this
@@ -445,13 +537,21 @@ gtk_box_layout_compute_opposite_size_for_size (GtkBoxLayout *self,
                               &child_minimum, &child_natural,
                               &child_minimum_baseline, &child_natural_baseline);
 
-          if (child_minimum_baseline >= 0)
+          if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
             {
-              have_baseline = TRUE;
-              computed_minimum_below = MAX (computed_minimum_below, child_minimum - child_minimum_baseline);
-              computed_natural_below = MAX (computed_natural_below, child_natural - child_natural_baseline);
-              computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline);
-              computed_natural_above = MAX (computed_natural_above, child_natural_baseline);
+              if (child_minimum_baseline > -1)
+                {
+                  have_baseline = TRUE;
+                  computed_minimum_below = MAX (computed_minimum_below, child_minimum - child_minimum_baseline);
+                  computed_natural_below = MAX (computed_natural_below, child_natural - child_natural_baseline);
+                  computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline);
+                  computed_natural_above = MAX (computed_natural_above, child_natural_baseline);
+                }
+              else
+                {
+                  computed_minimum = MAX (computed_minimum, child_minimum);
+                  computed_natural = MAX (computed_natural, child_natural);
+                }
             }
           else
             {
@@ -561,13 +661,21 @@ gtk_box_layout_compute_opposite_size_for_size (GtkBoxLayout *self,
                               &child_minimum, &child_natural,
                               &child_minimum_baseline, &child_natural_baseline);
 
-          if (child_minimum_baseline >= 0)
+          if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
             {
-              have_baseline = TRUE;
-              computed_minimum_below = MAX (computed_minimum_below, child_minimum - child_minimum_baseline);
-              computed_natural_below = MAX (computed_natural_below, child_natural - child_natural_baseline);
-              computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline);
-              computed_natural_above = MAX (computed_natural_above, child_natural_baseline);
+              if (child_minimum_baseline > -1)
+                {
+                  have_baseline = TRUE;
+                  computed_minimum_below = MAX (computed_minimum_below, child_minimum - child_minimum_baseline);
+                  computed_natural_below = MAX (computed_natural_below, child_natural - child_natural_baseline);
+                  computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline);
+                  computed_natural_above = MAX (computed_natural_above, child_natural_baseline);
+                }
+              else
+                {
+                  computed_minimum = MAX (computed_minimum, child_minimum);
+                  computed_natural = MAX (computed_natural, child_natural);
+                }
             }
           else
             {
@@ -579,24 +687,27 @@ gtk_box_layout_compute_opposite_size_for_size (GtkBoxLayout *self,
 
   if (have_baseline)
     {
-      computed_minimum = MAX (computed_minimum, computed_minimum_below + computed_minimum_above);
-      computed_natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
-      switch (self->baseline_position)
+      if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
         {
-        case GTK_BASELINE_POSITION_TOP:
-          computed_minimum_baseline = computed_minimum_above;
-          computed_natural_baseline = computed_natural_above;
-          break;
-        case GTK_BASELINE_POSITION_CENTER:
-          computed_minimum_baseline = computed_minimum_above + MAX((computed_minimum - (computed_minimum_above + computed_minimum_below)) / 2, 0);
-          computed_natural_baseline = computed_natural_above + MAX((computed_natural - (computed_natural_above + computed_natural_below)) / 2, 0);
-          break;
-        case GTK_BASELINE_POSITION_BOTTOM:
-          computed_minimum_baseline = computed_minimum - computed_minimum_below;
-          computed_natural_baseline = computed_natural - computed_natural_below;
-          break;
-        default:
-          break;
+          computed_minimum = MAX (computed_minimum, computed_minimum_below + computed_minimum_above);
+          computed_natural = MAX (computed_natural, computed_natural_below + computed_natural_above);
+          switch (self->baseline_position)
+            {
+            case GTK_BASELINE_POSITION_TOP:
+              computed_minimum_baseline = computed_minimum_above;
+              computed_natural_baseline = computed_natural_above;
+            break;
+            case GTK_BASELINE_POSITION_CENTER:
+              computed_minimum_baseline = computed_minimum_above + MAX((computed_minimum - (computed_minimum_above + computed_minimum_below)) / 2, 0);
+              computed_natural_baseline = computed_natural_above + MAX((computed_natural - (computed_natural_above + computed_natural_below)) / 2, 0);
+              break;
+            case GTK_BASELINE_POSITION_BOTTOM:
+              computed_minimum_baseline = computed_minimum - computed_minimum_below;
+              computed_natural_baseline = computed_natural - computed_natural_below;
+              break;
+            default:
+              break;
+            }
         }
     }
 
@@ -636,7 +747,8 @@ gtk_box_layout_measure (GtkLayoutManager *layout_manager,
   else
     {
       gtk_box_layout_compute_size (self, widget, for_size,
-                                   minimum, natural);
+                                   minimum, natural,
+                                   min_baseline, nat_baseline);
     }
 }
 
@@ -711,7 +823,6 @@ gtk_box_layout_allocate (GtkLayoutManager *layout_manager,
       /* We still need to run the above loop to populate the minimum sizes for
        * children that aren't going to fill.
        */
-
       size_given_to_child = extra_space / nvis_children;
       n_extra_widgets = extra_space % nvis_children;
     }
@@ -911,6 +1022,24 @@ gtk_box_layout_class_init (GtkBoxLayoutClass *klass)
                       GTK_PARAM_READWRITE |
                       G_PARAM_EXPLICIT_NOTIFY);
 
+  /**
+   * GtkBoxLayout:baseline-child: (attributes org.gtk.Property.get=gtk_box_layout_get_baseline_child org.gtk.Property.set=gtk_box_layout_set_baseline_child)
+   *
+   * The child that determines the baseline of the box
+   * in vertical layout.
+   *
+   * If the child does baseline positioning, then its baseline
+   * is lined up with the baseline of the box. If it doesn't, then
+   * the bottom edge of the child is used.
+   *
+   * Since: 4.12
+   */
+  box_layout_props[PROP_BASELINE_CHILD] =
+    g_param_spec_int ("baseline-child", NULL, NULL,
+                      -1, G_MAXINT, -1,
+                      GTK_PARAM_READWRITE |
+                      G_PARAM_EXPLICIT_NOTIFY);
+
   /**
    * GtkBoxLayout:baseline-position: (attributes org.gtk.Property.get=gtk_box_layout_get_baseline_position org.gtk.Property.set=gtk_box_layout_set_baseline_position)
    *
@@ -938,6 +1067,7 @@ gtk_box_layout_init (GtkBoxLayout *self)
   self->spacing = 0;
   self->orientation = GTK_ORIENTATION_HORIZONTAL;
   self->baseline_position = GTK_BASELINE_POSITION_CENTER;
+  self->baseline_child = -1;
 }
 
 /**
@@ -1078,3 +1208,49 @@ gtk_box_layout_get_baseline_position (GtkBoxLayout *box_layout)
 
   return box_layout->baseline_position;
 }
+
+/**
+ * gtk_box_layout_set_baseline_child: (attributes org.gtk.Method.set_property=baseline-child)
+ * @box_layout: a `GtkBoxLayout`
+ * @child: the child position, or -1
+ *
+ * Sets the index of the child that determines the baseline
+ * in vertical layout.
+ *
+ * Since: 4.12
+ */
+void
+gtk_box_layout_set_baseline_child (GtkBoxLayout *box_layout,
+                                   int           child)
+{
+  g_return_if_fail (GTK_IS_BOX_LAYOUT (box_layout));
+  g_return_if_fail (child >= -1);
+
+  if (box_layout->baseline_child == child)
+    return;
+
+  box_layout->baseline_child = child;
+
+  g_object_notify_by_pspec (G_OBJECT (box_layout), box_layout_props[PROP_BASELINE_CHILD]);
+
+  gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (box_layout));
+}
+
+/**
+ * gtk_box_layout_get_baseline_child:
+ * @box_layout: a `GtkBoxLayout`
+ *
+ * Gets the value set by gtk_box_layout_set_baseline_child().
+ *
+ * Returns: the index of the child that determines the baseline
+ *     in vertical layout, or -1
+ *
+ * Since: 4.12
+ */
+int
+gtk_box_layout_get_baseline_child (GtkBoxLayout *box_layout)
+{
+  g_return_val_if_fail (GTK_IS_BOX_LAYOUT (box_layout), -1);
+
+  return box_layout->baseline_child;
+}

gtk/gtkboxlayout.h

@@ -51,4 +51,10 @@ void                    gtk_box_layout_set_baseline_position    (GtkBoxLayout
 GDK_AVAILABLE_IN_ALL
 GtkBaselinePosition     gtk_box_layout_get_baseline_position    (GtkBoxLayout        *box_layout);
 
+GDK_AVAILABLE_IN_4_12
+void                    gtk_box_layout_set_baseline_child       (GtkBoxLayout        *box_layout,
+                                                                 int                  child);
+GDK_AVAILABLE_IN_4_12
+int                     gtk_box_layout_get_baseline_child       (GtkBoxLayout        *box_layout);
+
 G_END_DECLS

gtk/gtkbuilder.c

@@ -153,9 +153,10 @@
  * specifies the function to connect to the signal.
  * The remaining attributes, “after”, “swapped” and “object”, have the
  * same meaning as the corresponding parameters of the
- * g_signal_connect_object() or g_signal_connect_data() functions. A
- * “last_modification_time” attribute is also allowed, but it does not
- * have a meaning to the builder.
+ * g_signal_connect_object() or g_signal_connect_data() functions. By
+ * default "swapped" will be set to "yes" if not specified otherwise, in the
+ * case where "object" is set, for convenience. A “last_modification_time”
+ * attribute is also allowed, but it does not have a meaning to the builder.
  *
  * If you rely on `GModule` support to lookup callbacks in the symbol table,
  * the following details should be noted:

gtk/gtkbuilderprivate.h

@@ -69,9 +69,9 @@ typedef struct {
   GParamSpec *pspec;
   gpointer value;
   GString *text;
-  gboolean translatable : 1;
-  gboolean bound        : 1;
-  gboolean applied      : 1;
+  unsigned int translatable : 1;
+  unsigned int bound        : 1;
+  unsigned int applied      : 1;
   char *context;
   int line;
   int col;

gtk/gtkbutton.c

@@ -94,6 +94,7 @@ struct _GtkButtonPrivate
   guint          button_down           : 1;
   guint          use_underline         : 1;
   guint          child_type            : 2;
+  guint          can_shrink            : 1;
 };
 
 enum {
@@ -109,6 +110,7 @@ enum {
   PROP_USE_UNDERLINE,
   PROP_ICON_NAME,
   PROP_CHILD,
+  PROP_CAN_SHRINK,
 
   /* actionable properties */
   PROP_ACTION_NAME,
@@ -260,6 +262,24 @@ gtk_button_class_init (GtkButtonClass *klass)
                          GTK_TYPE_WIDGET,
                          GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
 
+  /**
+   * GtkButton:can-shrink:
+   *
+   * Whether the size of the button can be made smaller than the natural
+   * size of its contents.
+   *
+   * For text buttons, setting this property will allow ellipsizing the label.
+   *
+   * If the contents of a button are an icon or a custom widget, setting this
+   * property has no effect.
+   *
+   * Since: 4.12
+   */
+  props[PROP_CAN_SHRINK] =
+    g_param_spec_boolean ("can-shrink", NULL, NULL,
+                          FALSE,
+                          GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
+
   g_object_class_install_properties (gobject_class, LAST_PROP, props);
 
   g_object_class_override_property (gobject_class, PROP_ACTION_NAME, "action-name");
@@ -510,6 +530,9 @@ gtk_button_set_property (GObject         *object,
     case PROP_CHILD:
       gtk_button_set_child (button, g_value_get_object (value));
       break;
+    case PROP_CAN_SHRINK:
+      gtk_button_set_can_shrink (button, g_value_get_boolean (value));
+      break;
     case PROP_ACTION_NAME:
       gtk_button_set_action_name (GTK_ACTIONABLE (button), g_value_get_string (value));
       break;
@@ -548,6 +571,9 @@ gtk_button_get_property (GObject         *object,
     case PROP_CHILD:
       g_value_set_object (value, priv->child);
       break;
+    case PROP_CAN_SHRINK:
+      g_value_set_boolean (value, priv->can_shrink);
+      break;
     case PROP_ACTION_NAME:
       g_value_set_string (value, gtk_action_helper_get_action_name (priv->action_helper));
       break;
@@ -837,6 +863,10 @@ gtk_button_set_label (GtkButton   *button,
     }
 
   gtk_label_set_label (GTK_LABEL (priv->child), label);
+  gtk_label_set_ellipsize (GTK_LABEL (priv->child),
+                           priv->can_shrink ? PANGO_ELLIPSIZE_END
+                                            : PANGO_ELLIPSIZE_NONE);
+
   gtk_button_set_child_type (button, LABEL_CHILD);
 
   gtk_accessible_update_property (GTK_ACCESSIBLE (button),
@@ -1067,3 +1097,73 @@ gtk_button_get_child (GtkButton *button)
 
   return priv->child;
 }
+
+/**
+ * gtk_button_set_can_shrink:
+ * @button: a button
+ * @can_shrink: whether the button can shrink
+ *
+ * Sets whether the button size can be smaller than the natural size of
+ * its contents.
+ *
+ * For text buttons, setting @can_shrink to true will ellipsize the label.
+ *
+ * For icons and custom children, this function has no effect.
+ *
+ * Since: 4.12
+ */
+void
+gtk_button_set_can_shrink (GtkButton *button,
+                           gboolean   can_shrink)
+{
+  GtkButtonPrivate *priv = gtk_button_get_instance_private (button);
+
+  g_return_if_fail (GTK_IS_BUTTON (button));
+
+  can_shrink = !!can_shrink;
+
+  if (priv->can_shrink != can_shrink)
+    {
+      priv->can_shrink = can_shrink;
+
+      switch (priv->child_type)
+        {
+        case LABEL_CHILD:
+          gtk_label_set_ellipsize (GTK_LABEL (priv->child),
+                                   priv->can_shrink ? PANGO_ELLIPSIZE_END
+                                                    : PANGO_ELLIPSIZE_NONE);
+          break;
+
+        case ICON_CHILD:
+        case WIDGET_CHILD:
+          break;
+
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+
+      g_object_notify_by_pspec (G_OBJECT (button), props[PROP_CAN_SHRINK]);
+    }
+}
+
+/**
+ * gtk_button_get_can_shrink:
+ * @button: a button
+ *
+ * Retrieves whether the button can be smaller than the natural
+ * size of its contents.
+ *
+ * Returns: true if the button can shrink, and false otherwise
+ *
+ * Since: 4.12
+ */
+gboolean
+gtk_button_get_can_shrink (GtkButton *button)
+{
+  GtkButtonPrivate *priv = gtk_button_get_instance_private (button);
+
+  g_return_val_if_fail (GTK_IS_BUTTON (button), FALSE);
+
+  return priv->can_shrink;
+}

gtk/gtkbutton.h

@@ -93,7 +93,7 @@ GDK_AVAILABLE_IN_ALL
 void                  gtk_button_set_label          (GtkButton      *button,
 						     const char     *label);
 GDK_AVAILABLE_IN_ALL
-const char *         gtk_button_get_label          (GtkButton      *button);
+const char *          gtk_button_get_label          (GtkButton      *button);
 GDK_AVAILABLE_IN_ALL
 void                  gtk_button_set_use_underline  (GtkButton      *button,
 						     gboolean        use_underline);
@@ -112,6 +112,12 @@ void                  gtk_button_set_child          (GtkButton      *button,
 GDK_AVAILABLE_IN_ALL
 GtkWidget *           gtk_button_get_child          (GtkButton      *button);
 
+GDK_AVAILABLE_IN_4_12
+void                  gtk_button_set_can_shrink     (GtkButton      *button,
+                                                     gboolean        can_shrink);
+GDK_AVAILABLE_IN_4_12
+gboolean              gtk_button_get_can_shrink     (GtkButton      *button);
+
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkButton, g_object_unref)
 
 G_END_DECLS