ci: Hard reset subprojects

Another attempt to make meson handle the master -> main transition in glib.
2021-06-08 12:17:19 -04:00
403 changed files with 20190 additions and 26740 deletions
@@ -24,8 +24,9 @@ variables:
  BACKEND_FLAGS: "-Dx11-backend=true -Dwayland-backend=true -Dbroadway-backend=true"
  FEATURE_FLAGS: "-Dvulkan=enabled -Dcloudproviders=enabled"
  MESON_TEST_TIMEOUT_MULTIPLIER: 3
-  FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/gtk/fedora:v32"
+  FEDORA_IMAGE: "registry.gitlab.gnome.org/gnome/gtk/fedora:v31"
  FLATPAK_IMAGE: "registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:master"
+  DOCS_IMAGE: "registry.gitlab.gnome.org/gnome/gtk/fedora:v31"

 .only-default:
  only:
@@ -59,7 +60,6 @@ style-check-diff:
      - "${CI_PROJECT_DIR}/_build/testsuite/reftests/output/*/*.png"
      - "${CI_PROJECT_DIR}/_build/testsuite/gsk/compare/*/*/*.png"
      - "${CI_PROJECT_DIR}/_build/testsuite/css/output/*/*.syscap"
-      - "${CI_PROJECT_DIR}/_build_hello/meson-logs"
  cache:
    key: "$CI_JOB_NAME"
    paths:
@@ -78,15 +78,11 @@ fedora-x86_64:
    EXTRA_MESON_FLAGS: "--buildtype=debug --default-library=both"
  script:
    - .gitlab-ci/show-info-linux.sh
-    - meson subprojects update
-    - mkdir _install
-    - meson --prefix=${CI_PROJECT_DIR}/_install
-            ${COMMON_MESON_FLAGS} ${EXTRA_MESON_FLAGS} ${BACKEND_FLAGS} ${FEATURE_FLAGS}
+    - rm -rf subprojects/glib
+    - meson subprojects update --reset
+    - meson ${COMMON_MESON_FLAGS} ${EXTRA_MESON_FLAGS} ${BACKEND_FLAGS} ${FEATURE_FLAGS}
            _build
-    - meson compile -C _build
-    - meson install -C _build
-    - PKG_CONFIG_PATH=${CI_PROJECT_DIR}/_install/lib64/pkgconfig:${CI_PROJECT_DIR}/_install/share/pkgconfig meson setup _build_hello examples/hello
-    - meson compile -C _build_hello
+    - ninja -C _build
    - .gitlab-ci/run-tests.sh _build x11
    - .gitlab-ci/run-tests.sh _build wayland
    - .gitlab-ci/run-tests.sh _build broadway
@@ -99,7 +95,7 @@ release-build:
    EXTRA_MESON_FLAGS: "--buildtype=release"
  script:
    - .gitlab-ci/show-info-linux.sh
-    - meson subprojects update
+    - meson subprojects update --reset
    - meson ${COMMON_MESON_FLAGS} ${EXTRA_MESON_FLAGS} ${BACKEND_FLAGS} ${FEATURE_FLAGS}
            _build
    - ninja -C _build
@@ -114,7 +110,7 @@ installed-tests:
    G_TEST_ACCESSIBLE: 1
  script:
    - .gitlab-ci/show-info-linux.sh
-    - meson subprojects update
+    - meson subprojects update --reset
    - meson ${COMMON_MESON_FLAGS} ${EXTRA_MESON_FLAGS} ${BACKEND_FLAGS} ${FEATURE_FLAGS}
            _build
    - ninja -C _build
@@ -169,10 +165,8 @@ macos:
    - export PATH=/Users/gitlabrunner/Library/Python/3.7/bin:$PATH
    - export MESON_FORCE_BACKTRACE=1
  script:
+    - meson subprojects update --reset
    - meson -Dx11-backend=false
-            -Dbroadway-backend=true
-            -Dmacos-backend=true
-            -Dmedia-gstreamer=disabled
            -Dintrospection=disabled
            -Dcpp_std=c++11
            -Dpixman:tests=disabled
@@ -310,7 +304,7 @@ asan-build:
  allow_failure: true

 reference:
-  image: $FEDORA_IMAGE
+  image: $DOCS_IMAGE
  stage: docs
  needs: []
  variables:
@@ -38,6 +38,7 @@ RUN dnf -y install \
    gstreamer1-plugins-good \
    gstreamer1-plugins-bad-free-devel \
    gstreamer1-plugins-base-devel \
+    gtk-doc \
    hicolor-icon-theme \
    iso-codes \
    itstool \
@@ -15,7 +15,7 @@ meson \
        -Dx11-backend=true \
        -Dwayland-backend=true \
        -Dbroadway-backend=true \
-        -Dvulkan=enabled \
+        -Dvulkan=yes \
        -Dprofiler=true \
        --werror \
        ${EXTRA_MESON_FLAGS:-} \
@@ -6,7 +6,7 @@ call "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliar

 :: FIXME: make warnings fatal
 pip3 install --upgrade --user meson==0.56.2  || goto :error
-meson -Dmedia-gstreamer=disabled _build || goto :error
+meson _build || goto :error
 ninja -C _build || goto :error

 goto :EOF
@@ -1,213 +1,3 @@
-Overview of Changes in 4.3.2
-============================
-
-* GtkToggleButton:
- - Fix the actionable implementation
-
-* GtkCheckButton:
- - Fix the actionable implementation
- - Cancel activation on when the pointer leaves
-
-* GtkMenuButton:
- - Make activatable again
- - Add a way to have an icon + arrow
-
-* GtkColorButton:
- - Make activatable again
-
-* GtkFontButton:
- - Make activatable again
-
-* GtkAppChooserButton:
- - Make activatable again
-
-* GtkColumnView:
- - Fix double activation
-
-* GtkLabel:
- - Fix mnemonics without markup
-
-* GtkTreeView:
- - Clip header buttons
-
-* GtkTextView:
- - Add api to get the RTL and LTR contexts
- - Fix some errors in text history grouping
-
-* GtkText:
- - Don't show placeholder text on top of entry text
- - Add api to compute the cursor extents
- - Fix y coordinates for text selection
-
-* GtkFileChooser:
- - Don't show Trash in the side bar
-
-* GtkPopoverMenu:
- - Add scrollbars to long menus
-
-* GtkActionMuxer:
- - Fix propagation of accel changes
-
-* Introspection:
- - Annotate all filename arguments
- - Rename GtkMediaStream apis to avoid name collisions
- - Rename GtkDropTarget properties to avoid name collisions
- - Make GtkPasswordEntryBuffer introspectable
-
-* Printing:
- - Remove the Google Cloud Print backend
-
-* Theme:
- - Sync included icons with the Adwaita icon theme
-
-* GSK:
- - Avoid overflowing the vertex counter
- - Handle negative scales correctly in the ngl renderer
-
-* GDK:
- - Cleanup and simplify OpenGL setup code
- - Add a GdkDisplay::init_gl vfunc and gdk_display_prepare_gl() api
- - Require EGL 1.4
- - Fix EGL + NVidia
-
-* Build:
- - Enable gstreamer by default
- - Disable Vulkan by default
- - Remove the sassc option
- - Remove options and checks for X11 extensions
-
-* X11:
- - Stop using XComposite
- - Remove the Visual cache
-
-* Wayland:
- - Fix some DND corner cases
- - Work with version 2 of pointer-gestures-v1
- - Look for cursor themes in $HOME/.icons
-
-* Windows:
- - Fix SIGILL on x64 due to popcnt
- - Fix popup placement
- - Fix drag icon placement
- - Clean up HiDPI and WGL support
- - Default to WGL
-
-* MacOs:
- - Fix input method support
- - Register known clipboard types for drop targets
- - Add initial DND support
-
-* Translation updates:
- Brazilian Portuguese
- Portuguese
- Romanian
- Turkish
- Ukrainian
-
-
-Overview of Changes in 4.3.1
-============================
-
-* GtkEmojiChooser:
- - Update data from CLDR 39
- - Load Emoji data for both language and territory
-
-* GtkCalendar:
- - Fix an off-by-one error in day numbers
-
-* GtkListView:
- - Add .activatable style class to activatable items
-
-* GtkCheckButton:
- - Don't allow unchecking grouped radio buttons
-
-*GtkToggleButton:
- - Fix mnemonic activation propagation
-
-* GtkLabel:
- - Make mnemonics work even when invisible
- - Fix mnemonic activation propagation
-
-* GtkMenuButton:
- - Add a property to mark primary menus and make F10 work
-
-* GtkApplication:
- - Fix initial screensaver state async
-
-* GtkEntry:
- - Apply xalign to placeholder text (as it was in GTK 3)
-
-* GtkSpinButton:
- - Fix swipe gestures
-
-* GtkStackSwitcher:
- - Implement GtkOrientable (as it was in GTK 3)
- - Fix a use-after-free problem with drag timeouts
-
-* GtkFileChooser:
- - Add support for (case-insensitive) suffix matches in GtkFileFilter
-
-* GtkPasswordEntry:
- - Make GtkPasswordEntryBuffer public, to make it easier
-   to write your own password entry widget
-
-* Input:
- - Fix interference between various obscure XKB features
-   (e.g. overlays) and Compose sequences
-
-* Action support:
- - Fix submenu-action handling
-
-* Theme:
- - Update icons from the Adwaita icon theme
- - Fix icon names for GtkSwitch
- - Fix switch-off icon
-
-* GSK:
- - Improve transformed offscreen rendering
- - Add padding between cached glyphs
-
-* Wayland:
- - Fix monitor sizes in the presence of transforms
- - Add a getter for the EGLDisplay
- - Fix click-drag-release sequences for popovers
-
-* X11:
- - Support EGL for X11. Fall back to GLX if EGL isn't available
- - Always fall back to GLX on NVidia
- - Add a getter for the EGLDisplay
-
-* Broadway:
- - Add a setter for display scale
-
-* Windows:
- - Add a getter for the EGLDisplay
- - Make GL work for media playback
-
-* MacOS:
- - Fix menubar appearance
-
-* Tools:
- - gtk4-builder-tool: Replace can-focus with focusable in 3-to-4 conversion
-
-* Introspection:
- - Add missing annotations in a few places (e.g. gtk_free_view_row_activated)
-
-* Build:
- - Only build one source file with -mf16c
- - Fix devel styling for ci flatpak builds
- - Generate appdata for demo flatpaks
-
-* Docs:
- - Numerous fixes and additions
-
-* Translation updates:
- Friulian
- Nepali
- Norwegian Bokmål
- Ukrainian
-
-
 Overview of Changes in 4.3.0
 ============================

@@ -124,6 +124,9 @@
 /* Define to 1 if you have the <unistd.h> header file. */
 #mesondefine HAVE_UNISTD_H

+/* Have the XCOMPOSITE X extension */
+#mesondefine HAVE_XCOMPOSITE
+
 /* Have the Xcursor library */
 #mesondefine HAVE_XCURSOR

@@ -21,10 +21,8 @@ do_menu (GtkWidget *do_widget)

  if (!window)
    {
-      GtkWidget *box;
      GtkWidget *sw;
      GtkWidget *widget;
-      GtkWidget *scale;

      window = gtk_window_new ();
      gtk_window_set_title (GTK_WINDOW (window), "Menu");
@@ -33,23 +31,11 @@ do_menu (GtkWidget *do_widget)
                              gtk_widget_get_display (do_widget));
      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);

-      box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-      gtk_window_set_child (GTK_WINDOW (window), box);
-
      sw = gtk_scrolled_window_new ();
-      gtk_widget_set_vexpand (sw, TRUE);
-      gtk_box_append (GTK_BOX (box), sw);
+      gtk_window_set_child (GTK_WINDOW (window), sw);

      widget = demo3_widget_new ("/transparent/portland-rose.jpg");
      gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), widget);
-
-      scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0.01, 10.0, 0.1);
-      gtk_range_set_value (GTK_RANGE (scale), 1.0);
-      gtk_box_append (GTK_BOX (box), scale);
-
-      g_object_bind_property (gtk_range_get_adjustment (GTK_RANGE (scale)), "value",
-                              widget, "scale",
-                              G_BINDING_BIDIRECTIONAL);
    }

  if (!gtk_widget_get_visible (window))
@@ -1,9 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <component type="desktop">
-  <id>org.gtk.Demo4</id>
-  <launchable type="desktop-id">org.gtk.Demo4.desktop</launchable>
+  <id>org.gtk.Demo4.desktop</id>
  <metadata_license>CC0-1.0</metadata_license>
-  <project_license>LGPL-2.1-or-later</project_license>
+  <project_license>LGPL-2.0+</project_license>
  <name>GTK Demo</name>
  <summary>Program to demonstrate GTK functions</summary>
  <description>
@@ -31,7 +30,6 @@
  <translation type="gettext">gtk-4.0</translation>
  <update_contact>matthias.clasen_at_gmail.com</update_contact>
  <developer_name>Matthias Clasen and others</developer_name>
-  <content_rating type="oars-1.1"/>
  <releases>
    <release version="@BUILD_VERSION@" date="@BUILD_DATE@">
      <description>
@@ -150,7 +150,7 @@ gtk_nuclear_media_stream_step (gpointer data)
   * call our pause function to pause the stream.
   */
  if (nuclear->progress >= DURATION)
-    gtk_media_stream_stream_ended (GTK_MEDIA_STREAM (nuclear));
+    gtk_media_stream_ended (GTK_MEDIA_STREAM (nuclear));

  /* The timeout function is removed by the pause function,
   * so we can just always return this value.
@@ -267,11 +267,11 @@ gtk_nuclear_media_stream_init (GtkNuclearMediaStream *nuclear)
   * However, media streams need to tell GTK once they are initialized,
   * so we do that here.
   */
-  gtk_media_stream_stream_prepared (GTK_MEDIA_STREAM (nuclear),
-                                    FALSE,
-                                    TRUE,
-                                    TRUE,
-                                    DURATION);
+  gtk_media_stream_prepared (GTK_MEDIA_STREAM (nuclear),
+                             FALSE,
+                             TRUE,
+                             TRUE,
+                             DURATION);
 }

 /* And finally, we add the simple constructor we declared in the header. */
@@ -1,7 +1,7 @@
 /* Peg Solitaire
 * #Keywords: GtkGridView, game
 *
- * This demo demonstrates how to use drag-and-drop to implement peg solitaire.
+ * This demo demonstrates how to use drag'n'drop to implement peg solitaire.
 *
 */

@@ -98,7 +98,7 @@ solitaire_peg_init (SolitairePeg *peg)

 /* Add a little setter for the peg's position.
 * We want to track those so that we can check for legal moves
- * during drag-and-drop operations.
+ * during drag'n'drop operations.
 */
 static void
 solitaire_peg_set_position (SolitairePeg *peg,
@@ -1,9 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <component type="desktop">
-  <id>org.gtk.IconBrowser4</id>
-  <launchable type="desktop-id">org.gtk.IconBrowser4.desktop</launchable>
+  <id>org.gtk.IconBrowser4.desktop</id>
  <metadata_license>CC0-1.0</metadata_license>
-  <project_license>LGPL-2.1-or-later</project_license>
+  <project_license>LGPL-2.0+</project_license>
  <name>GTK Icon Browser</name>
  <summary>Program to browse themed icons</summary>
  <description>
@@ -30,7 +29,6 @@
  <translation type="gettext">gtk-4.0</translation>
  <update_contact>matthias.clasen_at_gmail.com</update_contact>
  <developer_name>Matthias Clasen and others</developer_name>
-  <content_rating type="oars-1.1"/>
  <releases>
    <release version="@BUILD_VERSION@" date="@BUILD_DATE@">
      <description>
@@ -1,9 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <component type="desktop">
-  <id>org.gtk.PrintEditor4</id>
-  <launchable type="desktop-id">org.gtk.PrintEditor4.desktop</launchable>
+  <id>org.gtk.PrintEditor4.desktop</id>
  <metadata_license>CC0-1.0</metadata_license>
-  <project_license>LGPL-2.1-or-later</project_license>
+  <project_license>LGPL-2.0+</project_license>
  <name>GTK Print Editor</name>
  <summary>Program to demonstrate GTK printing</summary>
  <description>
@@ -25,7 +24,6 @@
  <translation type="gettext">gtk-4.0</translation>
  <update_contact>matthias.clasen_at_gmail.com</update_contact>
  <developer_name>Matthias Clasen and others</developer_name>
-  <content_rating type="oars-1.1"/>
  <releases>
    <release version="3.99.0" date="2020-07-30">
      <description>
@@ -721,6 +721,7 @@ static const char ui_info[] =
  "        <item>"
  "          <attribute name='label'>_New</attribute>"
  "          <attribute name='action'>app.new</attribute>"
+  "          <attribute name='accel'>&lt;Primary&gt;n</attribute>"
  "        </item>"
  "        <item>"
  "          <attribute name='label'>_Open</attribute>"
@@ -729,10 +730,12 @@ static const char ui_info[] =
  "        <item>"
  "          <attribute name='label'>_Save</attribute>"
  "          <attribute name='action'>app.save</attribute>"
+  "          <attribute name='accel'>&lt;Primary&gt;s</attribute>"
  "        </item>"
  "        <item>"
  "          <attribute name='label'>Save _As...</attribute>"
  "          <attribute name='action'>app.save-as</attribute>"
+  "          <attribute name='accel'>&lt;Primary&gt;s</attribute>"
  "        </item>"
  "      </section>"
  "      <section>"
@@ -753,6 +756,7 @@ static const char ui_info[] =
  "        <item>"
  "          <attribute name='label'>_Quit</attribute>"
  "          <attribute name='action'>app.quit</attribute>"
+  "          <attribute name='accel'>&lt;Primary&gt;q</attribute>"
  "        </item>"
  "      </section>"
  "    </submenu>"
@@ -762,6 +766,7 @@ static const char ui_info[] =
  "        <item>"
  "          <attribute name='label'>_About Print Editor</attribute>"
  "          <attribute name='action'>app.about</attribute>"
+  "          <attribute name='accel'>&lt;Primary&gt;a</attribute>"
  "        </item>"
  "      </section>"
  "    </submenu>"
@@ -789,15 +794,6 @@ startup (GApplication *app)
 {
  GtkBuilder *builder;
  GMenuModel *menubar;
-  struct {
-    const char *action_and_target;
-    const char *accelerators[2];
-  } accels[] = {
-    { "app.new", { "<Control>n", NULL } },
-    { "app.quit", { "<Control>q", NULL } },
-    { "app.save", { "<Control>s", NULL } },
-    { "app.about", { "<Control>a", NULL } },
-  };

  builder = gtk_builder_new ();
  gtk_builder_add_from_string (builder, ui_info, -1, NULL);
@@ -806,9 +802,6 @@ startup (GApplication *app)

  gtk_application_set_menubar (GTK_APPLICATION (app), menubar);

-  for (int i = 0; i < G_N_ELEMENTS (accels); i++)
-    gtk_application_set_accels_for_action (GTK_APPLICATION (app), accels[i].action_and_target, accels[i].accelerators);
-
  g_object_unref (builder);
 }

@@ -1,9 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <component type="desktop">
-  <id>org.gtk.WidgetFactory4</id>
-  <launchable type="desktop-id">org.gtk.WidgetFactory4.desktop</launchable>
+  <id>org.gtk.WidgetFactory4.desktop</id>
  <metadata_license>CC0-1.0</metadata_license>
-  <project_license>LGPL-2.1-or-later</project_license>
+  <project_license>LGPL-2.0+</project_license>
  <name>GTK Widget Factory</name>
  <summary>Program to demonstrate GTK functions</summary>
  <description>
@@ -32,7 +31,6 @@
  <translation type="gettext">gtk-4.0</translation>
  <update_contact>matthias.clasen_at_gmail.com</update_contact>
  <developer_name>Matthias Clasen and others</developer_name>
-  <content_rating type="oars-1.1"/>
  <releases>
    <release version="@BUILD_VERSION@" date="@BUILD_DATE@">
      <description>
@@ -1997,7 +1997,6 @@ activate (GApplication *app)
    const char *accelerators[2];
  } accels[] = {
    { "app.about", { "F1", NULL } },
-    { "app.shortcuts", { "<Control>question", NULL } },
    { "app.quit", { "<Control>q", NULL } },
    { "app.open-in", { "<Control>n", NULL } },
    { "win.dark", { "<Control>d", NULL } },
@@ -2902,7 +2902,7 @@ bad things might happen.</property>

    <action-widgets>
      <action-widget response="cancel">cancel_info_dialog</action-widget>
-      <action-widget response="ok" default="true">doit_info_dialog</action-widget>
+      <action-widget response="ok">doit_info_dialog</action-widget>
    </action-widgets>
  </object>
  <object class="GtkDialog" id="action_dialog">
@@ -1,54 +0,0 @@
-Title: Drag-and-Drop in GTK
-
-Drag-and-Drop (DND) is a user interaction pattern where users drag a UI element
-from one place to another, either inside a single application or between
-different application windows.
-
-When the element is 'dropped', data is transferred from the source to the
-destination, according to the drag action that is negotiated between both
-sides. Most commonly, that is a _copy_, but it can also be a _move_ or a
-_link_, depending on the kind of data and how the drag operation has been
-set up.
-
-This chapter gives an overview over how Drag-and-Drop is handled with event
-controllers in GTK.
-
-## Drag sources
-
-To make data available via DND, you create a [class@Gtk.DragSource]. Drag sources
-are event controllers, which initiate a Drag-and-Drop operation when the user clicks
-and drags the widget.
-
-A drag source can be set up ahead of time, with the desired drag action(s) and the data
-to be transferred. But it is also possible to provide the data when a drag operation
-is about to begin, by connecting to the [signal@Gtk.DragSource::prepare] signal.
-
-The GtkDragSource emits the [signal@Gtk.DragSource::drag-begin] signal when the DND
-operation starts, and the [signal@Gtk.DragSource::drag-end] signal when it is done.
-But it is not normally necessary to handle these signals. One case in which a ::drag-end
-handler is necessary is to implement `GDK_ACTION_MOVE`.
-
-## Drop targets
-
-To receive data via DND, you create a [class@Gtk.DropTarget], and tell it what kind of
-data to accept. You need to connect to the [signal@Gtk.DropTarget::drop] signal to receive
-the data when a DND operation occurs.
-
-While a DND operation is ongoing, GTK provides updates when the pointer moves over
-the widget to which the drop target is associated. The [signal@Gtk.DropTarget::enter],
-[signal@Gtk.DropTarget::leave] and [signal@Gtk.DropTarget::motion] signals get emitted
-for this purpose.
-
-GtkDropTarget provides a simple API, and only provides the data when it has been completely
-transferred. If you need to handle the data transfer yourself (for example to provide progress
-information during the transfer), you can use the more complicated [class@Gtk.DropTargetAsync].
-
-## Other considerations
-
-It is sometimes necessary to update the UI of the destination while a DND operation is ongoing,
-say to scroll or expand a view, or to switch pages. Typically, such UI changes are triggered
-by hovering over the widget in question.
-
-[class@Gtk.DropControllerMotion] is an event controller that can help with implementing such
-behaviors. It is very similar to [class@Gtk.EventControllerMotion], but provides events during
-a DND operation.
@@ -161,19 +161,19 @@ activate (GtkApplication *app,
 {
  GtkWidget *window;
  GtkWidget *button;
+  GtkWidget *box;

  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW (window), "Window");
  gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);

-  button = gtk_button_new_with_label ("Hello World");
-  gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
-  gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_window_set_child (GTK_WINDOW (window), box);

+  button = gtk_button_new_with_label ("Hello World");
  g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
-
-  gtk_window_set_child (GTK_WINDOW (window), button);
+  gtk_box_append (GTK_BOX (box), button);

  gtk_widget_show (window);
 }
@@ -46,8 +46,7 @@ display, unless specified otherwise.
 <para>
 <command>gtk4-launch</command> takes at least one argument, the name of
 the application to launch. The name should match application desktop file name,
-as residing in the applications subdirectories of the XDG data directories, with
-or without the '.desktop' suffix.
+as residing in /usr/share/application, with or without the '.desktop' suffix.
 </para>
 <para>
 If called with more than one argument, the rest of them besides the application
@@ -72,14 +71,4 @@ application.
  </variablelist>
 </refsect1>

-<refsect1><title>Environment</title>
-  <para>Some environment variables affect the behavior of <command>gtk4-launch</command>.</para>
-  <variablelist>
-    <varlistentry>
-    <term><option>XDG_DATA_HOME</option>, <option>XDG_DATA_DIRS</option></term>
-      <listitem><para>The environment variables specifying the XDG dta directories.</para></listitem>
-    </varlistentry>
-  </variablelist>
-</refsect1>
-
 </refentry>
@@ -57,7 +57,6 @@ content_files = [
  "initialization.md",
  "actions.md",
  "input-handling.md",
-  "drag-and-drop.md",
  "drawing-model.md",
  "css-overview.md",
  "css-properties.md",
@@ -99,12 +99,6 @@ you should stop using `GdkVisual` APIs, since this object not longer
 exists in GTK 4. Most of its APIs are deprecated already and not
 useful when dealing with RGBA visuals.

-### Stop using `gtk_widget_set_app_paintable`
-
-This is gone in GTK4 with no direct replacement. But for some usecases there
-are alternatives. If you want to make the background transparent, you can set
-the background color to, for example, `rgba(255, 255, 255, 0)` using CSS instead.
-
 ### Stop using `GtkBox` padding, fill and expand child properties

 GTK 4 removes these [class@Gtk.Box] child properties, so you should stop using
@@ -139,7 +133,7 @@ or `gtk_style_context_get_color()` only accept the context's current
 state for their state argument. You should update all callers to pass
 the current state.

-### Stop using `gdk_pixbuf_get_from_window()` and `gdk_cairo_set_source_window()`
+### Stop using `gdk_pixbuf_get_from_window()` and `gdk_cairo_set_source_surface()`

 These functions are not supported in GTK 4. Instead, either use
 backend-specific APIs, or render your widgets using
@@ -193,22 +187,11 @@ for this change.
 | ::grab-broken-event | - |

 Event signals which are not directly related to input have to be dealt with
-on a one-by-one basis:
-
- - If you were using `::configure-event` and `::window-state-event` to save
-   window state, you should use property notification for corresponding
-   [class@Gtk.Window] properties, such as [property@Gtk.Window:default-width],
-   [property@Gtk.Window:default-height], [property@Gtk.Window:maximized] or
-   [property@Gtk.Window:fullscreened].
- - If you were using `::delete-event` to present a confirmation when using
-   the close button of a window, you should use the
-   [signal@Gtk.Window::close-request] signal.
- - If you were using `::map-event` and `::unmap-event` to track a window
-   being mapped, you should use property notification for the
-   [property@Gdk.Surface:mapped] property instead.
- - The `::damage-event` signal has no replacement, as the only consumer
-   of damage events were the offscreen GDK surfaces, which have no
-   replacement in GTK 4.x.
+on a one-by-one basis. If you were using `::configure-event` and
+`::window-state-event` to save window state, you should use property
+notification for corresponding [class@Gtk.Window] properties, such as
+[property@Gtk.Window:default-width], [property@Gtk.Window:default-height],
+[property@Gtk.Window:maximized] or [property@Gtk.Window:fullscreened].

 ### Set a proper application ID

@@ -249,10 +232,6 @@ in GTK 3, you can prepare for the switch by using `gtk_widget_destroy()`
 only on toplevel windows, and replace all other uses with
 `gtk_container_remove()` or `g_object_unref()`.

-### Stop using the GtkWidget.destroy vfunc
-
-Instead of implementing GtkWidget.destroy, you can implement GObject.dispose.
-
 ### Reduce the use of generic container APIs

 GTK 4 removes `gtk_container_add()` and `gtk_container_remove()`. While there
@@ -1359,4 +1338,3 @@ of tree models, and widgets instead of cell renderers.

 To learn more about the new list widgets, you can read the [List Widget
 Overview](#ListWidget).
-
@@ -197,17 +197,6 @@ text_buffer_changed_cb (GtkTextBuffer *buffer,
    }
 }

-static void
-fullscreen_changed (GObject    *object,
-                    GParamSpec *pspec,
-                    gpointer    user_data)
-{
-  if (gtk_window_is_fullscreen (GTK_WINDOW (object)))
-    gtk_button_set_icon_name (GTK_BUTTON (user_data), "view-restore-symbolic");
-  else
-    gtk_button_set_icon_name (GTK_BUTTON (user_data), "view-fullscreen-symbolic");
-}
-
 static GActionEntry win_entries[] = {
  { "copy", window_copy, NULL, NULL, NULL },
  { "paste", window_paste, NULL, NULL, NULL },
@@ -225,6 +214,7 @@ new_window (GApplication *app,
  GtkWidget *window, *grid, *scrolled, *view;
  GtkWidget *toolbar;
  GtkWidget *button;
+  GtkWidget *sw, *box, *label;

  window = gtk_application_window_new (GTK_APPLICATION (app));
  gtk_window_set_default_size ((GtkWindow*)window, 640, 480);
@@ -236,7 +226,6 @@ new_window (GApplication *app,
  gtk_window_set_child (GTK_WINDOW (window), grid);

  toolbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-  gtk_widget_add_css_class (toolbar, "toolbar");
  button = gtk_toggle_button_new ();
  gtk_button_set_icon_name (GTK_BUTTON (button), "format-justify-left");
  gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.justify::left");
@@ -252,18 +241,21 @@ new_window (GApplication *app,
  gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.justify::right");
  gtk_box_append (GTK_BOX (toolbar), button);

-  button = gtk_toggle_button_new ();
-  gtk_button_set_icon_name (GTK_BUTTON (button), "view-fullscreen-symbolic");
-  gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "win.fullscreen");
-  gtk_box_append (GTK_BOX (toolbar), button);
-  g_signal_connect (window, "notify::fullscreened", G_CALLBACK (fullscreen_changed), button);
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+  gtk_widget_set_halign (box, GTK_ALIGN_END);
+  label = gtk_label_new ("Fullscreen:");
+  gtk_box_append (GTK_BOX (box), label);
+  sw = gtk_switch_new ();
+  gtk_widget_set_valign (sw, GTK_ALIGN_CENTER);
+  gtk_actionable_set_action_name (GTK_ACTIONABLE (sw), "win.fullscreen");
+  gtk_box_append (GTK_BOX (box), sw);
+  gtk_box_append (GTK_BOX (toolbar), box);

  gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 1, 1);

  scrolled = gtk_scrolled_window_new ();
  gtk_widget_set_hexpand (scrolled, TRUE);
  gtk_widget_set_vexpand (scrolled, TRUE);
-  gtk_scrolled_window_set_has_frame (GTK_SCROLLED_WINDOW (scrolled), TRUE);
  view = gtk_text_view_new ();

  g_object_set_data ((GObject*)window, "bloatpad-text", view);
@@ -353,7 +345,6 @@ static void
 combo_changed (GtkComboBox *combo,
               gpointer     user_data)
 {
-  GtkDialog *dialog = user_data;
  GtkEntry *entry = g_object_get_data (user_data, "entry");
  const char *action;
  char **accels;
@@ -369,17 +360,6 @@ combo_changed (GtkComboBox *combo,
  g_strfreev (accels);

  gtk_editable_set_text (GTK_EDITABLE (entry), str);
-  gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_APPLY, FALSE);
-}
-
-static void
-entry_changed (GtkEntry   *entry,
-               GParamSpec *pspec,
-               gpointer    user_data)
-{
-  GtkDialog *dialog = user_data;
-
-  gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_APPLY, TRUE);
 }

 static void
@@ -393,7 +373,7 @@ response (GtkDialog *dialog,
  const char *str;
  char **accels;

-  if (response_id == GTK_RESPONSE_CANCEL)
+  if (response_id == GTK_RESPONSE_CLOSE)
    {
      gtk_window_destroy (GTK_WINDOW (dialog));
      return;
@@ -409,8 +389,6 @@ response (GtkDialog *dialog,

  gtk_application_set_accels_for_action (gtk_window_get_application (user_data), action, (const char **) accels);
  g_strfreev (accels);
-
-  gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_APPLY, FALSE);
 }

 static void
@@ -425,41 +403,22 @@ edit_accels (GSimpleAction *action,
  GtkWidget *dialog;
  int i;

-  dialog = gtk_dialog_new_with_buttons ("Accelerators",
-                                        NULL,
-                                        GTK_DIALOG_USE_HEADER_BAR,
-                                        "Close", GTK_RESPONSE_CANCEL,
-                                        "Set", GTK_RESPONSE_APPLY,
-                                        NULL);
-
+  dialog = gtk_dialog_new ();
  gtk_window_set_application (GTK_WINDOW (dialog), app);
  actions = gtk_application_list_action_descriptions (app);
-
  combo = gtk_combo_box_text_new ();
-  g_object_set (gtk_dialog_get_content_area (GTK_DIALOG (dialog)),
-                "margin-top", 10,
-                "margin-bottom", 10,
-                "margin-start", 10,
-                "margin-end", 10,
-                "spacing", 10,
-                NULL);
-
  gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), combo);
  for (i = 0; actions[i]; i++)
    gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), actions[i], actions[i]);
  g_signal_connect (combo, "changed", G_CALLBACK (combo_changed), dialog);
-
  entry = gtk_entry_new ();
-  gtk_widget_set_hexpand (entry, TRUE);
-  g_signal_connect (entry, "notify::text", G_CALLBACK (entry_changed), dialog);
-
  gtk_box_append (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), entry);
+  gtk_dialog_add_button (GTK_DIALOG (dialog), "Close", GTK_RESPONSE_CLOSE);
+  gtk_dialog_add_button (GTK_DIALOG (dialog), "Set", GTK_RESPONSE_APPLY);
  g_signal_connect (dialog, "response", G_CALLBACK (response), dialog);
  g_object_set_data (G_OBJECT (dialog), "combo", combo);
  g_object_set_data (G_OBJECT (dialog), "entry", entry);

-  gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
-
  gtk_widget_show (dialog);
 }

@@ -4,10 +4,5 @@
  <gresource prefix="/org/gtk/bloatpad">
    <file preprocess="xml-stripblanks">gtk/menus.ui</file>
    <file preprocess="xml-stripblanks">gtk/help-overlay.ui</file>
-    <file>icons/16x16/actions/format-justify-center-symbolic.symbolic.png</file>
-    <file>icons/16x16/actions/format-justify-left-symbolic.symbolic.png</file>
-    <file>icons/16x16/actions/format-justify-right-symbolic.symbolic.png</file>
-    <file>icons/16x16/actions/view-fullscreen-symbolic.symbolic.png</file>
-    <file>icons/16x16/actions/view-restore-symbolic.symbolic.png</file>
  </gresource>
 </gresources>
@@ -132,6 +132,7 @@ activate (GtkApplication *app,
          gpointer        user_data)
 {
  GtkWidget *window;
+  GtkWidget *frame;
  GtkWidget *drawing_area;
  GtkGesture *drag;
  GtkGesture *press;
@@ -141,11 +142,14 @@ activate (GtkApplication *app,

  g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);

+  frame = gtk_frame_new (NULL);
+  gtk_window_set_child (GTK_WINDOW (window), frame);
+
  drawing_area = gtk_drawing_area_new ();
  /* set a minimum size */
  gtk_widget_set_size_request (drawing_area, 100, 100);

-  gtk_window_set_child (GTK_WINDOW (window), drawing_area);
+  gtk_frame_set_child (GTK_FRAME (frame), drawing_area);

  gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area), draw_cb, NULL, NULL);

