win32: Use GWL_USERDATA instead of a global hash table

We can delete a whole source file again! Also deprecate a bunch of stupid and dangerous APIs that shouldn't have made it to 4.0, but who's gonna review the Windows backend, amirite?
win32: Store the window classes in the display
2021-07-31 05:50:14 +02:00 · 2021-07-31 05:50:14 +02:00 · 2021-07-31 05:50:14 +02:00 · 2021-07-31 05:50:14 +02:00 · 2021-07-31 05:50:14 +02:00 · 2021-07-31 03:55:07 +02:00
27 changed files with 483 additions and 1588 deletions
--- a/demos/widget-factory/widget-factory.c
+++ b/demos/widget-factory/widget-factory.c
@@ -27,6 +27,10 @@

 #include "demo_conf.h"

+#ifdef GDK_WINDOWING_WIN32
+#include <windows.h>
+#endif
+
 static void
 change_dark_state (GSimpleAction *action,
                    GVariant      *state,
@@ -2464,6 +2468,15 @@ main (int argc, char *argv[])
  };
  int status;

+#ifdef GDK_WINDOWING_WIN32
+  if (AttachConsole (ATTACH_PARENT_PROCESS))
+    {
+      freopen("CONOUT$", "w", stdout);
+      freopen("CONOUT$", "w", stderr);
+      freopen("CONIN$", "r", stdin);
+    }
+#endif
+
  app = gtk_application_new ("org.gtk.WidgetFactory4", G_APPLICATION_NON_UNIQUE);

  g_action_map_add_action_entries (G_ACTION_MAP (app),
--- a/gdk/win32/gdkclipdrop-win32.c
+++ b/gdk/win32/gdkclipdrop-win32.c
@@ -1565,10 +1565,6 @@ gdk_win32_clipdrop_init (GdkWin32Clipdrop *win32_clipdrop)
  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_IMAGE_BMP) = g_intern_static_string ("image/bmp");
  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_IMAGE_GIF) = g_intern_static_string ("image/gif");

-  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_LOCAL_DND_SELECTION) = g_intern_static_string ("LocalDndSelection");
-  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_DROPFILES_DND) = g_intern_static_string ("DROPFILES_DND");
-  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_OLE2_DND) = g_intern_static_string ("OLE2_DND");
-
  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_PNG)= g_intern_static_string ("PNG");
  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_JFIF) = g_intern_static_string ("JFIF");
  _gdk_atom_array_index (atoms, GDK_WIN32_ATOM_INDEX_GIF) = g_intern_static_string ("GIF");
@@ -1605,34 +1601,6 @@ gdk_win32_clipdrop_init (GdkWin32Clipdrop *win32_clipdrop)

  win32_clipdrop->active_source_drags = g_hash_table_new_full (NULL, NULL, (GDestroyNotify) g_object_unref, NULL);