@@ -13,19 +13,19 @@ activate (GtkApplication *app,
 {
  GtkWidget *window;
  GtkWidget *button;
+  GtkWidget *box;

  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW (window), "Window");
  gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);

-  button = gtk_button_new_with_label ("Hello World");
-  gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
-  gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
+  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_window_set_child (GTK_WINDOW (window), box);

+  button = gtk_button_new_with_label ("Hello World");
  g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
-
-  gtk_window_set_child (GTK_WINDOW (window), button);
+  gtk_box_append (GTK_BOX (box), button);

  gtk_widget_show (window);
 }
@@ -1,10 +0,0 @@
-project('hello', 'c',
-          version: '4.3.0',
-          meson_version: '>= 0.50.0',
-)
-
-executable('hello',
-  [ 'hello-world.c' ],
-  dependencies: [ dependency('gtk4') ],
-  install: false
-)
@@ -1,50 +0,0 @@
-#!/usr/bin/env -S GI_TYPELIB_PATH=${PWD}/build/gtk:${GI_TYPELIB_PATH} LD_PRELOAD=${LD_PRELOAD}:${PWD}/build/gtk/libgtk-4.so gjs
-
-imports.gi.versions['Gtk'] = '4.0';
-
-const GObject = imports.gi.GObject;
-const Gtk = imports.gi.Gtk;
-
-const DemoWidget = GObject.registerClass({
-  GTypeName: 'DemoWidget',
-  }, class DemoWidget extends Gtk.Widget {
-
-  _init(params = {}) {
-       super._init(params);
-
-       let layout_manager = new Gtk.GridLayout ();
-       this.set_layout_manager (layout_manager);
-       this.label1 = new Gtk.Label({ label: "Red",
-                                     hexpand: true,
-                                     vexpand: true });
-       this.label1.set_parent (this);
-       let child1 = layout_manager.get_layout_child (this.label1);
-       child1.set_row (0);
-       child1.set_column (0);
-
-       this.label2 = new Gtk.Label({ label: "Green",
-                                     hexpand: true,
-                                     vexpand: true });
-       this.label2.set_parent (this);
-       let child2 = layout_manager.get_layout_child (this.label2);
-       child2.set_row (0);
-       child2.set_column (1);
-    }
-});
-
-// Create a new application
-let app = new Gtk.Application({ application_id: 'org.gtk.exampleapp' });
-
-// When the application is launched…
-app.connect('activate', () => {
-    // … create a new window …
-    let win = new Gtk.ApplicationWindow({ application: app });
-    // … with a button in it …
-    let widget = new DemoWidget();
-    win.set_child(widget);
-    win.present();
-});
-
-// Run the application
-app.run([]);
-
@@ -2,6 +2,7 @@ examples = [
  'builder',
  'drawing',
  'grid-packing',
+  'hello-world',
  'plugman',
  'search-bar',
  'sunny',
@@ -1,61 +0,0 @@
-#!/usr/bin/env -S GI_TYPELIB_PATH=${PWD}/build/gtk:${GI_TYPELIB_PATH} LD_PRELOAD=${LD_PRELOAD}:${PWD}/build/gtk/libgtk-4.so python3
-
-import gi
-
-gi.require_version('Gdk', '4.0')
-gi.require_version('Gtk', '4.0')
-
-from gi.repository import Gdk
-from gi.repository import Gtk
-from gi.repository import Graphene
-
-
-class DemoWidget(Gtk.Widget):
-
-    __gtype_name__ = "DemoWidget"
-
-    def __init__(self):
-        super().__init__()
-
-    def do_measure(self, orientation, for_size: int):
-        # We need some space to draw
-        return 100, 200, -1, -1
-
-    def do_snapshot(self, snapshot):
-        # Draw four color squares
-        color = Gdk.RGBA()
-        rect = Graphene.Rect.alloc()
-
-        width = self.get_width() / 2
-        height = self.get_height() / 2
-
-        Gdk.RGBA.parse(color, "red")
-        rect.init(0, 0, width, height)
-        snapshot.append_color(color, rect)
-
-        Gdk.RGBA.parse(color, "green")
-        rect.init(width, 0, width, height)
-        snapshot.append_color(color, rect)
-
-        Gdk.RGBA.parse(color, "yellow")
-        rect.init(0, height, width, height)
-        snapshot.append_color(color, rect)
-
-        Gdk.RGBA.parse(color, "blue")
-        rect.init(width, height, width, height)
-        snapshot.append_color(color, rect)
-
-def on_activate(app):
-    # Create a new window
-    win = Gtk.ApplicationWindow(application=app)
-    win.set_title("Squares")
-    icon = DemoWidget()
-    win.set_child(icon)
-    win.present()
-
-# Create a new application
-app = Gtk.Application(application_id='org.gtk.exampleapp')
-app.connect('activate', on_activate)
-
-# Run the application
-app.run(None)
@@ -12,7 +12,7 @@ new_window (GApplication *app,
  gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (window), TRUE);
  gtk_window_set_default_size ((GtkWindow*)window, 640, 480);
  gtk_window_set_title (GTK_WINDOW (window), "Sunny");
-  gtk_window_set_icon_name (GTK_WINDOW (window), "weather-clear-symbolic");
+  gtk_window_set_icon_name (GTK_WINDOW (window), "sunny");

  header = gtk_header_bar_new ();
  gtk_window_set_titlebar (GTK_WINDOW (window), header);
@@ -78,7 +78,7 @@ show_about (GSimpleAction *action,
  gtk_show_about_dialog (NULL,
                         "program-name", "Sunny",
                         "title", "About Sunny",
-                         "logo-icon-name", "weather-clear-symbolic",
+                         "logo-icon-name", "sunny",
                         "comments", "A cheap Bloatpad clone.",
                         NULL);
 }
@@ -48,8 +48,6 @@ void                    gdk_broadway_display_show_keyboard       (GdkBroadwayDis
 GDK_AVAILABLE_IN_ALL
 void                    gdk_broadway_display_hide_keyboard       (GdkBroadwayDisplay *display);

-GDK_AVAILABLE_IN_4_4
-int                     gdk_broadway_display_get_surface_scale   (GdkDisplay *display);
 GDK_AVAILABLE_IN_4_4
 void                    gdk_broadway_display_set_surface_scale   (GdkDisplay *display,
                                                                  int         scale);
@@ -361,29 +361,6 @@ gdk_broadway_display_set_surface_scale (GdkDisplay *display,
  gdk_monitor_set_scale_factor (self->monitor, scale);
 }

-/**
- * gdk_broadway_display_get_surface_scale:
- * @display: (type GdkBroadwayDisplay): the display
- *
- * Gets the surface scale that was previously set by the client or
- * gdk_broadway_display_set_surface_scale().
- *
- * Returns: the scale for surfaces
- *
- * Since: 4.4
- */
-int
-gdk_broadway_display_get_surface_scale (GdkDisplay *display)
-{
-  GdkBroadwayDisplay *self;
-
-  g_return_val_if_fail (GDK_IS_BROADWAY_DISPLAY (display), 1);
-
-  self = GDK_BROADWAY_DISPLAY (display);
-
-  return self->scale_factor;
-}
-
 static GListModel *
 gdk_broadway_display_get_monitors (GdkDisplay *display)
 {
@@ -127,9 +127,7 @@ static const GdkDebugKey gdk_debug_keys[] = {
  { "gl-legacy",       GDK_DEBUG_GL_LEGACY, "Use a legacy OpenGL context" },
  { "gl-gles",         GDK_DEBUG_GL_GLES, "Use a GLES OpenGL context" },
  { "gl-debug",        GDK_DEBUG_GL_DEBUG, "Insert debugging information in OpenGL" },
-  { "gl-egl",          GDK_DEBUG_GL_EGL, "Use EGL on X11 or Windows" },
  { "gl-glx",          GDK_DEBUG_GL_GLX, "Use GLX on X11" },
-  { "gl-wgl",          GDK_DEBUG_GL_WGL, "Use WGL on Windows" },
  { "vulkan-disable",  GDK_DEBUG_VULKAN_DISABLE, "Disable Vulkan support" },
  { "vulkan-validate", GDK_DEBUG_VULKAN_VALIDATE, "Load the Vulkan validation layer" },
  { "default-settings",GDK_DEBUG_DEFAULT_SETTINGS, "Force default values for xsettings" },
@@ -41,12 +41,10 @@ typedef enum {
  GDK_DEBUG_GL_LEGACY       = 1 << 15,
  GDK_DEBUG_GL_GLES         = 1 << 16,
  GDK_DEBUG_GL_DEBUG        = 1 << 17,
-  GDK_DEBUG_GL_EGL          = 1 << 18,
-  GDK_DEBUG_GL_GLX          = 1 << 19,
-  GDK_DEBUG_GL_WGL          = 1 << 20,
-  GDK_DEBUG_VULKAN_DISABLE  = 1 << 21,
-  GDK_DEBUG_VULKAN_VALIDATE = 1 << 22,
-  GDK_DEBUG_DEFAULT_SETTINGS= 1 << 23,
+  GDK_DEBUG_GL_GLX          = 1 << 18,
+  GDK_DEBUG_VULKAN_DISABLE  = 1 << 19,
+  GDK_DEBUG_VULKAN_VALIDATE = 1 << 20,
+  GDK_DEBUG_DEFAULT_SETTINGS= 1 << 21
 } GdkDebugFlags;

 extern guint _gdk_debug_flags;
@@ -77,23 +77,6 @@ enum {
  LAST_SIGNAL
 };

-typedef struct _GdkDisplayPrivate GdkDisplayPrivate;
-
-struct _GdkDisplayPrivate {
-  /* The base context that all other contexts inherit from.
-   * This context is never exposed to public API and is
-   * allowed to have a %NULL surface.
-   */
-  GdkGLContext *gl_context;
-  GError *gl_error;
-
-  guint rgba : 1;
-  guint composited : 1;
-  guint input_shapes : 1;
-
-  GdkDebugFlags debug_flags;
-};
-
 static void gdk_display_dispose     (GObject         *object);
 static void gdk_display_finalize    (GObject         *object);

@@ -102,7 +85,7 @@ static GdkAppLaunchContext *gdk_display_real_get_app_launch_context (GdkDisplay

 static guint signals[LAST_SIGNAL] = { 0 };

-G_DEFINE_TYPE_WITH_PRIVATE (GdkDisplay, gdk_display, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GdkDisplay, gdk_display, G_TYPE_OBJECT)

 static void
 gdk_display_get_property (GObject    *object,
@@ -136,14 +119,10 @@ gdk_display_real_make_default (GdkDisplay *display)
 {
 }

-static GdkGLContext *
-gdk_display_default_init_gl (GdkDisplay  *display,
-                             GError     **error)
+static void
+gdk_display_real_opened (GdkDisplay *display)
 {
-  g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
-                       _("The current backend does not support OpenGL"));
-
-  return NULL;
+  _gdk_display_manager_add_display (gdk_display_manager_get (), display);
 }

 static GdkSeat *
@@ -155,12 +134,6 @@ gdk_display_real_get_default_seat (GdkDisplay *display)
  return display->seats->data;
 }

-static void
-gdk_display_real_opened (GdkDisplay *display)
-{
-  _gdk_display_manager_add_display (gdk_display_manager_get (), display);
-}
-
 static void
 gdk_display_class_init (GdkDisplayClass *class)
 {
@@ -170,11 +143,10 @@ gdk_display_class_init (GdkDisplayClass *class)
  object_class->dispose = gdk_display_dispose;
  object_class->get_property = gdk_display_get_property;

-  class->make_default = gdk_display_real_make_default;
  class->get_app_launch_context = gdk_display_real_get_app_launch_context;
-  class->init_gl = gdk_display_default_init_gl;
-  class->get_default_seat = gdk_display_real_get_default_seat;
  class->opened = gdk_display_real_opened;
+  class->make_default = gdk_display_real_make_default;
+  class->get_default_seat = gdk_display_real_get_default_seat;

  /**
   * GdkDisplay:composited: (attributes org.gtk.Property.get=gdk_display_is_composited)
@@ -322,8 +294,6 @@ free_device_grabs_foreach (gpointer key,
 static void
 gdk_display_init (GdkDisplay *display)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
  display->double_click_time = 250;
  display->double_click_distance = 5;

@@ -334,26 +304,22 @@ gdk_display_init (GdkDisplay *display)

  g_queue_init (&display->queued_events);

-  priv->debug_flags = _gdk_debug_flags;
+  display->debug_flags = _gdk_debug_flags;

-  priv->composited = TRUE;
-  priv->rgba = TRUE;
-  priv->input_shapes = TRUE;
+  display->composited = TRUE;
+  display->rgba = TRUE;
+  display->input_shapes = TRUE;
 }

 static void
 gdk_display_dispose (GObject *object)
 {
  GdkDisplay *display = GDK_DISPLAY (object);
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);

  _gdk_display_manager_remove_display (gdk_display_manager_get (), display);

  g_queue_clear (&display->queued_events);

-  g_clear_object (&priv->gl_context);
-  g_clear_error (&priv->gl_error);
-
  G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object);
 }

@@ -1032,25 +998,21 @@ gdk_display_get_primary_clipboard (GdkDisplay *display)
 gboolean
 gdk_display_supports_input_shapes (GdkDisplay *display)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);

-  return priv->input_shapes;
+  return display->input_shapes;
 }

 void
 gdk_display_set_input_shapes (GdkDisplay *display,
                              gboolean    input_shapes)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
  g_return_if_fail (GDK_IS_DISPLAY (display));

-  if (priv->input_shapes == input_shapes)
+  if (display->input_shapes == input_shapes)
    return;

-  priv->input_shapes = input_shapes;
+  display->input_shapes = input_shapes;

  g_object_notify_by_pspec (G_OBJECT (display), props[PROP_INPUT_SHAPES]);
 }
@@ -1195,136 +1157,32 @@ gdk_display_get_keymap (GdkDisplay *display)
  return GDK_DISPLAY_GET_CLASS (display)->get_keymap (display);
 }

-static void
-gdk_display_init_gl (GdkDisplay *self)
-{
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
-  GdkGLContext *context;
-  gint64 before G_GNUC_UNUSED;
-  gint64 before2 G_GNUC_UNUSED;
-
-  before = GDK_PROFILER_CURRENT_TIME;
-
-  if (GDK_DISPLAY_DEBUG_CHECK (self, GL_DISABLE))
-    {
-      g_set_error_literal (&priv->gl_error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("GL support disabled via GDK_DEBUG"));
-      return;
-    }
-
-  context = GDK_DISPLAY_GET_CLASS (self)->init_gl (self, &priv->gl_error);
-  if (context == NULL)
-    return;
-
-  before2 = GDK_PROFILER_CURRENT_TIME;
-
-  if (!gdk_gl_context_realize (context, &priv->gl_error))
-    {
-      g_object_unref (context);
-      return;
-    }
-
-  gdk_profiler_end_mark (before2, "realize OpenGL context", NULL);
-
-  /* Only assign after realize, so GdkGLContext::realize() can use
-   * gdk_display_get_gl_context() == NULL to differentiate between
-   * the display's context and any other context.
-   */
-  priv->gl_context = context;
-
-  gdk_profiler_end_mark (before, "initialize OpenGL", NULL);
-}
-
-/**
- * gdk_display_prepare_gl:
- * @self: a `GdkDisplay`
- * @error: return location for a `GError`
- *
- * Checks that OpenGL is available for @self and ensures that it is
- * properly initialized.
- * When this fails, an @error will be set describing the error and this
- * function returns %FALSE.
- *
- * Note that even if this function succeeds, creating a `GdkGLContext`
- * may still fail.
- *
- * This function is idempotent. Calling it multiple times will just 
- * return the same value or error.
- *
- * You never need to call this function, GDK will call it automatically
- * as needed. But you can use it as a check when setting up code that
- * might make use of OpenGL.
- *
- * Returns: %TRUE if the display supports OpenGL
- *
- * Since: 4.4
- **/
-gboolean
-gdk_display_prepare_gl (GdkDisplay  *self,
-                        GError     **error)
-{
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
-
-  g_return_val_if_fail (GDK_IS_DISPLAY (self), FALSE);
-  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-  for (;;)
-    {
-      if (priv->gl_context)
-        return TRUE;
-
-      if (priv->gl_error != NULL)
-        {
-          if (error)
-            *error = g_error_copy (priv->gl_error);
-
-
-          return FALSE;
-        }
-
-      gdk_display_init_gl (self);
-
-      /* try again */
-    }
-}
-
 /*< private >
- * gdk_display_get_gl_context:
- * @self: the `GdkDisplay`
+ * gdk_display_make_gl_context_current:
+ * @display: a `GdkDisplay`
+ * @context: (optional): a `GdkGLContext`
 *
- * Gets the GL context returned from [vfunc@Gdk.Display.init_gl]
- * previously.
- *
- * If that function has not been called yet or did fail, %NULL is
- * returned.
- * Call [method@Gdk.Display.prepare_gl] to avoid this.
- *
- * Returns: The `GdkGLContext`
+ * Makes the given @context the current GL context, or unsets
+ * the current GL context if @context is %NULL.
 */
-GdkGLContext *
-gdk_display_get_gl_context (GdkDisplay *self)
+gboolean
+gdk_display_make_gl_context_current (GdkDisplay   *display,
+                                     GdkGLContext *context)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
-
-  return priv->gl_context;
+  return GDK_DISPLAY_GET_CLASS (display)->make_gl_context_current (display, context);
 }

 GdkDebugFlags
 gdk_display_get_debug_flags (GdkDisplay *display)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
-  return display ? priv->debug_flags : _gdk_debug_flags;
+  return display ? display->debug_flags : _gdk_debug_flags;
 }

 void
 gdk_display_set_debug_flags (GdkDisplay    *display,
                             GdkDebugFlags  flags)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
-  priv->debug_flags = flags;
+  display->debug_flags = flags;
 }

 /**
@@ -1349,25 +1207,21 @@ gdk_display_set_debug_flags (GdkDisplay    *display,
 gboolean
 gdk_display_is_composited (GdkDisplay *display)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);

-  return priv->composited;
+  return display->composited;
 }

 void
 gdk_display_set_composited (GdkDisplay *display,
                            gboolean    composited)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
  g_return_if_fail (GDK_IS_DISPLAY (display));

-  if (priv->composited == composited)
+  if (display->composited == composited)
    return;

-  priv->composited = composited;
+  display->composited = composited;

  g_object_notify_by_pspec (G_OBJECT (display), props[PROP_COMPOSITED]);
 }
@@ -1394,25 +1248,21 @@ gdk_display_set_composited (GdkDisplay *display,
 gboolean
 gdk_display_is_rgba (GdkDisplay *display)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);

-  return priv->rgba;
+  return display->rgba;
 }

 void
 gdk_display_set_rgba (GdkDisplay *display,
                      gboolean    rgba)
 {
-  GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
-
  g_return_if_fail (GDK_IS_DISPLAY (display));

-  if (priv->rgba == rgba)
+  if (display->rgba == rgba)
    return;

-  priv->rgba = rgba;
+  display->rgba = rgba;

  g_object_notify_by_pspec (G_OBJECT (display), props[PROP_RGBA]);
 }
@@ -68,10 +68,6 @@ gboolean    gdk_display_is_rgba            (GdkDisplay  *display);
 GDK_AVAILABLE_IN_ALL
 gboolean    gdk_display_supports_input_shapes (GdkDisplay    *display);

-GDK_AVAILABLE_IN_4_4
-gboolean    gdk_display_prepare_gl         (GdkDisplay  *self,
-                                            GError     **error);
-
 GDK_AVAILABLE_IN_ALL
 GdkDisplay *gdk_display_get_default (void);

@@ -102,6 +102,11 @@ struct _GdkDisplay

  guint vulkan_refcount;
 #endif /* GDK_RENDERING_VULKAN */
+  guint rgba : 1;
+  guint composited : 1;
+  guint input_shapes : 1;
+
+  GdkDebugFlags debug_flags;

  GList *seats;
 };
@@ -140,8 +145,8 @@ struct _GdkDisplayClass

  GdkKeymap *                (*get_keymap)         (GdkDisplay    *display);

-  GdkGLContext *         (*init_gl)                    (GdkDisplay        *display,
-                                                        GError           **error);
+  gboolean               (*make_gl_context_current)    (GdkDisplay        *display,
+                                                        GdkGLContext      *context);

  GdkSeat *              (*get_default_seat)           (GdkDisplay     *display);

@@ -206,7 +211,8 @@ GdkSurface *        gdk_display_create_surface        (GdkDisplay       *display
                                                       int               width,
                                                       int               height);

-GdkGLContext *      gdk_display_get_gl_context        (GdkDisplay       *display);
+gboolean            gdk_display_make_gl_context_current  (GdkDisplay        *display,
+                                                          GdkGLContext      *context);

 void                gdk_display_set_rgba              (GdkDisplay       *display,
                                                       gboolean          rgba);
@@ -43,7 +43,6 @@
 typedef struct _GdkDrawContextPrivate GdkDrawContextPrivate;

 struct _GdkDrawContextPrivate {
-  GdkDisplay *display;
  GdkSurface *surface;

  cairo_region_t *frame_region;
@@ -78,7 +77,6 @@ gdk_draw_context_dispose (GObject *gobject)
      priv->surface->draw_contexts = g_slist_remove (priv->surface->draw_contexts, context);
      g_clear_object (&priv->surface);
    }
-  g_clear_object (&priv->display);

  G_OBJECT_CLASS (gdk_draw_context_parent_class)->dispose (gobject);
 }
@@ -94,31 +92,10 @@ gdk_draw_context_set_property (GObject      *gobject,

  switch (prop_id)
    {
-    case PROP_DISPLAY:
-      if (priv->display != NULL)
-        {
-          g_assert (g_value_get_object (value) == NULL);
-        }
-      else
-        {
-          priv->display = g_value_dup_object (value);
-        }
-      break;
-
    case PROP_SURFACE:
      priv->surface = g_value_dup_object (value);
-      if (priv->surface)
-        {
-          priv->surface->draw_contexts = g_slist_prepend (priv->surface->draw_contexts, context);
-          if (priv->display)
-            {
-              g_assert (priv->display == gdk_surface_get_display (priv->surface));
-            }
-          else
-            {
-              priv->display = g_object_ref (gdk_surface_get_display (priv->surface));
-            }
-        }
+      g_assert (priv->surface != NULL);
+      priv->surface->draw_contexts = g_slist_prepend (priv->surface->draw_contexts, context);
      break;

    default:
@@ -171,8 +148,7 @@ gdk_draw_context_class_init (GdkDrawContextClass *klass)
                         P_("Display"),
                         P_("The GDK display used to create the context"),
                         GDK_TYPE_DISPLAY,
-                         G_PARAM_READWRITE |
-                         G_PARAM_CONSTRUCT_ONLY |
+                         G_PARAM_READABLE |
                         G_PARAM_STATIC_STRINGS);

  /**
@@ -252,7 +228,7 @@ gdk_draw_context_get_display (GdkDrawContext *context)

  g_return_val_if_fail (GDK_IS_DRAW_CONTEXT (context), NULL);

-  return priv->display;
+  return priv->surface ? gdk_surface_get_display (priv->surface) : NULL;
 }

 /**
@@ -294,11 +294,8 @@ gdk_drop_finalize (GObject *object)

  /* someone forgot to send a LEAVE signal */
  g_warn_if_fail (!priv->entered);
-
  /* Should we emit finish() here if necessary?
-   * For now that's the backends' job
-   */
-  g_warn_if_fail (priv->state != GDK_DROP_STATE_DROPPING);
+   * For now that's the backends' job */

  g_clear_object (&priv->device);
  g_clear_object (&priv->drag);
@@ -574,7 +571,7 @@ gdk_drop_get_drag (GdkDrop *self)
 * the ones provided by [method@Gdk.Drop.get_actions]. Those actions may
 * change in the future, even depending on the actions you provide here.
 *
- * The @preferred action is a hint to the drag-and-drop mechanism about which
+ * The @preferred action is a hint to the drag'n'drop mechanism about which
 * action to use when multiple actions are possible.
 *
 * This function should be called by drag destinations in response to
@@ -865,7 +862,7 @@ gdk_drop_read_value_internal (GdkDrop             *self,
 * then call [method@Gdk.Drop.read_value_finish] to get the resulting
 * `GValue`.
 *
- * For local drag-and-drop operations that are available in the given
+ * For local drag'n'drop operations that are available in the given
 * `GType`, the value will be copied directly. Otherwise, GDK will
 * try to use [func@Gdk.content_deserialize_async] to convert the data.
 */
@@ -89,6 +89,8 @@
 #include <epoxy/gl.h>

 typedef struct {
+  GdkGLContext *shared_context;
+
  int major;
  int minor;
  int gl_version;
@@ -125,28 +127,7 @@ G_DEFINE_QUARK (gdk-gl-error-quark, gdk_gl_error)

 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkGLContext, gdk_gl_context, GDK_TYPE_DRAW_CONTEXT)

-typedef struct _MaskedContext MaskedContext;
-
-static inline MaskedContext *
-mask_context (GdkGLContext *context,
-              gboolean      surfaceless)
-{
-  return (MaskedContext *) GSIZE_TO_POINTER (GPOINTER_TO_SIZE (context) | (surfaceless ? 1 : 0));
-}
-
-static inline GdkGLContext *
-unmask_context (MaskedContext *mask)
-{
-  return GDK_GL_CONTEXT (GSIZE_TO_POINTER (GPOINTER_TO_SIZE (mask) & ~(gsize) 1));
-}
-
-static void
-unref_unmasked (gpointer data)
-{
-  g_object_unref (unmask_context (data));
-}
-
-static GPrivate thread_current_context = G_PRIVATE_INIT (unref_unmasked);
+static GPrivate thread_current_context = G_PRIVATE_INIT (g_object_unref);

 static void
 gdk_gl_context_clear_old_updated_area (GdkGLContext *context)
@@ -163,14 +144,17 @@ static void
 gdk_gl_context_dispose (GObject *gobject)
 {
  GdkGLContext *context = GDK_GL_CONTEXT (gobject);
-  MaskedContext *current;
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
+  GdkGLContext *current;

  gdk_gl_context_clear_old_updated_area (context);

  current = g_private_get (&thread_current_context);
-  if (unmask_context (current) == context)
+  if (current == context)
    g_private_replace (&thread_current_context, NULL);

+  g_clear_object (&priv->shared_context);
+
  G_OBJECT_CLASS (gdk_gl_context_parent_class)->dispose (gobject);
 }

@@ -190,10 +174,17 @@ gdk_gl_context_set_property (GObject      *gobject,
                             const GValue *value,
                             GParamSpec   *pspec)
 {
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private ((GdkGLContext *) gobject);
+
  switch (prop_id)
    {
    case PROP_SHARED_CONTEXT:
-      g_assert (g_value_get_object (value) == NULL);
+      {
+        GdkGLContext *context = g_value_get_object (value);
+
+        if (context != NULL)
+          priv->shared_context = g_object_ref (context);
+      }
      break;

    default:
@@ -207,10 +198,12 @@ gdk_gl_context_get_property (GObject    *gobject,
                             GValue     *value,
                             GParamSpec *pspec)
 {
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private ((GdkGLContext *) gobject);
+
  switch (prop_id)
    {
    case PROP_SHARED_CONTEXT:
-      g_value_set_object (value, NULL);
+      g_value_set_object (value, priv->shared_context);
      break;

    default:
@@ -340,27 +333,23 @@ gdk_gl_context_real_get_damage (GdkGLContext *context)
                                        });
 }

-static gboolean
-gdk_gl_context_real_is_shared (GdkGLContext *self,
-                               GdkGLContext *other)
-{
-  if (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (self)) != gdk_draw_context_get_display (GDK_DRAW_CONTEXT (other)))
-    return FALSE;
-
-  /* XXX: Should we check es or legacy here? */
-
-  return TRUE;
-}
-
 static void
 gdk_gl_context_real_begin_frame (GdkDrawContext *draw_context,
                                 cairo_region_t *region)
 {
  GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
  GdkSurface *surface;
+  GdkGLContext *shared;
  cairo_region_t *damage;
  int ww, wh;

+  shared = gdk_gl_context_get_shared_context (context);
+  if (shared)
+    {
+      GDK_DRAW_CONTEXT_GET_CLASS (GDK_DRAW_CONTEXT (shared))->begin_frame (GDK_DRAW_CONTEXT (shared), region);
+      return;
+    }
+
  damage = GDK_GL_CONTEXT_GET_CLASS (context)->get_damage (context);

  if (context->old_updated_area[1])
@@ -390,6 +379,15 @@ static void
 gdk_gl_context_real_end_frame (GdkDrawContext *draw_context,
                               cairo_region_t *painted)
 {
+  GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
+  GdkGLContext *shared;
+
+  shared = gdk_gl_context_get_shared_context (context);
+  if (shared)
+    {
+      GDK_DRAW_CONTEXT_GET_CLASS (GDK_DRAW_CONTEXT (shared))->end_frame (GDK_DRAW_CONTEXT (shared), painted);
+      return;
+    }
 }

 static void
@@ -408,7 +406,6 @@ gdk_gl_context_class_init (GdkGLContextClass *klass)

  klass->realize = gdk_gl_context_real_realize;
  klass->get_damage = gdk_gl_context_real_get_damage;
-  klass->is_shared = gdk_gl_context_real_is_shared;

  draw_context_class->begin_frame = gdk_gl_context_real_begin_frame;
  draw_context_class->end_frame = gdk_gl_context_real_end_frame;
@@ -417,13 +414,7 @@ gdk_gl_context_class_init (GdkGLContextClass *klass)
  /**
   * GdkGLContext:shared-context: (attributes org.gtk.Property.get=gdk_gl_context_get_shared_context)
   *
-   * Always %NULL
-   *
-   * As many contexts can share data now and no single shared context exists
-   * anymore, this function has been deprecated and now always returns %NULL.
-   *
-   * Deprecated: 4.4: Use [method@Gdk.GLContext.is_shared] to check if contexts
-   *   can be shared.
+   * The `GdkGLContext` that this context is sharing data with, or %NULL
   */
  obj_pspecs[PROP_SHARED_CONTEXT] =
    g_param_spec_object ("shared-context",
@@ -432,8 +423,7 @@ gdk_gl_context_class_init (GdkGLContextClass *klass)
                         GDK_TYPE_GL_CONTEXT,
                         G_PARAM_READWRITE |
                         G_PARAM_CONSTRUCT_ONLY |
-                         G_PARAM_STATIC_STRINGS |
-                         G_PARAM_DEPRECATED);
+                         G_PARAM_STATIC_STRINGS);

  gobject_class->set_property = gdk_gl_context_set_property;
  gobject_class->get_property = gdk_gl_context_get_property;
@@ -451,21 +441,6 @@ gdk_gl_context_init (GdkGLContext *self)
  priv->use_es = -1;
 }

-/* Must have called gdk_display_prepare_gl() before */
-GdkGLContext *
-gdk_gl_context_new_for_surface (GdkSurface *surface)
-{
-  GdkDisplay *display = gdk_surface_get_display (surface);
-  GdkGLContext *shared = gdk_display_get_gl_context (display);
-
-  /* assert gdk_display_prepare_gl() had been called */
-  g_assert (shared);
-
-  return g_object_new (G_OBJECT_TYPE (shared),
-                       "surface", surface,
-                       NULL);
-}
-
 GdkGLContextPaintData *
 gdk_gl_context_get_paint_data (GdkGLContext *context)
 {
@@ -837,42 +812,6 @@ gdk_gl_context_set_is_legacy (GdkGLContext *context,
  priv->is_legacy = !!is_legacy;
 }

-/**
- * gdk_gl_context_is_shared:
- * @self: a `GdkGLContext`
- * @other: the `GdkGLContext` that should be compatible with @self
- *
- * Checks if the two GL contexts can share resources.
- *
- * When they can, the texture IDs from @other can be used in @self. This
- * is particularly useful when passing `GdkGLTexture` objects between
- * different contexts.
- *
- * Contexts created for the same display with the same properties will
- * always be compatible, even if they are created for different surfaces.
- * For other contexts it depends on the GL backend.
- *
- * Both contexts must be realized for this check to succeed. If either one
- * is not, this function will return %FALSE.
- *
- * Returns: %TRUE if the two GL contexts are compatible.
- */
-gboolean
-gdk_gl_context_is_shared (GdkGLContext *self,
-                          GdkGLContext *other)
-{
-  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
-  GdkGLContextPrivate *priv_other = gdk_gl_context_get_instance_private (other);
-
-  g_return_val_if_fail (GDK_IS_GL_CONTEXT (self), FALSE);
-  g_return_val_if_fail (GDK_IS_GL_CONTEXT (other), FALSE);
-
-  if (!priv->realized || !priv_other->realized)
-    return FALSE;
-
-  return GDK_GL_CONTEXT_GET_CLASS (self)->is_shared (self, other);
-}
-
 /**
 * gdk_gl_context_set_use_es:
 * @context: a `GdkGLContext`
@@ -1153,16 +1092,12 @@ void
 gdk_gl_context_make_current (GdkGLContext *context)
 {
  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
-  MaskedContext *current, *masked_context;
-  gboolean surfaceless;
+  GdkGLContext *current;

  g_return_if_fail (GDK_IS_GL_CONTEXT (context));

-  surfaceless = !gdk_draw_context_is_in_frame (GDK_DRAW_CONTEXT (context));
-  masked_context = mask_context (context, surfaceless);
-
  current = g_private_get (&thread_current_context);
-  if (current == masked_context)
+  if (current == context)
    return;

  /* we need to realize the GdkGLContext if it wasn't explicitly realized */
@@ -1179,15 +1114,11 @@ gdk_gl_context_make_current (GdkGLContext *context)
        }
    }

-  if (!GDK_GL_CONTEXT_GET_CLASS (context)->make_current (context, surfaceless))
+  if (gdk_display_make_gl_context_current (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context)), context))
    {
-      g_warning ("gdk_gl_context_make_current() failed");
-      return;
+      g_private_replace (&thread_current_context, g_object_ref (context));
+      gdk_gl_context_check_extensions (context);
    }
-
-  g_object_ref (context);
-  g_private_replace (&thread_current_context, masked_context);
-  gdk_gl_context_check_extensions (context);
 }

 /**
@@ -1226,22 +1157,18 @@ gdk_gl_context_get_surface (GdkGLContext *context)
 * gdk_gl_context_get_shared_context: (attributes org.gtk.Method.get_property=shared-context)
 * @context: a `GdkGLContext`
 *
- * Used to retrieves the `GdkGLContext` that this @context share data with.
+ * Retrieves the `GdkGLContext` that this @context share data with.
 *
- * As many contexts can share data now and no single shared context exists
- * anymore, this function has been deprecated and now always returns %NULL.
- *
- * Returns: (nullable) (transfer none): %NULL
- *
- * Deprecated: 4.4: Use [method@Gdk.GLContext.is_shared] to check if contexts
- *   can be shared.
+ * Returns: (nullable) (transfer none): a `GdkGLContext`
 */
 GdkGLContext *
 gdk_gl_context_get_shared_context (GdkGLContext *context)
 {
+  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
+
  g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);

-  return NULL;
+  return priv->shared_context;
 }

 /**
@@ -1281,14 +1208,12 @@ gdk_gl_context_get_version (GdkGLContext *context,
 void
 gdk_gl_context_clear_current (void)
 {
-  MaskedContext *current;
+  GdkGLContext *current;

  current = g_private_get (&thread_current_context);
  if (current != NULL)
    {
-      GdkGLContext *context = unmask_context (current);
-
-      if (GDK_GL_CONTEXT_GET_CLASS (context)->clear_current (context))
+      if (gdk_display_make_gl_context_current (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (current)), NULL))
        g_private_replace (&thread_current_context, NULL);
    }
 }
@@ -1303,11 +1228,11 @@ gdk_gl_context_clear_current (void)
 GdkGLContext *
 gdk_gl_context_get_current (void)
 {
-  MaskedContext *current;
+  GdkGLContext *current;

  current = g_private_get (&thread_current_context);

-  return unmask_context (current);
+  return current;
 }

 gboolean
@@ -45,8 +45,8 @@ GType gdk_gl_context_get_type (void) G_GNUC_CONST;
 GDK_AVAILABLE_IN_ALL
 GdkDisplay *            gdk_gl_context_get_display              (GdkGLContext  *context);
 GDK_AVAILABLE_IN_ALL
-GdkSurface *            gdk_gl_context_get_surface               (GdkGLContext  *context);
-GDK_DEPRECATED_IN_4_4_FOR(gdk_gl_context_is_shared)
+GdkSurface *             gdk_gl_context_get_surface               (GdkGLContext  *context);
+GDK_AVAILABLE_IN_ALL
 GdkGLContext *          gdk_gl_context_get_shared_context       (GdkGLContext  *context);
 GDK_AVAILABLE_IN_ALL
 void                    gdk_gl_context_get_version              (GdkGLContext  *context,
@@ -54,9 +54,6 @@ void                    gdk_gl_context_get_version              (GdkGLContext  *
                                                                 int           *minor);
 GDK_AVAILABLE_IN_ALL
 gboolean                gdk_gl_context_is_legacy                (GdkGLContext  *context);
-GDK_AVAILABLE_IN_4_4
-gboolean                gdk_gl_context_is_shared                (GdkGLContext  *self,
-                                                                 GdkGLContext  *other);

 GDK_AVAILABLE_IN_ALL
 void                    gdk_gl_context_set_required_version     (GdkGLContext  *context,
@@ -27,13 +27,6 @@

 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)
-
 #define GDK_GL_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GL_CONTEXT, GdkGLContextClass))
 #define GDK_IS_GL_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GL_CONTEXT))
 #define GDK_GL_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GL_CONTEXT, GdkGLContextClass))
@@ -52,16 +45,10 @@ struct _GdkGLContextClass
 {
  GdkDrawContextClass parent_class;

-  gboolean              (* realize)                             (GdkGLContext          *context,
-                                                                 GError               **error);
+  gboolean (* realize) (GdkGLContext *context,
+                        GError **error);

-  gboolean              (* make_current)                        (GdkGLContext          *context,
-                                                                 gboolean               surfaceless);
-  gboolean              (* clear_current)                       (GdkGLContext          *context);
-  cairo_region_t *      (* get_damage)                          (GdkGLContext          *context);
-
-  gboolean              (* is_shared)                           (GdkGLContext          *self,
-                                                                 GdkGLContext          *other);
+  cairo_region_t * (* get_damage) (GdkGLContext *context);
 };

 typedef struct {
@@ -86,8 +73,6 @@ typedef struct {
  guint use_es : 1;
 } GdkGLContextPaintData;

-GdkGLContext *          gdk_gl_context_new_for_surface          (GdkSurface      *surface);
-
 void                    gdk_gl_context_set_is_legacy            (GdkGLContext    *context,
                                                                 gboolean         is_legacy);

@@ -1066,22 +1066,86 @@ gdk_surface_get_mapped (GdkSurface *surface)
 }

 GdkGLContext *
-gdk_surface_get_paint_gl_context (GdkSurface  *surface,
-                                  GError     **error)
+gdk_surface_get_shared_data_gl_context (GdkSurface *surface)
 {
-  if (!gdk_display_prepare_gl (surface->display, error))
+  static int in_shared_data_creation;
+  GdkDisplay *display;
+  GdkGLContext *context;
+
+  if (in_shared_data_creation)
    return NULL;

+  in_shared_data_creation = 1;
+
+  display = gdk_surface_get_display (surface);
+  context = (GdkGLContext *)g_object_get_data (G_OBJECT (display), "gdk-gl-shared-data-context");
+  if (context == NULL)
+    {
+      GError *error = NULL;
+      context = GDK_SURFACE_GET_CLASS (surface)->create_gl_context (surface, FALSE, NULL, &error);
+      if (context == NULL)
+        {
+          g_warning ("Failed to create shared context: %s", error->message);
+          g_clear_error (&error);
+        }
+
+      gdk_gl_context_realize (context, &error);
+      if (context == NULL)
+        {
+          g_warning ("Failed to realize shared context: %s", error->message);
+          g_clear_error (&error);
+        }
+
+
+      g_object_set_data (G_OBJECT (display), "gdk-gl-shared-data-context", context);
+    }
+
+  in_shared_data_creation = 0;
+
+  return context;
+}
+
+GdkGLContext *
+gdk_surface_get_paint_gl_context (GdkSurface  *surface,
+                                  GError    **error)
+{
+  GError *internal_error = NULL;
+
+  if (GDK_DISPLAY_DEBUG_CHECK (surface->display, GL_DISABLE))
+    {
+      g_set_error_literal (error, GDK_GL_ERROR,
+                           GDK_GL_ERROR_NOT_AVAILABLE,
+                           _("GL support disabled via GDK_DEBUG"));
+      return NULL;
+    }
+
  if (surface->gl_paint_context == NULL)
    {
-      surface->gl_paint_context = gdk_surface_create_gl_context (surface, error);
-      if (surface->gl_paint_context == NULL)
-        return NULL;
+      GdkSurfaceClass *class = GDK_SURFACE_GET_CLASS (surface);
+
+      if (class->create_gl_context == NULL)
+        {
+          g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
+                               _("The current backend does not support OpenGL"));
+          return NULL;
+        }
+
+      surface->gl_paint_context =
+        class->create_gl_context (surface, TRUE, NULL, &internal_error);
    }

-  if (!gdk_gl_context_realize (surface->gl_paint_context, error))
+  if (internal_error != NULL)
    {
-      g_clear_object (&surface->gl_paint_context);
+      g_propagate_error (error, internal_error);
+      g_clear_object (&(surface->gl_paint_context));
+      return NULL;
+    }
+
+  gdk_gl_context_realize (surface->gl_paint_context, &internal_error);
+  if (internal_error != NULL)
+    {
+      g_propagate_error (error, internal_error);
+      g_clear_object (&(surface->gl_paint_context));
      return NULL;
    }

@@ -1106,13 +1170,19 @@ GdkGLContext *
 gdk_surface_create_gl_context (GdkSurface   *surface,
                               GError      **error)
 {
+  GdkGLContext *paint_context;
+
  g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

-  if (!gdk_display_prepare_gl (surface->display, error))
+  paint_context = gdk_surface_get_paint_gl_context (surface, error);
+  if (paint_context == NULL)
    return NULL;

-  return gdk_gl_context_new_for_surface (surface);
+  return GDK_SURFACE_GET_CLASS (surface)->create_gl_context (surface,
+                                                             FALSE,
+                                                             paint_context,
+                                                             error);
 }

 /**
@@ -160,6 +160,10 @@ struct _GdkSurfaceClass

  void         (* set_opaque_region)      (GdkSurface      *surface,
                                           cairo_region_t *region);
+  GdkGLContext *(*create_gl_context)      (GdkSurface      *surface,
+                                           gboolean        attached,
+                                           GdkGLContext   *share,
+                                           GError        **error);
  void         (* request_layout)         (GdkSurface     *surface);
  gboolean     (* compute_size)           (GdkSurface     *surface);
 };
@@ -262,6 +266,7 @@ void       _gdk_surface_update_size       (GdkSurface      *surface);

 GdkGLContext * gdk_surface_get_paint_gl_context (GdkSurface *surface,
                                                 GError   **error);
+GdkGLContext * gdk_surface_get_shared_data_gl_context (GdkSurface *surface);

 gboolean gdk_surface_handle_event (GdkEvent       *event);
 GdkSeat * gdk_surface_get_seat_from_event (GdkSurface *surface,
@@ -533,7 +533,7 @@ gdk_texture_get_render_data (GdkTexture  *self,
 /**
 * gdk_texture_save_to_png:
 * @texture: a `GdkTexture`
- * @filename: (type filename): the filename to store to
+ * @filename: the filename to store to
 *
 * Store the given @texture to the @filename as a PNG file.
 *
@@ -28,9 +28,7 @@
 #import "GdkMacosGLView.h"
 #import "GdkMacosWindow.h"

-#include "gdkmacosclipboard-private.h"
 #include "gdkmacosdisplay-private.h"
-#include "gdkmacosdrop-private.h"
 #include "gdkmacosmonitor-private.h"
 #include "gdkmacossurface-private.h"
 #include "gdkmacospopupsurface-private.h"
@@ -289,9 +287,6 @@ typedef NSString *CALayerContentsGravity;
  [self setContentView:view];
  [view release];

-  /* TODO: We might want to make this more extensible at some point */
-  _gdk_macos_clipboard_register_drag_types (self);
-
  return self;
 }