-  pixbuf_formats = gdk_pixbuf_get_formats ();
-
-  win32_clipdrop->n_known_pixbuf_formats = 0;
-  for (rover = pixbuf_formats; rover != NULL; rover = rover->next)
-    {
-      char **mime_types =
-	gdk_pixbuf_format_get_mime_types ((GdkPixbufFormat *) rover->data);
-      char **mime_type;
-
-      for (mime_type = mime_types; *mime_type != NULL; mime_type++)
-	win32_clipdrop->n_known_pixbuf_formats++;
-    }
-
-  win32_clipdrop->known_pixbuf_formats = g_new (const char *, win32_clipdrop->n_known_pixbuf_formats);
-
-  i = 0;
-  for (rover = pixbuf_formats; rover != NULL; rover = rover->next)
-    {
-      char **mime_types =
-	gdk_pixbuf_format_get_mime_types ((GdkPixbufFormat *) rover->data);
-      char **mime_type;
-
-      for (mime_type = mime_types; *mime_type != NULL; mime_type++)
-	win32_clipdrop->known_pixbuf_formats[i++] = g_intern_string (*mime_type);
-    }
-
-  g_slist_free (pixbuf_formats);
-
  win32_clipdrop->compatibility_w32formats = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_array_unref);

  /* GTK actually has more text formats, but it's unlikely that we'd
@@ -1956,32 +1924,6 @@ _gdk_win32_get_clipboard_format_name_as_interned_mimetype (char *w32format_name)
  return result;
 }

-static GArray *
-get_compatibility_w32formats_for_contentformat (const char *contentformat)
-{
-  GArray *result = NULL;
-  int i;
-  GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
-
-  result = g_hash_table_lookup (clipdrop->compatibility_w32formats, contentformat);
-
-  if (result != NULL)
-    return result;
-
-  for (i = 0; i < clipdrop->n_known_pixbuf_formats; i++)
-    {
-      if (contentformat != clipdrop->known_pixbuf_formats[i])
-        continue;
-
-      /* Any format known to gdk-pixbuf can be presented as PNG or BMP */
-      result = g_hash_table_lookup (clipdrop->compatibility_w32formats,
-                                    _gdk_win32_clipdrop_atom (GDK_WIN32_ATOM_INDEX_IMAGE_PNG));
-      break;
-    }
-
-  return result;
-}
-
 static GArray *
 _gdk_win32_get_compatibility_contentformats_for_w32format (UINT w32format)
 {
@@ -2741,7 +2683,7 @@ _gdk_win32_add_contentformat_to_pairs (const char *contentformat,
  g_array_append_val (array, fmt);
  added_count += 1;

-  comp_pairs = get_compatibility_w32formats_for_contentformat (contentformat);
+  comp_pairs = g_hash_table_lookup (_win32_clipdrop->compatibility_w32formats, contentformat);
  for (i = 0; comp_pairs != NULL && i < comp_pairs->len; i++)
    {
      int j;
--- a/gdk/win32/gdkclipdrop-win32.h
+++ b/gdk/win32/gdkclipdrop-win32.h
@@ -68,10 +68,6 @@ enum _GdkWin32AtomIndex
  GDK_WIN32_ATOM_INDEX_IMAGE_JPEG,
  GDK_WIN32_ATOM_INDEX_IMAGE_BMP,
  GDK_WIN32_ATOM_INDEX_IMAGE_GIF,
-/* DND selections */
-  GDK_WIN32_ATOM_INDEX_LOCAL_DND_SELECTION,
-  GDK_WIN32_ATOM_INDEX_DROPFILES_DND,
-  GDK_WIN32_ATOM_INDEX_OLE2_DND,
 /* Clipboard formats */
  GDK_WIN32_ATOM_INDEX_PNG,
  GDK_WIN32_ATOM_INDEX_JFIF,
@@ -128,10 +124,6 @@ struct _GdkWin32Clipdrop
 {
  GObject *parent_instance;

-  /* interned strings for well-known image formats */
-  const char **known_pixbuf_formats;
-  int n_known_pixbuf_formats;
-
  /* GArray of GdkAtoms for various known Selection and DnD strings.
   * Size is guaranteed to be at least GDK_WIN32_ATOM_INDEX_LAST
   */
--- a/gdk/win32/gdkdevice-win32.c
+++ b/gdk/win32/gdkdevice-win32.c
@@ -72,6 +72,7 @@ gdk_device_win32_query_state (GdkDevice        *device,
                              double           *win_y,
                              GdkModifierType  *mask)
 {
+  GdkDisplay *display = gdk_device_get_display (device);
  POINT point;
  HWND hwnd, hwndc;
  int scale;
@@ -83,8 +84,6 @@ gdk_device_win32_query_state (GdkDevice        *device,
    }
  else
    {
-      GdkDisplay *display = gdk_device_get_display (device);
-
      scale = GDK_WIN32_DISPLAY (display)->surface_scale;
      hwnd = NULL;
    }
@@ -100,21 +99,12 @@ gdk_device_win32_query_state (GdkDevice        *device,
  if (win_y)
    *win_y = point.y / scale;

-  if (window)
-    {
-      if (win_x)
-        *win_x += _gdk_offset_x;
-
-      if (win_y)
-        *win_y += _gdk_offset_y;
-    }
-
  if (hwnd && child_window)
    {
      hwndc = ChildWindowFromPoint (hwnd, point);

      if (hwndc && hwndc != hwnd)
-        *child_window = gdk_win32_handle_table_lookup (hwndc);
+        *child_window = gdk_win32_surface_lookup_for_display (display, hwndc);
      else
        *child_window = NULL; /* Direct child unknown to gdk */
    }
@@ -171,6 +161,7 @@ _gdk_device_win32_surface_at_position (GdkDevice       *device,
                                       double          *win_y,
                                       GdkModifierType *mask)
 {
+  GdkDisplay *display = gdk_device_get_display (device);
  GdkSurface *window = NULL;
  GdkWin32Surface *impl = NULL;
  POINT screen_pt, client_pt;
@@ -192,7 +183,8 @@ _gdk_device_win32_surface_at_position (GdkDevice       *device,
  if (!PtInRect (&rect, client_pt))
    hwnd = NULL;

-  window = gdk_win32_handle_table_lookup (hwnd);
+  if (hwnd)
+    window = gdk_win32_surface_lookup_for_display (display, hwnd);

  if (window && (win_x || win_y))
    {
--- a/gdk/win32/gdkdevice-wintab.c
+++ b/gdk/win32/gdkdevice-wintab.c
@@ -69,6 +69,7 @@ gdk_device_wintab_query_state (GdkDevice        *device,
                               double           *win_y,
                               GdkModifierType  *mask)
 {
+  GdkDisplay *display = gdk_device_get_display (device);
  GdkDeviceWintab *device_wintab;
  POINT point;
  HWND hwnd, hwndc;
@@ -82,8 +83,6 @@ gdk_device_wintab_query_state (GdkDevice        *device,
    }
  else
    {
-      GdkDisplay *display = gdk_device_get_display (device);
-
      scale = GDK_WIN32_DISPLAY (display)->surface_scale;
      hwnd = NULL;
    }
@@ -99,21 +98,12 @@ gdk_device_wintab_query_state (GdkDevice        *device,
  if (win_y)
    *win_y = point.y / scale;

-  if (!window)
-    {
-      if (win_x)
-        *win_x += _gdk_offset_x;
-
-      if (win_y)
-        *win_y += _gdk_offset_y;
-    }
-
  if (hwnd && child_window)
    {
      hwndc = ChildWindowFromPoint (hwnd, point);

      if (hwndc && hwndc != hwnd)
-        *child_window = gdk_win32_handle_table_lookup (hwndc);
+        *child_window = gdk_win32_surface_lookup_for_display (display, hwndc);
      else
        *child_window = NULL; /* Direct child unknown to gdk */
    }
--- a/gdk/win32/gdkdevicemanager-win32.c
+++ b/gdk/win32/gdkdevicemanager-win32.c
@@ -21,14 +21,16 @@
 #include <stdio.h>
 #include <math.h>

-#include <gdk/gdk.h>
-#include "gdkwin32.h"
-#include "gdkprivate-win32.h"
 #include "gdkdevicemanager-win32.h"
-#include "gdkdeviceprivate.h"
-#include "gdkdevice-win32.h"
+
 #include "gdkdevice-virtual.h"
+#include "gdkdevice-win32.h"
 #include "gdkdevice-wintab.h"
+#include "gdkdisplay-win32.h"
+#include "gdkprivate-win32.h"
+#include "gdkwin32misc.h"
+
+#include "gdkdeviceprivate.h"
 #include "gdkdisplayprivate.h"
 #include "gdkseatdefaultprivate.h"

@@ -80,7 +82,7 @@ create_pointer (GdkDeviceManagerWin32 *device_manager,
                       "name", name,
                       "source", GDK_SOURCE_MOUSE,
                       "has-cursor", has_cursor,
-                       "display", _gdk_display,
+                       "display", device_manager->display,
                       NULL);
 }

@@ -93,7 +95,7 @@ create_keyboard (GdkDeviceManagerWin32 *device_manager,
                       "name", name,
                       "source", GDK_SOURCE_KEYBOARD,
                       "has-cursor", FALSE,
-                       "display", _gdk_display,
+                       "display", device_manager->display,
                       NULL);
 }

@@ -673,7 +675,7 @@ wintab_default_display_notify_cb (GdkDisplayManager *display_manager)

  g_assert (display != NULL);

-  device_manager = GDK_DEVICE_MANAGER_WIN32 (_gdk_device_manager);
+  device_manager = GDK_WIN32_DISPLAY (display)->device_manager;
  g_assert (display_manager != NULL);

  default_display_opened = TRUE;
@@ -681,15 +683,17 @@ wintab_default_display_notify_cb (GdkDisplayManager *display_manager)
  wintab_init_check (device_manager);
 }

-static void
-gdk_device_manager_win32_constructed (GObject *object)
+GdkDeviceManagerWin32 *
+gdk_device_manager_win32_new (GdkDisplay *display)
 {
  GdkDeviceManagerWin32 *device_manager;
  GdkSeat *seat;
  GdkDisplayManager *display_manager = NULL;
  GdkDisplay *default_display = NULL;

-  device_manager = GDK_DEVICE_MANAGER_WIN32 (object);
+  device_manager = g_object_new (GDK_TYPE_DEVICE_MANAGER_WIN32, NULL);
+  device_manager->display = display; /* no ref, the display owns us */
+
  device_manager->core_pointer =
    create_pointer (device_manager,
 		    GDK_TYPE_DEVICE_VIRTUAL,
@@ -723,7 +727,7 @@ gdk_device_manager_win32_constructed (GObject *object)

  seat = gdk_seat_default_new_for_logical_pair (device_manager->core_pointer,
                                                device_manager->core_keyboard);
-  gdk_display_add_seat (_gdk_display, seat);
+  gdk_display_add_seat (display, seat);
  gdk_seat_default_add_physical_device (GDK_SEAT_DEFAULT (seat), device_manager->system_pointer);
  gdk_seat_default_add_physical_device (GDK_SEAT_DEFAULT (seat), device_manager->system_keyboard);
  g_object_unref (seat);
@@ -740,6 +744,8 @@ gdk_device_manager_win32_constructed (GObject *object)
  g_signal_connect (display_manager, "notify::default-display",
                    G_CALLBACK (wintab_default_display_notify_cb),
                    NULL);
+
+  return device_manager;
 }

 static void
@@ -748,7 +754,6 @@ gdk_device_manager_win32_class_init (GdkDeviceManagerWin32Class *klass)
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->finalize = gdk_device_manager_win32_finalize;
-  object_class->constructed = gdk_device_manager_win32_constructed;
 }

 void
@@ -898,7 +903,7 @@ gdk_input_other_event (GdkDisplay *display,
      return NULL;
    }

-  device_manager = GDK_DEVICE_MANAGER_WIN32 (_gdk_device_manager);
+  device_manager = GDK_WIN32_DISPLAY (display)->device_manager;
  window = gdk_device_get_surface_at_position (device_manager->core_pointer, &x, &y);

  if (window)
--- a/gdk/win32/gdkdevicemanager-win32.h
+++ b/gdk/win32/gdkdevicemanager-win32.h
@@ -18,6 +18,10 @@
 #ifndef __GDK_DEVICE_MANAGER_WIN32_H__
 #define __GDK_DEVICE_MANAGER_WIN32_H__

+#include <gdk/gdkdisplay.h>
+
+#include <windows.h>
+
 G_BEGIN_DECLS

 #define GDK_TYPE_DEVICE_MANAGER_WIN32         (gdk_device_manager_win32_get_type ())
@@ -54,12 +58,15 @@ struct _GdkDeviceManagerWin32Class
  GObjectClass parent_class;
 };

-GType gdk_device_manager_win32_get_type (void) G_GNUC_CONST;
+GType                   gdk_device_manager_win32_get_type       (void) G_GNUC_CONST;

-void     _gdk_input_set_tablet_active (void);
-GdkEvent * gdk_input_other_event      (GdkDisplay *display,
-                                       MSG        *msg,
-                                       GdkSurface  *window);
+void                    _gdk_input_set_tablet_active            (void);
+
+GdkDeviceManagerWin32 * gdk_device_manager_win32_new            (GdkDisplay             *display);
+
+GdkEvent *              gdk_input_other_event                   (GdkDisplay             *display,
+                                                                 MSG                    *msg,
+                                                                 GdkSurface             *window);

 G_END_DECLS

--- a/gdk/win32/gdkdisplay-win32.c
+++ b/gdk/win32/gdkdisplay-win32.c
@@ -30,7 +30,6 @@
 #include "gdkdevicemanager-win32.h"
 #include "gdkglcontext-win32.h"
 #include "gdkwin32display.h"
-#include "gdkwin32screen.h"
 #include "gdkwin32surface.h"
 #include "gdkmonitor-win32.h"
 #include "gdkwin32.h"
@@ -190,8 +189,8 @@ _gdk_win32_display_find_matching_monitor (GdkWin32Display *win32_display,
  return NULL;
 }

-void
-_gdk_win32_display_init_monitors (GdkWin32Display *win32_display)
+static void
+gdk_win32_display_init_monitors (GdkWin32Display *win32_display)
 {
  GPtrArray *new_monitors;
  int i;
@@ -437,9 +436,9 @@ inner_display_change_window_procedure (HWND   hwnd,
      }
    case WM_DISPLAYCHANGE:
      {
-        GdkWin32Display *win32_display = GDK_WIN32_DISPLAY (_gdk_display);
+        GdkWin32Display *self = GDK_WIN32_DISPLAY (GetWindowLongPtr (hwnd, GWLP_USERDATA));

-        _gdk_win32_screen_on_displaychange_event (GDK_WIN32_SCREEN (win32_display->screen));
+        gdk_win32_display_init_monitors (self);
        return 0;
      }
    default:
@@ -472,84 +471,165 @@ display_change_window_procedure (HWND   hwnd,

 /* Use a hidden window to be notified about display changes */
 static void
-register_display_change_notification (GdkDisplay *display)
+gdk_win32_display_create_hwnd (GdkWin32Display *self)
 {
-  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
  WNDCLASS wclass = { 0, };
  ATOM klass;

  wclass.lpszClassName = "GdkDisplayChange";
  wclass.lpfnWndProc = display_change_window_procedure;
  wclass.hInstance = _gdk_app_hmodule;
-  wclass.style = CS_OWNDC;
+  wclass.style = CS_OWNDC; /* required because WGL uses this Window to initialize */

  klass = RegisterClass (&wclass);
  if (klass)
    {
-      display_win32->hwnd = CreateWindow (MAKEINTRESOURCE (klass),
-                                          NULL, WS_POPUP,
-                                          0, 0, 0, 0, NULL, NULL,
-                                          _gdk_app_hmodule, NULL);
-      if (!display_win32->hwnd)
+      self->hwnd = CreateWindow (MAKEINTRESOURCE (klass),
+                                 NULL, WS_POPUP,
+                                 0, 0, 0, 0, NULL, NULL,
+                                 _gdk_app_hmodule, NULL);
+      if (!self->hwnd)
        {
          UnregisterClass (MAKEINTRESOURCE (klass), _gdk_app_hmodule);
+          return;
+        }
+      SetWindowLongPtr (self->hwnd, GWLP_USERDATA, (LONG_PTR) self);
+    }
+}
+
+static void
+gdk_win32_display_register_classes (GdkWin32Display *self)
+{
+  HICON hAppIcon = NULL;
+  HICON hAppIconSm = NULL;
+  WNDCLASSEXW wcl;
+
+  wcl.cbSize = sizeof (WNDCLASSEX);
+  wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
+                  * on WM_SIZE and WM_MOVE. Flicker, Performance!
+                  */
+  wcl.lpfnWndProc = gdk_win32_surface_procedure;
+  wcl.cbClsExtra = 0;
+  wcl.cbWndExtra = 0;
+  wcl.hInstance = _gdk_dll_hinstance;
+  wcl.hIcon = 0;
+  wcl.hIconSm = 0;
+
+  /* initialize once! */
+  if (0 == hAppIcon && 0 == hAppIconSm)
+    {
+      char sLoc[MAX_PATH + 1];
+
+      // try to load first icon of executable program
+      if (0 != GetModuleFileName (NULL, sLoc, MAX_PATH))
+        {
+          ExtractIconEx (sLoc, 0, &hAppIcon, &hAppIconSm, 1);
+
+          if (0 == hAppIcon && 0 == hAppIconSm)
+            {
+              // fallback : load icon from GTK DLL
+              if (0 != GetModuleFileName (_gdk_dll_hinstance, sLoc, MAX_PATH))
+                {
+                  ExtractIconEx (sLoc, 0, &hAppIcon, &hAppIconSm, 1);
+                }
+            }
+        }
+
+      if (0 == hAppIcon && 0 == hAppIconSm)
+        {
+          hAppIcon = LoadImage (NULL, IDI_APPLICATION, IMAGE_ICON,
+                                GetSystemMetrics (SM_CXICON),
+                                GetSystemMetrics (SM_CYICON), 0);
+          hAppIconSm = LoadImage (NULL, IDI_APPLICATION, IMAGE_ICON,
+                                  GetSystemMetrics (SM_CXSMICON),
+                                  GetSystemMetrics (SM_CYSMICON), 0);
        }
    }
+
+  if (0 == hAppIcon)
+    hAppIcon = hAppIconSm;
+  else if (0 == hAppIconSm)
+    hAppIconSm = hAppIcon;
+
+  wcl.lpszMenuName = NULL;
+  wcl.hbrBackground = NULL;
+  wcl.hCursor = LoadCursor (NULL, IDC_ARROW);
+  /* MSDN: CS_OWNDC is needed for OpenGL contexts */
+  wcl.style |= CS_OWNDC;
+
+  wcl.lpszClassName = L"gdkSurfaceToplevel";
+  wcl.hIcon = CopyIcon (hAppIcon);
+  wcl.hIconSm = CopyIcon (hAppIconSm);
+  self->toplevel_class = RegisterClassExW (&wcl);
+  if (self->toplevel_class == 0)
+    {
+      WIN32_API_FAILED ("RegisterClassExW");
+      g_error ("That is a fatal error");
+    }
+
+  wcl.lpszClassName = L"gdkSurfaceTemp";
+  wcl.hIcon = CopyIcon (hAppIcon);
+  wcl.hIconSm = CopyIcon (hAppIconSm);
+  wcl.style |= CS_SAVEBITS;
+  self->temp_class = RegisterClassExW (&wcl);
+  if (self->temp_class == 0)
+    {
+      WIN32_API_FAILED ("RegisterClassExW");
+      g_error ("That is a fatal error");
+    }
+
+  if (hAppIcon != hAppIconSm)
+    DestroyIcon (hAppIconSm);
+  DestroyIcon (hAppIcon);
 }

 GdkDisplay *
 _gdk_win32_display_open (const char *display_name)
 {
+  static GdkDisplay *display = NULL;
  GdkWin32Display *win32_display;

  GDK_NOTE (MISC, g_print ("gdk_display_open: %s\n", (display_name ? display_name : "NULL")));

-  if (display_name == NULL ||
-      g_ascii_strcasecmp (display_name,
-			  gdk_display_get_name (_gdk_display)) == 0)
+  if (display_name != NULL)
    {
-      if (_gdk_display != NULL)
-	{
-	  GDK_NOTE (MISC, g_print ("... return _gdk_display\n"));
-	  return _gdk_display;
-	}
-    }
-  else
-    {
-      GDK_NOTE (MISC, g_print ("... return NULL\n"));
+      GDK_NOTE (MISC, g_print ("... return NULL for display name \"%s\"\n"));
      return NULL;
    }

-  _gdk_display = g_object_new (GDK_TYPE_WIN32_DISPLAY, NULL);
-  win32_display = GDK_WIN32_DISPLAY (_gdk_display);
+  if (display)
+    return display;

-  win32_display->screen = g_object_new (GDK_TYPE_WIN32_SCREEN, NULL);
+  display = g_object_new (GDK_TYPE_WIN32_DISPLAY, NULL);
+  win32_display = GDK_WIN32_DISPLAY (display);

-  _gdk_events_init (_gdk_display);
+  gdk_win32_display_register_classes (win32_display);
+  gdk_win32_display_init_monitors (win32_display);
+  
+  _gdk_events_init (display);

  _gdk_input_ignore_core = 0;

-  _gdk_device_manager = g_object_new (GDK_TYPE_DEVICE_MANAGER_WIN32,
-                                      NULL);
-  _gdk_device_manager->display = _gdk_display;
+  win32_display->device_manager = gdk_device_manager_win32_new (display);

  _gdk_win32_lang_notification_init ();
  _gdk_drag_init ();
-  _gdk_drop_init ();
-
-  _gdk_display->clipboard = gdk_win32_clipboard_new (_gdk_display);
-  _gdk_display->primary_clipboard = gdk_clipboard_new (_gdk_display);
+  
+  win32_display->keymap = g_object_new (GDK_TYPE_WIN32_KEYMAP, NULL);
+  _gdk_win32_keymap_set_active_layout (win32_display->keymap, _gdk_input_locale);
+  display->clipboard = gdk_win32_clipboard_new (display);
+  display->primary_clipboard = gdk_clipboard_new (display);

  /* Precalculate display name */
-  (void) gdk_display_get_name (_gdk_display);
+  (void) gdk_display_get_name (display);

-  register_display_change_notification (_gdk_display);
+  gdk_win32_display_create_hwnd (win32_display);

-  g_signal_emit_by_name (_gdk_display, "opened");
+  g_signal_emit_by_name (display, "opened");

-  GDK_NOTE (MISC, g_print ("... _gdk_display now set up\n"));
+  GDK_NOTE (MISC, g_print ("... win32 display now set up\n"));

-  return _gdk_display;
+  return display;
 }

 G_DEFINE_TYPE (GdkWin32Display, gdk_win32_display, GDK_TYPE_DISPLAY)
@@ -621,7 +701,6 @@ gdk_win32_display_get_name (GdkDisplay *display)
 static void
 gdk_win32_display_beep (GdkDisplay *display)
 {
-  g_return_if_fail (display == gdk_display_get_default());
  if (!MessageBeep (-1))
    Beep(1000, 50);
 }
@@ -629,16 +708,12 @@ gdk_win32_display_beep (GdkDisplay *display)
 static void
 gdk_win32_display_flush (GdkDisplay * display)
 {
-  g_return_if_fail (display == _gdk_display);
-
  GdiFlush ();
 }

 static void
 gdk_win32_display_sync (GdkDisplay * display)
 {
-  g_return_if_fail (display == _gdk_display);
-
  GdiFlush ();
 }

@@ -691,6 +766,7 @@ gdk_win32_display_finalize (GObject *object)

  g_list_store_remove_all (G_LIST_STORE (display_win32->monitors));
  g_object_unref (display_win32->monitors);
+  g_object_unref (display_win32->keymap);

  while (display_win32->filters)
    _gdk_win32_message_filter_unref (display_win32, display_win32->filters->data);
@@ -1065,6 +1141,14 @@ gdk_win32_display_get_monitors (GdkDisplay *display)
  return self->monitors;
 }

+static GdkKeymap *
+gdk_win32_display_get_keymap (GdkDisplay *display)
+{
+  GdkWin32Display *self = GDK_WIN32_DISPLAY (display);
+
+  return self->keymap;
+}
+
 guint
 gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *display_win32,
                                            GdkSurface      *surface,
@@ -1251,8 +1335,7 @@ gdk_win32_display_class_init (GdkWin32DisplayClass *klass)
  display_class->notify_startup_complete = gdk_win32_display_notify_startup_complete;
  display_class->create_surface = _gdk_win32_display_create_surface;

-  display_class->get_keymap = _gdk_win32_display_get_keymap;
-
+  display_class->get_keymap = gdk_win32_display_get_keymap;
  display_class->get_monitors = gdk_win32_display_get_monitors;

 #ifdef GDK_RENDERING_VULKAN
--- a/gdk/win32/gdkdisplay-win32.h
+++ b/gdk/win32/gdkdisplay-win32.h
@@ -22,9 +22,11 @@
 #ifndef __GDK_DISPLAY__WIN32_H__
 #define __GDK_DISPLAY__WIN32_H__

-#include "gdkwin32screen.h"
 #include "gdkwin32cursor.h"
 
+#include "gdkdevicemanager-win32.h"
+#include "gdkprivate-win32.h"
+
 #ifdef GDK_WIN32_ENABLE_EGL
 # include <epoxy/egl.h>
 #endif
@@ -116,7 +118,8 @@ struct _GdkWin32Display
 {
  GdkDisplay display;

-  GdkWin32Screen *screen;
+  ATOM toplevel_class;
+  ATOM temp_class;

  Win32CursorTheme *cursor_theme;
  char *cursor_theme_name;
@@ -137,6 +140,7 @@ struct _GdkWin32Display
  HDC hdc_egl_temp;
 #endif

+  GdkKeymap *keymap;
  GListModel *monitors;

  guint hasWglARBCreateContext : 1;
@@ -160,6 +164,8 @@ struct _GdkWin32Display
  GdkWin32ShcoreFuncs shcore_funcs;
  GdkWin32User32DPIFuncs user32_dpi_funcs;
  
+  GdkDeviceManagerWin32 *device_manager;
+
  /* Cursor Items (GdkCursor->GdkWin32HCursor) */
  GHashTable *cursors;
  /* The cursor that is used by current grab (if any) */
@@ -185,8 +191,6 @@ struct _GdkWin32DisplayClass
  GdkDisplayClass display_class;
 };

-void       _gdk_win32_display_init_monitors    (GdkWin32Display *display);
-
 GPtrArray *_gdk_win32_display_get_monitor_list (GdkWin32Display *display);

 void        gdk_win32_display_check_composited (GdkWin32Display *display);
--- a/gdk/win32/gdkdrag-win32.c
+++ b/gdk/win32/gdkdrag-win32.c
@@ -237,7 +237,6 @@ typedef struct
  /* Cached here, so that we don't have to look in
   * the context every time.
   */
-  HWND                            source_window_handle;
  guint                           scale;

  /* We get this from the OS via IDropSourceNotify and pass it to the
@@ -720,8 +719,6 @@ typedef enum {
  GDK_DRAG_STATUS_DROP
 } GdkDragStatus;

-static gboolean use_ole2_dnd = TRUE;
-
 static gboolean drag_context_grab (GdkDrag *drag);

 G_DEFINE_TYPE (GdkWin32Drag, gdk_win32_drag, GDK_TYPE_DRAG)
@@ -789,8 +786,7 @@ gdk_drag_new (GdkDisplay         *display,
              GdkSurface         *surface,
              GdkContentProvider *content,
              GdkDragAction       actions,
-              GdkDevice          *device,
-              GdkDragProtocol     protocol)
+              GdkDevice          *device)
 {
  GdkWin32Drag *drag_win32;
  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
@@ -810,8 +806,6 @@ gdk_drag_new (GdkDisplay         *display,
  else
    drag_win32->scale = gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL);

-  drag_win32->protocol = protocol;
-
  return drag;
 }

@@ -1079,21 +1073,6 @@ maybe_emit_action_changed (GdkWin32Drag        *drag_win32,
    }
 }

-void
-_gdk_win32_local_drag_give_feedback (GdkDrag        *drag,
-                                     GdkDragAction   actions)
-{
-  GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
-
-  if (drag_win32->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
-    drag_win32->drag_status = GDK_DRAG_STATUS_DRAG;
-
-  GDK_NOTE (DND, g_print ("_gdk_win32_local_drag_give_feedback: 0x%p\n",
-                          drag));
-
-  maybe_emit_action_changed (drag_win32, actions);
-}
-
 static gboolean
 give_feedback (gpointer user_data)
 {
@@ -1604,7 +1583,6 @@ source_context_new (GdkDrag           *drag,
  result->ids.lpVtbl = &ids_vtbl;
  result->idsn.lpVtbl = &idsn_vtbl;
  result->ref_count = 1;
-  result->source_window_handle = GDK_SURFACE_HWND (surface);
  result->scale = drag_win32->scale;
  result->util_data.state = GDK_WIN32_DND_PENDING; /* Implicit */
  result->dest_window_handle = INVALID_HANDLE_VALUE;
@@ -1669,28 +1647,18 @@ void
 _gdk_drag_init (void)
 {
  CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
+  HRESULT hr;

-  if (g_strcmp0 (getenv ("GDK_WIN32_OLE2_DND"), "0") == 0)
-    use_ole2_dnd = FALSE;
+  hr = OleInitialize (NULL);

-  if (use_ole2_dnd)
-    {
-      HRESULT hr;
-
-      hr = OleInitialize (NULL);
-
-      if (! SUCCEEDED (hr))
-        g_error ("OleInitialize failed");
-    }
+  if (!SUCCEEDED (hr))
+    g_error ("OleInitialize failed");
 }

 void
 _gdk_win32_dnd_exit (void)
 {
-  if (use_ole2_dnd)
-    {
-      OleUninitialize ();
-    }
+  OleUninitialize ();

  CoUninitialize ();
 }
@@ -1721,6 +1689,9 @@ _gdk_win32_surface_drag_begin (GdkSurface         *surface,
  GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
  double px, py;
  int x_root, y_root;
+  source_drag_context *source_ctx;
+  data_object *data_obj;
+  GdkWin32DnDThreadDoDragDrop *ddd;

  g_return_val_if_fail (surface != NULL, NULL);

@@ -1728,8 +1699,7 @@ _gdk_win32_surface_drag_begin (GdkSurface         *surface,
                       surface,
                       content,
                       actions,
-                       device,
-                       use_ole2_dnd ? GDK_DRAG_PROTO_OLE2 : GDK_DRAG_PROTO_LOCAL);
+                       device);
  drag_win32 = GDK_WIN32_DRAG (drag);

  GDK_NOTE (DND, g_print ("_gdk_win32_surface_drag_begin\n"));
@@ -1753,34 +1723,29 @@ _gdk_win32_surface_drag_begin (GdkSurface         *surface,
      return FALSE;
    }

-  if (drag_win32->protocol == GDK_DRAG_PROTO_OLE2)
-    {
-      GdkWin32DnDThreadDoDragDrop *ddd = g_new0 (GdkWin32DnDThreadDoDragDrop, 1);
-      source_drag_context *source_ctx;
-      data_object         *data_obj;
+  ddd = g_new0 (GdkWin32DnDThreadDoDragDrop, 1);

-      source_ctx = source_context_new (drag, gdk_drag_get_formats (drag));
-      data_obj = data_object_new (drag);
+  source_ctx = source_context_new (drag, gdk_drag_get_formats (drag));
+  data_obj = data_object_new (drag);

-      ddd->base.item_type = GDK_WIN32_DND_THREAD_QUEUE_ITEM_DO_DRAG_DROP;
-      ddd->base.opaque_context = drag_win32;
-      ddd->src_context = source_ctx;
-      ddd->src_object = data_obj;
-      ddd->allowed_drop_effects = 0;
-      if (actions & GDK_ACTION_COPY)
-        ddd->allowed_drop_effects |= DROPEFFECT_COPY;
-      if (actions & GDK_ACTION_MOVE)
-        ddd->allowed_drop_effects |= DROPEFFECT_MOVE;
-      if (actions & GDK_ACTION_LINK)
-        ddd->allowed_drop_effects |= DROPEFFECT_LINK;
+  ddd->base.item_type = GDK_WIN32_DND_THREAD_QUEUE_ITEM_DO_DRAG_DROP;
+  ddd->base.opaque_context = drag_win32;
+  ddd->src_context = source_ctx;
+  ddd->src_object = data_obj;
+  ddd->allowed_drop_effects = 0;
+  if (actions & GDK_ACTION_COPY)
+    ddd->allowed_drop_effects |= DROPEFFECT_COPY;
+  if (actions & GDK_ACTION_MOVE)
+    ddd->allowed_drop_effects |= DROPEFFECT_MOVE;
+  if (actions & GDK_ACTION_LINK)
+    ddd->allowed_drop_effects |= DROPEFFECT_LINK;

-      g_hash_table_replace (clipdrop->active_source_drags, g_object_ref (drag), ddd);
-      increment_dnd_queue_counter ();
-      g_async_queue_push (clipdrop->dnd_queue, ddd);
-      API_CALL (PostThreadMessage, (clipdrop->dnd_thread_id, thread_wakeup_message, 0, 0));
+  g_hash_table_replace (clipdrop->active_source_drags, g_object_ref (drag), ddd);
+  increment_dnd_queue_counter ();
+  g_async_queue_push (clipdrop->dnd_queue, ddd);
+  API_CALL (PostThreadMessage, (clipdrop->dnd_thread_id, thread_wakeup_message, 0, 0));

-      drag_win32->util_data.state = GDK_WIN32_DND_PENDING;
-    }
+  drag_win32->util_data.state = GDK_WIN32_DND_PENDING;

  move_drag_surface (drag, x_root, y_root);

@@ -1847,8 +1812,8 @@ gdk_win32_drag_find_window (GdkDrag    *drag,
  g_assert (_win32_main_thread == NULL ||
            _win32_main_thread == g_thread_self ());

-  a.x = x_root * drag_win32->scale - _gdk_offset_x;
-  a.y = y_root * drag_win32->scale - _gdk_offset_y;
+  a.x = x_root * drag_win32->scale;
+  a.y = y_root * drag_win32->scale;
  a.ignore = drag_surface ? GDK_SURFACE_HWND (drag_surface) : NULL;
  a.result = INVALID_HANDLE_VALUE;

@@ -1889,100 +1854,6 @@ manufacture_keystate_from_GMT (GdkModifierType state)
  return key_state;
 }

-/* This only works if dest_window our window and the DnD operation
- * is currently local to the application.
- */
-static GdkDrop *
-_gdk_win32_get_drop_for_dest_window (HWND dest_window)
-{
-  GdkSurface *drop_surface = gdk_win32_handle_table_lookup (dest_window);
-  GdkDrop    *result = NULL;
-
-  if (drop_surface)
-    result = _gdk_win32_get_drop_for_dest_surface (drop_surface);
-
-  return result;
-}
-
-static gboolean
-gdk_win32_local_drag_motion (GdkDrag         *drag,
-                             HWND             dest_window,
-                             int              x_root,
-                             int              y_root,
-                             GdkDragAction    possible_actions,
-                             DWORD            key_state,
-                             guint32          time_)
-{
-  GdkWin32Drag *drag_win32;
-  GdkDrop *drop;
-  GdkDragAction actions;
-
-  g_assert (_win32_main_thread == NULL ||
-            _win32_main_thread == g_thread_self ());
-
-  g_return_val_if_fail (drag != NULL, FALSE);
-
-  drag_win32 = GDK_WIN32_DRAG (drag);
-
-  drop = _gdk_win32_get_drop_for_dest_window (drag_win32->dest_window);
-
-  actions = gdk_drag_get_actions (drag);
-
-  GDK_NOTE (DND, g_print ("gdk_win32_local_drag_motion: @ %+d:%+d possible=%s\n"
-                          " dest=%p (current %p) drop=%p drag=%p:{actions=%s,action=%s}\n",
-                          x_root, y_root,
-                          _gdk_win32_drag_action_to_string (possible_actions),
-                          dest_window, drag_win32->dest_window, drop, drag,
-                          _gdk_win32_drag_action_to_string (actions),
-                          _gdk_win32_drag_action_to_string (gdk_drag_get_selected_action (drag))));
-
-  if (drag_win32->dest_window != dest_window)
-    {
-      /* Send a leave to the last destination */
-      if (drop)
-        _gdk_win32_local_drop_target_dragleave (drop, time_);
-
-      drag_win32->dest_window = dest_window;
-      drag_win32->drag_status = GDK_DRAG_STATUS_DRAG;
-
-      _gdk_win32_local_drop_target_dragenter (drag,
-                                              gdk_win32_handle_table_lookup (dest_window),
-                                              x_root,
-                                              y_root,
-                                              key_state,
-                                              time_,
-                                              &actions);
-
-      drop = _gdk_win32_get_drop_for_dest_window (drag_win32->dest_window);
-      maybe_emit_action_changed (drag_win32, actions);
-    }
-
-  /* Send a drag-motion event */
-
-  drag_win32->util_data.last_x = x_root;
-  drag_win32->util_data.last_y = y_root;
-
-  if (drop != NULL &&
-      drag_win32->drag_status == GDK_DRAG_STATUS_DRAG &&
-      _gdk_win32_local_drop_target_will_emit_motion (drop, x_root, y_root, key_state))
-    {
-      actions = gdk_drag_get_actions (drag);
-      drag_win32->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
-
-      _gdk_win32_local_drop_target_dragover (drop, drag, x_root, y_root, key_state, time_, &actions);
-
-      maybe_emit_action_changed (drag_win32, actions);
-    }
-
-  GDK_NOTE (DND, g_print (" returning %s\n"
-                          " drag=%p:{actions=%s,action=%s}\n",
-                          (drop != NULL && drag_win32->drag_status == GDK_DRAG_STATUS_DRAG) ? "TRUE" : "FALSE",
-                          drag,
-                          _gdk_win32_drag_action_to_string (gdk_drag_get_actions (drag)),
-                          _gdk_win32_drag_action_to_string (gdk_drag_get_selected_action (drag))));
-  return (drop != NULL && drag_win32->drag_status == GDK_DRAG_STATUS_DRAG);
-}
-
 static void
 send_source_state_update (GdkWin32Clipdrop    *clipdrop,
                          GdkWin32Drag        *drag_win32,
@@ -2003,6 +1874,7 @@ gdk_win32_drag_drop (GdkDrag *drag,
 {
  GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
  GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
+  gpointer ddd;

  g_assert (_win32_main_thread == NULL ||
            _win32_main_thread == g_thread_self ());
@@ -2011,29 +1883,12 @@ gdk_win32_drag_drop (GdkDrag *drag,

  GDK_NOTE (DND, g_print ("gdk_win32_drag_drop\n"));

-  if (drag_win32->protocol == GDK_DRAG_PROTO_LOCAL)
-    {
-      GdkDrop *drop = _gdk_win32_get_drop_for_dest_window (drag_win32->dest_window);
+  ddd = g_hash_table_lookup (clipdrop->active_source_drags, drag);

-      if (drop)
-        {
-          GdkDragAction actions;
+  drag_win32->util_data.state = GDK_WIN32_DND_DROPPED;

-          actions = gdk_drag_get_actions (drag);
-          _gdk_win32_local_drop_target_drop (drop, drag, time_, &actions);
-          maybe_emit_action_changed (drag_win32, actions);
-          _gdk_win32_local_drag_drop_response (drag, actions);
-        }
-    }
-  else if (drag_win32->protocol == GDK_DRAG_PROTO_OLE2)
-    {
-      gpointer ddd = g_hash_table_lookup (clipdrop->active_source_drags, drag);
-
-      drag_win32->util_data.state = GDK_WIN32_DND_DROPPED;
-
-      if (ddd)
-        send_source_state_update (clipdrop, drag_win32, ddd);
-    }
+  if (ddd)
+    send_source_state_update (clipdrop, drag_win32, ddd);
 }

 static void
@@ -2122,7 +1977,9 @@ gdk_win32_drag_drop_done (GdkDrag  *drag,
                          gboolean  success)
 {
  GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
+  GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
  GdkDragAnim *anim;
+  gpointer ddd;
 /*
  cairo_surface_t *win_surface;
  cairo_surface_t *surface;
@@ -2137,24 +1994,15 @@ gdk_win32_drag_drop_done (GdkDrag  *drag,
  /* FIXME: This is temporary, until the code is fixed to ensure that
   * gdk_drag_finish () is called by GTK.
   */
-  if (drag_win32->protocol == GDK_DRAG_PROTO_OLE2)
-    {
-      GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
-      gpointer ddd = g_hash_table_lookup (clipdrop->active_source_drags, drag);
+  ddd = g_hash_table_lookup (clipdrop->active_source_drags, drag);

-      if (success)
-        drag_win32->util_data.state = GDK_WIN32_DND_DROPPED;
-      else
-        drag_win32->util_data.state = GDK_WIN32_DND_NONE;
-
-      if (ddd)
-        send_source_state_update (clipdrop, drag_win32, ddd);
-    }
-  else if (drag_win32->protocol == GDK_DRAG_PROTO_LOCAL)
-    {
-      
-    }
+  if (success)
+    drag_win32->util_data.state = GDK_WIN32_DND_DROPPED;
+  else
+    drag_win32->util_data.state = GDK_WIN32_DND_NONE;

+  if (ddd)
+    send_source_state_update (clipdrop, drag_win32, ddd);
  drag_win32->handle_events = FALSE;

  if (success)
@@ -2279,14 +2127,6 @@ gdk_win32_drag_cancel (GdkDrag             *drag,
                          drag,
                          reason_str));

-  if (drag_win32->protocol == GDK_DRAG_PROTO_LOCAL)
-    {
-      GdkDrop *drop = _gdk_win32_get_drop_for_dest_window (drag_win32->dest_window);
-      if (drop)
-        _gdk_win32_local_drop_target_dragleave (drop, GDK_CURRENT_TIME);
-      drop = NULL;
-    }
-
  gdk_drag_set_cursor (drag, NULL);
  drag_context_ungrab (drag);
  gdk_drag_drop_done (drag, FALSE);
@@ -2308,32 +2148,11 @@ gdk_win32_drag_drop_performed (GdkDrag *drag,
 #define BIG_STEP 20
 #define SMALL_STEP 1

-static void
-gdk_local_drag_update (GdkDrag *drag,
-                       double   x_root,
-                       double   y_root,
-                       DWORD    grfKeyState,
-                       guint32  evtime)
-{
-  GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
-  HWND dest_window;
-
-  g_assert (_win32_main_thread == NULL ||
-            _win32_main_thread == g_thread_self ());
-
-  dest_window = gdk_win32_drag_find_window (drag,
-                                            drag_win32->drag_surface,
-                                            x_root, y_root);
-
-  gdk_win32_local_drag_motion (drag, dest_window, x_root, y_root,
-                               gdk_drag_get_actions (drag),
-                               grfKeyState, evtime);
-}
-
 static gboolean
 gdk_dnd_handle_motion_event (GdkDrag  *drag,
                             GdkEvent *event)
 {
+  GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
  GdkModifierType state;
  GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
  DWORD key_state;
@@ -2353,26 +2172,16 @@ gdk_dnd_handle_motion_event (GdkDrag  *drag,

  key_state = manufacture_keystate_from_GMT (state);

-  if (drag_win32->protocol == GDK_DRAG_PROTO_LOCAL)
-    {
-      gdk_local_drag_update (drag, x_root, y_root, key_state,
-                             gdk_event_get_time (event));
-    }
-  else if (drag_win32->protocol == GDK_DRAG_PROTO_OLE2)
-    {
-      GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
+  GDK_NOTE (DND, g_print ("Post WM_MOUSEMOVE keystate=%lu\n", key_state));

-      GDK_NOTE (DND, g_print ("Post WM_MOUSEMOVE keystate=%lu\n", key_state));
+  drag_win32->util_data.last_x = x_root;
+  drag_win32->util_data.last_y = y_root;

-      drag_win32->util_data.last_x = x_root;
-      drag_win32->util_data.last_y = y_root;
-
-      API_CALL (PostThreadMessage, (clipdrop->dnd_thread_id,
-                                    WM_MOUSEMOVE,
-                                    key_state,
-                                    MAKELPARAM (x * drag_win32->scale,
-                                                y * drag_win32->scale)));
-    }
+  API_CALL (PostThreadMessage, (clipdrop->dnd_thread_id,
+                                WM_MOUSEMOVE,
+                                key_state,
+                                MAKELPARAM (x * drag_win32->scale,
+                                            y * drag_win32->scale)));

  return TRUE;
 }
@@ -2454,11 +2263,6 @@ gdk_dnd_handle_key_event (GdkDrag  *drag,
  if (drag_win32->drag_surface)
    move_drag_surface (drag, drag_win32->util_data.last_x, drag_win32->util_data.last_y);

-  if (drag_win32->protocol == GDK_DRAG_PROTO_LOCAL)
-    gdk_local_drag_update (drag, drag_win32->util_data.last_x, drag_win32->util_data.last_y,
-                           manufacture_keystate_from_GMT (state),
-                           gdk_event_get_time (event));
-
  return TRUE;
 }

--- a/gdk/win32/gdkdrop-win32.c
+++ b/gdk/win32/gdkdrop-win32.c
@@ -76,9 +76,6 @@ struct _GdkWin32Drop
 {
  GdkDrop          drop;

-  /* The drag protocol being in use */
-  GdkDragProtocol  protocol;
-
  /* The actions supported at GTK level. Set in gdk_win32_drop_status(). */
  GdkDragAction    actions;

@@ -92,13 +89,7 @@ struct _GdkWin32Drop
   */
  GArray          *droptarget_w32format_contentformat_map;

-  /* The list from WM_DROPFILES is store here temporarily,
-   * until the next gdk_win32_drop_read_async ()
-   */
-  char            *dropfiles_list;
-
  guint drop_finished : 1; /* FALSE until gdk_drop_finish() is called */
-  guint drop_failed : 1;   /* Whether the drop was unsuccessful */
 };

 struct _GdkWin32DropClass
@@ -140,9 +131,6 @@ struct _drop_target_context
  IDataObject                    *data_object;
 };

-/* TRUE to use OLE2 protocol, FALSE to use local protocol */
-static gboolean use_ole2_dnd = TRUE;
-
 static void
 gdk_win32_drop_init (GdkWin32Drop *drop)
 {
@@ -173,8 +161,7 @@ gdk_drop_new (GdkDisplay        *display,
              GdkDevice         *device,
              GdkDrag           *drag,
              GdkContentFormats *formats,
-              GdkSurface        *surface,
-              GdkDragProtocol    protocol)
+              GdkSurface        *surface)
 {
  GdkWin32Drop *drop_win32;
  GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
@@ -191,8 +178,6 @@ gdk_drop_new (GdkDisplay        *display,
  else
    drop_win32->scale = gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL);

-  drop_win32->protocol = protocol;
-
  return GDK_DROP (drop_win32);
 }

@@ -451,51 +436,6 @@ set_source_actions_helper (GdkDrop       *drop,
  return actions;
 }

-void
-_gdk_win32_local_drop_target_dragenter (GdkDrag        *drag,
-                                        GdkSurface     *dest_surface,
-                                        int             x_root,
-                                        int             y_root,
-                                        DWORD           grfKeyState,
-                                        guint32         time_,
-                                        GdkDragAction  *actions)
-{
-  GdkDrop *drop;
-  GdkWin32Drop *drop_win32;
-  GdkDisplay *display;
-  GdkDragAction source_actions;
-  GdkWin32Surface *impl = GDK_WIN32_SURFACE (dest_surface);
-
-  GDK_NOTE (DND, g_print ("_gdk_win32_local_drop_target_dragenter %p @ %d : %d"
-                          " for dest window 0x%p"
-                          ". actions = %s\n",
-                          drag, x_root, y_root,
-                          dest_surface,
-                          _gdk_win32_drag_action_to_string (*actions)));
-
-  display = gdk_surface_get_display (dest_surface);
-  drop = gdk_drop_new (display,
-                       gdk_seat_get_pointer (gdk_display_get_default_seat (display)),
-                       drag,
-                       gdk_drag_get_formats (drag),
-                       dest_surface,
-                       GDK_DRAG_PROTO_LOCAL);
-  drop_win32 = GDK_WIN32_DROP (drop);
-
-  impl->drop = drop;
-
-  source_actions = set_source_actions_helper (drop, *actions, grfKeyState);
-
-  gdk_drop_emit_enter_event (drop, TRUE, x_root, y_root, time_);
-  drop_win32->last_key_state = grfKeyState;
-  drop_win32->last_x = x_root;
-  drop_win32->last_y = y_root;
-  *actions = filter_actions (drop_win32->actions, source_actions);
-
-  GDK_NOTE (DND, g_print ("_gdk_win32_local_drop_target_dragenter returns with actions %s\n",
-                          _gdk_win32_drag_action_to_string (*actions)));
-}
-
 /* The pdwEffect here initially points
 * to a DWORD that contains the value of dwOKEffects argument in DoDragDrop,
 * i.e. the drag action that the drag source deems acceptable.
@@ -545,8 +485,7 @@ idroptarget_dragenter (LPDROPTARGET This,
                       gdk_seat_get_pointer (gdk_display_get_default_seat (display)),
                       drag,
                       formats,
-                       ctx->surface,
-                       GDK_DRAG_PROTO_OLE2);
+                       ctx->surface);
  drop_win32 = GDK_WIN32_DROP (drop);
  g_array_set_size (drop_win32->droptarget_w32format_contentformat_map, 0);
  gdk_content_formats_unref (formats);
@@ -558,8 +497,8 @@ idroptarget_dragenter (LPDROPTARGET This,
                                              grfKeyState);

  set_data_object (&ctx->data_object, pDataObj);
-  pt_x = pt.x / drop_win32->scale + _gdk_offset_x;
-  pt_y = pt.y / drop_win32->scale + _gdk_offset_y;
+  pt_x = pt.x / drop_win32->scale;
+  pt_y = pt.y / drop_win32->scale;
  gdk_drop_emit_enter_event (drop, TRUE, pt_x, pt_y, GDK_CURRENT_TIME);
  drop_win32->last_key_state = grfKeyState;
  drop_win32->last_x = pt_x;
@@ -575,55 +514,6 @@ idroptarget_dragenter (LPDROPTARGET This,
  return S_OK;
 }

-gboolean
-_gdk_win32_local_drop_target_will_emit_motion (GdkDrop *drop,
-                                               int      x_root,
-                                               int      y_root,
-                                               DWORD    grfKeyState)
-{
-  GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (drop);
-
-  if (x_root != drop_win32->last_x ||
-      y_root != drop_win32->last_y ||
-      grfKeyState != drop_win32->last_key_state)
-    return TRUE;
-
-  return FALSE;
-}
-
-void
-_gdk_win32_local_drop_target_dragover (GdkDrop        *drop,
-                                       GdkDrag        *drag,
-                                       int             x_root,
-                                       int             y_root,
-                                       DWORD           grfKeyState,
-                                       guint32         time_,
-                                       GdkDragAction  *actions)
-{
-  GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (drop);
-  GdkDragAction source_actions;
-
-  source_actions = set_source_actions_helper (drop, *actions, grfKeyState);
-
-  GDK_NOTE (DND, g_print ("_gdk_win32_local_drop_target_dragover %p @ %d : %d"
-                          ", actions = %s\n",
-                          drop, x_root, y_root,
-                          _gdk_win32_drag_action_to_string (*actions)));
-
-  if (_gdk_win32_local_drop_target_will_emit_motion (drop, x_root, y_root, grfKeyState))
-    {
-      gdk_drop_emit_motion_event (drop, TRUE, x_root, y_root, time_);
-      drop_win32->last_key_state = grfKeyState;
-      drop_win32->last_x = x_root;
-      drop_win32->last_y = y_root;
-    }
-
-  *actions = filter_actions (drop_win32->actions, source_actions);
-
-  GDK_NOTE (DND, g_print ("_gdk_win32_local_drop_target_dragover returns with actions %s\n",
-                          _gdk_win32_drag_action_to_string (*actions)));
-}
-
 /* NOTE: This method is called continuously, even if nothing is
 * happening, as long as the drag operation is in progress and
 * the cursor is above our window.
@@ -642,8 +532,8 @@ idroptarget_dragover (LPDROPTARGET This,
 {
  drop_target_context *ctx = (drop_target_context *) This;
  GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (ctx->drop);
-  int pt_x = pt.x / drop_win32->scale + _gdk_offset_x;
-  int pt_y = pt.y / drop_win32->scale + _gdk_offset_y;
+  int pt_x = pt.x / drop_win32->scale;
+  int pt_y = pt.y / drop_win32->scale;
  GdkDragAction source_actions;
  GdkDragAction dest_actions;

@@ -681,18 +571,6 @@ idroptarget_dragover (LPDROPTARGET This,
  return S_OK;
 }

-void
-_gdk_win32_local_drop_target_dragleave (GdkDrop *drop,
-                                        guint32  time_)
-{
-  GdkWin32Surface *impl = GDK_WIN32_SURFACE (gdk_drop_get_surface (drop));
-  GDK_NOTE (DND, g_print ("_gdk_win32_local_drop_target_dragleave %p\n", drop));
-
-  gdk_drop_emit_leave_event (drop, TRUE, time_);
-
-  g_clear_object (&impl->drop);
-}
-
 static HRESULT STDMETHODCALLTYPE
 idroptarget_dragleave (LPDROPTARGET This)
 {
@@ -708,35 +586,6 @@ idroptarget_dragleave (LPDROPTARGET This)
  return S_OK;
 }

-void
-_gdk_win32_local_drop_target_drop (GdkDrop        *drop,
-                                   GdkDrag        *drag,
-                                   guint32         time_,
-                                   GdkDragAction  *actions)
-{
-  GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (drop);
-
-  GDK_NOTE (DND, g_print ("_gdk_win32_local_drop_target_drop %p ", drop));
-
-  set_source_actions_helper (drop,
-                             *actions,
-                             drop_win32->last_key_state);
-
-  drop_win32->drop_finished = FALSE;
-  gdk_drop_emit_drop_event (drop, TRUE, drop_win32->last_x, drop_win32->last_y, time_);
-
-  while (!drop_win32->drop_finished)
-    g_main_context_iteration (NULL, FALSE);
-
-  /* Notify local source of the DnD result
-   * Special case:
-   * drop_win32->actions is guaranteed to contain 1 action after gdk_drop_finish ()
-   */
-  *actions = drop_win32->actions;
-
-  GDK_NOTE (DND, g_print ("drop with action %s\n", _gdk_win32_drag_action_to_string (*actions)));
-}
-
 static HRESULT STDMETHODCALLTYPE
 idroptarget_drop (LPDROPTARGET This,
                  LPDATAOBJECT pDataObj,
@@ -746,8 +595,8 @@ idroptarget_drop (LPDROPTARGET This,
 {
  drop_target_context *ctx = (drop_target_context *) This;
  GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (ctx->drop);
-  int pt_x = pt.x / drop_win32->scale + _gdk_offset_x;
-  int pt_y = pt.y / drop_win32->scale + _gdk_offset_y;
+  int pt_x = pt.x / drop_win32->scale;
+  int pt_y = pt.y / drop_win32->scale;
  GdkDragAction dest_action;

  GDK_NOTE (DND, g_print ("idroptarget_drop %p ", This));
@@ -891,175 +740,6 @@ resolve_link (HWND     hWnd,
  return SUCCEEDED (hr);
 }

-#if 0
-
-/* Check for filenames like C:\Users\tml\AppData\Local\Temp\d5qtkvvs.bmp */
-static gboolean
-filename_looks_tempish (const char *filename)
-{
-  char *dirname;
-  char *p;
-  const char *q;
-  gboolean retval = FALSE;
-
-  dirname = g_path_get_dirname (filename);
-
-  p = dirname;
-  q = g_get_tmp_dir ();
-
-  while (*p && *q &&
-         ((G_IS_DIR_SEPARATOR (*p) && G_IS_DIR_SEPARATOR (*q)) ||
-          g_ascii_tolower (*p) == g_ascii_tolower (*q)))
-    p++, q++;
-
-  if (!*p && !*q)
-    retval = TRUE;
-
-  g_free (dirname);
-
-  return retval;
-}
-
-static gboolean
-close_it (gpointer data)
-{
-  close (GPOINTER_TO_INT (data));
-
-  return FALSE;
-}
-
-#endif
-
-static GdkWin32MessageFilterReturn
-gdk_dropfiles_filter (GdkWin32Display *display,
-                      MSG             *msg,
-                      int             *ret_valp,
-                      gpointer         data)
-{
-  GdkSurface *window;
-  GdkDrop *drop;
-  GdkWin32Drop *drop_win32;
-  GString *result;
-  HANDLE hdrop;
-  POINT pt;
-  int nfiles, i;
-  char *fileName, *linkedFile;
-
-  if (msg->message != WM_DROPFILES)
-    return GDK_WIN32_MESSAGE_FILTER_CONTINUE;
-
-  GDK_NOTE (DND, g_print ("WM_DROPFILES: %p\n", msg->hwnd));
-
-  window = gdk_win32_handle_table_lookup (msg->hwnd);
-
-  drop = gdk_drop_new (GDK_DISPLAY (display),
-                       gdk_seat_get_pointer (gdk_display_get_default_seat (GDK_DISPLAY (display))),
-                       NULL,
-                       /* WM_DROPFILES drops are always file names */
-                       gdk_content_formats_new ((const char *[2]) {
-                                                  "text/uri-list",
-                                                  NULL
-                                                }, 1),
-                       window,
-                       GDK_DRAG_PROTO_WIN32_DROPFILES);
-  drop_win32 = GDK_WIN32_DROP (drop);
-
-  gdk_drop_set_actions (drop, GDK_ACTION_COPY);
-
-  hdrop = (HANDLE) msg->wParam;
-  DragQueryPoint (hdrop, &pt);
-  ClientToScreen (msg->hwnd, &pt);
-
-  nfiles = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
-
-  result = g_string_new (NULL);
-  for (i = 0; i < nfiles; i++)
-    {
-      char *uri;
-      wchar_t wfn[MAX_PATH];
-
-      DragQueryFileW (hdrop, i, wfn, MAX_PATH);
-      fileName = g_utf16_to_utf8 (wfn, -1, NULL, NULL, NULL);
-
-      /* Resolve shortcuts */
-      if (resolve_link (msg->hwnd, wfn, &linkedFile))
-        {
-          uri = g_filename_to_uri (linkedFile, NULL, NULL);
-          if (uri != NULL)
-            {
-              g_string_append (result, uri);
-              GDK_NOTE (DND, g_print ("... %s link to %s: %s\n",
-                                      fileName, linkedFile, uri));
-              g_free (uri);
-            }
-          g_free (fileName);
-          fileName = linkedFile;
-        }
-      else
-        {
-          uri = g_filename_to_uri (fileName, NULL, NULL);
-          if (uri != NULL)
-            {
-              g_string_append (result, uri);
-              GDK_NOTE (DND, g_print ("... %s: %s\n", fileName, uri));
-              g_free (uri);
-            }
-        }
-
-#if 0
-      /* Awful hack to recognize temp files corresponding to
-       * images dragged from Firefox... Open the file right here
-       * so that it is less likely that Firefox manages to delete
-       * it before the GTK-using app (typically GIMP) has opened
-       * it.
-       *
-       * Not compiled in for now, because it means images dragged
-       * from Firefox would stay around in the temp folder which
-       * is not what Firefox intended. I don't feel comfortable
-       * with that, both from a geenral sanity point of view, and
-       * from a privacy point of view. It's better to wait for
-       * Firefox to fix the problem, for instance by deleting the
-       * temp file after a longer delay, or to wait until we
-       * implement the OLE2_DND...
-       */
-      if (filename_looks_tempish (fileName))
-        {
-          int fd = g_open (fileName, _O_RDONLY|_O_BINARY, 0);
-          if (fd == -1)
-            {
-              GDK_NOTE (DND, g_print ("Could not open %s, maybe an image dragged from Firefox that it already deleted\n", fileName));
-            }
-          else
-            {
-              GDK_NOTE (DND, g_print ("Opened %s as %d so that Firefox won't delete it\n", fileName, fd));
-              g_timeout_add_seconds (1, close_it, GINT_TO_POINTER (fd));
-            }
-        }
-#endif
-
-      g_free (fileName);
-      g_string_append (result, "\015\012");
-    }
-
-  g_clear_pointer (&drop_win32->dropfiles_list, g_free);
-  drop_win32->dropfiles_list = result->str;
-  g_string_free (result, FALSE);
-  if (drop_win32->dropfiles_list == NULL)
-    drop_win32->dropfiles_list = g_strdup ("");
-
-  gdk_drop_emit_drop_event (drop,
-                            FALSE, 
-                            pt.x / drop_win32->scale + _gdk_offset_x,
-                            pt.y / drop_win32->scale + _gdk_offset_y,
-                            _gdk_win32_get_next_tick (msg->time));
-
-  DragFinish (hdrop);
-
-  *ret_valp = 0;
-
-  return GDK_WIN32_MESSAGE_FILTER_REMOVE;
-}
-
 static void
 gdk_win32_drop_status (GdkDrop       *drop,
                       GdkDragAction  actions,
@@ -1078,14 +758,6 @@ gdk_win32_drop_status (GdkDrop       *drop,
                          _gdk_win32_drag_action_to_string (preferred)));

  drop_win32->actions = actions;
-
-  if (drop_win32->protocol == GDK_DRAG_PROTO_OLE2)
-    return;
-
-  drag = gdk_drop_get_drag (drop);
-
-  if (drag != NULL)
-    _gdk_win32_local_drag_give_feedback (drag, actions);
 }

 static void
@@ -1101,9 +773,6 @@ gdk_win32_drop_finish (GdkDrop       *drop,

  drop_win32->actions = action;
  drop_win32->drop_finished = TRUE;
-
-  if (drop_win32->protocol == GDK_DRAG_PROTO_OLE2)
-    return;
 }

 #if 0
@@ -1134,55 +803,36 @@ gdk_destroy_filter (GdkXEvent *xev,
 void
 _gdk_win32_surface_register_dnd (GdkSurface *window)
 {
+  GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
  drop_target_context *ctx;
  HRESULT hr;

  g_return_if_fail (window != NULL);

-  if (g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL)
-    return;
-  else
-    g_object_set_data (G_OBJECT (window), "gdk-dnd-registered", GINT_TO_POINTER (TRUE));
-
  GDK_NOTE (DND, g_print ("gdk_win32_surface_register_dnd: %p\n", GDK_SURFACE_HWND (window)));

-  if (!use_ole2_dnd)
-    {
-      /* We always claim to accept dropped files, but in fact we might not,
-       * of course. This function is called in such a way that it cannot know
-       * whether the window (widget) in question actually accepts files
-       * (in gtk, data of type text/uri-list) or not.
-       */
-      gdk_win32_display_add_filter (GDK_WIN32_DISPLAY (gdk_display_get_default ()), gdk_dropfiles_filter, NULL);
-      DragAcceptFiles (GDK_SURFACE_HWND (window), TRUE);
-    }
+  /* Return if window is already setup for DND. */
+  if (impl->drop_target != NULL)
+    return;
+
+  ctx = target_context_new (window);
+
+  hr = CoLockObjectExternal ((IUnknown *) &ctx->idt, TRUE, FALSE);
+  if (!SUCCEEDED (hr))
+    OTHER_API_FAILED ("CoLockObjectExternal");
  else
    {
-      GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
-
-      /* Return if window is already setup for DND. */
-      if (impl->drop_target != NULL)
-        return;
-
-      ctx = target_context_new (window);
-
-      hr = CoLockObjectExternal ((IUnknown *) &ctx->idt, TRUE, FALSE);
-      if (!SUCCEEDED (hr))
-        OTHER_API_FAILED ("CoLockObjectExternal");
+      hr = RegisterDragDrop (GDK_SURFACE_HWND (window), &ctx->idt);
+      if (hr == DRAGDROP_E_ALREADYREGISTERED)
+        {
+          g_print ("DRAGDROP_E_ALREADYREGISTERED\n");
+          CoLockObjectExternal ((IUnknown *) &ctx->idt, FALSE, FALSE);
+        }
+      else if (!SUCCEEDED (hr))
+        OTHER_API_FAILED ("RegisterDragDrop");
      else
        {
-          hr = RegisterDragDrop (GDK_SURFACE_HWND (window), &ctx->idt);
-          if (hr == DRAGDROP_E_ALREADYREGISTERED)
-            {
-              g_print ("DRAGDROP_E_ALREADYREGISTERED\n");
-              CoLockObjectExternal ((IUnknown *) &ctx->idt, FALSE, FALSE);
-            }
-          else if (!SUCCEEDED (hr))
-            OTHER_API_FAILED ("RegisterDragDrop");
-          else
-            {
-              impl->drop_target = ctx;
-            }
+          impl->drop_target = ctx;
        }
    }
 }
@@ -1271,28 +921,6 @@ gdk_win32_drop_read_async (GdkDrop             *drop,

  mime_types = gdk_content_formats_get_mime_types (formats, &n_mime_types);

-  if (drop_win32->protocol == GDK_DRAG_PROTO_WIN32_DROPFILES)
-    {
-      for (i = 0; i < n_mime_types; i++)
-        if (g_strcmp0 (mime_types[i], "text/uri-list") == 0)
-          break;
-      if (i >= n_mime_types)
-        {
-          g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
-                                   _("No compatible transfer format found"));
-          g_clear_pointer (&drop_win32->dropfiles_list, g_free);
-
-          return;
-        }
-
-      stream = g_memory_input_stream_new_from_data (drop_win32->dropfiles_list, strlen (drop_win32->dropfiles_list), g_free);
-      drop_win32->dropfiles_list = NULL;
-      g_object_set_data (G_OBJECT (stream), "gdk-dnd-stream-contenttype", (gpointer) "text/uri-list");
-      g_task_return_pointer (task, stream, g_object_unref);
-
-      return;
-    }
-
  tctx = GDK_WIN32_SURFACE (gdk_drop_get_surface (drop))->drop_target;

  if (tctx == NULL)
@@ -1418,10 +1046,3 @@ gdk_win32_drop_class_init (GdkWin32DropClass *klass)
  drop_class->read_async = gdk_win32_drop_read_async;
  drop_class->read_finish = gdk_win32_drop_read_finish;
 }
-
-void
-_gdk_drop_init (void)
-{
-  if (g_strcmp0 (getenv ("GDK_WIN32_OLE2_DND"), "0") == 0)
-    use_ole2_dnd = FALSE;
-}
--- a/gdk/win32/gdkevents-win32.c
+++ b/gdk/win32/gdkevents-win32.c
@@ -100,7 +100,8 @@

 #define SYNAPSIS_ICON_WINDOW_CLASS "SynTrackCursorWindowClass"

-static gboolean gdk_event_translate (MSG        *msg,
+static gboolean gdk_event_translate (GdkDisplay *display,
+                                     MSG        *msg,
 				     int        *ret_valp);
 static gboolean gdk_event_prepare  (GSource     *source,
 				    int         *timeout);
@@ -239,10 +240,34 @@ inner_window_procedure (HWND   hwnd,
 			WPARAM wparam,
 			LPARAM lparam)
 {
+  GdkSurface *surface;
+  GdkDisplay *display;
  MSG msg;
  DWORD pos;
  int ret_val = 0;

+  surface = GDK_SURFACE (GetWindowLongPtr (hwnd, GWLP_USERDATA));
+  if (surface == NULL)
+    {
+      /* XXX Handle WM_QUIT here ? */
+      if (message == WM_QUIT)
+        {
+          GDK_NOTE (EVENTS, g_print (" %d", (int) wparam));
+          exit (wparam);
+        }
+      else if (message == WM_CREATE)
+        {
+          surface = (UNALIGNED GdkSurface *) (((LPCREATESTRUCTW) lparam)->lpCreateParams);
+          GDK_SURFACE_HWND (surface) = hwnd;
+          SetWindowLongPtr (hwnd, GWLP_USERDATA, (LONG_PTR) surface);
+        }
+      else
+        {
+          GDK_NOTE (EVENTS, g_print (" (no GdkSurface)"));
+        }
+      return DefWindowProcW (hwnd, message, wparam, lparam);
+    }
+  display = gdk_surface_get_display (surface);
  msg.hwnd = hwnd;
  msg.message = message;
  msg.wParam = wparam;
@@ -252,7 +277,7 @@ inner_window_procedure (HWND   hwnd,
  msg.pt.x = GET_X_LPARAM (pos);
  msg.pt.y = GET_Y_LPARAM (pos);

-  if (gdk_event_translate (&msg, &ret_val))
+  if (gdk_event_translate (display, &msg, &ret_val))
    {
      /* If gdk_event_translate() returns TRUE, we return ret_val from
       * the window procedure.
@@ -271,7 +296,7 @@ inner_window_procedure (HWND   hwnd,
 }

 LRESULT CALLBACK
-_gdk_win32_surface_procedure (HWND   hwnd,
+gdk_win32_surface_procedure (HWND   hwnd,
                             UINT   message,
                             WPARAM wparam,
                             LPARAM lparam)
@@ -374,7 +399,7 @@ low_level_keyboard_proc (int    code,
    if (kbd_focus_owner == NULL)
      break;

-    gdk_kbd_focus_owner = gdk_win32_handle_table_lookup (kbd_focus_owner);
+    gdk_kbd_focus_owner = GDK_SURFACE (GetWindowLongPtr (kbd_focus_owner, GWLP_USERDATA));

    if (gdk_kbd_focus_owner == NULL)
      break;
@@ -571,20 +596,19 @@ event_mask_string (GdkEventMask mask)
 #endif

 static GdkSurface *
-find_window_for_mouse_event (GdkSurface* reported_window,
-			     MSG*       msg)
+find_window_for_mouse_event (GdkDisplay *display,
+                             GdkSurface *reported_window,
+			     MSG        *msg)
 {
  POINT pt;
-  GdkDisplay *display;
  GdkDeviceManagerWin32 *device_manager;
  GdkSurface *event_surface;
  HWND hwnd;
  RECT rect;
  GdkDeviceGrabInfo *grab;

-  display = gdk_display_get_default ();
-  device_manager = GDK_DEVICE_MANAGER_WIN32 (_gdk_device_manager);
-
+  device_manager = GDK_WIN32_DISPLAY (display)->device_manager;
+  
  grab = _gdk_display_get_last_device_grab (display, device_manager->core_pointer);
  if (grab == NULL)
    return reported_window;
@@ -604,7 +628,7 @@ find_window_for_mouse_event (GdkSurface* reported_window,
 	  ScreenToClient (hwnd, &client_pt);
 	  GetClientRect (hwnd, &rect);
 	  if (PtInRect (&rect, client_pt))
-	    event_surface = gdk_win32_handle_table_lookup (hwnd);
+	    event_surface = GDK_SURFACE (GetWindowLongPtr (hwnd, GWLP_USERDATA));
 	}
      if (event_surface == NULL)
 	event_surface = grab->surface;
@@ -620,7 +644,8 @@ find_window_for_mouse_event (GdkSurface* reported_window,
 }

 static GdkModifierType
-build_key_event_state (BYTE *key_state)
+build_key_event_state (GdkDisplay *display,
+                       BYTE       *key_state)
 {
  GdkModifierType state;
  GdkWin32Keymap *keymap;
@@ -644,7 +669,7 @@ build_key_event_state (BYTE *key_state)
  if (key_state[VK_XBUTTON2] & 0x80)
    state |= GDK_BUTTON5_MASK;

-  keymap = GDK_WIN32_KEYMAP (_gdk_win32_display_get_keymap (_gdk_display));
+  keymap = GDK_WIN32_KEYMAP (gdk_display_get_keymap (display));

  if (_gdk_win32_keymap_has_altgr (keymap) &&
      (key_state[VK_LCONTROL] & 0x80) &&
@@ -668,11 +693,11 @@ build_key_event_state (BYTE *key_state)
 }

 static guint8
-get_active_group (void)
+get_active_group (GdkDisplay *display)
 {
  GdkWin32Keymap *keymap;

-  keymap = GDK_WIN32_KEYMAP (_gdk_win32_display_get_keymap (_gdk_display));
+  keymap = GDK_WIN32_KEYMAP (gdk_display_get_keymap (display));

  return _gdk_win32_keymap_get_active_group (keymap);
 }
@@ -885,8 +910,8 @@ _gdk_win32_append_event (GdkEvent *event)
  GdkDisplay *display;
  GList *link;

-  display = gdk_display_get_default ();
-
+  display = gdk_event_get_display (event);
+  
  fixup_event (event);
 #if 1
  link = _gdk_event_queue_append (display, event);
@@ -1050,8 +1075,8 @@ send_crossing_event (GdkDisplay                 *display,
  POINT pt;
  GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);

-  device_manager = _gdk_device_manager;
-
+  device_manager = GDK_WIN32_DISPLAY (display)->device_manager;
+  
  grab = _gdk_display_has_device_grab (display, device_manager->core_pointer, 0);

  if (grab != NULL &&
@@ -1265,8 +1290,6 @@ _gdk_win32_get_window_rect (GdkSurface *window,
  if (GDK_IS_TOPLEVEL (window))
    {
      ClientToScreen (hwnd, &point);
-      point.x += _gdk_offset_x * impl->surface_scale;
-      point.y += _gdk_offset_y * impl->surface_scale;
    }

  rect->left = point.x;
@@ -1470,7 +1493,7 @@ handle_dpi_changed (GdkSurface *window,
                    MSG       *msg)
 {
  GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
-  GdkDisplay *display = gdk_display_get_default ();
+  GdkDisplay *display = gdk_surface_get_display (window);
  GdkWin32Display *win32_display = GDK_WIN32_DISPLAY (display);
  RECT *rect = (RECT *)msg->lParam;
  guint old_scale = impl->surface_scale;
@@ -1508,20 +1531,18 @@ handle_dpi_changed (GdkSurface *window,
 }

 static void
-generate_button_event (GdkEventType      type,
-                       int               button,
-                       GdkSurface        *window,
-                       MSG              *msg)
+generate_button_event (GdkDeviceManagerWin32 *device_manager,
+                       GdkEventType           type,
+                       int                    button,
+                       GdkSurface            *window,
+                       MSG                   *msg)
 {
  GdkEvent *event;
-  GdkDeviceManagerWin32 *device_manager;
  GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);

  if (_gdk_input_ignore_core > 0)
    return;

-  device_manager = GDK_DEVICE_MANAGER_WIN32 (_gdk_device_manager);
-
  current_x = (gint16) GET_X_LPARAM (msg->lParam) / impl->surface_scale;
  current_y = (gint16) GET_Y_LPARAM (msg->lParam) / impl->surface_scale;

@@ -1726,8 +1747,9 @@ _gdk_win32_surface_fill_min_max_info (GdkSurface  *window,
 			     GDK_BUTTON5_MASK)

 static gboolean
-gdk_event_translate (MSG *msg,
-		     int *ret_valp)
+gdk_event_translate (GdkDisplay *display,
+                     MSG        *msg,
+		     int        *ret_valp)
 {
  RECT rect;
  POINT point;
@@ -1743,7 +1765,6 @@ gdk_event_translate (MSG *msg,
  wchar_t wbuf[100];
  int ccount;

-  GdkDisplay *display;
  GdkSurface *window = NULL;
  GdkWin32Surface *impl;
  GdkWin32Display *win32_display;
@@ -1773,8 +1794,8 @@ gdk_event_translate (MSG *msg,
  GdkScrollDirection direction;
  GdkTranslatedKey translated;

-  display = gdk_display_get_default ();
  win32_display = GDK_WIN32_DISPLAY (display);
+  device_manager_win32 = win32_display->device_manager;

  if (win32_display->filters)
    {
@@ -1785,29 +1806,7 @@ gdk_event_translate (MSG *msg,
 	return TRUE;
    }

-  window = gdk_win32_handle_table_lookup (msg->hwnd);
-
-  if (window == NULL)
-    {
-      /* XXX Handle WM_QUIT here ? */
-      if (msg->message == WM_QUIT)
-	{
-	  GDK_NOTE (EVENTS, g_print (" %d", (int) msg->wParam));
-	  exit (msg->wParam);
-	}
-      else if (msg->message == WM_CREATE)
-	{
-	  window = (UNALIGNED GdkSurface*) (((LPCREATESTRUCTW) msg->lParam)->lpCreateParams);
-	  GDK_SURFACE_HWND (window) = msg->hwnd;
-	}
-      else
-	{
-	  GDK_NOTE (EVENTS, g_print (" (no GdkSurface)"));
-	}
-      return FALSE;
-    }
-
-  device_manager_win32 = GDK_DEVICE_MANAGER_WIN32 (_gdk_device_manager);
+  window = GDK_SURFACE (GetWindowLongPtr (msg->hwnd, GWLP_USERDATA));

  keyboard_grab = _gdk_display_get_last_device_grab (display,
                                                     device_manager_win32->core_keyboard);
@@ -1831,7 +1830,7 @@ gdk_event_translate (MSG *msg,
    {
    case WM_INPUTLANGCHANGE:
      _gdk_input_locale = (HKL) msg->lParam;
-      _gdk_win32_keymap_set_active_layout (GDK_WIN32_KEYMAP (_gdk_win32_display_get_keymap (_gdk_display)), _gdk_input_locale);
+      _gdk_win32_keymap_set_active_layout (GDK_WIN32_KEYMAP (gdk_display_get_keymap (display)), _gdk_input_locale);
      GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT),
 		     LOCALE_IDEFAULTANSICODEPAGE,
 		     buf, sizeof (buf));
@@ -1962,7 +1961,7 @@ gdk_event_translate (MSG *msg,
 	    }
 	}
      else if (msg->wParam == VK_SHIFT &&
-	       LOBYTE (HIWORD (msg->lParam)) == _gdk_win32_keymap_get_rshift_scancode (GDK_WIN32_KEYMAP (_gdk_win32_display_get_keymap (_gdk_display))))
+	       LOBYTE (HIWORD (msg->lParam)) == _gdk_win32_keymap_get_rshift_scancode (GDK_WIN32_KEYMAP (gdk_display_get_keymap (display))))
 	keycode = VK_RSHIFT;

      is_modifier = (msg->wParam == VK_CONTROL ||
@@ -1970,8 +1969,8 @@ gdk_event_translate (MSG *msg,
                     msg->wParam == VK_MENU);
      /* g_print ("ctrl:%02x lctrl:%02x rctrl:%02x alt:%02x lalt:%02x ralt:%02x\n", key_state[VK_CONTROL], key_state[VK_LCONTROL], key_state[VK_RCONTROL], key_state[VK_MENU], key_state[VK_LMENU], key_state[VK_RMENU]); */

-      state = build_key_event_state (key_state);
-      group = get_active_group ();
+      state = build_key_event_state (display, key_state);
+      group = get_active_group (display);

      if (msg->wParam == VK_PACKET && ccount == 1)
 	{
@@ -1997,7 +1996,7 @@ gdk_event_translate (MSG *msg,
 	}
      else
 	{
-	  gdk_keymap_translate_keyboard_state (_gdk_win32_display_get_keymap (display),
+	  gdk_keymap_translate_keyboard_state (gdk_display_get_keymap (display),
 					       keycode,
 					       state,
 					       group,
@@ -2037,7 +2036,7 @@ gdk_event_translate (MSG *msg,
            fake_release.lParam = both_shift_pressed[0];

          both_shift_pressed[0] = both_shift_pressed[1] = 0;
-          gdk_event_translate (&fake_release, &tmp_retval);
+          gdk_event_translate (display, &fake_release, &tmp_retval);
        }
      both_shift_pressed[0] = both_shift_pressed[1] = 0;
    }
@@ -2125,14 +2124,14 @@ gdk_event_translate (MSG *msg,
          /* Build a key press event */
          translated.keyval = gdk_unicode_to_keyval (wbuf[i]);
          translated.consumed = 0;
-          translated.layout = get_active_group ();
+          translated.layout = get_active_group (display);
          translated.level = 0;
          event = gdk_key_event_new (GDK_KEY_PRESS,
                                     window,
                                     device_manager_win32->core_keyboard,
                                     _gdk_win32_get_next_tick (msg->time),
                                     0,
-                                     build_key_event_state (key_state),
+                                     build_key_event_state (display, key_state),
                                     FALSE,
                                     &translated,
                                     &translated);
@@ -2145,7 +2144,7 @@ gdk_event_translate (MSG *msg,
                                     device_manager_win32->core_keyboard,
                                     _gdk_win32_get_next_tick (msg->time),
                                     0,
-                                     build_key_event_state (key_state),
+                                     build_key_event_state (display, key_state),
                                     FALSE,
                                     &translated,
                                     &translated);
@@ -2178,7 +2177,7 @@ gdk_event_translate (MSG *msg,
 		g_print (" (%d,%d)",
 			 GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));

-      g_set_object (&window, find_window_for_mouse_event (window, msg));
+      g_set_object (&window, find_window_for_mouse_event (display, window, msg));
      /* TODO_CSW?: there used to some synthesize and propagate */
      if (GDK_SURFACE_DESTROYED (window))
 	break;
@@ -2191,7 +2190,8 @@ gdk_event_translate (MSG *msg,
      else
 	g_set_object (&implicit_grab_surface, NULL);

-      generate_button_event (GDK_BUTTON_PRESS, button,
+      generate_button_event (device_manager_win32,
+	                     GDK_BUTTON_PRESS, button,
 			     window, msg);

      return_val = TRUE;
@@ -2220,7 +2220,7 @@ gdk_event_translate (MSG *msg,
 		g_print (" (%d,%d)",
 			 GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));

-      g_set_object (&window, find_window_for_mouse_event (window, msg));
+      g_set_object (&window, find_window_for_mouse_event (display, window, msg));

      if (pointer_grab == NULL && implicit_grab_surface != NULL)
 	{
@@ -2240,7 +2240,7 @@ gdk_event_translate (MSG *msg,
 		  ScreenToClient (hwnd, &client_pt);
 		  GetClientRect (hwnd, &rect);
 		  if (PtInRect (&rect, client_pt))
-		    new_window = gdk_win32_handle_table_lookup (hwnd);
+		    new_window = GDK_SURFACE (GetWindowLongPtr (hwnd, GWLP_USERDATA));
 		}

 	      synthesize_crossing_events (display,
@@ -2258,7 +2258,8 @@ gdk_event_translate (MSG *msg,
      else
 	g_set_object (&implicit_grab_surface, NULL);

-      generate_button_event (GDK_BUTTON_RELEASE, button,
+      generate_button_event (device_manager_win32,
+	                     GDK_BUTTON_RELEASE, button,
 			     window, msg);

      impl = GDK_WIN32_SURFACE (window);
@@ -2292,8 +2293,8 @@ gdk_event_translate (MSG *msg,

 	      ScreenToClient (hwnd, &client_pt);
 	      GetClientRect (hwnd, &rect);
-	      if (PtInRect (&rect, client_pt))
-		new_window = gdk_win32_handle_table_lookup (hwnd);
+              if (PtInRect (&rect, client_pt))
+                new_window = gdk_win32_surface_lookup_for_display (display, hwnd);
 	    }

 	  if (!pointer_grab->owner_events &&
@@ -2329,19 +2330,19 @@ gdk_event_translate (MSG *msg,
 	  track_mouse_event (TME_LEAVE, GDK_SURFACE_HWND (new_window));
 	}

-      g_set_object (&window, find_window_for_mouse_event (window, msg));
+      g_set_object (&window, find_window_for_mouse_event (display, window, msg));
      impl = GDK_WIN32_SURFACE (window);

      /* If we haven't moved, don't create any GDK event. Windows
       * sends WM_MOUSEMOVE messages after a new window is shows under
       * the mouse, even if the mouse hasn't moved. This disturbs gtk.
       */
-      if ((msg->pt.x + _gdk_offset_x) / impl->surface_scale == current_root_x &&
-	  (msg->pt.y + _gdk_offset_y) / impl->surface_scale == current_root_y)
+      if (msg->pt.x / impl->surface_scale == current_root_x &&
+	  msg->pt.y / impl->surface_scale == current_root_y)
 	break;

-      current_root_x = (msg->pt.x + _gdk_offset_x) / impl->surface_scale;
-      current_root_y = (msg->pt.y + _gdk_offset_y) / impl->surface_scale;
+      current_root_x = msg->pt.x / impl->surface_scale;
+      current_root_y = msg->pt.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);
@@ -2394,8 +2395,8 @@ gdk_event_translate (MSG *msg,

 	  ScreenToClient (hwnd, &client_pt);
 	  GetClientRect (hwnd, &rect);
-	  if (PtInRect (&rect, client_pt))
-	    new_window = gdk_win32_handle_table_lookup (hwnd);
+          if (PtInRect (&rect, client_pt))
+            new_window = gdk_win32_surface_lookup_for_display (display, hwnd);
 	}

      if (!ignore_leave)
@@ -2453,7 +2454,7 @@ gdk_event_translate (MSG *msg,
      }

      msg->hwnd = hwnd;
-      if ((new_window = gdk_win32_handle_table_lookup (msg->hwnd)) == NULL)
+      if ((new_window = gdk_win32_surface_lookup_for_display (display, hwnd)) == NULL)
 	break;

      if (new_window != window)
@@ -2568,7 +2569,7 @@ gdk_event_translate (MSG *msg,
 	  !GDK_SURFACE_DESTROYED (keyboard_grab->surface) &&
 	  (_modal_operation_in_progress & GDK_WIN32_MODAL_OP_DND) == 0)
 	{
-	  generate_grab_broken_event (_gdk_device_manager, keyboard_grab->surface, TRUE, NULL);
+          generate_grab_broken_event (device_manager_win32, keyboard_grab->surface, TRUE, NULL);
 	}
      G_GNUC_FALLTHROUGH;

@@ -2580,7 +2581,7 @@ gdk_event_translate (MSG *msg,
      if (GDK_SURFACE_DESTROYED (window))
 	break;

-      generate_focus_event (_gdk_device_manager, window, (msg->message == WM_SETFOCUS));
+      generate_focus_event (device_manager_win32, window, (msg->message == WM_SETFOCUS));
      return_val = TRUE;
      break;

@@ -3014,7 +3015,7 @@ gdk_event_translate (MSG *msg,
        {
          if (msg->lParam != 0)
            {
-               GdkSurface *other_surface = gdk_win32_handle_table_lookup ((HWND) msg->lParam);
+               GdkSurface *other_surface = gdk_win32_surface_lookup_for_display (display, (HWND) msg->lParam);
               if (other_surface != NULL &&
                   (GDK_IS_POPUP (other_surface) || GDK_IS_DRAG_SURFACE (other_surface)))
                {
--- a/gdk/win32/gdkglobals-win32.c
+++ b/gdk/win32/gdkglobals-win32.c
@@ -27,12 +27,6 @@
 #include "gdktypes.h"
 #include "gdkprivate-win32.h"

-GdkDisplay	 *_gdk_display = NULL;
-GdkDeviceManagerWin32 *_gdk_device_manager = NULL;
-
-int		  _gdk_offset_x, _gdk_offset_y;
-
-HDC		  _gdk_display_hdc;
 HINSTANCE	  _gdk_dll_hinstance;
 HINSTANCE	  _gdk_app_hmodule;

--- a/gdk/win32/gdkkeys-win32.c
+++ b/gdk/win32/gdkkeys-win32.c
@@ -180,8 +180,6 @@ G_DEFINE_TYPE (GdkWin32Keymap, gdk_win32_keymap, GDK_TYPE_KEYMAP)

 guint _gdk_keymap_serial = 0;

-static GdkKeymap *default_keymap = NULL;
-
 #define KEY_STATE_SIZE 256

 static void update_keymap (GdkKeymap *gdk_keymap);
@@ -1178,17 +1176,6 @@ _gdk_win32_keymap_get_active_group (GdkWin32Keymap *keymap)
  return 0;
 }

-GdkKeymap*
-_gdk_win32_display_get_keymap (GdkDisplay *display)
-{
-  g_return_val_if_fail (display == gdk_display_get_default (), NULL);
-
-  if (default_keymap == NULL)
-    default_keymap = g_object_new (gdk_win32_keymap_get_type (), NULL);
-
-  return default_keymap;
-}
-
 static PangoDirection
 get_hkl_direction (HKL hkl)
 {
@@ -1211,14 +1198,8 @@ get_hkl_direction (HKL hkl)
 static PangoDirection
 gdk_win32_keymap_get_direction (GdkKeymap *gdk_keymap)
 {
+  GdkWin32Keymap *keymap = GDK_WIN32_KEYMAP (gdk_keymap);
  HKL active_hkl;
-  GdkWin32Keymap *keymap;
-  GdkKeymap *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());
-
-  if (gdk_keymap == NULL || gdk_keymap != default_keymap)
-    keymap = GDK_WIN32_KEYMAP (default_keymap);
-  else
-    keymap = GDK_WIN32_KEYMAP (gdk_keymap);

  update_keymap (GDK_KEYMAP (keymap));

@@ -1233,16 +1214,10 @@ gdk_win32_keymap_get_direction (GdkKeymap *gdk_keymap)
 static gboolean
 gdk_win32_keymap_have_bidi_layouts (GdkKeymap *gdk_keymap)
 {
-  GdkWin32Keymap *keymap;
-  gboolean        have_rtl = FALSE;
+  GdkWin32Keymap *keymap = GDK_WIN32_KEYMAP (gdk_keymap);
+  gboolean have_rtl = FALSE;
  gboolean        have_ltr = FALSE;
  int             group;
-  GdkKeymap      *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());
-
-  if (gdk_keymap == NULL || gdk_keymap != default_keymap)
-    keymap = GDK_WIN32_KEYMAP (default_keymap);
-  else
-    keymap = GDK_WIN32_KEYMAP (gdk_keymap);

  update_keymap (GDK_KEYMAP (keymap));

@@ -1286,48 +1261,34 @@ gdk_win32_keymap_get_entries_for_keyval (GdkKeymap     *gdk_keymap,
                                         guint          keyval,
                                         GArray        *retval)
 {
-  GdkKeymap *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());
+  GdkWin32Keymap *keymap = GDK_WIN32_KEYMAP (gdk_keymap);
  guint len = retval->len;
+  int vk;

-  g_return_val_if_fail (gdk_keymap == NULL || GDK_IS_KEYMAP (gdk_keymap), FALSE);
-  g_return_val_if_fail (keyval != 0, FALSE);
+  update_keymap (gdk_keymap);

-  /* Accept only the default keymap */
-  if (gdk_keymap == NULL || gdk_keymap == default_keymap)
+  for (vk = 0; vk < KEY_STATE_SIZE; vk++)
    {
-      int vk;
-      GdkWin32Keymap *keymap;
+      int group;

-      if (gdk_keymap == NULL)
-        keymap = GDK_WIN32_KEYMAP (default_keymap);
-      else
-        keymap = GDK_WIN32_KEYMAP (gdk_keymap);
-
-      update_keymap (gdk_keymap);
-
-      for (vk = 0; vk < KEY_STATE_SIZE; vk++)
+      for (group = 0; group < keymap->layout_handles->len; group++)
        {
-          int group;
+          GdkWin32KeyLevelState level;

-          for (group = 0; group < keymap->layout_handles->len; group++)
+          for (level = GDK_WIN32_LEVEL_NONE; level < GDK_WIN32_LEVEL_COUNT; level++)
            {
-              GdkWin32KeyLevelState    level;
+              guint *keygroup;

-              for (level = GDK_WIN32_LEVEL_NONE; level < GDK_WIN32_LEVEL_COUNT; level++)
+              keygroup = &keymap->keysym_tab[(vk * keymap->layout_handles->len + group) * GDK_WIN32_LEVEL_COUNT];
+
+              if (keygroup[level] == keyval)
                {
-                  guint *keygroup;
+                  GdkKeymapKey key;

-                  keygroup = &keymap->keysym_tab[(vk * keymap->layout_handles->len + group) * GDK_WIN32_LEVEL_COUNT];
-
-                  if (keygroup[level] == keyval)
-                    {
-                      GdkKeymapKey key;
-
-                      key.keycode = vk;
-                      key.group = group;
-                      key.level = level;
-                      g_array_append_val (retval, key);
-                    }
+                  key.keycode = vk;
+                  key.group = group;
+                  key.level = level;
+                  g_array_append_val (retval, key);
                }
            }
        }
@@ -1359,19 +1320,14 @@ gdk_win32_keymap_get_entries_for_keycode (GdkKeymap     *gdk_keymap,
                                          guint        **keyvals,
                                          int           *n_entries)
 {
-  GArray         *key_array;
-  GArray         *keyval_array;
-  int             group;
-  GdkWin32Keymap *keymap;
-  GdkKeymap      *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());
-
-  g_return_val_if_fail (gdk_keymap == NULL || GDK_IS_KEYMAP (gdk_keymap), FALSE);
-  g_return_val_if_fail (n_entries != NULL, FALSE);
+  GdkWin32Keymap *keymap = GDK_WIN32_KEYMAP (gdk_keymap);
+  GArray *key_array;
+  GArray *keyval_array;
+  int group;

  if (hardware_keycode <= 0 ||
      hardware_keycode >= KEY_STATE_SIZE ||
-      (keys == NULL && keyvals == NULL) ||
-      (gdk_keymap != NULL && gdk_keymap != default_keymap))
+      (keys == NULL && keyvals == NULL))
    {
      /* Wrong keycode or NULL output arrays or wrong keymap */
      if (keys)
@@ -1393,7 +1349,6 @@ gdk_win32_keymap_get_entries_for_keycode (GdkKeymap     *gdk_keymap,
  else
    keyval_array = NULL;

-  keymap = GDK_WIN32_KEYMAP (default_keymap);
  update_keymap (GDK_KEYMAP (keymap));

  for (group = 0; group < keymap->layout_handles->len; group++)
@@ -1453,18 +1408,12 @@ static guint
 gdk_win32_keymap_lookup_key (GdkKeymap          *gdk_keymap,
                             const GdkKeymapKey *key)
 {
+  GdkWin32Keymap *keymap = GDK_WIN32_KEYMAP (gdk_keymap);
  guint sym;
-  GdkWin32Keymap *keymap;
-  GdkKeymap      *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());

  g_return_val_if_fail (gdk_keymap == NULL || GDK_IS_KEYMAP (gdk_keymap), 0);
  g_return_val_if_fail (key != NULL, 0);

-  /* Accept only the default keymap */
-  if (gdk_keymap != NULL && gdk_keymap != default_keymap)
-    return 0;
-
-  keymap = GDK_WIN32_KEYMAP (default_keymap);
  update_keymap (GDK_KEYMAP (keymap));

  if (key->keycode >= KEY_STATE_SIZE ||
@@ -1490,14 +1439,11 @@ gdk_win32_keymap_translate_keyboard_state (GdkKeymap       *gdk_keymap,
                                           int             *level,
                                           GdkModifierType *consumed_modifiers)
 {
-  GdkWin32Keymap *keymap;
+  GdkWin32Keymap *keymap = GDK_WIN32_KEYMAP (gdk_keymap);
  guint tmp_keyval;
  guint *keygroup;
  GdkWin32KeyLevelState shift_level;
  GdkModifierType modifiers = GDK_SHIFT_MASK | GDK_LOCK_MASK | GDK_MOD2_MASK;
-  GdkKeymap *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());
-
-  g_return_val_if_fail (gdk_keymap == NULL || GDK_IS_KEYMAP (gdk_keymap), FALSE);

 #if 0
  GDK_NOTE (EVENTS, g_print ("gdk_keymap_translate_keyboard_state: keycode=%#x state=%#x group=%d\n",
@@ -1512,14 +1458,9 @@ gdk_win32_keymap_translate_keyboard_state (GdkKeymap       *gdk_keymap,
  if (consumed_modifiers)
    *consumed_modifiers = 0;

-  /* Accept only the default keymap */
-  if (gdk_keymap != NULL && gdk_keymap != default_keymap)
-    return FALSE;
-
  if (hardware_keycode >= KEY_STATE_SIZE)
    return FALSE;

-  keymap = GDK_WIN32_KEYMAP (default_keymap);
  update_keymap (GDK_KEYMAP (keymap));

  if (group < 0 || group >= keymap->layout_handles->len)
--- a/gdk/win32/gdkmain-win32.c
+++ b/gdk/win32/gdkmain-win32.c
@@ -63,9 +63,7 @@ _gdk_win32_surfaceing_init (void)
    GdiSetBatchLimit (1);

  _gdk_app_hmodule = GetModuleHandle (NULL);
-  _gdk_display_hdc = CreateDC ("DISPLAY", NULL, NULL, NULL);
  _gdk_input_locale = GetKeyboardLayout (0);
-  _gdk_win32_keymap_set_active_layout (GDK_WIN32_KEYMAP (_gdk_win32_display_get_keymap (_gdk_display)), _gdk_input_locale);
  GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT),
 		 LOCALE_IDEFAULTANSICODEPAGE,
 		 buf, sizeof (buf));
@@ -149,27 +147,6 @@ _gdk_win32_print_paletteentries (const PALETTEENTRY *pep,
 		 (g_sprintf (buf, " %d", pep[i].peFlags), buf))))));
 }

-void
-_gdk_win32_print_system_palette (void)
-{
-  PALETTEENTRY *pe;
-  int k;
-
-  k = GetSystemPaletteEntries (_gdk_display_hdc, 0, 0, NULL);
-  pe = g_new (PALETTEENTRY, k);
-  k = GetSystemPaletteEntries (_gdk_display_hdc, 0, k, pe);
-
-  if (!k)
-    g_print ("GetSystemPaletteEntries failed: %s\n",
-	     g_win32_error_message (GetLastError ()));
-  else
-    {
-      g_print ("System palette: %d entries\n", k);
-      _gdk_win32_print_paletteentries (pe, k);
-    }
-  g_free (pe);
-}
-
 static int
 palette_size (HPALETTE hpal)
 {
@@ -244,23 +221,6 @@ _gdk_win32_print_dc (HDC hdc)
  DeleteObject (hrgn);
 }

-char *
-_gdk_win32_drag_protocol_to_string (GdkDragProtocol protocol)
-{
-  switch (protocol)
-    {
-#define CASE(x) case GDK_DRAG_PROTO_##x: return #x
-      CASE (NONE);
-      CASE (WIN32_DROPFILES);
-      CASE (OLE2);
-      CASE (LOCAL);
-#undef CASE
-    default: return static_printf ("illegal_%d", protocol);
-    }
-  /* NOTREACHED */
-  return NULL;
-}
-
 char *
 _gdk_win32_surface_state_to_string (GdkToplevelState state)
 {
--- a/gdk/win32/gdkmonitor-win32.c
+++ b/gdk/win32/gdkmonitor-win32.c
@@ -689,9 +689,6 @@ enum_monitor (HMONITOR hmonitor,
                  HMONITOR hmonitor;
                  POINT pt;

-                  /* Not subtracting _gdk_offset_x and _gdk_offset_y because they will only
-                   * be added later on, in _gdk_win32_display_get_monitor_list().
-                   */
                  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);
@@ -787,46 +784,7 @@ _gdk_win32_display_get_monitor_list (GdkWin32Display *win32_display)
      EnumDisplayMonitors (NULL, NULL, enum_monitor, (LPARAM) &data);
      prune_monitors (&data);
    }
-
-  _gdk_offset_x = G_MININT;
-  _gdk_offset_y = G_MININT;
-
-  for (i = 0; i < data.monitors->len; i++)
-    {
-      GdkWin32Monitor *m;
-      GdkRectangle rect;
-
-      m = g_ptr_array_index (data.monitors, i);
-
-      /* Calculate offset */
-      gdk_monitor_get_geometry (GDK_MONITOR (m), &rect);
-      _gdk_offset_x = MAX (_gdk_offset_x, -rect.x);
-      _gdk_offset_y = MAX (_gdk_offset_y, -rect.y);
-    }
-
-  GDK_NOTE (MISC, g_print ("Multi-monitor offset: (%d,%d)\n",
-                           _gdk_offset_x, _gdk_offset_y));
-
-  /* Translate monitor coords into GDK coordinate space */
-  for (i = 0; i < data.monitors->len; i++)
-    {
-      GdkWin32Monitor *m;
-      GdkRectangle rect;
-
-      m = g_ptr_array_index (data.monitors, i);
-
-      gdk_monitor_get_geometry (GDK_MONITOR (m), &rect);
-      rect.x += _gdk_offset_x;
-      rect.y += _gdk_offset_y;
-      gdk_monitor_set_geometry (GDK_MONITOR (m), &rect);
-
-      m->work_rect.x += _gdk_offset_x;
-      m->work_rect.y += _gdk_offset_y;
-
-      GDK_NOTE (MISC, g_print ("Monitor %d: %dx%d@%+d%+d\n", i,
-                               rect.width, rect.height, rect.x, rect.y));
-    }
-
+  
  return data.monitors;
 }

--- a/gdk/win32/gdkprivate-win32.h
+++ b/gdk/win32/gdkprivate-win32.h
@@ -149,14 +149,6 @@ typedef enum {
  GDK_WIN32_PE_INUSE
 } GdkWin32PalEntryState;

-typedef enum
-{
-  GDK_DRAG_PROTO_NONE = 0,
-  GDK_DRAG_PROTO_WIN32_DROPFILES,
-  GDK_DRAG_PROTO_OLE2,
-  GDK_DRAG_PROTO_LOCAL,
-} GdkDragProtocol;
-
 GType _gdk_gc_win32_get_type (void);

 gulong _gdk_win32_get_next_tick (gulong suggested_tick);
@@ -184,10 +176,6 @@ void _gdk_win32_surface_move_region (GdkSurface       *window,
 void _gdk_win32_selection_init (void);
 void _gdk_win32_dnd_exit (void);

-void     gdk_win32_handle_table_insert  (HANDLE   *handle,
-                                         gpointer data);
-void     gdk_win32_handle_table_remove  (HANDLE handle);
-
 HRGN      _gdk_win32_cairo_region_to_hrgn (const cairo_region_t *region,
                                           int                   x_origin,
                                           int                   y_origin);
@@ -208,11 +196,9 @@ gboolean   _gdk_modal_blocked       (GdkSurface *window);
 #ifdef G_ENABLE_DEBUG
 void   _gdk_win32_print_paletteentries (const PALETTEENTRY *pep,
                                        const int           nentries);
-void   _gdk_win32_print_system_palette (void);
 void   _gdk_win32_print_hpalette       (HPALETTE     hpal);
 void   _gdk_win32_print_dc             (HDC          hdc);

-char *_gdk_win32_drag_protocol_to_string (GdkDragProtocol protocol);
 char *_gdk_win32_surface_state_to_string (GdkToplevelState state);
 char *_gdk_win32_surface_style_to_string (LONG style);
 char *_gdk_win32_surface_exstyle_to_string (LONG style);
@@ -259,20 +245,8 @@ void    _gdk_other_api_failed        (const char *where,
 #define GDI_CALL(api, arglist) (api arglist ? 1 : (WIN32_GDI_FAILED (#api), 0))
 #define API_CALL(api, arglist) (api arglist ? 1 : (WIN32_API_FAILED (#api), 0))

-extern LRESULT CALLBACK _gdk_win32_surface_procedure (HWND, UINT, WPARAM, LPARAM);
+extern LRESULT CALLBACK gdk_win32_surface_procedure (HWND, UINT, WPARAM, LPARAM);

-extern GdkDisplay       *_gdk_display;
-
-extern GdkDeviceManagerWin32 *_gdk_device_manager;
-
-/* Offsets to add to Windows coordinates (which are relative to the
- * primary monitor's origin, and thus might be negative for monitors
- * to the left and/or above the primary monitor) to get GDK
- * coordinates, which should be non-negative on the whole screen.
- */
-extern int               _gdk_offset_x, _gdk_offset_y;
-
-extern HDC               _gdk_display_hdc;
 extern HINSTANCE         _gdk_dll_hinstance;
 extern HINSTANCE         _gdk_app_hmodule;

@@ -376,9 +350,6 @@ guint8     _gdk_win32_keymap_get_rshift_scancode (GdkWin32Keymap *keymap);
 void       _gdk_win32_keymap_set_active_layout   (GdkWin32Keymap *keymap,
                                                  HKL             hkl);

-
-GdkKeymap *_gdk_win32_display_get_keymap (GdkDisplay *display);
-
 GdkSurface *_gdk_win32_display_create_surface  (GdkDisplay    *display,
                                                GdkSurfaceType surface_type,
                                                GdkSurface     *parent,
@@ -442,7 +413,6 @@ BOOL WINAPI GtkShowWindow (GdkSurface *window,
 /* Initialization */
 void _gdk_win32_surfaceing_init (void);
 void _gdk_drag_init    (void);
-void _gdk_drop_init    (void);
 void _gdk_events_init (GdkDisplay *display);

 #endif /* __GDK_PRIVATE_WIN32_H__ */
--- a/gdk/win32/gdkproperty-win32.c
+++ b/gdk/win32/gdkproperty-win32.c
@@ -34,8 +34,9 @@
 #include "gdkwin32.h"

 static char *
-_get_system_font_name (HDC hdc)
+_get_system_font_name (void)
 {
+  HDC hdc;
  NONCLIENTMETRICSW ncm;
  PangoFontDescription *font_desc;
  char *result, *font_desc_string;
@@ -46,7 +47,10 @@ _get_system_font_name (HDC hdc)
  if (!SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0))
    return NULL;

+  hdc = GetDC (NULL);
  logpixelsy = GetDeviceCaps (hdc, LOGPIXELSY);
+  ReleaseDC (NULL, hdc);
+
  font_desc = pango_win32_font_description_from_logfontw (&ncm.lfMessageFont);
  font_desc_string = pango_font_description_to_string (font_desc);
  pango_font_description_free (font_desc);
@@ -188,19 +192,10 @@ _gdk_win32_get_setting (const char *name,
    }
  else if (strcmp ("gtk-font-name", name) == 0)
    {
-      char *font_name = _get_system_font_name (_gdk_display_hdc);
+      char *font_name = _get_system_font_name ();

      if (font_name)
        {
-          /* The pango font fallback list got fixed during 1.43, before that
-           * using anything but "Segoe UI" would lead to a poor glyph coverage */
-          if (pango_version_check (1, 43, 0) != NULL &&
-              g_ascii_strncasecmp (font_name, "Segoe UI", strlen ("Segoe UI")) != 0)
-            {
-              g_free (font_name);
-              return FALSE;
-            }
-
          GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %s\n", name, font_name));
          g_value_take_string (value, font_name);
          return TRUE;
--- a/gdk/win32/gdkscreen-win32.c
+++ b/gdk/win32/gdkscreen-win32.c
@@ -1,114 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 2002 Hans Breuer
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "config.h"
-
-#define _WIN32_WINNT 0x0600
-
-#include "gdk.h"
-#include "gdkprivate-win32.h"
-#include "gdkwin32screen.h"
-#include "gdkdisplayprivate.h"
-#include "gdkdisplay-win32.h"
-#include "gdkmonitor-win32.h"
-
-#include <dwmapi.h>
-
-struct _GdkWin32Screen
-{
-  GObject parent_instance;
-
-  int width, height;
-  int surface_scale;
-};
-
-struct _GdkWin32ScreenClass
-{
-  GObjectClass parent_class;
-};
-
-G_DEFINE_TYPE (GdkWin32Screen, gdk_win32_screen, G_TYPE_OBJECT)
-
-static void
-init_root_window_size (GdkWin32Screen *screen)
-{
-  GdkRectangle result = { 0, };
-  int i;
-  GdkDisplay *display = _gdk_display;
-  GListModel *monitors;
-  GdkMonitor *monitor;
-
-  monitors = gdk_display_get_monitors (display);
-
-  for (i = 1; i < g_list_model_get_n_items (monitors); i++)
-  {
-    GdkRectangle rect;
-
-    monitor = g_list_model_get_item (monitors, i);
-    gdk_monitor_get_geometry (monitor, &rect);
-    gdk_rectangle_union (&result, &rect, &result);
-    g_object_unref (monitor);
-  }
-
-  screen->width = result.width;
-  screen->height = result.height;
-}
-
-static void
-init_root_window (GdkWin32Screen *screen_win32)
-{
-  GdkWin32Display *win32_display;
-
-  init_root_window_size (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,
-                                                                              NULL,
-                                                                              NULL);
-  else
-    screen_win32->surface_scale = 1;
-}
-
-static void
-gdk_win32_screen_init (GdkWin32Screen *win32_screen)
-{
-  _gdk_win32_display_init_monitors (GDK_WIN32_DISPLAY (_gdk_display));
-  init_root_window (win32_screen);
-}
-
-void
-_gdk_win32_screen_on_displaychange_event (GdkWin32Screen *screen)
-{
-  _gdk_win32_display_init_monitors (GDK_WIN32_DISPLAY (_gdk_display));
-  init_root_window_size (screen);
-}
-
-static void
-gdk_win32_screen_finalize (GObject *object)
-{
-  G_OBJECT_CLASS (gdk_win32_screen_parent_class)->finalize (object);
-}
-
-static void
-gdk_win32_screen_class_init (GdkWin32ScreenClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gdk_win32_screen_finalize;
-}
--- a/gdk/win32/gdksurface-win32.c
+++ b/gdk/win32/gdksurface-win32.c
@@ -177,11 +177,6 @@ gdk_surface_win32_finalize (GObject *object)

  surface = GDK_WIN32_SURFACE (object);

-  if (!GDK_SURFACE_DESTROYED (surface))
-    {
-      gdk_win32_handle_table_remove (surface->handle);
-    }
-
  g_clear_pointer (&surface->snap_stash, g_free);
  g_clear_pointer (&surface->snap_stash_int, g_free);

@@ -319,127 +314,6 @@ get_default_title (void)
  return title;
 }

-/* RegisterGdkClass
- *   is a wrapper function for RegisterWindowClassEx.
- *   It creates at least one unique class for every
- *   GdkSurfaceType. If support for single window-specific icons
- *   is ever needed (e.g Dialog specific), every such window should
- *   get its own class
- */
-static ATOM
-RegisterGdkClass (GdkSurfaceType wtype)
-{
-  static ATOM klassTOPLEVEL = 0;
-  static ATOM klassTEMP     = 0;
-  static HICON hAppIcon = NULL;
-  static HICON hAppIconSm = NULL;
-  static WNDCLASSEXW wcl;
-  ATOM klass = 0;
-
-  wcl.cbSize = sizeof (WNDCLASSEX);
-  wcl.style = 0; /* DON'T set CS_<H,V>REDRAW. It causes total redraw
-                  * on WM_SIZE and WM_MOVE. Flicker, Performance!
-                  */
-  wcl.lpfnWndProc = _gdk_win32_surface_procedure;
-  wcl.cbClsExtra = 0;
-  wcl.cbWndExtra = 0;
-  wcl.hInstance = _gdk_dll_hinstance;
-  wcl.hIcon = 0;
-  wcl.hIconSm = 0;
-
-  /* initialize once! */
-  if (0 == hAppIcon && 0 == hAppIconSm)
-    {
-      char sLoc [MAX_PATH+1];
-
-      // try to load first icon of executable program
-      if (0 != GetModuleFileName (NULL, sLoc, MAX_PATH))
-        {
-          ExtractIconEx (sLoc, 0, &hAppIcon, &hAppIconSm, 1);
-
-          if (0 == hAppIcon && 0 == hAppIconSm)
-            {
-              // fallback : load icon from GTK DLL
-              if (0 != GetModuleFileName (_gdk_dll_hinstance, sLoc, MAX_PATH))
-		{
-		  ExtractIconEx (sLoc, 0, &hAppIcon, &hAppIconSm, 1);
-		}
-            }
-        }
-
-      if (0 == hAppIcon && 0 == hAppIconSm)
-        {
-          hAppIcon = LoadImage (NULL, IDI_APPLICATION, IMAGE_ICON,
-                                GetSystemMetrics (SM_CXICON),
-                                GetSystemMetrics (SM_CYICON), 0);
-          hAppIconSm = LoadImage (NULL, IDI_APPLICATION, IMAGE_ICON,
-                                  GetSystemMetrics (SM_CXSMICON),
-                                  GetSystemMetrics (SM_CYSMICON), 0);
-        }
-    }
-
-  if (0 == hAppIcon)
-    hAppIcon = hAppIconSm;
-  else if (0 == hAppIconSm)
-    hAppIconSm = hAppIcon;
-
-  wcl.lpszMenuName = NULL;
-
-  /* initialize once per class */
-  /*
-   * HB: Setting the background brush leads to flicker, because we
-   * don't get asked how to clear the background. This is not what
-   * we want, at least not for input_only windows ...
-   */
-#define ONCE_PER_CLASS() \
-  wcl.hIcon = CopyIcon (hAppIcon); \
-  wcl.hIconSm = CopyIcon (hAppIconSm); \
-  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:
-      if (0 == klassTOPLEVEL)
-        {
-          wcl.lpszClassName = L"gdkSurfaceToplevel";
-
-          ONCE_PER_CLASS ();
-          klassTOPLEVEL = RegisterClassExW (&wcl);
-        }
-      klass = klassTOPLEVEL;
-      break;
-
-    case GDK_SURFACE_TEMP:
-      if (klassTEMP == 0)
-        {
-          wcl.lpszClassName = L"gdkSurfaceTemp";
-          wcl.style |= CS_SAVEBITS;
-          ONCE_PER_CLASS ();
-          klassTEMP = RegisterClassExW (&wcl);
-        }
-
-      klass = klassTEMP;
-
-      break;
-
-    default:
-      g_assert_not_reached ();
-      break;
-    }
-
-  if (klass == 0)
-    {
-      WIN32_API_FAILED ("RegisterClassExW");
-      g_error ("That is a fatal error");
-    }
-  return klass;
-}
-
 /*
 * Create native windows.
 *
@@ -472,12 +346,9 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
  wchar_t *wtitle;
  int window_width, window_height;
  int window_x, window_y;
-  int offset_x = 0, offset_y = 0;
  int real_x = 0, real_y = 0;
  GdkFrameClock *frame_clock;

-  g_return_val_if_fail (display == _gdk_display, NULL);
-
  GDK_NOTE (MISC,
            g_print ("_gdk_surface_new: %s\n", (surface_type == GDK_SURFACE_TOPLEVEL ? "TOPLEVEL" :
                                                       (surface_type == GDK_SURFACE_TEMP ? "TEMP" :
@@ -527,8 +398,7 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
  dwExStyle = 0;
  owner = NULL;

-  offset_x = _gdk_offset_x;
-  offset_y = _gdk_offset_y;
+
  /* MSDN: We need WS_CLIPCHILDREN and WS_CLIPSIBLINGS for GL Context Creation */
  dwStyle = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;

@@ -560,8 +430,8 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,

  AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);

-  real_x = (x - offset_x) * impl->surface_scale;
-  real_y = (y - offset_y) * impl->surface_scale;
+  real_x = x * impl->surface_scale;
+  real_y = y * impl->surface_scale;

  if (surface_type == GDK_SURFACE_TOPLEVEL)
    {
@@ -582,17 +452,25 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
  title = get_default_title ();
  if (!title || !*title)
    title = "";
-
-  /* WS_EX_TRANSPARENT means "try draw this window last, and ignore input".
-   * It's the last part we're after. We don't want DND indicator to accept
-   * input, because that will make it a potential drop target, and if it's
-   * under the mouse cursor, this will kill any DND.
-   */
-
-  klass = RegisterGdkClass (surface_type);
-
  wtitle = g_utf8_to_utf16 (title, -1, NULL, NULL, NULL);

+  switch (surface_type)
+    {
+    case GDK_SURFACE_TOPLEVEL:
+    case GDK_SURFACE_POPUP:
+      klass = display_win32->toplevel_class;
+      break;
+
+    case GDK_SURFACE_TEMP:
+      klass = display_win32->temp_class;
+      break;
+
+    default:
+      g_assert_not_reached ();
+      klass = 0;
+      break;
+    }
+
  hwndNew = CreateWindowExW (dwExStyle,
 			     MAKEINTRESOURCEW (klass),
 			     wtitle,
@@ -603,7 +481,7 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
 			     NULL,
 			     _gdk_dll_hinstance,
 			     surface);
-  impl->handle = hwndNew;
+  g_assert (impl->handle == hwndNew);

  GetWindowRect (hwndNew, &rect);
  impl->initial_x = rect.left;
@@ -619,21 +497,12 @@ _gdk_win32_display_create_surface (GdkDisplay     *display,
    }

  g_object_ref (impl);
-  /* Take note: we're inserting a pointer into a heap-allocated
-   * object (impl). Inserting a pointer to a stack variable
-   * will break the logic, since stack variables are short-lived.
-   * We insert a pointer to the handle instead of the handle itself
-   * probably because we need to hash them differently depending
-   * on the bitness of the OS. That pointer is still unique,
-   * so this works out in the end.
-   */
-  gdk_win32_handle_table_insert (&GDK_SURFACE_HWND (impl), impl);

  GDK_NOTE (MISC, g_print ("... \"%s\" %dx%d@%+d%+d %p = %p\n",
 			   title,
 			   window_width, window_height,
-			   surface->x - offset_x,
-			   surface->y - offset_y,
+			   surface->x,
+			   surface->y,
 			   owner,
 			   hwndNew));

@@ -738,7 +607,6 @@ gdk_win32_surface_destroy_notify (GdkSurface *window)
      _gdk_surface_destroy (window, TRUE);
    }

-  gdk_win32_handle_table_remove (GDK_SURFACE_HWND (window));
  g_object_unref (window);
 }

@@ -865,8 +733,8 @@ show_window_internal (GdkSurface *window,
 	{
 	  GdkSurface *owner = surface->transient_owner;
 	  /* Center on transient parent */
-	  center_on_rect.left = (owner->x - _gdk_offset_x) * surface->surface_scale;
-	  center_on_rect.top = (owner->y - _gdk_offset_y) * surface->surface_scale;
+	  center_on_rect.left = owner->x * surface->surface_scale;
+	  center_on_rect.top = owner->y * surface->surface_scale;
 	  center_on_rect.right = center_on_rect.left + owner->width * surface->surface_scale;
 	  center_on_rect.bottom = center_on_rect.top + owner->height * surface->surface_scale;

@@ -1048,13 +916,13 @@ gdk_win32_surface_do_move (GdkSurface *window,
  GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,0,0,"
                           "NOACTIVATE|NOSIZE|NOZORDER)\n",
                           GDK_SURFACE_HWND (window),
-                           (x - _gdk_offset_x) * impl->surface_scale,
-                           (y - _gdk_offset_y) * impl->surface_scale));
+                           x * impl->surface_scale,
+                           y * impl->surface_scale));

  API_CALL (SetWindowPos, (GDK_SURFACE_HWND (window),
                           SWP_NOZORDER_SPECIFIED,
-                           (x - _gdk_offset_x) * impl->surface_scale,
-                           (y - _gdk_offset_y) * impl->surface_scale,
+                           x * impl->surface_scale,
+                           y * impl->surface_scale,
                           0, 0,
                           SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER));
 }
@@ -1134,15 +1002,15 @@ gdk_win32_surface_do_move_resize (GdkSurface *window,
  GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%ld,%ld,"
                           "NOACTIVATE|NOZORDER)\n",
                           GDK_SURFACE_HWND (window),
-                           (x - _gdk_offset_x) * impl->surface_scale,
-                           (y - _gdk_offset_y) * impl->surface_scale,
+                           x * impl->surface_scale,
+                           y * impl->surface_scale,
                           outer_rect.right - outer_rect.left,
                           outer_rect.bottom - outer_rect.top));

  API_CALL (SetWindowPos, (GDK_SURFACE_HWND (window),
                           SWP_NOZORDER_SPECIFIED,
-                           (x - _gdk_offset_x) * impl->surface_scale,
-                           (y - _gdk_offset_y) * impl->surface_scale,
+                           x * impl->surface_scale,
+                           y * impl->surface_scale,
                           outer_rect.right - outer_rect.left,
                           outer_rect.bottom - outer_rect.top,
                           SWP_NOACTIVATE | SWP_NOZORDER));
@@ -1685,14 +1553,6 @@ gdk_win32_surface_get_geometry (GdkSurface *window,

          rect.right = pt.x;
          rect.bottom = pt.y;
-
-	      if (parent == NULL)
-	        {
-	          rect.left += _gdk_offset_x * impl->surface_scale;
-	          rect.top += _gdk_offset_y * impl->surface_scale;
-	          rect.right += _gdk_offset_x * impl->surface_scale;
-	          rect.bottom += _gdk_offset_y * impl->surface_scale;
-	        }
        }

      if (x)
@@ -1731,16 +1591,16 @@ gdk_win32_surface_get_root_coords (GdkSurface *window,
  ty = pt.y;

  if (root_x)
-    *root_x = (tx + _gdk_offset_x) / impl->surface_scale;
+    *root_x = tx / impl->surface_scale;
  if (root_y)
-    *root_y = (ty + _gdk_offset_y) / impl->surface_scale;
+    *root_y = ty / impl->surface_scale;

  GDK_NOTE (MISC, g_print ("gdk_win32_surface_get_root_coords: %p: %+d%+d %+d%+d\n",
 			   GDK_SURFACE_HWND (window),
 			   x * impl->surface_scale,
 			   y * impl->surface_scale,
-			   (tx + _gdk_offset_x) / impl->surface_scale,
-			   (ty + _gdk_offset_y) / impl->surface_scale));
+			   tx / impl->surface_scale,
+			   ty / impl->surface_scale));
 }

 static gboolean
@@ -2869,8 +2729,8 @@ redraw_indicator (gpointer user_data)

  last_draw = draw_indicator (context, context->draw_timestamp);

-  window_position.x = (context->indicator_window_rect.x - _gdk_offset_x) * impl->surface_scale;
-  window_position.y = (context->indicator_window_rect.y - _gdk_offset_y) * impl->surface_scale;
+  window_position.x = context->indicator_window_rect.x * impl->surface_scale;
+  window_position.y = context->indicator_window_rect.y * impl->surface_scale;
  window_size.cx = context->indicator_window_rect.width * impl->surface_scale;
  window_size.cy = context->indicator_window_rect.height * impl->surface_scale;

@@ -3561,8 +3421,8 @@ setup_drag_move_resize_context (GdkSurface                   *window,
          GDK_NOTE (MISC, g_print ("W32 WM unmaximized window placement is %ld x %ld @ %ld : %ld\n",
                                   placement.rcNormalPosition.right - placement.rcNormalPosition.left,
                                   placement.rcNormalPosition.bottom - placement.rcNormalPosition.top,
-                                   placement.rcNormalPosition.left + _gdk_offset_x * impl->surface_scale,
-                                   placement.rcNormalPosition.top + _gdk_offset_y * impl->surface_scale));
+                                   placement.rcNormalPosition.left,
+                                   placement.rcNormalPosition.top));

          unmax_width = placement.rcNormalPosition.right - placement.rcNormalPosition.left;
          unmax_height = placement.rcNormalPosition.bottom - placement.rcNormalPosition.top;
@@ -3573,40 +3433,38 @@ setup_drag_move_resize_context (GdkSurface                   *window,
          if (offsetx * impl->surface_scale < (shadow_unmax_width / 2) &&
              offsety * impl->surface_scale < (shadow_unmax_height / 2))
            {
-              placement.rcNormalPosition.top = (root_y - offsety + impl->shadow.top - _gdk_offset_y) * impl->surface_scale;
+              placement.rcNormalPosition.top = (root_y - offsety + impl->shadow.top) * impl->surface_scale;
              placement.rcNormalPosition.bottom = placement.rcNormalPosition.top + unmax_height;

              if (left_half)
                {
-                  placement.rcNormalPosition.left = (root_x - offsetx + impl->shadow.left - _gdk_offset_x) * impl->surface_scale;
+                  placement.rcNormalPosition.left = (root_x - offsetx + impl->shadow.left) * impl->surface_scale;
                  placement.rcNormalPosition.right = placement.rcNormalPosition.left + unmax_width;
                }
              else
                {
-                  placement.rcNormalPosition.right = (root_x + offsetx + impl->shadow.right - _gdk_offset_x) * impl->surface_scale;
+                  placement.rcNormalPosition.right = (root_x + offsetx + impl->shadow.right) * impl->surface_scale;
                  placement.rcNormalPosition.left = placement.rcNormalPosition.right - unmax_width;
                }
            }
          else
            {
              placement.rcNormalPosition.left = (root_x * impl->surface_scale) -
-                                                (unmax_width / 2) -
-                                                (_gdk_offset_x * impl->surface_scale);
+                                                (unmax_width / 2);

              if (offsety * impl->surface_scale < shadow_unmax_height / 2)
-                placement.rcNormalPosition.top = (root_y - offsety + impl->shadow.top - _gdk_offset_y) * impl->surface_scale;
+                placement.rcNormalPosition.top = (root_y - offsety + impl->shadow.top) * impl->surface_scale;
              else
                placement.rcNormalPosition.top = (root_y * impl->surface_scale) -
-                                                 (unmax_height / 2) -
-                                                 (_gdk_offset_y * impl->surface_scale);
+                                                 (unmax_height / 2);

              placement.rcNormalPosition.right = placement.rcNormalPosition.left + unmax_width;
              placement.rcNormalPosition.bottom = placement.rcNormalPosition.top + unmax_height;
            }

          GDK_NOTE (MISC, g_print ("Unmaximized window will be at %ld : %ld\n",
-                                   placement.rcNormalPosition.left + _gdk_offset_x * impl->surface_scale,
-                                   placement.rcNormalPosition.top + _gdk_offset_y * impl->surface_scale));
+                                   placement.rcNormalPosition.left,
+                                   placement.rcNormalPosition.top));

          API_CALL (SetWindowPlacement, (GDK_SURFACE_HWND (window), &placement));
        }
@@ -3664,7 +3522,7 @@ setup_drag_move_resize_context (GdkSurface                   *window,
           * the titlebar is, if any.
           */
          root_y = wy + wheight / 2;
-          SetCursorPos (root_x - _gdk_offset_x, root_y - _gdk_offset_y);
+          SetCursorPos (root_x, root_y);
        }
    }

@@ -3786,11 +3644,6 @@ gdk_win32_get_window_size_and_position_from_client_rect (GdkSurface *window,
  _gdk_win32_adjust_client_rect (window, window_rect);

  /* Convert GDK screen coordinates to W32 desktop coordinates */
-  window_rect->left -= _gdk_offset_x * impl->surface_scale;
-  window_rect->right -= _gdk_offset_x * impl->surface_scale;
-  window_rect->top -= _gdk_offset_y * impl->surface_scale;
-  window_rect->bottom -= _gdk_offset_y * impl->surface_scale;
-
  window_position->x = window_rect->left;
  window_position->y = window_rect->top;
  window_size->cx = window_rect->right - window_rect->left;
@@ -4261,13 +4114,41 @@ gdk_win32_surface_focus (GdkSurface *window,
  SetFocus (GDK_SURFACE_HWND (window));
 }

+/* Yay for nobody cleaning up the win32 API.
+   At least there's no documentation for this crap,
+   so there's nothing we can break.*/
+gpointer
+gdk_win32_handle_table_lookup (HWND handle)
+{
+  return NULL;
+}
+
+/**
+ * gdk_win32_surface_lookup_for_display:
+ * @display: A display
+ * @hwnd: A HWND maybe belonging to a `GdkSurface`
+ * 
+ * Looks up the `GdkSurface` that created the given @hwnd.
+ * 
+ * Returns: (transfer none) (nullable) (type GdkWin32Surface):
+ *   The surface belonging to @hwnd or %NULL
+ */
 GdkSurface *
 gdk_win32_surface_lookup_for_display (GdkDisplay *display,
-                                     HWND        anid)
+                                      HWND        anid)
 {
-  g_return_val_if_fail (display == gdk_display_get_default (), NULL);
+  GdkWin32Display *self;
+  ATOM class;

-  return (GdkSurface*) gdk_win32_handle_table_lookup (anid);
+  g_return_val_if_fail (GDK_IS_WIN32_DISPLAY (display), NULL);
+
+  self = GDK_WIN32_DISPLAY (display);
+
+  class = GetWindowLong (anid, GCW_ATOM);
+  if (class != self->toplevel_class && class != self->temp_class)
+    return NULL;
+
+  return GDK_SURFACE (GetWindowLongPtr (anid, GWLP_USERDATA));
 }

 gboolean
@@ -5090,12 +4971,6 @@ gdk_win32_surface_get_queued_window_rect (GdkSurface *surface,
  /* Turn client area into window area */
  _gdk_win32_adjust_client_rect (surface, &window_rect);

-  /* Convert GDK screen coordinates to W32 desktop coordinates */
-  window_rect.left -= _gdk_offset_x * impl->surface_scale;
-  window_rect.right -= _gdk_offset_x * impl->surface_scale;
-  window_rect.top -= _gdk_offset_y * impl->surface_scale;
-  window_rect.bottom -= _gdk_offset_y * impl->surface_scale;
-
  *return_window_rect = window_rect;
 }

--- a/gdk/win32/gdkwin32dnd-private.h
+++ b/gdk/win32/gdkwin32dnd-private.h
@@ -43,9 +43,6 @@ struct _GdkWin32Drag
 {
  GdkDrag drag;

-  /* The drag protocol being used */
-  GdkDragProtocol  protocol;
-
  /* The surface used for grabs.
   * Usually the same as GdkDrag->source_surface
   */
@@ -95,38 +92,6 @@ gpointer _gdk_win32_dnd_thread_main                      (gpointer         data)
 GdkDrag *_gdk_win32_find_drag_for_dest_window     (HWND             dest_window);
 GdkDrop  *_gdk_win32_get_drop_for_dest_surface     (GdkSurface      *dest);

-gboolean _gdk_win32_local_drop_target_will_emit_motion   (GdkDrop *drop,
-                                                          int      x_root,
-                                                          int      y_root,
-                                                          DWORD    grfKeyState);
-
-void     _gdk_win32_local_drop_target_dragenter          (GdkDrag        *drag,
-                                                          GdkSurface     *dest_surface,
-                                                          int             x_root,
-                                                          int             y_root,
-                                                          DWORD           grfKeyState,
-                                                          guint32         time_,
-                                                          GdkDragAction  *actions);
-void     _gdk_win32_local_drop_target_dragover           (GdkDrop        *drop,
-                                                          GdkDrag        *drag,
-                                                          int             x_root,
-                                                          int             y_root,
-                                                          DWORD           grfKeyState,
-                                                          guint32         time_,
-                                                          GdkDragAction  *actions);
-void     _gdk_win32_local_drop_target_dragleave          (GdkDrop        *drop,
-                                                          guint32         time_);
-void     _gdk_win32_local_drop_target_drop               (GdkDrop        *drop,
-                                                          GdkDrag        *drag,
-                                                          guint32         time_,
-                                                          GdkDragAction  *actions);
-
-void     _gdk_win32_local_drag_give_feedback             (GdkDrag        *drag,
-                                                          GdkDragAction   actions);
-void     _gdk_win32_local_drag_drop_response             (GdkDrag        *drag,
-                                                          GdkDragAction   action);
-
-
 G_END_DECLS

 #endif /* __GDK_WIN32_DND_PRIVATE_H__ */
--- a/gdk/win32/gdkwin32id.c
+++ b/gdk/win32/gdkwin32id.c
@@ -1,81 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
- * file for a list of people on the GTK+ Team.  See the ChangeLog
- * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
- */
-
-#include "config.h"
-#include <gdk/gdk.h>
-
-#include "gdkprivate-win32.h"
-
-static GHashTable *handle_ht = NULL;
-
-static guint
-gdk_handle_hash (HANDLE *handle)
-{
-#ifdef _WIN64
-  return ((guint *) handle)[0] ^ ((guint *) handle)[1];
-#else
-  return (guint) *handle;
-#endif
-}
-
-static int
-gdk_handle_equal (HANDLE *a,
-		  HANDLE *b)
-{
-  return (*a == *b);
-}
-
-void
-gdk_win32_handle_table_insert (HANDLE  *handle,
-			       gpointer data)
-{
-  g_return_if_fail (handle != NULL);
-
-  if (!handle_ht)
-    handle_ht = g_hash_table_new ((GHashFunc) gdk_handle_hash,
-				  (GEqualFunc) gdk_handle_equal);
-
-  g_hash_table_insert (handle_ht, handle, data);
-}
-
-void
-gdk_win32_handle_table_remove (HANDLE handle)
-{
-  if (!handle_ht)
-    handle_ht = g_hash_table_new ((GHashFunc) gdk_handle_hash,
-				  (GEqualFunc) gdk_handle_equal);
-
-  g_hash_table_remove (handle_ht, &handle);
-}
-
-gpointer
-gdk_win32_handle_table_lookup (HWND handle)
-{
-  gpointer data = NULL;
-
-  if (handle_ht)
-    data = g_hash_table_lookup (handle_ht, &handle);
-
-  return data;
-}
--- a/gdk/win32/gdkwin32misc.h
+++ b/gdk/win32/gdkwin32misc.h
@@ -69,21 +69,21 @@ G_BEGIN_DECLS
 #endif

 /* Return true if the GdkSurface is a win32 implemented window */
-GDK_AVAILABLE_IN_ALL
+GDK_DEPRECATED_IN_4_4_FOR (GDK_IS_WIN32_SURFACE)
 gboolean      gdk_win32_surface_is_win32 (GdkSurface *window);
-GDK_AVAILABLE_IN_ALL
-HWND          gdk_win32_surface_get_impl_hwnd (GdkSurface *window);
+GDK_DEPRECATED_IN_4_4_FOR (gdk_win32_surface_get_handle)
+HWND gdk_win32_surface_get_impl_hwnd (GdkSurface *window);

 /* Return the Gdk* for a particular HANDLE */
-GDK_AVAILABLE_IN_ALL
+GDK_DEPRECATED_IN_4_4
 gpointer      gdk_win32_handle_table_lookup (HWND handle);
 /* Translate from window to Windows handle */
 GDK_AVAILABLE_IN_ALL
 HGDIOBJ       gdk_win32_surface_get_handle (GdkSurface *window);

-GDK_AVAILABLE_IN_ALL
-GdkSurface *   gdk_win32_surface_lookup_for_display (GdkDisplay *display,
-                                                     HWND        anid);
+GDK_DEPRECATED_IN_4_4
+GdkSurface *  gdk_win32_surface_lookup_for_display (GdkDisplay *display,
+                                                    HWND        anid);

 #if defined (INSIDE_GDK_WIN32) || defined (GTK_COMPILATION) || defined (GTK_COMPILATION)

--- a/gdk/win32/meson.build
+++ b/gdk/win32/meson.build
@@ -21,11 +21,9 @@ gdk_win32_sources = files([
  'gdkmain-win32.c',
  'gdkmonitor-win32.c',
  'gdkproperty-win32.c',
-  'gdkscreen-win32.c',
  'gdkvulkancontext-win32.c',
  'gdkwin32cursor.h',
  'gdkwin32display.h',
-  'gdkwin32id.c',
  'gdksurface-win32.c',
 ])

--- a/gdk/x11/gdkdrag-x11.c
+++ b/gdk/x11/gdkdrag-x11.c
@@ -1281,19 +1281,10 @@ _gdk_x11_display_get_drag_protocol (GdkDisplay      *display,
  surface = gdk_x11_surface_lookup_for_display (display, xid);
  if (surface)
    {
-      if (g_object_get_data (G_OBJECT (surface), "gdk-dnd-registered") != NULL)
-        {
-          *protocol = GDK_DRAG_PROTO_XDND;
-          *version = 5;
-          GDK_DISPLAY_NOTE (display, DND, g_message ("Entering local Xdnd window %#x\n", (guint) xid));
-          return xid;
-        }
-      else if (_gdk_x11_display_is_root_window (display, xid))
-        {
-          *protocol = GDK_DRAG_PROTO_ROOTWIN;
-          GDK_DISPLAY_NOTE (display, DND, g_message ("Entering root window\n"));
-          return xid;
-        }
+      *protocol = GDK_DRAG_PROTO_XDND;
+      *version = 5;
+      GDK_DISPLAY_NOTE (display, DND, g_message ("Entering local Xdnd window %#x\n", (guint) xid));
+      return xid;
    }
  else if ((retval = xdnd_check_dest (display, xid, version)))
    {
@@ -1573,11 +1564,6 @@ _gdk_x11_surface_register_dnd (GdkSurface *surface)

  g_return_if_fail (surface != NULL);

-  if (g_object_get_data (G_OBJECT (surface), "gdk-dnd-registered") != NULL)
-    return;
-  else
-    g_object_set_data (G_OBJECT (surface), "gdk-dnd-registered", GINT_TO_POINTER (TRUE));
-
  /* Set XdndAware */

  /* The property needs to be of type XA_ATOM, not XA_INTEGER. Blech */
--- a/gsk/gl/gskglrenderer.c
+++ b/gsk/gl/gskglrenderer.c
@@ -4289,9 +4289,6 @@ gsk_gl_renderer_do_render (GskRenderer           *renderer,
  gsk_gl_renderer_setup_render_mode (self);
  gsk_gl_renderer_clear (self);

-  glEnable (GL_DEPTH_TEST);
-  glDepthFunc (GL_LEQUAL);
-
  /* Pre-multiplied alpha! */
  glEnable (GL_BLEND);
  glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
--- a/gsk/ngl/gsknglcommandqueue.c
+++ b/gsk/ngl/gsknglcommandqueue.c
@@ -978,9 +978,6 @@ gsk_ngl_command_queue_execute (GskNglCommandQueue   *self,
  gsk_profiler_timer_begin (self->profiler, self->metrics.cpu_time);
 #endif

-  glEnable (GL_DEPTH_TEST);
-  glDepthFunc (GL_LEQUAL);
-
  /* Pre-multiplied alpha */
  glEnable (GL_BLEND);
  glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
Author	SHA1	Message	Date
Benjamin Otte	c1f1a1a623	win32: Use GWL_USERDATA instead of a global hash table We can delete a whole source file again! Also deprecate a bunch of stupid and dangerous APIs that shouldn't have made it to 4.0, but who's gonna review the Windows backend, amirite?	2021-07-31 05:50:14 +02:00
Benjamin Otte	0d6becdb67	win32: Store the window classes in the display This way, they are per-display and not hidden in some global variable somewhere, which also allows checking if a HWND belongs to a display.	2021-07-31 05:50:14 +02:00
Benjamin Otte	6b760b5d37	win32: Remove local dnd We use "real" OLE2 DND exclusively now.	2021-07-31 05:50:14 +02:00
Benjamin Otte	98424bd90c	win32: Remove _gdk_offset_x and _gdk_offset_y GTK can deal with negative coordinates just fine these days, so keeping offsets is not necessary and massively simplifies things.	2021-07-31 05:50:14 +02:00
Benjamin Otte	efbad0baa0	ngl: Turn off depth test Usually, the GdkGLContext will have the depth buffer disabled, so the depth test will not work. However, if the GDK backend does not provide a config without depth buffer, there will be one. And if we enable it, it'll do the wrong thing. For example, it'll paint the wrong thing in the cube flip animation of GtkStack (like on widget-factory page 2).	2021-07-31 05:50:14 +02:00
Benjamin Otte	020dbb7b4c	win32: Remove unused code	2021-07-31 03:55:07 +02:00
Benjamin Otte	6b3e0bf94d	x11: Remove unused code We register all our surfaces for DND, so no need to check anymore. Also, the root window has no attached GdkSurface.	2021-07-31 03:55:07 +02:00
Benjamin Otte	7ee42d1970	win32: Make prints reach the console GUI apps on Windows don't have a console and console apps open a command prompt when not launched from a terminal. This code keeps the app as a GUI app not opening a command prompt but tries to reattach to the parent, so that stdout and stderr reach it.	2021-07-31 03:55:06 +02:00
Benjamin Otte	8113a7a931	win32: Remove unused values	2021-07-31 03:55:06 +02:00
Benjamin Otte	04ff87143f	win32: Remove special casing for pixbuf formats That's the job of the generic code, not the Windows backend.	2021-07-31 03:55:06 +02:00
Benjamin Otte	6b2ee0f5a5	win32: Remove usage of gdk_display_get_default()	2021-07-31 03:55:06 +02:00
Benjamin Otte	129fea4157	win32: Use the right display in event handling ... instead of just using gdk_display_get_default().	2021-07-31 03:55:06 +02:00
Benjamin Otte	7fc6c2ece7	win32: Clean up keymap code 1. Store the keymap in the display 2. Don't pretend that a different keymap might be passed 3. Remove static global default_keymap variable	2021-07-31 03:44:59 +02:00
Benjamin Otte	8b7345c6a0	win32: Remove _gdk_display global All functions have the display available, so no need for the global. Only gdk_win32_display_open() needs the global for now, because it doesn't support opening multiple displays yet.	2021-07-31 03:44:59 +02:00
Benjamin Otte	8a9a4537b0	win32: Store device manager in the display One global variable less.	2021-07-31 00:11:23 +02:00
Benjamin Otte	2fd52cae26	win32: Remove global _gdk_display_hdc Bunch of unused code in there.	2021-07-31 00:11:23 +02:00
Benjamin Otte	e158b64f24	win32: Remove Pango workaround The workaround was only necessary for Pango < 1.43.	2021-07-31 00:11:23 +02:00
Benjamin Otte	19da0ab865	win32: Remove gdkscreen-win32.c It's been entirely unused fora while.	2021-07-31 00:11:23 +02:00
Benjamin Otte	b09f40ed29	display-win32: Improve display change code 1. Clarify that we use display->hwnd for GL. 2. Pass the display using SetWindowLongPtr()	2021-07-31 00:11:23 +02:00