@@ -602,86 +597,25 @@ typedef NSString *CALayerContentsGravity;

 -(NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 {
-  NSPoint location = [sender draggingLocation];
-  NSDragOperation ret;
-  GdkMacosDrop *drop;
-
-  if (!(drop = _gdk_macos_drop_new ([self gdkSurface], sender)))
-    return NSDragOperationNone;
-
-  _gdk_macos_display_set_drop ([self gdkDisplay],
-                               [sender draggingSequenceNumber],
-                               GDK_DROP (drop));
-
-  gdk_drop_emit_enter_event (GDK_DROP (drop),
-                             TRUE,
-                             location.x,
-                             GDK_SURFACE (gdk_surface)->height - location.y,
-                             GDK_CURRENT_TIME);
-
-  ret = _gdk_macos_drop_operation (drop);
-
-  g_object_unref (drop);
-
-  return ret;
+  return NSDragOperationNone;
 }

 -(void)draggingEnded:(id <NSDraggingInfo>)sender
 {
-  _gdk_macos_display_set_drop ([self gdkDisplay], [sender draggingSequenceNumber], NULL);
 }

 -(void)draggingExited:(id <NSDraggingInfo>)sender
 {
-  NSInteger sequence_number = [sender draggingSequenceNumber];
-  GdkDrop *drop = _gdk_macos_display_find_drop ([self gdkDisplay], sequence_number);
-
-  if (drop != NULL)
-    gdk_drop_emit_leave_event (drop, TRUE, GDK_CURRENT_TIME);
-
-  _gdk_macos_display_set_drop ([self gdkDisplay], sequence_number, NULL);
 }

 -(NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 {
-  NSInteger sequence_number = [sender draggingSequenceNumber];
-  GdkDisplay *display = gdk_surface_get_display (GDK_SURFACE (gdk_surface));
-  GdkDrop *drop = _gdk_macos_display_find_drop (GDK_MACOS_DISPLAY (display), sequence_number);
-  NSPoint location = [sender draggingLocation];
-
-  if (drop == NULL)
-    return NSDragOperationNone;
-
-  _gdk_macos_drop_update_actions (GDK_MACOS_DROP (drop), sender);
-
-  gdk_drop_emit_motion_event (drop,
-                              TRUE,
-                              location.x,
-                              GDK_SURFACE (gdk_surface)->height - location.y,
-                              GDK_CURRENT_TIME);
-
-  return _gdk_macos_drop_operation (GDK_MACOS_DROP (drop));
+  return NSDragOperationNone;
 }

 -(BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 {
-  NSInteger sequence_number = [sender draggingSequenceNumber];
-  GdkDisplay *display = gdk_surface_get_display (GDK_SURFACE (gdk_surface));
-  GdkDrop *drop = _gdk_macos_display_find_drop (GDK_MACOS_DISPLAY (display), sequence_number);
-  NSPoint location = [sender draggingLocation];
-
-  if (drop == NULL)
-    return NO;
-
-  gdk_drop_emit_drop_event (drop,
-                            TRUE,
-                            location.x,
-                            GDK_SURFACE (gdk_surface)->height - location.y,
-                            GDK_CURRENT_TIME);
-
-  gdk_drop_emit_leave_event (drop, TRUE, GDK_CURRENT_TIME);
-
-  return GDK_MACOS_DROP (drop)->finish_action != 0;
+  return YES;
 }

 -(BOOL)wantsPeriodicDraggingUpdates
@@ -35,24 +35,11 @@ typedef NSString *NSPasteboardType;

 G_DECLARE_FINAL_TYPE (GdkMacosClipboard, _gdk_macos_clipboard, GDK, MACOS_CLIPBOARD, GdkClipboard)

-GdkClipboard      *_gdk_macos_clipboard_new                       (GdkMacosDisplay      *display);
-void               _gdk_macos_clipboard_check_externally_modified (GdkMacosClipboard    *self);
-NSPasteboardType   _gdk_macos_clipboard_to_ns_type                (const char           *mime_type,
-                                                                   NSPasteboardType     *alternate);
-const char        *_gdk_macos_clipboard_from_ns_type              (NSPasteboardType      ns_type);
-void               _gdk_macos_clipboard_register_drag_types       (NSWindow             *window);
-GdkContentFormats *_gdk_macos_pasteboard_load_formats             (NSPasteboard         *pasteboard);
-void               _gdk_macos_pasteboard_read_async               (GObject              *object,
-                                                                   NSPasteboard         *pasteboard,
-                                                                   GdkContentFormats    *formats,
-                                                                   int                   io_priority,
-                                                                   GCancellable         *cancellable,
-                                                                   GAsyncReadyCallback   callback,
-                                                                   gpointer              user_data);
-GInputStream      *_gdk_macos_pasteboard_read_finish              (GObject              *object,
-                                                                   GAsyncResult         *result,
-                                                                   const char          **out_mime_type,
-                                                                   GError              **error);
+GdkClipboard     *_gdk_macos_clipboard_new                       (GdkMacosDisplay   *display);
+void              _gdk_macos_clipboard_check_externally_modified (GdkMacosClipboard *self);
+NSPasteboardType  _gdk_macos_clipboard_to_ns_type                (const char        *mime_type,
+                                                                  NSPasteboardType  *alternate);
+const char       *_gdk_macos_clipboard_from_ns_type              (NSPasteboardType   ns_type);

@interface GdkMacosClipboardDataProvider : NSObject <NSPasteboardItemDataProvider>
 {
@@ -172,15 +172,17 @@ populate_content_formats (GdkContentFormatsBuilder *builder,
 }

 static GdkContentFormats *
-load_offer_formats (NSPasteboard *pasteboard)
+load_offer_formats (GdkMacosClipboard *self)
 {
  GDK_BEGIN_MACOS_ALLOC_POOL;

  GdkContentFormatsBuilder *builder;
  GdkContentFormats *formats;

+  g_assert (GDK_IS_MACOS_CLIPBOARD (self));
+
  builder = gdk_content_formats_builder_new ();
-  for (NSPasteboardType type in [pasteboard types])
+  for (NSPasteboardType type in [self->pasteboard types])
    populate_content_formats (builder, type);
  formats = gdk_content_formats_builder_free_to_formats (builder);

@@ -199,7 +201,7 @@ _gdk_macos_clipboard_load_contents (GdkMacosClipboard *self)

  change_count = [self->pasteboard changeCount];

-  formats = load_offer_formats (self->pasteboard);
+  formats = load_offer_formats (self);
  gdk_clipboard_claim_remote (GDK_CLIPBOARD (self), formats);
  gdk_content_formats_unref (formats);

@@ -223,13 +225,125 @@ _gdk_macos_clipboard_read_async (GdkClipboard        *clipboard,
                                 GAsyncReadyCallback  callback,
                                 gpointer             user_data)
 {
-  _gdk_macos_pasteboard_read_async (G_OBJECT (clipboard),
-                                    GDK_MACOS_CLIPBOARD (clipboard)->pasteboard,
-                                    formats,
-                                    io_priority,
-                                    cancellable,
-                                    callback,
-                                    user_data);
+  GDK_BEGIN_MACOS_ALLOC_POOL;
+
+  GdkMacosClipboard *self = (GdkMacosClipboard *)clipboard;
+  GdkContentFormats *offer_formats = NULL;
+  const char *mime_type;
+  GInputStream *stream = NULL;
+  GTask *task = NULL;
+
+  g_assert (GDK_IS_MACOS_CLIPBOARD (self));
+  g_assert (formats != NULL);
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_source_tag (task, _gdk_macos_clipboard_read_async);
+  g_task_set_priority (task, io_priority);
+
+  offer_formats = load_offer_formats (GDK_MACOS_CLIPBOARD (clipboard));
+  mime_type = gdk_content_formats_match_mime_type (formats, offer_formats);
+
+  if (mime_type == NULL)
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               G_IO_ERROR_NOT_SUPPORTED,
+                               "%s",
+                               _("No compatible transfer format found"));
+      goto cleanup;
+    }
+
+  if (strcmp (mime_type, "text/plain;charset=utf-8") == 0)
+    {
+      NSString *nsstr = [self->pasteboard stringForType:NSPasteboardTypeString];
+
+      if (nsstr != NULL)
+        {
+          const char *str = [nsstr UTF8String];
+          stream = g_memory_input_stream_new_from_data (g_strdup (str),
+                                                        strlen (str) + 1,
+                                                        g_free);
+        }
+    }
+  else if (strcmp (mime_type, "text/uri-list") == 0)
+    {
+      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
+
+      if ([[self->pasteboard types] containsObject:PTYPE(FILE_URL)])
+        {
+          GString *str = g_string_new (NULL);
+          NSArray *files = [self->pasteboard propertyListForType:NSFilenamesPboardType];
+          gsize n_files = [files count];
+          char *data;
+          guint len;
+
+          for (gsize i = 0; i < n_files; ++i)
+            {
+              NSString* uriString = [files objectAtIndex:i];
+              uriString = [@"file://" stringByAppendingString:uriString];
+              uriString = [uriString stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+
+              g_string_append_printf (str,
+                                      "%s\r\n",
+                                      [uriString cStringUsingEncoding:NSUTF8StringEncoding]);
+            }
+
+          len = str->len;
+          data = g_string_free (str, FALSE);
+          stream = g_memory_input_stream_new_from_data (data, len, g_free);
+        }
+
+      G_GNUC_END_IGNORE_DEPRECATIONS;
+    }
+  else if (strcmp (mime_type, "application/x-color") == 0)
+    {
+      NSColorSpace *colorspace;
+      NSColor *nscolor;
+      guint16 color[4];
+
+      colorspace = [NSColorSpace genericRGBColorSpace];
+      nscolor = [[NSColor colorFromPasteboard:self->pasteboard]
+                    colorUsingColorSpace:colorspace];
+
+      color[0] = 0xffff * [nscolor redComponent];
+      color[1] = 0xffff * [nscolor greenComponent];
+      color[2] = 0xffff * [nscolor blueComponent];
+      color[3] = 0xffff * [nscolor alphaComponent];
+
+      stream = g_memory_input_stream_new_from_data (g_memdup2 (&color, sizeof color),
+                                                    sizeof color,
+                                                    g_free);
+    }
+  else if (strcmp (mime_type, "image/tiff") == 0)
+    {
+      NSData *data = [self->pasteboard dataForType:PTYPE(TIFF)];
+      stream = create_stream_from_nsdata (data);
+    }
+  else if (strcmp (mime_type, "image/png") == 0)
+    {
+      NSData *data = [self->pasteboard dataForType:PTYPE(PNG)];
+      stream = create_stream_from_nsdata (data);
+    }
+
+  if (stream != NULL)
+    {
+      g_task_set_task_data (task, g_strdup (mime_type), g_free);
+      g_task_return_pointer (task, g_steal_pointer (&stream), g_object_unref);
+    }
+  else
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               G_IO_ERROR_FAILED,
+                               _("Failed to decode contents with mime-type of '%s'"),
+                               mime_type);
+    }
+
+cleanup:
+  g_clear_object (&task);
+  g_clear_pointer (&offer_formats, gdk_content_formats_unref);
+
+  GDK_END_MACOS_ALLOC_POOL;
 }

 static GInputStream *
@@ -238,7 +352,15 @@ _gdk_macos_clipboard_read_finish (GdkClipboard  *clipboard,
                                  const char   **out_mime_type,
                                  GError       **error)
 {
-  return _gdk_macos_pasteboard_read_finish (G_OBJECT (clipboard), result, out_mime_type, error);
+  GTask *task = (GTask *)result;
+
+  g_assert (GDK_IS_MACOS_CLIPBOARD (clipboard));
+  g_assert (G_IS_TASK (task));
+
+  if (out_mime_type != NULL)
+    *out_mime_type = g_strdup (g_task_get_task_data (task));
+
+  return g_task_propagate_pointer (task, error);
 }

 static void
@@ -500,170 +622,4 @@ on_data_ready_cb (GObject      *object,
  write_request_free (wr);
 }

-void
-_gdk_macos_clipboard_register_drag_types (NSWindow *window)
-{
-  [window registerForDraggedTypes:[NSArray arrayWithObjects:PTYPE(STRING),
-                                                            PTYPE(PBOARD),
-                                                            PTYPE(URL),
-                                                            PTYPE(FILE_URL),
-                                                            PTYPE(COLOR),
-                                                            PTYPE(TIFF),
-                                                            PTYPE(PNG),
-                                                            nil]];
-}
-
@end
-
-GdkContentFormats *
-_gdk_macos_pasteboard_load_formats (NSPasteboard *pasteboard)
-{
-  return load_offer_formats (pasteboard);
-}
-
-void
-_gdk_macos_pasteboard_read_async (GObject             *object,
-                                  NSPasteboard        *pasteboard,
-                                  GdkContentFormats   *formats,
-                                  int                  io_priority,
-                                  GCancellable        *cancellable,
-                                  GAsyncReadyCallback  callback,
-                                  gpointer             user_data)
-{
-  GDK_BEGIN_MACOS_ALLOC_POOL;
-
-  GdkContentFormats *offer_formats = NULL;
-  const char *mime_type;
-  GInputStream *stream = NULL;
-  GTask *task = NULL;
-
-  g_assert (G_IS_OBJECT (object));
-  g_assert (pasteboard != NULL);
-  g_assert (formats != NULL);
-
-  task = g_task_new (object, cancellable, callback, user_data);
-  g_task_set_source_tag (task, _gdk_macos_pasteboard_read_async);
-  g_task_set_priority (task, io_priority);
-
-  offer_formats = load_offer_formats (pasteboard);
-  mime_type = gdk_content_formats_match_mime_type (formats, offer_formats);
-
-  if (mime_type == NULL)
-    {
-      g_task_return_new_error (task,
-                               G_IO_ERROR,
-                               G_IO_ERROR_NOT_SUPPORTED,
-                               "%s",
-                               _("No compatible transfer format found"));
-      goto cleanup;
-    }
-
-  if (strcmp (mime_type, "text/plain;charset=utf-8") == 0)
-    {
-      NSString *nsstr = [pasteboard stringForType:NSPasteboardTypeString];
-
-      if (nsstr != NULL)
-        {
-          const char *str = [nsstr UTF8String];
-          stream = g_memory_input_stream_new_from_data (g_strdup (str),
-                                                        strlen (str) + 1,
-                                                        g_free);
-        }
-    }
-  else if (strcmp (mime_type, "text/uri-list") == 0)
-    {
-      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
-
-      if ([[pasteboard types] containsObject:PTYPE(FILE_URL)])
-        {
-          GString *str = g_string_new (NULL);
-          NSArray *files = [pasteboard propertyListForType:NSFilenamesPboardType];
-          gsize n_files = [files count];
-          char *data;
-          guint len;
-
-          for (gsize i = 0; i < n_files; ++i)
-            {
-              NSString* uriString = [files objectAtIndex:i];
-              uriString = [@"file://" stringByAppendingString:uriString];
-              uriString = [uriString stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
-
-              g_string_append_printf (str,
-                                      "%s\r\n",
-                                      [uriString cStringUsingEncoding:NSUTF8StringEncoding]);
-            }
-
-          len = str->len;
-          data = g_string_free (str, FALSE);
-          stream = g_memory_input_stream_new_from_data (data, len, g_free);
-        }
-
-      G_GNUC_END_IGNORE_DEPRECATIONS;
-    }
-  else if (strcmp (mime_type, "application/x-color") == 0)
-    {
-      NSColorSpace *colorspace;
-      NSColor *nscolor;
-      guint16 color[4];
-
-      colorspace = [NSColorSpace genericRGBColorSpace];
-      nscolor = [[NSColor colorFromPasteboard:pasteboard]
-                    colorUsingColorSpace:colorspace];
-
-      color[0] = 0xffff * [nscolor redComponent];
-      color[1] = 0xffff * [nscolor greenComponent];
-      color[2] = 0xffff * [nscolor blueComponent];
-      color[3] = 0xffff * [nscolor alphaComponent];
-
-      stream = g_memory_input_stream_new_from_data (g_memdup2 (&color, sizeof color),
-                                                    sizeof color,
-                                                    g_free);
-    }
-  else if (strcmp (mime_type, "image/tiff") == 0)
-    {
-      NSData *data = [pasteboard dataForType:PTYPE(TIFF)];
-      stream = create_stream_from_nsdata (data);
-    }
-  else if (strcmp (mime_type, "image/png") == 0)
-    {
-      NSData *data = [pasteboard dataForType:PTYPE(PNG)];
-      stream = create_stream_from_nsdata (data);
-    }
-
-  if (stream != NULL)
-    {
-      g_task_set_task_data (task, g_strdup (mime_type), g_free);
-      g_task_return_pointer (task, g_steal_pointer (&stream), g_object_unref);
-    }
-  else
-    {
-      g_task_return_new_error (task,
-                               G_IO_ERROR,
-                               G_IO_ERROR_FAILED,
-                               _("Failed to decode contents with mime-type of '%s'"),
-                               mime_type);
-    }
-
-cleanup:
-  g_clear_object (&task);
-  g_clear_pointer (&offer_formats, gdk_content_formats_unref);
-
-  GDK_END_MACOS_ALLOC_POOL;
-}
-
-GInputStream *
-_gdk_macos_pasteboard_read_finish (GObject       *object,
-                                   GAsyncResult  *result,
-                                   const char   **out_mime_type,
-                                   GError       **error)
-{
-  GTask *task = (GTask *)result;
-
-  g_assert (G_IS_OBJECT (object));
-  g_assert (G_IS_TASK (task));
-
-  if (out_mime_type != NULL)
-    *out_mime_type = g_strdup (g_task_get_task_data (task));
-
-  return g_task_propagate_pointer (task, error);
-}
@@ -81,10 +81,6 @@ struct _GdkMacosDisplay
  /* The surface that is receiving keyboard events */
  GdkMacosSurface *keyboard_surface;

-  /* [NSDraggingInfo draggingSequenceNumber] to GdkMacosDr(ag,op) */
-  GHashTable *active_drags;
-  GHashTable *active_drops;
-
  /* Used to translate from quartz coordinate space to GDK */
  int width;
  int height;
@@ -164,16 +160,6 @@ void             _gdk_macos_display_warp_pointer                   (GdkMacosDisp
                                                                    int              x,
                                                                    int              y);
 NSEvent         *_gdk_macos_display_get_nsevent                    (GdkEvent        *event);
-GdkDrag         *_gdk_macos_display_find_drag                      (GdkMacosDisplay *self,
-                                                                    NSInteger        sequence_number);
-GdkDrop         *_gdk_macos_display_find_drop                      (GdkMacosDisplay *self,
-                                                                    NSInteger        sequence_number);
-void             _gdk_macos_display_set_drag                       (GdkMacosDisplay *self,
-                                                                    NSInteger        sequence_number,
-                                                                    GdkDrag         *drag);
-void             _gdk_macos_display_set_drop                       (GdkMacosDisplay *self,
-                                                                    NSInteger        sequence_number,
-                                                                    GdkDrop         *drop);

 G_END_DECLS

@@ -788,9 +788,6 @@ get_surface_from_ns_event (GdkMacosDisplay *self,
      NSRect view_frame;

      view = (GdkMacosBaseView *)[nswindow contentView];
-      if (!GDK_IS_MACOS_BASE_VIEW (view))
-        goto find_under_pointer;
-
      surface = GDK_SURFACE ([view gdkSurface]);

      point = [nsevent locationInWindow];
@@ -849,8 +846,6 @@ get_surface_from_ns_event (GdkMacosDisplay *self,
        }
    }

-find_under_pointer:
-
  if (!surface)
    {
      /* Fallback used when no NSSurface set.  This happens e.g. when
@@ -869,24 +864,17 @@ find_under_pointer:
 static GdkMacosSurface *
 find_surface_for_keyboard_event (NSEvent *nsevent)
 {
-  NSView *nsview = [[nsevent window] contentView];
+  GdkMacosBaseView *view = (GdkMacosBaseView *)[[nsevent window] contentView];
+  GdkSurface *surface = GDK_SURFACE ([view gdkSurface]);
+  GdkDisplay *display = gdk_surface_get_display (surface);
+  GdkSeat *seat = gdk_display_get_default_seat (display);
+  GdkDevice *device = gdk_seat_get_keyboard (seat);
+  GdkDeviceGrabInfo *grab = _gdk_display_get_last_device_grab (display, device);

-  if (GDK_IS_MACOS_BASE_VIEW (nsview))
-    {
-      GdkMacosBaseView *view = (GdkMacosBaseView *)nsview;
-      GdkSurface *surface = GDK_SURFACE ([view gdkSurface]);
-      GdkDisplay *display = gdk_surface_get_display (surface);
-      GdkSeat *seat = gdk_display_get_default_seat (display);
-      GdkDevice *device = gdk_seat_get_keyboard (seat);
-      GdkDeviceGrabInfo *grab = _gdk_display_get_last_device_grab (display, device);
+  if (grab && grab->surface && !grab->owner_events)
+    return GDK_MACOS_SURFACE (grab->surface);

-      if (grab && grab->surface && !grab->owner_events)
-        return GDK_MACOS_SURFACE (grab->surface);
-
-      return GDK_MACOS_SURFACE (surface);
-    }
-
-  return NULL;
+  return GDK_MACOS_SURFACE (surface);
 }

 static GdkMacosSurface *
@@ -1102,8 +1090,7 @@ _gdk_macos_display_translate (GdkMacosDisplay *self,
  if (!(surface = find_surface_for_ns_event (self, nsevent, &x, &y)))
    return NULL;

-  if (!(window = (GdkMacosWindow *)_gdk_macos_surface_get_native (surface)) ||
-      !GDK_IS_MACOS_WINDOW (window))
+  if (!(window = (GdkMacosWindow *)_gdk_macos_surface_get_native (surface)))
    return NULL;

  /* Ignore events and break grabs while the window is being
@@ -31,8 +31,6 @@
 #include "gdkmacoscairocontext-private.h"
 #include "gdkmacoseventsource-private.h"
 #include "gdkmacosdisplay-private.h"
-#include "gdkmacosdrag-private.h"
-#include "gdkmacosdrop-private.h"
 #include "gdkmacosglcontext-private.h"
 #include "gdkmacoskeymap-private.h"
 #include "gdkmacosmonitor-private.h"
@@ -637,13 +635,17 @@ gdk_macos_display_load_clipboard (GdkMacosDisplay *self)
  GDK_DISPLAY (self)->clipboard = _gdk_macos_clipboard_new (self);
 }

-static GdkGLContext *
-gdk_macos_display_init_gl (GdkDisplay  *display,
-                           GError     **error)
+static gboolean
+gdk_macos_display_make_gl_context_current (GdkDisplay   *display,
+                                           GdkGLContext *gl_context)
 {
-  return g_object_new (GDK_TYPE_MACOS_GL_CONTEXT,
-                       "display", display,
-                       NULL);
+  g_assert (GDK_IS_MACOS_DISPLAY (display));
+  g_assert (!gl_context || GDK_IS_MACOS_GL_CONTEXT (gl_context));
+
+  if (gl_context == NULL)
+    return FALSE;
+
+  return _gdk_macos_gl_context_make_current (GDK_MACOS_GL_CONTEXT (gl_context));
 }

 static void
@@ -661,8 +663,6 @@ gdk_macos_display_finalize (GObject *object)
                                      CFSTR ("NSUserDefaultsDidChangeNotification"),
                                      NULL);

-  g_clear_pointer (&self->active_drags, g_hash_table_unref);
-  g_clear_pointer (&self->active_drops, g_hash_table_unref);
  g_clear_object (&GDK_DISPLAY (self)->clipboard);
  g_clear_pointer (&self->frame_source, g_source_unref);
  g_clear_object (&self->monitors);
@@ -691,7 +691,7 @@ gdk_macos_display_class_init (GdkMacosDisplayClass *klass)
  display_class->get_name = gdk_macos_display_get_name;
  display_class->get_setting = gdk_macos_display_get_setting;
  display_class->has_pending = gdk_macos_display_has_pending;
-  display_class->init_gl = gdk_macos_display_init_gl;
+  display_class->make_gl_context_current = gdk_macos_display_make_gl_context_current;
  display_class->notify_startup_complete = gdk_macos_display_notify_startup_complete;
  display_class->queue_events = gdk_macos_display_queue_events;
  display_class->sync = gdk_macos_display_sync;
@@ -701,8 +701,6 @@ static void
 gdk_macos_display_init (GdkMacosDisplay *self)
 {
  self->monitors = g_list_store_new (GDK_TYPE_MONITOR);
-  self->active_drags = g_hash_table_new_full (NULL, NULL, NULL, g_object_unref);
-  self->active_drops = g_hash_table_new_full (NULL, NULL, NULL, g_object_unref);

  gdk_display_set_composited (GDK_DISPLAY (self), TRUE);
  gdk_display_set_input_shapes (GDK_DISPLAY (self), FALSE);
@@ -1115,55 +1113,3 @@ _gdk_macos_display_get_nsevent (GdkEvent *event)

  return NULL;
 }
-
-GdkDrag *
-_gdk_macos_display_find_drag (GdkMacosDisplay *self,
-                              NSInteger        sequence_number)
-{
-  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (self), NULL);
-
-  return g_hash_table_lookup (self->active_drags, GSIZE_TO_POINTER (sequence_number));
-}
-
-void
-_gdk_macos_display_set_drag (GdkMacosDisplay *self,
-                             NSInteger        sequence_number,
-                             GdkDrag         *drag)
-{
-  g_return_if_fail (GDK_IS_MACOS_DISPLAY (self));
-  g_return_if_fail (!drag || GDK_IS_MACOS_DRAG (drag));
-
-  if (drag)
-    g_hash_table_insert (self->active_drags,
-                         GSIZE_TO_POINTER (sequence_number),
-                         g_object_ref (drag));
-  else
-    g_hash_table_remove (self->active_drags,
-                         GSIZE_TO_POINTER (sequence_number));
-}
-
-GdkDrop *
-_gdk_macos_display_find_drop (GdkMacosDisplay *self,
-                              NSInteger        sequence_number)
-{
-  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (self), NULL);
-
-  return g_hash_table_lookup (self->active_drops, GSIZE_TO_POINTER (sequence_number));
-}
-
-void
-_gdk_macos_display_set_drop (GdkMacosDisplay *self,
-                             NSInteger        sequence_number,
-                             GdkDrop         *drop)
-{
-  g_return_if_fail (GDK_IS_MACOS_DISPLAY (self));
-  g_return_if_fail (!drop || GDK_IS_MACOS_DROP (drop));
-
-  if (drop)
-    g_hash_table_insert (self->active_drops,
-                         GSIZE_TO_POINTER (sequence_number),
-                         g_object_ref (drop));
-  else
-    g_hash_table_remove (self->active_drops,
-                         GSIZE_TO_POINTER (sequence_number));
-}
@@ -326,10 +326,12 @@ gdk_drag_update (GdkDrag         *drag,
                                &suggested_action,
                                &possible_actions);

-  if (GDK_IS_MACOS_SURFACE (self->drag_surface))
-    _gdk_macos_surface_move (GDK_MACOS_SURFACE (self->drag_surface),
-                             x_root - self->hot_x,
-                             y_root - self->hot_y);
+  _gdk_macos_drag_surface_drag_motion (self->drag_surface,
+                                       x_root - self->hot_x,
+                                       y_root - self->hot_y,
+                                       suggested_action,
+                                       possible_actions,
+                                       evtime);

  if (!self->did_update)
    {
@@ -337,8 +339,6 @@ gdk_drag_update (GdkDrag         *drag,
      self->start_y = self->last_y;
      self->did_update = TRUE;
    }
-
-  gdk_drag_set_actions (drag, possible_actions);
 }

 static gboolean
@@ -31,13 +31,19 @@ typedef struct _GdkMacosDragSurfaceClass GdkMacosDragSurfaceClass;
 #define GDK_MACOS_DRAG_SURFACE(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_DRAG_SURFACE, GdkMacosDragSurface))
 #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);
+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);
+void             _gdk_macos_drag_surface_drag_motion (GdkMacosDragSurface *self,
+                                                      int                  x_root,
+                                                      int                  y_root,
+                                                      GdkDragAction        suggested_action,
+                                                      GdkDragAction        possible_actions,
+                                                      guint32              evtime);

 G_END_DECLS

@@ -123,3 +123,16 @@ _gdk_macos_drag_surface_new (GdkMacosDisplay *display,

  return g_steal_pointer (&self);
 }
+
+void
+_gdk_macos_drag_surface_drag_motion (GdkMacosDragSurface *self,
+                                     int                  x_root,
+                                     int                  y_root,
+                                     GdkDragAction        suggested_action,
+                                     GdkDragAction        possible_actions,
+                                     guint32              evtime)
+{
+  g_return_if_fail (GDK_IS_MACOS_DRAG_SURFACE (self));
+
+  _gdk_macos_surface_move (GDK_MACOS_SURFACE (self), x_root, y_root);
+}
@@ -1,66 +0,0 @@
-/*
- * Copyright © 2021 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef __GDK_MACOS_DROP_PRIVATE_H__
-#define __GDK_MACOS_DROP_PRIVATE_H__
-
-#include <AppKit/AppKit.h>
-
-#include "gdkdropprivate.h"
-
-#include "gdkmacossurface-private.h"
-
-G_BEGIN_DECLS
-
-#define GDK_TYPE_MACOS_DROP            (gdk_macos_drop_get_type ())
-#define GDK_MACOS_DROP(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_DROP, GdkMacosDrop))
-#define GDK_MACOS_DROP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MACOS_DROP, GdkMacosDropClass))
-#define GDK_IS_MACOS_DROP(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_DROP))
-#define GDK_IS_MACOS_DROP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MACOS_DROP))
-#define GDK_MACOS_DROP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MACOS_DROP, GdkMacosDropClass))
-
-typedef struct _GdkMacosDrop GdkMacosDrop;
-typedef struct _GdkMacosDropClass GdkMacosDropClass;
-
-struct _GdkMacosDrop
-{
-  GdkDrop parent_instance;
-
-  NSPasteboard *pasteboard;
-
-  GdkDragAction all_actions;
-  GdkDragAction preferred_action;
-  GdkDragAction finish_action;
-};
-
-struct _GdkMacosDropClass
-{
-  GdkDropClass parent_class;
-};
-
-GType             gdk_macos_drop_get_type       (void) G_GNUC_CONST;
-GdkMacosDrop    *_gdk_macos_drop_new            (GdkMacosSurface    *surface,
-                                                 id<NSDraggingInfo>  info);
-NSDragOperation  _gdk_macos_drop_operation      (GdkMacosDrop       *self);
-void             _gdk_macos_drop_update_actions (GdkMacosDrop       *self,
-                                                 id<NSDraggingInfo>  info);
-
-G_END_DECLS
-
-#endif /* __GDK_MACOS_DROP_PRIVATE_H__ */
@@ -1,183 +0,0 @@
-/*
- * Copyright © 2021 Red Hat, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#include "config.h"
-
-#include "gdkmacosclipboard-private.h"
-#include "gdkmacosdisplay-private.h"
-#include "gdkmacosdrag-private.h"
-#include "gdkmacosdrop-private.h"
-
-G_DEFINE_TYPE (GdkMacosDrop, gdk_macos_drop, GDK_TYPE_DROP)
-
-static void
-gdk_macos_drop_status (GdkDrop       *drop,
-                       GdkDragAction  actions,
-                       GdkDragAction  preferred)
-{
-  GdkMacosDrop *self = (GdkMacosDrop *)drop;
-
-  g_assert (GDK_IS_MACOS_DROP (self));
-
-  self->all_actions = actions;
-  self->preferred_action = preferred;
-}
-
-static void
-gdk_macos_drop_read_async (GdkDrop             *drop,
-                           GdkContentFormats   *content_formats,
-                           int                  io_priority,
-                           GCancellable        *cancellable,
-                           GAsyncReadyCallback  callback,
-                           gpointer             user_data)
-{
-  _gdk_macos_pasteboard_read_async (G_OBJECT (drop),
-                                    GDK_MACOS_DROP (drop)->pasteboard,
-                                    content_formats,
-                                    io_priority,
-                                    cancellable,
-                                    callback,
-                                    user_data);
-}
-
-static GInputStream *
-gdk_macos_drop_read_finish (GdkDrop       *drop,
-                            GAsyncResult  *result,
-                            const char   **out_mime_type,
-                            GError       **error)
-{
-  return _gdk_macos_pasteboard_read_finish (G_OBJECT (drop), result, out_mime_type, error);
-}
-
-static void
-gdk_macos_drop_finish (GdkDrop       *drop,
-                       GdkDragAction  action)
-{
-  g_assert (GDK_IS_MACOS_DROP (drop));
-
-  GDK_MACOS_DROP (drop)->finish_action = action;
-}
-
-static void
-gdk_macos_drop_finalize (GObject *object)
-{
-  GdkMacosDrop *self = (GdkMacosDrop *)object;
-
-  if (self->pasteboard)
-    {
-      [self->pasteboard release];
-      self->pasteboard = NULL;
-    }
-
-  G_OBJECT_CLASS (gdk_macos_drop_parent_class)->finalize (object);
-}
-
-static void
-gdk_macos_drop_class_init (GdkMacosDropClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  GdkDropClass *drop_class = GDK_DROP_CLASS (klass);
-
-  object_class->finalize = gdk_macos_drop_finalize;
-
-  drop_class->status = gdk_macos_drop_status;
-  drop_class->read_async = gdk_macos_drop_read_async;
-  drop_class->read_finish = gdk_macos_drop_read_finish;
-  drop_class->finish = gdk_macos_drop_finish;
-}
-
-static void
-gdk_macos_drop_init (GdkMacosDrop *self)
-{
-}
-
-void
-_gdk_macos_drop_update_actions (GdkMacosDrop       *self,
-                                id<NSDraggingInfo>  info)
-{
-  NSDragOperation op;
-  GdkDragAction actions = 0;
-
-  g_assert (GDK_IS_MACOS_DROP (self));
-
-  op = [info draggingSourceOperationMask];
-
-  if (op & NSDragOperationCopy)
-    actions |= GDK_ACTION_COPY;
-
-  if (op & NSDragOperationLink)
-    actions |= GDK_ACTION_LINK;
-
-  if (op & NSDragOperationMove)
-    actions |= GDK_ACTION_MOVE;
-
-  gdk_drop_set_actions (GDK_DROP (self), actions);
-}
-
-GdkMacosDrop *
-_gdk_macos_drop_new (GdkMacosSurface    *surface,
-                     id<NSDraggingInfo>  info)
-{
-  GdkDrag *drag = NULL;
-  GdkContentFormats *content_formats;
-  GdkMacosDrop *self;
-  GdkDisplay *display;
-  GdkDevice *device;
-  GdkSeat *seat;
-
-  g_return_val_if_fail (GDK_IS_MACOS_SURFACE (surface), NULL);
-  g_return_val_if_fail (info != NULL, NULL);
-
-  display = gdk_surface_get_display (GDK_SURFACE (surface));
-  seat = gdk_display_get_default_seat (display);
-  device = gdk_seat_get_pointer (seat);
-  drag = _gdk_macos_display_find_drag (GDK_MACOS_DISPLAY (display), [info draggingSequenceNumber]);
-
-  content_formats = _gdk_macos_pasteboard_load_formats ([info draggingPasteboard]);
-
-  self = g_object_new (GDK_TYPE_MACOS_DROP,
-                       "device", device,
-                       "drag", drag,
-                       "formats", content_formats,
-                       "surface", surface,
-                       NULL);
-
-  self->pasteboard = [[info draggingPasteboard] retain];
-
-  _gdk_macos_drop_update_actions (self, info);
-
-  gdk_content_formats_unref (content_formats);
-
-  return g_steal_pointer (&self);
-}
-
-NSDragOperation
-_gdk_macos_drop_operation (GdkMacosDrop *self)
-{
-  if (self->preferred_action & GDK_ACTION_LINK)
-    return NSDragOperationLink;
-
-  if (self->preferred_action & GDK_ACTION_MOVE)
-    return NSDragOperationMove;
-
-  if (self->preferred_action & GDK_ACTION_COPY)
-    return NSDragOperationCopy;
-  
-  return NSDragOperationNone;
-}
@@ -19,14 +19,12 @@
 #ifndef __GDK_MACOS_GL_CONTEXT_PRIVATE_H__
 #define __GDK_MACOS_GL_CONTEXT_PRIVATE_H__

-#include "gdkmacosglcontext.h"
-
 #include "gdkglcontextprivate.h"
 #include "gdkdisplayprivate.h"
 #include "gdksurface.h"
 #include "gdkinternals.h"

-#include "gdkmacosdisplay.h"
+#include "gdkmacosglcontext.h"
 #include "gdkmacossurface.h"

 #import <OpenGL/OpenGL.h>
@@ -57,6 +55,11 @@ struct _GdkMacosGLContextClass
  GdkGLContextClass parent_class;
 };

+GdkGLContext *_gdk_macos_gl_context_new          (GdkMacosSurface    *surface,
+                                                  gboolean            attached,
+                                                  GdkGLContext       *share,
+                                                  GError            **error);
+gboolean      _gdk_macos_gl_context_make_current (GdkMacosGLContext  *self);

 G_END_DECLS

@@ -145,7 +145,6 @@ ensure_gl_view (GdkMacosGLContext *self)
      [nsview setPostsFrameChangedNotifications: YES];
      [nsview setNeedsDisplay:YES];
      [nswindow setContentView:nsview];
-      [nswindow makeFirstResponder:nsview];
      [nsview release];

      if (self->dummy_view != NULL)
@@ -170,12 +169,12 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,
 {
  GdkMacosGLContext *self = (GdkMacosGLContext *)context;
  GdkSurface *surface;
-  GdkDisplay *display;
  NSOpenGLContext *shared_gl_context = nil;
  NSOpenGLContext *gl_context;
  NSOpenGLPixelFormat *pixelFormat;
  CGLContextObj cgl_context;
  GdkGLContext *shared;
+  GdkGLContext *shared_data;
  NSOpenGLContext *existing;
  GLint sync_to_framerate = 1;
  GLint validate = 0;
@@ -192,16 +191,21 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,
  gdk_gl_context_get_required_version (context, &major, &minor);

  surface = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
-  display = gdk_gl_context_get_display (context);
-  shared = gdk_display_get_gl_context (display);
+  shared = gdk_gl_context_get_shared_context (context);
+  shared_data = gdk_surface_get_shared_data_gl_context (surface);

  if (shared != NULL)
    {
      if (!(shared_gl_context = get_ns_open_gl_context (GDK_MACOS_GL_CONTEXT (shared), error)))
        return FALSE;
    }
+  else if (shared_data != NULL)
+    {
+      if (!(shared_gl_context = get_ns_open_gl_context (GDK_MACOS_GL_CONTEXT (shared_data), error)))
+        return FALSE;
+    }

-  GDK_DISPLAY_NOTE (display,
+  GDK_DISPLAY_NOTE (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context)),
                    OPENGL,
                    g_message ("Creating NSOpenGLContext (version %d.%d)",
                               major, minor));
@@ -248,7 +252,7 @@ gdk_macos_gl_context_real_realize (GdkGLContext  *context,

  GLint renderer_id = 0;
  [gl_context getValues:&renderer_id forParameter:NSOpenGLContextParameterCurrentRendererID];
-  GDK_DISPLAY_NOTE (display,
+  GDK_DISPLAY_NOTE (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context)),
                    OPENGL,
                    g_message ("Created NSOpenGLContext[%p] using %s",
                               gl_context,
@@ -310,7 +314,9 @@ gdk_macos_gl_context_begin_frame (GdkDrawContext *context,
   * want to replace our damage region for the next frame (to avoid
   * doing it multiple times).
   */
-  ensure_gl_view (self);
+  if (!self->is_attached &&
+      gdk_gl_context_get_shared_context (GDK_GL_CONTEXT (context)))
+    ensure_gl_view (self);

  if (self->needs_resize)
    {
@@ -403,57 +409,6 @@ gdk_macos_gl_context_surface_resized (GdkDrawContext *draw_context)
  g_clear_pointer (&self->damage, cairo_region_destroy);
 }

-static gboolean
-gdk_macos_gl_context_clear_current (GdkGLContext *context)
-{
-  GdkMacosGLContext *self = GDK_MACOS_GL_CONTEXT (context);
-  NSOpenGLContext *current;
-
-  g_return_val_if_fail (GDK_IS_MACOS_GL_CONTEXT (self), FALSE);
-
-  current = [NSOpenGLContext currentContext];
-
-  if (self->gl_context == current)
-    {
-      /* The OpenGL mac programming guide suggests that glFlush() is called
-       * before switching current contexts to ensure that the drawing commands
-       * are submitted.
-       */
-      if (current != NULL)
-        glFlush ();
-
-      [NSOpenGLContext clearCurrentContext];
-    }
-
-  return TRUE;
-}
-
-static gboolean
-gdk_macos_gl_context_make_current (GdkGLContext *context,
-                                   gboolean      surfaceless)
-{
-  GdkMacosGLContext *self = GDK_MACOS_GL_CONTEXT (context);
-  NSOpenGLContext *current;
-
-  g_return_val_if_fail (GDK_IS_MACOS_GL_CONTEXT (self), FALSE);
-
-  current = [NSOpenGLContext currentContext];
-
-  if (self->gl_context != current)
-    {
-      /* The OpenGL mac programming guide suggests that glFlush() is called
-       * before switching current contexts to ensure that the drawing commands
-       * are submitted.
-       */
-      if (current != NULL)
-        glFlush ();
-
-      [self->gl_context makeCurrentContext];
-    }
-
-  return TRUE;
-}
-
 static cairo_region_t *
 gdk_macos_gl_context_get_damage (GdkGLContext *context)
 {
@@ -522,4 +477,52 @@ gdk_macos_gl_context_init (GdkMacosGLContext *self)
 {
 }

+GdkGLContext *
+_gdk_macos_gl_context_new (GdkMacosSurface  *surface,
+                           gboolean          attached,
+                           GdkGLContext     *share,
+                           GError          **error)
+{
+  GdkMacosGLContext *context;
+
+  g_return_val_if_fail (GDK_IS_MACOS_SURFACE (surface), NULL);
+  g_return_val_if_fail (!share || GDK_IS_MACOS_GL_CONTEXT (share), NULL);
+
+  context = g_object_new (GDK_TYPE_MACOS_GL_CONTEXT,
+                          "surface", surface,
+                          "shared-context", share,
+                          NULL);
+
+  context->is_attached = !!attached;
+
+  return GDK_GL_CONTEXT (context);
+}
+
+gboolean
+_gdk_macos_gl_context_make_current (GdkMacosGLContext *self)
+{
+  NSOpenGLContext *current;
+
+  g_return_val_if_fail (GDK_IS_MACOS_GL_CONTEXT (self), FALSE);
+
+  if (self->gl_context == NULL)
+    return FALSE;
+
+  current = [NSOpenGLContext currentContext];
+
+  if (self->gl_context != current)
+    {
+      /* The OpenGL mac programming guide suggests that glFlush() is called
+       * before switching current contexts to ensure that the drawing commands
+       * are submitted.
+       */
+      if (current != NULL)
+        glFlush ();
+
+      [self->gl_context makeCurrentContext];
+    }
+
+  return TRUE;
+}
+
 G_GNUC_END_IGNORE_DEPRECATIONS
@@ -348,7 +348,7 @@ _gdk_macos_seat_new (GdkMacosDisplay *display)

  init_devices (self);

-  return GDK_SEAT (g_steal_pointer (&self));
+  return g_steal_pointer (&self);
 }

 static GdkDeviceToolType
@@ -332,7 +332,7 @@ gdk_macos_surface_drag_begin (GdkSurface         *surface,
  drag_surface = _gdk_macos_surface_new (GDK_MACOS_DISPLAY (surface->display),
                                         GDK_SURFACE_TEMP,
                                         surface,
-                                         sx, sy, 1, 1);
+                                         -99, -99, 1, 1);
  drag = g_object_new (GDK_TYPE_MACOS_DRAG,
                       "drag-surface", drag_surface,
                       "surface", surface,
@@ -358,6 +358,20 @@ gdk_macos_surface_drag_begin (GdkSurface         *surface,
  return GDK_DRAG (g_steal_pointer (&drag));
 }

+static GdkGLContext *
+gdk_macos_surface_create_gl_context (GdkSurface    *surface,
+                                     gboolean       attached,
+                                     GdkGLContext  *share,
+                                     GError       **error)
+{
+  GdkMacosSurface *self = (GdkMacosSurface *)surface;
+
+  g_assert (GDK_IS_MACOS_SURFACE (self));
+  g_assert (!share || GDK_IS_GL_CONTEXT (share));
+
+  return _gdk_macos_gl_context_new (self, attached, share, error);
+}
+
 static void
 gdk_macos_surface_destroy (GdkSurface *surface,
                           gboolean    foreign_destroy)
@@ -481,6 +495,7 @@ gdk_macos_surface_class_init (GdkMacosSurfaceClass *klass)
  object_class->get_property = gdk_macos_surface_get_property;
  object_class->set_property = gdk_macos_surface_set_property;

+  surface_class->create_gl_context = gdk_macos_surface_create_gl_context;
  surface_class->destroy = gdk_macos_surface_destroy;
  surface_class->drag_begin = gdk_macos_surface_drag_begin;
  surface_class->get_device_state = gdk_macos_surface_get_device_state;
@@ -10,7 +10,6 @@ gdk_macos_sources = files([
  'gdkmacosdisplay-settings.c',
  'gdkmacosdisplay-translate.c',
  'gdkmacosdrag.c',
-  'gdkmacosdrop.c',
  'gdkmacosdragsurface.c',
  'gdkmacosglcontext.c',
  'gdkmacoseventsource.c',
@@ -3093,11 +3093,6 @@ seat_handle_capabilities (void                    *data,
    }
  else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && seat->wl_pointer)
    {
-      g_clear_pointer (&seat->wp_pointer_gesture_swipe,
-                       zwp_pointer_gesture_swipe_v1_destroy);
-      g_clear_pointer (&seat->wp_pointer_gesture_pinch,
-                       zwp_pointer_gesture_pinch_v1_destroy);
-
      wl_pointer_release (seat->wl_pointer);
      seat->wl_pointer = NULL;
      gdk_seat_device_removed (GDK_SEAT (seat), seat->pointer);
@@ -432,12 +432,12 @@ gdk_registry_handle_global (void               *data,
      display_wayland->subcompositor =
        wl_registry_bind (display_wayland->wl_registry, id, &wl_subcompositor_interface, 1);
    }
-  else if (strcmp (interface, "zwp_pointer_gestures_v1") == 0)
+  else if (strcmp (interface, "zwp_pointer_gestures_v1") == 0 &&
+           version == GDK_ZWP_POINTER_GESTURES_V1_VERSION)
    {
      display_wayland->pointer_gestures =
        wl_registry_bind (display_wayland->wl_registry,
-                          id, &zwp_pointer_gestures_v1_interface,
-                          MIN (version, GDK_ZWP_POINTER_GESTURES_V1_VERSION));
+                          id, &zwp_pointer_gestures_v1_interface, version);
    }
  else if (strcmp (interface, "zwp_primary_selection_device_manager_v1") == 0)
    {
@@ -969,7 +969,7 @@ gdk_wayland_display_class_init (GdkWaylandDisplayClass *class)
  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;
+  display_class->make_gl_context_current = gdk_wayland_display_make_gl_context_current;

  display_class->get_monitors = gdk_wayland_display_get_monitors;
  display_class->get_monitor_at_surface = gdk_wayland_display_get_monitor_at_surface;
@@ -991,26 +991,6 @@ gdk_wayland_display_get_toplevel_surfaces (GdkDisplay *display)
  return GDK_WAYLAND_DISPLAY (display)->toplevels;
 }

-static struct wl_cursor_theme *
-try_load_theme (GdkWaylandDisplay *display_wayland,
-                const char        *dir,
-                gboolean           dotdir,
-                const char        *name,
-                int                size)
-{
-  struct wl_cursor_theme *theme = NULL;
-  char *path;
-
-  path = g_build_filename (dir, dotdir ? ".icons" : "icons", name, "cursors", NULL);
-
-  if (g_file_test (path, G_FILE_TEST_IS_DIR))
-    theme = wl_cursor_theme_create (path, size, display_wayland->shm);
-
-  g_free (path);
-
-  return theme;
-}
-
 static struct wl_cursor_theme *
 get_cursor_theme (GdkWaylandDisplay *display_wayland,
                  const char *name,
@@ -1020,18 +1000,16 @@ get_cursor_theme (GdkWaylandDisplay *display_wayland,
  struct wl_cursor_theme *theme = NULL;
  int i;

-  theme = try_load_theme (display_wayland, g_get_user_data_dir (), FALSE, name, size);
-  if (theme)
-    return theme;
-
-  theme = try_load_theme (display_wayland, g_get_home_dir (), TRUE, name, size);
-  if (theme)
-    return theme;
-
  xdg_data_dirs = g_get_system_data_dirs ();
  for (i = 0; xdg_data_dirs[i]; i++)
    {
-      theme = try_load_theme (display_wayland, xdg_data_dirs[i], FALSE, name, size);
+      char *path = g_build_filename (xdg_data_dirs[i], "icons", name, "cursors", NULL);
+
+      if (g_file_test (path, G_FILE_TEST_IS_DIR))
+        theme = wl_cursor_theme_create (path, size, display_wayland->shm);
+
+      g_free (path);
+
      if (theme)
        return theme;
    }
@@ -153,12 +153,14 @@ struct _GdkWaylandDisplay

  /* egl info */
  EGLDisplay egl_display;
-  EGLConfig egl_config;
  int egl_major_version;
  int egl_minor_version;

+  guint have_egl : 1;
+  guint have_egl_khr_create_context : 1;
  guint have_egl_buffer_age : 1;
  guint have_egl_swap_buffers_with_damage : 1;
+  guint have_egl_surfaceless_context : 1;
 };

 struct _GdkWaylandDisplayClass
@@ -163,7 +163,6 @@ gdk_wayland_drag_cancel (GdkDrag             *drag,
                         GdkDragCancelReason  reason)
 {
  gdk_drag_set_cursor (drag, NULL);
-  gdk_drag_drop_done (drag, FALSE);
 }

 static void
@@ -291,7 +290,6 @@ data_source_dnd_finished (void                  *data,
  GdkDrag *drag = data;

  g_signal_emit_by_name (drag, "dnd-finished");
-  gdk_drag_drop_done (drag, TRUE);
 }

 static void
@@ -22,9 +22,7 @@
 #include "config.h"

 #include "gdkglcontext-wayland.h"
-
 #include "gdkdisplay-wayland.h"
-#include "gdksurface-wayland.h"

 #include "gdkwaylanddisplay.h"
 #include "gdkwaylandglcontext.h"
@@ -55,14 +53,14 @@ gdk_wayland_gl_context_realize (GdkGLContext *context,
 {
  GdkWaylandGLContext *context_wayland = GDK_WAYLAND_GL_CONTEXT (context);
  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkGLContext *share = gdk_display_get_gl_context (display);
+  GdkGLContext *share = gdk_gl_context_get_shared_context (context);
+  GdkGLContext *shared_data_context = gdk_surface_get_shared_data_gl_context (gdk_gl_context_get_surface (context));
  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
  EGLContext ctx;
  EGLint context_attribs[N_EGL_ATTRS];
  int major, minor, flags;
  gboolean debug_bit, forward_bit, legacy_bit, use_es;
  int i = 0;
-  G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;

  gdk_gl_context_get_required_version (context, &major, &minor);
  debug_bit = gdk_gl_context_get_debug_enabled (context);
@@ -122,9 +120,10 @@ gdk_wayland_gl_context_realize (GdkGLContext *context,
                               use_es ? "yes" : "no"));

  ctx = eglCreateContext (display_wayland->egl_display,
-                          display_wayland->egl_config,
+                          context_wayland->egl_config,
                          share != NULL ? GDK_WAYLAND_GL_CONTEXT (share)->egl_context
-                                        : EGL_NO_CONTEXT,
+                             : shared_data_context != NULL ? GDK_WAYLAND_GL_CONTEXT (shared_data_context)->egl_context
+                                                  : EGL_NO_CONTEXT,
                          context_attribs);

  /* If context creation failed without the ES bit, let's try again with it */
@@ -148,9 +147,10 @@ gdk_wayland_gl_context_realize (GdkGLContext *context,
      GDK_DISPLAY_NOTE (display, OPENGL,
                g_message ("eglCreateContext failed, switching to OpenGL ES"));
      ctx = eglCreateContext (display_wayland->egl_display,
-                              display_wayland->egl_config,
+                              context_wayland->egl_config,
                              share != NULL ? GDK_WAYLAND_GL_CONTEXT (share)->egl_context
-                                            : EGL_NO_CONTEXT,
+                                 : shared_data_context != NULL ? GDK_WAYLAND_GL_CONTEXT (shared_data_context)->egl_context
+                                    : EGL_NO_CONTEXT,
                              context_attribs);
    }

@@ -177,9 +177,10 @@ gdk_wayland_gl_context_realize (GdkGLContext *context,
      GDK_DISPLAY_NOTE (display, OPENGL,
                g_message ("eglCreateContext failed, switching to legacy"));
      ctx = eglCreateContext (display_wayland->egl_display,
-                              display_wayland->egl_config,
+                              context_wayland->egl_config,
                              share != NULL ? GDK_WAYLAND_GL_CONTEXT (share)->egl_context
-                                            : EGL_NO_CONTEXT,
+                                 : shared_data_context != NULL ? GDK_WAYLAND_GL_CONTEXT (shared_data_context)->egl_context
+                                    : EGL_NO_CONTEXT,
                              context_attribs);
    }

@@ -198,8 +199,6 @@ gdk_wayland_gl_context_realize (GdkGLContext *context,
  gdk_gl_context_set_is_legacy (context, legacy_bit);
  gdk_gl_context_set_use_es (context, use_es);

-  gdk_profiler_end_mark (start_time, "realize GdkWaylandGLContext", NULL);
-
  return TRUE;
 }

@@ -214,8 +213,17 @@ gdk_wayland_gl_context_get_damage (GdkGLContext *context)

  if (display_wayland->have_egl_buffer_age)
    {
-      egl_surface = gdk_wayland_surface_get_egl_surface (surface);
-      gdk_gl_context_make_current (context);
+      GdkGLContext *shared;
+      GdkWaylandGLContext *shared_wayland;
+
+      shared = gdk_gl_context_get_shared_context (context);
+      if (shared == NULL)
+        shared = context;
+      shared_wayland = GDK_WAYLAND_GL_CONTEXT (shared);
+
+      egl_surface = gdk_wayland_surface_get_egl_surface (surface,
+                                                        shared_wayland->egl_config);
+      gdk_gl_context_make_current (shared);
      eglQuerySurface (display_wayland->egl_display, egl_surface,
                       EGL_BUFFER_AGE_EXT, &buffer_age);

@@ -248,47 +256,6 @@ gdk_wayland_gl_context_get_damage (GdkGLContext *context)
  return GDK_GL_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->get_damage (context);
 }

-static gboolean
-gdk_wayland_gl_context_clear_current (GdkGLContext *context)
-{
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
-
-  return eglMakeCurrent (display_wayland->egl_display,
-                         EGL_NO_SURFACE,
-                         EGL_NO_SURFACE,
-                         EGL_NO_CONTEXT);
-}
-
-static gboolean
-gdk_wayland_gl_context_make_current (GdkGLContext *context,
-                                     gboolean      surfaceless)
-{
-  GdkWaylandGLContext *context_wayland = GDK_WAYLAND_GL_CONTEXT (context);
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
-  EGLSurface egl_surface;
-
-  if (!surfaceless)
-    egl_surface = gdk_wayland_surface_get_egl_surface (gdk_gl_context_get_surface (context));
-  else
-    egl_surface = EGL_NO_SURFACE;
-
-  return eglMakeCurrent (display_wayland->egl_display,
-                         egl_surface,
-                         egl_surface,
-                         context_wayland->egl_context);
-}
-
-static void
-gdk_wayland_gl_context_begin_frame (GdkDrawContext *draw_context,
-                                    cairo_region_t *region)
-{
-  GDK_DRAW_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->begin_frame (draw_context, region);
-
-  glDrawBuffers (1, (GLenum[1]) { GL_BACK });
-}
-
 static void
 gdk_wayland_gl_context_end_frame (GdkDrawContext *draw_context,
                                  cairo_region_t *painted)
@@ -297,13 +264,18 @@ gdk_wayland_gl_context_end_frame (GdkDrawContext *draw_context,
  GdkSurface *surface = gdk_gl_context_get_surface (context);
  GdkDisplay *display = gdk_surface_get_display (surface);
  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
+  GdkWaylandGLContext *context_wayland = GDK_WAYLAND_GL_CONTEXT (context);
  EGLSurface egl_surface;

  GDK_DRAW_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->end_frame (draw_context, painted);
+  if (gdk_gl_context_get_shared_context (context))
+    return;

  gdk_gl_context_make_current (context);

-  egl_surface = gdk_wayland_surface_get_egl_surface (surface);
+  egl_surface = gdk_wayland_surface_get_egl_surface (surface,
+                                                    context_wayland->egl_config);
+
  gdk_wayland_surface_sync (surface);
  gdk_wayland_surface_request_frame (surface);

@@ -350,12 +322,9 @@ gdk_wayland_gl_context_class_init (GdkWaylandGLContextClass *klass)

  gobject_class->dispose = gdk_wayland_gl_context_dispose;

-  draw_context_class->begin_frame = gdk_wayland_gl_context_begin_frame;
  draw_context_class->end_frame = gdk_wayland_gl_context_end_frame;

  context_class->realize = gdk_wayland_gl_context_realize;
-  context_class->make_current = gdk_wayland_gl_context_make_current;
-  context_class->clear_current = gdk_wayland_gl_context_clear_current;
  context_class->get_damage = gdk_wayland_gl_context_get_damage;
 }

@@ -371,8 +340,6 @@ gdk_wayland_gl_context_init (GdkWaylandGLContext *self)
 * Retrieves the EGL display connection object for the given GDK display.
 *
 * Returns: (nullable): the EGL display
- *
- * Since: 4.4
 */
 gpointer
 gdk_wayland_display_get_egl_display (GdkDisplay *display)
@@ -381,7 +348,7 @@ gdk_wayland_display_get_egl_display (GdkDisplay *display)

  g_return_val_if_fail (GDK_IS_WAYLAND_DISPLAY (display), NULL);

-  if (!gdk_display_prepare_gl (display, NULL))
+  if (!gdk_wayland_display_init_gl (display))
    return NULL;

  display_wayland = GDK_WAYLAND_DISPLAY (display);
@@ -426,11 +393,71 @@ out:
  return dpy;
 }

+gboolean
+gdk_wayland_display_init_gl (GdkDisplay *display)
+{
+  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
+  EGLint major, minor;
+  EGLDisplay dpy;
+
+  if (display_wayland->have_egl)
+    return TRUE;
+
+  dpy = get_egl_display (display_wayland);
+
+  if (dpy == NULL)
+    return FALSE;
+
+  if (!eglInitialize (dpy, &major, &minor))
+    return FALSE;
+
+  if (!eglBindAPI (EGL_OPENGL_API))
+    return FALSE;
+
+  display_wayland->egl_display = dpy;
+  display_wayland->egl_major_version = major;
+  display_wayland->egl_minor_version = minor;
+
+  display_wayland->have_egl = TRUE;
+
+  display_wayland->have_egl_khr_create_context =
+    epoxy_has_egl_extension (dpy, "EGL_KHR_create_context");
+
+  display_wayland->have_egl_buffer_age =
+    epoxy_has_egl_extension (dpy, "EGL_EXT_buffer_age");
+
+  display_wayland->have_egl_swap_buffers_with_damage =
+    epoxy_has_egl_extension (dpy, "EGL_EXT_swap_buffers_with_damage");
+
+  display_wayland->have_egl_surfaceless_context =
+    epoxy_has_egl_extension (dpy, "EGL_KHR_surfaceless_context");
+
+  GDK_DISPLAY_NOTE (display, OPENGL,
+            g_message ("EGL API version %d.%d found\n"
+                       " - Vendor: %s\n"
+                       " - Version: %s\n"
+                       " - Client APIs: %s\n"
+                       " - Extensions:\n"
+                       "\t%s",
+                       display_wayland->egl_major_version,
+                       display_wayland->egl_minor_version,
+                       eglQueryString (dpy, EGL_VENDOR),
+                       eglQueryString (dpy, EGL_VERSION),
+                       eglQueryString (dpy, EGL_CLIENT_APIS),
+                       eglQueryString (dpy, EGL_EXTENSIONS)));
+
+  return TRUE;
+}
+
 #define MAX_EGL_ATTRS   30

-static EGLConfig
-get_eglconfig (EGLDisplay dpy)
+static gboolean
+find_eglconfig_for_surface (GdkSurface  *surface,
+                           EGLConfig  *egl_config_out,
+                           GError    **error)
 {
+  GdkDisplay *display = gdk_surface_get_display (surface);
+  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
  EGLint attrs[MAX_EGL_ATTRS];
  EGLint count;
  EGLConfig config;
@@ -455,129 +482,59 @@ get_eglconfig (EGLDisplay dpy)
  g_assert (i < MAX_EGL_ATTRS);

  /* Pick first valid configuration i guess? */
-  if (!eglChooseConfig (dpy, attrs, &config, 1, &count) || count < 1)
-    return NULL;
+  if (!eglChooseConfig (display_wayland->egl_display, attrs, &config, 1, &count) || count < 1)
+    {
+      g_set_error_literal (error, GDK_GL_ERROR,
+                           GDK_GL_ERROR_UNSUPPORTED_FORMAT,
+                           _("No available configurations for the given pixel format"));
+      return FALSE;
+    }

-  return config;
+  g_assert (egl_config_out);
+  *egl_config_out = config;
+
+  return TRUE;
 }

-#undef MAX_EGL_ATTRS
-
 GdkGLContext *
-gdk_wayland_display_init_gl (GdkDisplay  *display,
-                             GError     **error)
+gdk_wayland_surface_create_gl_context (GdkSurface     *surface,
+                                       gboolean       attached,
+                                       GdkGLContext  *share,
+                                       GError       **error)
 {
+  GdkDisplay *display = gdk_surface_get_display (surface);
  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
-  EGLint major, minor;
-  EGLDisplay dpy;
-  GdkGLContext *ctx;
-  G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
-  G_GNUC_UNUSED gint64 start_time2;
+  GdkWaylandGLContext *context;
+  EGLConfig config;

-  start_time2 = GDK_PROFILER_CURRENT_TIME;
-  dpy = get_egl_display (display_wayland);
-  gdk_profiler_end_mark (start_time, "get_egl_display", NULL);
-  if (dpy == NULL)
+  if (!gdk_wayland_display_init_gl (display))
    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Failed to create EGL display"));
-      return NULL;
-    }
-
-  start_time2 = GDK_PROFILER_CURRENT_TIME;
-  if (!eglInitialize (dpy, &major, &minor))
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Could not initialize EGL display"));
-      return NULL;
-    }
-  gdk_profiler_end_mark (start_time2, "eglInitialize", NULL);
-
-  if (major < GDK_EGL_MIN_VERSION_MAJOR ||
-      (major == GDK_EGL_MIN_VERSION_MAJOR && minor < GDK_EGL_MIN_VERSION_MINOR))
-    {
-      eglTerminate (dpy);
-      g_set_error (error, GDK_GL_ERROR,
-                   GDK_GL_ERROR_NOT_AVAILABLE,
-                   _("EGL version %d.%d is too old. GTK requires %d.%d"),
-                   major, minor, GDK_EGL_MIN_VERSION_MAJOR, GDK_EGL_MIN_VERSION_MINOR);
-      return NULL;
-    }
-
-  start_time2 = GDK_PROFILER_CURRENT_TIME;
-  if (!eglBindAPI (EGL_OPENGL_API))
-    {
-      eglTerminate (dpy);
      g_set_error_literal (error, GDK_GL_ERROR,
                           GDK_GL_ERROR_NOT_AVAILABLE,
                           _("No GL implementation is available"));
      return NULL;
    }
-  gdk_profiler_end_mark (start_time2, "eglBindAPI", NULL);

-  if (!epoxy_has_egl_extension (dpy, "EGL_KHR_create_context"))
+  if (!display_wayland->have_egl_khr_create_context)
    {
-      eglTerminate (dpy);
      g_set_error_literal (error, GDK_GL_ERROR,
                           GDK_GL_ERROR_UNSUPPORTED_PROFILE,
                           _("Core GL is not available on EGL implementation"));
      return NULL;
    }

-  if (!epoxy_has_egl_extension (dpy, "EGL_KHR_surfaceless_context"))
-    {
-      eglTerminate (dpy);
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_UNSUPPORTED_PROFILE,
-                           _("Surfaceless contexts are not supported on this EGL implementation"));
-      return NULL;
-    }
+  if (!find_eglconfig_for_surface (surface, &config, error))
+    return NULL;

-  start_time2 = GDK_PROFILER_CURRENT_TIME;
-  display_wayland->egl_config = get_eglconfig (dpy);
-  gdk_profiler_end_mark (start_time2, "get_eglconfig", NULL);
-  if (!display_wayland->egl_config)
-    {
-      eglTerminate (dpy);
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_UNSUPPORTED_FORMAT,
-                           _("No available configurations for the given pixel format"));
-      return NULL;
-    }
+  context = g_object_new (GDK_TYPE_WAYLAND_GL_CONTEXT,
+                          "surface", surface,
+                          "shared-context", share,
+                          NULL);

-  display_wayland->egl_display = dpy;
-  display_wayland->egl_major_version = major;
-  display_wayland->egl_minor_version = minor;
+  context->egl_config = config;
+  context->is_attached = attached;

-  display_wayland->have_egl_buffer_age =
-    epoxy_has_egl_extension (dpy, "EGL_EXT_buffer_age");
-
-  display_wayland->have_egl_swap_buffers_with_damage =
-    epoxy_has_egl_extension (dpy, "EGL_EXT_swap_buffers_with_damage");
-
-  GDK_DISPLAY_NOTE (display, OPENGL,
-            g_message ("EGL API version %d.%d found\n"
-                       " - Vendor: %s\n"
-                       " - Version: %s\n"
-                       " - Client APIs: %s\n"
-                       " - Extensions:\n"
-                       "\t%s",
-                       display_wayland->egl_major_version,
-                       display_wayland->egl_minor_version,
-                       eglQueryString (dpy, EGL_VENDOR),
-                       eglQueryString (dpy, EGL_VERSION),
-                       eglQueryString (dpy, EGL_CLIENT_APIS),
-                       eglQueryString (dpy, EGL_EXTENSIONS)));
-
-  ctx = g_object_new (GDK_TYPE_WAYLAND_GL_CONTEXT,
-                      "display", display,
-                      NULL);
-
-  gdk_profiler_end_mark (start_time, "init Wayland GL", NULL);
-
-  return ctx;
+  return GDK_GL_CONTEXT (context);
 }

 static void
@@ -606,3 +563,42 @@ gdk_wayland_gl_context_dispose (GObject *gobject)
  G_OBJECT_CLASS (gdk_wayland_gl_context_parent_class)->dispose (gobject);
 }

+gboolean
+gdk_wayland_display_make_gl_context_current (GdkDisplay   *display,
+                                             GdkGLContext *context)
+{
+  GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
+  GdkWaylandGLContext *context_wayland;
+  GdkSurface *surface;
+  EGLSurface egl_surface;
+
+  if (context == NULL)
+    {
+      eglMakeCurrent(display_wayland->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                     EGL_NO_CONTEXT);
+      return TRUE;
+    }
+
+  context_wayland = GDK_WAYLAND_GL_CONTEXT (context);
+  surface = gdk_gl_context_get_surface (context);
+
+  if (context_wayland->is_attached || gdk_draw_context_is_in_frame (GDK_DRAW_CONTEXT (context)))
+    egl_surface = gdk_wayland_surface_get_egl_surface (surface, context_wayland->egl_config);
+  else
+    {
+      if (display_wayland->have_egl_surfaceless_context)
+        egl_surface = EGL_NO_SURFACE;
+      else
+        egl_surface = gdk_wayland_surface_get_dummy_egl_surface (surface,
+                                                                 context_wayland->egl_config);
+    }
+
+  if (!eglMakeCurrent (display_wayland->egl_display, egl_surface,
+                       egl_surface, context_wayland->egl_context))
+    {
+      g_warning ("eglMakeCurrent failed");
+      return FALSE;
+    }
+
+  return TRUE;
+}
@@ -36,6 +36,8 @@ struct _GdkWaylandGLContext
  GdkGLContext parent_instance;

  EGLContext egl_context;
+  EGLConfig egl_config;
+  gboolean is_attached;
 };

 struct _GdkWaylandGLContextClass
@@ -43,8 +45,13 @@ struct _GdkWaylandGLContextClass
  GdkGLContextClass parent_class;
 };

-GdkGLContext *  gdk_wayland_display_init_gl                         (GdkDisplay        *display,
+gboolean        gdk_wayland_display_init_gl                         (GdkDisplay        *display);
+GdkGLContext *  gdk_wayland_surface_create_gl_context                (GdkSurface         *surface,
+								     gboolean           attach,
+                                                                     GdkGLContext      *share,
                                                                     GError           **error);
+gboolean        gdk_wayland_display_make_gl_context_current         (GdkDisplay        *display,
+                                                                     GdkGLContext      *context);

 G_END_DECLS

@@ -182,6 +182,11 @@ cairo_surface_t * _gdk_wayland_display_create_shm_surface (GdkWaylandDisplay *di
 struct wl_buffer *_gdk_wayland_shm_surface_get_wl_buffer (cairo_surface_t *surface);
 gboolean _gdk_wayland_is_shm_surface (cairo_surface_t *surface);

+EGLSurface gdk_wayland_surface_get_egl_surface (GdkSurface *surface,
+                                               EGLConfig config);
+EGLSurface gdk_wayland_surface_get_dummy_egl_surface (GdkSurface *surface,
+                                                     EGLConfig config);
+
 struct gtk_surface1 * gdk_wayland_surface_get_gtk_surface (GdkSurface *surface);

 void gdk_wayland_seat_set_global_cursor (GdkSeat   *seat,
@@ -103,6 +103,7 @@ struct _GdkWaylandSurface

    struct gtk_surface1  *gtk_surface;
    struct wl_egl_window *egl_window;
+    struct wl_egl_window *dummy_egl_window;
    struct zxdg_exported_v1 *xdg_exported;
    struct org_kde_kwin_server_decoration *server_decoration;
  } display_server;
@@ -110,6 +111,7 @@ struct _GdkWaylandSurface
  struct wl_event_queue *event_queue;

  EGLSurface egl_surface;
+  EGLSurface dummy_egl_surface;

  uint32_t reposition_token;
  uint32_t received_reposition_token;
@@ -2899,6 +2901,18 @@ gdk_wayland_surface_hide_surface (GdkSurface *surface)

  if (impl->display_server.wl_surface)
    {
+      if (impl->dummy_egl_surface)
+        {
+          eglDestroySurface (display_wayland->egl_display, impl->dummy_egl_surface);
+          impl->dummy_egl_surface = NULL;
+        }
+
+      if (impl->display_server.dummy_egl_window)
+        {
+          wl_egl_window_destroy (impl->display_server.dummy_egl_window);
+          impl->display_server.dummy_egl_window = NULL;
+        }
+
      if (impl->egl_surface)
        {
          eglDestroySurface (display_wayland->egl_display, impl->egl_surface);
@@ -4224,6 +4238,7 @@ gdk_wayland_surface_class_init (GdkWaylandSurfaceClass *klass)
  impl_class->drag_begin = _gdk_wayland_surface_drag_begin;
  impl_class->get_scale_factor = gdk_wayland_surface_get_scale_factor;
  impl_class->set_opaque_region = gdk_wayland_surface_set_opaque_region;
+  impl_class->create_gl_context = gdk_wayland_surface_create_gl_context;
  impl_class->request_layout = gdk_wayland_surface_request_layout;
  impl_class->compute_size = gdk_wayland_surface_compute_size;
 }
@@ -4289,7 +4304,8 @@ gdk_wayland_surface_get_wl_egl_window (GdkSurface *surface)
 }

 EGLSurface
-gdk_wayland_surface_get_egl_surface (GdkSurface *surface)
+gdk_wayland_surface_get_egl_surface (GdkSurface *surface,
+                                     EGLConfig   config)
 {
  GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
  GdkWaylandSurface *impl;
@@ -4304,12 +4320,35 @@ gdk_wayland_surface_get_egl_surface (GdkSurface *surface)
      egl_window = gdk_wayland_surface_get_wl_egl_window (surface);

      impl->egl_surface =
-        eglCreateWindowSurface (display->egl_display, display->egl_config, egl_window, NULL);
+        eglCreateWindowSurface (display->egl_display, config, egl_window, NULL);
    }

  return impl->egl_surface;
 }

+EGLSurface
+gdk_wayland_surface_get_dummy_egl_surface (GdkSurface *surface,
+                                           EGLConfig   config)
+{
+  GdkWaylandDisplay *display = GDK_WAYLAND_DISPLAY (gdk_surface_get_display (surface));
+  GdkWaylandSurface *impl;
+
+  g_return_val_if_fail (GDK_IS_WAYLAND_SURFACE (surface), NULL);
+
+  impl = GDK_WAYLAND_SURFACE (surface);
+
+  if (impl->dummy_egl_surface == NULL)
+    {
+      impl->display_server.dummy_egl_window =
+        wl_egl_window_create (impl->display_server.wl_surface, 1, 1);
+
+      impl->dummy_egl_surface =
+        eglCreateWindowSurface (display->egl_display, config, impl->display_server.dummy_egl_window, NULL);
+    }
+
+  return impl->dummy_egl_surface;
+}
+
 struct gtk_surface1 *
 gdk_wayland_surface_get_gtk_surface (GdkSurface *surface)
 {
@@ -22,9 +22,6 @@

 #include "gdkwaylandsurface.h"

-#include <wayland-egl.h>
-#include <epoxy/egl.h>
-
 G_BEGIN_DECLS

 void                     gdk_wayland_toplevel_set_dbus_properties       (GdkToplevel *toplevel,
@@ -41,6 +38,4 @@ void                     gdk_wayland_toplevel_announce_ssd              (GdkTopl
 gboolean                 gdk_wayland_toplevel_inhibit_idle              (GdkToplevel *toplevel);
 void                     gdk_wayland_toplevel_uninhibit_idle            (GdkToplevel *toplevel);

-EGLSurface               gdk_wayland_surface_get_egl_surface            (GdkSurface  *surface);
-
 G_END_DECLS
@@ -481,7 +481,6 @@ register_display_change_notification (GdkDisplay *display)
  wclass.lpszClassName = "GdkDisplayChange";
  wclass.lpfnWndProc = display_change_window_procedure;
  wclass.hInstance = _gdk_app_hmodule;
-  wclass.style = CS_OWNDC;

  klass = RegisterClass (&wclass);
  if (klass)
@@ -657,13 +656,6 @@ gdk_win32_display_dispose (GObject *object)

  if (display_win32->hwnd != NULL)
    {
-      if (display_win32->dummy_context_wgl.hglrc != NULL)
-        {
-          wglMakeCurrent (NULL, NULL);
-          wglDeleteContext (display_win32->dummy_context_wgl.hglrc);
-          display_win32->dummy_context_wgl.hglrc = NULL;
-        }
-
      DestroyWindow (display_win32->hwnd);
      display_win32->hwnd = NULL;
    }
@@ -990,32 +982,31 @@ _gdk_win32_check_on_arm64 (GdkWin32Display *display)
 }

 static void
-gdk_win32_display_init (GdkWin32Display *display_win32)
+gdk_win32_display_init (GdkWin32Display *display)
 {
  const char *scale_str = g_getenv ("GDK_SCALE");

-  display_win32->monitors = G_LIST_MODEL (g_list_store_new (GDK_TYPE_MONITOR));
+  display->monitors = G_LIST_MODEL (g_list_store_new (GDK_TYPE_MONITOR));

-  _gdk_win32_enable_hidpi (display_win32);
-  _gdk_win32_check_on_arm64 (display_win32);
+  _gdk_win32_enable_hidpi (display);
+  _gdk_win32_check_on_arm64 (display);

  /* if we have DPI awareness, set up fixed scale if set */
-  if (display_win32->dpi_aware_type != PROCESS_DPI_UNAWARE &&
+  if (display->dpi_aware_type != PROCESS_DPI_UNAWARE &&
      scale_str != NULL)
    {
-      display_win32->surface_scale = atol (scale_str);
+      display->surface_scale = atol (scale_str);

-      if (display_win32->surface_scale <= 0)
-        display_win32->surface_scale = 1;
+      if (display->surface_scale <= 0)
+        display->surface_scale = 1;

-      display_win32->has_fixed_scale = TRUE;
+      display->has_fixed_scale = TRUE;
    }
  else
-    display_win32->surface_scale =
-      gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL);
+    display->surface_scale = _gdk_win32_display_get_monitor_scale_factor (display, NULL, NULL, NULL);

-  _gdk_win32_display_init_cursors (display_win32);
-  gdk_win32_display_check_composited (display_win32);
+  _gdk_win32_display_init_cursors (display);
+  gdk_win32_display_check_composited (display);
 }

 void
@@ -1066,64 +1057,64 @@ gdk_win32_display_get_monitors (GdkDisplay *display)
 }

 guint
-gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *display_win32,
-                                            GdkSurface      *surface,
-                                            HMONITOR         hmonitor)
+_gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *win32_display,
+                                             HMONITOR         hmonitor,
+                                             HWND             hwnd,
+                                             int             *dpi)
 {
  gboolean is_scale_acquired = FALSE;
  gboolean use_dpi_for_monitor = FALSE;
  guint dpix, dpiy;

-  if (display_win32->have_at_least_win81)
+  if (win32_display->have_at_least_win81)
    {
-      if (surface != NULL && hmonitor == NULL)
-        hmonitor = MonitorFromWindow (GDK_SURFACE_HWND (surface),
-                                      MONITOR_DEFAULTTONEAREST);
-      if (hmonitor != NULL &&
-          display_win32->shcore_funcs.hshcore != NULL &&
-          display_win32->shcore_funcs.getDpiForMonitorFunc != NULL)
+      if (hmonitor != NULL)
        use_dpi_for_monitor = TRUE;
+
+      else
+        {
+          if (hwnd != NULL)
+            {
+              hmonitor = MonitorFromWindow (hwnd, MONITOR_DEFAULTTONEAREST);
+              use_dpi_for_monitor = TRUE;
+            }
+        }
    }

  if (use_dpi_for_monitor)
    {
      /* Use GetDpiForMonitor() for Windows 8.1+, when we have a HMONITOR */
-      if (display_win32->shcore_funcs.getDpiForMonitorFunc (hmonitor,
-                                                            MDT_EFFECTIVE_DPI,
-                                                           &dpix,
-                                                           &dpiy) == S_OK)
-        is_scale_acquired = TRUE;
+      if (win32_display->shcore_funcs.hshcore != NULL &&
+          win32_display->shcore_funcs.getDpiForMonitorFunc != NULL)
+        {
+          if (win32_display->shcore_funcs.getDpiForMonitorFunc (hmonitor,
+                                                                MDT_EFFECTIVE_DPI,
+                                                                &dpix,
+                                                                &dpiy) == S_OK)
+            {
+              is_scale_acquired = TRUE;
+            }
+        }
    }
  else
    {
      /* Go back to GetDeviceCaps() for Windows 8 and earlier, or when we don't
       * have a HMONITOR nor a HWND
       */
-      HDC hdc;
-
-      if (surface != NULL)
-        {
-          if (GDK_WIN32_SURFACE (surface)->hdc == NULL)
-            GDK_WIN32_SURFACE (surface)->hdc = GetDC (GDK_SURFACE_HWND (surface));
-
-          hdc = GDK_WIN32_SURFACE (surface)->hdc;
-        }
-      else
-        hdc = GetDC (NULL);
+      HDC hdc = GetDC (hwnd);

      /* in case we can't get the DC for the window, return 1 for the scale */
      if (hdc == NULL)
-        return 1;
+        {
+          if (dpi != NULL)
+            *dpi = USER_DEFAULT_SCREEN_DPI;
+
+          return 1;
+        }

      dpix = GetDeviceCaps (hdc, LOGPIXELSX);
      dpiy = GetDeviceCaps (hdc, LOGPIXELSY);
-
-      /*
-       * If surface is not NULL, the HDC should not be released, since surfaces have
-       * Win32 windows created with CS_OWNDC
-       */
-      if (surface == NULL)
-        ReleaseDC (NULL, hdc);
+      ReleaseDC (hwnd, hdc);

      is_scale_acquired = TRUE;
    }
@@ -1131,13 +1122,21 @@ gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *display_win32,
  if (is_scale_acquired)
    /* USER_DEFAULT_SCREEN_DPI = 96, in winuser.h */
    {
-      if (display_win32->has_fixed_scale)
-        return display_win32->surface_scale;
+      if (dpi != NULL)
+        *dpi = dpix;
+
+      if (win32_display->has_fixed_scale)
+        return win32_display->surface_scale;
      else
        return dpix / USER_DEFAULT_SCREEN_DPI > 1 ? dpix / USER_DEFAULT_SCREEN_DPI : 1;
    }
  else
-    return 1;
+    {
+      if (dpi != NULL)
+        *dpi = USER_DEFAULT_SCREEN_DPI;
+
+      return 1;
+  }
 }

 static gboolean
@@ -1148,85 +1147,6 @@ gdk_win32_display_get_setting (GdkDisplay  *display,
  return _gdk_win32_get_setting (name, value);
 }

-static gboolean
-gdk_win32_display_init_gl_backend (GdkDisplay  *display,
-                                   GError     **error)
-{
-#ifdef GDK_WIN32_ENABLE_EGL
-  if (GDK_DISPLAY_DEBUG_CHECK (display, GL_EGL))
-    return gdk_win32_display_init_egl (display, error);
-#endif
-  if (GDK_DISPLAY_DEBUG_CHECK (display, GL_WGL))
-    return gdk_win32_display_init_wgl (display, error);
-
-  /* No env vars set, do the regular GL initialization, first WGL and then EGL,
-   * as WGL is the more tried-and-tested configuration.
-   */
-
-  if (gdk_win32_display_init_wgl (display, error))
-    return TRUE;
-  g_clear_error (error);
-
-#ifdef GDK_WIN32_ENABLE_EGL
-  if (gdk_win32_display_init_egl (display, error))
-    return TRUE;
-#endif
-  g_clear_error (error);
-
-  return gdk_win32_display_init_wgl (display, error);
-}
-
-static GdkGLContext *
-gdk_win32_display_init_gl (GdkDisplay  *display,
-                           GError     **error)
-{
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-  GdkGLContext *gl_context = NULL;
-
-  if (!gdk_win32_display_init_gl_backend (display, error))
-    return NULL;
-
-#ifdef GDK_WIN32_ENABLE_EGL
-  if (display_win32->egl_disp)
-    gl_context = g_object_new (GDK_TYPE_WIN32_GL_CONTEXT_EGL, "display", display, NULL);
-  else
-#endif
-  if (display_win32->wgl_pixel_format != 0)
-    gl_context = g_object_new (GDK_TYPE_WIN32_GL_CONTEXT_WGL, "display", display, NULL);
-
-  g_return_val_if_fail (gl_context != NULL, NULL);
-
-  return gl_context;
-}
-
-/**
- * gdk_win32_display_get_egl_display:
- * @display: (type GdkWin32Display): a Win32 display
- *
- * Retrieves the EGL display connection object for the given GDK display.
- *
- * Returns: (nullable): the EGL display
- */
-gpointer
-gdk_win32_display_get_egl_display (GdkDisplay *display)
-{
-  GdkWin32Display *display_win32;
-
-  g_return_val_if_fail (GDK_IS_WIN32_DISPLAY (display), NULL);
-
-#ifdef GDK_WIN32_ENABLE_EGL
-  display_win32 = GDK_WIN32_DISPLAY (display);
-
-  if (display_win32->wgl_pixel_format != 0)
-    return NULL;
-
-  return display_win32->egl_disp;
-#else
-  /* no EGL support */
-  return NULL;
-#endif
-}
-
 static void
 gdk_win32_display_class_init (GdkWin32DisplayClass *klass)
 {
@@ -1252,6 +1172,7 @@ gdk_win32_display_class_init (GdkWin32DisplayClass *klass)
  display_class->create_surface = _gdk_win32_display_create_surface;

  display_class->get_keymap = _gdk_win32_display_get_keymap;
+  display_class->make_gl_context_current = _gdk_win32_display_make_gl_context_current;

  display_class->get_monitors = gdk_win32_display_get_monitors;

@@ -1262,7 +1183,6 @@ gdk_win32_display_class_init (GdkWin32DisplayClass *klass)

  display_class->get_setting = gdk_win32_display_get_setting;
  display_class->set_cursor_theme = gdk_win32_display_set_cursor_theme;
-  display_class->init_gl = gdk_win32_display_init_gl;

  _gdk_win32_surfaceing_init ();
 }
@@ -106,12 +106,6 @@ typedef struct _GdkWin32KernelCPUFuncs
  funcIsWow64Process2 isWow64Process2;
 } GdkWin32KernelCPUFuncs;

-typedef struct
-{
-  HDC hdc;
-  HGLRC hglrc;
-} GdkWin32GLDummyContextWGL;
-
 struct _GdkWin32Display
 {
  GdkDisplay display;
@@ -125,15 +119,15 @@ struct _GdkWin32Display
  HWND hwnd;

  /* WGL/OpenGL Items */
-  GdkWin32GLDummyContextWGL dummy_context_wgl;
-  int wgl_pixel_format;
+  guint have_wgl : 1;
  guint gl_version;
+  HWND gl_hwnd;

 #ifdef GDK_WIN32_ENABLE_EGL
  /* EGL (Angle) Items */
+  guint have_egl : 1;
  guint egl_version;
  EGLDisplay egl_disp;
-  EGLConfig egl_config;
  HDC hdc_egl_temp;
 #endif

@@ -191,9 +185,10 @@ GPtrArray *_gdk_win32_display_get_monitor_list (GdkWin32Display *display);

 void        gdk_win32_display_check_composited (GdkWin32Display *display);

-guint      gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *display_win32,
-                                                       GdkSurface      *surface,
-                                                       HMONITOR         hmonitor);
+guint      _gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *win32_display,
+                                                        HMONITOR         hmonitor,
+                                                        HWND             hwnd,
+                                                        int              *dpi);

 typedef struct _GdkWin32MessageFilter GdkWin32MessageFilter;

@@ -793,7 +793,7 @@ gdk_drag_new (GdkDisplay         *display,
              GdkDragProtocol     protocol)
 {
  GdkWin32Drag *drag_win32;
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
+  GdkWin32Display *win32_display = GDK_WIN32_DISPLAY (display);
  GdkDrag *drag;

  drag_win32 = g_object_new (GDK_TYPE_WIN32_DRAG,
@@ -805,10 +805,10 @@ gdk_drag_new (GdkDisplay         *display,

  drag = GDK_DRAG (drag_win32);

-  if (display_win32->has_fixed_scale)
-    drag_win32->scale = display_win32->surface_scale;
+  if (win32_display->has_fixed_scale)
+    drag_win32->scale = win32_display->surface_scale;
  else
-    drag_win32->scale = gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL);
+    drag_win32->scale = _gdk_win32_display_get_monitor_scale_factor (win32_display, NULL, NULL, NULL);

  drag_win32->protocol = protocol;

@@ -2345,8 +2345,8 @@ gdk_dnd_handle_motion_event (GdkDrag  *drag,
  state = gdk_event_get_modifier_state (event);
  gdk_event_get_position (event, &x, &y);

-  x_root = event->surface->x + x;
-  y_root = event->surface->y + y;
+  x_root = x + _gdk_offset_x;
+  y_root = y + _gdk_offset_y;

  if (drag_win32->drag_surface)
    move_drag_surface (drag, x_root, y_root);
@@ -177,7 +177,7 @@ gdk_drop_new (GdkDisplay        *display,
              GdkDragProtocol    protocol)
 {
  GdkWin32Drop *drop_win32;
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
+  GdkWin32Display *win32_display = GDK_WIN32_DISPLAY (display);

  drop_win32 = g_object_new (GDK_TYPE_WIN32_DROP,
                             "device", device,
@@ -186,10 +186,10 @@ gdk_drop_new (GdkDisplay        *display,
                             "surface", surface,
                             NULL);

-  if (display_win32->has_fixed_scale)
-    drop_win32->scale = display_win32->surface_scale;
+  if (win32_display->has_fixed_scale)
+    drop_win32->scale = win32_display->surface_scale;
  else
-    drop_win32->scale = gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL);
+    drop_win32->scale = _gdk_win32_display_get_monitor_scale_factor (win32_display, NULL, NULL, NULL);

  drop_win32->protocol = protocol;

@@ -2343,6 +2343,7 @@ gdk_event_translate (MSG *msg,
      current_root_x = (msg->pt.x + _gdk_offset_x) / impl->surface_scale;
      current_root_y = (msg->pt.y + _gdk_offset_y) / impl->surface_scale;

+
      if (impl->drag_move_resize_context.op != GDK_WIN32_DRAGOP_NONE)
        gdk_win32_surface_do_move_resize_drag (window, current_root_x, current_root_y);
      else if (_gdk_input_ignore_core == 0)
@@ -1,504 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- *
- * gdkglcontext-win32.c: Win32 specific OpenGL wrappers
- *
- * Copyright © 2014 Emmanuele Bassi
- * Copyright © 2014 Alexander Larsson
- * Copyright © 2014 Chun-wei Fan
- *
- * 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/>.
- */
-
-#include "config.h"
-
-#include "gdkprivate-win32.h"
-#include "gdksurface-win32.h"
-#include "gdkglcontext-win32.h"
-#include "gdkdisplay-win32.h"
-
-#include "gdkwin32display.h"
-#include "gdkwin32glcontext.h"
-#include "gdkwin32misc.h"
-#include "gdkwin32screen.h"
-#include "gdkwin32surface.h"
-
-#include "gdkglcontext.h"
-#include "gdksurface.h"
-#include "gdkinternals.h"
-#include "gdkintl.h"
-
-#include <cairo.h>
-#include <epoxy/egl.h>
-
-struct _GdkWin32GLContextEGL
-{
-  GdkWin32GLContext parent_instance;
-
-  /* EGL (Angle) Context Items */
-  EGLContext egl_context;
-  guint do_frame_sync : 1;
-};
-
-typedef struct _GdkWin32GLContextClass    GdkWin32GLContextEGLClass;
-
-G_DEFINE_TYPE (GdkWin32GLContextEGL, gdk_win32_gl_context_egl, GDK_TYPE_WIN32_GL_CONTEXT)
-
-static void
-gdk_win32_gl_context_egl_dispose (GObject *gobject)
-{
-  GdkGLContext *context = GDK_GL_CONTEXT (gobject);
-  GdkWin32GLContextEGL *context_egl = GDK_WIN32_GL_CONTEXT_EGL (gobject);
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (gdk_gl_context_get_display (context));
-  GdkSurface *surface = gdk_gl_context_get_surface (context);
-
-  if (display_win32 != NULL)
-    {
-      if (eglGetCurrentContext () == context_egl->egl_context)
-        eglMakeCurrent(display_win32->egl_disp, EGL_NO_SURFACE, EGL_NO_SURFACE,
-                       EGL_NO_CONTEXT);
-
-      GDK_NOTE (OPENGL, g_message ("Destroying EGL (ANGLE) context"));
-
-      eglDestroyContext (display_win32->egl_disp,
-                         context_egl->egl_context);
-      context_egl->egl_context = EGL_NO_CONTEXT;
-    }
-
-  G_OBJECT_CLASS (gdk_win32_gl_context_egl_parent_class)->dispose (gobject);
-}
-
-static gboolean
-is_egl_force_redraw (GdkSurface *surface)
-{
-  /* We only need to call gdk_window_invalidate_rect () if necessary */
-  if (surface->gl_paint_context != NULL && gdk_gl_context_get_use_es (surface->gl_paint_context))
-    {
-      GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
-
-      return impl->egl_force_redraw_all;
-    }
-  return FALSE;
-}
-
-static void
-reset_egl_force_redraw (GdkSurface *surface)
-{
-  if (surface->gl_paint_context != NULL && gdk_gl_context_get_use_es (surface->gl_paint_context))
-    {
-      GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
-
-      if (impl->egl_force_redraw_all)
-        impl->egl_force_redraw_all = FALSE;
-    }
-}
-
-static void
-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);
-  GdkWin32Display *display_win32 = (GDK_WIN32_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_win32_surface_get_egl_surface (surface, display_win32->egl_config, FALSE);
-
-  if (is_egl_force_redraw (surface))
-    {
-      GdkRectangle rect = {0, 0, gdk_surface_get_width (surface), gdk_surface_get_height (surface)};
-
-      /* We need to do gdk_window_invalidate_rect() so that we don't get glitches after maximizing or
-       *  restoring or using aerosnap
-       */
-      gdk_surface_invalidate_rect (surface, &rect);
-      reset_egl_force_redraw (surface);
-    }
-
-  eglSwapBuffers (display_win32->egl_disp, egl_surface);
-}
-
-#ifndef EGL_PLATFORM_ANGLE_ANGLE
-#define EGL_PLATFORM_ANGLE_ANGLE          0x3202
-#endif
-
-#ifndef EGL_PLATFORM_ANGLE_TYPE_ANGLE
-#define EGL_PLATFORM_ANGLE_TYPE_ANGLE     0x3203
-#endif
-
-#ifndef EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE
-#define EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE 0x3208
-#endif
-
-static EGLDisplay
-gdk_win32_get_egl_display (GdkWin32Display *display)
-{
-  EGLDisplay disp;
-
-  if (epoxy_has_egl_extension (NULL, "EGL_EXT_platform_base"))
-    {
-      PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay = (void *) eglGetProcAddress ("eglGetPlatformDisplayEXT");
-      if (getPlatformDisplay)
-        {
-          EGLint disp_attr[] = {EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE, EGL_NONE};
-
-          disp = getPlatformDisplay (EGL_PLATFORM_ANGLE_ANGLE, display->hdc_egl_temp, disp_attr);
-
-          if (disp != EGL_NO_DISPLAY)
-            return disp;
-        }
-    }
-
-  return eglGetDisplay (display->hdc_egl_temp);
-}
-
-#define MAX_EGL_ATTRS   30
-
-static gboolean
-find_eglconfig_for_window (GdkWin32Display  *display,
-                           EGLConfig        *egl_config_out,
-                           EGLint           *min_swap_interval_out,
-                           GError          **error)
-{
-  EGLint attrs[MAX_EGL_ATTRS];
-  EGLint count;
-  EGLConfig *configs, chosen_config;
-
-  int i = 0;
-
-  EGLDisplay egl_disp = display->egl_disp;
-
-  attrs[i++] = EGL_CONFORMANT;
-  attrs[i++] = EGL_OPENGL_ES2_BIT;
-  attrs[i++] = EGL_SURFACE_TYPE;
-  attrs[i++] = EGL_WINDOW_BIT;
-
-  attrs[i++] = EGL_COLOR_BUFFER_TYPE;
-  attrs[i++] = EGL_RGB_BUFFER;
-
-  attrs[i++] = EGL_RED_SIZE;
-  attrs[i++] = 1;
-  attrs[i++] = EGL_GREEN_SIZE;
-  attrs[i++] = 1;
-  attrs[i++] = EGL_BLUE_SIZE;
-  attrs[i++] = 1;
-  attrs[i++] = EGL_ALPHA_SIZE;
-  attrs[i++] = 1;
-
-  attrs[i++] = EGL_NONE;
-  g_assert (i < MAX_EGL_ATTRS);
-
-  if (!eglChooseConfig (display->egl_disp, attrs, NULL, 0, &count) || count < 1)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_UNSUPPORTED_FORMAT,
-                           _("No available configurations for the given pixel format"));
-      return FALSE;
-    }
-
-  configs = g_new (EGLConfig, count);
-
-  if (!eglChooseConfig (display->egl_disp, attrs, configs, count, &count) || count < 1)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_UNSUPPORTED_FORMAT,
-                           _("No available configurations for the given pixel format"));
-      return FALSE;
-    }
-
-  /* Pick first valid configuration i guess? */
-  chosen_config = configs[0];
-
-  if (!eglGetConfigAttrib (display->egl_disp, chosen_config,
-                           EGL_MIN_SWAP_INTERVAL, min_swap_interval_out))
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           "Could not retrieve the minimum swap interval");
-      g_free (configs);
-      return FALSE;
-    }
-
-  if (egl_config_out != NULL)
-    *egl_config_out = chosen_config;
-
-  g_free (configs);
-
-  return TRUE;
-}
-
-gboolean
-gdk_win32_display_init_egl (GdkDisplay  *display,
-                            GError     **error)
-{
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-  int best_idx = 0;
-  EGLDisplay egl_disp;
-
-  if (display_win32->egl_disp != EGL_NO_DISPLAY)
-    return TRUE;
-  
-  egl_disp = gdk_win32_get_egl_display (display_win32);
-
-  if (egl_disp == EGL_NO_DISPLAY)
-    return FALSE;
-
-  if (!eglInitialize (egl_disp, NULL, NULL))
-    {
-      eglTerminate (egl_disp);
-      egl_disp = EGL_NO_DISPLAY;
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("No GL implementation is available"));
-      return FALSE;
-    }
-
-  display_win32->egl_disp = egl_disp;
-  display_win32->egl_version = epoxy_egl_version (egl_disp);
-
-  eglBindAPI(EGL_OPENGL_ES_API);
-
-  display_win32->hasEglSurfacelessContext =
-    epoxy_has_egl_extension (egl_disp, "EGL_KHR_surfaceless_context");
-
-  GDK_NOTE (OPENGL,
-            g_print ("EGL API version %d.%d found\n"
-                     " - Vendor: %s\n"
-                     " - Checked extensions:\n"
-                     "\t* EGL_KHR_surfaceless_context: %s\n",
-                     display_win32->egl_version / 10,
-                     display_win32->egl_version % 10,
-                     eglQueryString (display_win32->egl_disp, EGL_VENDOR),
-                     display_win32->hasEglSurfacelessContext ? "yes" : "no"));
-
-  return find_eglconfig_for_window (display_win32, &display_win32->egl_config,
-                                   &display_win32->egl_min_swap_interval, error);
-}
-
-#define N_EGL_ATTRS     16
-
-static EGLContext
-create_egl_context (EGLDisplay    display,
-                    EGLConfig     config,
-                    GdkGLContext *share,
-                    int           flags,
-                    int           major,
-                    int           minor,
-                    gboolean     *is_legacy)
-{
-  EGLContext ctx;
-  EGLint context_attribs[N_EGL_ATTRS];
-  int i = 0;
-
-  /* ANGLE does not support the GL_OES_vertex_array_object extension, so we need to use ES3 directly */
-  context_attribs[i++] = EGL_CONTEXT_CLIENT_VERSION;
-  context_attribs[i++] = 3;
-
-  /* Specify the flags */
-  context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
-  context_attribs[i++] = flags;
-
-  context_attribs[i++] = EGL_NONE;
-  g_assert (i < N_EGL_ATTRS);
-
-  ctx = eglCreateContext (display,
-                          config,
-                          share != NULL ? GDK_WIN32_GL_CONTEXT_EGL (share)->egl_context
-                                        : EGL_NO_CONTEXT,
-                          context_attribs);
-
-  if (ctx != EGL_NO_CONTEXT)
-    GDK_NOTE (OPENGL, g_message ("Created EGL context[%p]", ctx));
-
-  return ctx;
-}
-
-static gboolean
-gdk_win32_gl_context_egl_realize (GdkGLContext *context,
-                                  GError **error)
-{
-  GdkWin32GLContextEGL *context_egl = GDK_WIN32_GL_CONTEXT_EGL (context);
-
-  gboolean debug_bit, compat_bit, legacy_bit;
-  gboolean use_es = FALSE;
-  EGLContext egl_context;
-  EGLContext ctx;
-
-  /* request flags and specific versions for core (3.2+) WGL context */
-  int flags = 0;
-  int major = 0;
-  int minor = 0;
-
-  GdkSurface *surface = gdk_gl_context_get_surface (context);
-  GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-  GdkGLContext *share = gdk_display_get_gl_context (display);
-
-  gdk_gl_context_get_required_version (context, &major, &minor);
-  debug_bit = gdk_gl_context_get_debug_enabled (context);
-  compat_bit = gdk_gl_context_get_forward_compatible (context);
-
-  /*
-   * 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
-   */
-
-  /* if GDK_GL_LEGACY is set, we default to a legacy context */
-  legacy_bit = GDK_DISPLAY_DEBUG_CHECK (display, GL_LEGACY) ?
-               TRUE :
-			   share != NULL && gdk_gl_context_is_legacy (share);
-
-  use_es = GDK_DISPLAY_DEBUG_CHECK (display, GL_GLES) ||
-    (share != NULL && gdk_gl_context_get_use_es (share));
-
-  if (debug_bit)
-    flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
-  if (compat_bit)
-    flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
-
-  GDK_NOTE (OPENGL, g_message ("Creating EGL context version %d.%d (debug:%s, forward:%s, legacy:%s)",
-                               major, minor,
-                               debug_bit ? "yes" : "no",
-                               compat_bit ? "yes" : "no",
-                               legacy_bit ? "yes" : "no"));
-
-  ctx = create_egl_context (display_win32->egl_disp,
-                            display_win32->egl_config,
-                            share,
-                            flags,
-                            major,
-                            minor,
-                           &legacy_bit);
-
-  if (ctx == EGL_NO_CONTEXT)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Unable to create a GL context"));
-      return FALSE;
-    }
-
-  GDK_NOTE (OPENGL, g_print ("Created EGL context[%p]\n", ctx));
-
-  context_egl->egl_context = ctx;
-
-  /* We are using GLES here */
-  gdk_gl_context_set_use_es (context, TRUE);
-
-  /* Ensure that any other context is created with a legacy bit set */
-  gdk_gl_context_set_is_legacy (context, legacy_bit);
-
-  return TRUE;
-}
-
-static gboolean
-gdk_win32_gl_context_egl_clear_current (GdkGLContext *context)
-{
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-
-  if (display_win32->egl_disp != EGL_NO_DISPLAY)
-    return eglMakeCurrent (display_win32->egl_disp,
-                           EGL_NO_SURFACE, 
-                           EGL_NO_SURFACE, 
-                           EGL_NO_CONTEXT);
-  else
-    return TRUE;
-}
-
-static gboolean
-gdk_win32_gl_context_egl_make_current (GdkGLContext *context,
-                                       gboolean      surfaceless)
-{
-  GdkWin32GLContextEGL *context_egl = GDK_WIN32_GL_CONTEXT_EGL (context);
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-  GdkSurface *surface;
-
-  gboolean do_frame_sync = FALSE;
-
-  EGLSurface egl_surface;
-
-  surface = gdk_gl_context_get_surface (context);
-
-  if (!surfaceless)
-    egl_surface = gdk_win32_surface_get_egl_surface (surface, display_win32->egl_config, FALSE);
-  else
-    {
-      if (display_win32->hasEglSurfacelessContext)
-        egl_surface = EGL_NO_SURFACE;
-      else
-        egl_surface = gdk_win32_surface_get_egl_surface (surface, display_win32->egl_config, TRUE);
-    }
-
-  if (!eglMakeCurrent (display_win32->egl_disp,
-                       egl_surface,
-                       egl_surface,
-                       context_egl->egl_context))
-    return FALSE;
-
-  if (display_win32->egl_min_swap_interval == 0)
-    eglSwapInterval (display_win32->egl_disp, 0);
-  else
-    g_debug ("Can't disable GL swap interval");
-
-  return TRUE;
-}
-
-static void
-gdk_win32_gl_context_egl_begin_frame (GdkDrawContext *draw_context,
-                                      cairo_region_t *update_area)
-{
-  GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
-  GdkSurface *surface;
-
-  surface = gdk_gl_context_get_surface (context);
-
-  gdk_win32_surface_handle_queued_move_resize (draw_context);
-
-  GDK_DRAW_CONTEXT_CLASS (gdk_win32_gl_context_egl_parent_class)->begin_frame (draw_context, update_area);
-}
-
-static void
-gdk_win32_gl_context_egl_class_init (GdkWin32GLContextClass *klass)
-{
-  GdkGLContextClass *context_class = GDK_GL_CONTEXT_CLASS(klass);
-  GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS(klass);
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-
-  context_class->realize = gdk_win32_gl_context_egl_realize;
-  context_class->make_current = gdk_win32_gl_context_egl_make_current;
-  context_class->clear_current = gdk_win32_gl_context_egl_clear_current;
-
-  draw_context_class->begin_frame = gdk_win32_gl_context_egl_begin_frame;
-  draw_context_class->end_frame = gdk_win32_gl_context_egl_end_frame;
-
-  gobject_class->dispose = gdk_win32_gl_context_egl_dispose;
-}
-
-static void
-gdk_win32_gl_context_egl_init (GdkWin32GLContextEGL *egl_context)
-{
-}
@@ -1,727 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- *
- * gdkglcontext-win32.c: Win32 specific OpenGL wrappers
- *
- * Copyright © 2014 Emmanuele Bassi
- * Copyright © 2014 Alexander Larsson
- * Copyright © 2014 Chun-wei Fan
- *
- * 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/>.
- */
-
-#include "config.h"
-
-#include "gdkprivate-win32.h"
-#include "gdksurface-win32.h"
-#include "gdkglcontext-win32.h"
-#include "gdkdisplay-win32.h"
-
-#include "gdkwin32display.h"
-#include "gdkwin32glcontext.h"
-#include "gdkwin32misc.h"
-#include "gdkwin32screen.h"
-#include "gdkwin32surface.h"
-
-#include "gdkglcontext.h"
-#include "gdkprofilerprivate.h"
-#include "gdkinternals.h"
-#include "gdkintl.h"
-#include "gdksurface.h"
-
-#include <cairo.h>
-#include <epoxy/wgl.h>
-
-struct _GdkWin32GLContextWGL
-{
-  GdkWin32GLContext parent_instance;
-
-  HGLRC wgl_context;
-  guint do_frame_sync : 1;
-};
-
-typedef struct _GdkWin32GLContextClass    GdkWin32GLContextWGLClass;
-
-G_DEFINE_TYPE (GdkWin32GLContextWGL, gdk_win32_gl_context_wgl, GDK_TYPE_WIN32_GL_CONTEXT)
-
-static void
-gdk_win32_gl_context_wgl_dispose (GObject *gobject)
-{
-  GdkWin32GLContextWGL *context_wgl = GDK_WIN32_GL_CONTEXT_WGL (gobject);
-
-  if (context_wgl->wgl_context != NULL)
-    {
-      if (wglGetCurrentContext () == context_wgl->wgl_context)
-        wglMakeCurrent (NULL, NULL);
-
-      GDK_NOTE (OPENGL, g_print ("Destroying WGL context\n"));
-
-      wglDeleteContext (context_wgl->wgl_context);
-      context_wgl->wgl_context = NULL;
-    }
-
-  G_OBJECT_CLASS (gdk_win32_gl_context_wgl_parent_class)->dispose (gobject);
-}
-
-static void
-gdk_win32_gl_context_wgl_end_frame (GdkDrawContext *draw_context,
-                                    cairo_region_t *painted)
-{
-  GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
-  GdkWin32GLContextWGL *context_wgl = GDK_WIN32_GL_CONTEXT_WGL (context);
-  GdkSurface *surface = gdk_gl_context_get_surface (context);
-  GdkWin32Display *display_win32 = (GDK_WIN32_DISPLAY (gdk_gl_context_get_display (context)));
-  cairo_rectangle_int_t whole_window;
-  gboolean can_wait = display_win32->hasWglOMLSyncControl;
-  HDC hdc;
-
-  GDK_DRAW_CONTEXT_CLASS (gdk_win32_gl_context_wgl_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) };
-
-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "win32", "swap buffers");
-
-  if (surface != NULL)
-    hdc = GDK_WIN32_SURFACE (surface)->hdc;
-  else
-    hdc = display_win32->dummy_context_wgl.hdc;
-
-  if (context_wgl->do_frame_sync)
-    {
-
-      glFinish ();
-
-      if (can_wait)
-        {
-          gint64 ust, msc, sbc;
-
-          wglGetSyncValuesOML (hdc, &ust, &msc, &sbc);
-          wglWaitForMscOML (hdc,
-                            0,
-                            2,
-                            (msc + 1) % 2,
-                           &ust, &msc, &sbc);
-        }
-
-    }
-
-  SwapBuffers (hdc);
-}
-
-static void
-gdk_win32_gl_context_wgl_begin_frame (GdkDrawContext *draw_context,
-                                      cairo_region_t *update_area)
-{
-  GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
-  GdkSurface *surface;
-
-  surface = gdk_gl_context_get_surface (context);
-
-  gdk_win32_surface_handle_queued_move_resize (draw_context);
-
-  GDK_DRAW_CONTEXT_CLASS (gdk_win32_gl_context_wgl_parent_class)->begin_frame (draw_context, update_area);
-}
-
-static int
-gdk_init_dummy_wgl_context (GdkWin32Display *display_win32);
-
-#define PIXEL_ATTRIBUTES 17
-
-static int
-get_wgl_pfd (HDC                    hdc,
-             PIXELFORMATDESCRIPTOR *pfd,
-             GdkWin32Display       *display_win32)
-{
-  int best_pf = 0;
-
-  pfd->nSize = sizeof (PIXELFORMATDESCRIPTOR);
-
-  if (display_win32 != NULL && display_win32->hasWglARBPixelFormat)
-    {
-      UINT num_formats;
-      int colorbits = GetDeviceCaps (hdc, BITSPIXEL);
-      int i = 0;
-      int pixelAttribs[PIXEL_ATTRIBUTES];
-
-      /* 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 ();
-
-      /* Update PIXEL_ATTRIBUTES above if any groups are added here! */
-      pixelAttribs[i] = WGL_DRAW_TO_WINDOW_ARB;
-      pixelAttribs[i++] = GL_TRUE;
-
-      pixelAttribs[i++] = WGL_SUPPORT_OPENGL_ARB;
-      pixelAttribs[i++] = GL_TRUE;
-
-      pixelAttribs[i++] = WGL_DOUBLE_BUFFER_ARB;
-      pixelAttribs[i++] = GL_TRUE;
-
-      pixelAttribs[i++] = WGL_ACCELERATION_ARB;
-      pixelAttribs[i++] = WGL_FULL_ACCELERATION_ARB;
-
-      pixelAttribs[i++] = WGL_PIXEL_TYPE_ARB;
-      pixelAttribs[i++] = WGL_TYPE_RGBA_ARB;
-
-      pixelAttribs[i++] = WGL_COLOR_BITS_ARB;
-      pixelAttribs[i++] = colorbits;
-
-      /* end of "Update PIXEL_ATTRIBUTES above if any groups are added here!" */
-
-      if (display_win32->hasWglARBmultisample)
-        {
-          pixelAttribs[i++] = WGL_SAMPLE_BUFFERS_ARB;
-          pixelAttribs[i++] = 1;
-
-          pixelAttribs[i++] = WGL_SAMPLES_ARB;
-          pixelAttribs[i++] = 8;
-        }
-
-      pixelAttribs[i++] = 0; /* end of pixelAttribs */
-      best_pf = gdk_init_dummy_wgl_context (display_win32);
-
-      if (!wglMakeCurrent (display_win32->dummy_context_wgl.hdc,
-                           display_win32->dummy_context_wgl.hglrc))
-        {
-          wglMakeCurrent (hdc_current, hglrc_current);
-          return 0;
-        }
-
-      wglChoosePixelFormatARB (hdc,
-                               pixelAttribs,
-                               NULL,
-                               1,
-                              &best_pf,
-                              &num_formats);
-
-      /* Go back to the HDC that we were using, since we are done with the dummy HDC and GL Context */
-      wglMakeCurrent (hdc_current, hglrc_current);
-    }
-  else
-    {
-      pfd->nVersion = 1;
-      pfd->dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER;
-      pfd->iPixelType = PFD_TYPE_RGBA;
-      pfd->cColorBits = GetDeviceCaps (hdc, BITSPIXEL);
-      pfd->cAlphaBits = 8;
-      pfd->dwLayerMask = PFD_MAIN_PLANE;
-
-      best_pf = ChoosePixelFormat (hdc, pfd);
-    }
-
-  return best_pf;
-}
-
-/* in WGL, for many OpenGL items, we need a dummy WGL context, so create
- * one and cache it for later use
- */
-static int
-gdk_init_dummy_wgl_context (GdkWin32Display *display_win32)
-{
-  PIXELFORMATDESCRIPTOR pfd;
-  gboolean set_pixel_format_result = FALSE;
-  int best_idx = 0;
-
-  if (display_win32->dummy_context_wgl.hdc == NULL)
-    display_win32->dummy_context_wgl.hdc = GetDC (display_win32->hwnd);
-
-  memset (&pfd, 0, sizeof (PIXELFORMATDESCRIPTOR));
-
-  best_idx = get_wgl_pfd (display_win32->dummy_context_wgl.hdc, &pfd, NULL);
-
-  if (best_idx != 0)
-    set_pixel_format_result = SetPixelFormat (display_win32->dummy_context_wgl.hdc,
-                                              best_idx,
-                                             &pfd);
-
-  if (best_idx == 0 || !set_pixel_format_result)
-    return 0;
-
-  display_win32->dummy_context_wgl.hglrc =
-    wglCreateContext (display_win32->dummy_context_wgl.hdc);
-
-  if (display_win32->dummy_context_wgl.hglrc == NULL)
-    return 0;
-
-  return best_idx;
-}
-
-gboolean
-gdk_win32_display_init_wgl (GdkDisplay  *display,
-                            GError     **error)
-{
-  int best_idx = 0;
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-  HDC hdc;
-
-  if (display_win32->wgl_pixel_format != 0)
-    return TRUE;
-
-  /* acquire and cache dummy Window (HWND & HDC) and
-   * dummy GL Context, it is used to query functions
-   * and used for other stuff as well
-   */
-  best_idx = gdk_init_dummy_wgl_context (display_win32);
-  hdc = display_win32->dummy_context_wgl.hdc;
-
-  if (best_idx == 0 ||
-     !wglMakeCurrent (hdc, 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;
-    }
-
-  display_win32->wgl_pixel_format = best_idx;
-  display_win32->gl_version = epoxy_gl_version ();
-
-  display_win32->hasWglARBCreateContext =
-    epoxy_has_wgl_extension (hdc, "WGL_ARB_create_context");
-  display_win32->hasWglEXTSwapControl =
-    epoxy_has_wgl_extension (hdc, "WGL_EXT_swap_control");
-  display_win32->hasWglOMLSyncControl =
-    epoxy_has_wgl_extension (hdc, "WGL_OML_sync_control");
-  display_win32->hasWglARBPixelFormat =
-    epoxy_has_wgl_extension (hdc, "WGL_ARB_pixel_format");
-  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"));
-
-  wglMakeCurrent (NULL, NULL);
-
-  return TRUE;
-}
-
-/* Setup the legacy context after creating it */
-static gboolean
-ensure_legacy_wgl_context (HDC           hdc,
-                           HGLRC         hglrc_legacy,
-                           GdkGLContext *share)
-{
-  GdkWin32GLContextWGL *context_wgl;
-
-  if (!wglMakeCurrent (hdc, hglrc_legacy))
-    return FALSE;
-
-  if (share != NULL)
-    {
-      context_wgl = GDK_WIN32_GL_CONTEXT_WGL (share);
-
-      return wglShareLists (hglrc_legacy, context_wgl->wgl_context);
-    }
-
-  return TRUE;
-}
-
-static HGLRC
-create_wgl_context_with_attribs (HDC           hdc,
-                                 HGLRC         hglrc_base,
-                                 GdkGLContext *share,
-                                 int           flags,
-                                 int           major,
-                                 int           minor,
-                                 gboolean     *is_legacy)
-{
-  HGLRC hglrc;
-  GdkWin32GLContextWGL *context_wgl;
-
-  /* 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;
-
-  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
-  };
-
-  if (share != NULL)
-    context_wgl = GDK_WIN32_GL_CONTEXT_WGL (share);
-
-  hglrc = wglCreateContextAttribsARB (hdc,
-                                      share != NULL ? context_wgl->wgl_context : NULL,
-                                      attribs);
-
-  return hglrc;
-}
-
-static HGLRC
-create_wgl_context (HDC           hdc,
-                    GdkGLContext *share,
-                    int           flags,
-                    int           major,
-                    int           minor,
-                    gboolean     *is_legacy,
-                    gboolean      hasWglARBCreateContext)
-{
-  /* We need a legacy context for *all* cases */
-  HGLRC hglrc_base = wglCreateContext (hdc);
-  gboolean success = TRUE;
-
-  /* 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)
-    {
-      if (ensure_legacy_wgl_context (hdc, hglrc_base, share))
-        {
-          wglMakeCurrent (hdc_current, hglrc_current);
-          return hglrc_base;
-        }
-
-      success = FALSE;
-      goto gl_fail;
-    }
-  else
-    {
-      HGLRC hglrc = NULL;
-
-      if (!wglMakeCurrent (hdc, hglrc_base))
-        {
-          success = FALSE;
-          goto gl_fail;
-        }
-
-      /*
-       * We need a Core GL 4.1 context in order to use the GL support in
-       * the GStreamer media widget backend, but wglCreateContextAttribsARB()
-       * may only give us the GL context version that we ask for here, and
-       * nothing more.  So, if we are asking for a pre-GL 4.1 context,
-       * try to ask for a 4.1 context explicitly first.  If that is not supported,
-       * then we fall back to whatever version that we were asking for (or, even a
-       * legacy context if that fails), at a price of not able to have GL support
-       * for the media GStreamer backend.
-       */
-      if (major < 4 || (major == 4 && minor < 1))
-        hglrc = create_wgl_context_with_attribs (hdc,
-                                                 hglrc_base,
-                                                 share,
-                                                 flags,
-                                                 4,
-                                                 1,
-                                                 is_legacy);
-
-      if (hglrc == NULL)
-        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"));
-        }
-
-gl_fail:
-
-      if (!success)
-        {
-          wglMakeCurrent (NULL, NULL);
-          wglDeleteContext (hglrc_base);
-          return NULL;
-        }
-
-      wglMakeCurrent (hdc_current, hglrc_current);
-
-      if (hglrc != NULL)
-        {
-          wglDeleteContext (hglrc_base);
-          return hglrc;
-        }
-
-      return hglrc_base;
-  }
-}
-
-static gboolean
-set_wgl_pixformat_for_hdc (HDC              hdc,
-                           int             *best_idx,
-                           GdkWin32Display *display_win32)
-{
-  gboolean already_checked = TRUE;
-  *best_idx = GetPixelFormat (hdc);
-
-  /* one is only allowed to call SetPixelFormat(), and so ChoosePixelFormat()
-   * one single time per window HDC
-   */
-  if (*best_idx == 0)
-    {
-      PIXELFORMATDESCRIPTOR pfd;
-      gboolean set_pixel_format_result = FALSE;
-
-      GDK_NOTE (OPENGL, g_print ("requesting pixel format...\n"));
-	  already_checked = FALSE;
-      *best_idx = get_wgl_pfd (hdc, &pfd, display_win32);
-
-      if (*best_idx != 0)
-        set_pixel_format_result = SetPixelFormat (hdc, *best_idx, &pfd);
-
-      /* ChoosePixelFormat() or SetPixelFormat() failed, bail out */
-      if (*best_idx == 0 || !set_pixel_format_result)
-        return FALSE;
-    }
-
-  GDK_NOTE (OPENGL, g_print ("%s""requested and set pixel format: %d\n", already_checked ? "already " : "", *best_idx));
-
-  return TRUE;
-}
-
-static gboolean
-gdk_win32_gl_context_wgl_realize (GdkGLContext *context,
-                                  GError **error)
-{
-  GdkWin32GLContextWGL *context_wgl = GDK_WIN32_GL_CONTEXT_WGL (context);
-
-  gboolean debug_bit, compat_bit, legacy_bit;
-
-  /* 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;
-  HWND hwnd;
-
-  GdkSurface *surface = gdk_gl_context_get_surface (context);
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-  GdkGLContext *share = gdk_display_get_gl_context (display);
-
-  gdk_gl_context_get_required_version (context, &major, &minor);
-  debug_bit = gdk_gl_context_get_debug_enabled (context);
-  compat_bit = gdk_gl_context_get_forward_compatible (context);
-
-  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
-   */
-  legacy_bit = GDK_DISPLAY_DEBUG_CHECK (display, GL_LEGACY) ?
-               TRUE :
-			   share != NULL && gdk_gl_context_is_legacy (share);
-
-  if (!set_wgl_pixformat_for_hdc (hdc,
-                                 &pixel_format,
-                                  display_win32))
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_UNSUPPORTED_FORMAT,
-                           _("No available configurations for the given pixel format"));
-
-      return FALSE;
-    }
-
-  /* if there isn't wglCreateContextAttribsARB() on WGL, use a legacy context */
-  if (!legacy_bit)
-    legacy_bit = !display_win32->hasWglARBCreateContext;
-  if (debug_bit)
-    flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
-  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,
-                              share,
-                              flags,
-                              major,
-                              minor,
-                             &legacy_bit,
-                              display_win32->hasWglARBCreateContext);
-
-  if (hglrc == NULL)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Unable to create a GL context"));
-      return FALSE;
-    }
-
-  GDK_NOTE (OPENGL,
-            g_print ("Created WGL context[%p], pixel_format=%d\n",
-                     hglrc,
-                     pixel_format));
-
-  context_wgl->wgl_context = hglrc;
-
-  /* No GLES, WGL does not support using EGL contexts */
-  gdk_gl_context_set_use_es (context, FALSE);
-
-  /* Ensure that any other context is created with a legacy bit set */
-  gdk_gl_context_set_is_legacy (context, legacy_bit);
-
-  return TRUE;
-}
-
-static gboolean
-gdk_win32_gl_context_wgl_clear_current (GdkGLContext *context)
-{
-  return wglMakeCurrent (NULL, NULL);
-}
-
-static gboolean
-gdk_win32_gl_context_wgl_make_current (GdkGLContext *context,
-                                       gboolean      surfaceless)
-{
-  GdkWin32GLContextWGL *context_wgl = GDK_WIN32_GL_CONTEXT_WGL (context);
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
-  GdkSurface *surface = gdk_gl_context_get_surface (context);
-  HDC hdc;
-
-  if (surfaceless || surface == NULL)
-    hdc = display_win32->dummy_context_wgl.hdc;
-  else
-    hdc = GDK_WIN32_SURFACE (surface)->hdc;
-
-  if (!wglMakeCurrent (hdc, context_wgl->wgl_context))
-    return FALSE;
-
-  if (!surfaceless && display_win32->hasWglEXTSwapControl)
-    {
-      gboolean do_frame_sync = FALSE;
-
-      /* If there is compositing there is no particular need to delay
-       * the swap when drawing on the offscreen, rendering to the screen
-       * happens later anyway, and its up to the compositor to sync that
-       * to the vblank. */
-      do_frame_sync = ! gdk_display_is_composited (display);
-
-      if (do_frame_sync != context_wgl->do_frame_sync)
-        {
-          context_wgl->do_frame_sync = do_frame_sync;
-
-          wglSwapIntervalEXT (do_frame_sync ? 1 : 0);
-        }
-    }
-
-  return TRUE;
-}
-
-static void
-gdk_win32_gl_context_wgl_class_init (GdkWin32GLContextWGLClass *klass)
-{
-  GdkGLContextClass *context_class = GDK_GL_CONTEXT_CLASS (klass);
-  GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS (klass);
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-
-  context_class->realize = gdk_win32_gl_context_wgl_realize;
-  context_class->make_current = gdk_win32_gl_context_wgl_make_current;
-  context_class->clear_current = gdk_win32_gl_context_wgl_clear_current;
-
-  draw_context_class->begin_frame = gdk_win32_gl_context_wgl_begin_frame;
-  draw_context_class->end_frame = gdk_win32_gl_context_wgl_end_frame;
-  gobject_class->dispose = gdk_win32_gl_context_wgl_dispose;
-}
-
-static void
-gdk_win32_gl_context_wgl_init (GdkWin32GLContextWGL *wgl_context)
-{
-}
-
-
-/**
- * gdk_win32_display_get_wgl_version:
- * @display: a `GdkDisplay`
- * @major: (out): return location for the WGL major version
- * @minor: (out): return location for the WGL minor version
- *
- * Retrieves the version of the WGL implementation.
- *
- * Returns: %TRUE if WGL is available
- */
-gboolean
-gdk_win32_display_get_wgl_version (GdkDisplay *display,
-                                   int *major,
-                                   int *minor)
-{
-  GdkWin32Display *display_win32;
-  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
-
-  if (!GDK_IS_WIN32_DISPLAY (display))
-    return FALSE;
-
-  display_win32 = GDK_WIN32_DISPLAY (display);
-  if (display_win32->wgl_pixel_format == 0)
-    return FALSE;
-
-  if (major != NULL)
-    *major = display_win32->gl_version / 10;
-  if (minor != NULL)
-    *minor = display_win32->gl_version % 10;
-
-  return TRUE;
-}
@@ -35,13 +35,24 @@

 G_BEGIN_DECLS

-#define GDK_WIN32_GL_CONTEXT_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_GL_CONTEXT, GdkWin32GLContextClass))
-#define GDK_WIN32_GL_CONTEXT_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_GL_CONTEXT, GdkWin32GLContextClass))
-#define GDK_WIN32_IS_GL_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_GL_CONTEXT))
-
 struct _GdkWin32GLContext
 {
  GdkGLContext parent_instance;
+
+  /* WGL Context Items */
+  HGLRC hglrc;
+  HDC gl_hdc;
+  guint need_alpha_bits : 1;
+
+  /* other items */
+  guint is_attached : 1;
+  guint do_frame_sync : 1;
+
+#ifdef GDK_WIN32_ENABLE_EGL
+  /* EGL (Angle) Context Items */
+  EGLContext egl_context;
+  EGLConfig egl_config;
+#endif
 };

 struct _GdkWin32GLContextClass
@@ -49,33 +60,15 @@ struct _GdkWin32GLContextClass
  GdkGLContextClass parent_class;
 };

-/* WGL */
-#define GDK_TYPE_WIN32_GL_CONTEXT_WGL     (gdk_win32_gl_context_wgl_get_type())
-#define GDK_WIN32_GL_CONTEXT_WGL(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WIN32_GL_CONTEXT_WGL, GdkWin32GLContextWGL))
-#define GDK_IS_WIN32_GL_CONTEXT_WGL(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WIN32_GL_CONTEXT_WGL))
-
-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);
-
-GType     gdk_win32_gl_context_wgl_get_type         (void) G_GNUC_CONST;
-
-/* EGL */
-#define GDK_TYPE_WIN32_GL_CONTEXT_EGL     (gdk_win32_gl_context_egl_get_type())
-#define GDK_WIN32_GL_CONTEXT_EGL(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WIN32_GL_CONTEXT_EGL, GdkWin32GLContextEGL))
-#define GDK_IS_WIN32_GL_CONTEXT_EGL(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WIN32_GL_CONTEXT_EGL))
-
-typedef struct _GdkWin32GLContextEGL      GdkWin32GLContextEGL;
-
-gboolean  gdk_win32_display_init_egl                (GdkDisplay  *display,
-                                                     GError     **error);
-void      gdk_win32_surface_destroy_egl_surface     (GdkWin32Surface *self);
-
-GType     gdk_win32_gl_context_egl_get_type         (void) G_GNUC_CONST;
+GdkGLContext *
+_gdk_win32_surface_create_gl_context (GdkSurface *window,
+                                     gboolean attached,
+                                     GdkGLContext *share,
+                                     GError **error);

+gboolean
+_gdk_win32_display_make_gl_context_current (GdkDisplay *display,
+                                            GdkGLContext *context);
 void
 _gdk_win32_surface_invalidate_egl_framebuffer (GdkSurface *surface);

@@ -694,7 +694,6 @@ update_keymap (GdkKeymap *gdk_keymap)
  if (hkls_len != keymap->layout_handles->len)
    keymap->keysym_tab = g_renew (guint, keymap->keysym_tab, keysym_tab_size);

-  memset (key_state, 0, sizeof(key_state));
  memset (keymap->keysym_tab, 0, keysym_tab_size);
  g_array_set_size (keymap->layout_handles, hkls_len);
  g_array_set_size (keymap->options, hkls_len);
@@ -681,7 +681,7 @@ enum_monitor (HMONITOR hmonitor,
          else
            {
              /* First acquire the scale using the current screen */
-              scale = gdk_win32_display_get_monitor_scale_factor (data->display, NULL, NULL);
+              scale = _gdk_win32_display_get_monitor_scale_factor (data->display, NULL, NULL, NULL);

              /* acquire the scale using the monitor which the window is nearest on Windows 8.1+ */
              if (data->display->have_at_least_win81)
@@ -695,7 +695,7 @@ enum_monitor (HMONITOR hmonitor,
                  pt.x = w32mon->work_rect.x + w32mon->work_rect.width / 2;
                  pt.y = w32mon->work_rect.y + w32mon->work_rect.height / 2;
                  hmonitor = MonitorFromPoint (pt, MONITOR_DEFAULTTONEAREST);
-                  scale = gdk_win32_display_get_monitor_scale_factor (data->display, NULL, hmonitor);
+                  scale = _gdk_win32_display_get_monitor_scale_factor (data->display, hmonitor, NULL, NULL);
                }
            }

@@ -78,7 +78,8 @@ init_root_window (GdkWin32Screen *screen_win32)
  win32_display = GDK_WIN32_DISPLAY (_gdk_display);

  if (win32_display->dpi_aware_type != PROCESS_DPI_UNAWARE)
-    screen_win32->surface_scale = gdk_win32_display_get_monitor_scale_factor (win32_display,
+    screen_win32->surface_scale = _gdk_win32_display_get_monitor_scale_factor (win32_display,
+                                                                              NULL,
                                                                              NULL,
                                                                              NULL);
  else
@@ -397,13 +397,12 @@ RegisterGdkClass (GdkSurfaceType wtype)
  wcl.hbrBackground = NULL; \
  wcl.hCursor = LoadCursor (NULL, IDC_ARROW);

-  /* MSDN: CS_OWNDC is needed for OpenGL contexts */
-  wcl.style |= CS_OWNDC;
-
  switch (wtype)
    {
    case GDK_SURFACE_TOPLEVEL:
    case GDK_SURFACE_POPUP:
+      /* MSDN: CS_OWNDC is needed for OpenGL contexts */
+      wcl.style |= CS_OWNDC;
      if (0 == klassTOPLEVEL)
        {
          wcl.lpszClassName = L"gdkSurfaceToplevel";
@@ -522,7 +521,7 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
  surface->width = width;
  surface->height = height;

-  impl->surface_scale = gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL);
+  impl->surface_scale = _gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL, NULL);

  dwExStyle = 0;
  owner = NULL;
@@ -655,7 +654,6 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
                    impl);

  g_object_unref (frame_clock);
-  impl->hdc = GetDC (impl->handle);

  return surface;
 }
@@ -1231,7 +1229,6 @@ gdk_win32_surface_layout_popup (GdkSurface     *surface,
                                     &shadow_right,
                                     &shadow_top,
                                     &shadow_bottom);
-
  gdk_win32_surface_set_shadow_width (surface,
                                      shadow_left,
                                      shadow_right,
@@ -1241,10 +1238,10 @@ gdk_win32_surface_layout_popup (GdkSurface     *surface,
  gdk_surface_layout_popup_helper (surface,
                                   width,
                                   height,
-                                   shadow_left,
-                                   shadow_right,
-                                   shadow_top,
-                                   shadow_bottom,
+                                   impl->shadow.left,
+                                   impl->shadow.right,
+                                   impl->shadow.top,
+                                   impl->shadow.bottom,
                                   monitor,
                                   &bounds,
                                   layout,
@@ -1264,7 +1261,9 @@ gdk_win32_surface_layout_popup (GdkSurface     *surface,
                                     final_rect.height);
    }
  else
-    gdk_win32_surface_move (surface, x, y);
+    {
+      gdk_win32_surface_move (surface, x, y);
+    }
 }

 static void
@@ -4418,9 +4417,9 @@ gdk_win32_surface_set_shadow_width (GdkSurface *window,
  if (impl->zero_shadow)
    return;

-  impl->shadow.left = left * impl->surface_scale;;
+  impl->shadow.left = left;
  impl->shadow.right = right * impl->surface_scale;
-  impl->shadow.top = top * impl->surface_scale;;
+  impl->shadow.top = top;
  impl->shadow.bottom = bottom * impl->surface_scale;
  impl->shadow_x = left + right;
  impl->shadow_y = top + bottom;
@@ -4428,19 +4427,19 @@ gdk_win32_surface_set_shadow_width (GdkSurface *window,


 int
-_gdk_win32_surface_get_scale_factor (GdkSurface *surface)
+_gdk_win32_surface_get_scale_factor (GdkSurface *window)
 {
  GdkDisplay *display;
  GdkWin32Surface *impl;
  GdkWin32Display *win32_display;

-  if (GDK_SURFACE_DESTROYED (surface))
+  if (GDK_SURFACE_DESTROYED (window))
    return 1;

-  g_return_val_if_fail (surface != NULL, 1);
+  g_return_val_if_fail (window != NULL, 1);

-  display = gdk_surface_get_display (surface);
-  impl = GDK_WIN32_SURFACE (surface);
+  display = gdk_surface_get_display (window);
+  impl = GDK_WIN32_SURFACE (window);

  win32_display = GDK_WIN32_DISPLAY (display);

@@ -4449,8 +4448,9 @@ _gdk_win32_surface_get_scale_factor (GdkSurface *surface)
      if (win32_display->has_fixed_scale)
        impl->surface_scale = win32_display->surface_scale;
      else
-        impl->surface_scale = gdk_win32_display_get_monitor_scale_factor (win32_display,
-                                                                          surface,
+        impl->surface_scale = _gdk_win32_display_get_monitor_scale_factor (win32_display,
+                                                                          NULL,
+                                                                          GDK_SURFACE_HWND (window),
                                                                          NULL);

      return impl->surface_scale;
@@ -4555,7 +4555,7 @@ _gdk_win32_surface_request_layout (GdkSurface *surface)
  int scale = impl->surface_scale;
  RECT rect;

-  if (impl->drag_move_resize_context.native_move_resize_pending)
+  if (GDK_IS_TOPLEVEL (surface) && impl->drag_move_resize_context.native_move_resize_pending)
    {
      surface->width = impl->next_layout.configured_width;
      surface->height = impl->next_layout.configured_height;
@@ -4566,18 +4566,8 @@ _gdk_win32_surface_request_layout (GdkSurface *surface)

      impl->next_layout.configured_width = (rect.right - rect.left + scale - 1) / scale;
      impl->next_layout.configured_height = (rect.bottom - rect.top + scale - 1) / scale;
-
-      if (GDK_IS_TOPLEVEL (surface))
-        {
-          surface->x = rect.left / scale;
-          surface->y = rect.top / scale;
-        }
-      else if (GDK_IS_POPUP (surface))
-        {
-          gdk_win32_surface_get_geometry (surface,
-                                         &surface->x, &surface->y,
-                                          NULL, NULL);
-        }
+      surface->x = rect.left / scale;
+      surface->y = rect.top / scale;
    }
 }

@@ -4624,6 +4614,7 @@ gdk_win32_surface_class_init (GdkWin32SurfaceClass *klass)

  impl_class->destroy_notify = gdk_win32_surface_destroy_notify;
  impl_class->drag_begin = _gdk_win32_surface_drag_begin;
+  impl_class->create_gl_context = _gdk_win32_surface_create_gl_context;
  impl_class->get_scale_factor = _gdk_win32_surface_get_scale_factor;
  impl_class->request_layout = _gdk_win32_surface_request_layout;
  impl_class->compute_size = _gdk_win32_surface_compute_size;
@@ -4666,9 +4657,9 @@ gdk_win32_popup_init (GdkWin32Popup *popup)

 static void
 gdk_win32_popup_get_property (GObject    *object,
-                              guint       prop_id,
-                              GValue     *value,
-                              GParamSpec *pspec)
+                                guint       prop_id,
+                                GValue     *value,
+                                GParamSpec *pspec)
 {
  GdkSurface *surface = GDK_SURFACE (object);

@@ -4690,9 +4681,9 @@ gdk_win32_popup_get_property (GObject    *object,

 static void
 gdk_win32_popup_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);

@@ -4727,9 +4718,9 @@ gdk_win32_popup_class_init (GdkWin32PopupClass *class)

 static gboolean
 gdk_win32_popup_present (GdkPopup       *popup,
-                         int             width,
-                         int             height,
-                         GdkPopupLayout *layout)
+                           int             width,
+                           int             height,
+                           GdkPopupLayout *layout)
 {
  return gdk_win32_surface_present_popup (GDK_SURFACE (popup), width, height, layout);
 }
@@ -5045,9 +5036,9 @@ gdk_win32_drag_surface_iface_init (GdkDragSurfaceInterface *iface)

 #ifdef GDK_WIN32_ENABLE_EGL
 EGLSurface
-gdk_win32_surface_get_egl_surface (GdkSurface *surface,
-                                   EGLConfig   config,
-                                   gboolean    is_dummy)
+_gdk_win32_surface_get_egl_surface (GdkSurface *surface,
+                                    EGLConfig   config,
+                                    gboolean    is_dummy)
 {
  GdkWin32Display *display = GDK_WIN32_DISPLAY (gdk_surface_get_display (surface));
  GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
@@ -5066,10 +5057,7 @@ gdk_win32_surface_get_egl_surface (GdkSurface *surface,
  else
    {
      if (impl->egl_surface == EGL_NO_SURFACE)
-        impl->egl_surface = eglCreateWindowSurface (display->egl_disp,
-                                                    config,
-                                                    GDK_SURFACE_HWND (surface),
-                                                    NULL);
+        impl->egl_surface = eglCreateWindowSurface (display->egl_disp, config, display->gl_hwnd, NULL);

      return impl->egl_surface;
    }
@@ -5152,20 +5140,3 @@ gdk_win32_surface_handle_queued_move_resize (GdkDrawContext *draw_context)

  return queued_window_rect;
 }
-
-void
-_gdk_win32_surface_invalidate_egl_framebuffer (GdkSurface *surface)
-{
-/* If we are using ANGLE, we need to force redraw of the whole Window and its child windows
- *  as we need to re-acquire the EGL surfaces that we rendered to upload to Cairo explicitly,
- *  using gdk_window_invalidate_rect (), when we maximize or restore or use aerosnap
- */
-#ifdef GDK_WIN32_ENABLE_EGL
-  if (surface->gl_paint_context != NULL && gdk_gl_context_get_use_es (surface->gl_paint_context))
-    {
-      GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
-
-      impl->egl_force_redraw_all = TRUE;
-    }
-#endif
-}
@@ -379,9 +379,9 @@ RECT
 gdk_win32_surface_handle_queued_move_resize (GdkDrawContext *draw_context);

 #ifdef GDK_WIN32_ENABLE_EGL
-EGLSurface gdk_win32_surface_get_egl_surface (GdkSurface *surface,
-                                              EGLConfig   config,
-                                              gboolean    is_dummy);
+EGLSurface _gdk_win32_surface_get_egl_surface (GdkSurface *surface,
+                                               EGLConfig   config,
+                                               gboolean    is_dummy);
 #endif

 G_END_DECLS
@@ -13,7 +13,6 @@ gdk_win32_sources = files([
  'gdkdrop-win32.c',
  'gdkevents-win32.c',
  'gdkglcontext-win32.c',
-  'gdkglcontext-win32-wgl.c',
  'gdkglobals-win32.c',
  'gdkhdataoutputstream-win32.c',
  'gdkkeys-win32.c',
@@ -48,7 +47,6 @@ GDK_WIN32_EGL_CFLAGS = []

 if win32_has_egl
  GDK_WIN32_EGL_CFLAGS = ['-DGDK_WIN32_ENABLE_EGL']
-  gdk_win32_sources += ['gdkglcontext-win32-egl.c']
 endif

 gdk_win32_deps = [ # FIXME
@@ -69,6 +69,10 @@

 #include <X11/extensions/shape.h>

+#ifdef HAVE_XCOMPOSITE
+#include <X11/extensions/Xcomposite.h>
+#endif
+
 #ifdef HAVE_RANDR
 #include <X11/extensions/Xrandr.h>
 #endif
@@ -1335,70 +1339,20 @@ set_sm_client_id (GdkDisplay  *display,
                     gdk_x11_get_xatom_by_name_for_display (display, "SM_CLIENT_ID"));
 }

-static void
-gdk_x11_display_query_default_visual (GdkX11Display  *self,
-                                      Visual        **out_visual,
-                                      int            *out_depth)
+void
+gdk_display_setup_window_visual (GdkDisplay *display,
+                                 int         depth,
+                                 Visual     *visual,
+                                 Colormap    colormap,
+                                 gboolean    rgba)
 {
-  XVisualInfo template, *visinfo;
-  int n_visuals;
-  Display *dpy;
+  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);

-  dpy = gdk_x11_display_get_xdisplay (GDK_DISPLAY (self));
+  display_x11->window_depth = depth;
+  display_x11->window_visual = visual;
+  display_x11->window_colormap = colormap;

-  template.screen = self->screen->screen_num;
-  template.depth = 32;
-  template.red_mask  = 0xff0000;
-  template.green_mask = 0x00ff00;
-  template.blue_mask = 0x0000ff;
-
-  visinfo = XGetVisualInfo (dpy,
-                            VisualScreenMask | VisualDepthMask
-                            | VisualRedMaskMask | VisualGreenMaskMask | VisualBlueMaskMask,
-                            &template,
-                            &n_visuals);
-  if (visinfo != NULL)
-    {
-      *out_visual = visinfo[0].visual;
-      *out_depth = visinfo[0].depth;
-      XFree (visinfo);
-      return;
-    }
-
-  *out_visual = DefaultVisual (dpy, self->screen->screen_num);
-  *out_depth = DefaultDepth (dpy, self->screen->screen_num);
-}
-
-static void
-gdk_x11_display_init_leader_surface (GdkX11Display *self)
-{
-  GdkDisplay *display = GDK_DISPLAY (self);
-  Display *xdisplay = gdk_x11_display_get_xdisplay (display);
-
-  self->window_colormap = XCreateColormap (xdisplay,
-                                           DefaultRootWindow (xdisplay),
-                                           self->window_visual,
-                                           AllocNone);
-  gdk_display_set_rgba (display, self->window_depth == 32);
-
-  /* We need to initialize events after we have the screen
-   * structures in places
-   */
-  _gdk_x11_xsettings_init (GDK_X11_SCREEN (self->screen));
-
-  self->device_manager = _gdk_x11_device_manager_new (display);
-
-  gdk_event_init (display);
-
-  self->leader_gdk_surface =
-      _gdk_x11_display_create_surface (display,
-                                       GDK_SURFACE_TEMP,
-                                       NULL,
-                                       -100, -100, 1, 1);
-
-  (_gdk_x11_surface_get_toplevel (self->leader_gdk_surface))->is_leader = TRUE;
-  self->leader_window = GDK_SURFACE_XID (self->leader_gdk_surface);
-  self->leader_window_title_set = FALSE;
+  gdk_display_set_rgba (display, rgba);
 }

 /**
@@ -1466,20 +1420,28 @@ gdk_x11_display_open (const char *display_name)
 #endif

  /* initialize the display's screens */ 
-  display_x11->screen = _gdk_x11_screen_new (display, DefaultScreen (display_x11->xdisplay));
+  display_x11->screen = _gdk_x11_screen_new (display, DefaultScreen (display_x11->xdisplay), TRUE);

-  /* If GL is available we want to pick better default/rgba visuals,
-   * as we care about GLX details such as alpha/depth/stencil depth,
-   * stereo and double buffering
-   *
-   * Note that this also sets up the leader surface while creating the inital
-   * GL context.
+  /* We need to initialize events after we have the screen
+   * structures in places
   */
-  if (!gdk_display_prepare_gl (display, NULL))
-    {
-      gdk_x11_display_query_default_visual (display_x11, &display_x11->window_visual, &display_x11->window_depth);
-      gdk_x11_display_init_leader_surface (display_x11);
-    }
+  _gdk_x11_xsettings_init (GDK_X11_SCREEN (display_x11->screen));
+
+  display_x11->device_manager = _gdk_x11_device_manager_new (display);
+
+  gdk_event_init (display);
+
+  display_x11->leader_gdk_surface =
+      _gdk_x11_display_create_surface (display,
+                                       GDK_SURFACE_TEMP,
+                                       NULL,
+                                       -100, -100, 1, 1);
+
+  (_gdk_x11_surface_get_toplevel (display_x11->leader_gdk_surface))->is_leader = TRUE;
+
+  display_x11->leader_window = GDK_SURFACE_XID (display_x11->leader_gdk_surface);
+
+  display_x11->leader_window_title_set = FALSE;

 #ifdef HAVE_XFIXES
  if (XFixesQueryExtension (display_x11->xdisplay, 
@@ -1492,6 +1454,24 @@ gdk_x11_display_open (const char *display_name)
 #endif
    display_x11->have_xfixes = FALSE;

+#ifdef HAVE_XCOMPOSITE
+  if (XCompositeQueryExtension (display_x11->xdisplay,
+				&ignore, &ignore))
+    {
+      int major, minor;
+
+      XCompositeQueryVersion (display_x11->xdisplay, &major, &minor);
+
+      /* Prior to Composite version 0.4, composited windows clipped their
+       * parents, so you had to use IncludeInferiors to draw to the parent
+       * This isn't useful for our purposes, so require 0.4
+       */
+      display_x11->have_xcomposite = major > 0 || (major == 0 && minor >= 4);
+    }
+  else
+#endif
+    display_x11->have_xcomposite = FALSE;
+
  display_x11->have_shapes = FALSE;
  display_x11->have_input_shapes = FALSE;

@@ -1948,6 +1928,7 @@ gdk_x11_display_finalize (GObject *object)

  /* Free all GdkX11Screens */
  g_object_unref (display_x11->screen);
+  g_list_free_full (display_x11->screens, g_object_unref);

  g_list_store_remove_all (display_x11->monitors);
  g_object_unref (display_x11->monitors);
@@ -1959,8 +1940,6 @@ gdk_x11_display_finalize (GObject *object)

  XCloseDisplay (display_x11->xdisplay);

-  g_clear_error (&display_x11->gl_error);
-
  /* error traps */
  while (display_x11->error_traps != NULL)
    {
@@ -2014,6 +1993,52 @@ gdk_x11_lookup_xdisplay (Display *xdisplay)
  return display;
 }

+/*
+ * _gdk_x11_display_screen_for_xrootwin:
+ * @display: a `GdkDisplay`
+ * @xrootwin: window ID for one of the screen’s of the display.
+ *
+ * Given the root window ID of one of the screen’s of a `GdkDisplay`,
+ * finds the screen.
+ *
+ * Returns: (transfer none): the `GdkX11Screen` corresponding to @xrootwin
+ */
+GdkX11Screen *
+_gdk_x11_display_screen_for_xrootwin (GdkDisplay *display,
+				      Window      xrootwin)
+{
+  GdkX11Screen *screen;
+  XWindowAttributes attrs;
+  gboolean result;
+  GdkX11Display *display_x11;
+  GList *l;
+
+  screen = GDK_X11_DISPLAY (display)->screen;
+
+  if (GDK_SCREEN_XROOTWIN (screen) == xrootwin)
+    return screen;
+
+  display_x11 = GDK_X11_DISPLAY (display);
+
+  for (l = display_x11->screens; l; l = l->next)
+    {
+      screen = l->data;
+      if (GDK_SCREEN_XROOTWIN (screen) == xrootwin)
+        return screen;
+    }
+
+  gdk_x11_display_error_trap_push (display);
+  result = XGetWindowAttributes (display_x11->xdisplay, xrootwin, &attrs);
+  if (gdk_x11_display_error_trap_pop (display) || !result)
+    return NULL;
+
+  screen = _gdk_x11_screen_new (display, XScreenNumberOfScreen (attrs.screen), FALSE);
+
+  display_x11->screens = g_list_prepend (display_x11->screens, screen);
+
+  return screen;
+}
+
 /**
 * gdk_x11_display_get_xdisplay:
 * @display: (type GdkX11Display): a `GdkDisplay`
@@ -2885,60 +2910,6 @@ gdk_boolean_handled_accumulator (GSignalInvocationHint *ihint,
  return continue_emission;
 }

-static gboolean
-gdk_x11_display_init_gl_backend (GdkX11Display  *self,
-                                 Visual        **out_visual,
-                                 int            *out_depth,
-                                 GError        **error)
-{
-  GdkDisplay *display G_GNUC_UNUSED = GDK_DISPLAY (self);
-
-  if (GDK_DISPLAY_DEBUG_CHECK (display, GL_EGL))
-    return gdk_x11_display_init_egl (self, TRUE, out_visual, out_depth, error);
-  if (GDK_DISPLAY_DEBUG_CHECK (display, GL_GLX))
-    return gdk_x11_display_init_glx (self, out_visual, out_depth, error);
-
-  /* No env vars set, do the regular GL initialization.
-   * 
-   * We try EGL first, but are very picky about what we accept.
-   * If that fails, we try to go with GLX instead.
-   * And if that also fails, we try EGL again, but this time accept anything.
-   *
-   * The idea here is that EGL is the preferred method going forward, but GLX is
-   * the tried and tested method that we know works. So if we detect issues with
-   * EGL, we want to avoid using it in favor of GLX.
-   */
-
-  if (gdk_x11_display_init_egl (self, FALSE, out_visual, out_depth, error))
-    return TRUE;
-  g_clear_error (error);
-
-  if (gdk_x11_display_init_glx (self, out_visual, out_depth, error))
-    return TRUE;
-  g_clear_error (error);
-
-  return gdk_x11_display_init_egl (self, TRUE, out_visual, out_depth, error);
-}
-
-static GdkGLContext *
-gdk_x11_display_init_gl (GdkDisplay  *display,
-                         GError     **error)
-{
-  GdkX11Display *self = GDK_X11_DISPLAY (display);
-
-  if (!gdk_x11_display_init_gl_backend (self, &self->window_visual, &self->window_depth, error))
-    return FALSE;
-
-  gdk_x11_display_init_leader_surface (self);
-
-  if (self->egl_display)
-    return g_object_new (GDK_TYPE_X11_GL_CONTEXT_EGL, "surface", self->leader_gdk_surface, NULL);
-  else if (self->glx_config != NULL)
-    return g_object_new (GDK_TYPE_X11_GL_CONTEXT_GLX, "surface", self->leader_gdk_surface, NULL);
-  else
-    g_return_val_if_reached (NULL);
-}
-
 static void
 gdk_x11_display_class_init (GdkX11DisplayClass * class)
 {
@@ -2969,7 +2940,7 @@ gdk_x11_display_class_init (GdkX11DisplayClass * class)
  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;
+  display_class->make_gl_context_current = gdk_x11_display_make_gl_context_current;

  display_class->get_default_seat = gdk_x11_display_get_default_seat;

@@ -42,6 +42,7 @@ struct _GdkX11Display
  GdkDisplay parent_instance;
  Display *xdisplay;
  GdkX11Screen *screen;
+  GList *screens;
  GList *toplevels;
  GdkX11DeviceManagerXI2 *device_manager;

@@ -70,6 +71,8 @@ struct _GdkX11Display
  gboolean have_xfixes;
  int xfixes_event_base;

+  gboolean have_xcomposite;
+
  gboolean have_randr12;
  gboolean have_randr13;
  gboolean have_randr15;
@@ -129,17 +132,12 @@ struct _GdkX11Display
  guint have_damage;
 #endif

-  /* If GL is not supported, store the error here */
-  GError *gl_error;
-
  /* GLX information */
-  /* GLXFBConfig */ gpointer glx_config;
  int glx_version;
+  int glx_error_base;
+  int glx_event_base;

  /* EGL information */
-  /* We use gpointer here so we don't have to pull in EGL headers (which glx doesn't like) */
-  /* EGLDisplay */ gpointer egl_display;
-  /* EGLConfig */ gpointer egl_config;
  int egl_version;

  /* Translation between X server time and system-local monotonic time */
@@ -148,6 +146,9 @@ struct _GdkX11Display

  guint server_time_is_monotonic_time : 1;

+  guint have_glx : 1;
+  guint have_egl : 1;
+
  /* GLX extensions we check */
  guint has_glx_swap_interval : 1;
  guint has_glx_create_context : 1;
@@ -164,6 +165,7 @@ struct _GdkX11Display
  guint has_egl_khr_create_context : 1;
  guint has_egl_buffer_age : 1;
  guint has_egl_swap_buffers_with_damage : 1;
+  guint has_egl_surfaceless_context : 1;
 };

 struct _GdkX11DisplayClass
@@ -174,6 +176,8 @@ struct _GdkX11DisplayClass
                                                                 const XEvent           *event);
 };

+GdkX11Screen *  _gdk_x11_display_screen_for_xrootwin            (GdkDisplay             *display,
+                                                                 Window                  xrootwin);
 void            _gdk_x11_display_error_event                    (GdkDisplay             *display,
                                                                 XErrorEvent            *error);
 gsize           gdk_x11_display_get_max_request_size            (GdkDisplay             *display);
@@ -47,6 +47,9 @@
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/shape.h>
+#ifdef HAVE_XCOMPOSITE
+#include <X11/extensions/Xcomposite.h>
+#endif

 #include <string.h>

@@ -515,6 +518,9 @@ gdk_surface_cache_new (GdkDisplay *display)
  Window xroot_window = GDK_DISPLAY_XROOTWIN (display);
  GdkChildInfoX11 *children;
  guint nchildren, i;
+#ifdef HAVE_XCOMPOSITE
+  Window cow;
+#endif

  GdkSurfaceCache *result = g_new (GdkSurfaceCache, 1);

@@ -565,6 +571,27 @@ gdk_surface_cache_new (GdkDisplay *display)

  g_free (children);

+#ifdef HAVE_XCOMPOSITE
+  /*
+   * Add the composite overlay window to the cache, as this can be a reasonable
+   * Xdnd proxy as well.
+   * This is only done when the screen is composited in order to avoid mapping
+   * the COW. We assume that the CM is using the COW (which is true for pretty
+   * much any CM currently in use).
+   */
+  if (gdk_display_is_composited (display))
+    {
+      gdk_x11_display_error_trap_push (display);
+      cow = XCompositeGetOverlayWindow (xdisplay, xroot_window);
+      gdk_surface_cache_add (result, cow, 0, 0,
+			    WidthOfScreen (GDK_X11_SCREEN (screen)->xscreen),
+			    HeightOfScreen (GDK_X11_SCREEN (screen)->xscreen),
+			    TRUE);
+      XCompositeReleaseOverlayWindow (xdisplay, xroot_window);
+      gdk_x11_display_error_trap_pop_ignored (display);
+    }
+#endif
+
  return result;
 }

@@ -45,6 +45,9 @@
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
 #include <X11/extensions/shape.h>
+#ifdef HAVE_XCOMPOSITE
+#include <X11/extensions/Xcomposite.h>
+#endif

 #include <string.h>

@@ -19,6 +19,7 @@
 #include "gdkx11glcontext.h"
 #include "gdkx11screen.h"
 #include "gdkx11surface.h"
+#include "gdkvisual-x11.h"
 #include "gdkx11property.h"
 #include <X11/Xatom.h>

@@ -34,15 +35,55 @@ struct _GdkX11GLContextEGL
 {
  GdkX11GLContext parent_instance;

+  EGLDisplay egl_display;
+  EGLConfig egl_config;
  EGLContext egl_context;
-
-  guint do_frame_sync : 1;
 };

+typedef struct {
+  EGLDisplay egl_display;
+  EGLConfig egl_config;
+  EGLSurface egl_surface;
+
+  /* Only set by the dummy surface we attach to the display */
+  Display *xdisplay;
+  Window dummy_xwin;
+  XVisualInfo *xvisinfo;
+} DrawableInfo;
+
 typedef struct _GdkX11GLContextClass    GdkX11GLContextEGLClass;

 G_DEFINE_TYPE (GdkX11GLContextEGL, gdk_x11_gl_context_egl, GDK_TYPE_X11_GL_CONTEXT)

+static void
+drawable_info_free (gpointer data)
+{
+  DrawableInfo *info = data;
+
+  if (data == NULL)
+    return;
+
+  if (info->egl_surface != NULL)
+    {
+      eglDestroySurface (info->egl_display, info->egl_surface);
+      info->egl_surface = NULL;
+    }
+
+  if (info->dummy_xwin != None)
+    {
+      XDestroyWindow (info->xdisplay, info->dummy_xwin);
+      info->dummy_xwin = None;
+    }
+
+  if (info->xvisinfo != NULL)
+    {
+      XFree (info->xvisinfo);
+      info->xvisinfo = NULL;
+    }
+
+  g_free (info);
+}
+
 /**
 * gdk_x11_display_get_egl_display:
 * @display: (type GdkX11Display): an X11 display
@@ -58,23 +99,19 @@ G_DEFINE_TYPE (GdkX11GLContextEGL, gdk_x11_gl_context_egl, GDK_TYPE_X11_GL_CONTE
 gpointer
 gdk_x11_display_get_egl_display (GdkDisplay *display)
 {
-  GdkX11Display *self;
+  EGLDisplay edpy = NULL;
+  Display *dpy;

  g_return_val_if_fail (GDK_IS_X11_DISPLAY (display), NULL);

-  self = GDK_X11_DISPLAY (display);
+  if (GDK_X11_DISPLAY (display)->have_glx)
+    return NULL;

-  return self->egl_display;
-}
+  edpy = g_object_get_data (G_OBJECT (display), "-gdk-x11-egl-display");
+  if (edpy != NULL)
+    return edpy;

-static void
-gdk_x11_display_create_egl_display (GdkX11Display *self)
-{
-  Display *dpy;
-
-  g_assert (self->egl_display == NULL);
-
-  dpy = gdk_x11_display_get_xdisplay (GDK_DISPLAY (self));
+  dpy = gdk_x11_display_get_xdisplay (display);

  if (epoxy_has_egl_extension (NULL, "EGL_KHR_platform_base"))
    {
@@ -82,10 +119,10 @@ gdk_x11_display_create_egl_display (GdkX11Display *self)
        (void *) eglGetProcAddress ("eglGetPlatformDisplay");

      if (getPlatformDisplay != NULL)
-        self->egl_display = getPlatformDisplay (EGL_PLATFORM_X11_KHR, dpy, NULL);
+        edpy = getPlatformDisplay (EGL_PLATFORM_X11_KHR, dpy, NULL);

-      if (self->egl_display != NULL)
-        return;
+      if (edpy != NULL)
+        goto out;
    }

  if (epoxy_has_egl_extension (NULL, "EGL_EXT_platform_base"))
@@ -94,231 +131,145 @@ gdk_x11_display_create_egl_display (GdkX11Display *self)
        (void *) eglGetProcAddress ("eglGetPlatformDisplayEXT");

      if (getPlatformDisplay)
-        self->egl_display = getPlatformDisplay (EGL_PLATFORM_X11_EXT, dpy, NULL);
+        edpy = getPlatformDisplay (EGL_PLATFORM_X11_EXT, dpy, NULL);

-      if (self->egl_display != NULL)
-        return;
+      if (edpy != NULL)
+        goto out;
    }

-  self->egl_display = eglGetDisplay ((EGLNativeDisplayType) dpy);
+  edpy = eglGetDisplay ((EGLNativeDisplayType) dpy);
+
+out:
+  if (edpy != NULL)
+    g_object_set_data (G_OBJECT (display), "-gdk-x11-egl-display", edpy);
+
+  return edpy;
 }

 static XVisualInfo *
-gdk_x11_display_get_visual_info_for_visual (GdkX11Display  *self,
-                                            VisualID        visualid)
+get_visual_info_for_egl_config (GdkDisplay *display,
+                                EGLConfig   egl_config)
 {
-  XVisualInfo template, *visinfo;
-  int nvisuals;
+  XVisualInfo visinfo_template;
+  int template_mask = 0;
+  XVisualInfo *visinfo = NULL;
+  int visinfos_count;
+  EGLint visualid, red_size, green_size, blue_size, alpha_size;
+  EGLDisplay egl_display = gdk_x11_display_get_egl_display (display);

-  template.screen = self->screen->screen_num;
-  template.visualid = visualid;
+  eglGetConfigAttrib (egl_display, egl_config, EGL_NATIVE_VISUAL_ID, &visualid);
+
+  if (visualid != 0)
+    {
+      visinfo_template.visualid = visualid;
+      template_mask |= VisualIDMask;
+    }
+  else
+    {
+      /* some EGL drivers don't implement the EGL_NATIVE_VISUAL_ID
+       * attribute, so attempt to find the closest match.
+       */
+      eglGetConfigAttrib (egl_display, egl_config, EGL_RED_SIZE, &red_size);
+      eglGetConfigAttrib (egl_display, egl_config, EGL_GREEN_SIZE, &green_size);
+      eglGetConfigAttrib (egl_display, egl_config, EGL_BLUE_SIZE, &blue_size);
+      eglGetConfigAttrib (egl_display, egl_config, EGL_ALPHA_SIZE, &alpha_size);
+
+      visinfo_template.depth = red_size + green_size + blue_size + alpha_size;
+      template_mask |= VisualDepthMask;
+
+      visinfo_template.screen = DefaultScreen (gdk_x11_display_get_xdisplay (display));
+      template_mask |= VisualScreenMask;
+    }
+
+  visinfo = XGetVisualInfo (gdk_x11_display_get_xdisplay (display),
+                            template_mask,
+                            &visinfo_template,
+                            &visinfos_count);
+
+  if (visinfos_count < 1)
+    return NULL;

-  visinfo = XGetVisualInfo (gdk_x11_display_get_xdisplay (GDK_DISPLAY (self)),
-                            VisualScreenMask | VisualIDMask,
-                            &template,
-                            &nvisuals);
-  g_warn_if_fail (nvisuals == 1);
-  
  return visinfo;
 }

-static gboolean
-visual_is_rgba (XVisualInfo *visinfo)
+static EGLSurface
+gdk_x11_display_get_egl_dummy_surface (GdkDisplay *display,
+                                       EGLConfig   egl_config)
 {
-  return
-    visinfo->depth == 32 &&
-    visinfo->visual->red_mask   == 0xff0000 &&
-    visinfo->visual->green_mask == 0x00ff00 &&
-    visinfo->visual->blue_mask  == 0x0000ff;
+  DrawableInfo *info;
+  XVisualInfo *xvisinfo;
+  XSetWindowAttributes attrs;
+
+  info = g_object_get_data (G_OBJECT (display), "-gdk-x11-egl-dummy-surface");
+  if (info != NULL)
+    return info->egl_surface;
+
+  xvisinfo = get_visual_info_for_egl_config (display, egl_config);
+  if (xvisinfo == NULL)
+    return NULL;
+
+  info = g_new (DrawableInfo, 1);
+  info->xdisplay = gdk_x11_display_get_xdisplay (display);
+  info->xvisinfo = xvisinfo;
+  info->egl_display = gdk_x11_display_get_egl_display (display);
+  info->egl_config = egl_config;
+
+  attrs.override_redirect = True;
+  attrs.colormap = XCreateColormap (info->xdisplay,
+                                    DefaultRootWindow (info->xdisplay),
+                                    xvisinfo->visual,
+                                    AllocNone);
+  attrs.border_pixel = 0;
+
+  info->dummy_xwin =
+    XCreateWindow (info->xdisplay,
+                   DefaultRootWindow (info->xdisplay),
+                   -100, -100, 1, 1,
+                   0,
+                   xvisinfo->depth,
+                   CopyFromParent,
+                   xvisinfo->visual,
+                   CWOverrideRedirect | CWColormap | CWBorderPixel,
+                   &attrs);
+
+  info->egl_surface =
+    eglCreateWindowSurface (info->egl_display,
+                            info->egl_config,
+                            (EGLNativeWindowType) info->dummy_xwin,
+                            NULL);
+
+  g_object_set_data_full (G_OBJECT (display), "-gdk-x11-egl-dummy-surface",
+                          info,
+                          drawable_info_free);
+
+  return info->egl_surface;
 }

-#define MAX_EGL_ATTRS   30
-
-static gboolean
-gdk_x11_display_create_egl_config (GdkX11Display  *display,
-                                   gboolean        force,
-                                   Visual        **out_visual,
-                                   int            *out_depth,
-                                   GError        **error)
-{
-  GdkX11Display *self = GDK_X11_DISPLAY (display);
-  EGLint attrs[MAX_EGL_ATTRS];
-  EGLConfig *configs;
-  EGLint count, alloced;
-  enum {
-    NO_VISUAL_FOUND,
-    WITH_MULTISAMPLING,
-    WITH_STENCIL_AND_DEPTH_BUFFER,
-    NO_ALPHA,
-    NO_ALPHA_VISUAL,
-    PERFECT
-  } best_features;
-
-  int i = 0;
-
-  attrs[i++] = EGL_SURFACE_TYPE;
-  attrs[i++] = EGL_WINDOW_BIT;
-
-  attrs[i++] = EGL_COLOR_BUFFER_TYPE;
-  attrs[i++] = EGL_RGB_BUFFER;
-
-  attrs[i++] = EGL_RED_SIZE;
-  attrs[i++] = 8;
-  attrs[i++] = EGL_GREEN_SIZE;
-  attrs[i++] = 8;
-  attrs[i++] = EGL_BLUE_SIZE;
-  attrs[i++] = 8;
-  attrs[i++] = EGL_ALPHA_SIZE;
-  attrs[i++] = 8;
-
-  attrs[i++] = EGL_NONE;
-  g_assert (i < MAX_EGL_ATTRS);
-
-  if (!eglChooseConfig (self->egl_display, attrs, NULL, -1, &alloced) || alloced == 0)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("No EGL configuration available"));
-      return FALSE;
-    }
-
-  configs = g_new (EGLConfig, alloced);
-  if (!eglChooseConfig (self->egl_display, attrs, configs, alloced, &count))
-    {
-      g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Failed to get EGL configurations"));
-      return FALSE;
-    }
-  g_warn_if_fail (alloced == count);
-
-  best_features = NO_VISUAL_FOUND;
-
-  for (i = 0; i < count; i++)
-    {
-      XVisualInfo *visinfo;
-      int tmp, visualid;
-
-      if (!eglGetConfigAttrib (self->egl_display, configs[i], EGL_NATIVE_VISUAL_ID, &visualid))
-        continue;
-
-      visinfo = gdk_x11_display_get_visual_info_for_visual (self, visualid);
-      if (visinfo == NULL)
-        continue;
-
-      if (!eglGetConfigAttrib (self->egl_display, configs[i], EGL_SAMPLE_BUFFERS, &tmp) || tmp != 0)
-        {
-          if (best_features < WITH_MULTISAMPLING)
-            {
-              GDK_NOTE (OPENGL, g_message ("Best EGL config is %u for visual 0x%lX with multisampling", i, visinfo->visualid));
-              best_features = WITH_MULTISAMPLING;
-              *out_visual = visinfo->visual;
-              *out_depth = visinfo->depth;
-              self->egl_config = configs[i];
-            }
-          XFree (visinfo);
-          continue;
-        }
-
-      if (!eglGetConfigAttrib (self->egl_display, configs[i], EGL_DEPTH_SIZE, &tmp) || tmp != 0 ||
-          !eglGetConfigAttrib (self->egl_display, configs[i], EGL_STENCIL_SIZE, &tmp) || tmp != 0)
-        {
-          GDK_NOTE (OPENGL, g_message ("Best EGL config is %u for visual 0x%lX with stencil or depth buffer", i, visinfo->visualid));
-          if (best_features < WITH_STENCIL_AND_DEPTH_BUFFER)
-            {
-              best_features = WITH_STENCIL_AND_DEPTH_BUFFER;
-              *out_visual = visinfo->visual;
-              *out_depth = visinfo->depth;
-              self->egl_config = configs[i];
-            }
-          XFree (visinfo);
-          continue;
-        }
-    
-      if (!visual_is_rgba (visinfo))
-        {
-          GDK_NOTE (OPENGL, g_message ("Best EGL config is %u for visual 0x%lX without RGBA Visual", i, visinfo->visualid));
-          if (best_features < NO_ALPHA_VISUAL)
-            {
-              best_features = NO_ALPHA_VISUAL;
-              *out_visual = visinfo->visual;
-              *out_depth = visinfo->depth;
-              self->egl_config = configs[i];
-            }
-          XFree (visinfo);
-          continue;
-        }
-
-      GDK_NOTE (OPENGL, g_message ("EGL Config %u for visual 0x%lX is the perfect choice", i, visinfo->visualid));
-      *out_visual = visinfo->visual;
-      *out_depth = visinfo->depth;
-      self->egl_config = configs[i];
-      XFree (visinfo);
-      /* everything is perfect */
-      best_features = PERFECT;
-      break;
-    }
-
-  g_free (configs);
-
-  if (best_features == NO_VISUAL_FOUND)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("No EGL configuration with required features found"));
-      return FALSE;
-    }
-  else if (!force && best_features != PERFECT)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("No perfect EGL configuration found"));
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-#undef MAX_EGL_ATTRS
-
 static EGLSurface
-gdk_x11_surface_get_egl_surface (GdkSurface *surface)
+gdk_x11_surface_get_egl_surface (GdkSurface *surface,
+                                 EGLConfig   config)
 {
-  GdkX11Surface *self = GDK_X11_SURFACE (surface);
-  GdkDisplay *display = gdk_surface_get_display (GDK_SURFACE (self));
-  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+  GdkDisplay *display = gdk_surface_get_display (surface);
+  EGLDisplay egl_display = gdk_x11_display_get_egl_display (display);
+  DrawableInfo *info;

-  if (self->egl_surface)
-    return self->egl_surface;
+  info = g_object_get_data (G_OBJECT (surface), "-gdk-x11-egl-drawable");
+  if (info != NULL)
+    return info->egl_surface;

-  self->egl_surface =
-    eglCreateWindowSurface (display_x11->egl_display, 
-                            display_x11->egl_config,
+  info = g_new0 (DrawableInfo, 1);
+  info->egl_display = egl_display;
+  info->egl_config = config;
+  info->egl_surface =
+    eglCreateWindowSurface (info->egl_display, config,
                            (EGLNativeWindowType) gdk_x11_surface_get_xid (surface),
                            NULL);

-  return self->egl_surface;
-}
+  g_object_set_data_full (G_OBJECT (surface), "-gdk-x11-egl-drawable",
+                          info,
+                          drawable_info_free);

-void
-gdk_x11_surface_destroy_egl_surface (GdkX11Surface *self)
-{
-  GdkX11Display *display_x11;
-
-  if (self->egl_surface == NULL)
-    return;
-
-  display_x11 = GDK_X11_DISPLAY (gdk_surface_get_display (GDK_SURFACE (self)));
-
-  eglDestroySurface (display_x11->egl_display, self->egl_surface);
-  self->egl_surface = NULL;
-}
-
-static void
-gdk_x11_gl_context_egl_begin_frame (GdkDrawContext *draw_context,
-                                    cairo_region_t *region)
-{
-  GDK_DRAW_CONTEXT_CLASS (gdk_x11_gl_context_egl_parent_class)->begin_frame (draw_context, region);
-
-  glDrawBuffers (1, (GLenum[1]) { GL_BACK });
+  return info->egl_surface;
 }

 static void
@@ -326,16 +277,20 @@ gdk_x11_gl_context_egl_end_frame (GdkDrawContext *draw_context,
                                  cairo_region_t *painted)
 {
  GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
+  GdkX11GLContextEGL *context_egl = GDK_X11_GL_CONTEXT_EGL (context);
  GdkSurface *surface = gdk_gl_context_get_surface (context);
  GdkDisplay *display = gdk_surface_get_display (surface);
  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+  EGLDisplay egl_display = gdk_x11_display_get_egl_display (display);
  EGLSurface egl_surface;

  GDK_DRAW_CONTEXT_CLASS (gdk_x11_gl_context_egl_parent_class)->end_frame (draw_context, painted);
+  if (gdk_gl_context_get_shared_context (context) != NULL)
+    return;

  gdk_gl_context_make_current (context);

-  egl_surface = gdk_x11_surface_get_egl_surface (surface);
+  egl_surface = gdk_x11_surface_get_egl_surface (surface, context_egl->egl_config);

  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "x11", "swap buffers");
  if (display_x11->has_egl_swap_buffers_with_damage)
@@ -364,74 +319,11 @@ gdk_x11_gl_context_egl_end_frame (GdkDrawContext *draw_context,
          rects[j++] = rect.height * scale;
        }

-      eglSwapBuffersWithDamageEXT (display_x11->egl_display, egl_surface, rects, n_rects);
+      eglSwapBuffersWithDamageEXT (egl_display, egl_surface, rects, n_rects);
      g_free (heap_rects);
    }
  else
-    eglSwapBuffers (display_x11->egl_display, egl_surface);
-}
-
-static gboolean
-gdk_x11_gl_context_egl_clear_current (GdkGLContext *context)
-{
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
-
-  return eglMakeCurrent (display_x11->egl_display,
-                         EGL_NO_SURFACE,
-                         EGL_NO_SURFACE,
-                         EGL_NO_CONTEXT);
-}
-
-static gboolean
-gdk_x11_gl_context_egl_make_current (GdkGLContext *context,
-                                     gboolean      surfaceless)
-{
-  GdkX11GLContextEGL *self = GDK_X11_GL_CONTEXT_EGL (context);
-  GdkDisplay *display = gdk_gl_context_get_display (context);
-  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
-  GdkSurface *surface;
-  EGLSurface egl_surface;
-  gboolean do_frame_sync = FALSE;
-
-  if (surfaceless)
-    {
-      return eglMakeCurrent (display_x11->egl_display,
-                             EGL_NO_SURFACE,
-                             EGL_NO_SURFACE,
-                             self->egl_context);
-    }
-
-  surface = gdk_gl_context_get_surface (context);
-  egl_surface = gdk_x11_surface_get_egl_surface (surface);
-
-  GDK_DISPLAY_NOTE (display, OPENGL,
-                    g_message ("Making EGL context %p current to surface %p",
-                               self->egl_context, egl_surface));
-
-  if (!eglMakeCurrent (display_x11->egl_display,
-                       egl_surface,
-                       egl_surface,
-                       self->egl_context))
-    return FALSE;
-
-  /* If the WM is compositing there is no particular need to delay
-   * the swap when drawing on the offscreen, rendering to the screen
-   * happens later anyway, and its up to the compositor to sync that
-   * to the vblank. */
-  do_frame_sync = ! gdk_display_is_composited (display);
-
-  if (do_frame_sync != self->do_frame_sync)
-    {
-      self->do_frame_sync = do_frame_sync;
-
-      if (do_frame_sync)
-        eglSwapInterval (display_x11->egl_display, 1);
-      else
-        eglSwapInterval (display_x11->egl_display, 0);
-    }
-
-  return TRUE;
+    eglSwapBuffers (egl_display, egl_surface);
 }

 static cairo_region_t *
@@ -443,13 +335,20 @@ gdk_x11_gl_context_egl_get_damage (GdkGLContext *context)
  if (display_x11->has_egl_buffer_age)
    {
      GdkSurface *surface = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
+      GdkGLContext *shared = gdk_gl_context_get_shared_context (context);
+      GdkX11GLContextEGL *shared_egl;
      EGLSurface egl_surface;
      int buffer_age = 0;

-      egl_surface = gdk_x11_surface_get_egl_surface (surface);
-      gdk_gl_context_make_current (context);
+      shared = gdk_gl_context_get_shared_context (context);
+      if (shared == NULL)
+        shared = context;
+      shared_egl = GDK_X11_GL_CONTEXT_EGL (shared);

-      eglQuerySurface (display_x11->egl_display,
+      egl_surface = gdk_x11_surface_get_egl_surface (surface, shared_egl->egl_config);
+      gdk_gl_context_make_current (shared);
+
+      eglQuerySurface (gdk_x11_display_get_egl_display (display),
                       egl_surface,
                       EGL_BUFFER_AGE_EXT,
                       &buffer_age);
@@ -490,16 +389,20 @@ gdk_x11_gl_context_egl_realize (GdkGLContext  *context,
  GdkX11Display *display_x11;
  GdkDisplay *display;
  GdkX11GLContextEGL *context_egl;
-  GdkGLContext *share;
+  GdkGLContext *share, *shared_data_context;
+  GdkSurface *surface;
  gboolean debug_bit, forward_bit, legacy_bit, use_es;
  int major, minor, i = 0;
  EGLint context_attrs[N_EGL_ATTRS];
+  EGLDisplay egl_display;

-  display = gdk_gl_context_get_display (context);
+  surface = gdk_gl_context_get_surface (context);
+  display = gdk_surface_get_display (surface);

  context_egl = GDK_X11_GL_CONTEXT_EGL (context);
  display_x11 = GDK_X11_DISPLAY (display);
-  share = gdk_display_get_gl_context (display);
+  share = gdk_gl_context_get_shared_context (context);
+  shared_data_context = gdk_surface_get_shared_data_gl_context (surface);

  gdk_gl_context_get_required_version (context, &major, &minor);
  debug_bit = gdk_gl_context_get_debug_enabled (context);
@@ -562,12 +465,16 @@ gdk_x11_gl_context_egl_realize (GdkGLContext  *context,
                               legacy_bit ? "yes" : "no",
                               use_es ? "yes" : "no"));

+  egl_display = gdk_x11_display_get_egl_display (display);
+
  context_egl->egl_context =
-    eglCreateContext (display_x11->egl_display,
-                      display_x11->egl_config,
+    eglCreateContext (egl_display,
+                      context_egl->egl_config,
                      share != NULL
                        ? GDK_X11_GL_CONTEXT_EGL (share)->egl_context
-                        : EGL_NO_CONTEXT,
+                        : shared_data_context != NULL
+                            ? GDK_X11_GL_CONTEXT_EGL (shared_data_context)->egl_context
+                            : EGL_NO_CONTEXT,
                      context_attrs);

  /* If we're not asking for a GLES context, and we don't have the legacy bit set
@@ -586,11 +493,13 @@ gdk_x11_gl_context_egl_realize (GdkGLContext  *context,
                g_message ("Context creation failed; trying legacy EGL context"));

      context_egl->egl_context =
-        eglCreateContext (display_x11->egl_display,
-                          display_x11->egl_config,
+        eglCreateContext (egl_display,
+                          context_egl->egl_config,
                          share != NULL
                            ? GDK_X11_GL_CONTEXT_EGL (share)->egl_context
-                            : EGL_NO_CONTEXT,
+                            : shared_data_context != NULL
+                                ? GDK_X11_GL_CONTEXT_EGL (shared_data_context)->egl_context
+                                : EGL_NO_CONTEXT,
                          context_attrs);
    }

@@ -621,14 +530,15 @@ gdk_x11_gl_context_egl_dispose (GObject *gobject)
  if (context_egl->egl_context != NULL)
    {
      GdkGLContext *context = GDK_GL_CONTEXT (gobject);
-      GdkX11Display *display_x11 = GDK_X11_DISPLAY (gdk_gl_context_get_display (context));
+      GdkDisplay *display = gdk_gl_context_get_display (context);
+      EGLDisplay egl_display = gdk_x11_display_get_egl_display (display);

      /* Unset the current context if we're disposing it */
      if (eglGetCurrentContext () == context_egl->egl_context)
-        eglMakeCurrent (display_x11->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        eglMakeCurrent (egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

      GDK_NOTE (OPENGL, g_message ("Destroying EGL context"));
-      eglDestroyContext (display_x11->egl_display, context_egl->egl_context);
+      eglDestroyContext (egl_display, context_egl->egl_context);
      context_egl->egl_context = NULL;
    }

@@ -643,11 +553,8 @@ gdk_x11_gl_context_egl_class_init (GdkX11GLContextEGLClass *klass)
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  context_class->realize = gdk_x11_gl_context_egl_realize;
-  context_class->make_current = gdk_x11_gl_context_egl_make_current;
-  context_class->clear_current = gdk_x11_gl_context_egl_clear_current;
  context_class->get_damage = gdk_x11_gl_context_egl_get_damage;

-  draw_context_class->begin_frame = gdk_x11_gl_context_egl_begin_frame;
  draw_context_class->end_frame = gdk_x11_gl_context_egl_end_frame;

  gobject_class->dispose = gdk_x11_gl_context_egl_dispose;
@@ -656,84 +563,55 @@ gdk_x11_gl_context_egl_class_init (GdkX11GLContextEGLClass *klass)
 static void
 gdk_x11_gl_context_egl_init (GdkX11GLContextEGL *self)
 {
-  self->do_frame_sync = TRUE;
 }

 gboolean
-gdk_x11_display_init_egl (GdkX11Display  *self,
-                          gboolean        force,
-                          Visual        **out_visual,
-                          int            *out_depth,
-                          GError        **error)
+gdk_x11_screen_init_egl (GdkX11Screen *screen)
 {
-  GdkDisplay *display = GDK_DISPLAY (self);
+  GdkDisplay *display = GDK_SCREEN_DISPLAY (screen);
+  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+  EGLDisplay edpy;
  Display *dpy;
  int major, minor;

+  if (display_x11->have_egl)
+    return TRUE;
+
  dpy = gdk_x11_display_get_xdisplay (display);

  if (!epoxy_has_egl ())
+    return FALSE;
+
+  edpy = gdk_x11_display_get_egl_display (display);
+  if (edpy == NULL)
+    return FALSE;
+
+  if (!eglInitialize (edpy, &major, &minor))
+    return FALSE;
+
+  /* While NVIDIA might support EGL, it might very well not support
+   * all the EGL subset we rely on; we should be looking at more
+   * EGL extensions, but for the time being, this is a blanket
+   * fallback to GLX
+   */
+  const char *vendor = eglQueryString (edpy, EGL_VENDOR);
+  if (strstr (vendor, "NVIDIA") != NULL)
    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("EGL is not supported"));
+      eglTerminate (edpy);
      return FALSE;
    }

-  gdk_x11_display_create_egl_display (self);
-  if (self->egl_display == NULL)
-    {
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Failed to create EGL display"));
-      return FALSE;
-    }
+  display_x11->have_egl = TRUE;
+  display_x11->egl_version = epoxy_egl_version (dpy);

-  if (!eglInitialize (self->egl_display, &major, &minor))
-    {
-      self->egl_display = NULL;
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_NOT_AVAILABLE,
-                           _("Could not initialize EGL display"));
-      return FALSE;
-    }
-  if (major < GDK_EGL_MIN_VERSION_MAJOR ||
-      (major == GDK_EGL_MIN_VERSION_MAJOR && minor < GDK_EGL_MIN_VERSION_MINOR))
-    {
-      eglTerminate (dpy);
-      self->egl_display = NULL;
-      g_set_error (error, GDK_GL_ERROR,
-                   GDK_GL_ERROR_NOT_AVAILABLE,
-                   _("EGL version %d.%d is too old. GTK requires %d.%d"),
-                   major, minor, GDK_EGL_MIN_VERSION_MAJOR, GDK_EGL_MIN_VERSION_MINOR);
-      return FALSE;
-    }
-
-  if (!epoxy_has_egl_extension (self->egl_display, "EGL_KHR_surfaceless_context"))
-    {
-      eglTerminate (dpy);
-      self->egl_display = NULL;
-      g_set_error_literal (error, GDK_GL_ERROR,
-                           GDK_GL_ERROR_UNSUPPORTED_PROFILE,
-                           _("Surfaceless contexts are not supported on this EGL implementation"));
-      return FALSE;
-    }
-
-  if (!gdk_x11_display_create_egl_config (self, force, out_visual, out_depth, error))
-    {
-      eglTerminate (self->egl_display);
-      self->egl_display = NULL;
-      return FALSE;
-    }
-
-  self->egl_version = epoxy_egl_version (dpy);
-
-  self->has_egl_khr_create_context =
-    epoxy_has_egl_extension (self->egl_display, "EGL_KHR_create_context");
-  self->has_egl_buffer_age =
-    epoxy_has_egl_extension (self->egl_display, "EGL_EXT_buffer_age");
-  self->has_egl_swap_buffers_with_damage =
-    epoxy_has_egl_extension (self->egl_display, "EGL_EXT_swap_buffers_with_damage");
+  display_x11->has_egl_khr_create_context =
+    epoxy_has_egl_extension (edpy, "EGL_KHR_create_context");
+  display_x11->has_egl_buffer_age =
+    epoxy_has_egl_extension (edpy, "EGL_EXT_buffer_age");
+  display_x11->has_egl_swap_buffers_with_damage =
+    epoxy_has_egl_extension (edpy, "EGL_EXT_swap_buffers_with_damage");
+  display_x11->has_egl_surfaceless_context =
+    epoxy_has_egl_extension (edpy, "EGL_KHR_surfaceless_context");

  GDK_DISPLAY_NOTE (display, OPENGL,
                    g_message ("EGL found\n"
@@ -743,13 +621,162 @@ gdk_x11_display_init_egl (GdkX11Display  *self,
                               " - Checked extensions:\n"
                               "\t* EGL_KHR_create_context: %s\n"
                               "\t* EGL_EXT_buffer_age: %s\n"
-                               "\t* EGL_EXT_swap_buffers_with_damage: %s\n",
-                               eglQueryString (self->egl_display, EGL_VERSION),
-                               eglQueryString (self->egl_display, EGL_VENDOR),
-                               eglQueryString (self->egl_display, EGL_CLIENT_APIS),
-                               self->has_egl_khr_create_context ? "yes" : "no",
-                               self->has_egl_buffer_age ? "yes" : "no",
-                               self->has_egl_swap_buffers_with_damage ? "yes" : "no"));
+                               "\t* EGL_EXT_swap_buffers_with_damage: %s\n"
+                               "\t* EGL_KHR_surfaceless_context: %s\n",
+                               eglQueryString (edpy, EGL_VERSION),
+                               eglQueryString (edpy, EGL_VENDOR),
+                               eglQueryString (edpy, EGL_CLIENT_APIS),
+                               display_x11->has_egl_khr_create_context ? "yes" : "no",
+                               display_x11->has_egl_buffer_age ? "yes" : "no",
+                               display_x11->has_egl_swap_buffers_with_damage ? "yes" : "no",
+                               display_x11->has_egl_surfaceless_context ? "yes" : "no"));
+
+  return TRUE;
+}
+
+#define MAX_EGL_ATTRS   30
+
+static gboolean
+find_eglconfig_for_display (GdkDisplay  *display,
+                            EGLConfig   *egl_config_out,
+                            GError     **error)
+{
+  EGLint attrs[MAX_EGL_ATTRS];
+  EGLint count;
+  EGLConfig egl_config;
+  EGLDisplay egl_display;
+  int i = 0;
+
+  attrs[i++] = EGL_SURFACE_TYPE;
+  attrs[i++] = EGL_WINDOW_BIT;
+
+  attrs[i++] = EGL_COLOR_BUFFER_TYPE;
+  attrs[i++] = EGL_RGB_BUFFER;
+
+  attrs[i++] = EGL_RED_SIZE;
+  attrs[i++] = 8;
+  attrs[i++] = EGL_GREEN_SIZE;
+  attrs[i++] = 8;
+  attrs[i++] = EGL_BLUE_SIZE;
+  attrs[i++] = 8;
+  attrs[i++] = EGL_ALPHA_SIZE;
+  attrs[i++] = 8;
+
+  attrs[i++] = EGL_NONE;
+  g_assert (i < MAX_EGL_ATTRS);
+
+  /* Pick first valid configuration that the driver returns us */
+  egl_display = gdk_x11_display_get_egl_display (display);
+  if (!eglChooseConfig (egl_display, attrs, &egl_config, 1, &count) || count < 1)
+    {
+      g_set_error_literal (error, GDK_GL_ERROR,
+                           GDK_GL_ERROR_UNSUPPORTED_FORMAT,
+                           _("No available configurations for the given pixel format"));
+      return FALSE;
+    }
+
+  g_assert (egl_config_out);
+  *egl_config_out = egl_config;
+
+  return TRUE;
+}
+
+#undef MAX_EGL_ATTRS
+
+GdkX11GLContext *
+gdk_x11_gl_context_egl_new (GdkSurface    *surface,
+                            gboolean       attached,
+                            GdkGLContext  *share,
+                            GError       **error)
+{
+  GdkDisplay *display;
+  GdkX11GLContextEGL *context;
+  EGLConfig egl_config;
+
+  display = gdk_surface_get_display (surface);
+
+  if (!find_eglconfig_for_display (display, &egl_config, error))
+    return NULL;
+
+  context = g_object_new (GDK_TYPE_X11_GL_CONTEXT_EGL,
+                          "surface", surface,
+                          "shared-context", share,
+                          NULL);
+
+  context->egl_config = egl_config;
+
+  return GDK_X11_GL_CONTEXT (context);
+}
+
+gboolean
+gdk_x11_gl_context_egl_make_current (GdkDisplay   *display,
+                                     GdkGLContext *context)
+{
+  GdkX11GLContextEGL *context_egl = GDK_X11_GL_CONTEXT_EGL (context);
+  GdkX11GLContext *context_x11 = GDK_X11_GL_CONTEXT (context);
+  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+  GdkSurface *surface;
+  EGLDisplay egl_display;
+  EGLSurface egl_surface;
+
+  egl_display = gdk_x11_display_get_egl_display (display);
+
+  if (context == NULL)
+    {
+      eglMakeCurrent (egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+      return TRUE;
+    }
+
+  if (context_egl->egl_context == NULL)
+    {
+      g_critical ("No EGL context associated to the GdkGLContext; you must "
+                  "call gdk_gl_context_realize() first.");
+      return FALSE;
+    }
+
+  surface = gdk_gl_context_get_surface (context);
+
+  if (context_x11->is_attached || gdk_draw_context_is_in_frame (GDK_DRAW_CONTEXT (context)))
+    egl_surface = gdk_x11_surface_get_egl_surface (surface, context_egl->egl_config);
+  else
+    {
+      if (display_x11->has_egl_surfaceless_context)
+        egl_surface = EGL_NO_SURFACE;
+      else
+        egl_surface = gdk_x11_display_get_egl_dummy_surface (display, context_egl->egl_config);
+    }
+
+  GDK_DISPLAY_NOTE (display, OPENGL,
+                    g_message ("Making EGL context %p current to surface %p",
+                               context_egl->egl_context, egl_surface));
+
+  if (!eglMakeCurrent (egl_display, egl_surface, egl_surface, context_egl->egl_context))
+    {
+      GDK_DISPLAY_NOTE (display, OPENGL,
+                        g_message ("Making EGL context current failed"));
+      return FALSE;
+    }
+
+  if (context_x11->is_attached)
+    {
+      gboolean do_frame_sync = FALSE;
+
+      /* If the WM is compositing there is no particular need to delay
+       * the swap when drawing on the offscreen, rendering to the screen
+       * happens later anyway, and its up to the compositor to sync that
+       * to the vblank. */
+      do_frame_sync = ! gdk_display_is_composited (display);
+
+      if (do_frame_sync != context_x11->do_frame_sync)
+        {
+          context_x11->do_frame_sync = do_frame_sync;
+
+          if (do_frame_sync)
+            eglSwapInterval (egl_display, 1);
+          else
+            eglSwapInterval (egl_display, 0);
+        }
+    }

  return TRUE;
 }
@@ -778,7 +805,10 @@ gdk_x11_display_get_egl_version (GdkDisplay *display,

  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);

-  if (display_x11->egl_display == NULL)
+  if (display_x11->have_glx)
+    return FALSE;
+
+  if (!gdk_x11_screen_init_egl (display_x11->screen))
    return FALSE;

  if (major != NULL)
@@ -29,6 +29,7 @@
 #include "gdkx11glcontext.h"
 #include "gdkx11screen.h"
 #include "gdkx11surface.h"
+#include "gdkvisual-x11.h"
 #include "gdkx11property.h"
 #include <X11/Xatom.h>

@@ -50,5 +51,78 @@ gdk_x11_gl_context_class_init (GdkX11GLContextClass *klass)
 static void
 gdk_x11_gl_context_init (GdkX11GLContext *self)
 {
+  self->do_frame_sync = TRUE;
 }

+gboolean
+gdk_x11_screen_init_gl (GdkX11Screen *screen)
+{
+  GdkDisplay *display G_GNUC_UNUSED = GDK_SCREEN_DISPLAY (screen);
+
+  if (GDK_DISPLAY_DEBUG_CHECK (display, GL_DISABLE))
+    return FALSE;
+
+  if (!GDK_DISPLAY_DEBUG_CHECK (display, GL_GLX))
+    {
+      /* We favour EGL */
+      if (gdk_x11_screen_init_egl (screen))
+        return TRUE;
+    }
+
+  if (gdk_x11_screen_init_glx (screen))
+    return TRUE;
+
+  return FALSE;
+}
+
+GdkGLContext *
+gdk_x11_surface_create_gl_context (GdkSurface    *surface,
+                                   gboolean       attached,
+                                   GdkGLContext  *share,
+                                   GError       **error)
+{
+  GdkX11GLContext *context = NULL;
+  GdkX11Display *display_x11;
+  GdkDisplay *display;
+
+  display = gdk_surface_get_display (surface);
+
+  if (!gdk_x11_screen_init_gl (GDK_SURFACE_SCREEN (surface)))
+    {
+      g_set_error_literal (error, GDK_GL_ERROR,
+                           GDK_GL_ERROR_NOT_AVAILABLE,
+                           _("No GL implementation is available"));
+      return NULL;
+    }
+
+  display_x11 = GDK_X11_DISPLAY (display);
+  if (display_x11->have_egl)
+    context = gdk_x11_gl_context_egl_new (surface, attached, share, error);
+  else if (display_x11->have_glx)
+    context = gdk_x11_gl_context_glx_new (surface, attached, share, error);
+  else
+    g_assert_not_reached ();
+
+  if (context == NULL)
+    return NULL;
+
+  context->is_attached = attached;
+
+  return GDK_GL_CONTEXT (context);
+}
+
+gboolean
+gdk_x11_display_make_gl_context_current (GdkDisplay   *display,
+                                         GdkGLContext *context)
+{
+  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+
+  if (display_x11->have_egl)
+    return gdk_x11_gl_context_egl_make_current (display, context);
+  else if (display_x11->have_glx)
+    return gdk_x11_gl_context_glx_make_current (display, context);
+  else
+    g_assert_not_reached ();
+
+  return FALSE;
+}
@@ -34,7 +34,8 @@
 #include <epoxy/glx.h>

 #include "gdkglcontextprivate.h"
-#include "gdkdisplay-x11.h"
+#include "gdkdisplayprivate.h"
+#include "gdkvisual-x11.h"
 #include "gdksurface.h"
 #include "gdkinternals.h"

@@ -47,13 +48,27 @@ G_BEGIN_DECLS
 struct _GdkX11GLContext
 {
  GdkGLContext parent_instance;
+
+  guint do_frame_sync : 1;
+  guint is_attached : 1;
 };

 struct _GdkX11GLContextClass
 {
  GdkGLContextClass parent_class;
+
+  void (* bind_for_frame_fence) (GdkX11GLContext *self);
 };

+gboolean        gdk_x11_screen_init_gl                  (GdkX11Screen  *screen);
+
+GdkGLContext *  gdk_x11_surface_create_gl_context       (GdkSurface    *window,
+                                                         gboolean       attached,
+                                                         GdkGLContext  *share,
+                                                         GError       **error);
+gboolean        gdk_x11_display_make_gl_context_current (GdkDisplay    *display,
+                                                         GdkGLContext  *context);
+
 /* GLX */
 #define GDK_TYPE_X11_GL_CONTEXT_GLX     (gdk_x11_gl_context_glx_get_type())
 #define GDK_X11_GL_CONTEXT_GLX(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_GL_CONTEXT_GLX, GdkX11GLContextGLX))
@@ -61,13 +76,16 @@ struct _GdkX11GLContextClass

 typedef struct _GdkX11GLContextGLX      GdkX11GLContextGLX;

-gboolean                gdk_x11_display_init_glx                (GdkX11Display *display_x11,
-                                                                 Visual       **out_visual,
-                                                                 int           *out_depth,
-                                                                 GError       **error);
-void                    gdk_x11_surface_destroy_glx_drawable    (GdkX11Surface *self);
+gboolean                gdk_x11_screen_init_glx                 (GdkX11Screen  *screen);
+void                    gdk_x11_screen_update_visuals_for_glx   (GdkX11Screen  *screen);

 GType                   gdk_x11_gl_context_glx_get_type         (void) G_GNUC_CONST;
+GdkX11GLContext *       gdk_x11_gl_context_glx_new              (GdkSurface    *surface,
+                                                                 gboolean       attached,
+                                                                 GdkGLContext  *share,
+                                                                 GError       **error);
+gboolean                gdk_x11_gl_context_glx_make_current     (GdkDisplay    *display,
+                                                                 GdkGLContext  *context);


 /* EGL */
@@ -77,14 +95,14 @@ GType                   gdk_x11_gl_context_glx_get_type         (void) G_GNUC_CO

 typedef struct _GdkX11GLContextEGL      GdkX11GLContextEGL;

-gboolean                gdk_x11_display_init_egl                (GdkX11Display *display_x11,
-                                                                 gboolean       force,
-                                                                 Visual       **out_visual,
-                                                                 int           *out_depth,
-                                                                 GError       **error);
-void                    gdk_x11_surface_destroy_egl_surface     (GdkX11Surface *self);
-
+gboolean                gdk_x11_screen_init_egl                 (GdkX11Screen  *screen);
 GType                   gdk_x11_gl_context_egl_get_type         (void) G_GNUC_CONST;
+GdkX11GLContext *       gdk_x11_gl_context_egl_new              (GdkSurface    *surface,
+                                                                 gboolean       attached,
+                                                                 GdkGLContext  *share,
+                                                                 GError       **error);
+gboolean                gdk_x11_gl_context_egl_make_current     (GdkDisplay    *display,
+                                                                 GdkGLContext  *context);

 G_END_DECLS

@@ -55,6 +55,11 @@ typedef GdkFilterReturn (*GdkFilterFunc) (const XEvent *xevent,
 void _gdk_x11_error_handler_push (void);
 void _gdk_x11_error_handler_pop  (void);

+void          gdk_display_setup_window_visual            (GdkDisplay     *display,
+                                                          int             depth,
+                                                          Visual         *visual,
+                                                          Colormap        colormap,
+                                                          gboolean        rgba);
 int           gdk_x11_display_get_window_depth           (GdkX11Display  *display);
 Visual *      gdk_x11_display_get_window_visual          (GdkX11Display  *display);
 Colormap      gdk_x11_display_get_window_colormap        (GdkX11Display  *display);
@@ -91,6 +91,9 @@ gdk_x11_screen_dispose (GObject *object)

  _gdk_x11_xsettings_finish (x11_screen);

+  for (i = 0; i < x11_screen->nvisuals; i++)
+    g_object_run_dispose (G_OBJECT (x11_screen->visuals[i]));
+
  G_OBJECT_CLASS (gdk_x11_screen_parent_class)->dispose (object);

  x11_screen->xdisplay = NULL;
@@ -103,6 +106,12 @@ static void
 gdk_x11_screen_finalize (GObject *object)
 {
  GdkX11Screen *x11_screen = GDK_X11_SCREEN (object);
+  int           i;
+
+  /* Visual Part */
+  for (i = 0; i < x11_screen->nvisuals; i++)
+    g_object_unref (x11_screen->visuals[i]);
+  g_free (x11_screen->visuals);

  g_free (x11_screen->window_manager_name);

@@ -857,7 +866,8 @@ init_multihead (GdkX11Screen *screen)

 GdkX11Screen *
 _gdk_x11_screen_new (GdkDisplay *display,
-		     int	 screen_number)
+		     int	 screen_number,
+                     gboolean    setup_display)
 {
  GdkX11Screen *x11_screen;
  GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
@@ -888,6 +898,8 @@ _gdk_x11_screen_new (GdkDisplay *display,
  init_randr_support (x11_screen);
  init_multihead (x11_screen);

+  _gdk_x11_screen_init_visuals (x11_screen, setup_display);
+
  return x11_screen;
 }

--- a/Show More
+++ b/Show More